# Pull Model

## How It Works

In this model, developers:

1. **Fetch** data from Block Scholes off-chain via [**WebSocket**](https://block-scholes.gitbook.io/block-scholes/data-access/websocket-api) or [**REST**](https://block-scholes.gitbook.io/block-scholes/data-access/rest-api) 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](https://github.com/blockscholes/IvCheckVerifier/blob/main/src/IvCheckVerifier.sol)

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](https://github.com/blockscholes/IvCheckVerifier) accordingly.

***

### 1. Interest rate

Interest rate term structure for given currency

**Structs**

```solidity
struct Values {
    string sid;
    int256 v;
}

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

**Type Hashes**

```solidity
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**

```solidity
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

```solidity
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**

```solidity
struct Values {
    string sid;
    int256 v;
}

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

Type Hashes

```solidity
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**

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

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


```

**Type Hashes**

```solidity
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**

```solidity
int256 spread;

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

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

**Type Hashes**

```solidity
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**

```solidity
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:

```solidity
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**

```solidity
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

```solidity
struct Values {
    string sid;
    uint256 v;
}

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

Type hashes

```solidity
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)");

```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.blockscholes.com/blockchain-oracle/pull-based-oracle.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.