From b9d8d72a00ae63adcf3219ae8b636bbe92a41aa8 Mon Sep 17 00:00:00 2001
From: Achthar <69119535+Achthar@users.noreply.github.com>
Date: Tue, 13 Aug 2024 12:29:39 +0200
Subject: [PATCH] ad builds
---
dist/abi/InterfaceMulticall.d.ts | 70 +
dist/constants.d.ts | 10 +
dist/context.d.ts | 5 +
dist/create.d.ts | 43 +
dist/hooks.d.ts | 13 +
dist/index.d.ts | 3 +
dist/integration-tests/App.d.ts | 2 +
dist/integration-tests/MultichainApp.d.ts | 2 +
dist/integration-tests/Updater.d.ts | 9 +
dist/integration-tests/consts.d.ts | 9 +
dist/integration-tests/erc20.d.ts | 168 ++
dist/integration-tests/hooks.d.ts | 893 +++++++++
dist/integration-tests/multicall.d.ts | 41 +
dist/integration-tests/store.d.ts | 8 +
dist/integration-tests/utils.d.ts | 1 +
dist/redux-multicall-viem.cjs.development.js | 1628 +++++++++++++++++
...edux-multicall-viem.cjs.development.js.map | 1 +
...redux-multicall-viem.cjs.production.min.js | 2 +
...x-multicall-viem.cjs.production.min.js.map | 1 +
dist/redux-multicall-viem.esm.js | 1612 ++++++++++++++++
dist/redux-multicall-viem.esm.js.map | 1 +
dist/slice.d.ts | 11 +
dist/types.d.ts | 78 +
dist/updater.d.ts | 31 +
dist/utils/callKeys.d.ts | 5 +
dist/utils/callState.d.ts | 4 +
dist/utils/chunkCalls.d.ts | 9 +
dist/utils/retry.d.ts | 22 +
dist/utils/useDebounce.d.ts | 1 +
dist/validation.d.ts | 4 +
30 files changed, 4687 insertions(+)
create mode 100644 dist/abi/InterfaceMulticall.d.ts
create mode 100644 dist/constants.d.ts
create mode 100644 dist/context.d.ts
create mode 100644 dist/create.d.ts
create mode 100644 dist/hooks.d.ts
create mode 100644 dist/index.d.ts
create mode 100644 dist/integration-tests/App.d.ts
create mode 100644 dist/integration-tests/MultichainApp.d.ts
create mode 100644 dist/integration-tests/Updater.d.ts
create mode 100644 dist/integration-tests/consts.d.ts
create mode 100644 dist/integration-tests/erc20.d.ts
create mode 100644 dist/integration-tests/hooks.d.ts
create mode 100644 dist/integration-tests/multicall.d.ts
create mode 100644 dist/integration-tests/store.d.ts
create mode 100644 dist/integration-tests/utils.d.ts
create mode 100644 dist/redux-multicall-viem.cjs.development.js
create mode 100644 dist/redux-multicall-viem.cjs.development.js.map
create mode 100644 dist/redux-multicall-viem.cjs.production.min.js
create mode 100644 dist/redux-multicall-viem.cjs.production.min.js.map
create mode 100644 dist/redux-multicall-viem.esm.js
create mode 100644 dist/redux-multicall-viem.esm.js.map
create mode 100644 dist/slice.d.ts
create mode 100644 dist/types.d.ts
create mode 100644 dist/updater.d.ts
create mode 100644 dist/utils/callKeys.d.ts
create mode 100644 dist/utils/callState.d.ts
create mode 100644 dist/utils/chunkCalls.d.ts
create mode 100644 dist/utils/retry.d.ts
create mode 100644 dist/utils/useDebounce.d.ts
create mode 100644 dist/validation.d.ts
diff --git a/dist/abi/InterfaceMulticall.d.ts b/dist/abi/InterfaceMulticall.d.ts
new file mode 100644
index 0000000..80b993a
--- /dev/null
+++ b/dist/abi/InterfaceMulticall.d.ts
@@ -0,0 +1,70 @@
+declare const _default: readonly [{
+ readonly inputs: readonly [];
+ readonly name: "getCurrentBlockTimestamp";
+ readonly outputs: readonly [{
+ readonly internalType: "uint256";
+ readonly name: "timestamp";
+ readonly type: "uint256";
+ }];
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly inputs: readonly [{
+ readonly internalType: "address";
+ readonly name: "addr";
+ readonly type: "address";
+ }];
+ readonly name: "getEthBalance";
+ readonly outputs: readonly [{
+ readonly internalType: "uint256";
+ readonly name: "balance";
+ readonly type: "uint256";
+ }];
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly inputs: readonly [{
+ readonly components: readonly [{
+ readonly internalType: "address";
+ readonly name: "target";
+ readonly type: "address";
+ }, {
+ readonly internalType: "uint256";
+ readonly name: "gasLimit";
+ readonly type: "uint256";
+ }, {
+ readonly internalType: "bytes";
+ readonly name: "callData";
+ readonly type: "bytes";
+ }];
+ readonly internalType: "struct PancakeInterfaceMulticall.Call[]";
+ readonly name: "calls";
+ readonly type: "tuple[]";
+ }];
+ readonly name: "multicall";
+ readonly outputs: readonly [{
+ readonly internalType: "uint256";
+ readonly name: "blockNumber";
+ readonly type: "uint256";
+ }, {
+ readonly components: readonly [{
+ readonly internalType: "bool";
+ readonly name: "success";
+ readonly type: "bool";
+ }, {
+ readonly internalType: "uint256";
+ readonly name: "gasUsed";
+ readonly type: "uint256";
+ }, {
+ readonly internalType: "bytes";
+ readonly name: "returnData";
+ readonly type: "bytes";
+ }];
+ readonly internalType: "struct PancakeInterfaceMulticall.Result[]";
+ readonly name: "returnData";
+ readonly type: "tuple[]";
+ }];
+ readonly stateMutability: "nonpayable";
+ readonly type: "function";
+}];
+export default _default;
diff --git a/dist/constants.d.ts b/dist/constants.d.ts
new file mode 100644
index 0000000..1599407
--- /dev/null
+++ b/dist/constants.d.ts
@@ -0,0 +1,10 @@
+import type { CallResult, CallState, ListenerOptions } from './types';
+export declare const DEFAULT_BLOCKS_PER_FETCH = 1;
+export declare const DEFAULT_CALL_GAS_REQUIRED = 1000000;
+export declare const DEFAULT_CHUNK_GAS_REQUIRED = 200000;
+export declare const CHUNK_GAS_LIMIT = 100000000;
+export declare const CONSERVATIVE_BLOCK_GAS_LIMIT = 10000000;
+export declare const INVALID_RESULT: CallResult;
+export declare const NEVER_RELOAD: ListenerOptions;
+export declare const INVALID_CALL_STATE: CallState;
+export declare const LOADING_CALL_STATE: CallState;
diff --git a/dist/context.d.ts b/dist/context.d.ts
new file mode 100644
index 0000000..1b7abde
--- /dev/null
+++ b/dist/context.d.ts
@@ -0,0 +1,5 @@
+import type { MulticallActions } from './slice';
+export interface MulticallContext {
+ reducerPath: string;
+ actions: MulticallActions;
+}
diff --git a/dist/create.d.ts b/dist/create.d.ts
new file mode 100644
index 0000000..656a218
--- /dev/null
+++ b/dist/create.d.ts
@@ -0,0 +1,43 @@
+///
+export interface MulticallOptions {
+ reducerPath?: string;
+}
+export declare function createMulticall(options?: MulticallOptions): {
+ reducerPath: string;
+ reducer: import("redux").Reducer;
+ actions: import("@reduxjs/toolkit").CaseReducerActions<{
+ addMulticallListeners: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("./types").MulticallListenerPayload;
+ type: string;
+ }) => void;
+ removeMulticallListeners: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("./types").MulticallListenerPayload;
+ type: string;
+ }) => void;
+ fetchingMulticallResults: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("./types").MulticallFetchingPayload;
+ type: string;
+ }) => void;
+ errorFetchingMulticallResults: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("./types").MulticallFetchingPayload;
+ type: string;
+ }) => void;
+ updateMulticallResults: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("./types").MulticallResultsPayload;
+ type: string;
+ }) => void;
+ updateListenerOptions: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("./types").MulticallListenerOptionsPayload;
+ type: string;
+ }) => void;
+ }, string>;
+ hooks: {
+ useMultipleContractSingleData: (chainId: number | undefined, latestBlockNumber: number | undefined, addresses: (string | undefined)[], contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("./validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => import("./types").CallState[];
+ useSingleContractMultipleData: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("./types").ContractInfo | null | undefined, methodName: string, callInputs: ((string | number | BigInt | import("./validation").MethodArg[] | undefined)[] | undefined)[], options?: Partial | undefined) => import("./types").CallState[];
+ useSingleContractWithCallData: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("./types").ContractInfo | null | undefined, callDatas: string[], options?: Partial | undefined) => import("./types").CallState[];
+ useSingleCallResult: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("./types").ContractInfo | null | undefined, methodName: string, inputs?: (string | number | BigInt | import("./validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => import("./types").CallState;
+ useMultiChainMultiContractSingleData: (chainToBlockNumber: Record, chainToAddresses: Record, contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("./validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => Record;
+ useMultiChainSingleContractSingleData: (chainToBlockNumber: Record, chainToAddress: Record, contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("./validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => Record;
+ };
+ Updater: (props: Pick) => import("react").JSX.Element;
+};
diff --git a/dist/hooks.d.ts b/dist/hooks.d.ts
new file mode 100644
index 0000000..2a7e25d
--- /dev/null
+++ b/dist/hooks.d.ts
@@ -0,0 +1,13 @@
+import type { MulticallContext } from './context';
+import type { Call, CallResult, CallState, ContractInfo, ListenerOptions, ListenerOptionsWithGas } from './types';
+import { MethodArg } from './validation';
+import { AbiFunction } from 'viem';
+declare type OptionalMethodInputs = Array | undefined;
+export declare function useCallsDataSubscription(context: MulticallContext, chainId: number | undefined, calls: Array, listenerOptions?: ListenerOptions): CallResult[];
+export declare function useSingleContractMultipleData(context: MulticallContext, chainId: number | undefined, latestBlockNumber: number | undefined, contract: ContractInfo | null | undefined, methodName: string, callInputs: OptionalMethodInputs[], options?: Partial): CallState[];
+export declare function useMultipleContractSingleData(context: MulticallContext, chainId: number | undefined, latestBlockNumber: number | undefined, addresses: (string | undefined)[], contractInterface: AbiFunction[], methodName: string, callInputs?: OptionalMethodInputs, options?: Partial): CallState[];
+export declare function useSingleCallResult(context: MulticallContext, chainId: number | undefined, latestBlockNumber: number | undefined, contract: ContractInfo | null | undefined, methodName: string, inputs?: OptionalMethodInputs, options?: Partial): CallState;
+export declare function useSingleContractWithCallData(context: MulticallContext, chainId: number | undefined, latestBlockNumber: number | undefined, contract: ContractInfo | null | undefined, callDatas: string[], options?: Partial): CallState[];
+export declare function useMultiChainMultiContractSingleData(context: MulticallContext, chainToBlockNumber: Record, chainToAddresses: Record>, contractInterface: AbiFunction[], methodName: string, callInputs?: OptionalMethodInputs, options?: Partial): Record;
+export declare function useMultiChainSingleContractSingleData(context: MulticallContext, chainToBlockNumber: Record, chainToAddress: Record, contractInterface: AbiFunction[], methodName: string, callInputs?: OptionalMethodInputs, options?: Partial): Record;
+export {};
diff --git a/dist/index.d.ts b/dist/index.d.ts
new file mode 100644
index 0000000..3cf59a0
--- /dev/null
+++ b/dist/index.d.ts
@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './create';
+export * from './types';
diff --git a/dist/integration-tests/App.d.ts b/dist/integration-tests/App.d.ts
new file mode 100644
index 0000000..377078c
--- /dev/null
+++ b/dist/integration-tests/App.d.ts
@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function App(): React.JSX.Element;
diff --git a/dist/integration-tests/MultichainApp.d.ts b/dist/integration-tests/MultichainApp.d.ts
new file mode 100644
index 0000000..a2829cb
--- /dev/null
+++ b/dist/integration-tests/MultichainApp.d.ts
@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function MultichainApp(): React.JSX.Element;
diff --git a/dist/integration-tests/Updater.d.ts b/dist/integration-tests/Updater.d.ts
new file mode 100644
index 0000000..d356054
--- /dev/null
+++ b/dist/integration-tests/Updater.d.ts
@@ -0,0 +1,9 @@
+import React from 'react';
+import { ChainId } from './consts';
+interface Props {
+ chainId: ChainId;
+ blockNumber: number | undefined;
+ blocksPerFetch?: number;
+}
+export declare function Updater({ chainId, blockNumber, blocksPerFetch }: Props): React.JSX.Element;
+export {};
diff --git a/dist/integration-tests/consts.d.ts b/dist/integration-tests/consts.d.ts
new file mode 100644
index 0000000..4025db7
--- /dev/null
+++ b/dist/integration-tests/consts.d.ts
@@ -0,0 +1,9 @@
+export declare const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const MULTICALL_ADDRESS = "0x1F98415757620B543A52E61c46B32eB19261F984";
+export declare const DAI_ADDRESS = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
+export declare const USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+export declare const USDT_ADDRESS = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
+export declare enum ChainId {
+ MAINNET = 1,
+ SEPOLIA = 11155111
+}
diff --git a/dist/integration-tests/erc20.d.ts b/dist/integration-tests/erc20.d.ts
new file mode 100644
index 0000000..c6feef7
--- /dev/null
+++ b/dist/integration-tests/erc20.d.ts
@@ -0,0 +1,168 @@
+export declare const ERC20_ABI: readonly [{
+ readonly constant: true;
+ readonly inputs: readonly [];
+ readonly name: "name";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "string";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly constant: false;
+ readonly inputs: readonly [{
+ readonly name: "_spender";
+ readonly type: "address";
+ }, {
+ readonly name: "_value";
+ readonly type: "uint256";
+ }];
+ readonly name: "approve";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "bool";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "nonpayable";
+ readonly type: "function";
+}, {
+ readonly constant: true;
+ readonly inputs: readonly [];
+ readonly name: "totalSupply";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "uint256";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly constant: false;
+ readonly inputs: readonly [{
+ readonly name: "_from";
+ readonly type: "address";
+ }, {
+ readonly name: "_to";
+ readonly type: "address";
+ }, {
+ readonly name: "_value";
+ readonly type: "uint256";
+ }];
+ readonly name: "transferFrom";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "bool";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "nonpayable";
+ readonly type: "function";
+}, {
+ readonly constant: true;
+ readonly inputs: readonly [];
+ readonly name: "decimals";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "uint8";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly constant: true;
+ readonly inputs: readonly [{
+ readonly name: "_owner";
+ readonly type: "address";
+ }];
+ readonly name: "balanceOf";
+ readonly outputs: readonly [{
+ readonly name: "balance";
+ readonly type: "uint256";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly constant: true;
+ readonly inputs: readonly [];
+ readonly name: "symbol";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "string";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly constant: false;
+ readonly inputs: readonly [{
+ readonly name: "_to";
+ readonly type: "address";
+ }, {
+ readonly name: "_value";
+ readonly type: "uint256";
+ }];
+ readonly name: "transfer";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "bool";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "nonpayable";
+ readonly type: "function";
+}, {
+ readonly constant: true;
+ readonly inputs: readonly [{
+ readonly name: "_owner";
+ readonly type: "address";
+ }, {
+ readonly name: "_spender";
+ readonly type: "address";
+ }];
+ readonly name: "allowance";
+ readonly outputs: readonly [{
+ readonly name: "";
+ readonly type: "uint256";
+ }];
+ readonly payable: false;
+ readonly stateMutability: "view";
+ readonly type: "function";
+}, {
+ readonly payable: true;
+ readonly stateMutability: "payable";
+ readonly type: "fallback";
+}, {
+ readonly anonymous: false;
+ readonly inputs: readonly [{
+ readonly indexed: true;
+ readonly name: "owner";
+ readonly type: "address";
+ }, {
+ readonly indexed: true;
+ readonly name: "spender";
+ readonly type: "address";
+ }, {
+ readonly indexed: false;
+ readonly name: "value";
+ readonly type: "uint256";
+ }];
+ readonly name: "Approval";
+ readonly type: "event";
+}, {
+ readonly anonymous: false;
+ readonly inputs: readonly [{
+ readonly indexed: true;
+ readonly name: "from";
+ readonly type: "address";
+ }, {
+ readonly indexed: true;
+ readonly name: "to";
+ readonly type: "address";
+ }, {
+ readonly indexed: false;
+ readonly name: "value";
+ readonly type: "uint256";
+ }];
+ readonly name: "Transfer";
+ readonly type: "event";
+}];
diff --git a/dist/integration-tests/hooks.d.ts b/dist/integration-tests/hooks.d.ts
new file mode 100644
index 0000000..ee0d931
--- /dev/null
+++ b/dist/integration-tests/hooks.d.ts
@@ -0,0 +1,893 @@
+import { ChainId } from './consts';
+import { MulticallInfo } from '../src';
+import { PublicClient } from 'viem';
+export declare function useMulticallContract(chainId: ChainId): MulticallInfo;
+export declare function useLatestBlock(provider: PublicClient): number | undefined;
+export declare function useCurrentBlockTimestamp(chainId: ChainId, blockNumber: number | undefined): string | undefined;
+export declare function useCurrentBlockTimestampMultichain(chainIds: ChainId[], blockNumbers: Array): Array;
+export declare function useMaxTokenBalance(chainId: ChainId, blockNumber: number | undefined): string | undefined;
+export declare function getProvider(chainId: ChainId): any;
+export declare function getInfuraChainName(chainId: ChainId): "homestead" | "sepolia";
+export declare function getViemChain(chainId: ChainId): {
+ chain: {
+ blockExplorers: {
+ readonly default: {
+ readonly name: "Etherscan";
+ readonly url: "https://etherscan.io";
+ readonly apiUrl: "https://api.etherscan.io/api";
+ };
+ };
+ contracts: {
+ readonly ensRegistry: {
+ readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+ };
+ readonly ensUniversalResolver: {
+ readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+ readonly blockCreated: 19258213;
+ };
+ readonly multicall3: {
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+ readonly blockCreated: 14353601;
+ };
+ };
+ id: 1;
+ name: "Ethereum";
+ nativeCurrency: {
+ readonly name: "Ether";
+ readonly symbol: "ETH";
+ readonly decimals: 18;
+ };
+ rpcUrls: {
+ readonly default: {
+ readonly http: readonly ["https://cloudflare-eth.com"];
+ };
+ };
+ sourceId?: number | undefined;
+ testnet?: boolean | undefined;
+ custom?: Record | undefined;
+ fees?: import("viem").ChainFees | undefined;
+ formatters?: undefined;
+ serializers?: import("viem").ChainSerializers[] | undefined;
+ blobs?: readonly any[] | readonly Uint8Array[] | undefined;
+ blobVersionedHashes: readonly any[];
+ kzg?: undefined;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs: readonly any[] | readonly Uint8Array[];
+ blobVersionedHashes?: readonly any[] | undefined;
+ kzg: import("viem").Kzg;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs?: readonly any[] | readonly Uint8Array[] | undefined;
+ blobVersionedHashes: readonly any[];
+ kzg?: undefined;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs: readonly any[] | readonly Uint8Array[];
+ blobVersionedHashes?: readonly any[] | undefined;
+ kzg: import("viem").Kzg;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs?: readonly any[] | readonly Uint8Array[] | undefined;
+ blobVersionedHashes: readonly any[];
+ kzg?: undefined;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs: readonly any[] | readonly Uint8Array[];
+ blobVersionedHashes?: readonly any[] | undefined;
+ kzg: import("viem").Kzg;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip7702" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
+ chainId: number;
+ blobVersionedHashes?: undefined;
+ blobs?: undefined;
+ kzg?: undefined;
+ sidecars?: undefined;
+ } | {
+ type?: "eip7702" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
+ chainId: number;
+ blobVersionedHashes?: undefined;
+ blobs?: undefined;
+ kzg?: undefined;
+ sidecars?: undefined;
+ } | {
+ type?: "eip7702" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
+ chainId: number;
+ blobVersionedHashes?: undefined;
+ blobs?: undefined;
+ kzg?: undefined;
+ sidecars?: undefined;
+ }> | undefined;
+ };
+ transport: import("viem").Transport<"http", {
+ fetchOptions?: Pick | undefined;
+ url?: string | undefined;
+ }, import("viem").EIP1193RequestFn>;
+} | {
+ chain: {
+ blockExplorers: {
+ readonly default: {
+ readonly name: "Etherscan";
+ readonly url: "https://sepolia.etherscan.io";
+ readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+ };
+ };
+ contracts: {
+ readonly multicall3: {
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+ readonly blockCreated: 751532;
+ };
+ readonly ensRegistry: {
+ readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+ };
+ readonly ensUniversalResolver: {
+ readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
+ readonly blockCreated: 5317080;
+ };
+ };
+ id: 11155111;
+ name: "Sepolia";
+ nativeCurrency: {
+ readonly name: "Sepolia Ether";
+ readonly symbol: "ETH";
+ readonly decimals: 18;
+ };
+ rpcUrls: {
+ readonly default: {
+ readonly http: readonly ["https://rpc.sepolia.org"];
+ };
+ };
+ sourceId?: number | undefined;
+ testnet: true;
+ custom?: Record | undefined;
+ fees?: import("viem").ChainFees | undefined;
+ formatters?: undefined;
+ serializers?: import("viem").ChainSerializers[] | undefined;
+ blobs?: readonly any[] | readonly Uint8Array[] | undefined;
+ blobVersionedHashes: readonly any[];
+ kzg?: undefined;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs: readonly any[] | readonly Uint8Array[];
+ blobVersionedHashes?: readonly any[] | undefined;
+ kzg: import("viem").Kzg;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs?: readonly any[] | readonly Uint8Array[] | undefined;
+ blobVersionedHashes: readonly any[];
+ kzg?: undefined;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs: readonly any[] | readonly Uint8Array[];
+ blobVersionedHashes?: readonly any[] | undefined;
+ kzg: import("viem").Kzg;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs?: readonly any[] | readonly Uint8Array[] | undefined;
+ blobVersionedHashes: readonly any[];
+ kzg?: undefined;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip4844" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: bigint | undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ chainId: number;
+ sidecars?: false | readonly import("viem").BlobSidecar[] | undefined;
+ blobs: readonly any[] | readonly Uint8Array[];
+ blobVersionedHashes?: readonly any[] | undefined;
+ kzg: import("viem").Kzg;
+ authorizationList?: undefined;
+ } | {
+ type?: "eip7702" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
+ chainId: number;
+ blobVersionedHashes?: undefined;
+ blobs?: undefined;
+ kzg?: undefined;
+ sidecars?: undefined;
+ } | {
+ type?: "eip7702" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
+ chainId: number;
+ blobVersionedHashes?: undefined;
+ blobs?: undefined;
+ kzg?: undefined;
+ sidecars?: undefined;
+ } | {
+ type?: "eip7702" | undefined;
+ data?: any;
+ gas?: bigint | undefined;
+ nonce?: number | undefined;
+ to?: any;
+ value?: bigint | undefined;
+ r?: any;
+ s?: any;
+ v?: bigint | undefined;
+ yParity?: number | undefined;
+ gasPrice?: undefined;
+ maxFeePerBlobGas?: undefined;
+ maxFeePerGas?: bigint | undefined;
+ maxPriorityFeePerGas?: bigint | undefined;
+ accessList?: import("viem").AccessList | undefined;
+ authorizationList: import("viem/experimental").SignedAuthorizationList;
+ chainId: number;
+ blobVersionedHashes?: undefined;
+ blobs?: undefined;
+ kzg?: undefined;
+ sidecars?: undefined;
+ }> | undefined;
+ };
+ transport: import("viem").Transport<"http", {
+ fetchOptions?: Pick | undefined;
+ url?: string | undefined;
+ }, import("viem").EIP1193RequestFn>;
+};
diff --git a/dist/integration-tests/multicall.d.ts b/dist/integration-tests/multicall.d.ts
new file mode 100644
index 0000000..37d61b6
--- /dev/null
+++ b/dist/integration-tests/multicall.d.ts
@@ -0,0 +1,41 @@
+///
+export declare const multicall: {
+ reducerPath: string;
+ reducer: import("redux").Reducer;
+ actions: import("@reduxjs/toolkit").CaseReducerActions<{
+ addMulticallListeners: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("../src").MulticallListenerPayload;
+ type: string;
+ }) => void;
+ removeMulticallListeners: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("../src").MulticallListenerPayload;
+ type: string;
+ }) => void;
+ fetchingMulticallResults: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("../src").MulticallFetchingPayload;
+ type: string;
+ }) => void;
+ errorFetchingMulticallResults: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("../src").MulticallFetchingPayload;
+ type: string;
+ }) => void;
+ updateMulticallResults: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("../src").MulticallResultsPayload;
+ type: string;
+ }) => void;
+ updateListenerOptions: (state: import("immer/dist/internal").WritableDraft, action: {
+ payload: import("../src").MulticallListenerOptionsPayload;
+ type: string;
+ }) => void;
+ }, string>;
+ hooks: {
+ useMultipleContractSingleData: (chainId: number | undefined, latestBlockNumber: number | undefined, addresses: (string | undefined)[], contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => import("../src").CallState[];
+ useSingleContractMultipleData: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("../src").ContractInfo | null | undefined, methodName: string, callInputs: ((string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined)[], options?: Partial | undefined) => import("../src").CallState[];
+ useSingleContractWithCallData: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("../src").ContractInfo | null | undefined, callDatas: string[], options?: Partial | undefined) => import("../src").CallState[];
+ useSingleCallResult: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("../src").ContractInfo | null | undefined, methodName: string, inputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => import("../src").CallState;
+ useMultiChainMultiContractSingleData: (chainToBlockNumber: Record, chainToAddresses: Record, contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => Record;
+ useMultiChainSingleContractSingleData: (chainToBlockNumber: Record, chainToAddress: Record, contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => Record;
+ };
+ Updater: (props: Pick) => import("react").JSX.Element;
+};
+export declare const useMultipleContractSingleData: (chainId: number | undefined, latestBlockNumber: number | undefined, addresses: (string | undefined)[], contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => import("../src").CallState[], useSingleCallResult: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("../src").ContractInfo | null | undefined, methodName: string, inputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => import("../src").CallState, useSingleContractMultipleData: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("../src").ContractInfo | null | undefined, methodName: string, callInputs: ((string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined)[], options?: Partial | undefined) => import("../src").CallState[], useSingleContractWithCallData: (chainId: number | undefined, latestBlockNumber: number | undefined, contract: import("../src").ContractInfo | null | undefined, callDatas: string[], options?: Partial | undefined) => import("../src").CallState[], useMultiChainMultiContractSingleData: (chainToBlockNumber: Record, chainToAddresses: Record, contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => Record, useMultiChainSingleContractSingleData: (chainToBlockNumber: Record, chainToAddress: Record, contractInterface: import("abitype").AbiFunction[], methodName: string, callInputs?: (string | number | BigInt | import("../src/validation").MethodArg[] | undefined)[] | undefined, options?: Partial | undefined) => Record;
diff --git a/dist/integration-tests/store.d.ts b/dist/integration-tests/store.d.ts
new file mode 100644
index 0000000..4b95d6b
--- /dev/null
+++ b/dist/integration-tests/store.d.ts
@@ -0,0 +1,8 @@
+export declare const rootReducer: import("redux").Reducer, import("redux").AnyAction>;
+export declare const store: import("@reduxjs/toolkit/dist/configureStore").ToolkitStore, import("redux").AnyAction, [import("@reduxjs/toolkit").ThunkMiddleware, import("redux").AnyAction, undefined>]>;
diff --git a/dist/integration-tests/utils.d.ts b/dist/integration-tests/utils.d.ts
new file mode 100644
index 0000000..6b29a07
--- /dev/null
+++ b/dist/integration-tests/utils.d.ts
@@ -0,0 +1 @@
+export declare function sleep(milliseconds: number): Promise;
diff --git a/dist/redux-multicall-viem.cjs.development.js b/dist/redux-multicall-viem.cjs.development.js
new file mode 100644
index 0000000..9c4a64e
--- /dev/null
+++ b/dist/redux-multicall-viem.cjs.development.js
@@ -0,0 +1,1628 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var React = require('react');
+var React__default = _interopDefault(React);
+var reactRedux = require('react-redux');
+var viem = require('viem');
+var toolkit = require('@reduxjs/toolkit');
+
+var DEFAULT_BLOCKS_PER_FETCH = 1;
+var DEFAULT_CALL_GAS_REQUIRED = 1000000;
+var DEFAULT_CHUNK_GAS_REQUIRED = 200000;
+var CHUNK_GAS_LIMIT = 100000000;
+var CONSERVATIVE_BLOCK_GAS_LIMIT = 10000000; // conservative, hard-coded estimate of the current block gas limit
+// Consts for hooks
+var INVALID_RESULT = {
+ valid: false,
+ blockNumber: undefined,
+ data: undefined
+};
+var NEVER_RELOAD = {
+ blocksPerFetch: Infinity
+};
+var INVALID_CALL_STATE = {
+ valid: false,
+ result: undefined,
+ loading: false,
+ syncing: false,
+ error: false
+};
+var LOADING_CALL_STATE = {
+ valid: true,
+ result: undefined,
+ loading: true,
+ syncing: true,
+ error: false
+};
+
+function _arrayLikeToArray(r, a) {
+ (null == a || a > r.length) && (a = r.length);
+ for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+ return n;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+ try {
+ var i = n[a](c),
+ u = i.value;
+ } catch (n) {
+ return void e(n);
+ }
+ i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+ return function () {
+ var t = this,
+ e = arguments;
+ return new Promise(function (r, o) {
+ var a = n.apply(t, e);
+ function _next(n) {
+ asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+ }
+ function _throw(n) {
+ asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+ }
+ _next(void 0);
+ });
+ };
+}
+function _construct(t, e, r) {
+ if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+ var o = [null];
+ o.push.apply(o, e);
+ var p = new (t.bind.apply(t, o))();
+ return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+ var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+ if (t) return (t = t.call(r)).next.bind(t);
+ if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+ t && (r = t);
+ var o = 0;
+ return function () {
+ return o >= r.length ? {
+ done: !0
+ } : {
+ done: !1,
+ value: r[o++]
+ };
+ };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _extends() {
+ return _extends = Object.assign ? Object.assign.bind() : function (n) {
+ for (var e = 1; e < arguments.length; e++) {
+ var t = arguments[e];
+ for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+ }
+ return n;
+ }, _extends.apply(null, arguments);
+}
+function _getPrototypeOf(t) {
+ return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+ return t.__proto__ || Object.getPrototypeOf(t);
+ }, _getPrototypeOf(t);
+}
+function _inheritsLoose(t, o) {
+ t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _isNativeFunction(t) {
+ try {
+ return -1 !== Function.toString.call(t).indexOf("[native code]");
+ } catch (n) {
+ return "function" == typeof t;
+ }
+}
+function _isNativeReflectConstruct() {
+ try {
+ var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+ } catch (t) {}
+ return (_isNativeReflectConstruct = function () {
+ return !!t;
+ })();
+}
+function _regeneratorRuntime() {
+ _regeneratorRuntime = function () {
+ return e;
+ };
+ var t,
+ e = {},
+ r = Object.prototype,
+ n = r.hasOwnProperty,
+ o = Object.defineProperty || function (t, e, r) {
+ t[e] = r.value;
+ },
+ i = "function" == typeof Symbol ? Symbol : {},
+ a = i.iterator || "@@iterator",
+ c = i.asyncIterator || "@@asyncIterator",
+ u = i.toStringTag || "@@toStringTag";
+ function define(t, e, r) {
+ return Object.defineProperty(t, e, {
+ value: r,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }), t[e];
+ }
+ try {
+ define({}, "");
+ } catch (t) {
+ define = function (t, e, r) {
+ return t[e] = r;
+ };
+ }
+ function wrap(t, e, r, n) {
+ var i = e && e.prototype instanceof Generator ? e : Generator,
+ a = Object.create(i.prototype),
+ c = new Context(n || []);
+ return o(a, "_invoke", {
+ value: makeInvokeMethod(t, r, c)
+ }), a;
+ }
+ function tryCatch(t, e, r) {
+ try {
+ return {
+ type: "normal",
+ arg: t.call(e, r)
+ };
+ } catch (t) {
+ return {
+ type: "throw",
+ arg: t
+ };
+ }
+ }
+ e.wrap = wrap;
+ var h = "suspendedStart",
+ l = "suspendedYield",
+ f = "executing",
+ s = "completed",
+ y = {};
+ function Generator() {}
+ function GeneratorFunction() {}
+ function GeneratorFunctionPrototype() {}
+ var p = {};
+ define(p, a, function () {
+ return this;
+ });
+ var d = Object.getPrototypeOf,
+ v = d && d(d(values([])));
+ v && v !== r && n.call(v, a) && (p = v);
+ var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+ function defineIteratorMethods(t) {
+ ["next", "throw", "return"].forEach(function (e) {
+ define(t, e, function (t) {
+ return this._invoke(e, t);
+ });
+ });
+ }
+ function AsyncIterator(t, e) {
+ function invoke(r, o, i, a) {
+ var c = tryCatch(t[r], t, o);
+ if ("throw" !== c.type) {
+ var u = c.arg,
+ h = u.value;
+ return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+ invoke("next", t, i, a);
+ }, function (t) {
+ invoke("throw", t, i, a);
+ }) : e.resolve(h).then(function (t) {
+ u.value = t, i(u);
+ }, function (t) {
+ return invoke("throw", t, i, a);
+ });
+ }
+ a(c.arg);
+ }
+ var r;
+ o(this, "_invoke", {
+ value: function (t, n) {
+ function callInvokeWithMethodAndArg() {
+ return new e(function (e, r) {
+ invoke(t, n, e, r);
+ });
+ }
+ return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+ }
+ });
+ }
+ function makeInvokeMethod(e, r, n) {
+ var o = h;
+ return function (i, a) {
+ if (o === f) throw Error("Generator is already running");
+ if (o === s) {
+ if ("throw" === i) throw a;
+ return {
+ value: t,
+ done: !0
+ };
+ }
+ for (n.method = i, n.arg = a;;) {
+ var c = n.delegate;
+ if (c) {
+ var u = maybeInvokeDelegate(c, n);
+ if (u) {
+ if (u === y) continue;
+ return u;
+ }
+ }
+ if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+ if (o === h) throw o = s, n.arg;
+ n.dispatchException(n.arg);
+ } else "return" === n.method && n.abrupt("return", n.arg);
+ o = f;
+ var p = tryCatch(e, r, n);
+ if ("normal" === p.type) {
+ if (o = n.done ? s : l, p.arg === y) continue;
+ return {
+ value: p.arg,
+ done: n.done
+ };
+ }
+ "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+ }
+ };
+ }
+ function maybeInvokeDelegate(e, r) {
+ var n = r.method,
+ o = e.iterator[n];
+ if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+ var i = tryCatch(o, e.iterator, r.arg);
+ if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+ var a = i.arg;
+ return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+ }
+ function pushTryEntry(t) {
+ var e = {
+ tryLoc: t[0]
+ };
+ 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+ }
+ function resetTryEntry(t) {
+ var e = t.completion || {};
+ e.type = "normal", delete e.arg, t.completion = e;
+ }
+ function Context(t) {
+ this.tryEntries = [{
+ tryLoc: "root"
+ }], t.forEach(pushTryEntry, this), this.reset(!0);
+ }
+ function values(e) {
+ if (e || "" === e) {
+ var r = e[a];
+ if (r) return r.call(e);
+ if ("function" == typeof e.next) return e;
+ if (!isNaN(e.length)) {
+ var o = -1,
+ i = function next() {
+ for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+ return next.value = t, next.done = !0, next;
+ };
+ return i.next = i;
+ }
+ }
+ throw new TypeError(typeof e + " is not iterable");
+ }
+ return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+ value: GeneratorFunctionPrototype,
+ configurable: !0
+ }), o(GeneratorFunctionPrototype, "constructor", {
+ value: GeneratorFunction,
+ configurable: !0
+ }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+ var e = "function" == typeof t && t.constructor;
+ return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+ }, e.mark = function (t) {
+ return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+ }, e.awrap = function (t) {
+ return {
+ __await: t
+ };
+ }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+ return this;
+ }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+ void 0 === i && (i = Promise);
+ var a = new AsyncIterator(wrap(t, r, n, o), i);
+ return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+ return t.done ? t.value : a.next();
+ });
+ }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+ return this;
+ }), define(g, "toString", function () {
+ return "[object Generator]";
+ }), e.keys = function (t) {
+ var e = Object(t),
+ r = [];
+ for (var n in e) r.push(n);
+ return r.reverse(), function next() {
+ for (; r.length;) {
+ var t = r.pop();
+ if (t in e) return next.value = t, next.done = !1, next;
+ }
+ return next.done = !0, next;
+ };
+ }, e.values = values, Context.prototype = {
+ constructor: Context,
+ reset: function (e) {
+ if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+ },
+ stop: function () {
+ this.done = !0;
+ var t = this.tryEntries[0].completion;
+ if ("throw" === t.type) throw t.arg;
+ return this.rval;
+ },
+ dispatchException: function (e) {
+ if (this.done) throw e;
+ var r = this;
+ function handle(n, o) {
+ return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+ }
+ for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+ var i = this.tryEntries[o],
+ a = i.completion;
+ if ("root" === i.tryLoc) return handle("end");
+ if (i.tryLoc <= this.prev) {
+ var c = n.call(i, "catchLoc"),
+ u = n.call(i, "finallyLoc");
+ if (c && u) {
+ if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+ if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+ } else if (c) {
+ if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+ } else {
+ if (!u) throw Error("try statement without catch or finally");
+ if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+ }
+ }
+ }
+ },
+ abrupt: function (t, e) {
+ for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+ var o = this.tryEntries[r];
+ if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+ var i = o;
+ break;
+ }
+ }
+ i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+ var a = i ? i.completion : {};
+ return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+ },
+ complete: function (t, e) {
+ if ("throw" === t.type) throw t.arg;
+ return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+ },
+ finish: function (t) {
+ for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+ var r = this.tryEntries[e];
+ if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+ }
+ },
+ catch: function (t) {
+ for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+ var r = this.tryEntries[e];
+ if (r.tryLoc === t) {
+ var n = r.completion;
+ if ("throw" === n.type) {
+ var o = n.arg;
+ resetTryEntry(r);
+ }
+ return o;
+ }
+ }
+ throw Error("illegal catch attempt");
+ },
+ delegateYield: function (e, r, n) {
+ return this.delegate = {
+ iterator: values(e),
+ resultName: r,
+ nextLoc: n
+ }, "next" === this.method && (this.arg = t), y;
+ }
+ }, e;
+}
+function _setPrototypeOf(t, e) {
+ return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+ return t.__proto__ = e, t;
+ }, _setPrototypeOf(t, e);
+}
+function _unsupportedIterableToArray(r, a) {
+ if (r) {
+ if ("string" == typeof r) return _arrayLikeToArray(r, a);
+ var t = {}.toString.call(r).slice(8, -1);
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+ }
+}
+function _wrapNativeSuper(t) {
+ var r = "function" == typeof Map ? new Map() : void 0;
+ return _wrapNativeSuper = function (t) {
+ if (null === t || !_isNativeFunction(t)) return t;
+ if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+ if (void 0 !== r) {
+ if (r.has(t)) return r.get(t);
+ r.set(t, Wrapper);
+ }
+ function Wrapper() {
+ return _construct(t, arguments, _getPrototypeOf(this).constructor);
+ }
+ return Wrapper.prototype = Object.create(t.prototype, {
+ constructor: {
+ value: Wrapper,
+ enumerable: !1,
+ writable: !0,
+ configurable: !0
+ }
+ }), _setPrototypeOf(Wrapper, t);
+ }, _wrapNativeSuper(t);
+}
+
+function toCallKey(call) {
+ var key = call.address + "-" + call.callData;
+ if (call.gasRequired) {
+ if (!Number.isSafeInteger(call.gasRequired)) {
+ throw new Error("Invalid number: " + call.gasRequired);
+ }
+ key += "-" + call.gasRequired;
+ }
+ return key;
+}
+function parseCallKey(callKey) {
+ var pcs = callKey.split('-');
+ if (![2, 3].includes(pcs.length)) {
+ throw new Error("Invalid call key: " + callKey);
+ }
+ return _extends({
+ address: pcs[0],
+ callData: pcs[1]
+ }, pcs[2] ? {
+ gasRequired: Number.parseInt(pcs[2])
+ } : {});
+}
+function callsToCallKeys(calls) {
+ var _calls$filter$map$sor, _calls$filter;
+ return (_calls$filter$map$sor = calls == null || (_calls$filter = calls.filter(function (c) {
+ return Boolean(c);
+ })) == null || (_calls$filter = _calls$filter.map(toCallKey)) == null ? void 0 : _calls$filter.sort()) != null ? _calls$filter$map$sor : [];
+}
+function callKeysToCalls(callKeys) {
+ if (!(callKeys != null && callKeys.length)) return null;
+ return callKeys.map(function (key) {
+ return parseCallKey(key);
+ });
+}
+
+// Converts CallResult[] to CallState[], only updating if call states have changed.
+// Ensures that CallState results remain referentially stable when unchanged, preventing
+// spurious re-renders which would otherwise occur because mapping always creates a new object.
+function useCallStates(results, contractInterface, fragment, latestBlockNumber) {
+ // Avoid refreshing the results with every changing block number (eg latestBlockNumber).
+ // Instead, only refresh the results if they need to be synced - if there is a result which is stale, for which blockNumber < latestBlockNumber.
+ var syncingBlockNumber = React.useMemo(function () {
+ var lowestBlockNumber = results.reduce(function (memo, result) {
+ return result.blockNumber ? Math.min(memo != null ? memo : result.blockNumber, result.blockNumber) : memo;
+ }, undefined);
+ return Math.max(lowestBlockNumber != null ? lowestBlockNumber : 0, latestBlockNumber != null ? latestBlockNumber : 0);
+ }, [results, latestBlockNumber]);
+ return React.useMemo(function () {
+ return results.map(function (result, i) {
+ var resultFragment = typeof fragment === 'function' ? fragment(i) : fragment;
+ return toCallState(result, contractInterface, resultFragment, syncingBlockNumber);
+ });
+ }, [contractInterface, fragment, results, syncingBlockNumber]);
+}
+function toCallState(callResult, contractInterface, fragment, syncingBlockNumber) {
+ if (!callResult || !callResult.valid) {
+ return INVALID_CALL_STATE;
+ }
+ var data = callResult.data,
+ blockNumber = callResult.blockNumber;
+ if (!blockNumber || !contractInterface || !fragment || !syncingBlockNumber) {
+ return LOADING_CALL_STATE;
+ }
+ var success = data && data.length > 2;
+ var syncing = blockNumber < syncingBlockNumber;
+ var result = undefined;
+ if (success && data) {
+ try {
+ result = viem.decodeFunctionResult({
+ abi: contractInterface,
+ functionName: fragment,
+ data: data
+ });
+ } catch (error) {
+ console.debug('Result data parsing failed', fragment, data);
+ return {
+ valid: true,
+ loading: false,
+ error: true,
+ syncing: syncing,
+ result: result
+ };
+ }
+ }
+ return {
+ valid: true,
+ loading: false,
+ syncing: syncing,
+ result: result,
+ error: !success
+ };
+}
+
+function isMethodArg(x) {
+ return x === null || x === undefined ? false : typeof BigInt(x) === 'bigint' || ['string', 'number'].indexOf(typeof x) !== -1;
+}
+function isValidMethodArgs(x) {
+ return x === undefined || Array.isArray(x) && x.every(function (xi) {
+ return isMethodArg(xi) || Array.isArray(xi) && xi.every(isMethodArg);
+ });
+}
+
+// the lowest level call for subscribing to contract data
+function useCallsDataSubscription(context, chainId, calls, listenerOptions) {
+ var reducerPath = context.reducerPath,
+ actions = context.actions;
+ var callResults = reactRedux.useSelector(function (state) {
+ return state[reducerPath].callResults;
+ });
+ var defaultListenerOptions = reactRedux.useSelector(function (state) {
+ return state[reducerPath].listenerOptions;
+ });
+ var dispatch = reactRedux.useDispatch();
+ var serializedCallKeys = React.useMemo(function () {
+ return JSON.stringify(callsToCallKeys(calls));
+ }, [calls]);
+ // update listeners when there is an actual change that persists for at least 100ms
+ React.useEffect(function () {
+ var _chainId, _ref, _listenerOptions$bloc;
+ var callKeys = JSON.parse(serializedCallKeys);
+ var calls = callKeysToCalls(callKeys);
+ if (!chainId || !calls) return;
+ var blocksPerFetchFromState = (_chainId = (defaultListenerOptions != null ? defaultListenerOptions : {})[chainId]) == null ? void 0 : _chainId.blocksPerFetch;
+ var blocksPerFetchForChain = (_ref = (_listenerOptions$bloc = listenerOptions == null ? void 0 : listenerOptions.blocksPerFetch) != null ? _listenerOptions$bloc : blocksPerFetchFromState) != null ? _ref : DEFAULT_BLOCKS_PER_FETCH;
+ dispatch(actions.addMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ return function () {
+ dispatch(actions.removeMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ };
+ }, [actions, chainId, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions]);
+ var lastResults = React.useRef([]);
+ return React.useMemo(function () {
+ var isChanged = lastResults.current.length !== calls.length;
+ // Construct results using a for-loop to handle sparse arrays.
+ // Array.prototype.map would skip empty entries.
+ var results = [];
+ for (var i = 0; i < calls.length; ++i) {
+ var call = calls[i];
+ var result = INVALID_RESULT;
+ if (chainId && call) {
+ var _callResults$chainId;
+ var callResult = (_callResults$chainId = callResults[chainId]) == null ? void 0 : _callResults$chainId[toCallKey(call)];
+ result = {
+ valid: true,
+ data: callResult != null && callResult.data && callResult.data !== '0x' ? callResult.data : undefined,
+ blockNumber: callResult == null ? void 0 : callResult.blockNumber
+ };
+ }
+ isChanged = isChanged || !areCallResultsEqual(result, lastResults.current[i]);
+ results.push(result);
+ }
+ // Force the results to be referentially stable if they have not changed.
+ // This is necessary because *all* callResults are passed as deps when initially memoizing the results.
+ if (isChanged) {
+ lastResults.current = results;
+ }
+ return lastResults.current;
+ }, [callResults, calls, chainId]);
+}
+function areCallResultsEqual(a, b) {
+ return a.valid === b.valid && a.data === b.data && a.blockNumber === b.blockNumber;
+}
+// Similar to useCallsDataSubscription above but for subscribing to
+// calls to multiple chains at once
+function useMultichainCallsDataSubscription(context, chainToCalls, listenerOptions) {
+ var reducerPath = context.reducerPath,
+ actions = context.actions;
+ var callResults = reactRedux.useSelector(function (state) {
+ return state[reducerPath].callResults;
+ });
+ var defaultListenerOptions = reactRedux.useSelector(function (state) {
+ return state[reducerPath].listenerOptions;
+ });
+ var dispatch = reactRedux.useDispatch();
+ var serializedCallKeys = React.useMemo(function () {
+ var sortedChainIds = getChainIds(chainToCalls).sort();
+ var chainCallKeysTuple = sortedChainIds.map(function (chainId) {
+ var calls = chainToCalls[chainId];
+ var callKeys = callsToCallKeys(calls);
+ // Note, using a tuple to ensure consistent order when serialized
+ return [chainId, callKeys];
+ });
+ return JSON.stringify(chainCallKeysTuple);
+ }, [chainToCalls]);
+ React.useEffect(function () {
+ var chainCallKeysTuples = JSON.parse(serializedCallKeys);
+ if (!(chainCallKeysTuples != null && chainCallKeysTuples.length)) return;
+ reactRedux.batch(function () {
+ for (var _iterator = _createForOfIteratorHelperLoose(chainCallKeysTuples), _step; !(_step = _iterator()).done;) {
+ var _chainId2, _ref2, _listenerOptions$bloc2;
+ var _step$value = _step.value,
+ chainId = _step$value[0],
+ callKeys = _step$value[1];
+ var calls = callKeysToCalls(callKeys);
+ if (!(calls != null && calls.length)) continue;
+ var blocksPerFetchFromState = (_chainId2 = (defaultListenerOptions != null ? defaultListenerOptions : {})[chainId]) == null ? void 0 : _chainId2.blocksPerFetch;
+ var blocksPerFetchForChain = (_ref2 = (_listenerOptions$bloc2 = listenerOptions == null ? void 0 : listenerOptions.blocksPerFetch) != null ? _listenerOptions$bloc2 : blocksPerFetchFromState) != null ? _ref2 : DEFAULT_BLOCKS_PER_FETCH;
+ dispatch(actions.addMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ }
+ });
+ return function () {
+ reactRedux.batch(function () {
+ for (var _iterator2 = _createForOfIteratorHelperLoose(chainCallKeysTuples), _step2; !(_step2 = _iterator2()).done;) {
+ var _chainId3, _ref3, _listenerOptions$bloc3;
+ var _step2$value = _step2.value,
+ chainId = _step2$value[0],
+ callKeys = _step2$value[1];
+ var calls = callKeysToCalls(callKeys);
+ if (!(calls != null && calls.length)) continue;
+ var blocksPerFetchFromState = (_chainId3 = (defaultListenerOptions != null ? defaultListenerOptions : {})[chainId]) == null ? void 0 : _chainId3.blocksPerFetch;
+ var blocksPerFetchForChain = (_ref3 = (_listenerOptions$bloc3 = listenerOptions == null ? void 0 : listenerOptions.blocksPerFetch) != null ? _listenerOptions$bloc3 : blocksPerFetchFromState) != null ? _ref3 : DEFAULT_BLOCKS_PER_FETCH;
+ dispatch(actions.removeMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ }
+ });
+ };
+ }, [actions, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions]);
+ return React.useMemo(function () {
+ return getChainIds(chainToCalls).reduce(function (result, chainId) {
+ var calls = chainToCalls[chainId];
+ result[chainId] = calls.map(function (call) {
+ var _callResults$chainId2;
+ if (!chainId || !call) return INVALID_RESULT;
+ var result = (_callResults$chainId2 = callResults[chainId]) == null ? void 0 : _callResults$chainId2[toCallKey(call)];
+ var data = result != null && result.data && result.data !== '0x' ? result.data : undefined;
+ return {
+ valid: true,
+ data: data,
+ blockNumber: result == null ? void 0 : result.blockNumber
+ };
+ });
+ return result;
+ }, {});
+ }, [callResults, chainToCalls]);
+}
+// formats many calls to a single function on a single contract, with the function name and inputs specified
+function useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options) {
+ var _ref4 = options != null ? options : {},
+ gasRequired = _ref4.gasRequired;
+ // Create ethers function fragment
+ var fragment = React.useMemo(function () {
+ var _getAbiItem;
+ return contract && ((_getAbiItem = viem.getAbiItem({
+ abi: contract.abi,
+ name: methodName
+ })) == null ? void 0 : _getAbiItem.name);
+ }, [contract, methodName]);
+ // Get encoded call data. Note can't use useCallData below b.c. this is for a list of CallInputs
+ var callDatas = React.useMemo(function () {
+ if (!contract || !fragment) return [];
+ return callInputs.map(function (callInput) {
+ return isValidMethodArgs(callInput) ? viem.encodeFunctionData({
+ abi: contract.abi,
+ functionName: fragment,
+ args: callInput
+ }) : undefined;
+ });
+ }, [callInputs, contract, fragment]);
+ // Create call objects
+ var calls = React.useMemo(function () {
+ if (!contract) return [];
+ return callDatas.map(function (callData) {
+ if (!callData) return undefined;
+ return {
+ address: contract.address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ }, [contract, callDatas, gasRequired]);
+ // Subscribe to call data
+ var results = useCallsDataSubscription(context, chainId, calls, options);
+ return useCallStates(results, contract == null ? void 0 : contract.abi, fragment, latestBlockNumber);
+}
+function useMultipleContractSingleData(context, chainId, latestBlockNumber, addresses, contractInterface, methodName, callInputs, options) {
+ var _ref5 = options != null ? options : {},
+ gasRequired = _ref5.gasRequired;
+ var _useCallData = useCallData(methodName, contractInterface, callInputs),
+ fragment = _useCallData.fragment,
+ callData = _useCallData.callData;
+ // Create call objects
+ var calls = React.useMemo(function () {
+ if (!callData) return [];
+ return addresses.map(function (address) {
+ if (!address) return undefined;
+ return {
+ address: address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ }, [addresses, callData, gasRequired]);
+ // Subscribe to call data
+ var results = useCallsDataSubscription(context, chainId, calls, options);
+ return useCallStates(results, contractInterface, fragment, latestBlockNumber);
+}
+function useSingleCallResult(context, chainId, latestBlockNumber, contract, methodName, inputs, options) {
+ var _useSingleContractMul;
+ var callInputs = React.useMemo(function () {
+ return [inputs];
+ }, [inputs]);
+ return (_useSingleContractMul = useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options)[0]) != null ? _useSingleContractMul : INVALID_CALL_STATE;
+}
+// formats many calls to any number of functions on a single contract, with only the calldata specified
+function useSingleContractWithCallData(context, chainId, latestBlockNumber, contract, callDatas, options) {
+ var _ref6 = options != null ? options : {},
+ gasRequired = _ref6.gasRequired;
+ // Create call objects
+ var calls = React.useMemo(function () {
+ if (!contract) return [];
+ return callDatas.map(function (callData) {
+ return {
+ address: contract.address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ }, [callDatas, contract, gasRequired]);
+ // Subscribe to call data
+ var results = useCallsDataSubscription(context, chainId, calls, options);
+ var fragment = React.useCallback(function (i) {
+ var _getAbiItem2;
+ return (_getAbiItem2 = viem.getAbiItem({
+ abi: contract == null ? void 0 : contract.abi,
+ name: callDatas[i].substring(0, 10)
+ })) == null ? void 0 : _getAbiItem2.name;
+ }, [callDatas, contract]);
+ return useCallStates(results, contract == null ? void 0 : contract.abi, fragment, latestBlockNumber);
+}
+// Similar to useMultipleContractSingleData but instead of multiple contracts on one chain,
+// this is for querying compatible contracts on multiple chains
+function useMultiChainMultiContractSingleData(context, chainToBlockNumber, chainToAddresses, contractInterface, methodName, callInputs, options) {
+ var _ref7 = options != null ? options : {},
+ gasRequired = _ref7.gasRequired;
+ var _useCallData2 = useCallData(methodName, contractInterface, callInputs),
+ fragment = _useCallData2.fragment,
+ callData = _useCallData2.callData;
+ // Create call objects
+ var chainToCalls = React.useMemo(function () {
+ if (!callData || !chainToAddresses) return {};
+ return getChainIds(chainToAddresses).reduce(function (result, chainId) {
+ var addresses = chainToAddresses[chainId];
+ var calls = addresses.map(function (address) {
+ if (!address) return undefined;
+ return {
+ address: address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ result[chainId] = calls;
+ return result;
+ }, {});
+ }, [chainToAddresses, callData, gasRequired]);
+ // Subscribe to call data
+ var chainIdToResults = useMultichainCallsDataSubscription(context, chainToCalls, options);
+ // TODO(WEB-2097): Multichain states are not referentially stable, because they cannot use the
+ // same codepath (eg useCallStates).
+ return React.useMemo(function () {
+ return getChainIds(chainIdToResults).reduce(function (combinedResults, chainId) {
+ var latestBlockNumber = chainToBlockNumber == null ? void 0 : chainToBlockNumber[chainId];
+ var results = chainIdToResults[chainId];
+ combinedResults[chainId] = results.map(function (result) {
+ return toCallState(result, contractInterface, fragment, latestBlockNumber);
+ });
+ return combinedResults;
+ }, {});
+ }, [fragment, contractInterface, chainIdToResults, chainToBlockNumber]);
+}
+// Similar to useSingleCallResult but instead of one contract on one chain,
+// this is for querying a contract on multiple chains
+function useMultiChainSingleContractSingleData(context, chainToBlockNumber, chainToAddress, contractInterface, methodName, callInputs, options) {
+ // This hook uses the more flexible useMultiChainMultiContractSingleData internally,
+ // but transforms the inputs and outputs for convenience
+ var chainIdToAddresses = React.useMemo(function () {
+ return getChainIds(chainToAddress).reduce(function (result, chainId) {
+ result[chainId] = [chainToAddress[chainId]];
+ return result;
+ }, {});
+ }, [chainToAddress]);
+ var multiContractResults = useMultiChainMultiContractSingleData(context, chainToBlockNumber, chainIdToAddresses, contractInterface, methodName, callInputs, options);
+ return React.useMemo(function () {
+ return getChainIds(chainToAddress).reduce(function (result, chainId) {
+ var _multiContractResults, _multiContractResults2;
+ result[chainId] = (_multiContractResults = (_multiContractResults2 = multiContractResults[chainId]) == null ? void 0 : _multiContractResults2[0]) != null ? _multiContractResults : INVALID_CALL_STATE;
+ return result;
+ }, {});
+ }, [chainToAddress, multiContractResults]);
+}
+function useCallData(methodName, contractInterface, callInputs) {
+ // Create ethers function fragment
+ var fragment = React.useMemo(function () {
+ var _getAbiItem3;
+ return contractInterface && ((_getAbiItem3 = viem.getAbiItem({
+ abi: contractInterface,
+ name: methodName
+ })) == null ? void 0 : _getAbiItem3.name);
+ }, [contractInterface, methodName]);
+ // Get encoded call data
+ var callData = React.useMemo(function () {
+ return fragment && isValidMethodArgs(callInputs) ? viem.encodeFunctionData({
+ abi: contractInterface,
+ functionName: fragment,
+ args: callInputs
+ }) : undefined;
+ }, [callInputs, contractInterface, fragment]);
+ return {
+ fragment: fragment,
+ callData: callData
+ };
+}
+function getChainIds(chainIdMap) {
+ return Object.keys(chainIdMap).map(function (c) {
+ return parseInt(c, 10);
+ });
+}
+
+var initialState = {
+ callResults: {}
+};
+function createMulticallSlice(reducerPath) {
+ return toolkit.createSlice({
+ name: reducerPath,
+ initialState: initialState,
+ reducers: {
+ addMulticallListeners: function addMulticallListeners(state, action) {
+ var _listeners$chainId;
+ var _action$payload = action.payload,
+ calls = _action$payload.calls,
+ chainId = _action$payload.chainId,
+ blocksPerFetch = _action$payload.options.blocksPerFetch;
+ var listeners = state.callListeners ? state.callListeners : state.callListeners = {};
+ listeners[chainId] = (_listeners$chainId = listeners[chainId]) != null ? _listeners$chainId : {};
+ calls.forEach(function (call) {
+ var _listeners$chainId$ca, _listeners$chainId$ca2;
+ var callKey = toCallKey(call);
+ listeners[chainId][callKey] = (_listeners$chainId$ca = listeners[chainId][callKey]) != null ? _listeners$chainId$ca : {};
+ listeners[chainId][callKey][blocksPerFetch] = ((_listeners$chainId$ca2 = listeners[chainId][callKey][blocksPerFetch]) != null ? _listeners$chainId$ca2 : 0) + 1;
+ });
+ },
+ removeMulticallListeners: function removeMulticallListeners(state, action) {
+ var _action$payload2 = action.payload,
+ calls = _action$payload2.calls,
+ chainId = _action$payload2.chainId,
+ blocksPerFetch = _action$payload2.options.blocksPerFetch;
+ var listeners = state.callListeners ? state.callListeners : state.callListeners = {};
+ if (!listeners[chainId]) return;
+ calls.forEach(function (call) {
+ var callKey = toCallKey(call);
+ if (!listeners[chainId][callKey]) return;
+ if (!listeners[chainId][callKey][blocksPerFetch]) return;
+ if (listeners[chainId][callKey][blocksPerFetch] === 1) {
+ delete listeners[chainId][callKey][blocksPerFetch];
+ } else {
+ listeners[chainId][callKey][blocksPerFetch]--;
+ }
+ });
+ },
+ fetchingMulticallResults: function fetchingMulticallResults(state, action) {
+ var _state$callResults$ch;
+ var _action$payload3 = action.payload,
+ chainId = _action$payload3.chainId,
+ fetchingBlockNumber = _action$payload3.fetchingBlockNumber,
+ calls = _action$payload3.calls;
+ state.callResults[chainId] = (_state$callResults$ch = state.callResults[chainId]) != null ? _state$callResults$ch : {};
+ calls.forEach(function (call) {
+ var callKey = toCallKey(call);
+ var current = state.callResults[chainId][callKey];
+ if (!current) {
+ state.callResults[chainId][callKey] = {
+ fetchingBlockNumber: fetchingBlockNumber
+ };
+ } else {
+ var _current$fetchingBloc;
+ if (((_current$fetchingBloc = current.fetchingBlockNumber) != null ? _current$fetchingBloc : 0) >= fetchingBlockNumber) return;
+ state.callResults[chainId][callKey].fetchingBlockNumber = fetchingBlockNumber;
+ }
+ });
+ },
+ errorFetchingMulticallResults: function errorFetchingMulticallResults(state, action) {
+ var _state$callResults$ch2;
+ var _action$payload4 = action.payload,
+ chainId = _action$payload4.chainId,
+ fetchingBlockNumber = _action$payload4.fetchingBlockNumber,
+ calls = _action$payload4.calls;
+ state.callResults[chainId] = (_state$callResults$ch2 = state.callResults[chainId]) != null ? _state$callResults$ch2 : {};
+ calls.forEach(function (call) {
+ var callKey = toCallKey(call);
+ var current = state.callResults[chainId][callKey];
+ if (!current || typeof current.fetchingBlockNumber !== 'number') return; // only should be dispatched if we are already fetching
+ if (current.fetchingBlockNumber <= fetchingBlockNumber) {
+ delete current.fetchingBlockNumber;
+ current.data = null;
+ current.blockNumber = fetchingBlockNumber;
+ }
+ });
+ },
+ updateMulticallResults: function updateMulticallResults(state, action) {
+ var _state$callResults$ch3;
+ var _action$payload5 = action.payload,
+ chainId = _action$payload5.chainId,
+ results = _action$payload5.results,
+ blockNumber = _action$payload5.blockNumber;
+ state.callResults[chainId] = (_state$callResults$ch3 = state.callResults[chainId]) != null ? _state$callResults$ch3 : {};
+ Object.keys(results).forEach(function (callKey) {
+ var _current$blockNumber;
+ var current = state.callResults[chainId][callKey];
+ if (((_current$blockNumber = current == null ? void 0 : current.blockNumber) != null ? _current$blockNumber : 0) > blockNumber) return;
+ if ((current == null ? void 0 : current.data) === results[callKey] && (current == null ? void 0 : current.blockNumber) === blockNumber) return;
+ state.callResults[chainId][callKey] = {
+ data: results[callKey],
+ blockNumber: blockNumber
+ };
+ });
+ },
+ updateListenerOptions: function updateListenerOptions(state, action) {
+ var _state$listenerOption;
+ var _action$payload6 = action.payload,
+ chainId = _action$payload6.chainId,
+ listenerOptions = _action$payload6.listenerOptions;
+ state.listenerOptions = (_state$listenerOption = state.listenerOptions) != null ? _state$listenerOption : {};
+ state.listenerOptions[chainId] = listenerOptions;
+ }
+ }
+ });
+}
+
+/**
+ * Tries to pack a list of items into as few bins as possible using the first-fit bin packing algorithm
+ * @param calls the calls to chunk
+ * @param chunkGasLimit the gas limit of any one chunk of calls, i.e. bin capacity
+ * @param defaultGasRequired the default amount of gas an individual call should cost if not specified
+ */
+function chunkCalls(calls, chunkGasLimit, defaultGasRequired) {
+ if (defaultGasRequired === void 0) {
+ defaultGasRequired = DEFAULT_CHUNK_GAS_REQUIRED;
+ }
+ return calls
+ // first sort by gas required
+ .sort(function (c1, c2) {
+ var _c2$gasRequired, _c1$gasRequired;
+ return ((_c2$gasRequired = c2.gasRequired) != null ? _c2$gasRequired : defaultGasRequired) - ((_c1$gasRequired = c1.gasRequired) != null ? _c1$gasRequired : defaultGasRequired);
+ })
+ // then bin the calls according to the first fit algorithm
+ .reduce(function (bins, call) {
+ var _call$gasRequired;
+ var gas = (_call$gasRequired = call.gasRequired) != null ? _call$gasRequired : defaultGasRequired;
+ for (var _iterator = _createForOfIteratorHelperLoose(bins), _step; !(_step = _iterator()).done;) {
+ var bin = _step.value;
+ if (bin.cumulativeGasLimit + gas <= chunkGasLimit) {
+ bin.calls.push(call);
+ bin.cumulativeGasLimit += gas;
+ return bins;
+ }
+ }
+ // didn't find a bin for the call, make a new bin
+ bins.push({
+ calls: [call],
+ cumulativeGasLimit: gas
+ });
+ return bins;
+ }, [])
+ // pull out just the calls from each bin
+ .map(function (b) {
+ return b.calls;
+ });
+}
+
+// TODO de-duplicate this file with web interface
+// https://github.com/Uniswap/interface/blob/main/src/utils/retry.ts
+function wait(ms) {
+ return new Promise(function (resolve) {
+ return setTimeout(resolve, ms);
+ });
+}
+function waitRandom(min, max) {
+ return wait(min + Math.round(Math.random() * Math.max(0, max - min)));
+}
+/**
+ * This error is thrown if the function is cancelled before completing
+ */
+var CancelledError = /*#__PURE__*/function (_Error) {
+ function CancelledError() {
+ var _this;
+ _this = _Error.call(this, 'Cancelled') || this;
+ _this.isCancelledError = true;
+ return _this;
+ }
+ _inheritsLoose(CancelledError, _Error);
+ return CancelledError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * Throw this error if the function should retry
+ */
+var RetryableError = /*#__PURE__*/function (_Error2) {
+ function RetryableError() {
+ var _this2;
+ _this2 = _Error2.apply(this, arguments) || this;
+ _this2.isRetryableError = true;
+ return _this2;
+ }
+ _inheritsLoose(RetryableError, _Error2);
+ return RetryableError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * Retries the function that returns the promise until the promise successfully resolves up to n retries
+ * @param fn function to retry
+ * @param n how many times to retry
+ * @param minWait min wait between retries in ms
+ * @param maxWait max wait between retries in ms
+ */
+function retry(fn, _ref) {
+ var n = _ref.n,
+ minWait = _ref.minWait,
+ maxWait = _ref.maxWait;
+ var completed = false;
+ var rejectCancelled;
+ var promise = new Promise( /*#__PURE__*/function () {
+ var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(resolve, reject) {
+ var result;
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
+ while (1) switch (_context.prev = _context.next) {
+ case 0:
+ rejectCancelled = reject;
+ case 1:
+ result = void 0;
+ _context.prev = 3;
+ _context.next = 6;
+ return fn();
+ case 6:
+ result = _context.sent;
+ if (!completed) {
+ resolve(result);
+ completed = true;
+ }
+ return _context.abrupt("break", 24);
+ case 11:
+ _context.prev = 11;
+ _context.t0 = _context["catch"](3);
+ if (!completed) {
+ _context.next = 15;
+ break;
+ }
+ return _context.abrupt("break", 24);
+ case 15:
+ if (!(n <= 0 || !_context.t0.isRetryableError)) {
+ _context.next = 19;
+ break;
+ }
+ reject(_context.t0);
+ completed = true;
+ return _context.abrupt("break", 24);
+ case 19:
+ n--;
+ case 20:
+ _context.next = 22;
+ return waitRandom(minWait, maxWait);
+ case 22:
+ _context.next = 1;
+ break;
+ case 24:
+ case "end":
+ return _context.stop();
+ }
+ }, _callee, null, [[3, 11]]);
+ }));
+ return function (_x, _x2) {
+ return _ref2.apply(this, arguments);
+ };
+ }());
+ return {
+ promise: promise,
+ cancel: function cancel() {
+ if (completed) return;
+ completed = true;
+ rejectCancelled(new CancelledError());
+ }
+ };
+}
+
+// TODO de-duplicate this file with web interface
+// modified from https://usehooks.com/useDebounce/
+function useDebounce(value, delay) {
+ var _useState = React.useState(value),
+ debouncedValue = _useState[0],
+ setDebouncedValue = _useState[1];
+ React.useEffect(function () {
+ // Update debounced value after delay
+ var handler = setTimeout(function () {
+ setDebouncedValue(value);
+ }, delay);
+ // Cancel the timeout if value changes (also on delay change or unmount)
+ // This is how we prevent debounced value from updating if value is changed ...
+ // .. within the delay period. Timeout gets cleared and restarted.
+ return function () {
+ clearTimeout(handler);
+ };
+ }, [value, delay]);
+ return debouncedValue;
+}
+
+var IMulticallABI = [{
+ inputs: [],
+ name: 'getCurrentBlockTimestamp',
+ outputs: [{
+ internalType: 'uint256',
+ name: 'timestamp',
+ type: 'uint256'
+ }],
+ stateMutability: 'view',
+ type: 'function'
+}, {
+ inputs: [{
+ internalType: 'address',
+ name: 'addr',
+ type: 'address'
+ }],
+ name: 'getEthBalance',
+ outputs: [{
+ internalType: 'uint256',
+ name: 'balance',
+ type: 'uint256'
+ }],
+ stateMutability: 'view',
+ type: 'function'
+}, {
+ inputs: [{
+ components: [{
+ internalType: 'address',
+ name: 'target',
+ type: 'address'
+ }, {
+ internalType: 'uint256',
+ name: 'gasLimit',
+ type: 'uint256'
+ }, {
+ internalType: 'bytes',
+ name: 'callData',
+ type: 'bytes'
+ }],
+ internalType: 'struct PancakeInterfaceMulticall.Call[]',
+ name: 'calls',
+ type: 'tuple[]'
+ }],
+ name: 'multicall',
+ outputs: [{
+ internalType: 'uint256',
+ name: 'blockNumber',
+ type: 'uint256'
+ }, {
+ components: [{
+ internalType: 'bool',
+ name: 'success',
+ type: 'bool'
+ }, {
+ internalType: 'uint256',
+ name: 'gasUsed',
+ type: 'uint256'
+ }, {
+ internalType: 'bytes',
+ name: 'returnData',
+ type: 'bytes'
+ }],
+ internalType: 'struct PancakeInterfaceMulticall.Result[]',
+ name: 'returnData',
+ type: 'tuple[]'
+ }],
+ stateMutability: 'nonpayable',
+ type: 'function'
+}];
+
+var FETCH_RETRY_CONFIG = {
+ n: Infinity,
+ minWait: 1000,
+ maxWait: 2500
+};
+/**
+ * Fetches a chunk of calls, enforcing a minimum block number constraint
+ * @param multicall multicall contract to fetch against
+ * @param chunk chunk of calls to make
+ * @param blockNumber block number passed as the block tag in the eth_call
+ */
+function fetchChunk(_x, _x2, _x3, _x4) {
+ return _fetchChunk.apply(this, arguments);
+}
+/**
+ * From the current all listeners state, return each call key mapped to the
+ * minimum number of blocks per fetch. This is how often each key must be fetched.
+ * @param allListeners the all listeners state
+ * @param chainId the current chain id
+ */
+function _fetchChunk() {
+ _fetchChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(multicallInfo, chunk, blockNumber, isDebug) {
+ var _yield$multicallInfo$, _yield$multicallInfo$2, returnData, _error$message, _error$message2, error, half, _yield$Promise$all, c0, c1;
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
+ while (1) switch (_context.prev = _context.next) {
+ case 0:
+ console.debug('Fetching chunk', chunk, blockNumber, chunk.map(function (obj) {
+ var _obj$gasRequired;
+ return {
+ target: obj.address,
+ callData: obj.callData,
+ gasLimit: (_obj$gasRequired = obj.gasRequired) != null ? _obj$gasRequired : DEFAULT_CALL_GAS_REQUIRED
+ };
+ }));
+ _context.prev = 1;
+ _context.next = 4;
+ return multicallInfo.provider.simulateContract({
+ abi: IMulticallABI,
+ address: multicallInfo.address,
+ functionName: 'multicall',
+ args: [chunk.map(function (obj) {
+ var _obj$gasRequired2;
+ return {
+ target: obj.address,
+ callData: obj.callData,
+ gasLimit: (_obj$gasRequired2 = obj.gasRequired) != null ? _obj$gasRequired2 : DEFAULT_CALL_GAS_REQUIRED
+ };
+ })],
+ // we aren't passing through the block gas limit we used to create the chunk, because it causes a problem with the integ tests
+ blockNumber: BigInt(blockNumber)
+ });
+ case 4:
+ _yield$multicallInfo$ = _context.sent;
+ _yield$multicallInfo$2 = _yield$multicallInfo$.result;
+ returnData = _yield$multicallInfo$2[1];
+ if (isDebug) {
+ returnData.forEach(function (_ref, i) {
+ var _chunk$i$gasRequired;
+ var gasUsed = _ref.gasUsed,
+ returnData = _ref.returnData,
+ success = _ref.success;
+ if (!success && returnData.length === 2 && gasUsed >= Math.floor(((_chunk$i$gasRequired = chunk[i].gasRequired) != null ? _chunk$i$gasRequired : DEFAULT_CALL_GAS_REQUIRED) * 0.95)) {
+ var _chunk$i$gasRequired2;
+ console.warn("A call failed due to requiring " + gasUsed.toString() + " vs. allowed " + ((_chunk$i$gasRequired2 = chunk[i].gasRequired) != null ? _chunk$i$gasRequired2 : DEFAULT_CALL_GAS_REQUIRED), chunk[i]);
+ }
+ });
+ }
+ return _context.abrupt("return", returnData);
+ case 11:
+ _context.prev = 11;
+ _context.t0 = _context["catch"](1);
+ error = _context.t0;
+ if (!(error.code === -32000 || ((_error$message = error.message) == null ? void 0 : _error$message.indexOf('header not found')) !== -1)) {
+ _context.next = 18;
+ break;
+ }
+ throw new RetryableError("header not found for block number " + blockNumber);
+ case 18:
+ if (!(error.code === -32603 || ((_error$message2 = error.message) == null ? void 0 : _error$message2.indexOf('execution ran out of gas')) !== -1)) {
+ _context.next = 28;
+ break;
+ }
+ if (!(chunk.length > 1)) {
+ _context.next = 28;
+ break;
+ }
+ {
+ console.debug('Splitting a chunk in 2', chunk);
+ }
+ half = Math.floor(chunk.length / 2);
+ _context.next = 24;
+ return Promise.all([fetchChunk(multicallInfo, chunk.slice(0, half), blockNumber), fetchChunk(multicallInfo, chunk.slice(half, chunk.length), blockNumber)]);
+ case 24:
+ _yield$Promise$all = _context.sent;
+ c0 = _yield$Promise$all[0];
+ c1 = _yield$Promise$all[1];
+ return _context.abrupt("return", c0.concat(c1));
+ case 28:
+ console.error('Failed to fetch chunk', error);
+ throw error;
+ case 30:
+ case "end":
+ return _context.stop();
+ }
+ }, _callee, null, [[1, 11]]);
+ }));
+ return _fetchChunk.apply(this, arguments);
+}
+function activeListeningKeys(allListeners, chainId) {
+ if (!allListeners || !chainId) return {};
+ var listeners = allListeners[chainId];
+ if (!listeners) return {};
+ return Object.keys(listeners).reduce(function (memo, callKey) {
+ var keyListeners = listeners[callKey];
+ memo[callKey] = Object.keys(keyListeners).filter(function (key) {
+ var blocksPerFetch = parseInt(key);
+ if (blocksPerFetch <= 0) return false;
+ return keyListeners[blocksPerFetch] > 0;
+ }).reduce(function (previousMin, current) {
+ return Math.min(previousMin, parseInt(current));
+ }, Infinity);
+ return memo;
+ }, {});
+}
+/**
+ * Return the keys that need to be refetched
+ * @param callResults current call result state
+ * @param listeningKeys each call key mapped to how old the data can be in blocks
+ * @param chainId the current chain id
+ * @param latestBlockNumber the latest block number
+ */
+function outdatedListeningKeys(callResults, listeningKeys, chainId, latestBlockNumber) {
+ if (!chainId || !latestBlockNumber) return [];
+ var results = callResults[chainId];
+ // no results at all, load everything
+ if (!results) return Object.keys(listeningKeys);
+ return Object.keys(listeningKeys).filter(function (callKey) {
+ var blocksPerFetch = listeningKeys[callKey];
+ var data = callResults[chainId][callKey];
+ // no data, must fetch
+ if (!data) return true;
+ var minDataBlockNumber = latestBlockNumber - (blocksPerFetch - 1);
+ // already fetching it for a recent enough block, don't refetch it
+ if (data.fetchingBlockNumber && data.fetchingBlockNumber >= minDataBlockNumber) return false;
+ // if data is older than minDataBlockNumber, fetch it
+ return !data.blockNumber || data.blockNumber < minDataBlockNumber;
+ });
+}
+function onFetchChunkSuccess(context, chunk, result) {
+ var actions = context.actions,
+ dispatch = context.dispatch,
+ chainId = context.chainId,
+ latestBlockNumber = context.latestBlockNumber,
+ isDebug = context.isDebug;
+ // split the returned slice into errors and results
+ var _chunk$reduce = chunk.reduce(function (memo, call, i) {
+ if (result[i].success) {
+ var _result$i$returnData;
+ memo.results[toCallKey(call)] = (_result$i$returnData = result[i].returnData) != null ? _result$i$returnData : null;
+ } else {
+ memo.erroredCalls.push(call);
+ }
+ return memo;
+ }, {
+ erroredCalls: [],
+ results: {}
+ }),
+ erroredCalls = _chunk$reduce.erroredCalls,
+ results = _chunk$reduce.results;
+ // dispatch any new results
+ if (Object.keys(results).length > 0) dispatch(actions.updateMulticallResults({
+ chainId: chainId,
+ results: results,
+ blockNumber: latestBlockNumber
+ }));
+ // dispatch any errored calls
+ if (erroredCalls.length > 0) {
+ if (isDebug) {
+ result.forEach(function (returnData, ix) {
+ if (!returnData.success) {
+ console.debug('Call failed', chunk[ix], returnData);
+ }
+ });
+ } else {
+ console.debug('Calls errored in fetch', erroredCalls);
+ }
+ dispatch(actions.errorFetchingMulticallResults({
+ calls: erroredCalls,
+ chainId: chainId,
+ fetchingBlockNumber: latestBlockNumber
+ }));
+ }
+}
+function onFetchChunkFailure(context, chunk, error) {
+ var actions = context.actions,
+ dispatch = context.dispatch,
+ chainId = context.chainId,
+ latestBlockNumber = context.latestBlockNumber;
+ if (error.isCancelledError) {
+ console.debug('Cancelled fetch for blockNumber', latestBlockNumber, chunk, chainId);
+ return;
+ }
+ console.error('Failed to fetch multicall chunk', chunk, chainId, error);
+ dispatch(actions.errorFetchingMulticallResults({
+ calls: chunk,
+ chainId: chainId,
+ fetchingBlockNumber: latestBlockNumber
+ }));
+}
+function Updater(props) {
+ var context = props.context,
+ chainId = props.chainId,
+ latestBlockNumber = props.latestBlockNumber,
+ multicallInfo = props.multicallInfo,
+ isDebug = props.isDebug,
+ listenerOptions = props.listenerOptions;
+ var actions = context.actions,
+ reducerPath = context.reducerPath;
+ var dispatch = reactRedux.useDispatch();
+ // set user configured listenerOptions in state for given chain ID.
+ React.useEffect(function () {
+ if (chainId && listenerOptions) {
+ dispatch(actions.updateListenerOptions({
+ chainId: chainId,
+ listenerOptions: listenerOptions
+ }));
+ }
+ }, [chainId, listenerOptions, actions, dispatch]);
+ var state = reactRedux.useSelector(function (state) {
+ return state[reducerPath];
+ });
+ // wait for listeners to settle before triggering updates
+ var debouncedListeners = useDebounce(state.callListeners, 100);
+ var cancellations = React.useRef();
+ var listeningKeys = React.useMemo(function () {
+ return activeListeningKeys(debouncedListeners, chainId);
+ }, [debouncedListeners, chainId]);
+ var serializedOutdatedCallKeys = React.useMemo(function () {
+ var outdatedCallKeys = outdatedListeningKeys(state.callResults, listeningKeys, chainId, latestBlockNumber);
+ return JSON.stringify(outdatedCallKeys.sort());
+ }, [chainId, state.callResults, listeningKeys, latestBlockNumber]);
+ React.useEffect(function () {
+ if (!latestBlockNumber || !chainId || !multicallInfo) return;
+ var outdatedCallKeys = JSON.parse(serializedOutdatedCallKeys);
+ if (outdatedCallKeys.length === 0) return;
+ var calls = outdatedCallKeys.map(function (key) {
+ return parseCallKey(key);
+ });
+ var chunkedCalls = chunkCalls(calls, CHUNK_GAS_LIMIT);
+ if (cancellations.current && cancellations.current.blockNumber !== latestBlockNumber) {
+ cancellations.current.cancellations.forEach(function (c) {
+ return c();
+ });
+ }
+ dispatch(actions.fetchingMulticallResults({
+ calls: calls,
+ chainId: chainId,
+ fetchingBlockNumber: latestBlockNumber
+ }));
+ var fetchChunkContext = {
+ actions: actions,
+ dispatch: dispatch,
+ chainId: chainId,
+ latestBlockNumber: latestBlockNumber,
+ isDebug: isDebug
+ };
+ // Execute fetches and gather cancellation callbacks
+ var newCancellations = chunkedCalls.map(function (chunk) {
+ var _retry = retry(function () {
+ return fetchChunk(multicallInfo, chunk, latestBlockNumber, isDebug);
+ }, FETCH_RETRY_CONFIG),
+ cancel = _retry.cancel,
+ promise = _retry.promise;
+ promise.then(function (result) {
+ return onFetchChunkSuccess(fetchChunkContext, chunk, result);
+ })["catch"](function (error) {
+ return onFetchChunkFailure(fetchChunkContext, chunk, error);
+ });
+ return cancel;
+ });
+ cancellations.current = {
+ blockNumber: latestBlockNumber,
+ cancellations: newCancellations
+ };
+ }, [actions, chainId, multicallInfo, dispatch, serializedOutdatedCallKeys, latestBlockNumber, isDebug]);
+ return null;
+}
+function createUpdater(context) {
+ var UpdaterContextBound = function UpdaterContextBound(props) {
+ return React__default.createElement(Updater, Object.assign({
+ context: context
+ }, props));
+ };
+ return UpdaterContextBound;
+}
+
+// Inspired by RTK Query's createApi
+function createMulticall(options) {
+ var _options$reducerPath;
+ var reducerPath = (_options$reducerPath = options == null ? void 0 : options.reducerPath) != null ? _options$reducerPath : 'multicall';
+ var slice = createMulticallSlice(reducerPath);
+ var actions = slice.actions,
+ reducer = slice.reducer;
+ var context = {
+ reducerPath: reducerPath,
+ actions: actions
+ };
+ var useMultipleContractSingleData$1 = function useMultipleContractSingleData$1() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+ return useMultipleContractSingleData.apply(void 0, [context].concat(args));
+ };
+ var useSingleContractMultipleData$1 = function useSingleContractMultipleData$1() {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+ return useSingleContractMultipleData.apply(void 0, [context].concat(args));
+ };
+ var useSingleContractWithCallData$1 = function useSingleContractWithCallData$1() {
+ for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+ return useSingleContractWithCallData.apply(void 0, [context].concat(args));
+ };
+ var useSingleCallResult$1 = function useSingleCallResult$1() {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+ return useSingleCallResult.apply(void 0, [context].concat(args));
+ };
+ var useMultiChainMultiContractSingleData$1 = function useMultiChainMultiContractSingleData$1() {
+ for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+ args[_key5] = arguments[_key5];
+ }
+ return useMultiChainMultiContractSingleData.apply(void 0, [context].concat(args));
+ };
+ var useMultiChainSingleContractSingleData$1 = function useMultiChainSingleContractSingleData$1() {
+ for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+ args[_key6] = arguments[_key6];
+ }
+ return useMultiChainSingleContractSingleData.apply(void 0, [context].concat(args));
+ };
+ var hooks = {
+ useMultipleContractSingleData: useMultipleContractSingleData$1,
+ useSingleContractMultipleData: useSingleContractMultipleData$1,
+ useSingleContractWithCallData: useSingleContractWithCallData$1,
+ useSingleCallResult: useSingleCallResult$1,
+ useMultiChainMultiContractSingleData: useMultiChainMultiContractSingleData$1,
+ useMultiChainSingleContractSingleData: useMultiChainSingleContractSingleData$1
+ };
+ var Updater = createUpdater(context);
+ return {
+ reducerPath: reducerPath,
+ reducer: reducer,
+ actions: actions,
+ hooks: hooks,
+ Updater: Updater
+ };
+}
+
+exports.CHUNK_GAS_LIMIT = CHUNK_GAS_LIMIT;
+exports.CONSERVATIVE_BLOCK_GAS_LIMIT = CONSERVATIVE_BLOCK_GAS_LIMIT;
+exports.DEFAULT_BLOCKS_PER_FETCH = DEFAULT_BLOCKS_PER_FETCH;
+exports.DEFAULT_CALL_GAS_REQUIRED = DEFAULT_CALL_GAS_REQUIRED;
+exports.DEFAULT_CHUNK_GAS_REQUIRED = DEFAULT_CHUNK_GAS_REQUIRED;
+exports.INVALID_CALL_STATE = INVALID_CALL_STATE;
+exports.INVALID_RESULT = INVALID_RESULT;
+exports.LOADING_CALL_STATE = LOADING_CALL_STATE;
+exports.NEVER_RELOAD = NEVER_RELOAD;
+exports.createMulticall = createMulticall;
+//# sourceMappingURL=redux-multicall-viem.cjs.development.js.map
diff --git a/dist/redux-multicall-viem.cjs.development.js.map b/dist/redux-multicall-viem.cjs.development.js.map
new file mode 100644
index 0000000..8f720fc
--- /dev/null
+++ b/dist/redux-multicall-viem.cjs.development.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"redux-multicall-viem.cjs.development.js","sources":["../src/constants.ts","../src/utils/callKeys.ts","../src/utils/callState.ts","../src/validation.ts","../src/hooks.ts","../src/slice.ts","../src/utils/chunkCalls.ts","../src/utils/retry.ts","../src/utils/useDebounce.ts","../src/abi/InterfaceMulticall.ts","../src/updater.tsx","../src/create.ts"],"sourcesContent":["import type { CallResult, CallState, ListenerOptions } from './types'\n\nexport const DEFAULT_BLOCKS_PER_FETCH = 1\nexport const DEFAULT_CALL_GAS_REQUIRED = 1_000_000\nexport const DEFAULT_CHUNK_GAS_REQUIRED = 200_000\nexport const CHUNK_GAS_LIMIT = 100_000_000\nexport const CONSERVATIVE_BLOCK_GAS_LIMIT = 10_000_000 // conservative, hard-coded estimate of the current block gas limit\n\n// Consts for hooks\nexport const INVALID_RESULT: CallResult = { valid: false, blockNumber: undefined, data: undefined }\nexport const NEVER_RELOAD: ListenerOptions = {\n blocksPerFetch: Infinity,\n}\n\nexport const INVALID_CALL_STATE: CallState = {\n valid: false,\n result: undefined,\n loading: false,\n syncing: false,\n error: false,\n}\nexport const LOADING_CALL_STATE: CallState = {\n valid: true,\n result: undefined,\n loading: true,\n syncing: true,\n error: false,\n}\n","import { Call } from '../types'\n\nexport function toCallKey(call: Call): string {\n let key = `${call.address}-${call.callData}`\n if (call.gasRequired) {\n if (!Number.isSafeInteger(call.gasRequired)) {\n throw new Error(`Invalid number: ${call.gasRequired}`)\n }\n key += `-${call.gasRequired}`\n }\n return key\n}\n\nexport function parseCallKey(callKey: string): Call {\n const pcs = callKey.split('-')\n if (![2, 3].includes(pcs.length)) {\n throw new Error(`Invalid call key: ${callKey}`)\n }\n return {\n address: pcs[0],\n callData: pcs[1],\n ...(pcs[2] ? { gasRequired: Number.parseInt(pcs[2]) } : {}),\n }\n}\n\nexport function callsToCallKeys(calls?: Array) {\n return (\n calls\n ?.filter((c): c is Call => Boolean(c))\n ?.map(toCallKey)\n ?.sort() ?? []\n )\n}\n\nexport function callKeysToCalls(callKeys: string[]) {\n if (!callKeys?.length) return null\n return callKeys.map((key) => parseCallKey(key))\n}\n","import { useMemo } from 'react'\nimport { INVALID_CALL_STATE, LOADING_CALL_STATE } from '../constants'\nimport type { CallResult, CallState, CallStateResult } from '../types'\nimport { AbiFunction, decodeFunctionResult } from 'viem'\n\n// Converts CallResult[] to CallState[], only updating if call states have changed.\n// Ensures that CallState results remain referentially stable when unchanged, preventing\n// spurious re-renders which would otherwise occur because mapping always creates a new object.\nexport function useCallStates(\n results: CallResult[],\n contractInterface: AbiFunction[] | undefined,\n fragment: ((i: number) => string | undefined) | string | undefined,\n latestBlockNumber: number | undefined\n): CallState[] {\n // Avoid refreshing the results with every changing block number (eg latestBlockNumber).\n // Instead, only refresh the results if they need to be synced - if there is a result which is stale, for which blockNumber < latestBlockNumber.\n const syncingBlockNumber = useMemo(() => {\n const lowestBlockNumber = results.reduce(\n (memo, result) => (result.blockNumber ? Math.min(memo ?? result.blockNumber, result.blockNumber) : memo),\n undefined\n )\n return Math.max(lowestBlockNumber ?? 0, latestBlockNumber ?? 0)\n }, [results, latestBlockNumber])\n\n return useMemo(() => {\n return results.map((result, i) => {\n const resultFragment = typeof fragment === 'function' ? fragment(i) : fragment\n return toCallState(result, contractInterface, resultFragment, syncingBlockNumber)\n })\n }, [contractInterface, fragment, results, syncingBlockNumber])\n}\n\nexport function toCallState(\n callResult: CallResult | undefined,\n contractInterface: AbiFunction[] | undefined,\n fragment: string | undefined,\n syncingBlockNumber: number | undefined\n): CallState {\n if (!callResult || !callResult.valid) {\n return INVALID_CALL_STATE\n }\n\n const { data, blockNumber } = callResult\n if (!blockNumber || !contractInterface || !fragment || !syncingBlockNumber) {\n return LOADING_CALL_STATE\n }\n\n const success = data && data.length > 2\n const syncing = blockNumber < syncingBlockNumber\n let result: CallStateResult | undefined = undefined\n if (success && data) {\n try {\n result = (decodeFunctionResult as any)({\n abi: contractInterface,\n functionName: fragment,\n data: data as any,\n }) as any\n } catch (error) {\n console.debug('Result data parsing failed', fragment, data)\n return {\n valid: true,\n loading: false,\n error: true,\n syncing,\n result,\n }\n }\n }\n return {\n valid: true,\n loading: false,\n syncing,\n result,\n error: !success,\n }\n}\n","export type MethodArg = string | number | BigInt\nexport type MethodArgs = Array\n\nexport function isMethodArg(x: unknown): x is MethodArg {\n return (x === null || x === undefined) ? false : typeof BigInt(x as any) === 'bigint' || ['string', 'number'].indexOf(typeof x) !== -1\n}\n\nexport function isValidMethodArgs(x: unknown): x is MethodArgs | undefined {\n return (\n x === undefined ||\n (Array.isArray(x) && x.every((xi) => isMethodArg(xi) || (Array.isArray(xi) && xi.every(isMethodArg))))\n )\n}\n","import { useCallback, useEffect, useMemo, useRef } from 'react'\nimport { batch, useDispatch, useSelector } from 'react-redux'\nimport { INVALID_CALL_STATE, INVALID_RESULT, DEFAULT_BLOCKS_PER_FETCH } from './constants'\nimport type { MulticallContext } from './context'\nimport type {\n Call,\n CallResult,\n CallState,\n ContractInfo,\n ListenerOptions,\n ListenerOptionsWithGas,\n WithMulticallState,\n} from './types'\nimport { callKeysToCalls, callsToCallKeys, toCallKey } from './utils/callKeys'\nimport { toCallState, useCallStates } from './utils/callState'\nimport { isValidMethodArgs, MethodArg } from './validation'\nimport { AbiFunction, encodeFunctionData, getAbiItem } from 'viem'\n\ntype OptionalMethodInputs = Array | undefined\n\n// the lowest level call for subscribing to contract data\nexport function useCallsDataSubscription(\n context: MulticallContext,\n chainId: number | undefined,\n calls: Array,\n listenerOptions?: ListenerOptions\n): CallResult[] {\n const { reducerPath, actions } = context\n const callResults = useSelector((state: WithMulticallState) => state[reducerPath].callResults)\n const defaultListenerOptions = useSelector((state: WithMulticallState) => state[reducerPath].listenerOptions)\n const dispatch = useDispatch()\n const serializedCallKeys: string = useMemo(() => JSON.stringify(callsToCallKeys(calls)), [calls])\n\n // update listeners when there is an actual change that persists for at least 100ms\n useEffect(() => {\n const callKeys: string[] = JSON.parse(serializedCallKeys)\n const calls = callKeysToCalls(callKeys)\n if (!chainId || !calls) return\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n\n dispatch(\n actions.addMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n\n return () => {\n dispatch(\n actions.removeMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n }, [actions, chainId, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions])\n\n const lastResults = useRef([])\n return useMemo(() => {\n let isChanged = lastResults.current.length !== calls.length\n\n // Construct results using a for-loop to handle sparse arrays.\n // Array.prototype.map would skip empty entries.\n let results: CallResult[] = []\n for (let i = 0; i < calls.length; ++i) {\n const call = calls[i]\n let result = INVALID_RESULT\n if (chainId && call) {\n const callResult = callResults[chainId]?.[toCallKey(call)]\n result = {\n valid: true,\n data: callResult?.data && callResult.data !== '0x' ? callResult.data : undefined,\n blockNumber: callResult?.blockNumber,\n }\n }\n\n isChanged = isChanged || !areCallResultsEqual(result, lastResults.current[i])\n results.push(result)\n }\n\n // Force the results to be referentially stable if they have not changed.\n // This is necessary because *all* callResults are passed as deps when initially memoizing the results.\n if (isChanged) {\n lastResults.current = results\n }\n return lastResults.current\n }, [callResults, calls, chainId])\n}\n\nfunction areCallResultsEqual(a: CallResult, b: CallResult) {\n return a.valid === b.valid && a.data === b.data && a.blockNumber === b.blockNumber\n}\n\n// Similar to useCallsDataSubscription above but for subscribing to\n// calls to multiple chains at once\nfunction useMultichainCallsDataSubscription(\n context: MulticallContext,\n chainToCalls: Record>,\n listenerOptions?: ListenerOptions\n): Record {\n const { reducerPath, actions } = context\n const callResults = useSelector((state: WithMulticallState) => state[reducerPath].callResults)\n const defaultListenerOptions = useSelector((state: WithMulticallState) => state[reducerPath].listenerOptions)\n const dispatch = useDispatch()\n\n const serializedCallKeys: string = useMemo(() => {\n const sortedChainIds = getChainIds(chainToCalls).sort()\n const chainCallKeysTuple = sortedChainIds.map((chainId) => {\n const calls = chainToCalls[chainId]\n const callKeys = callsToCallKeys(calls)\n // Note, using a tuple to ensure consistent order when serialized\n return [chainId, callKeys]\n })\n return JSON.stringify(chainCallKeysTuple)\n }, [chainToCalls])\n\n useEffect(() => {\n const chainCallKeysTuples: Array<[number, string[]]> = JSON.parse(serializedCallKeys)\n if (!chainCallKeysTuples?.length) return\n\n batch(() => {\n for (const [chainId, callKeys] of chainCallKeysTuples) {\n const calls = callKeysToCalls(callKeys)\n if (!calls?.length) continue\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n\n dispatch(\n actions.addMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n })\n\n return () => {\n batch(() => {\n for (const [chainId, callKeys] of chainCallKeysTuples) {\n const calls = callKeysToCalls(callKeys)\n if (!calls?.length) continue\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n dispatch(\n actions.removeMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n })\n }\n }, [actions, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions])\n\n return useMemo(\n () =>\n getChainIds(chainToCalls).reduce((result, chainId) => {\n const calls = chainToCalls[chainId]\n result[chainId] = calls.map((call) => {\n if (!chainId || !call) return INVALID_RESULT\n const result = callResults[chainId]?.[toCallKey(call)]\n const data = result?.data && result.data !== '0x' ? result.data : undefined\n return { valid: true, data, blockNumber: result?.blockNumber }\n })\n return result\n }, {} as Record),\n [callResults, chainToCalls]\n )\n}\n\n// formats many calls to a single function on a single contract, with the function name and inputs specified\nexport function useSingleContractMultipleData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n methodName: string,\n callInputs: OptionalMethodInputs[],\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n // Create ethers function fragment\n const fragment = useMemo(\n () => contract && ((getAbiItem as any)({ abi: contract.abi, name: methodName } as any) as any)?.name,\n [contract, methodName]\n )\n\n // Get encoded call data. Note can't use useCallData below b.c. this is for a list of CallInputs\n const callDatas = useMemo(() => {\n if (!contract || !fragment) return []\n return callInputs.map((callInput) =>\n isValidMethodArgs(callInput)\n ? (encodeFunctionData as any)({\n abi: contract.abi,\n functionName: fragment,\n args: callInput,\n })\n : undefined\n )\n }, [callInputs, contract, fragment])\n\n // Create call objects\n const calls = useMemo(() => {\n if (!contract) return []\n return callDatas.map((callData) => {\n if (!callData) return undefined\n return {\n address: contract.address,\n callData,\n gasRequired,\n }\n })\n }, [contract, callDatas, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n return useCallStates(results, contract?.abi, fragment, latestBlockNumber)\n}\n\nexport function useMultipleContractSingleData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n addresses: (string | undefined)[],\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n const { fragment, callData } = useCallData(methodName, contractInterface, callInputs)\n\n // Create call objects\n const calls = useMemo(() => {\n if (!callData) return []\n return addresses.map((address) => {\n if (!address) return undefined\n return { address, callData, gasRequired }\n })\n }, [addresses, callData, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n return useCallStates(results, contractInterface, fragment, latestBlockNumber)\n}\n\nexport function useSingleCallResult(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n methodName: string,\n inputs?: OptionalMethodInputs,\n options?: Partial\n): CallState {\n const callInputs = useMemo(() => [inputs], [inputs])\n return (\n useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options)[0] ??\n INVALID_CALL_STATE\n )\n}\n\n// formats many calls to any number of functions on a single contract, with only the calldata specified\nexport function useSingleContractWithCallData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n callDatas: string[],\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n // Create call objects\n const calls = useMemo(() => {\n if (!contract) return []\n return callDatas.map((callData) => ({\n address: contract.address,\n callData,\n gasRequired,\n }))\n }, [callDatas, contract, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n const fragment = useCallback(\n (i: number) => ((getAbiItem as any)({ abi: contract?.abi as any, name: callDatas[i].substring(0, 10) }) as any)?.name,\n [callDatas, contract]\n )\n return useCallStates(results, contract?.abi, fragment, latestBlockNumber)\n}\n\n// Similar to useMultipleContractSingleData but instead of multiple contracts on one chain,\n// this is for querying compatible contracts on multiple chains\nexport function useMultiChainMultiContractSingleData(\n context: MulticallContext,\n chainToBlockNumber: Record,\n chainToAddresses: Record>,\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): Record {\n const { gasRequired } = options ?? {}\n\n const { fragment, callData } = useCallData(methodName, contractInterface, callInputs)\n\n // Create call objects\n const chainToCalls = useMemo(() => {\n if (!callData || !chainToAddresses) return {}\n return getChainIds(chainToAddresses).reduce((result, chainId) => {\n const addresses = chainToAddresses[chainId]\n const calls = addresses.map((address) => {\n if (!address) return undefined\n return { address, callData, gasRequired }\n })\n result[chainId] = calls\n return result\n }, {} as Record>)\n }, [chainToAddresses, callData, gasRequired])\n\n // Subscribe to call data\n const chainIdToResults = useMultichainCallsDataSubscription(context, chainToCalls, options as ListenerOptions)\n\n // TODO(WEB-2097): Multichain states are not referentially stable, because they cannot use the\n // same codepath (eg useCallStates).\n return useMemo(() => {\n return getChainIds(chainIdToResults).reduce((combinedResults, chainId) => {\n const latestBlockNumber = chainToBlockNumber?.[chainId]\n const results = chainIdToResults[chainId]\n combinedResults[chainId] = results.map((result) =>\n toCallState(result, contractInterface, fragment, latestBlockNumber)\n )\n return combinedResults\n }, {} as Record)\n }, [fragment, contractInterface, chainIdToResults, chainToBlockNumber])\n}\n\n// Similar to useSingleCallResult but instead of one contract on one chain,\n// this is for querying a contract on multiple chains\nexport function useMultiChainSingleContractSingleData(\n context: MulticallContext,\n chainToBlockNumber: Record,\n chainToAddress: Record,\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): Record {\n // This hook uses the more flexible useMultiChainMultiContractSingleData internally,\n // but transforms the inputs and outputs for convenience\n const chainIdToAddresses = useMemo(() => {\n return getChainIds(chainToAddress).reduce((result, chainId) => {\n result[chainId] = [chainToAddress[chainId]]\n return result\n }, {} as Record>)\n }, [chainToAddress])\n\n const multiContractResults = useMultiChainMultiContractSingleData(\n context,\n chainToBlockNumber,\n chainIdToAddresses,\n contractInterface,\n methodName,\n callInputs,\n options\n )\n\n return useMemo(() => {\n return getChainIds(chainToAddress).reduce((result, chainId) => {\n result[chainId] = multiContractResults[chainId]?.[0] ?? INVALID_CALL_STATE\n return result\n }, {} as Record)\n }, [chainToAddress, multiContractResults])\n}\n\nfunction useCallData(\n methodName: string,\n contractInterface: AbiFunction[] | null | undefined,\n callInputs: OptionalMethodInputs | undefined\n) {\n // Create ethers function fragment\n const fragment = useMemo(\n () => contractInterface && ((getAbiItem as any)({ abi: contractInterface as any, name: methodName }) as any)?.name,\n [contractInterface, methodName]\n )\n // Get encoded call data\n const callData: string | undefined = useMemo(\n () =>\n fragment && isValidMethodArgs(callInputs)\n ? (encodeFunctionData as any)({\n abi: contractInterface as any,\n functionName: fragment,\n args: callInputs as unknown as any[],\n })\n : undefined,\n [callInputs, contractInterface, fragment]\n )\n return { fragment, callData }\n}\n\nfunction getChainIds(chainIdMap: Record) {\n return Object.keys(chainIdMap).map((c) => parseInt(c, 10))\n}\n","import { createSlice, PayloadAction } from '@reduxjs/toolkit'\nimport {\n MulticallFetchingPayload,\n MulticallListenerPayload,\n MulticallResultsPayload,\n MulticallState,\n MulticallListenerOptionsPayload,\n} from './types'\nimport { toCallKey } from './utils/callKeys'\n\nconst initialState: MulticallState = {\n callResults: {},\n}\n\nexport function createMulticallSlice(reducerPath: string) {\n return createSlice({\n name: reducerPath,\n initialState,\n reducers: {\n addMulticallListeners: (state, action: PayloadAction) => {\n const {\n calls,\n chainId,\n options: { blocksPerFetch },\n } = action.payload\n const listeners: MulticallState['callListeners'] = state.callListeners\n ? state.callListeners\n : (state.callListeners = {})\n listeners[chainId] = listeners[chainId] ?? {}\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n listeners[chainId][callKey] = listeners[chainId][callKey] ?? {}\n listeners[chainId][callKey][blocksPerFetch] = (listeners[chainId][callKey][blocksPerFetch] ?? 0) + 1\n })\n },\n\n removeMulticallListeners: (state, action: PayloadAction) => {\n const {\n calls,\n chainId,\n options: { blocksPerFetch },\n } = action.payload\n const listeners: MulticallState['callListeners'] = state.callListeners\n ? state.callListeners\n : (state.callListeners = {})\n\n if (!listeners[chainId]) return\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n if (!listeners[chainId][callKey]) return\n if (!listeners[chainId][callKey][blocksPerFetch]) return\n\n if (listeners[chainId][callKey][blocksPerFetch] === 1) {\n delete listeners[chainId][callKey][blocksPerFetch]\n } else {\n listeners[chainId][callKey][blocksPerFetch]--\n }\n })\n },\n\n fetchingMulticallResults: (state, action: PayloadAction) => {\n const { chainId, fetchingBlockNumber, calls } = action.payload\n state.callResults[chainId] = state.callResults[chainId] ?? {}\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n const current = state.callResults[chainId][callKey]\n if (!current) {\n state.callResults[chainId][callKey] = {\n fetchingBlockNumber,\n }\n } else {\n if ((current.fetchingBlockNumber ?? 0) >= fetchingBlockNumber) return\n state.callResults[chainId][callKey].fetchingBlockNumber = fetchingBlockNumber\n }\n })\n },\n\n errorFetchingMulticallResults: (state, action: PayloadAction) => {\n const { chainId, fetchingBlockNumber, calls } = action.payload\n state.callResults[chainId] = state.callResults[chainId] ?? {}\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n const current = state.callResults[chainId][callKey]\n if (!current || typeof current.fetchingBlockNumber !== 'number') return // only should be dispatched if we are already fetching\n if (current.fetchingBlockNumber <= fetchingBlockNumber) {\n delete current.fetchingBlockNumber\n current.data = null\n current.blockNumber = fetchingBlockNumber\n }\n })\n },\n\n updateMulticallResults: (state, action: PayloadAction) => {\n const { chainId, results, blockNumber } = action.payload\n state.callResults[chainId] = state.callResults[chainId] ?? {}\n Object.keys(results).forEach((callKey) => {\n const current = state.callResults[chainId][callKey]\n if ((current?.blockNumber ?? 0) > blockNumber) return\n if (current?.data === results[callKey] && current?.blockNumber === blockNumber) return\n state.callResults[chainId][callKey] = {\n data: results[callKey],\n blockNumber,\n }\n })\n },\n\n updateListenerOptions: (state, action: PayloadAction) => {\n const { chainId, listenerOptions } = action.payload\n state.listenerOptions = state.listenerOptions ?? {}\n state.listenerOptions[chainId] = listenerOptions\n },\n },\n })\n}\n\nexport type MulticallActions = ReturnType['actions']\n","import { DEFAULT_CHUNK_GAS_REQUIRED } from '../constants'\n\ninterface Bin {\n calls: T[]\n cumulativeGasLimit: number\n}\n\n/**\n * Tries to pack a list of items into as few bins as possible using the first-fit bin packing algorithm\n * @param calls the calls to chunk\n * @param chunkGasLimit the gas limit of any one chunk of calls, i.e. bin capacity\n * @param defaultGasRequired the default amount of gas an individual call should cost if not specified\n */\nexport default function chunkCalls(\n calls: T[],\n chunkGasLimit: number,\n defaultGasRequired: number = DEFAULT_CHUNK_GAS_REQUIRED\n): T[][] {\n return (\n calls\n // first sort by gas required\n .sort((c1, c2) => (c2.gasRequired ?? defaultGasRequired) - (c1.gasRequired ?? defaultGasRequired))\n // then bin the calls according to the first fit algorithm\n .reduce[]>((bins, call) => {\n const gas = call.gasRequired ?? defaultGasRequired\n for (const bin of bins) {\n if (bin.cumulativeGasLimit + gas <= chunkGasLimit) {\n bin.calls.push(call)\n bin.cumulativeGasLimit += gas\n return bins\n }\n }\n // didn't find a bin for the call, make a new bin\n bins.push({\n calls: [call],\n cumulativeGasLimit: gas,\n })\n return bins\n }, [])\n // pull out just the calls from each bin\n .map((b) => b.calls)\n )\n}\n","// TODO de-duplicate this file with web interface\n// https://github.com/Uniswap/interface/blob/main/src/utils/retry.ts\n\nfunction wait(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\nfunction waitRandom(min: number, max: number): Promise {\n return wait(min + Math.round(Math.random() * Math.max(0, max - min)))\n}\n\n/**\n * This error is thrown if the function is cancelled before completing\n */\nclass CancelledError extends Error {\n public isCancelledError: true = true\n constructor() {\n super('Cancelled')\n }\n}\n\n/**\n * Throw this error if the function should retry\n */\nexport class RetryableError extends Error {\n public isRetryableError: true = true\n}\n\nexport interface RetryOptions {\n n: number\n minWait: number\n maxWait: number\n}\n\n/**\n * Retries the function that returns the promise until the promise successfully resolves up to n retries\n * @param fn function to retry\n * @param n how many times to retry\n * @param minWait min wait between retries in ms\n * @param maxWait max wait between retries in ms\n */\nexport function retry(\n fn: () => Promise,\n { n, minWait, maxWait }: RetryOptions\n): { promise: Promise; cancel: () => void } {\n let completed = false\n let rejectCancelled: (error: Error) => void\n const promise = new Promise(async (resolve, reject) => {\n rejectCancelled = reject\n while (true) {\n let result: T\n try {\n result = await fn()\n if (!completed) {\n resolve(result)\n completed = true\n }\n break\n } catch (error) {\n if (completed) {\n break\n }\n if (n <= 0 || !(error as any).isRetryableError) {\n reject(error)\n completed = true\n break\n }\n n--\n }\n await waitRandom(minWait, maxWait)\n }\n })\n return {\n promise,\n cancel: () => {\n if (completed) return\n completed = true\n rejectCancelled(new CancelledError())\n },\n }\n}\n","// TODO de-duplicate this file with web interface\n// https://github.com/Uniswap/interface/blob/main/src/hooks/useDebounce.ts\n\nimport { useEffect, useState } from 'react'\n\n// modified from https://usehooks.com/useDebounce/\nexport default function useDebounce(value: T, delay: number): T {\n const [debouncedValue, setDebouncedValue] = useState(value)\n\n useEffect(() => {\n // Update debounced value after delay\n const handler = setTimeout(() => {\n setDebouncedValue(value)\n }, delay)\n\n // Cancel the timeout if value changes (also on delay change or unmount)\n // This is how we prevent debounced value from updating if value is changed ...\n // .. within the delay period. Timeout gets cleared and restarted.\n return () => {\n clearTimeout(handler)\n }\n }, [value, delay])\n\n return debouncedValue\n}\n","export default [\n {\n inputs: [],\n name: 'getCurrentBlockTimestamp',\n outputs: [\n {\n internalType: 'uint256',\n name: 'timestamp',\n type: 'uint256',\n },\n ],\n stateMutability: 'view',\n type: 'function',\n },\n {\n inputs: [\n {\n internalType: 'address',\n name: 'addr',\n type: 'address',\n },\n ],\n name: 'getEthBalance',\n outputs: [\n {\n internalType: 'uint256',\n name: 'balance',\n type: 'uint256',\n },\n ],\n stateMutability: 'view',\n type: 'function',\n },\n {\n inputs: [\n {\n components: [\n {\n internalType: 'address',\n name: 'target',\n type: 'address',\n },\n {\n internalType: 'uint256',\n name: 'gasLimit',\n type: 'uint256',\n },\n {\n internalType: 'bytes',\n name: 'callData',\n type: 'bytes',\n },\n ],\n internalType: 'struct PancakeInterfaceMulticall.Call[]',\n name: 'calls',\n type: 'tuple[]',\n },\n ],\n name: 'multicall',\n outputs: [\n {\n internalType: 'uint256',\n name: 'blockNumber',\n type: 'uint256',\n },\n {\n components: [\n {\n internalType: 'bool',\n name: 'success',\n type: 'bool',\n },\n {\n internalType: 'uint256',\n name: 'gasUsed',\n type: 'uint256',\n },\n {\n internalType: 'bytes',\n name: 'returnData',\n type: 'bytes',\n },\n ],\n internalType: 'struct PancakeInterfaceMulticall.Result[]',\n name: 'returnData',\n type: 'tuple[]',\n },\n ],\n stateMutability: 'nonpayable',\n type: 'function',\n },\n] as const\n","import React, { Dispatch, useEffect, useMemo, useRef } from 'react'\nimport { useDispatch, useSelector } from 'react-redux'\nimport { CHUNK_GAS_LIMIT, DEFAULT_CALL_GAS_REQUIRED } from './constants'\nimport type { MulticallContext } from './context'\nimport type { MulticallActions } from './slice'\nimport type { Call, MulticallState, WithMulticallState, ListenerOptions, MulticallInfo } from './types'\nimport { parseCallKey, toCallKey } from './utils/callKeys'\nimport chunkCalls from './utils/chunkCalls'\nimport { retry, RetryableError } from './utils/retry'\nimport useDebounce from './utils/useDebounce'\nimport IMulticallABI from './abi/InterfaceMulticall'\n\nconst FETCH_RETRY_CONFIG = {\n n: Infinity,\n minWait: 1000,\n maxWait: 2500,\n}\n\n/**\n * Fetches a chunk of calls, enforcing a minimum block number constraint\n * @param multicall multicall contract to fetch against\n * @param chunk chunk of calls to make\n * @param blockNumber block number passed as the block tag in the eth_call\n */\nasync function fetchChunk(\n multicallInfo: MulticallInfo,\n chunk: Call[],\n blockNumber: number,\n isDebug?: boolean\n): Promise {\n console.debug('Fetching chunk', chunk, blockNumber, chunk.map((obj) => ({\n target: obj.address,\n callData: obj.callData,\n gasLimit: obj.gasRequired ?? DEFAULT_CALL_GAS_REQUIRED,\n })))\n try {\n const {\n result: [, returnData], // [blockNumber, results]\n }: { result: [any, any[]] } = await (multicallInfo.provider as any).simulateContract({\n abi: IMulticallABI,\n address: multicallInfo.address,\n functionName: 'multicall',\n args: [\n chunk.map((obj) => ({\n target: obj.address,\n callData: obj.callData,\n gasLimit: obj.gasRequired ?? DEFAULT_CALL_GAS_REQUIRED,\n }))\n ],\n // we aren't passing through the block gas limit we used to create the chunk, because it causes a problem with the integ tests\n blockNumber: BigInt(blockNumber)\n }\n )\n if (isDebug) {\n returnData.forEach(({ gasUsed, returnData, success }, i) => {\n if (\n !success &&\n returnData.length === 2 &&\n gasUsed >= (Math.floor((chunk[i].gasRequired ?? DEFAULT_CALL_GAS_REQUIRED) * 0.95))\n ) {\n console.warn(\n `A call failed due to requiring ${gasUsed.toString()} vs. allowed ${chunk[i].gasRequired ?? DEFAULT_CALL_GAS_REQUIRED\n }`,\n chunk[i]\n )\n }\n })\n }\n\n return returnData\n } catch (e) {\n const error = e as any\n if (error.code === -32000 || error.message?.indexOf('header not found') !== -1) {\n throw new RetryableError(`header not found for block number ${blockNumber}`)\n } else if (error.code === -32603 || error.message?.indexOf('execution ran out of gas') !== -1) {\n if (chunk.length > 1) {\n if (process.env.NODE_ENV === 'development') {\n console.debug('Splitting a chunk in 2', chunk)\n }\n const half = Math.floor(chunk.length / 2)\n const [c0, c1] = await Promise.all([\n fetchChunk(multicallInfo, chunk.slice(0, half), blockNumber),\n fetchChunk(multicallInfo, chunk.slice(half, chunk.length), blockNumber),\n ])\n return c0.concat(c1)\n }\n }\n console.error('Failed to fetch chunk', error)\n throw error\n }\n}\n\n/**\n * From the current all listeners state, return each call key mapped to the\n * minimum number of blocks per fetch. This is how often each key must be fetched.\n * @param allListeners the all listeners state\n * @param chainId the current chain id\n */\nexport function activeListeningKeys(\n allListeners: MulticallState['callListeners'],\n chainId?: number\n): { [callKey: string]: number } {\n if (!allListeners || !chainId) return {}\n const listeners = allListeners[chainId]\n if (!listeners) return {}\n\n return Object.keys(listeners).reduce<{ [callKey: string]: number }>((memo, callKey) => {\n const keyListeners = listeners[callKey]\n\n memo[callKey] = Object.keys(keyListeners)\n .filter((key) => {\n const blocksPerFetch = parseInt(key)\n if (blocksPerFetch <= 0) return false\n return keyListeners[blocksPerFetch] > 0\n })\n .reduce((previousMin, current) => {\n return Math.min(previousMin, parseInt(current))\n }, Infinity)\n return memo\n }, {})\n}\n\n/**\n * Return the keys that need to be refetched\n * @param callResults current call result state\n * @param listeningKeys each call key mapped to how old the data can be in blocks\n * @param chainId the current chain id\n * @param latestBlockNumber the latest block number\n */\nexport function outdatedListeningKeys(\n callResults: MulticallState['callResults'],\n listeningKeys: { [callKey: string]: number },\n chainId: number | undefined,\n latestBlockNumber: number | undefined\n): string[] {\n if (!chainId || !latestBlockNumber) return []\n const results = callResults[chainId]\n // no results at all, load everything\n if (!results) return Object.keys(listeningKeys)\n\n return Object.keys(listeningKeys).filter((callKey) => {\n const blocksPerFetch = listeningKeys[callKey]\n\n const data = callResults[chainId][callKey]\n // no data, must fetch\n if (!data) return true\n\n const minDataBlockNumber = latestBlockNumber - (blocksPerFetch - 1)\n\n // already fetching it for a recent enough block, don't refetch it\n if (data.fetchingBlockNumber && data.fetchingBlockNumber >= minDataBlockNumber) return false\n\n // if data is older than minDataBlockNumber, fetch it\n return !data.blockNumber || data.blockNumber < minDataBlockNumber\n })\n}\n\ninterface FetchChunkContext {\n actions: MulticallActions\n dispatch: Dispatch\n chainId: number\n latestBlockNumber: number\n isDebug?: boolean\n}\n\nfunction onFetchChunkSuccess(\n context: FetchChunkContext,\n chunk: Call[],\n result: readonly { success: boolean; returnData: string }[]\n) {\n const { actions, dispatch, chainId, latestBlockNumber, isDebug } = context\n\n // split the returned slice into errors and results\n const { erroredCalls, results } = chunk.reduce<{\n erroredCalls: Call[]\n results: { [callKey: string]: string | null }\n }>(\n (memo, call, i) => {\n if (result[i].success) {\n memo.results[toCallKey(call)] = result[i].returnData ?? null\n } else {\n memo.erroredCalls.push(call)\n }\n return memo\n },\n { erroredCalls: [], results: {} }\n )\n\n // dispatch any new results\n if (Object.keys(results).length > 0)\n dispatch(\n actions.updateMulticallResults({\n chainId,\n results,\n blockNumber: latestBlockNumber,\n })\n )\n\n // dispatch any errored calls\n if (erroredCalls.length > 0) {\n if (isDebug) {\n result.forEach((returnData, ix) => {\n if (!returnData.success) {\n console.debug('Call failed', chunk[ix], returnData)\n }\n })\n } else {\n console.debug('Calls errored in fetch', erroredCalls)\n }\n dispatch(\n actions.errorFetchingMulticallResults({\n calls: erroredCalls,\n chainId,\n fetchingBlockNumber: latestBlockNumber,\n })\n )\n }\n}\n\nfunction onFetchChunkFailure(context: FetchChunkContext, chunk: Call[], error: any) {\n const { actions, dispatch, chainId, latestBlockNumber } = context\n\n if (error.isCancelledError) {\n console.debug('Cancelled fetch for blockNumber', latestBlockNumber, chunk, chainId)\n return\n }\n console.error('Failed to fetch multicall chunk', chunk, chainId, error)\n dispatch(\n actions.errorFetchingMulticallResults({\n calls: chunk,\n chainId,\n fetchingBlockNumber: latestBlockNumber,\n })\n )\n}\n\nexport interface UpdaterProps {\n context: MulticallContext\n chainId: number | undefined // For now, one updater is required for each chainId to be watched\n latestBlockNumber: number | undefined\n multicallInfo: MulticallInfo\n isDebug?: boolean\n listenerOptions?: ListenerOptions\n}\n\nfunction Updater(props: UpdaterProps): null {\n const { context, chainId, latestBlockNumber, multicallInfo, isDebug, listenerOptions } = props\n const { actions, reducerPath } = context\n const dispatch = useDispatch()\n\n // set user configured listenerOptions in state for given chain ID.\n useEffect(() => {\n if (chainId && listenerOptions) {\n dispatch(actions.updateListenerOptions({ chainId, listenerOptions }))\n }\n }, [chainId, listenerOptions, actions, dispatch])\n\n const state = useSelector((state: WithMulticallState) => state[reducerPath])\n\n // wait for listeners to settle before triggering updates\n const debouncedListeners = useDebounce(state.callListeners, 100)\n const cancellations = useRef<{ blockNumber: number; cancellations: (() => void)[] }>()\n\n const listeningKeys: { [callKey: string]: number } = useMemo(() => {\n return activeListeningKeys(debouncedListeners, chainId)\n }, [debouncedListeners, chainId])\n\n const serializedOutdatedCallKeys = useMemo(() => {\n const outdatedCallKeys = outdatedListeningKeys(state.callResults, listeningKeys, chainId, latestBlockNumber)\n return JSON.stringify(outdatedCallKeys.sort())\n }, [chainId, state.callResults, listeningKeys, latestBlockNumber])\n\n useEffect(() => {\n if (!latestBlockNumber || !chainId || !multicallInfo) return\n\n const outdatedCallKeys: string[] = JSON.parse(serializedOutdatedCallKeys)\n if (outdatedCallKeys.length === 0) return\n const calls = outdatedCallKeys.map((key) => parseCallKey(key))\n\n const chunkedCalls = chunkCalls(calls, CHUNK_GAS_LIMIT)\n\n if (cancellations.current && cancellations.current.blockNumber !== latestBlockNumber) {\n cancellations.current.cancellations.forEach((c) => c())\n }\n\n dispatch(\n actions.fetchingMulticallResults({\n calls,\n chainId,\n fetchingBlockNumber: latestBlockNumber,\n })\n )\n\n const fetchChunkContext = {\n actions,\n dispatch,\n chainId,\n latestBlockNumber,\n isDebug,\n }\n // Execute fetches and gather cancellation callbacks\n const newCancellations = chunkedCalls.map((chunk) => {\n const { cancel, promise } = retry(\n () => fetchChunk(multicallInfo, chunk, latestBlockNumber, isDebug),\n FETCH_RETRY_CONFIG\n )\n promise\n .then((result) => onFetchChunkSuccess(fetchChunkContext, chunk, result))\n .catch((error) => onFetchChunkFailure(fetchChunkContext, chunk, error))\n return cancel\n })\n\n cancellations.current = {\n blockNumber: latestBlockNumber,\n cancellations: newCancellations,\n }\n }, [actions, chainId, multicallInfo, dispatch, serializedOutdatedCallKeys, latestBlockNumber, isDebug])\n\n return null\n}\n\nexport function createUpdater(context: MulticallContext) {\n const UpdaterContextBound = (props: Omit) => {\n return \n }\n return UpdaterContextBound\n}\n","import type { MulticallContext } from './context'\nimport {\n useMultiChainMultiContractSingleData as _useMultiChainMultiContractSingleData,\n useMultiChainSingleContractSingleData as _useMultiChainSingleContractSingleData,\n useMultipleContractSingleData as _useMultipleContractSingleData,\n useSingleCallResult as _useSingleCallResult,\n useSingleContractMultipleData as _useSingleContractMultipleData,\n useSingleContractWithCallData as _useSingleContractWithCallData,\n} from './hooks'\nimport { createMulticallSlice } from './slice'\nimport { createUpdater } from './updater'\n\ntype RemoveFirstFromTuple = T['length'] extends 0\n ? undefined\n : ((...b: T) => void) extends (a: any, ...b: infer I) => void\n ? I\n : []\ntype ParamsWithoutContext any> = RemoveFirstFromTuple>\n\nexport interface MulticallOptions {\n reducerPath?: string\n // More options can be added here as multicall's capabilities are extended\n}\n\n// Inspired by RTK Query's createApi\nexport function createMulticall(options?: MulticallOptions) {\n const reducerPath = options?.reducerPath ?? 'multicall'\n const slice = createMulticallSlice(reducerPath)\n const { actions, reducer } = slice\n const context: MulticallContext = { reducerPath, actions }\n\n const useMultipleContractSingleData = (...args: ParamsWithoutContext) =>\n _useMultipleContractSingleData(context, ...args)\n const useSingleContractMultipleData = (...args: ParamsWithoutContext) =>\n _useSingleContractMultipleData(context, ...args)\n const useSingleContractWithCallData = (...args: ParamsWithoutContext) =>\n _useSingleContractWithCallData(context, ...args)\n const useSingleCallResult = (...args: ParamsWithoutContext) =>\n _useSingleCallResult(context, ...args)\n const useMultiChainMultiContractSingleData = (\n ...args: ParamsWithoutContext\n ) => _useMultiChainMultiContractSingleData(context, ...args)\n const useMultiChainSingleContractSingleData = (\n ...args: ParamsWithoutContext\n ) => _useMultiChainSingleContractSingleData(context, ...args)\n const hooks = {\n useMultipleContractSingleData,\n useSingleContractMultipleData,\n useSingleContractWithCallData,\n useSingleCallResult,\n useMultiChainMultiContractSingleData,\n useMultiChainSingleContractSingleData,\n }\n\n const Updater = createUpdater(context)\n\n return {\n reducerPath,\n reducer,\n actions,\n hooks,\n Updater,\n }\n}\n"],"names":["DEFAULT_BLOCKS_PER_FETCH","DEFAULT_CALL_GAS_REQUIRED","DEFAULT_CHUNK_GAS_REQUIRED","CHUNK_GAS_LIMIT","CONSERVATIVE_BLOCK_GAS_LIMIT","INVALID_RESULT","valid","blockNumber","undefined","data","NEVER_RELOAD","blocksPerFetch","Infinity","INVALID_CALL_STATE","result","loading","syncing","error","LOADING_CALL_STATE","toCallKey","call","key","address","callData","gasRequired","Number","isSafeInteger","Error","parseCallKey","callKey","pcs","split","includes","length","_extends","parseInt","callsToCallKeys","calls","_calls$filter$map$sor","_calls$filter","filter","c","Boolean","map","sort","callKeysToCalls","callKeys","useCallStates","results","contractInterface","fragment","latestBlockNumber","syncingBlockNumber","useMemo","lowestBlockNumber","reduce","memo","Math","min","max","i","resultFragment","toCallState","callResult","success","decodeFunctionResult","abi","functionName","console","debug","isMethodArg","x","BigInt","indexOf","isValidMethodArgs","Array","isArray","every","xi","useCallsDataSubscription","context","chainId","listenerOptions","reducerPath","actions","callResults","useSelector","state","defaultListenerOptions","dispatch","useDispatch","serializedCallKeys","JSON","stringify","useEffect","parse","blocksPerFetchFromState","_chainId","blocksPerFetchForChain","_ref","_listenerOptions$bloc","addMulticallListeners","options","removeMulticallListeners","lastResults","useRef","isChanged","current","_callResults$chainId","areCallResultsEqual","push","a","b","useMultichainCallsDataSubscription","chainToCalls","sortedChainIds","getChainIds","chainCallKeysTuple","chainCallKeysTuples","batch","_iterator","_createForOfIteratorHelperLoose","_step","done","_chainId2","_ref2","_listenerOptions$bloc2","_step$value","value","_iterator2","_step2","_chainId3","_ref3","_listenerOptions$bloc3","_step2$value","_callResults$chainId2","useSingleContractMultipleData","contract","methodName","callInputs","_ref4","_getAbiItem","getAbiItem","name","callDatas","callInput","encodeFunctionData","args","useMultipleContractSingleData","addresses","_ref5","_useCallData","useCallData","useSingleCallResult","inputs","_useSingleContractMul","useSingleContractWithCallData","_ref6","useCallback","_getAbiItem2","substring","useMultiChainMultiContractSingleData","chainToBlockNumber","chainToAddresses","_ref7","_useCallData2","chainIdToResults","combinedResults","useMultiChainSingleContractSingleData","chainToAddress","chainIdToAddresses","multiContractResults","_multiContractResults","_multiContractResults2","_getAbiItem3","chainIdMap","Object","keys","initialState","createMulticallSlice","createSlice","reducers","action","_action$payload","payload","listeners","callListeners","_listeners$chainId","forEach","_listeners$chainId$ca","_listeners$chainId$ca2","_action$payload2","fetchingMulticallResults","_action$payload3","fetchingBlockNumber","_state$callResults$ch","_current$fetchingBloc","errorFetchingMulticallResults","_action$payload4","_state$callResults$ch2","updateMulticallResults","_action$payload5","_state$callResults$ch3","_current$blockNumber","updateListenerOptions","_action$payload6","_state$listenerOption","chunkCalls","chunkGasLimit","defaultGasRequired","c1","c2","_c2$gasRequired","_c1$gasRequired","bins","gas","_call$gasRequired","bin","cumulativeGasLimit","wait","ms","Promise","resolve","setTimeout","waitRandom","round","random","CancelledError","_Error","_this","_inheritsLoose","_wrapNativeSuper","RetryableError","_Error2","_this2","retry","fn","n","minWait","maxWait","completed","rejectCancelled","promise","_asyncToGenerator","_regeneratorRuntime","mark","_callee","reject","wrap","_callee$","_context","prev","next","sent","abrupt","t0","isRetryableError","stop","_x","_x2","apply","arguments","cancel","useDebounce","delay","_useState","useState","debouncedValue","setDebouncedValue","handler","clearTimeout","outputs","internalType","type","stateMutability","components","FETCH_RETRY_CONFIG","fetchChunk","_x3","_x4","_fetchChunk","multicallInfo","chunk","isDebug","_yield$multicallInfo$","_yield$multicallInfo$2","returnData","_error$message","_error$message2","half","_yield$Promise$all","c0","obj","_obj$gasRequired","target","gasLimit","provider","simulateContract","IMulticallABI","_obj$gasRequired2","gasUsed","floor","_chunk$i$gasRequired","_chunk$i$gasRequired2","warn","toString","code","message","all","slice","concat","activeListeningKeys","allListeners","keyListeners","previousMin","outdatedListeningKeys","listeningKeys","minDataBlockNumber","onFetchChunkSuccess","_chunk$reduce","_result$i$returnData","erroredCalls","ix","onFetchChunkFailure","isCancelledError","Updater","props","debouncedListeners","cancellations","serializedOutdatedCallKeys","outdatedCallKeys","chunkedCalls","fetchChunkContext","newCancellations","_retry","then","createUpdater","UpdaterContextBound","React","createMulticall","_options$reducerPath","reducer","_len","_key","_useMultipleContractSingleData","_len2","_key2","_useSingleContractMultipleData","_len3","_key3","_useSingleContractWithCallData","_len4","_key4","_useSingleCallResult","_len5","_key5","_useMultiChainMultiContractSingleData","_len6","_key6","_useMultiChainSingleContractSingleData","hooks"],"mappings":"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"}
\ No newline at end of file
diff --git a/dist/redux-multicall-viem.cjs.production.min.js b/dist/redux-multicall-viem.cjs.production.min.js
new file mode 100644
index 0000000..a0105ed
--- /dev/null
+++ b/dist/redux-multicall-viem.cjs.production.min.js
@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t,e=require("react"),r=(t=e)&&"object"==typeof t&&"default"in t?t.default:t,n=require("react-redux"),a=require("viem"),u=require("@reduxjs/toolkit"),o={valid:!1,blockNumber:void 0,data:void 0},i={valid:!1,result:void 0,loading:!1,syncing:!1,error:!1},l={valid:!0,result:void 0,loading:!0,syncing:!0,error:!1};function c(t,e){(null==e||e>t.length)&&(e=t.length);for(var r=0,n=Array(e);r=t.length?{done:!0}:{done:!1,value:t[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function h(){return(h=Object.assign?Object.assign.bind():function(t){for(var e=1;e=0;--u){var o=this.tryEntries[u],i=o.completion;if("root"===o.tryLoc)return a("end");if(o.tryLoc<=this.prev){var l=n.call(o,"catchLoc"),c=n.call(o,"finallyLoc");if(l&&c){if(this.prev=0;--r){var a=this.tryEntries[r];if(a.tryLoc<=this.prev&&n.call(a,"finallyLoc")&&this.prev=0;--e){var r=this.tryEntries[e];if(r.finallyLoc===t)return this.complete(r.completion,r.afterLoc),I(r),v}},catch:function(t){for(var e=this.tryEntries.length-1;e>=0;--e){var r=this.tryEntries[e];if(r.tryLoc===t){var n=r.completion;if("throw"===n.type){var a=n.arg;I(r)}return a}}throw Error("illegal catch attempt")},delegateYield:function(e,r,n){return this.delegate={iterator:_(e),resultName:r,nextLoc:n},"next"===this.method&&(this.arg=t),v}},e}function g(t,e){return(g=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t})(t,e)}function k(t){var e="function"==typeof Map?new Map:void 0;return(k=function(t){if(null===t||!function(t){try{return-1!==Function.toString.call(t).indexOf("[native code]")}catch(e){return"function"==typeof t}}(t))return t;if("function"!=typeof t)throw new TypeError("Super expression must either be null or a function");if(void 0!==e){if(e.has(t))return e.get(t);e.set(t,r)}function r(){return d(t,arguments,v(this).constructor)}return r.prototype=Object.create(t.prototype,{constructor:{value:r,enumerable:!1,writable:!0,configurable:!0}}),g(r,t)})(t)}function w(t){var e=t.address+"-"+t.callData;if(t.gasRequired){if(!Number.isSafeInteger(t.gasRequired))throw new Error("Invalid number: "+t.gasRequired);e+="-"+t.gasRequired}return e}function N(t){var e=t.split("-");if(![2,3].includes(e.length))throw new Error("Invalid call key: "+t);return h({address:e[0],callData:e[1]},e[2]?{gasRequired:Number.parseInt(e[2])}:{})}function L(t){var e,r;return null!=(e=null==t||null==(r=t.filter((function(t){return Boolean(t)})))||null==(r=r.map(w))?void 0:r.sort())?e:[]}function x(t){return null!=t&&t.length?t.map((function(t){return N(t)})):null}function E(t,r,n,a){var u=e.useMemo((function(){var e=t.reduce((function(t,e){return e.blockNumber?Math.min(null!=t?t:e.blockNumber,e.blockNumber):t}),void 0);return Math.max(null!=e?e:0,null!=a?a:0)}),[t,a]);return e.useMemo((function(){return t.map((function(t,e){var a="function"==typeof n?n(e):n;return O(t,r,a,u)}))}),[r,n,t,u])}function O(t,e,r,n){if(!t||!t.valid)return i;var u=t.data,o=t.blockNumber;if(!(o&&e&&r&&n))return l;var c=u&&u.length>2,s=o=Math.floor(.95*(null!=(n=r[e].gasRequired)?n:1e6))&&console.warn("A call failed due to requiring "+u.toString()+" vs. allowed "+(null!=(a=r[e].gasRequired)?a:1e6),r[e])})),t.abrupt("return",u);case 11:if(t.prev=11,t.t0=t.catch(1),-32e3!==(l=t.t0).code&&-1===(null==(o=l.message)?void 0:o.indexOf("header not found"))){t.next=18;break}throw new G("header not found for block number "+n);case 18:if(-32603!==l.code&&-1===(null==(i=l.message)?void 0:i.indexOf("execution ran out of gas"))){t.next=28;break}if(!(r.length>1)){t.next=28;break}return c=Math.floor(r.length/2),t.next=24,Promise.all([V(e,r.slice(0,c),n),V(e,r.slice(c,r.length),n)]);case 24:return t.abrupt("return",(s=t.sent)[0].concat(s[1]));case 28:throw console.error("Failed to fetch chunk",l),l;case 30:case"end":return t.stop()}}),t,null,[[1,11]])})))).apply(this,arguments)}function K(t){var r=t.context,a=t.chainId,u=t.latestBlockNumber,o=t.multicallInfo,i=t.isDebug,l=t.listenerOptions,c=r.actions,s=r.reducerPath,d=n.useDispatch();e.useEffect((function(){a&&l&&d(c.updateListenerOptions({chainId:a,listenerOptions:l}))}),[a,l,c,d]);var h,v,m,y,g=n.useSelector((function(t){return t[s]})),k=(m=(v=e.useState(h=g.callListeners))[0],y=v[1],e.useEffect((function(){var t=setTimeout((function(){y(h)}),100);return function(){clearTimeout(t)}}),[h,100]),m),L=e.useRef(),x=e.useMemo((function(){return function(t,e){if(!t||!e)return{};var r=t[e];return r?Object.keys(r).reduce((function(t,e){var n=r[e];return t[e]=Object.keys(n).filter((function(t){var e=parseInt(t);return!(e<=0)&&n[e]>0})).reduce((function(t,e){return Math.min(t,parseInt(e))}),Infinity),t}),{}):{}}(k,a)}),[k,a]),E=e.useMemo((function(){var t=function(t,e,r,n){return r&&n?t[r]?Object.keys(e).filter((function(a){var u=t[r][a];if(!u)return!0;var o=n-(e[a]-1);return!(u.fetchingBlockNumber&&u.fetchingBlockNumber>=o)&&(!u.blockNumber||u.blockNumber0&&a(n.updateMulticallResults({chainId:u,results:s,blockNumber:o})),c.length>0&&(i?r.forEach((function(t,r){t.success||console.debug("Call failed",e[r],t)})):console.debug("Calls errored in fetch",c),a(n.errorFetchingMulticallResults({calls:c,chainId:u,fetchingBlockNumber:o})))}(n,t,e)})).catch((function(e){return function(t,e,r){var n=t.actions,a=t.dispatch,u=t.chainId,o=t.latestBlockNumber;r.isCancelledError?console.debug("Cancelled fetch for blockNumber",o,e,u):(console.error("Failed to fetch multicall chunk",e,u,r),a(n.errorFetchingMulticallResults({calls:e,chainId:u,fetchingBlockNumber:o})))}(n,t,e)})),h}));L.current={blockNumber:u,cancellations:l}}}}),[c,a,o,d,E,u,i]),null}function H(t){return function(e){return r.createElement(K,Object.assign({context:t},e))}}exports.CHUNK_GAS_LIMIT=1e8,exports.CONSERVATIVE_BLOCK_GAS_LIMIT=1e7,exports.DEFAULT_BLOCKS_PER_FETCH=1,exports.DEFAULT_CALL_GAS_REQUIRED=1e6,exports.DEFAULT_CHUNK_GAS_REQUIRED=2e5,exports.INVALID_CALL_STATE=i,exports.INVALID_RESULT=o,exports.LOADING_CALL_STATE=l,exports.NEVER_RELOAD={blocksPerFetch:Infinity},exports.createMulticall=function(t){var e,r=null!=(e=null==t?void 0:t.reducerPath)?e:"multicall",n=function(t){return u.createSlice({name:t,initialState:F,reducers:{addMulticallListeners:function(t,e){var r,n=e.payload,a=n.calls,u=n.chainId,o=n.options.blocksPerFetch,i=t.callListeners?t.callListeners:t.callListeners={};i[u]=null!=(r=i[u])?r:{},a.forEach((function(t){var e,r,n=w(t);i[u][n]=null!=(e=i[u][n])?e:{},i[u][n][o]=(null!=(r=i[u][n][o])?r:0)+1}))},removeMulticallListeners:function(t,e){var r=e.payload,n=r.calls,a=r.chainId,u=r.options.blocksPerFetch,o=t.callListeners?t.callListeners:t.callListeners={};o[a]&&n.forEach((function(t){var e=w(t);o[a][e]&&o[a][e][u]&&(1===o[a][e][u]?delete o[a][e][u]:o[a][e][u]--)}))},fetchingMulticallResults:function(t,e){var r,n=e.payload,a=n.chainId,u=n.fetchingBlockNumber,o=n.calls;t.callResults[a]=null!=(r=t.callResults[a])?r:{},o.forEach((function(e){var r=w(e),n=t.callResults[a][r];if(n){var o;if((null!=(o=n.fetchingBlockNumber)?o:0)>=u)return;t.callResults[a][r].fetchingBlockNumber=u}else t.callResults[a][r]={fetchingBlockNumber:u}}))},errorFetchingMulticallResults:function(t,e){var r,n=e.payload,a=n.chainId,u=n.fetchingBlockNumber,o=n.calls;t.callResults[a]=null!=(r=t.callResults[a])?r:{},o.forEach((function(e){var r=w(e),n=t.callResults[a][r];n&&"number"==typeof n.fetchingBlockNumber&&n.fetchingBlockNumber<=u&&(delete n.fetchingBlockNumber,n.data=null,n.blockNumber=u)}))},updateMulticallResults:function(t,e){var r,n=e.payload,a=n.chainId,u=n.results,o=n.blockNumber;t.callResults[a]=null!=(r=t.callResults[a])?r:{},Object.keys(u).forEach((function(e){var r,n=t.callResults[a][e];(null!=(r=null==n?void 0:n.blockNumber)?r:0)>o||(null==n?void 0:n.data)===u[e]&&(null==n?void 0:n.blockNumber)===o||(t.callResults[a][e]={data:u[e],blockNumber:o})}))},updateListenerOptions:function(t,e){var r,n=e.payload,a=n.chainId,u=n.listenerOptions;t.listenerOptions=null!=(r=t.listenerOptions)?r:{},t.listenerOptions[a]=u}}})}(r),a=n.actions,o={reducerPath:r,actions:a};return{reducerPath:r,reducer:n.reducer,actions:a,hooks:{useMultipleContractSingleData:function(){for(var t=arguments.length,e=new Array(t),r=0;r) {\n return (\n calls\n ?.filter((c): c is Call => Boolean(c))\n ?.map(toCallKey)\n ?.sort() ?? []\n )\n}\n\nexport function callKeysToCalls(callKeys: string[]) {\n if (!callKeys?.length) return null\n return callKeys.map((key) => parseCallKey(key))\n}\n","import { useMemo } from 'react'\nimport { INVALID_CALL_STATE, LOADING_CALL_STATE } from '../constants'\nimport type { CallResult, CallState, CallStateResult } from '../types'\nimport { AbiFunction, decodeFunctionResult } from 'viem'\n\n// Converts CallResult[] to CallState[], only updating if call states have changed.\n// Ensures that CallState results remain referentially stable when unchanged, preventing\n// spurious re-renders which would otherwise occur because mapping always creates a new object.\nexport function useCallStates(\n results: CallResult[],\n contractInterface: AbiFunction[] | undefined,\n fragment: ((i: number) => string | undefined) | string | undefined,\n latestBlockNumber: number | undefined\n): CallState[] {\n // Avoid refreshing the results with every changing block number (eg latestBlockNumber).\n // Instead, only refresh the results if they need to be synced - if there is a result which is stale, for which blockNumber < latestBlockNumber.\n const syncingBlockNumber = useMemo(() => {\n const lowestBlockNumber = results.reduce(\n (memo, result) => (result.blockNumber ? Math.min(memo ?? result.blockNumber, result.blockNumber) : memo),\n undefined\n )\n return Math.max(lowestBlockNumber ?? 0, latestBlockNumber ?? 0)\n }, [results, latestBlockNumber])\n\n return useMemo(() => {\n return results.map((result, i) => {\n const resultFragment = typeof fragment === 'function' ? fragment(i) : fragment\n return toCallState(result, contractInterface, resultFragment, syncingBlockNumber)\n })\n }, [contractInterface, fragment, results, syncingBlockNumber])\n}\n\nexport function toCallState(\n callResult: CallResult | undefined,\n contractInterface: AbiFunction[] | undefined,\n fragment: string | undefined,\n syncingBlockNumber: number | undefined\n): CallState {\n if (!callResult || !callResult.valid) {\n return INVALID_CALL_STATE\n }\n\n const { data, blockNumber } = callResult\n if (!blockNumber || !contractInterface || !fragment || !syncingBlockNumber) {\n return LOADING_CALL_STATE\n }\n\n const success = data && data.length > 2\n const syncing = blockNumber < syncingBlockNumber\n let result: CallStateResult | undefined = undefined\n if (success && data) {\n try {\n result = (decodeFunctionResult as any)({\n abi: contractInterface,\n functionName: fragment,\n data: data as any,\n }) as any\n } catch (error) {\n console.debug('Result data parsing failed', fragment, data)\n return {\n valid: true,\n loading: false,\n error: true,\n syncing,\n result,\n }\n }\n }\n return {\n valid: true,\n loading: false,\n syncing,\n result,\n error: !success,\n }\n}\n","export type MethodArg = string | number | BigInt\nexport type MethodArgs = Array\n\nexport function isMethodArg(x: unknown): x is MethodArg {\n return (x === null || x === undefined) ? false : typeof BigInt(x as any) === 'bigint' || ['string', 'number'].indexOf(typeof x) !== -1\n}\n\nexport function isValidMethodArgs(x: unknown): x is MethodArgs | undefined {\n return (\n x === undefined ||\n (Array.isArray(x) && x.every((xi) => isMethodArg(xi) || (Array.isArray(xi) && xi.every(isMethodArg))))\n )\n}\n","import { useCallback, useEffect, useMemo, useRef } from 'react'\nimport { batch, useDispatch, useSelector } from 'react-redux'\nimport { INVALID_CALL_STATE, INVALID_RESULT, DEFAULT_BLOCKS_PER_FETCH } from './constants'\nimport type { MulticallContext } from './context'\nimport type {\n Call,\n CallResult,\n CallState,\n ContractInfo,\n ListenerOptions,\n ListenerOptionsWithGas,\n WithMulticallState,\n} from './types'\nimport { callKeysToCalls, callsToCallKeys, toCallKey } from './utils/callKeys'\nimport { toCallState, useCallStates } from './utils/callState'\nimport { isValidMethodArgs, MethodArg } from './validation'\nimport { AbiFunction, encodeFunctionData, getAbiItem } from 'viem'\n\ntype OptionalMethodInputs = Array | undefined\n\n// the lowest level call for subscribing to contract data\nexport function useCallsDataSubscription(\n context: MulticallContext,\n chainId: number | undefined,\n calls: Array,\n listenerOptions?: ListenerOptions\n): CallResult[] {\n const { reducerPath, actions } = context\n const callResults = useSelector((state: WithMulticallState) => state[reducerPath].callResults)\n const defaultListenerOptions = useSelector((state: WithMulticallState) => state[reducerPath].listenerOptions)\n const dispatch = useDispatch()\n const serializedCallKeys: string = useMemo(() => JSON.stringify(callsToCallKeys(calls)), [calls])\n\n // update listeners when there is an actual change that persists for at least 100ms\n useEffect(() => {\n const callKeys: string[] = JSON.parse(serializedCallKeys)\n const calls = callKeysToCalls(callKeys)\n if (!chainId || !calls) return\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n\n dispatch(\n actions.addMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n\n return () => {\n dispatch(\n actions.removeMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n }, [actions, chainId, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions])\n\n const lastResults = useRef([])\n return useMemo(() => {\n let isChanged = lastResults.current.length !== calls.length\n\n // Construct results using a for-loop to handle sparse arrays.\n // Array.prototype.map would skip empty entries.\n let results: CallResult[] = []\n for (let i = 0; i < calls.length; ++i) {\n const call = calls[i]\n let result = INVALID_RESULT\n if (chainId && call) {\n const callResult = callResults[chainId]?.[toCallKey(call)]\n result = {\n valid: true,\n data: callResult?.data && callResult.data !== '0x' ? callResult.data : undefined,\n blockNumber: callResult?.blockNumber,\n }\n }\n\n isChanged = isChanged || !areCallResultsEqual(result, lastResults.current[i])\n results.push(result)\n }\n\n // Force the results to be referentially stable if they have not changed.\n // This is necessary because *all* callResults are passed as deps when initially memoizing the results.\n if (isChanged) {\n lastResults.current = results\n }\n return lastResults.current\n }, [callResults, calls, chainId])\n}\n\nfunction areCallResultsEqual(a: CallResult, b: CallResult) {\n return a.valid === b.valid && a.data === b.data && a.blockNumber === b.blockNumber\n}\n\n// Similar to useCallsDataSubscription above but for subscribing to\n// calls to multiple chains at once\nfunction useMultichainCallsDataSubscription(\n context: MulticallContext,\n chainToCalls: Record>,\n listenerOptions?: ListenerOptions\n): Record {\n const { reducerPath, actions } = context\n const callResults = useSelector((state: WithMulticallState) => state[reducerPath].callResults)\n const defaultListenerOptions = useSelector((state: WithMulticallState) => state[reducerPath].listenerOptions)\n const dispatch = useDispatch()\n\n const serializedCallKeys: string = useMemo(() => {\n const sortedChainIds = getChainIds(chainToCalls).sort()\n const chainCallKeysTuple = sortedChainIds.map((chainId) => {\n const calls = chainToCalls[chainId]\n const callKeys = callsToCallKeys(calls)\n // Note, using a tuple to ensure consistent order when serialized\n return [chainId, callKeys]\n })\n return JSON.stringify(chainCallKeysTuple)\n }, [chainToCalls])\n\n useEffect(() => {\n const chainCallKeysTuples: Array<[number, string[]]> = JSON.parse(serializedCallKeys)\n if (!chainCallKeysTuples?.length) return\n\n batch(() => {\n for (const [chainId, callKeys] of chainCallKeysTuples) {\n const calls = callKeysToCalls(callKeys)\n if (!calls?.length) continue\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n\n dispatch(\n actions.addMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n })\n\n return () => {\n batch(() => {\n for (const [chainId, callKeys] of chainCallKeysTuples) {\n const calls = callKeysToCalls(callKeys)\n if (!calls?.length) continue\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n dispatch(\n actions.removeMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n })\n }\n }, [actions, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions])\n\n return useMemo(\n () =>\n getChainIds(chainToCalls).reduce((result, chainId) => {\n const calls = chainToCalls[chainId]\n result[chainId] = calls.map((call) => {\n if (!chainId || !call) return INVALID_RESULT\n const result = callResults[chainId]?.[toCallKey(call)]\n const data = result?.data && result.data !== '0x' ? result.data : undefined\n return { valid: true, data, blockNumber: result?.blockNumber }\n })\n return result\n }, {} as Record),\n [callResults, chainToCalls]\n )\n}\n\n// formats many calls to a single function on a single contract, with the function name and inputs specified\nexport function useSingleContractMultipleData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n methodName: string,\n callInputs: OptionalMethodInputs[],\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n // Create ethers function fragment\n const fragment = useMemo(\n () => contract && ((getAbiItem as any)({ abi: contract.abi, name: methodName } as any) as any)?.name,\n [contract, methodName]\n )\n\n // Get encoded call data. Note can't use useCallData below b.c. this is for a list of CallInputs\n const callDatas = useMemo(() => {\n if (!contract || !fragment) return []\n return callInputs.map((callInput) =>\n isValidMethodArgs(callInput)\n ? (encodeFunctionData as any)({\n abi: contract.abi,\n functionName: fragment,\n args: callInput,\n })\n : undefined\n )\n }, [callInputs, contract, fragment])\n\n // Create call objects\n const calls = useMemo(() => {\n if (!contract) return []\n return callDatas.map((callData) => {\n if (!callData) return undefined\n return {\n address: contract.address,\n callData,\n gasRequired,\n }\n })\n }, [contract, callDatas, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n return useCallStates(results, contract?.abi, fragment, latestBlockNumber)\n}\n\nexport function useMultipleContractSingleData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n addresses: (string | undefined)[],\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n const { fragment, callData } = useCallData(methodName, contractInterface, callInputs)\n\n // Create call objects\n const calls = useMemo(() => {\n if (!callData) return []\n return addresses.map((address) => {\n if (!address) return undefined\n return { address, callData, gasRequired }\n })\n }, [addresses, callData, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n return useCallStates(results, contractInterface, fragment, latestBlockNumber)\n}\n\nexport function useSingleCallResult(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n methodName: string,\n inputs?: OptionalMethodInputs,\n options?: Partial\n): CallState {\n const callInputs = useMemo(() => [inputs], [inputs])\n return (\n useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options)[0] ??\n INVALID_CALL_STATE\n )\n}\n\n// formats many calls to any number of functions on a single contract, with only the calldata specified\nexport function useSingleContractWithCallData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n callDatas: string[],\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n // Create call objects\n const calls = useMemo(() => {\n if (!contract) return []\n return callDatas.map((callData) => ({\n address: contract.address,\n callData,\n gasRequired,\n }))\n }, [callDatas, contract, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n const fragment = useCallback(\n (i: number) => ((getAbiItem as any)({ abi: contract?.abi as any, name: callDatas[i].substring(0, 10) }) as any)?.name,\n [callDatas, contract]\n )\n return useCallStates(results, contract?.abi, fragment, latestBlockNumber)\n}\n\n// Similar to useMultipleContractSingleData but instead of multiple contracts on one chain,\n// this is for querying compatible contracts on multiple chains\nexport function useMultiChainMultiContractSingleData(\n context: MulticallContext,\n chainToBlockNumber: Record,\n chainToAddresses: Record>,\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): Record {\n const { gasRequired } = options ?? {}\n\n const { fragment, callData } = useCallData(methodName, contractInterface, callInputs)\n\n // Create call objects\n const chainToCalls = useMemo(() => {\n if (!callData || !chainToAddresses) return {}\n return getChainIds(chainToAddresses).reduce((result, chainId) => {\n const addresses = chainToAddresses[chainId]\n const calls = addresses.map((address) => {\n if (!address) return undefined\n return { address, callData, gasRequired }\n })\n result[chainId] = calls\n return result\n }, {} as Record>)\n }, [chainToAddresses, callData, gasRequired])\n\n // Subscribe to call data\n const chainIdToResults = useMultichainCallsDataSubscription(context, chainToCalls, options as ListenerOptions)\n\n // TODO(WEB-2097): Multichain states are not referentially stable, because they cannot use the\n // same codepath (eg useCallStates).\n return useMemo(() => {\n return getChainIds(chainIdToResults).reduce((combinedResults, chainId) => {\n const latestBlockNumber = chainToBlockNumber?.[chainId]\n const results = chainIdToResults[chainId]\n combinedResults[chainId] = results.map((result) =>\n toCallState(result, contractInterface, fragment, latestBlockNumber)\n )\n return combinedResults\n }, {} as Record)\n }, [fragment, contractInterface, chainIdToResults, chainToBlockNumber])\n}\n\n// Similar to useSingleCallResult but instead of one contract on one chain,\n// this is for querying a contract on multiple chains\nexport function useMultiChainSingleContractSingleData(\n context: MulticallContext,\n chainToBlockNumber: Record,\n chainToAddress: Record,\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): Record {\n // This hook uses the more flexible useMultiChainMultiContractSingleData internally,\n // but transforms the inputs and outputs for convenience\n const chainIdToAddresses = useMemo(() => {\n return getChainIds(chainToAddress).reduce((result, chainId) => {\n result[chainId] = [chainToAddress[chainId]]\n return result\n }, {} as Record>)\n }, [chainToAddress])\n\n const multiContractResults = useMultiChainMultiContractSingleData(\n context,\n chainToBlockNumber,\n chainIdToAddresses,\n contractInterface,\n methodName,\n callInputs,\n options\n )\n\n return useMemo(() => {\n return getChainIds(chainToAddress).reduce((result, chainId) => {\n result[chainId] = multiContractResults[chainId]?.[0] ?? INVALID_CALL_STATE\n return result\n }, {} as Record)\n }, [chainToAddress, multiContractResults])\n}\n\nfunction useCallData(\n methodName: string,\n contractInterface: AbiFunction[] | null | undefined,\n callInputs: OptionalMethodInputs | undefined\n) {\n // Create ethers function fragment\n const fragment = useMemo(\n () => contractInterface && ((getAbiItem as any)({ abi: contractInterface as any, name: methodName }) as any)?.name,\n [contractInterface, methodName]\n )\n // Get encoded call data\n const callData: string | undefined = useMemo(\n () =>\n fragment && isValidMethodArgs(callInputs)\n ? (encodeFunctionData as any)({\n abi: contractInterface as any,\n functionName: fragment,\n args: callInputs as unknown as any[],\n })\n : undefined,\n [callInputs, contractInterface, fragment]\n )\n return { fragment, callData }\n}\n\nfunction getChainIds(chainIdMap: Record) {\n return Object.keys(chainIdMap).map((c) => parseInt(c, 10))\n}\n","import { createSlice, PayloadAction } from '@reduxjs/toolkit'\nimport {\n MulticallFetchingPayload,\n MulticallListenerPayload,\n MulticallResultsPayload,\n MulticallState,\n MulticallListenerOptionsPayload,\n} from './types'\nimport { toCallKey } from './utils/callKeys'\n\nconst initialState: MulticallState = {\n callResults: {},\n}\n\nexport function createMulticallSlice(reducerPath: string) {\n return createSlice({\n name: reducerPath,\n initialState,\n reducers: {\n addMulticallListeners: (state, action: PayloadAction) => {\n const {\n calls,\n chainId,\n options: { blocksPerFetch },\n } = action.payload\n const listeners: MulticallState['callListeners'] = state.callListeners\n ? state.callListeners\n : (state.callListeners = {})\n listeners[chainId] = listeners[chainId] ?? {}\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n listeners[chainId][callKey] = listeners[chainId][callKey] ?? {}\n listeners[chainId][callKey][blocksPerFetch] = (listeners[chainId][callKey][blocksPerFetch] ?? 0) + 1\n })\n },\n\n removeMulticallListeners: (state, action: PayloadAction) => {\n const {\n calls,\n chainId,\n options: { blocksPerFetch },\n } = action.payload\n const listeners: MulticallState['callListeners'] = state.callListeners\n ? state.callListeners\n : (state.callListeners = {})\n\n if (!listeners[chainId]) return\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n if (!listeners[chainId][callKey]) return\n if (!listeners[chainId][callKey][blocksPerFetch]) return\n\n if (listeners[chainId][callKey][blocksPerFetch] === 1) {\n delete listeners[chainId][callKey][blocksPerFetch]\n } else {\n listeners[chainId][callKey][blocksPerFetch]--\n }\n })\n },\n\n fetchingMulticallResults: (state, action: PayloadAction) => {\n const { chainId, fetchingBlockNumber, calls } = action.payload\n state.callResults[chainId] = state.callResults[chainId] ?? {}\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n const current = state.callResults[chainId][callKey]\n if (!current) {\n state.callResults[chainId][callKey] = {\n fetchingBlockNumber,\n }\n } else {\n if ((current.fetchingBlockNumber ?? 0) >= fetchingBlockNumber) return\n state.callResults[chainId][callKey].fetchingBlockNumber = fetchingBlockNumber\n }\n })\n },\n\n errorFetchingMulticallResults: (state, action: PayloadAction) => {\n const { chainId, fetchingBlockNumber, calls } = action.payload\n state.callResults[chainId] = state.callResults[chainId] ?? {}\n calls.forEach((call) => {\n const callKey = toCallKey(call)\n const current = state.callResults[chainId][callKey]\n if (!current || typeof current.fetchingBlockNumber !== 'number') return // only should be dispatched if we are already fetching\n if (current.fetchingBlockNumber <= fetchingBlockNumber) {\n delete current.fetchingBlockNumber\n current.data = null\n current.blockNumber = fetchingBlockNumber\n }\n })\n },\n\n updateMulticallResults: (state, action: PayloadAction) => {\n const { chainId, results, blockNumber } = action.payload\n state.callResults[chainId] = state.callResults[chainId] ?? {}\n Object.keys(results).forEach((callKey) => {\n const current = state.callResults[chainId][callKey]\n if ((current?.blockNumber ?? 0) > blockNumber) return\n if (current?.data === results[callKey] && current?.blockNumber === blockNumber) return\n state.callResults[chainId][callKey] = {\n data: results[callKey],\n blockNumber,\n }\n })\n },\n\n updateListenerOptions: (state, action: PayloadAction) => {\n const { chainId, listenerOptions } = action.payload\n state.listenerOptions = state.listenerOptions ?? {}\n state.listenerOptions[chainId] = listenerOptions\n },\n },\n })\n}\n\nexport type MulticallActions = ReturnType['actions']\n","// TODO de-duplicate this file with web interface\n// https://github.com/Uniswap/interface/blob/main/src/utils/retry.ts\n\nfunction wait(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\nfunction waitRandom(min: number, max: number): Promise {\n return wait(min + Math.round(Math.random() * Math.max(0, max - min)))\n}\n\n/**\n * This error is thrown if the function is cancelled before completing\n */\nclass CancelledError extends Error {\n public isCancelledError: true = true\n constructor() {\n super('Cancelled')\n }\n}\n\n/**\n * Throw this error if the function should retry\n */\nexport class RetryableError extends Error {\n public isRetryableError: true = true\n}\n\nexport interface RetryOptions {\n n: number\n minWait: number\n maxWait: number\n}\n\n/**\n * Retries the function that returns the promise until the promise successfully resolves up to n retries\n * @param fn function to retry\n * @param n how many times to retry\n * @param minWait min wait between retries in ms\n * @param maxWait max wait between retries in ms\n */\nexport function retry(\n fn: () => Promise,\n { n, minWait, maxWait }: RetryOptions\n): { promise: Promise; cancel: () => void } {\n let completed = false\n let rejectCancelled: (error: Error) => void\n const promise = new Promise(async (resolve, reject) => {\n rejectCancelled = reject\n while (true) {\n let result: T\n try {\n result = await fn()\n if (!completed) {\n resolve(result)\n completed = true\n }\n break\n } catch (error) {\n if (completed) {\n break\n }\n if (n <= 0 || !(error as any).isRetryableError) {\n reject(error)\n completed = true\n break\n }\n n--\n }\n await waitRandom(minWait, maxWait)\n }\n })\n return {\n promise,\n cancel: () => {\n if (completed) return\n completed = true\n rejectCancelled(new CancelledError())\n },\n }\n}\n","export default [\n {\n inputs: [],\n name: 'getCurrentBlockTimestamp',\n outputs: [\n {\n internalType: 'uint256',\n name: 'timestamp',\n type: 'uint256',\n },\n ],\n stateMutability: 'view',\n type: 'function',\n },\n {\n inputs: [\n {\n internalType: 'address',\n name: 'addr',\n type: 'address',\n },\n ],\n name: 'getEthBalance',\n outputs: [\n {\n internalType: 'uint256',\n name: 'balance',\n type: 'uint256',\n },\n ],\n stateMutability: 'view',\n type: 'function',\n },\n {\n inputs: [\n {\n components: [\n {\n internalType: 'address',\n name: 'target',\n type: 'address',\n },\n {\n internalType: 'uint256',\n name: 'gasLimit',\n type: 'uint256',\n },\n {\n internalType: 'bytes',\n name: 'callData',\n type: 'bytes',\n },\n ],\n internalType: 'struct PancakeInterfaceMulticall.Call[]',\n name: 'calls',\n type: 'tuple[]',\n },\n ],\n name: 'multicall',\n outputs: [\n {\n internalType: 'uint256',\n name: 'blockNumber',\n type: 'uint256',\n },\n {\n components: [\n {\n internalType: 'bool',\n name: 'success',\n type: 'bool',\n },\n {\n internalType: 'uint256',\n name: 'gasUsed',\n type: 'uint256',\n },\n {\n internalType: 'bytes',\n name: 'returnData',\n type: 'bytes',\n },\n ],\n internalType: 'struct PancakeInterfaceMulticall.Result[]',\n name: 'returnData',\n type: 'tuple[]',\n },\n ],\n stateMutability: 'nonpayable',\n type: 'function',\n },\n] as const\n","import React, { Dispatch, useEffect, useMemo, useRef } from 'react'\nimport { useDispatch, useSelector } from 'react-redux'\nimport { CHUNK_GAS_LIMIT, DEFAULT_CALL_GAS_REQUIRED } from './constants'\nimport type { MulticallContext } from './context'\nimport type { MulticallActions } from './slice'\nimport type { Call, MulticallState, WithMulticallState, ListenerOptions, MulticallInfo } from './types'\nimport { parseCallKey, toCallKey } from './utils/callKeys'\nimport chunkCalls from './utils/chunkCalls'\nimport { retry, RetryableError } from './utils/retry'\nimport useDebounce from './utils/useDebounce'\nimport IMulticallABI from './abi/InterfaceMulticall'\n\nconst FETCH_RETRY_CONFIG = {\n n: Infinity,\n minWait: 1000,\n maxWait: 2500,\n}\n\n/**\n * Fetches a chunk of calls, enforcing a minimum block number constraint\n * @param multicall multicall contract to fetch against\n * @param chunk chunk of calls to make\n * @param blockNumber block number passed as the block tag in the eth_call\n */\nasync function fetchChunk(\n multicallInfo: MulticallInfo,\n chunk: Call[],\n blockNumber: number,\n isDebug?: boolean\n): Promise {\n console.debug('Fetching chunk', chunk, blockNumber, chunk.map((obj) => ({\n target: obj.address,\n callData: obj.callData,\n gasLimit: obj.gasRequired ?? DEFAULT_CALL_GAS_REQUIRED,\n })))\n try {\n const {\n result: [, returnData], // [blockNumber, results]\n }: { result: [any, any[]] } = await (multicallInfo.provider as any).simulateContract({\n abi: IMulticallABI,\n address: multicallInfo.address,\n functionName: 'multicall',\n args: [\n chunk.map((obj) => ({\n target: obj.address,\n callData: obj.callData,\n gasLimit: obj.gasRequired ?? DEFAULT_CALL_GAS_REQUIRED,\n }))\n ],\n // we aren't passing through the block gas limit we used to create the chunk, because it causes a problem with the integ tests\n blockNumber: BigInt(blockNumber)\n }\n )\n if (isDebug) {\n returnData.forEach(({ gasUsed, returnData, success }, i) => {\n if (\n !success &&\n returnData.length === 2 &&\n gasUsed >= (Math.floor((chunk[i].gasRequired ?? DEFAULT_CALL_GAS_REQUIRED) * 0.95))\n ) {\n console.warn(\n `A call failed due to requiring ${gasUsed.toString()} vs. allowed ${chunk[i].gasRequired ?? DEFAULT_CALL_GAS_REQUIRED\n }`,\n chunk[i]\n )\n }\n })\n }\n\n return returnData\n } catch (e) {\n const error = e as any\n if (error.code === -32000 || error.message?.indexOf('header not found') !== -1) {\n throw new RetryableError(`header not found for block number ${blockNumber}`)\n } else if (error.code === -32603 || error.message?.indexOf('execution ran out of gas') !== -1) {\n if (chunk.length > 1) {\n if (process.env.NODE_ENV === 'development') {\n console.debug('Splitting a chunk in 2', chunk)\n }\n const half = Math.floor(chunk.length / 2)\n const [c0, c1] = await Promise.all([\n fetchChunk(multicallInfo, chunk.slice(0, half), blockNumber),\n fetchChunk(multicallInfo, chunk.slice(half, chunk.length), blockNumber),\n ])\n return c0.concat(c1)\n }\n }\n console.error('Failed to fetch chunk', error)\n throw error\n }\n}\n\n/**\n * From the current all listeners state, return each call key mapped to the\n * minimum number of blocks per fetch. This is how often each key must be fetched.\n * @param allListeners the all listeners state\n * @param chainId the current chain id\n */\nexport function activeListeningKeys(\n allListeners: MulticallState['callListeners'],\n chainId?: number\n): { [callKey: string]: number } {\n if (!allListeners || !chainId) return {}\n const listeners = allListeners[chainId]\n if (!listeners) return {}\n\n return Object.keys(listeners).reduce<{ [callKey: string]: number }>((memo, callKey) => {\n const keyListeners = listeners[callKey]\n\n memo[callKey] = Object.keys(keyListeners)\n .filter((key) => {\n const blocksPerFetch = parseInt(key)\n if (blocksPerFetch <= 0) return false\n return keyListeners[blocksPerFetch] > 0\n })\n .reduce((previousMin, current) => {\n return Math.min(previousMin, parseInt(current))\n }, Infinity)\n return memo\n }, {})\n}\n\n/**\n * Return the keys that need to be refetched\n * @param callResults current call result state\n * @param listeningKeys each call key mapped to how old the data can be in blocks\n * @param chainId the current chain id\n * @param latestBlockNumber the latest block number\n */\nexport function outdatedListeningKeys(\n callResults: MulticallState['callResults'],\n listeningKeys: { [callKey: string]: number },\n chainId: number | undefined,\n latestBlockNumber: number | undefined\n): string[] {\n if (!chainId || !latestBlockNumber) return []\n const results = callResults[chainId]\n // no results at all, load everything\n if (!results) return Object.keys(listeningKeys)\n\n return Object.keys(listeningKeys).filter((callKey) => {\n const blocksPerFetch = listeningKeys[callKey]\n\n const data = callResults[chainId][callKey]\n // no data, must fetch\n if (!data) return true\n\n const minDataBlockNumber = latestBlockNumber - (blocksPerFetch - 1)\n\n // already fetching it for a recent enough block, don't refetch it\n if (data.fetchingBlockNumber && data.fetchingBlockNumber >= minDataBlockNumber) return false\n\n // if data is older than minDataBlockNumber, fetch it\n return !data.blockNumber || data.blockNumber < minDataBlockNumber\n })\n}\n\ninterface FetchChunkContext {\n actions: MulticallActions\n dispatch: Dispatch\n chainId: number\n latestBlockNumber: number\n isDebug?: boolean\n}\n\nfunction onFetchChunkSuccess(\n context: FetchChunkContext,\n chunk: Call[],\n result: readonly { success: boolean; returnData: string }[]\n) {\n const { actions, dispatch, chainId, latestBlockNumber, isDebug } = context\n\n // split the returned slice into errors and results\n const { erroredCalls, results } = chunk.reduce<{\n erroredCalls: Call[]\n results: { [callKey: string]: string | null }\n }>(\n (memo, call, i) => {\n if (result[i].success) {\n memo.results[toCallKey(call)] = result[i].returnData ?? null\n } else {\n memo.erroredCalls.push(call)\n }\n return memo\n },\n { erroredCalls: [], results: {} }\n )\n\n // dispatch any new results\n if (Object.keys(results).length > 0)\n dispatch(\n actions.updateMulticallResults({\n chainId,\n results,\n blockNumber: latestBlockNumber,\n })\n )\n\n // dispatch any errored calls\n if (erroredCalls.length > 0) {\n if (isDebug) {\n result.forEach((returnData, ix) => {\n if (!returnData.success) {\n console.debug('Call failed', chunk[ix], returnData)\n }\n })\n } else {\n console.debug('Calls errored in fetch', erroredCalls)\n }\n dispatch(\n actions.errorFetchingMulticallResults({\n calls: erroredCalls,\n chainId,\n fetchingBlockNumber: latestBlockNumber,\n })\n )\n }\n}\n\nfunction onFetchChunkFailure(context: FetchChunkContext, chunk: Call[], error: any) {\n const { actions, dispatch, chainId, latestBlockNumber } = context\n\n if (error.isCancelledError) {\n console.debug('Cancelled fetch for blockNumber', latestBlockNumber, chunk, chainId)\n return\n }\n console.error('Failed to fetch multicall chunk', chunk, chainId, error)\n dispatch(\n actions.errorFetchingMulticallResults({\n calls: chunk,\n chainId,\n fetchingBlockNumber: latestBlockNumber,\n })\n )\n}\n\nexport interface UpdaterProps {\n context: MulticallContext\n chainId: number | undefined // For now, one updater is required for each chainId to be watched\n latestBlockNumber: number | undefined\n multicallInfo: MulticallInfo\n isDebug?: boolean\n listenerOptions?: ListenerOptions\n}\n\nfunction Updater(props: UpdaterProps): null {\n const { context, chainId, latestBlockNumber, multicallInfo, isDebug, listenerOptions } = props\n const { actions, reducerPath } = context\n const dispatch = useDispatch()\n\n // set user configured listenerOptions in state for given chain ID.\n useEffect(() => {\n if (chainId && listenerOptions) {\n dispatch(actions.updateListenerOptions({ chainId, listenerOptions }))\n }\n }, [chainId, listenerOptions, actions, dispatch])\n\n const state = useSelector((state: WithMulticallState) => state[reducerPath])\n\n // wait for listeners to settle before triggering updates\n const debouncedListeners = useDebounce(state.callListeners, 100)\n const cancellations = useRef<{ blockNumber: number; cancellations: (() => void)[] }>()\n\n const listeningKeys: { [callKey: string]: number } = useMemo(() => {\n return activeListeningKeys(debouncedListeners, chainId)\n }, [debouncedListeners, chainId])\n\n const serializedOutdatedCallKeys = useMemo(() => {\n const outdatedCallKeys = outdatedListeningKeys(state.callResults, listeningKeys, chainId, latestBlockNumber)\n return JSON.stringify(outdatedCallKeys.sort())\n }, [chainId, state.callResults, listeningKeys, latestBlockNumber])\n\n useEffect(() => {\n if (!latestBlockNumber || !chainId || !multicallInfo) return\n\n const outdatedCallKeys: string[] = JSON.parse(serializedOutdatedCallKeys)\n if (outdatedCallKeys.length === 0) return\n const calls = outdatedCallKeys.map((key) => parseCallKey(key))\n\n const chunkedCalls = chunkCalls(calls, CHUNK_GAS_LIMIT)\n\n if (cancellations.current && cancellations.current.blockNumber !== latestBlockNumber) {\n cancellations.current.cancellations.forEach((c) => c())\n }\n\n dispatch(\n actions.fetchingMulticallResults({\n calls,\n chainId,\n fetchingBlockNumber: latestBlockNumber,\n })\n )\n\n const fetchChunkContext = {\n actions,\n dispatch,\n chainId,\n latestBlockNumber,\n isDebug,\n }\n // Execute fetches and gather cancellation callbacks\n const newCancellations = chunkedCalls.map((chunk) => {\n const { cancel, promise } = retry(\n () => fetchChunk(multicallInfo, chunk, latestBlockNumber, isDebug),\n FETCH_RETRY_CONFIG\n )\n promise\n .then((result) => onFetchChunkSuccess(fetchChunkContext, chunk, result))\n .catch((error) => onFetchChunkFailure(fetchChunkContext, chunk, error))\n return cancel\n })\n\n cancellations.current = {\n blockNumber: latestBlockNumber,\n cancellations: newCancellations,\n }\n }, [actions, chainId, multicallInfo, dispatch, serializedOutdatedCallKeys, latestBlockNumber, isDebug])\n\n return null\n}\n\nexport function createUpdater(context: MulticallContext) {\n const UpdaterContextBound = (props: Omit) => {\n return \n }\n return UpdaterContextBound\n}\n","// TODO de-duplicate this file with web interface\n// https://github.com/Uniswap/interface/blob/main/src/hooks/useDebounce.ts\n\nimport { useEffect, useState } from 'react'\n\n// modified from https://usehooks.com/useDebounce/\nexport default function useDebounce(value: T, delay: number): T {\n const [debouncedValue, setDebouncedValue] = useState(value)\n\n useEffect(() => {\n // Update debounced value after delay\n const handler = setTimeout(() => {\n setDebouncedValue(value)\n }, delay)\n\n // Cancel the timeout if value changes (also on delay change or unmount)\n // This is how we prevent debounced value from updating if value is changed ...\n // .. within the delay period. Timeout gets cleared and restarted.\n return () => {\n clearTimeout(handler)\n }\n }, [value, delay])\n\n return debouncedValue\n}\n","import { DEFAULT_CHUNK_GAS_REQUIRED } from '../constants'\n\ninterface Bin {\n calls: T[]\n cumulativeGasLimit: number\n}\n\n/**\n * Tries to pack a list of items into as few bins as possible using the first-fit bin packing algorithm\n * @param calls the calls to chunk\n * @param chunkGasLimit the gas limit of any one chunk of calls, i.e. bin capacity\n * @param defaultGasRequired the default amount of gas an individual call should cost if not specified\n */\nexport default function chunkCalls(\n calls: T[],\n chunkGasLimit: number,\n defaultGasRequired: number = DEFAULT_CHUNK_GAS_REQUIRED\n): T[][] {\n return (\n calls\n // first sort by gas required\n .sort((c1, c2) => (c2.gasRequired ?? defaultGasRequired) - (c1.gasRequired ?? defaultGasRequired))\n // then bin the calls according to the first fit algorithm\n .reduce[]>((bins, call) => {\n const gas = call.gasRequired ?? defaultGasRequired\n for (const bin of bins) {\n if (bin.cumulativeGasLimit + gas <= chunkGasLimit) {\n bin.calls.push(call)\n bin.cumulativeGasLimit += gas\n return bins\n }\n }\n // didn't find a bin for the call, make a new bin\n bins.push({\n calls: [call],\n cumulativeGasLimit: gas,\n })\n return bins\n }, [])\n // pull out just the calls from each bin\n .map((b) => b.calls)\n )\n}\n","import type { MulticallContext } from './context'\nimport {\n useMultiChainMultiContractSingleData as _useMultiChainMultiContractSingleData,\n useMultiChainSingleContractSingleData as _useMultiChainSingleContractSingleData,\n useMultipleContractSingleData as _useMultipleContractSingleData,\n useSingleCallResult as _useSingleCallResult,\n useSingleContractMultipleData as _useSingleContractMultipleData,\n useSingleContractWithCallData as _useSingleContractWithCallData,\n} from './hooks'\nimport { createMulticallSlice } from './slice'\nimport { createUpdater } from './updater'\n\ntype RemoveFirstFromTuple = T['length'] extends 0\n ? undefined\n : ((...b: T) => void) extends (a: any, ...b: infer I) => void\n ? I\n : []\ntype ParamsWithoutContext any> = RemoveFirstFromTuple>\n\nexport interface MulticallOptions {\n reducerPath?: string\n // More options can be added here as multicall's capabilities are extended\n}\n\n// Inspired by RTK Query's createApi\nexport function createMulticall(options?: MulticallOptions) {\n const reducerPath = options?.reducerPath ?? 'multicall'\n const slice = createMulticallSlice(reducerPath)\n const { actions, reducer } = slice\n const context: MulticallContext = { reducerPath, actions }\n\n const useMultipleContractSingleData = (...args: ParamsWithoutContext) =>\n _useMultipleContractSingleData(context, ...args)\n const useSingleContractMultipleData = (...args: ParamsWithoutContext) =>\n _useSingleContractMultipleData(context, ...args)\n const useSingleContractWithCallData = (...args: ParamsWithoutContext) =>\n _useSingleContractWithCallData(context, ...args)\n const useSingleCallResult = (...args: ParamsWithoutContext) =>\n _useSingleCallResult(context, ...args)\n const useMultiChainMultiContractSingleData = (\n ...args: ParamsWithoutContext\n ) => _useMultiChainMultiContractSingleData(context, ...args)\n const useMultiChainSingleContractSingleData = (\n ...args: ParamsWithoutContext\n ) => _useMultiChainSingleContractSingleData(context, ...args)\n const hooks = {\n useMultipleContractSingleData,\n useSingleContractMultipleData,\n useSingleContractWithCallData,\n useSingleCallResult,\n useMultiChainMultiContractSingleData,\n useMultiChainSingleContractSingleData,\n }\n\n const Updater = createUpdater(context)\n\n return {\n reducerPath,\n reducer,\n actions,\n hooks,\n Updater,\n }\n}\n"],"names":["INVALID_RESULT","valid","blockNumber","undefined","data","INVALID_CALL_STATE","result","loading","syncing","error","LOADING_CALL_STATE","toCallKey","call","key","address","callData","gasRequired","Number","isSafeInteger","Error","parseCallKey","callKey","pcs","split","includes","length","_extends","parseInt","callsToCallKeys","calls","_calls$filter$map$sor","_calls$filter","filter","c","Boolean","map","sort","callKeysToCalls","callKeys","useCallStates","results","contractInterface","fragment","latestBlockNumber","syncingBlockNumber","useMemo","lowestBlockNumber","reduce","memo","Math","min","max","i","resultFragment","toCallState","callResult","success","decodeFunctionResult","abi","functionName","console","debug","isMethodArg","x","BigInt","indexOf","isValidMethodArgs","Array","isArray","every","xi","useCallsDataSubscription","context","chainId","listenerOptions","reducerPath","actions","callResults","useSelector","state","defaultListenerOptions","dispatch","useDispatch","serializedCallKeys","JSON","stringify","useEffect","parse","blocksPerFetchFromState","_chainId","blocksPerFetch","blocksPerFetchForChain","_ref","_listenerOptions$bloc","addMulticallListeners","options","removeMulticallListeners","lastResults","useRef","a","b","isChanged","current","_callResults$chainId","push","useSingleContractMultipleData","contract","methodName","callInputs","_getAbiItem","getAbiItem","name","callDatas","callInput","encodeFunctionData","args","useMultipleContractSingleData","addresses","_useCallData","useCallData","useSingleCallResult","inputs","_useSingleContractMul","useSingleContractWithCallData","useCallback","_getAbiItem2","substring","useMultiChainMultiContractSingleData","chainToBlockNumber","chainToAddresses","_useCallData2","chainIdToResults","chainToCalls","chainCallKeysTuple","getChainIds","chainCallKeysTuples","batch","_step","_iterator","_createForOfIteratorHelperLoose","done","_chainId2","_ref2","_listenerOptions$bloc2","_step$value","value","_step2","_iterator2","_chainId3","_ref3","_listenerOptions$bloc3","_step2$value","_callResults$chainId2","useMultichainCallsDataSubscription","combinedResults","useMultiChainSingleContractSingleData","chainToAddress","multiContractResults","_multiContractResults","_multiContractResults2","_getAbiItem3","chainIdMap","Object","keys","initialState","waitRandom","ms","round","random","Promise","resolve","setTimeout","CancelledError","_Error","_this","_inheritsLoose","_wrapNativeSuper","RetryableError","_Error2","_this2","outputs","internalType","type","stateMutability","components","FETCH_RETRY_CONFIG","n","Infinity","minWait","maxWait","fetchChunk","_x","_x2","_x3","_x4","_fetchChunk","apply","arguments","_asyncToGenerator","_regeneratorRuntime","mark","_callee","multicallInfo","chunk","isDebug","returnData","_error$message","_error$message2","half","_yield$Promise$all","wrap","_context","prev","next","obj","_obj$gasRequired","target","gasLimit","provider","simulateContract","IMulticallABI","_obj$gasRequired2","sent","forEach","_chunk$i$gasRequired2","gasUsed","floor","_chunk$i$gasRequired","warn","toString","abrupt","t0","code","message","all","slice","concat","stop","Updater","props","updateListenerOptions","_useState","debouncedValue","setDebouncedValue","debouncedListeners","useState","callListeners","handler","clearTimeout","cancellations","listeningKeys","allListeners","listeners","keyListeners","previousMin","activeListeningKeys","serializedOutdatedCallKeys","outdatedCallKeys","minDataBlockNumber","fetchingBlockNumber","outdatedListeningKeys","chunkedCalls","chunkGasLimit","defaultGasRequired","c1","c2","_c2$gasRequired","_c1$gasRequired","bins","gas","_call$gasRequired","bin","cumulativeGasLimit","chunkCalls","fetchingMulticallResults","fetchChunkContext","newCancellations","fn","rejectCancelled","completed","_retry","promise","reject","isRetryableError","cancel","then","_chunk$reduce","_result$i$returnData","erroredCalls","updateMulticallResults","ix","errorFetchingMulticallResults","onFetchChunkSuccess","isCancelledError","onFetchChunkFailure","createUpdater","React","_options$reducerPath","createSlice","reducers","action","_action$payload","payload","_listeners$chainId","_listeners$chainId$ca","_listeners$chainId$ca2","_action$payload2","_action$payload3","_state$callResults$ch","_current$fetchingBloc","_action$payload4","_state$callResults$ch2","_action$payload5","_state$callResults$ch3","_current$blockNumber","_action$payload6","_state$listenerOption","createMulticallSlice","reducer","hooks","_len","_key","_useMultipleContractSingleData","_len2","_key2","_useSingleContractMultipleData","_len3","_key3","_useSingleContractWithCallData","_len4","_key4","_useSingleCallResult","_len5","_key5","_useMultiChainMultiContractSingleData","_len6","_key6","_useMultiChainSingleContractSingleData"],"mappings":"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"}
\ No newline at end of file
diff --git a/dist/redux-multicall-viem.esm.js b/dist/redux-multicall-viem.esm.js
new file mode 100644
index 0000000..2d07246
--- /dev/null
+++ b/dist/redux-multicall-viem.esm.js
@@ -0,0 +1,1612 @@
+import React, { useMemo, useCallback, useEffect, useRef, useState } from 'react';
+import { useSelector, useDispatch, batch } from 'react-redux';
+import { decodeFunctionResult, getAbiItem, encodeFunctionData } from 'viem';
+import { createSlice } from '@reduxjs/toolkit';
+
+var DEFAULT_BLOCKS_PER_FETCH = 1;
+var DEFAULT_CALL_GAS_REQUIRED = 1000000;
+var DEFAULT_CHUNK_GAS_REQUIRED = 200000;
+var CHUNK_GAS_LIMIT = 100000000;
+var CONSERVATIVE_BLOCK_GAS_LIMIT = 10000000; // conservative, hard-coded estimate of the current block gas limit
+// Consts for hooks
+var INVALID_RESULT = {
+ valid: false,
+ blockNumber: undefined,
+ data: undefined
+};
+var NEVER_RELOAD = {
+ blocksPerFetch: Infinity
+};
+var INVALID_CALL_STATE = {
+ valid: false,
+ result: undefined,
+ loading: false,
+ syncing: false,
+ error: false
+};
+var LOADING_CALL_STATE = {
+ valid: true,
+ result: undefined,
+ loading: true,
+ syncing: true,
+ error: false
+};
+
+function _arrayLikeToArray(r, a) {
+ (null == a || a > r.length) && (a = r.length);
+ for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+ return n;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+ try {
+ var i = n[a](c),
+ u = i.value;
+ } catch (n) {
+ return void e(n);
+ }
+ i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+ return function () {
+ var t = this,
+ e = arguments;
+ return new Promise(function (r, o) {
+ var a = n.apply(t, e);
+ function _next(n) {
+ asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+ }
+ function _throw(n) {
+ asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+ }
+ _next(void 0);
+ });
+ };
+}
+function _construct(t, e, r) {
+ if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+ var o = [null];
+ o.push.apply(o, e);
+ var p = new (t.bind.apply(t, o))();
+ return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+ var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+ if (t) return (t = t.call(r)).next.bind(t);
+ if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+ t && (r = t);
+ var o = 0;
+ return function () {
+ return o >= r.length ? {
+ done: !0
+ } : {
+ done: !1,
+ value: r[o++]
+ };
+ };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _extends() {
+ return _extends = Object.assign ? Object.assign.bind() : function (n) {
+ for (var e = 1; e < arguments.length; e++) {
+ var t = arguments[e];
+ for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+ }
+ return n;
+ }, _extends.apply(null, arguments);
+}
+function _getPrototypeOf(t) {
+ return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+ return t.__proto__ || Object.getPrototypeOf(t);
+ }, _getPrototypeOf(t);
+}
+function _inheritsLoose(t, o) {
+ t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _isNativeFunction(t) {
+ try {
+ return -1 !== Function.toString.call(t).indexOf("[native code]");
+ } catch (n) {
+ return "function" == typeof t;
+ }
+}
+function _isNativeReflectConstruct() {
+ try {
+ var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+ } catch (t) {}
+ return (_isNativeReflectConstruct = function () {
+ return !!t;
+ })();
+}
+function _regeneratorRuntime() {
+ _regeneratorRuntime = function () {
+ return e;
+ };
+ var t,
+ e = {},
+ r = Object.prototype,
+ n = r.hasOwnProperty,
+ o = Object.defineProperty || function (t, e, r) {
+ t[e] = r.value;
+ },
+ i = "function" == typeof Symbol ? Symbol : {},
+ a = i.iterator || "@@iterator",
+ c = i.asyncIterator || "@@asyncIterator",
+ u = i.toStringTag || "@@toStringTag";
+ function define(t, e, r) {
+ return Object.defineProperty(t, e, {
+ value: r,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }), t[e];
+ }
+ try {
+ define({}, "");
+ } catch (t) {
+ define = function (t, e, r) {
+ return t[e] = r;
+ };
+ }
+ function wrap(t, e, r, n) {
+ var i = e && e.prototype instanceof Generator ? e : Generator,
+ a = Object.create(i.prototype),
+ c = new Context(n || []);
+ return o(a, "_invoke", {
+ value: makeInvokeMethod(t, r, c)
+ }), a;
+ }
+ function tryCatch(t, e, r) {
+ try {
+ return {
+ type: "normal",
+ arg: t.call(e, r)
+ };
+ } catch (t) {
+ return {
+ type: "throw",
+ arg: t
+ };
+ }
+ }
+ e.wrap = wrap;
+ var h = "suspendedStart",
+ l = "suspendedYield",
+ f = "executing",
+ s = "completed",
+ y = {};
+ function Generator() {}
+ function GeneratorFunction() {}
+ function GeneratorFunctionPrototype() {}
+ var p = {};
+ define(p, a, function () {
+ return this;
+ });
+ var d = Object.getPrototypeOf,
+ v = d && d(d(values([])));
+ v && v !== r && n.call(v, a) && (p = v);
+ var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+ function defineIteratorMethods(t) {
+ ["next", "throw", "return"].forEach(function (e) {
+ define(t, e, function (t) {
+ return this._invoke(e, t);
+ });
+ });
+ }
+ function AsyncIterator(t, e) {
+ function invoke(r, o, i, a) {
+ var c = tryCatch(t[r], t, o);
+ if ("throw" !== c.type) {
+ var u = c.arg,
+ h = u.value;
+ return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+ invoke("next", t, i, a);
+ }, function (t) {
+ invoke("throw", t, i, a);
+ }) : e.resolve(h).then(function (t) {
+ u.value = t, i(u);
+ }, function (t) {
+ return invoke("throw", t, i, a);
+ });
+ }
+ a(c.arg);
+ }
+ var r;
+ o(this, "_invoke", {
+ value: function (t, n) {
+ function callInvokeWithMethodAndArg() {
+ return new e(function (e, r) {
+ invoke(t, n, e, r);
+ });
+ }
+ return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+ }
+ });
+ }
+ function makeInvokeMethod(e, r, n) {
+ var o = h;
+ return function (i, a) {
+ if (o === f) throw Error("Generator is already running");
+ if (o === s) {
+ if ("throw" === i) throw a;
+ return {
+ value: t,
+ done: !0
+ };
+ }
+ for (n.method = i, n.arg = a;;) {
+ var c = n.delegate;
+ if (c) {
+ var u = maybeInvokeDelegate(c, n);
+ if (u) {
+ if (u === y) continue;
+ return u;
+ }
+ }
+ if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+ if (o === h) throw o = s, n.arg;
+ n.dispatchException(n.arg);
+ } else "return" === n.method && n.abrupt("return", n.arg);
+ o = f;
+ var p = tryCatch(e, r, n);
+ if ("normal" === p.type) {
+ if (o = n.done ? s : l, p.arg === y) continue;
+ return {
+ value: p.arg,
+ done: n.done
+ };
+ }
+ "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+ }
+ };
+ }
+ function maybeInvokeDelegate(e, r) {
+ var n = r.method,
+ o = e.iterator[n];
+ if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+ var i = tryCatch(o, e.iterator, r.arg);
+ if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+ var a = i.arg;
+ return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+ }
+ function pushTryEntry(t) {
+ var e = {
+ tryLoc: t[0]
+ };
+ 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+ }
+ function resetTryEntry(t) {
+ var e = t.completion || {};
+ e.type = "normal", delete e.arg, t.completion = e;
+ }
+ function Context(t) {
+ this.tryEntries = [{
+ tryLoc: "root"
+ }], t.forEach(pushTryEntry, this), this.reset(!0);
+ }
+ function values(e) {
+ if (e || "" === e) {
+ var r = e[a];
+ if (r) return r.call(e);
+ if ("function" == typeof e.next) return e;
+ if (!isNaN(e.length)) {
+ var o = -1,
+ i = function next() {
+ for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+ return next.value = t, next.done = !0, next;
+ };
+ return i.next = i;
+ }
+ }
+ throw new TypeError(typeof e + " is not iterable");
+ }
+ return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+ value: GeneratorFunctionPrototype,
+ configurable: !0
+ }), o(GeneratorFunctionPrototype, "constructor", {
+ value: GeneratorFunction,
+ configurable: !0
+ }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+ var e = "function" == typeof t && t.constructor;
+ return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+ }, e.mark = function (t) {
+ return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+ }, e.awrap = function (t) {
+ return {
+ __await: t
+ };
+ }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+ return this;
+ }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+ void 0 === i && (i = Promise);
+ var a = new AsyncIterator(wrap(t, r, n, o), i);
+ return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+ return t.done ? t.value : a.next();
+ });
+ }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+ return this;
+ }), define(g, "toString", function () {
+ return "[object Generator]";
+ }), e.keys = function (t) {
+ var e = Object(t),
+ r = [];
+ for (var n in e) r.push(n);
+ return r.reverse(), function next() {
+ for (; r.length;) {
+ var t = r.pop();
+ if (t in e) return next.value = t, next.done = !1, next;
+ }
+ return next.done = !0, next;
+ };
+ }, e.values = values, Context.prototype = {
+ constructor: Context,
+ reset: function (e) {
+ if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+ },
+ stop: function () {
+ this.done = !0;
+ var t = this.tryEntries[0].completion;
+ if ("throw" === t.type) throw t.arg;
+ return this.rval;
+ },
+ dispatchException: function (e) {
+ if (this.done) throw e;
+ var r = this;
+ function handle(n, o) {
+ return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+ }
+ for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+ var i = this.tryEntries[o],
+ a = i.completion;
+ if ("root" === i.tryLoc) return handle("end");
+ if (i.tryLoc <= this.prev) {
+ var c = n.call(i, "catchLoc"),
+ u = n.call(i, "finallyLoc");
+ if (c && u) {
+ if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+ if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+ } else if (c) {
+ if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+ } else {
+ if (!u) throw Error("try statement without catch or finally");
+ if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+ }
+ }
+ }
+ },
+ abrupt: function (t, e) {
+ for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+ var o = this.tryEntries[r];
+ if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+ var i = o;
+ break;
+ }
+ }
+ i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+ var a = i ? i.completion : {};
+ return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+ },
+ complete: function (t, e) {
+ if ("throw" === t.type) throw t.arg;
+ return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+ },
+ finish: function (t) {
+ for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+ var r = this.tryEntries[e];
+ if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+ }
+ },
+ catch: function (t) {
+ for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+ var r = this.tryEntries[e];
+ if (r.tryLoc === t) {
+ var n = r.completion;
+ if ("throw" === n.type) {
+ var o = n.arg;
+ resetTryEntry(r);
+ }
+ return o;
+ }
+ }
+ throw Error("illegal catch attempt");
+ },
+ delegateYield: function (e, r, n) {
+ return this.delegate = {
+ iterator: values(e),
+ resultName: r,
+ nextLoc: n
+ }, "next" === this.method && (this.arg = t), y;
+ }
+ }, e;
+}
+function _setPrototypeOf(t, e) {
+ return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+ return t.__proto__ = e, t;
+ }, _setPrototypeOf(t, e);
+}
+function _unsupportedIterableToArray(r, a) {
+ if (r) {
+ if ("string" == typeof r) return _arrayLikeToArray(r, a);
+ var t = {}.toString.call(r).slice(8, -1);
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+ }
+}
+function _wrapNativeSuper(t) {
+ var r = "function" == typeof Map ? new Map() : void 0;
+ return _wrapNativeSuper = function (t) {
+ if (null === t || !_isNativeFunction(t)) return t;
+ if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+ if (void 0 !== r) {
+ if (r.has(t)) return r.get(t);
+ r.set(t, Wrapper);
+ }
+ function Wrapper() {
+ return _construct(t, arguments, _getPrototypeOf(this).constructor);
+ }
+ return Wrapper.prototype = Object.create(t.prototype, {
+ constructor: {
+ value: Wrapper,
+ enumerable: !1,
+ writable: !0,
+ configurable: !0
+ }
+ }), _setPrototypeOf(Wrapper, t);
+ }, _wrapNativeSuper(t);
+}
+
+function toCallKey(call) {
+ var key = call.address + "-" + call.callData;
+ if (call.gasRequired) {
+ if (!Number.isSafeInteger(call.gasRequired)) {
+ throw new Error("Invalid number: " + call.gasRequired);
+ }
+ key += "-" + call.gasRequired;
+ }
+ return key;
+}
+function parseCallKey(callKey) {
+ var pcs = callKey.split('-');
+ if (![2, 3].includes(pcs.length)) {
+ throw new Error("Invalid call key: " + callKey);
+ }
+ return _extends({
+ address: pcs[0],
+ callData: pcs[1]
+ }, pcs[2] ? {
+ gasRequired: Number.parseInt(pcs[2])
+ } : {});
+}
+function callsToCallKeys(calls) {
+ var _calls$filter$map$sor, _calls$filter;
+ return (_calls$filter$map$sor = calls == null || (_calls$filter = calls.filter(function (c) {
+ return Boolean(c);
+ })) == null || (_calls$filter = _calls$filter.map(toCallKey)) == null ? void 0 : _calls$filter.sort()) != null ? _calls$filter$map$sor : [];
+}
+function callKeysToCalls(callKeys) {
+ if (!(callKeys != null && callKeys.length)) return null;
+ return callKeys.map(function (key) {
+ return parseCallKey(key);
+ });
+}
+
+// Converts CallResult[] to CallState[], only updating if call states have changed.
+// Ensures that CallState results remain referentially stable when unchanged, preventing
+// spurious re-renders which would otherwise occur because mapping always creates a new object.
+function useCallStates(results, contractInterface, fragment, latestBlockNumber) {
+ // Avoid refreshing the results with every changing block number (eg latestBlockNumber).
+ // Instead, only refresh the results if they need to be synced - if there is a result which is stale, for which blockNumber < latestBlockNumber.
+ var syncingBlockNumber = useMemo(function () {
+ var lowestBlockNumber = results.reduce(function (memo, result) {
+ return result.blockNumber ? Math.min(memo != null ? memo : result.blockNumber, result.blockNumber) : memo;
+ }, undefined);
+ return Math.max(lowestBlockNumber != null ? lowestBlockNumber : 0, latestBlockNumber != null ? latestBlockNumber : 0);
+ }, [results, latestBlockNumber]);
+ return useMemo(function () {
+ return results.map(function (result, i) {
+ var resultFragment = typeof fragment === 'function' ? fragment(i) : fragment;
+ return toCallState(result, contractInterface, resultFragment, syncingBlockNumber);
+ });
+ }, [contractInterface, fragment, results, syncingBlockNumber]);
+}
+function toCallState(callResult, contractInterface, fragment, syncingBlockNumber) {
+ if (!callResult || !callResult.valid) {
+ return INVALID_CALL_STATE;
+ }
+ var data = callResult.data,
+ blockNumber = callResult.blockNumber;
+ if (!blockNumber || !contractInterface || !fragment || !syncingBlockNumber) {
+ return LOADING_CALL_STATE;
+ }
+ var success = data && data.length > 2;
+ var syncing = blockNumber < syncingBlockNumber;
+ var result = undefined;
+ if (success && data) {
+ try {
+ result = decodeFunctionResult({
+ abi: contractInterface,
+ functionName: fragment,
+ data: data
+ });
+ } catch (error) {
+ console.debug('Result data parsing failed', fragment, data);
+ return {
+ valid: true,
+ loading: false,
+ error: true,
+ syncing: syncing,
+ result: result
+ };
+ }
+ }
+ return {
+ valid: true,
+ loading: false,
+ syncing: syncing,
+ result: result,
+ error: !success
+ };
+}
+
+function isMethodArg(x) {
+ return x === null || x === undefined ? false : typeof BigInt(x) === 'bigint' || ['string', 'number'].indexOf(typeof x) !== -1;
+}
+function isValidMethodArgs(x) {
+ return x === undefined || Array.isArray(x) && x.every(function (xi) {
+ return isMethodArg(xi) || Array.isArray(xi) && xi.every(isMethodArg);
+ });
+}
+
+// the lowest level call for subscribing to contract data
+function useCallsDataSubscription(context, chainId, calls, listenerOptions) {
+ var reducerPath = context.reducerPath,
+ actions = context.actions;
+ var callResults = useSelector(function (state) {
+ return state[reducerPath].callResults;
+ });
+ var defaultListenerOptions = useSelector(function (state) {
+ return state[reducerPath].listenerOptions;
+ });
+ var dispatch = useDispatch();
+ var serializedCallKeys = useMemo(function () {
+ return JSON.stringify(callsToCallKeys(calls));
+ }, [calls]);
+ // update listeners when there is an actual change that persists for at least 100ms
+ useEffect(function () {
+ var _chainId, _ref, _listenerOptions$bloc;
+ var callKeys = JSON.parse(serializedCallKeys);
+ var calls = callKeysToCalls(callKeys);
+ if (!chainId || !calls) return;
+ var blocksPerFetchFromState = (_chainId = (defaultListenerOptions != null ? defaultListenerOptions : {})[chainId]) == null ? void 0 : _chainId.blocksPerFetch;
+ var blocksPerFetchForChain = (_ref = (_listenerOptions$bloc = listenerOptions == null ? void 0 : listenerOptions.blocksPerFetch) != null ? _listenerOptions$bloc : blocksPerFetchFromState) != null ? _ref : DEFAULT_BLOCKS_PER_FETCH;
+ dispatch(actions.addMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ return function () {
+ dispatch(actions.removeMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ };
+ }, [actions, chainId, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions]);
+ var lastResults = useRef([]);
+ return useMemo(function () {
+ var isChanged = lastResults.current.length !== calls.length;
+ // Construct results using a for-loop to handle sparse arrays.
+ // Array.prototype.map would skip empty entries.
+ var results = [];
+ for (var i = 0; i < calls.length; ++i) {
+ var call = calls[i];
+ var result = INVALID_RESULT;
+ if (chainId && call) {
+ var _callResults$chainId;
+ var callResult = (_callResults$chainId = callResults[chainId]) == null ? void 0 : _callResults$chainId[toCallKey(call)];
+ result = {
+ valid: true,
+ data: callResult != null && callResult.data && callResult.data !== '0x' ? callResult.data : undefined,
+ blockNumber: callResult == null ? void 0 : callResult.blockNumber
+ };
+ }
+ isChanged = isChanged || !areCallResultsEqual(result, lastResults.current[i]);
+ results.push(result);
+ }
+ // Force the results to be referentially stable if they have not changed.
+ // This is necessary because *all* callResults are passed as deps when initially memoizing the results.
+ if (isChanged) {
+ lastResults.current = results;
+ }
+ return lastResults.current;
+ }, [callResults, calls, chainId]);
+}
+function areCallResultsEqual(a, b) {
+ return a.valid === b.valid && a.data === b.data && a.blockNumber === b.blockNumber;
+}
+// Similar to useCallsDataSubscription above but for subscribing to
+// calls to multiple chains at once
+function useMultichainCallsDataSubscription(context, chainToCalls, listenerOptions) {
+ var reducerPath = context.reducerPath,
+ actions = context.actions;
+ var callResults = useSelector(function (state) {
+ return state[reducerPath].callResults;
+ });
+ var defaultListenerOptions = useSelector(function (state) {
+ return state[reducerPath].listenerOptions;
+ });
+ var dispatch = useDispatch();
+ var serializedCallKeys = useMemo(function () {
+ var sortedChainIds = getChainIds(chainToCalls).sort();
+ var chainCallKeysTuple = sortedChainIds.map(function (chainId) {
+ var calls = chainToCalls[chainId];
+ var callKeys = callsToCallKeys(calls);
+ // Note, using a tuple to ensure consistent order when serialized
+ return [chainId, callKeys];
+ });
+ return JSON.stringify(chainCallKeysTuple);
+ }, [chainToCalls]);
+ useEffect(function () {
+ var chainCallKeysTuples = JSON.parse(serializedCallKeys);
+ if (!(chainCallKeysTuples != null && chainCallKeysTuples.length)) return;
+ batch(function () {
+ for (var _iterator = _createForOfIteratorHelperLoose(chainCallKeysTuples), _step; !(_step = _iterator()).done;) {
+ var _chainId2, _ref2, _listenerOptions$bloc2;
+ var _step$value = _step.value,
+ chainId = _step$value[0],
+ callKeys = _step$value[1];
+ var calls = callKeysToCalls(callKeys);
+ if (!(calls != null && calls.length)) continue;
+ var blocksPerFetchFromState = (_chainId2 = (defaultListenerOptions != null ? defaultListenerOptions : {})[chainId]) == null ? void 0 : _chainId2.blocksPerFetch;
+ var blocksPerFetchForChain = (_ref2 = (_listenerOptions$bloc2 = listenerOptions == null ? void 0 : listenerOptions.blocksPerFetch) != null ? _listenerOptions$bloc2 : blocksPerFetchFromState) != null ? _ref2 : DEFAULT_BLOCKS_PER_FETCH;
+ dispatch(actions.addMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ }
+ });
+ return function () {
+ batch(function () {
+ for (var _iterator2 = _createForOfIteratorHelperLoose(chainCallKeysTuples), _step2; !(_step2 = _iterator2()).done;) {
+ var _chainId3, _ref3, _listenerOptions$bloc3;
+ var _step2$value = _step2.value,
+ chainId = _step2$value[0],
+ callKeys = _step2$value[1];
+ var calls = callKeysToCalls(callKeys);
+ if (!(calls != null && calls.length)) continue;
+ var blocksPerFetchFromState = (_chainId3 = (defaultListenerOptions != null ? defaultListenerOptions : {})[chainId]) == null ? void 0 : _chainId3.blocksPerFetch;
+ var blocksPerFetchForChain = (_ref3 = (_listenerOptions$bloc3 = listenerOptions == null ? void 0 : listenerOptions.blocksPerFetch) != null ? _listenerOptions$bloc3 : blocksPerFetchFromState) != null ? _ref3 : DEFAULT_BLOCKS_PER_FETCH;
+ dispatch(actions.removeMulticallListeners({
+ chainId: chainId,
+ calls: calls,
+ options: {
+ blocksPerFetch: blocksPerFetchForChain
+ }
+ }));
+ }
+ });
+ };
+ }, [actions, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions]);
+ return useMemo(function () {
+ return getChainIds(chainToCalls).reduce(function (result, chainId) {
+ var calls = chainToCalls[chainId];
+ result[chainId] = calls.map(function (call) {
+ var _callResults$chainId2;
+ if (!chainId || !call) return INVALID_RESULT;
+ var result = (_callResults$chainId2 = callResults[chainId]) == null ? void 0 : _callResults$chainId2[toCallKey(call)];
+ var data = result != null && result.data && result.data !== '0x' ? result.data : undefined;
+ return {
+ valid: true,
+ data: data,
+ blockNumber: result == null ? void 0 : result.blockNumber
+ };
+ });
+ return result;
+ }, {});
+ }, [callResults, chainToCalls]);
+}
+// formats many calls to a single function on a single contract, with the function name and inputs specified
+function useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options) {
+ var _ref4 = options != null ? options : {},
+ gasRequired = _ref4.gasRequired;
+ // Create ethers function fragment
+ var fragment = useMemo(function () {
+ var _getAbiItem;
+ return contract && ((_getAbiItem = getAbiItem({
+ abi: contract.abi,
+ name: methodName
+ })) == null ? void 0 : _getAbiItem.name);
+ }, [contract, methodName]);
+ // Get encoded call data. Note can't use useCallData below b.c. this is for a list of CallInputs
+ var callDatas = useMemo(function () {
+ if (!contract || !fragment) return [];
+ return callInputs.map(function (callInput) {
+ return isValidMethodArgs(callInput) ? encodeFunctionData({
+ abi: contract.abi,
+ functionName: fragment,
+ args: callInput
+ }) : undefined;
+ });
+ }, [callInputs, contract, fragment]);
+ // Create call objects
+ var calls = useMemo(function () {
+ if (!contract) return [];
+ return callDatas.map(function (callData) {
+ if (!callData) return undefined;
+ return {
+ address: contract.address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ }, [contract, callDatas, gasRequired]);
+ // Subscribe to call data
+ var results = useCallsDataSubscription(context, chainId, calls, options);
+ return useCallStates(results, contract == null ? void 0 : contract.abi, fragment, latestBlockNumber);
+}
+function useMultipleContractSingleData(context, chainId, latestBlockNumber, addresses, contractInterface, methodName, callInputs, options) {
+ var _ref5 = options != null ? options : {},
+ gasRequired = _ref5.gasRequired;
+ var _useCallData = useCallData(methodName, contractInterface, callInputs),
+ fragment = _useCallData.fragment,
+ callData = _useCallData.callData;
+ // Create call objects
+ var calls = useMemo(function () {
+ if (!callData) return [];
+ return addresses.map(function (address) {
+ if (!address) return undefined;
+ return {
+ address: address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ }, [addresses, callData, gasRequired]);
+ // Subscribe to call data
+ var results = useCallsDataSubscription(context, chainId, calls, options);
+ return useCallStates(results, contractInterface, fragment, latestBlockNumber);
+}
+function useSingleCallResult(context, chainId, latestBlockNumber, contract, methodName, inputs, options) {
+ var _useSingleContractMul;
+ var callInputs = useMemo(function () {
+ return [inputs];
+ }, [inputs]);
+ return (_useSingleContractMul = useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options)[0]) != null ? _useSingleContractMul : INVALID_CALL_STATE;
+}
+// formats many calls to any number of functions on a single contract, with only the calldata specified
+function useSingleContractWithCallData(context, chainId, latestBlockNumber, contract, callDatas, options) {
+ var _ref6 = options != null ? options : {},
+ gasRequired = _ref6.gasRequired;
+ // Create call objects
+ var calls = useMemo(function () {
+ if (!contract) return [];
+ return callDatas.map(function (callData) {
+ return {
+ address: contract.address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ }, [callDatas, contract, gasRequired]);
+ // Subscribe to call data
+ var results = useCallsDataSubscription(context, chainId, calls, options);
+ var fragment = useCallback(function (i) {
+ var _getAbiItem2;
+ return (_getAbiItem2 = getAbiItem({
+ abi: contract == null ? void 0 : contract.abi,
+ name: callDatas[i].substring(0, 10)
+ })) == null ? void 0 : _getAbiItem2.name;
+ }, [callDatas, contract]);
+ return useCallStates(results, contract == null ? void 0 : contract.abi, fragment, latestBlockNumber);
+}
+// Similar to useMultipleContractSingleData but instead of multiple contracts on one chain,
+// this is for querying compatible contracts on multiple chains
+function useMultiChainMultiContractSingleData(context, chainToBlockNumber, chainToAddresses, contractInterface, methodName, callInputs, options) {
+ var _ref7 = options != null ? options : {},
+ gasRequired = _ref7.gasRequired;
+ var _useCallData2 = useCallData(methodName, contractInterface, callInputs),
+ fragment = _useCallData2.fragment,
+ callData = _useCallData2.callData;
+ // Create call objects
+ var chainToCalls = useMemo(function () {
+ if (!callData || !chainToAddresses) return {};
+ return getChainIds(chainToAddresses).reduce(function (result, chainId) {
+ var addresses = chainToAddresses[chainId];
+ var calls = addresses.map(function (address) {
+ if (!address) return undefined;
+ return {
+ address: address,
+ callData: callData,
+ gasRequired: gasRequired
+ };
+ });
+ result[chainId] = calls;
+ return result;
+ }, {});
+ }, [chainToAddresses, callData, gasRequired]);
+ // Subscribe to call data
+ var chainIdToResults = useMultichainCallsDataSubscription(context, chainToCalls, options);
+ // TODO(WEB-2097): Multichain states are not referentially stable, because they cannot use the
+ // same codepath (eg useCallStates).
+ return useMemo(function () {
+ return getChainIds(chainIdToResults).reduce(function (combinedResults, chainId) {
+ var latestBlockNumber = chainToBlockNumber == null ? void 0 : chainToBlockNumber[chainId];
+ var results = chainIdToResults[chainId];
+ combinedResults[chainId] = results.map(function (result) {
+ return toCallState(result, contractInterface, fragment, latestBlockNumber);
+ });
+ return combinedResults;
+ }, {});
+ }, [fragment, contractInterface, chainIdToResults, chainToBlockNumber]);
+}
+// Similar to useSingleCallResult but instead of one contract on one chain,
+// this is for querying a contract on multiple chains
+function useMultiChainSingleContractSingleData(context, chainToBlockNumber, chainToAddress, contractInterface, methodName, callInputs, options) {
+ // This hook uses the more flexible useMultiChainMultiContractSingleData internally,
+ // but transforms the inputs and outputs for convenience
+ var chainIdToAddresses = useMemo(function () {
+ return getChainIds(chainToAddress).reduce(function (result, chainId) {
+ result[chainId] = [chainToAddress[chainId]];
+ return result;
+ }, {});
+ }, [chainToAddress]);
+ var multiContractResults = useMultiChainMultiContractSingleData(context, chainToBlockNumber, chainIdToAddresses, contractInterface, methodName, callInputs, options);
+ return useMemo(function () {
+ return getChainIds(chainToAddress).reduce(function (result, chainId) {
+ var _multiContractResults, _multiContractResults2;
+ result[chainId] = (_multiContractResults = (_multiContractResults2 = multiContractResults[chainId]) == null ? void 0 : _multiContractResults2[0]) != null ? _multiContractResults : INVALID_CALL_STATE;
+ return result;
+ }, {});
+ }, [chainToAddress, multiContractResults]);
+}
+function useCallData(methodName, contractInterface, callInputs) {
+ // Create ethers function fragment
+ var fragment = useMemo(function () {
+ var _getAbiItem3;
+ return contractInterface && ((_getAbiItem3 = getAbiItem({
+ abi: contractInterface,
+ name: methodName
+ })) == null ? void 0 : _getAbiItem3.name);
+ }, [contractInterface, methodName]);
+ // Get encoded call data
+ var callData = useMemo(function () {
+ return fragment && isValidMethodArgs(callInputs) ? encodeFunctionData({
+ abi: contractInterface,
+ functionName: fragment,
+ args: callInputs
+ }) : undefined;
+ }, [callInputs, contractInterface, fragment]);
+ return {
+ fragment: fragment,
+ callData: callData
+ };
+}
+function getChainIds(chainIdMap) {
+ return Object.keys(chainIdMap).map(function (c) {
+ return parseInt(c, 10);
+ });
+}
+
+var initialState = {
+ callResults: {}
+};
+function createMulticallSlice(reducerPath) {
+ return createSlice({
+ name: reducerPath,
+ initialState: initialState,
+ reducers: {
+ addMulticallListeners: function addMulticallListeners(state, action) {
+ var _listeners$chainId;
+ var _action$payload = action.payload,
+ calls = _action$payload.calls,
+ chainId = _action$payload.chainId,
+ blocksPerFetch = _action$payload.options.blocksPerFetch;
+ var listeners = state.callListeners ? state.callListeners : state.callListeners = {};
+ listeners[chainId] = (_listeners$chainId = listeners[chainId]) != null ? _listeners$chainId : {};
+ calls.forEach(function (call) {
+ var _listeners$chainId$ca, _listeners$chainId$ca2;
+ var callKey = toCallKey(call);
+ listeners[chainId][callKey] = (_listeners$chainId$ca = listeners[chainId][callKey]) != null ? _listeners$chainId$ca : {};
+ listeners[chainId][callKey][blocksPerFetch] = ((_listeners$chainId$ca2 = listeners[chainId][callKey][blocksPerFetch]) != null ? _listeners$chainId$ca2 : 0) + 1;
+ });
+ },
+ removeMulticallListeners: function removeMulticallListeners(state, action) {
+ var _action$payload2 = action.payload,
+ calls = _action$payload2.calls,
+ chainId = _action$payload2.chainId,
+ blocksPerFetch = _action$payload2.options.blocksPerFetch;
+ var listeners = state.callListeners ? state.callListeners : state.callListeners = {};
+ if (!listeners[chainId]) return;
+ calls.forEach(function (call) {
+ var callKey = toCallKey(call);
+ if (!listeners[chainId][callKey]) return;
+ if (!listeners[chainId][callKey][blocksPerFetch]) return;
+ if (listeners[chainId][callKey][blocksPerFetch] === 1) {
+ delete listeners[chainId][callKey][blocksPerFetch];
+ } else {
+ listeners[chainId][callKey][blocksPerFetch]--;
+ }
+ });
+ },
+ fetchingMulticallResults: function fetchingMulticallResults(state, action) {
+ var _state$callResults$ch;
+ var _action$payload3 = action.payload,
+ chainId = _action$payload3.chainId,
+ fetchingBlockNumber = _action$payload3.fetchingBlockNumber,
+ calls = _action$payload3.calls;
+ state.callResults[chainId] = (_state$callResults$ch = state.callResults[chainId]) != null ? _state$callResults$ch : {};
+ calls.forEach(function (call) {
+ var callKey = toCallKey(call);
+ var current = state.callResults[chainId][callKey];
+ if (!current) {
+ state.callResults[chainId][callKey] = {
+ fetchingBlockNumber: fetchingBlockNumber
+ };
+ } else {
+ var _current$fetchingBloc;
+ if (((_current$fetchingBloc = current.fetchingBlockNumber) != null ? _current$fetchingBloc : 0) >= fetchingBlockNumber) return;
+ state.callResults[chainId][callKey].fetchingBlockNumber = fetchingBlockNumber;
+ }
+ });
+ },
+ errorFetchingMulticallResults: function errorFetchingMulticallResults(state, action) {
+ var _state$callResults$ch2;
+ var _action$payload4 = action.payload,
+ chainId = _action$payload4.chainId,
+ fetchingBlockNumber = _action$payload4.fetchingBlockNumber,
+ calls = _action$payload4.calls;
+ state.callResults[chainId] = (_state$callResults$ch2 = state.callResults[chainId]) != null ? _state$callResults$ch2 : {};
+ calls.forEach(function (call) {
+ var callKey = toCallKey(call);
+ var current = state.callResults[chainId][callKey];
+ if (!current || typeof current.fetchingBlockNumber !== 'number') return; // only should be dispatched if we are already fetching
+ if (current.fetchingBlockNumber <= fetchingBlockNumber) {
+ delete current.fetchingBlockNumber;
+ current.data = null;
+ current.blockNumber = fetchingBlockNumber;
+ }
+ });
+ },
+ updateMulticallResults: function updateMulticallResults(state, action) {
+ var _state$callResults$ch3;
+ var _action$payload5 = action.payload,
+ chainId = _action$payload5.chainId,
+ results = _action$payload5.results,
+ blockNumber = _action$payload5.blockNumber;
+ state.callResults[chainId] = (_state$callResults$ch3 = state.callResults[chainId]) != null ? _state$callResults$ch3 : {};
+ Object.keys(results).forEach(function (callKey) {
+ var _current$blockNumber;
+ var current = state.callResults[chainId][callKey];
+ if (((_current$blockNumber = current == null ? void 0 : current.blockNumber) != null ? _current$blockNumber : 0) > blockNumber) return;
+ if ((current == null ? void 0 : current.data) === results[callKey] && (current == null ? void 0 : current.blockNumber) === blockNumber) return;
+ state.callResults[chainId][callKey] = {
+ data: results[callKey],
+ blockNumber: blockNumber
+ };
+ });
+ },
+ updateListenerOptions: function updateListenerOptions(state, action) {
+ var _state$listenerOption;
+ var _action$payload6 = action.payload,
+ chainId = _action$payload6.chainId,
+ listenerOptions = _action$payload6.listenerOptions;
+ state.listenerOptions = (_state$listenerOption = state.listenerOptions) != null ? _state$listenerOption : {};
+ state.listenerOptions[chainId] = listenerOptions;
+ }
+ }
+ });
+}
+
+/**
+ * Tries to pack a list of items into as few bins as possible using the first-fit bin packing algorithm
+ * @param calls the calls to chunk
+ * @param chunkGasLimit the gas limit of any one chunk of calls, i.e. bin capacity
+ * @param defaultGasRequired the default amount of gas an individual call should cost if not specified
+ */
+function chunkCalls(calls, chunkGasLimit, defaultGasRequired) {
+ if (defaultGasRequired === void 0) {
+ defaultGasRequired = DEFAULT_CHUNK_GAS_REQUIRED;
+ }
+ return calls
+ // first sort by gas required
+ .sort(function (c1, c2) {
+ var _c2$gasRequired, _c1$gasRequired;
+ return ((_c2$gasRequired = c2.gasRequired) != null ? _c2$gasRequired : defaultGasRequired) - ((_c1$gasRequired = c1.gasRequired) != null ? _c1$gasRequired : defaultGasRequired);
+ })
+ // then bin the calls according to the first fit algorithm
+ .reduce(function (bins, call) {
+ var _call$gasRequired;
+ var gas = (_call$gasRequired = call.gasRequired) != null ? _call$gasRequired : defaultGasRequired;
+ for (var _iterator = _createForOfIteratorHelperLoose(bins), _step; !(_step = _iterator()).done;) {
+ var bin = _step.value;
+ if (bin.cumulativeGasLimit + gas <= chunkGasLimit) {
+ bin.calls.push(call);
+ bin.cumulativeGasLimit += gas;
+ return bins;
+ }
+ }
+ // didn't find a bin for the call, make a new bin
+ bins.push({
+ calls: [call],
+ cumulativeGasLimit: gas
+ });
+ return bins;
+ }, [])
+ // pull out just the calls from each bin
+ .map(function (b) {
+ return b.calls;
+ });
+}
+
+// TODO de-duplicate this file with web interface
+// https://github.com/Uniswap/interface/blob/main/src/utils/retry.ts
+function wait(ms) {
+ return new Promise(function (resolve) {
+ return setTimeout(resolve, ms);
+ });
+}
+function waitRandom(min, max) {
+ return wait(min + Math.round(Math.random() * Math.max(0, max - min)));
+}
+/**
+ * This error is thrown if the function is cancelled before completing
+ */
+var CancelledError = /*#__PURE__*/function (_Error) {
+ function CancelledError() {
+ var _this;
+ _this = _Error.call(this, 'Cancelled') || this;
+ _this.isCancelledError = true;
+ return _this;
+ }
+ _inheritsLoose(CancelledError, _Error);
+ return CancelledError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * Throw this error if the function should retry
+ */
+var RetryableError = /*#__PURE__*/function (_Error2) {
+ function RetryableError() {
+ var _this2;
+ _this2 = _Error2.apply(this, arguments) || this;
+ _this2.isRetryableError = true;
+ return _this2;
+ }
+ _inheritsLoose(RetryableError, _Error2);
+ return RetryableError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * Retries the function that returns the promise until the promise successfully resolves up to n retries
+ * @param fn function to retry
+ * @param n how many times to retry
+ * @param minWait min wait between retries in ms
+ * @param maxWait max wait between retries in ms
+ */
+function retry(fn, _ref) {
+ var n = _ref.n,
+ minWait = _ref.minWait,
+ maxWait = _ref.maxWait;
+ var completed = false;
+ var rejectCancelled;
+ var promise = new Promise( /*#__PURE__*/function () {
+ var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(resolve, reject) {
+ var result;
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
+ while (1) switch (_context.prev = _context.next) {
+ case 0:
+ rejectCancelled = reject;
+ case 1:
+ result = void 0;
+ _context.prev = 3;
+ _context.next = 6;
+ return fn();
+ case 6:
+ result = _context.sent;
+ if (!completed) {
+ resolve(result);
+ completed = true;
+ }
+ return _context.abrupt("break", 24);
+ case 11:
+ _context.prev = 11;
+ _context.t0 = _context["catch"](3);
+ if (!completed) {
+ _context.next = 15;
+ break;
+ }
+ return _context.abrupt("break", 24);
+ case 15:
+ if (!(n <= 0 || !_context.t0.isRetryableError)) {
+ _context.next = 19;
+ break;
+ }
+ reject(_context.t0);
+ completed = true;
+ return _context.abrupt("break", 24);
+ case 19:
+ n--;
+ case 20:
+ _context.next = 22;
+ return waitRandom(minWait, maxWait);
+ case 22:
+ _context.next = 1;
+ break;
+ case 24:
+ case "end":
+ return _context.stop();
+ }
+ }, _callee, null, [[3, 11]]);
+ }));
+ return function (_x, _x2) {
+ return _ref2.apply(this, arguments);
+ };
+ }());
+ return {
+ promise: promise,
+ cancel: function cancel() {
+ if (completed) return;
+ completed = true;
+ rejectCancelled(new CancelledError());
+ }
+ };
+}
+
+// TODO de-duplicate this file with web interface
+// modified from https://usehooks.com/useDebounce/
+function useDebounce(value, delay) {
+ var _useState = useState(value),
+ debouncedValue = _useState[0],
+ setDebouncedValue = _useState[1];
+ useEffect(function () {
+ // Update debounced value after delay
+ var handler = setTimeout(function () {
+ setDebouncedValue(value);
+ }, delay);
+ // Cancel the timeout if value changes (also on delay change or unmount)
+ // This is how we prevent debounced value from updating if value is changed ...
+ // .. within the delay period. Timeout gets cleared and restarted.
+ return function () {
+ clearTimeout(handler);
+ };
+ }, [value, delay]);
+ return debouncedValue;
+}
+
+var IMulticallABI = [{
+ inputs: [],
+ name: 'getCurrentBlockTimestamp',
+ outputs: [{
+ internalType: 'uint256',
+ name: 'timestamp',
+ type: 'uint256'
+ }],
+ stateMutability: 'view',
+ type: 'function'
+}, {
+ inputs: [{
+ internalType: 'address',
+ name: 'addr',
+ type: 'address'
+ }],
+ name: 'getEthBalance',
+ outputs: [{
+ internalType: 'uint256',
+ name: 'balance',
+ type: 'uint256'
+ }],
+ stateMutability: 'view',
+ type: 'function'
+}, {
+ inputs: [{
+ components: [{
+ internalType: 'address',
+ name: 'target',
+ type: 'address'
+ }, {
+ internalType: 'uint256',
+ name: 'gasLimit',
+ type: 'uint256'
+ }, {
+ internalType: 'bytes',
+ name: 'callData',
+ type: 'bytes'
+ }],
+ internalType: 'struct PancakeInterfaceMulticall.Call[]',
+ name: 'calls',
+ type: 'tuple[]'
+ }],
+ name: 'multicall',
+ outputs: [{
+ internalType: 'uint256',
+ name: 'blockNumber',
+ type: 'uint256'
+ }, {
+ components: [{
+ internalType: 'bool',
+ name: 'success',
+ type: 'bool'
+ }, {
+ internalType: 'uint256',
+ name: 'gasUsed',
+ type: 'uint256'
+ }, {
+ internalType: 'bytes',
+ name: 'returnData',
+ type: 'bytes'
+ }],
+ internalType: 'struct PancakeInterfaceMulticall.Result[]',
+ name: 'returnData',
+ type: 'tuple[]'
+ }],
+ stateMutability: 'nonpayable',
+ type: 'function'
+}];
+
+var FETCH_RETRY_CONFIG = {
+ n: Infinity,
+ minWait: 1000,
+ maxWait: 2500
+};
+/**
+ * Fetches a chunk of calls, enforcing a minimum block number constraint
+ * @param multicall multicall contract to fetch against
+ * @param chunk chunk of calls to make
+ * @param blockNumber block number passed as the block tag in the eth_call
+ */
+function fetchChunk(_x, _x2, _x3, _x4) {
+ return _fetchChunk.apply(this, arguments);
+}
+/**
+ * From the current all listeners state, return each call key mapped to the
+ * minimum number of blocks per fetch. This is how often each key must be fetched.
+ * @param allListeners the all listeners state
+ * @param chainId the current chain id
+ */
+function _fetchChunk() {
+ _fetchChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(multicallInfo, chunk, blockNumber, isDebug) {
+ var _yield$multicallInfo$, _yield$multicallInfo$2, returnData, _error$message, _error$message2, error, half, _yield$Promise$all, c0, c1;
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
+ while (1) switch (_context.prev = _context.next) {
+ case 0:
+ console.debug('Fetching chunk', chunk, blockNumber, chunk.map(function (obj) {
+ var _obj$gasRequired;
+ return {
+ target: obj.address,
+ callData: obj.callData,
+ gasLimit: (_obj$gasRequired = obj.gasRequired) != null ? _obj$gasRequired : DEFAULT_CALL_GAS_REQUIRED
+ };
+ }));
+ _context.prev = 1;
+ _context.next = 4;
+ return multicallInfo.provider.simulateContract({
+ abi: IMulticallABI,
+ address: multicallInfo.address,
+ functionName: 'multicall',
+ args: [chunk.map(function (obj) {
+ var _obj$gasRequired2;
+ return {
+ target: obj.address,
+ callData: obj.callData,
+ gasLimit: (_obj$gasRequired2 = obj.gasRequired) != null ? _obj$gasRequired2 : DEFAULT_CALL_GAS_REQUIRED
+ };
+ })],
+ // we aren't passing through the block gas limit we used to create the chunk, because it causes a problem with the integ tests
+ blockNumber: BigInt(blockNumber)
+ });
+ case 4:
+ _yield$multicallInfo$ = _context.sent;
+ _yield$multicallInfo$2 = _yield$multicallInfo$.result;
+ returnData = _yield$multicallInfo$2[1];
+ if (isDebug) {
+ returnData.forEach(function (_ref, i) {
+ var _chunk$i$gasRequired;
+ var gasUsed = _ref.gasUsed,
+ returnData = _ref.returnData,
+ success = _ref.success;
+ if (!success && returnData.length === 2 && gasUsed >= Math.floor(((_chunk$i$gasRequired = chunk[i].gasRequired) != null ? _chunk$i$gasRequired : DEFAULT_CALL_GAS_REQUIRED) * 0.95)) {
+ var _chunk$i$gasRequired2;
+ console.warn("A call failed due to requiring " + gasUsed.toString() + " vs. allowed " + ((_chunk$i$gasRequired2 = chunk[i].gasRequired) != null ? _chunk$i$gasRequired2 : DEFAULT_CALL_GAS_REQUIRED), chunk[i]);
+ }
+ });
+ }
+ return _context.abrupt("return", returnData);
+ case 11:
+ _context.prev = 11;
+ _context.t0 = _context["catch"](1);
+ error = _context.t0;
+ if (!(error.code === -32000 || ((_error$message = error.message) == null ? void 0 : _error$message.indexOf('header not found')) !== -1)) {
+ _context.next = 18;
+ break;
+ }
+ throw new RetryableError("header not found for block number " + blockNumber);
+ case 18:
+ if (!(error.code === -32603 || ((_error$message2 = error.message) == null ? void 0 : _error$message2.indexOf('execution ran out of gas')) !== -1)) {
+ _context.next = 28;
+ break;
+ }
+ if (!(chunk.length > 1)) {
+ _context.next = 28;
+ break;
+ }
+ if (process.env.NODE_ENV === 'development') {
+ console.debug('Splitting a chunk in 2', chunk);
+ }
+ half = Math.floor(chunk.length / 2);
+ _context.next = 24;
+ return Promise.all([fetchChunk(multicallInfo, chunk.slice(0, half), blockNumber), fetchChunk(multicallInfo, chunk.slice(half, chunk.length), blockNumber)]);
+ case 24:
+ _yield$Promise$all = _context.sent;
+ c0 = _yield$Promise$all[0];
+ c1 = _yield$Promise$all[1];
+ return _context.abrupt("return", c0.concat(c1));
+ case 28:
+ console.error('Failed to fetch chunk', error);
+ throw error;
+ case 30:
+ case "end":
+ return _context.stop();
+ }
+ }, _callee, null, [[1, 11]]);
+ }));
+ return _fetchChunk.apply(this, arguments);
+}
+function activeListeningKeys(allListeners, chainId) {
+ if (!allListeners || !chainId) return {};
+ var listeners = allListeners[chainId];
+ if (!listeners) return {};
+ return Object.keys(listeners).reduce(function (memo, callKey) {
+ var keyListeners = listeners[callKey];
+ memo[callKey] = Object.keys(keyListeners).filter(function (key) {
+ var blocksPerFetch = parseInt(key);
+ if (blocksPerFetch <= 0) return false;
+ return keyListeners[blocksPerFetch] > 0;
+ }).reduce(function (previousMin, current) {
+ return Math.min(previousMin, parseInt(current));
+ }, Infinity);
+ return memo;
+ }, {});
+}
+/**
+ * Return the keys that need to be refetched
+ * @param callResults current call result state
+ * @param listeningKeys each call key mapped to how old the data can be in blocks
+ * @param chainId the current chain id
+ * @param latestBlockNumber the latest block number
+ */
+function outdatedListeningKeys(callResults, listeningKeys, chainId, latestBlockNumber) {
+ if (!chainId || !latestBlockNumber) return [];
+ var results = callResults[chainId];
+ // no results at all, load everything
+ if (!results) return Object.keys(listeningKeys);
+ return Object.keys(listeningKeys).filter(function (callKey) {
+ var blocksPerFetch = listeningKeys[callKey];
+ var data = callResults[chainId][callKey];
+ // no data, must fetch
+ if (!data) return true;
+ var minDataBlockNumber = latestBlockNumber - (blocksPerFetch - 1);
+ // already fetching it for a recent enough block, don't refetch it
+ if (data.fetchingBlockNumber && data.fetchingBlockNumber >= minDataBlockNumber) return false;
+ // if data is older than minDataBlockNumber, fetch it
+ return !data.blockNumber || data.blockNumber < minDataBlockNumber;
+ });
+}
+function onFetchChunkSuccess(context, chunk, result) {
+ var actions = context.actions,
+ dispatch = context.dispatch,
+ chainId = context.chainId,
+ latestBlockNumber = context.latestBlockNumber,
+ isDebug = context.isDebug;
+ // split the returned slice into errors and results
+ var _chunk$reduce = chunk.reduce(function (memo, call, i) {
+ if (result[i].success) {
+ var _result$i$returnData;
+ memo.results[toCallKey(call)] = (_result$i$returnData = result[i].returnData) != null ? _result$i$returnData : null;
+ } else {
+ memo.erroredCalls.push(call);
+ }
+ return memo;
+ }, {
+ erroredCalls: [],
+ results: {}
+ }),
+ erroredCalls = _chunk$reduce.erroredCalls,
+ results = _chunk$reduce.results;
+ // dispatch any new results
+ if (Object.keys(results).length > 0) dispatch(actions.updateMulticallResults({
+ chainId: chainId,
+ results: results,
+ blockNumber: latestBlockNumber
+ }));
+ // dispatch any errored calls
+ if (erroredCalls.length > 0) {
+ if (isDebug) {
+ result.forEach(function (returnData, ix) {
+ if (!returnData.success) {
+ console.debug('Call failed', chunk[ix], returnData);
+ }
+ });
+ } else {
+ console.debug('Calls errored in fetch', erroredCalls);
+ }
+ dispatch(actions.errorFetchingMulticallResults({
+ calls: erroredCalls,
+ chainId: chainId,
+ fetchingBlockNumber: latestBlockNumber
+ }));
+ }
+}
+function onFetchChunkFailure(context, chunk, error) {
+ var actions = context.actions,
+ dispatch = context.dispatch,
+ chainId = context.chainId,
+ latestBlockNumber = context.latestBlockNumber;
+ if (error.isCancelledError) {
+ console.debug('Cancelled fetch for blockNumber', latestBlockNumber, chunk, chainId);
+ return;
+ }
+ console.error('Failed to fetch multicall chunk', chunk, chainId, error);
+ dispatch(actions.errorFetchingMulticallResults({
+ calls: chunk,
+ chainId: chainId,
+ fetchingBlockNumber: latestBlockNumber
+ }));
+}
+function Updater(props) {
+ var context = props.context,
+ chainId = props.chainId,
+ latestBlockNumber = props.latestBlockNumber,
+ multicallInfo = props.multicallInfo,
+ isDebug = props.isDebug,
+ listenerOptions = props.listenerOptions;
+ var actions = context.actions,
+ reducerPath = context.reducerPath;
+ var dispatch = useDispatch();
+ // set user configured listenerOptions in state for given chain ID.
+ useEffect(function () {
+ if (chainId && listenerOptions) {
+ dispatch(actions.updateListenerOptions({
+ chainId: chainId,
+ listenerOptions: listenerOptions
+ }));
+ }
+ }, [chainId, listenerOptions, actions, dispatch]);
+ var state = useSelector(function (state) {
+ return state[reducerPath];
+ });
+ // wait for listeners to settle before triggering updates
+ var debouncedListeners = useDebounce(state.callListeners, 100);
+ var cancellations = useRef();
+ var listeningKeys = useMemo(function () {
+ return activeListeningKeys(debouncedListeners, chainId);
+ }, [debouncedListeners, chainId]);
+ var serializedOutdatedCallKeys = useMemo(function () {
+ var outdatedCallKeys = outdatedListeningKeys(state.callResults, listeningKeys, chainId, latestBlockNumber);
+ return JSON.stringify(outdatedCallKeys.sort());
+ }, [chainId, state.callResults, listeningKeys, latestBlockNumber]);
+ useEffect(function () {
+ if (!latestBlockNumber || !chainId || !multicallInfo) return;
+ var outdatedCallKeys = JSON.parse(serializedOutdatedCallKeys);
+ if (outdatedCallKeys.length === 0) return;
+ var calls = outdatedCallKeys.map(function (key) {
+ return parseCallKey(key);
+ });
+ var chunkedCalls = chunkCalls(calls, CHUNK_GAS_LIMIT);
+ if (cancellations.current && cancellations.current.blockNumber !== latestBlockNumber) {
+ cancellations.current.cancellations.forEach(function (c) {
+ return c();
+ });
+ }
+ dispatch(actions.fetchingMulticallResults({
+ calls: calls,
+ chainId: chainId,
+ fetchingBlockNumber: latestBlockNumber
+ }));
+ var fetchChunkContext = {
+ actions: actions,
+ dispatch: dispatch,
+ chainId: chainId,
+ latestBlockNumber: latestBlockNumber,
+ isDebug: isDebug
+ };
+ // Execute fetches and gather cancellation callbacks
+ var newCancellations = chunkedCalls.map(function (chunk) {
+ var _retry = retry(function () {
+ return fetchChunk(multicallInfo, chunk, latestBlockNumber, isDebug);
+ }, FETCH_RETRY_CONFIG),
+ cancel = _retry.cancel,
+ promise = _retry.promise;
+ promise.then(function (result) {
+ return onFetchChunkSuccess(fetchChunkContext, chunk, result);
+ })["catch"](function (error) {
+ return onFetchChunkFailure(fetchChunkContext, chunk, error);
+ });
+ return cancel;
+ });
+ cancellations.current = {
+ blockNumber: latestBlockNumber,
+ cancellations: newCancellations
+ };
+ }, [actions, chainId, multicallInfo, dispatch, serializedOutdatedCallKeys, latestBlockNumber, isDebug]);
+ return null;
+}
+function createUpdater(context) {
+ var UpdaterContextBound = function UpdaterContextBound(props) {
+ return React.createElement(Updater, Object.assign({
+ context: context
+ }, props));
+ };
+ return UpdaterContextBound;
+}
+
+// Inspired by RTK Query's createApi
+function createMulticall(options) {
+ var _options$reducerPath;
+ var reducerPath = (_options$reducerPath = options == null ? void 0 : options.reducerPath) != null ? _options$reducerPath : 'multicall';
+ var slice = createMulticallSlice(reducerPath);
+ var actions = slice.actions,
+ reducer = slice.reducer;
+ var context = {
+ reducerPath: reducerPath,
+ actions: actions
+ };
+ var useMultipleContractSingleData$1 = function useMultipleContractSingleData$1() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+ return useMultipleContractSingleData.apply(void 0, [context].concat(args));
+ };
+ var useSingleContractMultipleData$1 = function useSingleContractMultipleData$1() {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+ return useSingleContractMultipleData.apply(void 0, [context].concat(args));
+ };
+ var useSingleContractWithCallData$1 = function useSingleContractWithCallData$1() {
+ for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+ return useSingleContractWithCallData.apply(void 0, [context].concat(args));
+ };
+ var useSingleCallResult$1 = function useSingleCallResult$1() {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+ return useSingleCallResult.apply(void 0, [context].concat(args));
+ };
+ var useMultiChainMultiContractSingleData$1 = function useMultiChainMultiContractSingleData$1() {
+ for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+ args[_key5] = arguments[_key5];
+ }
+ return useMultiChainMultiContractSingleData.apply(void 0, [context].concat(args));
+ };
+ var useMultiChainSingleContractSingleData$1 = function useMultiChainSingleContractSingleData$1() {
+ for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+ args[_key6] = arguments[_key6];
+ }
+ return useMultiChainSingleContractSingleData.apply(void 0, [context].concat(args));
+ };
+ var hooks = {
+ useMultipleContractSingleData: useMultipleContractSingleData$1,
+ useSingleContractMultipleData: useSingleContractMultipleData$1,
+ useSingleContractWithCallData: useSingleContractWithCallData$1,
+ useSingleCallResult: useSingleCallResult$1,
+ useMultiChainMultiContractSingleData: useMultiChainMultiContractSingleData$1,
+ useMultiChainSingleContractSingleData: useMultiChainSingleContractSingleData$1
+ };
+ var Updater = createUpdater(context);
+ return {
+ reducerPath: reducerPath,
+ reducer: reducer,
+ actions: actions,
+ hooks: hooks,
+ Updater: Updater
+ };
+}
+
+export { CHUNK_GAS_LIMIT, CONSERVATIVE_BLOCK_GAS_LIMIT, DEFAULT_BLOCKS_PER_FETCH, DEFAULT_CALL_GAS_REQUIRED, DEFAULT_CHUNK_GAS_REQUIRED, INVALID_CALL_STATE, INVALID_RESULT, LOADING_CALL_STATE, NEVER_RELOAD, createMulticall };
+//# sourceMappingURL=redux-multicall-viem.esm.js.map
diff --git a/dist/redux-multicall-viem.esm.js.map b/dist/redux-multicall-viem.esm.js.map
new file mode 100644
index 0000000..103739f
--- /dev/null
+++ b/dist/redux-multicall-viem.esm.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"redux-multicall-viem.esm.js","sources":["../src/constants.ts","../src/utils/callKeys.ts","../src/utils/callState.ts","../src/validation.ts","../src/hooks.ts","../src/slice.ts","../src/utils/chunkCalls.ts","../src/utils/retry.ts","../src/utils/useDebounce.ts","../src/abi/InterfaceMulticall.ts","../src/updater.tsx","../src/create.ts"],"sourcesContent":["import type { CallResult, CallState, ListenerOptions } from './types'\n\nexport const DEFAULT_BLOCKS_PER_FETCH = 1\nexport const DEFAULT_CALL_GAS_REQUIRED = 1_000_000\nexport const DEFAULT_CHUNK_GAS_REQUIRED = 200_000\nexport const CHUNK_GAS_LIMIT = 100_000_000\nexport const CONSERVATIVE_BLOCK_GAS_LIMIT = 10_000_000 // conservative, hard-coded estimate of the current block gas limit\n\n// Consts for hooks\nexport const INVALID_RESULT: CallResult = { valid: false, blockNumber: undefined, data: undefined }\nexport const NEVER_RELOAD: ListenerOptions = {\n blocksPerFetch: Infinity,\n}\n\nexport const INVALID_CALL_STATE: CallState = {\n valid: false,\n result: undefined,\n loading: false,\n syncing: false,\n error: false,\n}\nexport const LOADING_CALL_STATE: CallState = {\n valid: true,\n result: undefined,\n loading: true,\n syncing: true,\n error: false,\n}\n","import { Call } from '../types'\n\nexport function toCallKey(call: Call): string {\n let key = `${call.address}-${call.callData}`\n if (call.gasRequired) {\n if (!Number.isSafeInteger(call.gasRequired)) {\n throw new Error(`Invalid number: ${call.gasRequired}`)\n }\n key += `-${call.gasRequired}`\n }\n return key\n}\n\nexport function parseCallKey(callKey: string): Call {\n const pcs = callKey.split('-')\n if (![2, 3].includes(pcs.length)) {\n throw new Error(`Invalid call key: ${callKey}`)\n }\n return {\n address: pcs[0],\n callData: pcs[1],\n ...(pcs[2] ? { gasRequired: Number.parseInt(pcs[2]) } : {}),\n }\n}\n\nexport function callsToCallKeys(calls?: Array) {\n return (\n calls\n ?.filter((c): c is Call => Boolean(c))\n ?.map(toCallKey)\n ?.sort() ?? []\n )\n}\n\nexport function callKeysToCalls(callKeys: string[]) {\n if (!callKeys?.length) return null\n return callKeys.map((key) => parseCallKey(key))\n}\n","import { useMemo } from 'react'\nimport { INVALID_CALL_STATE, LOADING_CALL_STATE } from '../constants'\nimport type { CallResult, CallState, CallStateResult } from '../types'\nimport { AbiFunction, decodeFunctionResult } from 'viem'\n\n// Converts CallResult[] to CallState[], only updating if call states have changed.\n// Ensures that CallState results remain referentially stable when unchanged, preventing\n// spurious re-renders which would otherwise occur because mapping always creates a new object.\nexport function useCallStates(\n results: CallResult[],\n contractInterface: AbiFunction[] | undefined,\n fragment: ((i: number) => string | undefined) | string | undefined,\n latestBlockNumber: number | undefined\n): CallState[] {\n // Avoid refreshing the results with every changing block number (eg latestBlockNumber).\n // Instead, only refresh the results if they need to be synced - if there is a result which is stale, for which blockNumber < latestBlockNumber.\n const syncingBlockNumber = useMemo(() => {\n const lowestBlockNumber = results.reduce(\n (memo, result) => (result.blockNumber ? Math.min(memo ?? result.blockNumber, result.blockNumber) : memo),\n undefined\n )\n return Math.max(lowestBlockNumber ?? 0, latestBlockNumber ?? 0)\n }, [results, latestBlockNumber])\n\n return useMemo(() => {\n return results.map((result, i) => {\n const resultFragment = typeof fragment === 'function' ? fragment(i) : fragment\n return toCallState(result, contractInterface, resultFragment, syncingBlockNumber)\n })\n }, [contractInterface, fragment, results, syncingBlockNumber])\n}\n\nexport function toCallState(\n callResult: CallResult | undefined,\n contractInterface: AbiFunction[] | undefined,\n fragment: string | undefined,\n syncingBlockNumber: number | undefined\n): CallState {\n if (!callResult || !callResult.valid) {\n return INVALID_CALL_STATE\n }\n\n const { data, blockNumber } = callResult\n if (!blockNumber || !contractInterface || !fragment || !syncingBlockNumber) {\n return LOADING_CALL_STATE\n }\n\n const success = data && data.length > 2\n const syncing = blockNumber < syncingBlockNumber\n let result: CallStateResult | undefined = undefined\n if (success && data) {\n try {\n result = (decodeFunctionResult as any)({\n abi: contractInterface,\n functionName: fragment,\n data: data as any,\n }) as any\n } catch (error) {\n console.debug('Result data parsing failed', fragment, data)\n return {\n valid: true,\n loading: false,\n error: true,\n syncing,\n result,\n }\n }\n }\n return {\n valid: true,\n loading: false,\n syncing,\n result,\n error: !success,\n }\n}\n","export type MethodArg = string | number | BigInt\nexport type MethodArgs = Array\n\nexport function isMethodArg(x: unknown): x is MethodArg {\n return (x === null || x === undefined) ? false : typeof BigInt(x as any) === 'bigint' || ['string', 'number'].indexOf(typeof x) !== -1\n}\n\nexport function isValidMethodArgs(x: unknown): x is MethodArgs | undefined {\n return (\n x === undefined ||\n (Array.isArray(x) && x.every((xi) => isMethodArg(xi) || (Array.isArray(xi) && xi.every(isMethodArg))))\n )\n}\n","import { useCallback, useEffect, useMemo, useRef } from 'react'\nimport { batch, useDispatch, useSelector } from 'react-redux'\nimport { INVALID_CALL_STATE, INVALID_RESULT, DEFAULT_BLOCKS_PER_FETCH } from './constants'\nimport type { MulticallContext } from './context'\nimport type {\n Call,\n CallResult,\n CallState,\n ContractInfo,\n ListenerOptions,\n ListenerOptionsWithGas,\n WithMulticallState,\n} from './types'\nimport { callKeysToCalls, callsToCallKeys, toCallKey } from './utils/callKeys'\nimport { toCallState, useCallStates } from './utils/callState'\nimport { isValidMethodArgs, MethodArg } from './validation'\nimport { AbiFunction, encodeFunctionData, getAbiItem } from 'viem'\n\ntype OptionalMethodInputs = Array | undefined\n\n// the lowest level call for subscribing to contract data\nexport function useCallsDataSubscription(\n context: MulticallContext,\n chainId: number | undefined,\n calls: Array,\n listenerOptions?: ListenerOptions\n): CallResult[] {\n const { reducerPath, actions } = context\n const callResults = useSelector((state: WithMulticallState) => state[reducerPath].callResults)\n const defaultListenerOptions = useSelector((state: WithMulticallState) => state[reducerPath].listenerOptions)\n const dispatch = useDispatch()\n const serializedCallKeys: string = useMemo(() => JSON.stringify(callsToCallKeys(calls)), [calls])\n\n // update listeners when there is an actual change that persists for at least 100ms\n useEffect(() => {\n const callKeys: string[] = JSON.parse(serializedCallKeys)\n const calls = callKeysToCalls(callKeys)\n if (!chainId || !calls) return\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n\n dispatch(\n actions.addMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n\n return () => {\n dispatch(\n actions.removeMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n }, [actions, chainId, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions])\n\n const lastResults = useRef([])\n return useMemo(() => {\n let isChanged = lastResults.current.length !== calls.length\n\n // Construct results using a for-loop to handle sparse arrays.\n // Array.prototype.map would skip empty entries.\n let results: CallResult[] = []\n for (let i = 0; i < calls.length; ++i) {\n const call = calls[i]\n let result = INVALID_RESULT\n if (chainId && call) {\n const callResult = callResults[chainId]?.[toCallKey(call)]\n result = {\n valid: true,\n data: callResult?.data && callResult.data !== '0x' ? callResult.data : undefined,\n blockNumber: callResult?.blockNumber,\n }\n }\n\n isChanged = isChanged || !areCallResultsEqual(result, lastResults.current[i])\n results.push(result)\n }\n\n // Force the results to be referentially stable if they have not changed.\n // This is necessary because *all* callResults are passed as deps when initially memoizing the results.\n if (isChanged) {\n lastResults.current = results\n }\n return lastResults.current\n }, [callResults, calls, chainId])\n}\n\nfunction areCallResultsEqual(a: CallResult, b: CallResult) {\n return a.valid === b.valid && a.data === b.data && a.blockNumber === b.blockNumber\n}\n\n// Similar to useCallsDataSubscription above but for subscribing to\n// calls to multiple chains at once\nfunction useMultichainCallsDataSubscription(\n context: MulticallContext,\n chainToCalls: Record>,\n listenerOptions?: ListenerOptions\n): Record {\n const { reducerPath, actions } = context\n const callResults = useSelector((state: WithMulticallState) => state[reducerPath].callResults)\n const defaultListenerOptions = useSelector((state: WithMulticallState) => state[reducerPath].listenerOptions)\n const dispatch = useDispatch()\n\n const serializedCallKeys: string = useMemo(() => {\n const sortedChainIds = getChainIds(chainToCalls).sort()\n const chainCallKeysTuple = sortedChainIds.map((chainId) => {\n const calls = chainToCalls[chainId]\n const callKeys = callsToCallKeys(calls)\n // Note, using a tuple to ensure consistent order when serialized\n return [chainId, callKeys]\n })\n return JSON.stringify(chainCallKeysTuple)\n }, [chainToCalls])\n\n useEffect(() => {\n const chainCallKeysTuples: Array<[number, string[]]> = JSON.parse(serializedCallKeys)\n if (!chainCallKeysTuples?.length) return\n\n batch(() => {\n for (const [chainId, callKeys] of chainCallKeysTuples) {\n const calls = callKeysToCalls(callKeys)\n if (!calls?.length) continue\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n\n dispatch(\n actions.addMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n })\n\n return () => {\n batch(() => {\n for (const [chainId, callKeys] of chainCallKeysTuples) {\n const calls = callKeysToCalls(callKeys)\n if (!calls?.length) continue\n const blocksPerFetchFromState = (defaultListenerOptions ?? {})[chainId]?.blocksPerFetch\n const blocksPerFetchForChain =\n listenerOptions?.blocksPerFetch ?? blocksPerFetchFromState ?? DEFAULT_BLOCKS_PER_FETCH\n dispatch(\n actions.removeMulticallListeners({\n chainId,\n calls,\n options: { blocksPerFetch: blocksPerFetchForChain },\n })\n )\n }\n })\n }\n }, [actions, dispatch, listenerOptions, serializedCallKeys, defaultListenerOptions])\n\n return useMemo(\n () =>\n getChainIds(chainToCalls).reduce((result, chainId) => {\n const calls = chainToCalls[chainId]\n result[chainId] = calls.map((call) => {\n if (!chainId || !call) return INVALID_RESULT\n const result = callResults[chainId]?.[toCallKey(call)]\n const data = result?.data && result.data !== '0x' ? result.data : undefined\n return { valid: true, data, blockNumber: result?.blockNumber }\n })\n return result\n }, {} as Record),\n [callResults, chainToCalls]\n )\n}\n\n// formats many calls to a single function on a single contract, with the function name and inputs specified\nexport function useSingleContractMultipleData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n methodName: string,\n callInputs: OptionalMethodInputs[],\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n // Create ethers function fragment\n const fragment = useMemo(\n () => contract && ((getAbiItem as any)({ abi: contract.abi, name: methodName } as any) as any)?.name,\n [contract, methodName]\n )\n\n // Get encoded call data. Note can't use useCallData below b.c. this is for a list of CallInputs\n const callDatas = useMemo(() => {\n if (!contract || !fragment) return []\n return callInputs.map((callInput) =>\n isValidMethodArgs(callInput)\n ? (encodeFunctionData as any)({\n abi: contract.abi,\n functionName: fragment,\n args: callInput,\n })\n : undefined\n )\n }, [callInputs, contract, fragment])\n\n // Create call objects\n const calls = useMemo(() => {\n if (!contract) return []\n return callDatas.map((callData) => {\n if (!callData) return undefined\n return {\n address: contract.address,\n callData,\n gasRequired,\n }\n })\n }, [contract, callDatas, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n return useCallStates(results, contract?.abi, fragment, latestBlockNumber)\n}\n\nexport function useMultipleContractSingleData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n addresses: (string | undefined)[],\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n const { fragment, callData } = useCallData(methodName, contractInterface, callInputs)\n\n // Create call objects\n const calls = useMemo(() => {\n if (!callData) return []\n return addresses.map((address) => {\n if (!address) return undefined\n return { address, callData, gasRequired }\n })\n }, [addresses, callData, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n return useCallStates(results, contractInterface, fragment, latestBlockNumber)\n}\n\nexport function useSingleCallResult(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n methodName: string,\n inputs?: OptionalMethodInputs,\n options?: Partial\n): CallState {\n const callInputs = useMemo(() => [inputs], [inputs])\n return (\n useSingleContractMultipleData(context, chainId, latestBlockNumber, contract, methodName, callInputs, options)[0] ??\n INVALID_CALL_STATE\n )\n}\n\n// formats many calls to any number of functions on a single contract, with only the calldata specified\nexport function useSingleContractWithCallData(\n context: MulticallContext,\n chainId: number | undefined,\n latestBlockNumber: number | undefined,\n contract: ContractInfo | null | undefined,\n callDatas: string[],\n options?: Partial\n): CallState[] {\n const { gasRequired } = options ?? {}\n\n // Create call objects\n const calls = useMemo(() => {\n if (!contract) return []\n return callDatas.map((callData) => ({\n address: contract.address,\n callData,\n gasRequired,\n }))\n }, [callDatas, contract, gasRequired])\n\n // Subscribe to call data\n const results = useCallsDataSubscription(context, chainId, calls, options as ListenerOptions)\n const fragment = useCallback(\n (i: number) => ((getAbiItem as any)({ abi: contract?.abi as any, name: callDatas[i].substring(0, 10) }) as any)?.name,\n [callDatas, contract]\n )\n return useCallStates(results, contract?.abi, fragment, latestBlockNumber)\n}\n\n// Similar to useMultipleContractSingleData but instead of multiple contracts on one chain,\n// this is for querying compatible contracts on multiple chains\nexport function useMultiChainMultiContractSingleData(\n context: MulticallContext,\n chainToBlockNumber: Record,\n chainToAddresses: Record>,\n contractInterface: AbiFunction[],\n methodName: string,\n callInputs?: OptionalMethodInputs,\n options?: Partial\n): Record {\n const { gasRequired } = options ?? {}\n\n const { fragment, callData } = useCallData(methodName, contractInterface, callInputs)\n\n // Create call objects\n const chainToCalls = useMemo(() => {\n if (!callData || !chainToAddresses) return {}\n return getChainIds(chainToAddresses).reduce((result, chainId) => {\n const addresses = chainToAddresses[chainId]\n const calls = addresses.map((address) => {\n if (!address) return undefined\n return { address, callData, gasRequired }\n })\n result[chainId] = calls\n return result\n }, {} as Record>)\n }, [chainToAddresses, callData, gasRequired])\n\n // Subscribe to call data\n const chainIdToResults = useMultichainCallsDataSubscription(context, chainToCalls, options as ListenerOptions)\n\n // TODO(WEB-2097): Multichain states are not referentially stable, because they cannot use the\n // same codepath (eg useCallStates).\n return useMemo(() => {\n return getChainIds(chainIdToResults).reduce((combinedResults, chainId) => {\n const latestBlockNumber = chainToBlockNumber?.[chainId]\n const results = chainIdToResults[chainId]\n combinedResults[chainId] = results.map((result) =>\n toCallState(result, contractInterface, fragment, latestBlockNumber)\n )\n return combinedResults\n }, {} as Record)\n }, [fragment, contractInterface, chainIdToResults, chainToBlockNumber])\n}\n\n// Similar to useSingleCallResult but instead of one contract on one chain,\n// this is for querying a contract on multiple chains\nexport function useMultiChainSingleContractSingleData(\n context: MulticallContext,\n chainToBlockNumber: Record