@ensnode/datasources 1.16.0 → 1.17.0

package/dist/index.d.ts

@@ -6496,6 +6496,9 @@ declare const DatasourceNames: {
     readonly ReverseResolverArbitrum: "rrArbitrum";
     readonly ReverseResolverScroll: "rrScroll";
     readonly ENSv2Root: "ENSv2Root";
+    readonly EFPBase: "efpBase";
+    readonly EFPOptimism: "efpOptimism";
+    readonly EFPEthereum: "efpEthereum";
 };
 type DatasourceName = (typeof DatasourceNames)[keyof typeof DatasourceNames];
 /**
@@ -28384,6 +28387,348 @@ declare const _default$3: {
             };
         };
     };
+    /**
+     * EFP Datasources
+     *
+     * The Ethereum Follow Protocol contracts, deployed onto the ens-test-env devnet by the EFP devnet
+     * image (attach mode) on top of the ENS deployment. On the `mainnet` namespace EFP spans Base,
+     * Optimism, and Ethereum; the single-chain devnet has only one EFP deployment, so all three EFP
+     * datasources resolve to `ensTestEnvChain` (id 31337) with the same `ListRecords` contract.
+     *
+     * The EFP plugin's Ponder config keys each contract by chain id, so the three datasources collapse
+     * to a single set of contracts on chain 31337 (no double-indexing). This relies on the
+     * `ListRecords` address being IDENTICAL across all three datasources below — if they diverge, the
+     * per-chain-id merge silently keeps only `EFPEthereum`'s.
+     *
+     * @see docker/services/efp-devnet.yml for how these contracts are deployed and addresses captured.
+     */
+    efpBase: {
+        chain: {
+            readonly id: 31337;
+            readonly name: "ens-test-env";
+            readonly blockExplorers?: {
+                [key: string]: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+                default: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+            } | undefined | undefined;
+            readonly blockTime?: number | undefined | undefined;
+            readonly contracts?: {
+                [x: string]: viem.ChainContract | {
+                    [sourceId: number]: viem.ChainContract | undefined;
+                } | undefined;
+                ensRegistry?: viem.ChainContract | undefined;
+                ensUniversalResolver?: viem.ChainContract | undefined;
+                multicall3?: viem.ChainContract | undefined;
+                erc6492Verifier?: viem.ChainContract | undefined;
+            } | undefined;
+            readonly ensTlds?: readonly string[] | undefined;
+            readonly nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            readonly experimental_preconfirmationTime?: number | undefined | undefined;
+            readonly rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["http://127.0.0.1:8545"];
+                    readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+                };
+            };
+            readonly sourceId?: number | undefined | undefined;
+            readonly testnet?: boolean | undefined | undefined;
+            readonly custom?: Record<string, unknown> | undefined;
+            readonly extendSchema?: Record<string, unknown> | undefined;
+            readonly fees?: viem.ChainFees<undefined> | undefined;
+            readonly formatters?: undefined;
+            readonly prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            readonly serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            readonly verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        contracts: {
+            ListRegistry: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "Transfer";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "from";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: true;
+                        readonly name: "to";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: true;
+                        readonly name: "tokenId";
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListStorageLocation";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "tokenId";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "listStorageLocation";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0xf8e31cb472bc70500f08cd84917e5a1912ec8397";
+                startBlock: number;
+            };
+            AccountMetadata: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "UpdateAccountMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "addr";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0xd5ac451b0c50b9476107823af206ed814a2e2580";
+                startBlock: number;
+            };
+            ListRecords: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "ListOp";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "op";
+                        readonly type: "bytes";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0xc0f115a19107322cfbf1cdbc7ea011c19ebdb4f8";
+                startBlock: number;
+            };
+        };
+    };
+    efpOptimism: {
+        chain: {
+            readonly id: 31337;
+            readonly name: "ens-test-env";
+            readonly blockExplorers?: {
+                [key: string]: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+                default: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+            } | undefined | undefined;
+            readonly blockTime?: number | undefined | undefined;
+            readonly contracts?: {
+                [x: string]: viem.ChainContract | {
+                    [sourceId: number]: viem.ChainContract | undefined;
+                } | undefined;
+                ensRegistry?: viem.ChainContract | undefined;
+                ensUniversalResolver?: viem.ChainContract | undefined;
+                multicall3?: viem.ChainContract | undefined;
+                erc6492Verifier?: viem.ChainContract | undefined;
+            } | undefined;
+            readonly ensTlds?: readonly string[] | undefined;
+            readonly nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            readonly experimental_preconfirmationTime?: number | undefined | undefined;
+            readonly rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["http://127.0.0.1:8545"];
+                    readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+                };
+            };
+            readonly sourceId?: number | undefined | undefined;
+            readonly testnet?: boolean | undefined | undefined;
+            readonly custom?: Record<string, unknown> | undefined;
+            readonly extendSchema?: Record<string, unknown> | undefined;
+            readonly fees?: viem.ChainFees<undefined> | undefined;
+            readonly formatters?: undefined;
+            readonly prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            readonly serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            readonly verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        contracts: {
+            ListRecords: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "ListOp";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "op";
+                        readonly type: "bytes";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0xc0f115a19107322cfbf1cdbc7ea011c19ebdb4f8";
+                startBlock: number;
+            };
+        };
+    };
+    efpEthereum: {
+        chain: {
+            readonly id: 31337;
+            readonly name: "ens-test-env";
+            readonly blockExplorers?: {
+                [key: string]: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+                default: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+            } | undefined | undefined;
+            readonly blockTime?: number | undefined | undefined;
+            readonly contracts?: {
+                [x: string]: viem.ChainContract | {
+                    [sourceId: number]: viem.ChainContract | undefined;
+                } | undefined;
+                ensRegistry?: viem.ChainContract | undefined;
+                ensUniversalResolver?: viem.ChainContract | undefined;
+                multicall3?: viem.ChainContract | undefined;
+                erc6492Verifier?: viem.ChainContract | undefined;
+            } | undefined;
+            readonly ensTlds?: readonly string[] | undefined;
+            readonly nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            readonly experimental_preconfirmationTime?: number | undefined | undefined;
+            readonly rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["http://127.0.0.1:8545"];
+                    readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+                };
+            };
+            readonly sourceId?: number | undefined | undefined;
+            readonly testnet?: boolean | undefined | undefined;
+            readonly custom?: Record<string, unknown> | undefined;
+            readonly extendSchema?: Record<string, unknown> | undefined;
+            readonly fees?: viem.ChainFees<undefined> | undefined;
+            readonly formatters?: undefined;
+            readonly prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            readonly serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            readonly verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        contracts: {
+            ListRecords: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "ListOp";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "op";
+                        readonly type: "bytes";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0xc0f115a19107322cfbf1cdbc7ea011c19ebdb4f8";
+                startBlock: number;
+            };
+        };
+    };
 };
 
 /**
@@ -74448,6 +74793,882 @@ declare const _default$2: {
             };
         };
     };
+    /**
+     * EFP (Ethereum Follow Protocol) Datasource on Base.
+     *
+     * The `ListRegistry` (list NFTs) and `AccountMetadata` contracts are deployed only on Base.
+     * The `ListRecords` contract is also deployed on Base (one of the three "list storage location"
+     * chains a list NFT may point at via `UpdateListStorageLocation`).
+     *
+     * Every address below is cross-checked against the official EFP deployments,
+     * https://docs.efp.app/production/deployments/ (and ethereumfollowprotocol/api-v2).
+     */
+    efpBase: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Basescan";
+                    readonly url: "https://basescan.org";
+                    readonly apiUrl: "https://api.basescan.org/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                    };
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 5022;
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                        readonly blockCreated: 17482143;
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                        readonly blockCreated: 17482143;
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 8453;
+            name: "Base";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.base.org"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: viem.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                    } | {
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: viem.Address | null;
+                        from: viem.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        contractAddress: viem.Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: viem.Address;
+                        gasUsed: bigint;
+                        logs: viem.Log<bigint, number, false>[];
+                        logsBloom: viem.Hex;
+                        root?: `0x${string}` | undefined;
+                        status: "success" | "reverted";
+                        to: viem.Address | null;
+                        transactionHash: viem.Hash;
+                        transactionIndex: number;
+                        type: viem.TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        contracts: {
+            ListRegistry: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "Transfer";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "from";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: true;
+                        readonly name: "to";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: true;
+                        readonly name: "tokenId";
+                        readonly type: "uint256";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListStorageLocation";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "tokenId";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "listStorageLocation";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0x0e688f5dca4a0a4729946acbc44c792341714e08";
+                startBlock: number;
+            };
+            AccountMetadata: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "UpdateAccountMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "addr";
+                        readonly type: "address";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0x5289fe5dabc021d02fddf23d4a4df96f4e0f17ef";
+                startBlock: number;
+            };
+            ListRecords: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "ListOp";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "op";
+                        readonly type: "bytes";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0x41aa48ef3c0446b46a5b1cc6337ff3d3716e2a33";
+                startBlock: number;
+            };
+        };
+    };
+    /**
+     * EFP `ListRecords` Datasource on Optimism.
+     */
+    efpOptimism: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Optimism Explorer";
+                    readonly url: "https://optimistic.etherscan.io";
+                    readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
+                    };
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 4286263;
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 10;
+            name: "OP Mainnet";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.optimism.io"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: viem.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                    } | {
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: viem.Address | null;
+                        from: viem.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: viem.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: viem.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        contractAddress: viem.Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: viem.Address;
+                        gasUsed: bigint;
+                        logs: viem.Log<bigint, number, false>[];
+                        logsBloom: viem.Hex;
+                        root?: `0x${string}` | undefined;
+                        status: "success" | "reverted";
+                        to: viem.Address | null;
+                        transactionHash: viem.Hash;
+                        transactionIndex: number;
+                        type: viem.TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        contracts: {
+            ListRecords: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "ListOp";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "op";
+                        readonly type: "bytes";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0x4ca00413d850dcfa3516e14d21dae2772f2acb85";
+                startBlock: number;
+            };
+        };
+    };
+    /**
+     * EFP `ListRecords` Datasource on Ethereum mainnet.
+     */
+    efpEthereum: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            blockTime: 12000;
+            contracts: {
+                readonly ensUniversalResolver: {
+                    readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                    readonly blockCreated: 23085558;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://eth.merkle.io"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        contracts: {
+            ListRecords: {
+                abi: readonly [{
+                    readonly type: "event";
+                    readonly name: "ListOp";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "op";
+                        readonly type: "bytes";
+                    }];
+                }, {
+                    readonly type: "event";
+                    readonly name: "UpdateListMetadata";
+                    readonly inputs: readonly [{
+                        readonly indexed: true;
+                        readonly name: "slot";
+                        readonly type: "uint256";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "key";
+                        readonly type: "string";
+                    }, {
+                        readonly indexed: false;
+                        readonly name: "value";
+                        readonly type: "bytes";
+                    }];
+                }];
+                address: "0x5289fe5dabc021d02fddf23d4a4df96f4e0f17ef";
+                startBlock: number;
+            };
+        };
+    };
 };
 
 /**
@@ -117101,7 +118322,7 @@ declare const _default: {
                         readonly type: "bytes[]";
                     }];
                 }];
-                address: "0x651d670ce0d0f1ed0893f39d51fd0dbd4546c9ef";
+                address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
                 startBlock: number;
             };
         };
@@ -121017,7 +122238,7 @@ declare const _default: {
                         readonly internalType: "address";
                     }];
                 }];
-                address: "0x835f0b284e78cd3f358bcf6cba3b53809f09b79e";
+                address: "0xc960f7217d3643b525ef36bec8adf86953cd9ab8";
                 startBlock: number;
             };
             ETHRegistry: {
@@ -122215,7 +123436,7 @@ declare const _default: {
                         readonly internalType: "address";
                     }];
                 }];
-                address: "0x64c81210d0e580cfc7746f3fb910bf0e8f6378e1";
+                address: "0xdedb92913a25abe1f7bcdd85d8a344a43b398b67";
                 startBlock: number;
             };
             ETHRegistrar: {
@@ -122876,7 +124097,7 @@ declare const _default: {
                     readonly stateMutability: "nonpayable";
                     readonly type: "function";
                 }];
-                address: "0xb68e594a47fe057bd31e7a8229ffcfd85b2e28af";
+                address: "0x8c2e866b439358c41ae05de9cbe8a00bfefaffca";
                 startBlock: number;
             };
         };
@@ -124103,7 +125324,7 @@ declare const _default: {
                     readonly stateMutability: "view";
                     readonly type: "function";
                 }];
-                address: "0xb441cb480460eb8b2964dcb82b64a883b14abf3e";
+                address: "0x5239a812ec9a62f46dbb5de8f346c8efe7553a9f";
                 startBlock: number;
             };
             BaseReverseResolver: {