> ## Documentation Index
> Fetch the complete documentation index at: https://docs.layerzero.network/llms.txt
> Use this file to discover all available pages before exploring further.

# Supported Data Types

> LayerZero Read currently supports a variety of data types for reading external state via `calldata` from `EVMCallRequestV1`. The following types of...

LayerZero Read currently supports a variety of data types for reading external state via `calldata` from `EVMCallRequestV1`. The following types of `calldata` methods are supported:

1. **Public State Variables**: Direct access to `public` state variables on target contracts.

2. **View or Pure Functions**: Functions that do not modify the blockchain state and only return data.

3. **Non-View or Pure Functions Returning Data**: Functions that are not marked as `view` or `pure`, but do not alter the onchain state and only return data.

These supported data types enable developers to fetch and utilize external state data efficiently without incurring unnecessary gas costs or affecting the target blockchain's state.

## Function Types

See the simple data type examples below for reference on how to implement `EVMCallRequestV1` in your `OAppRead` application.

### State Variables

Public state variables in Solidity automatically generate `getter` functions, making them easily accessible for read operations. LayerZero Read can directly interact with these `getter` functions to retrieve the current state:

```solidity wrap theme={null}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title ExampleContract
 * @notice A simple contract with a public state variable.
 */
contract ExampleContract {
    // a public data variable on the target data chain to read from
    uint256 public data;

    constructor(uint256 _data) {
        data = _data;
    }
}
```

To read the data variable using `lzRead`, you can encode the getter function call as follows:

```solidity wrap theme={null}
bytes memory callData = abi.encodeWithSelector(ExampleContract.data.selector);

readRequests[i] = EVMCallRequestV1({
    appRequestLabel: uint16(i + 1), // arbitrary request label, for OApp filtering purposes
    targetEid: targetEid,
    isBlockNum: false,
    blockNumOrTimestamp: uint64(block.timestamp),
    confirmations: 15, // Example set block confirmations to wait to 15 blocks
    to: 0x1234567890123456789012345678901234567890, // Dummy address where ExampleContract is deployed
    callData: callData
});
```

### View or Pure Functions

`view` and `pure` functions are ideal for read operations as they do not modify the blockchain state. LayerZero Read can seamlessly interact with these functions to retrieve necessary data.

```solidity wrap theme={null}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title MathContract
 * @notice A contract with a pure function for mathematical operations.
 */
contract MathContract {
    /**
     * @notice Adds two numbers.
     * @param a First number.
     * @param b Second number.
     * @return sum The sum of a and b.
     */
    function add(uint256 a, uint256 b) external pure returns (uint256 sum) {
        return a + b;
    }
}
```

To read the result of the `add` function using `lzRead`:

```solidity wrap theme={null}
bytes memory callData = abi.encodeWithSelector(MathContract.add.selector, 5, 10);

readRequests[i] = EVMCallRequestV1({
    appRequestLabel: uint16(i + 1),
    targetEid: targetEid,
    isBlockNum: false,
    blockNumOrTimestamp: uint64(block.timestamp),
    confirmations: 15, // Set to 15 blocks
    to: 0x1234567890123456789012345678901234567890, // Dummy contract address
    callData: callData
});
```

## Non-View or Pure Functions Returning Data

Some functions are not marked as `view` or `pure`, but still do not modify the onchain state. These functions can also be utilized with `lzRead` as long as they only return data without performing state changes.

For example, Uniswap V3's `IQuoterV2` relies on calling non-view functions and reverting to compute the result. This is not gas efficient and should not be called onchain, making `lzRead` a great option for retrieving the state:

```solidity wrap theme={null}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @title QuoterV2 Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps.
/// @notice For each pool also tells you the number of initialized ticks crossed and the sqrt price of the pool after the swap.
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called onchain.
interface IQuoterV2 {

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param params The params for the quote, encoded as `QuoteExactInputSingleParams`
    /// tokenIn The token being swapped in
    /// tokenOut The token being swapped out
    /// fee The fee of the token pool to consider for the pair
    /// amountIn The desired input amount
    /// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    /// @return sqrtPriceX96After The sqrt price of the pool after the swap
    /// @return initializedTicksCrossed The number of initialized ticks that the swap crossed
    /// @return gasEstimate The estimate of the gas that the swap consumes
    function quoteExactInputSingle(QuoteExactInputSingleParams memory params)
        external
        returns (
            uint256 amountOut,
            uint160 sqrtPriceX96After,
            uint32 initializedTicksCrossed,
            uint256 gasEstimate
        );
}
```

To read a quote for an `amountOut` for a specific token pair function using `lzRead`:

```solidity wrap theme={null}
// Define the QuoteExactInputSingleParams
IQuoterV2.QuoteExactInputSingleParams memory params = IQuoterV2.QuoteExactInputSingleParams({
    tokenIn: config.tokenInAddress,
    tokenOut: config.tokenOutAddress,
    amountIn: 1 ether, // amountIn: 1 WETH
    fee: config.fee,
    sqrtPriceLimitX96: 0 // No price limit
});

// @notice Encode the function call
// @dev From Uniswap Docs, this function is not marked view because it relies on calling non-view
// functions and reverting to compute the result. It is also not gas efficient and should not
// be called onchain. We take advantage of lzRead to call this function off-chain and get the result
// returned back onchain to the OApp's _lzReceive method.
// https://docs.uniswap.org/contracts/v3/reference/periphery/interfaces/IQuoterV2
bytes memory callData = abi.encodeWithSelector(IQuoterV2.quoteExactInputSingle.selector, params);

readRequests[i] = EVMCallRequestV1({
    appRequestLabel: uint16(i + 1),
    targetEid: targetEid,
    isBlockNum: false,
    blockNumOrTimestamp: uint64(block.timestamp),
    confirmations: config.confirmations,
    to: config.quoterAddress,
    callData: callData
});
```
