This document outlines the architecture and implementation of a Hybrid Smart Contract built to securely fetch off-chain financial data. The project demonstrates how to bridge the determinisitic environment of a blockchain with real-world data using Chainlink Decentralized Oracle Networks (DONs) utilizing Solidity for the on-chain logic and Rust for the off-chain high performance client

Context: The Blockchain Oracle Problem

Blockchains, by design, are deterministic and isolated networks. A smart contract cannot natively execute an HTTP request to fetch an API endpoint (like weather API or cryptocurrency exchange). If it did, different nodes would getr different data at different times, breaking the network consesus.

This is known as the Oracle Problem. To build functional DeFi applications, we need an oracle. However, using a single centralized oracle introduces a single point of failure. The industry-standard solution is utilizing a Decentralized Oracle Network (DON) like Chainlink, which aggregates and validates data off-chain before securely delivering it on-chain. This creates a Hybrid Smart Contract.

System Architecture

The project is divided into two main components:

1. On-Chain (Solidity): A smart contract deployed on the blockchain that acts as a consumer interface to read the validated data from the Chainlink Aggregator.

2. Off-Chain (Rust): A robust client leveraging the alloy framework to interact asynchronously with the blockchain via an RPC node, retrieving and formatting the data in a memory-safe environment.

1. The On-Chain Component (Solidity)

The PriceConsumer contract is designed to be highly gas-efficient. It reads the ETH/USD price feed from the Sepolia Testnet. By utilizing the AggregatorV3Interface it safely retrives the latest validated round of data

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";

