Pull Model

The Pull-Based Oracle is ideal for latency-sensitive use cases where developers want control over when and how data is retrieved and fed into smart contracts.

How It Works

In this model, developers:

1. Fetch data from Block Scholes off-chain via WebSocket or REST APIs.

2. Relay this data into any smart contract of choice.

3. Verify its authenticity using EIP-712 signatures.

Verification via EIP-712

To ensure that the data originates from Block Scholes and is not tampered with, every data payload is signed using EIP-712. Developers must implement signature verification logic in their contracts to check the integrity of this data.

An open-source example for verifying strike.iv feeds is available here

You can adapt this verification flow for other feed types by changing the structs and type hashes accordingly.

---

Feed-Specific Structs and Type Hashes

Below are the Solidity structs and EIP-712 type hashes for each supported feed. Replace the definitions in the example repo accordingly.

---

1. Interest rate

Interest rate term structure for given currency

Structs

struct Values {
    string sid;
    int256 v;
}

struct Data {
    Values[] values;
    int256 timestamp;
}

Type Hashes

bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant VALUES_TYPEHASH = keccak256("Values(string sid,int256 v)");
bytes32 constant DATA_TYPEHASH = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,int256 v)");

2. Mark price

Mark price for any option strike for a given expiry.

Structs and Type Hashes

struct Data {
    Values[] values;
    int256 timestamp;
}


// ---------------------
// 📦 Format A: Moneyness
// ---------------------
struct Values {
    string sid;
    uint256[] v;
    uint256[] moneyness;
}

bytes32 constant VALUES_TYPEHASH_A = keccak256("Values(string sid,uint256[] v,uint256[] moneyness)");
bytes32 constant DATA_TYPEHASH_A = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,uint256[] v,uint256[] moneyness)");


// ---------------------
// 📦 Format B: Strike
// ---------------------
struct Values {
    string sid;
    uint256[] v;
    uint256[] strike;
}

bytes32 constant VALUES_TYPEHASH_B = keccak256("Values(string sid,uint256[] v,uint256[] strike)");
bytes32 constant DATA_TYPEHASH_B = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,uint256[] v,uint256[] strike)");


// ---------------------
// 📦 Format C: Delta
// ---------------------
struct Values {
    string sid;
    uint256[] v;
    int256[] delta;
}

bytes32 constant VALUES_TYPEHASH_C = keccak256("Values(string sid,uint256[] v,int256[] delta)");
bytes32 constant DATA_TYPEHASH_C = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,uint256[] v,int256[] delta)");


// 📌 Common to all
bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

Additional optional fields may be included to represent first-order Greeks in value structs

int256[] delta;
int256[] vega;
int256[] theta;
int256[] rho;
int256[] phi;

// Example
struct Values {
    string sid;
    int256[] v;
    int256[] moneyness;
    // Optional Greek
    int256[] delta;
}

bytes32 constant VALUES_TYPEHASH_A = keccak256("Values(string sid,int256[] v,int256[] moneyness,int256[] delta)");
bytes32 constant DATA_TYPEHASH_A = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,int256[] v,int256[] moneyness,int256[] delta)");

Future mark price

When querying futures mark prices, the structure is simplified. Instead of returning arrays or multiple buckets, the response contains only a single value per sid.

Structs

struct Values {
    string sid;
    int256 v;
}

struct Data {
    Values[] values;
    int256 timestamp;
}

Type Hashes

bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant VALUES_TYPEHASH = keccak256("Values(string sid,int256 v)");
bytes32 constant DATA_TYPEHASH = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,int256 v)");

3. Model params

Calibrated SVI model parameters defining the implied volatility smile for a specific expiry.

Structs

struct Values {
    string sid;
    int256 alpha;
    int256 beta;
    int256 rho;
    int256 m;
    int256 sigma;
}

struct Data {
    Values[] values;
    int256 timestamp;
}

Type Hashes

bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant VALUES_TYPEHASH = keccak256("Values(string sid,int256 alpha,int256 beta,int256 rho,int256 m,int256 sigma)");
bytes32 constant DATA_TYPEHASH = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,int256 alpha,int256 beta,int256 rho,int256 m,int256 sigma)");

4. Settlement and Index Price

Settlement Price: Time-weighted average of the spot index price at a specified expiry. Designed for robust and manipulation-resistant settlement of derivatives contracts (including futures and options).

Index Price: Block Scholes index price for the given asset.

Structs

int256 spread;

struct Values {
    string sid;
    uint256 v;
    // Optional Spread
    int256 spread;
}

struct Data {
    Values[] values;
    int256 timestamp;
}

Type Hashes

bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant VALUES_TYPEHASH = bytes32 constant VALUES_TYPEHASH = keccak256("Values(string sid,uint256 v)");
bytes32 constant DATA_TYPEHASH = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,uint256 v)");

5. Implied Volatility Surface (IV)

IV datapoints are supported in different formats:

• Strike-based IV — Implied volatilities at different strikes

• Moneyness-based IV — Implied volatilities at different forward-moneyness levels

• Delta-based IV — Implied volatilities at different delta levels

• IV Index (BSIV) - Weighted expectation of IV across all strikes on the smile

Strike, Moneyness & Delta types follow the same struct and EIP-712 signature pattern — only the bucket field name changes depending on the dimension used.

Solidity structs

struct Values {
    string sid;
    int256[] bucket; // This can be strike, moneyness, or delta
    int256[] v;      // Corresponding implied volatilities
}

struct Data {
    Values[] values;
    int256 timestamp;
}

// Example for strike-based IV
struct Values {
    string sid;
    int256[] strike;
    int256[] v;      
}

Type Hashes

For generic usage:

bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant TYPE_HASH_VALUES = keccak256("Values(string sid,int256[] bucket,int256[] v)");
bytes32 constant TYPE_HASH_DATA = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,int256[] bucket,int256[] v)");

For concrete implementations, replace bucket with the actual field:

Example: Strike-based IV

bytes32 constant TYPE_HASH_VALUES = keccak256("Values(string sid,int256[] strike,int256[] v)");
bytes32 constant TYPE_HASH_DATA = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,int256[] strike,int256[] v)");

Index IV

struct Values {
    string sid;
    uint256 v;
}

struct Data {
    Values[] values;
    int256 timestamp;
}

Type hashes

bytes32 constant TYPE_HASH_DOMAIN = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant VALUES_TYPEHASH = keccak256("Values(string sid,uint256 v)");
bytes32 constant DATA_TYPEHASH = keccak256("Data(Values[] values,int256 timestamp)Values(string sid,uint256 v)");