ponder 0.9.4-debug.1 → 0.9.5-debug.1

package/dist/types/indexing/index.d.ts

@@ -0,0 +1,575 @@
+import { type Extend } from '../utils/extend.js';
+import type { Context, Service } from "./service.js";
+declare const methods: {
+    create: ({ common, indexingBuild: { sources, networks, indexingFunctions }, requestQueues, syncStore, }: {
+        common: import("../internal/common.js").Common;
+        indexingBuild: Pick<import("../internal/types.js").IndexingBuild, "networks" | "sources" | "indexingFunctions">;
+        requestQueues: import("../utils/requestQueue.js").RequestQueue[];
+        syncStore: import("../sync-store/index.js").SyncStore;
+    }) => Service;
+    processEvents: (indexingService: Service, { events }: {
+        events: import("../internal/types.js").Event[];
+    }) => Promise<{
+        status: "error";
+        error: Error;
+    } | {
+        status: "success";
+    }>;
+    processSetupEvents: (indexingService: Service, { sources, networks, }: {
+        sources: import("../internal/types.js").Source[];
+        networks: import("../internal/types.js").Network[];
+    }) => Promise<{
+        status: "error";
+        error: Error;
+    } | {
+        status: "success";
+    }>;
+    setIndexingStore: (indexingService: Service, indexingStore: import("../indexing-store/index.js").IndexingStore<"historical" | "realtime">) => void;
+};
+export declare const createIndexingService: (params_0: {
+    common: import("../internal/common.js").Common;
+    indexingBuild: Pick<import("../internal/types.js").IndexingBuild, "networks" | "sources" | "indexingFunctions">;
+    requestQueues: import("../utils/requestQueue.js").RequestQueue[];
+    syncStore: import("../sync-store/index.js").SyncStore;
+}) => {
+    common: import("../internal/common.js").Common;
+    indexingFunctions: import("../internal/types.js").IndexingFunctions;
+    eventCount: {
+        [eventName: string]: number;
+    };
+    currentEvent: {
+        contextState: {
+            blockNumber: bigint;
+        };
+        context: Context;
+    };
+    networkByChainId: {
+        [chainId: number]: import("../internal/types.js").Network;
+    };
+    clientByChainId: {
+        [chainId: number]: {
+            request: import("viem").EIP1193RequestFn<import("viem").PublicRpcSchema>;
+            call: (args: Omit<import("viem").CallParameters<import("viem").Chain | undefined>, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").CallReturnType>;
+            estimateGas: (args: Omit<import("viem").EstimateGasParameters<import("viem").Chain | undefined>, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<bigint>;
+            getBalance: (args: Omit<import("viem").GetBalanceParameters, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<bigint>;
+            getBlock: <includeTransactions extends boolean = false>(args: {
+                includeTransactions?: includeTransactions | undefined;
+            } & ({
+                blockHash: `0x${string}`;
+                blockNumber?: undefined;
+            } | {
+                blockHash?: undefined;
+                blockNumber: bigint;
+            })) => Promise<{
+                number: bigint;
+                timestamp: bigint;
+                baseFeePerGas: bigint | null;
+                difficulty: bigint;
+                extraData: `0x${string}`;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}`;
+                logsBloom: `0x${string}`;
+                miner: `0x${string}`;
+                mixHash: `0x${string}`;
+                nonce: `0x${string}`;
+                parentHash: `0x${string}`;
+                receiptsRoot: `0x${string}`;
+                sha3Uncles: `0x${string}`;
+                size: bigint;
+                stateRoot: `0x${string}`;
+                totalDifficulty: bigint | null;
+                transactionsRoot: `0x${string}`;
+                blobGasUsed: bigint;
+                excessBlobGas: bigint;
+                sealFields: `0x${string}`[];
+                uncles: `0x${string}`[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+                transactions: includeTransactions extends true ? ({
+                    type: "legacy";
+                    gas: bigint;
+                    chainId?: number | undefined;
+                    hash: `0x${string}`;
+                    nonce: number;
+                    from: `0x${string}`;
+                    input: `0x${string}`;
+                    r: `0x${string}`;
+                    s: `0x${string}`;
+                    to: `0x${string}` | null;
+                    v: bigint;
+                    value: bigint;
+                    accessList?: undefined;
+                    gasPrice: bigint;
+                    maxFeePerGas?: undefined;
+                    maxPriorityFeePerGas?: undefined;
+                    yParity?: undefined;
+                    typeHex: `0x${string}` | null;
+                    authorizationList?: undefined;
+                    blobVersionedHashes?: undefined;
+                    maxFeePerBlobGas?: undefined;
+                    transactionIndex: number;
+                    blockHash: `0x${string}`;
+                    blockNumber: bigint;
+                } | {
+                    type: "eip2930";
+                    gas: bigint;
+                    chainId: number;
+                    hash: `0x${string}`;
+                    nonce: number;
+                    from: `0x${string}`;
+                    input: `0x${string}`;
+                    r: `0x${string}`;
+                    s: `0x${string}`;
+                    to: `0x${string}` | null;
+                    v: bigint;
+                    value: bigint;
+                    accessList: import("viem").AccessList;
+                    gasPrice: bigint;
+                    maxFeePerGas?: undefined;
+                    maxPriorityFeePerGas?: undefined;
+                    yParity: number;
+                    typeHex: `0x${string}` | null;
+                    authorizationList?: undefined;
+                    blobVersionedHashes?: undefined;
+                    maxFeePerBlobGas?: undefined;
+                    transactionIndex: number;
+                    blockHash: `0x${string}`;
+                    blockNumber: bigint;
+                } | {
+                    type: "eip1559";
+                    gas: bigint;
+                    chainId: number;
+                    hash: `0x${string}`;
+                    nonce: number;
+                    from: `0x${string}`;
+                    input: `0x${string}`;
+                    r: `0x${string}`;
+                    s: `0x${string}`;
+                    to: `0x${string}` | null;
+                    v: bigint;
+                    value: bigint;
+                    accessList: import("viem").AccessList;
+                    gasPrice?: undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    yParity: number;
+                    typeHex: `0x${string}` | null;
+                    authorizationList?: undefined;
+                    blobVersionedHashes?: undefined;
+                    maxFeePerBlobGas?: undefined;
+                    transactionIndex: number;
+                    blockHash: `0x${string}`;
+                    blockNumber: bigint;
+                } | {
+                    type: "eip4844";
+                    gas: bigint;
+                    chainId: number;
+                    hash: `0x${string}`;
+                    nonce: number;
+                    from: `0x${string}`;
+                    input: `0x${string}`;
+                    r: `0x${string}`;
+                    s: `0x${string}`;
+                    to: `0x${string}` | null;
+                    v: bigint;
+                    value: bigint;
+                    accessList: import("viem").AccessList;
+                    gasPrice?: undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    yParity: number;
+                    typeHex: `0x${string}` | null;
+                    authorizationList?: undefined;
+                    blobVersionedHashes: readonly `0x${string}`[];
+                    maxFeePerBlobGas: bigint;
+                    transactionIndex: number;
+                    blockHash: `0x${string}`;
+                    blockNumber: bigint;
+                } | {
+                    type: "eip7702";
+                    gas: bigint;
+                    chainId: number;
+                    hash: `0x${string}`;
+                    nonce: number;
+                    from: `0x${string}`;
+                    input: `0x${string}`;
+                    r: `0x${string}`;
+                    s: `0x${string}`;
+                    to: `0x${string}` | null;
+                    v: bigint;
+                    value: bigint;
+                    accessList: import("viem").AccessList;
+                    gasPrice?: undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    yParity: number;
+                    typeHex: `0x${string}` | null;
+                    authorizationList: import("viem/experimental").SignedAuthorizationList;
+                    blobVersionedHashes?: undefined;
+                    maxFeePerBlobGas?: undefined;
+                    transactionIndex: number;
+                    blockHash: `0x${string}`;
+                    blockNumber: bigint;
+                })[] : `0x${string}`[];
+            }>;
+            getBlockTransactionCount: (args: {
+                blockHash: `0x${string}`;
+                blockNumber?: undefined;
+            } | {
+                blockHash?: undefined;
+                blockNumber: bigint;
+            }) => Promise<number>;
+            getCode: (args: Omit<import("viem").GetBytecodeParameters, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetBytecodeReturnType>;
+            getEnsAddress: (args: Omit<{
+                blockNumber?: bigint | undefined;
+                blockTag?: import("viem").BlockTag | undefined;
+                coinType?: number | undefined;
+                gatewayUrls?: string[] | undefined;
+                name: string;
+                strict?: boolean | undefined;
+                universalResolverAddress?: `0x${string}` | undefined;
+            }, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetEnsAddressReturnType>;
+            getEnsAvatar: (args: Omit<{
+                name: string;
+                blockNumber?: bigint | undefined;
+                blockTag?: import("viem").BlockTag | undefined;
+                gatewayUrls?: string[] | undefined;
+                strict?: boolean | undefined;
+                universalResolverAddress?: `0x${string}` | undefined;
+                assetGatewayUrls?: import("viem").AssetGatewayUrls | undefined;
+            }, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetEnsAvatarReturnType>;
+            getEnsName: (args: Omit<{
+                blockNumber?: bigint | undefined;
+                blockTag?: import("viem").BlockTag | undefined;
+                address: `0x${string}`;
+                gatewayUrls?: string[] | undefined;
+                strict?: boolean | undefined;
+                universalResolverAddress?: `0x${string}` | undefined;
+            }, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetEnsNameReturnType>;
+            getEnsResolver: (args: Omit<{
+                blockNumber?: bigint | undefined;
+                blockTag?: import("viem").BlockTag | undefined;
+                name: string;
+                universalResolverAddress?: `0x${string}` | undefined;
+            }, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<`0x${string}`>;
+            getEnsText: (args: Omit<{
+                blockNumber?: bigint | undefined;
+                blockTag?: import("viem").BlockTag | undefined;
+                name: string;
+                gatewayUrls?: string[] | undefined;
+                key: string;
+                strict?: boolean | undefined;
+                universalResolverAddress?: `0x${string}` | undefined;
+            }, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetEnsTextReturnType>;
+            getFeeHistory: (args: Omit<import("viem").GetFeeHistoryParameters, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetFeeHistoryReturnType>;
+            getProof: (args: Omit<import("viem").GetProofParameters, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetProofReturnType>;
+            getStorageAt: (args: Omit<import("viem").GetStorageAtParameters, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").GetStorageAtReturnType>;
+            getTransaction: <blockTag extends import("viem").BlockTag = "latest">(args: import("viem").GetTransactionParameters<blockTag>) => Promise<{
+                type: "legacy";
+                gas: bigint;
+                chainId?: number | undefined;
+                hash: `0x${string}`;
+                nonce: number;
+                from: `0x${string}`;
+                input: `0x${string}`;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                accessList?: undefined;
+                gasPrice: bigint;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                yParity?: undefined;
+                typeHex: `0x${string}` | null;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                maxFeePerBlobGas?: undefined;
+                transactionIndex: (blockTag extends "pending" ? true : false) extends infer T ? T extends (blockTag extends "pending" ? true : false) ? T extends true ? null : number : never : never;
+                blockHash: (blockTag extends "pending" ? true : false) extends infer T_1 ? T_1 extends (blockTag extends "pending" ? true : false) ? T_1 extends true ? null : `0x${string}` : never : never;
+                blockNumber: (blockTag extends "pending" ? true : false) extends infer T_2 ? T_2 extends (blockTag extends "pending" ? true : false) ? T_2 extends true ? null : bigint : never : never;
+            } | {
+                type: "eip2930";
+                gas: bigint;
+                chainId: number;
+                hash: `0x${string}`;
+                nonce: number;
+                from: `0x${string}`;
+                input: `0x${string}`;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                accessList: import("viem").AccessList;
+                gasPrice: bigint;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                yParity: number;
+                typeHex: `0x${string}` | null;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                maxFeePerBlobGas?: undefined;
+                transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_3 ? T_3 extends (blockTag extends "pending" ? true : false) ? T_3 extends true ? null : number : never : never;
+                blockHash: (blockTag extends "pending" ? true : false) extends infer T_4 ? T_4 extends (blockTag extends "pending" ? true : false) ? T_4 extends true ? null : `0x${string}` : never : never;
+                blockNumber: (blockTag extends "pending" ? true : false) extends infer T_5 ? T_5 extends (blockTag extends "pending" ? true : false) ? T_5 extends true ? null : bigint : never : never;
+            } | {
+                type: "eip1559";
+                gas: bigint;
+                chainId: number;
+                hash: `0x${string}`;
+                nonce: number;
+                from: `0x${string}`;
+                input: `0x${string}`;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                accessList: import("viem").AccessList;
+                gasPrice?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                yParity: number;
+                typeHex: `0x${string}` | null;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                maxFeePerBlobGas?: undefined;
+                transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_6 ? T_6 extends (blockTag extends "pending" ? true : false) ? T_6 extends true ? null : number : never : never;
+                blockHash: (blockTag extends "pending" ? true : false) extends infer T_7 ? T_7 extends (blockTag extends "pending" ? true : false) ? T_7 extends true ? null : `0x${string}` : never : never;
+                blockNumber: (blockTag extends "pending" ? true : false) extends infer T_8 ? T_8 extends (blockTag extends "pending" ? true : false) ? T_8 extends true ? null : bigint : never : never;
+            } | {
+                type: "eip4844";
+                gas: bigint;
+                chainId: number;
+                hash: `0x${string}`;
+                nonce: number;
+                from: `0x${string}`;
+                input: `0x${string}`;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                accessList: import("viem").AccessList;
+                gasPrice?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                yParity: number;
+                typeHex: `0x${string}` | null;
+                authorizationList?: undefined;
+                blobVersionedHashes: readonly `0x${string}`[];
+                maxFeePerBlobGas: bigint;
+                transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_9 ? T_9 extends (blockTag extends "pending" ? true : false) ? T_9 extends true ? null : number : never : never;
+                blockHash: (blockTag extends "pending" ? true : false) extends infer T_10 ? T_10 extends (blockTag extends "pending" ? true : false) ? T_10 extends true ? null : `0x${string}` : never : never;
+                blockNumber: (blockTag extends "pending" ? true : false) extends infer T_11 ? T_11 extends (blockTag extends "pending" ? true : false) ? T_11 extends true ? null : bigint : never : never;
+            } | {
+                type: "eip7702";
+                gas: bigint;
+                chainId: number;
+                hash: `0x${string}`;
+                nonce: number;
+                from: `0x${string}`;
+                input: `0x${string}`;
+                r: `0x${string}`;
+                s: `0x${string}`;
+                to: `0x${string}` | null;
+                v: bigint;
+                value: bigint;
+                accessList: import("viem").AccessList;
+                gasPrice?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                yParity: number;
+                typeHex: `0x${string}` | null;
+                authorizationList: import("viem/experimental").SignedAuthorizationList;
+                blobVersionedHashes?: undefined;
+                maxFeePerBlobGas?: undefined;
+                transactionIndex: (blockTag extends "pending" ? true : false) extends infer T_12 ? T_12 extends (blockTag extends "pending" ? true : false) ? T_12 extends true ? null : number : never : never;
+                blockHash: (blockTag extends "pending" ? true : false) extends infer T_13 ? T_13 extends (blockTag extends "pending" ? true : false) ? T_13 extends true ? null : `0x${string}` : never : never;
+                blockNumber: (blockTag extends "pending" ? true : false) extends infer T_14 ? T_14 extends (blockTag extends "pending" ? true : false) ? T_14 extends true ? null : bigint : never : never;
+            }>;
+            getTransactionConfirmations: (args: import("viem").GetTransactionConfirmationsParameters<import("viem").Chain | undefined>) => Promise<bigint>;
+            getTransactionCount: (args: {
+                address: `0x${string}`;
+            } & ({
+                blockHash: `0x${string}`;
+                blockNumber?: undefined;
+            } | {
+                blockHash?: undefined;
+                blockNumber: bigint;
+            })) => Promise<number>;
+            getTransactionReceipt: (args: import("viem").GetTransactionReceiptParameters) => Promise<import("viem").TransactionReceipt>;
+            multicall: <const contracts extends readonly unknown[], allowFailure extends boolean = true>(args: Omit<import("viem").MulticallParameters<contracts, allowFailure>, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").MulticallReturnType<contracts, allowFailure>>;
+            readContract: <const abi extends readonly unknown[] | import("viem").Abi, functionName extends import("viem").ContractFunctionName<abi, "pure" | "view">, const args extends import("viem").ContractFunctionArgs<abi, "pure" | "view", functionName>>(args: Omit<import("viem").ReadContractParameters<abi, functionName, args>, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").ReadContractReturnType<abi, functionName, args>>;
+            simulateContract: <const abi_1 extends readonly unknown[] | import("viem").Abi, functionName_1 extends import("viem").ContractFunctionName<abi_1, "payable" | "nonpayable">, const args_1 extends import("viem").ContractFunctionArgs<abi_1, "payable" | "nonpayable", functionName_1>>(args: Omit<import("viem").SimulateContractParameters<abi_1, functionName_1, args>, "blockNumber" | "blockTag"> & ({
+                cache?: undefined;
+                blockNumber?: undefined;
+            } | {
+                cache: "immutable";
+                blockNumber?: undefined;
+            } | {
+                cache?: undefined;
+                blockNumber: bigint;
+            })) => Promise<import("viem").SimulateContractReturnType<abi_1, functionName_1, args>>;
+        };
+    };
+    contractsByChainId: {
+        [chainId: number]: Record<string, {
+            abi: import("viem").Abi;
+            address?: `0x${string}` | readonly `0x${string}`[] | undefined;
+            startBlock?: number | undefined;
+            endBlock?: number | undefined;
+        }>;
+    };
+    create: () => Service;
+    processEvents: (params_0: {
+        events: import("../internal/types.js").Event[];
+    }) => Promise<{
+        status: "error";
+        error: Error;
+    } | {
+        status: "success";
+    }>;
+    processSetupEvents: (params_0: {
+        sources: import("../internal/types.js").Source[];
+        networks: import("../internal/types.js").Network[];
+    }) => Promise<{
+        status: "error";
+        error: Error;
+    } | {
+        status: "success";
+    }>;
+    setIndexingStore: (indexingStore: import("../indexing-store/index.js").IndexingStore<"historical" | "realtime">) => void;
+};
+export type IndexingService = Extend<Service, typeof methods>;
+export type { Context };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/indexing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/indexing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAU,MAAM,mBAAmB,CAAC;AAOxD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAErD,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;CAKZ,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,EAAE,OAAO,OAAO,CAAC,CAAC;AAE9D,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/types/indexing/ponderActions.d.ts

@@ -0,0 +1,47 @@
+import type { Prettify } from '../types/utils.js';
+import { type Abi, type Account, type Address, type Chain, type Client, type ContractFunctionArgs, type ContractFunctionName, type GetBlockReturnType, type GetBlockTransactionCountReturnType, type GetTransactionCountReturnType, type Hash, type MulticallParameters, type MulticallReturnType, type PublicActions, type PublicRpcSchema, type ReadContractParameters, type ReadContractReturnType, type SimulateContractParameters, type SimulateContractReturnType, type Transport, publicActions } from "viem";
+import type { Service } from "./service.js";
+/** Viem actions where the `block` property is optional and implicit. */
+declare const blockDependentActions: readonly ["getBalance", "call", "estimateGas", "getFeeHistory", "getProof", "getCode", "getStorageAt", "getEnsAddress", "getEnsAvatar", "getEnsName", "getEnsResolver", "getEnsText"];
+/** Viem actions where the `block` property is non-existent. */
+declare const nonBlockDependentActions: readonly ["getTransaction", "getTransactionReceipt", "getTransactionConfirmations"];
+type BlockOptions = {
+    cache?: undefined;
+    blockNumber?: undefined;
+} | {
+    cache: "immutable";
+    blockNumber?: undefined;
+} | {
+    cache?: undefined;
+    blockNumber: bigint;
+};
+type RequiredBlockOptions = {
+    /** Hash of the block. */
+    blockHash: Hash;
+    blockNumber?: undefined;
+} | {
+    blockHash?: undefined;
+    /** The block number. */
+    blockNumber: bigint;
+};
+type BlockDependentAction<fn extends (client: any, args: any) => unknown, params = Parameters<fn>[0], returnType = ReturnType<fn>> = (args: Omit<params, "blockTag" | "blockNumber"> & BlockOptions) => returnType;
+export type PonderActions = {
+    [action in (typeof blockDependentActions)[number]]: BlockDependentAction<ReturnType<typeof publicActions>[action]>;
+} & {
+    multicall: <const contracts extends readonly unknown[], allowFailure extends boolean = true>(args: Omit<MulticallParameters<contracts, allowFailure>, "blockTag" | "blockNumber"> & BlockOptions) => Promise<MulticallReturnType<contracts, allowFailure>>;
+    readContract: <const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, "pure" | "view">, const args extends ContractFunctionArgs<abi, "pure" | "view", functionName>>(args: Omit<ReadContractParameters<abi, functionName, args>, "blockTag" | "blockNumber"> & BlockOptions) => Promise<ReadContractReturnType<abi, functionName, args>>;
+    simulateContract: <const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, "nonpayable" | "payable">, const args extends ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>>(args: Omit<SimulateContractParameters<abi, functionName, args>, "blockTag" | "blockNumber"> & BlockOptions) => Promise<SimulateContractReturnType<abi, functionName, args>>;
+    getBlock: <includeTransactions extends boolean = false>(args: {
+        /** Whether or not to include transaction data in the response. */
+        includeTransactions?: includeTransactions | undefined;
+    } & RequiredBlockOptions) => Promise<GetBlockReturnType<Chain | undefined, includeTransactions>>;
+    getTransactionCount: (args: {
+        /** The account address. */
+        address: Address;
+    } & RequiredBlockOptions) => Promise<GetTransactionCountReturnType>;
+    getBlockTransactionCount: (args: RequiredBlockOptions) => Promise<GetBlockTransactionCountReturnType>;
+} & Pick<PublicActions, (typeof nonBlockDependentActions)[number]>;
+export type ReadOnlyClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined> = Prettify<Omit<Client<transport, chain, undefined, PublicRpcSchema, PonderActions>, "extend" | "key" | "batch" | "cacheTime" | "account" | "type" | "uid" | "chain" | "name" | "pollingInterval" | "transport" | "ccipRead">>;
+export declare const getPonderActions: (contextState: Pick<Service["currentEvent"]["contextState"], "blockNumber">) => <TTransport extends Transport = Transport, TChain extends Chain | undefined = Chain | undefined, TAccount extends Account | undefined = Account | undefined>(client: Client<TTransport, TChain, TAccount>) => PonderActions;
+export {};
+//# sourceMappingURL=ponderActions.d.ts.map

package/dist/types/indexing/ponderActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ponderActions.d.ts","sourceRoot":"","sources":["../../../src/indexing/ponderActions.ts"],"names":[],"mappings":"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"}