contract PriceConsumer {
	AggregatorV3Interface internal dataFeed;

	constructor(){
		// ETH/USD price feed address on Sepolia
		dataFeed = AggregatorV3Interface(
			0x694AA1769357215DE4FAC081bf1f309aDC325306
        );
	}

	function getLatestPrice() public view returns(int){
	// Fetching the price, explicitly ignoring unused variables to save gas
		(,int price,,,) = dataFeed.LatestRoundData();
		return price;
    }

2. The Off-Chain Client (Rust)

While standard Web3 tutorials rely heavily on JavaScript/TypeScript, I chose Rust for the off-chain client. Rust provides unmatched memory safety, strict typing, and high performance, which are critical traits for production-grade financial infrastructure.

The client utilizes:

• Alloy: the modern standart for Ethereum interaction in Rust (replacing ethers-rs), providinf the sol! macro to easily generate Rust bidings from Solidity interfaces.

• Tokio: For asynchronous runtime.

• Dotenv: For secure environment variable management (RPC URLs).

use std::{env, str::FromStr};
use alloy::{
    primitives::Address,
    providers::ProviderBuilder,
    sol,
};
use dotenv::dotenv;
use eyre::Result;

// Generating Rust bindings directly from the Solidity interface
sol! {
    #[sol(rpc)]
    interface PriceConsumer {
        function getLatestPrice() external view returns (int256 price);
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    // Securely loading configuration
    let rpc_url = env::var("RPC_URL")?.parse()?;
    let contract_address = env::var("CONTRACT_ADDRESS")?.parse()?;

    // Initializing the Alloy provider
    let provider = ProviderBuilder::new().on_http(rpc_url);
    let contract = PriceConsumer::new(contract_address, provider);

    // Asynchronously fetching the on-chain data
    let price_raw = contract.getLatestPrice().call().await?;

    // Formatting the price (Chainlink USD feeds have 8 decimals)
    let price_formatted = price_raw.price.to_string().parse::<f64>()? / 100_000_000.0;

    println!("-----------------------------------------------------------------------");
    println!("Connection established");
    println!("Current ETH/USD Price validated by Chainlink DON: ${:.2}", price_formatted);
    println!("-----------------------------------------------------------------------");
    
    Ok(())
}

Conclusion

Building this project solidified the fundamental architecture of modern Web3 applications.

1. Bridging the Gap: I sucessfully established a secure pipeline between an isolated smart contract and a high-performance extrenal envirement.

2. Rust in Web3: Leveraging alloy and its sol! macro heavily streamlined the RPC communication process. It demonstrated why systems-level languages are becoming the standard for robust Web3 backend infrastructure.

3. Decentralization in Practice: Understanding that the integrity of a smart contract is only as strong as the data it consumes. Chainlink's architecture guarantees that the deterministic nature of the blockchain is not compromised by a single point of failure in the real world.

You can also visit my code on GitHub:

GitHub - JosueGabrielNavarro/hybrid-oracle-client

Contribute to JosueGabrielNavarro/hybrid-oracle-client development by creating an account on GitHub.

https://github.com

History: Who is Évariste Galois

Paris, May 1832. A 20-year-old mathematician, Évariste Galois, stares down the barrel of a literal sunrise. A messy romance has led him to a challenge: a pistol duel scheduled for the following morning. He was convinced he would not survive that encounter, so Galois spent his last night, his last hours, scribbling his mathematical legacy by candlelight as he recorded his legacy in revolutionary concepts like Group Theory and the algebraic structure known as Galois Fields. The next morning, a single bullet ended his life, but his midnight notes would not be forgotten.

Now, 200 years later, the legacy of those midnight notes is still alive. The math recorded that fateful night is the foundation of Zero Knowledge Proofs, zk-SNARKs, Ethereum cryptography, and Web3.

The heart of modern digital privacy now lies in Galois Fields and Finite Fields, unique sets of finite numbers in which basic operations like addition, subtraction, multiplication, and division are well-defined.

Instead of using computational power on checking solutions with standard decimal numbers that can grow infinitely large, we can perform calculations over a finite field, typically using a prime number as a "limit" for the math (arithmetic modulo p). Every interaction with Ethereum cryptography occurs within a field of prime order that obeys the laws Galois discovered that final night in 1832.

The Clock Analogy & Why Computers Lie

The Visual Trap: The Infinite Ruler

Standard programming operates on an infinite ruler. If a calculation—like a financial transaction or a complex simulation—stretches beyond the computer's physical memory, the ruler can snap. For math to be perfectly secure, it must function like a Clock Face.

In a Finite Field, we just throw away the infinite ruler and replace it with a circle containing exactly $$p$$ elements, where $$p$$ is a massive prime number.

Like in a clock, we don't have negative numbers or decimals. For example, instead of going backward into negative numbers, we just walk around the clock, and we are either at one point or the next, ensuring total precision.

The Mathematical Magic: Division via Fermat

Now, in a circular world, we also face some challenges, the most common one being division. Traditional division in a circular world is impossible because it creates decimals, for example:

$$1 \div 3 = 0.333...$$

So, how can we solve this problem in our circular world?

Here's where we begin using Fermat's Little Theorem. Division does not really exist; it is just multiplication in the inverse, so instead of dividing a number, we find a number's Multiplicative Inverse.

Think about it, instead of "cutting a cake into pieces," we find a secret partner, a value that, when we multiply it by the original, wraps the clock hand exactly back to 1. To find this partner instantly, cryptographers use Fermat's Little Theorem:

$$a^{p-1} \equiv 1 \pmod p$$

PoW: The Application.

Now theory is great, but in the world of cryptography, code is truth. To make me truly understand the "circular universe," I built a small Galois Field Calculator in Python from scratch

My goal was to move beyond the linear math to the logic used in Ethereum's Arithmetic Circuits.

Here is the implementation of the core operations:

# Addition (Wrap around a clock)
def finiteAdd(a: int, b: int, p: int) -> int:
    """
    Addition Calculator in a Galois Field
    Enter the numbers (a,b) and set up the field (p) 
    """
    assert a < p, 'Number exceed the field'
    assert b < p, 'Number exceed the field'
    return (a + b) % p

# Subtraction (Go backward around the clock)
def finiteSub(a: int, b: int, p: int) -> int:
    """
    Substraction Calculator in a Galois Field
    Enter the numbers (a,b) and set up the field (p)
    """
    assert a < p, 'Number exceed the field'
    assert b < p, 'Number exceed the field'
    return (a - b) % p

# Multiplication (Spin the clock super fast)
def finiteMul(a: int, b: int, p: int) -> int:
    """
    Multiplication Calculator in a Galois Field
    Enter the numbers (a,b) and set up the field (p)
    """
    assert a < p, 'Number exceed the field'
    assert b < p, 'Number exceed the field'
    return (a * b) % p

# Division (Find the inverse, then multiply)
def finiteDiv(a: int, b: int, p: int) -> int:
    """
    Division Calculator in a Galois Field
    Enter the numbers (a,b) and set up the field (p)
    """
    assert a < p, 'Number exceed the field'
    assert b < p, 'Number exceed the field'
    assert b != 0, 'We cannot divide by zero'
    inv = pow(b, p - 2, p) # Fermat's Little Theorem
    return (a * inv) % p

The Conclusion: The Journey

I am a 19-year-old rewiring my brain. My mission is more than just learning to code; it is a deliberate exercise in neuroplasticity, physically reconfiguring my neural connections to grasp the high-abstraction mathematics required for modern cryptography. Just as Galois spent his final hours ensuring his theories were recorded for the future, I am dedicated to mastering the logic that secures our digital world.

Next time, I am tackling Merkle Trees and Arithmetization. You can find the source code for this Galois Field calculator and follow my progress as I build out the full stack of ZK primitives here:

• GitHub Repository: https://github.com/JosueGabrielNavarro/ZK-Primitives-Python

• X Profile: https://x.com/JosueNavar83869

• Farcaster Profile: https://farcaster.xyz/jossh