@gitmyabi/multicall 1.0.0

package/contracts/Multicall3_json.d.ts

@@ -0,0 +1,696 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * Multicall3.Call struct type
+ */
+export type Multicall3_Call = {
+    target: `0x${string}`;
+    callData: `0x${string}`;
+};
+/**
+ * Multicall3.Call3 struct type
+ */
+export type Multicall3_Call3 = {
+    target: `0x${string}`;
+    allowFailure: boolean;
+    callData: `0x${string}`;
+};
+/**
+ * Multicall3.Result struct type
+ */
+export type Multicall3_Result = {
+    success: boolean;
+    returnData: `0x${string}`;
+};
+/**
+ * Multicall3.Call3Value struct type
+ */
+export type Multicall3_Call3Value = {
+    target: `0x${string}`;
+    allowFailure: boolean;
+    value: bigint;
+    callData: `0x${string}`;
+};
+/**
+ * Multicall3_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const Multicall3_jsonAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Call[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "aggregate";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "blockNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "returnData";
+        readonly type: "bytes[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "allowFailure";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Call3[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "aggregate3";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "returnData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Result[]";
+        readonly name: "returnData";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "allowFailure";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Call3Value[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "aggregate3Value";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "returnData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Result[]";
+        readonly name: "returnData";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Call[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "blockAndAggregate";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "blockNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "blockHash";
+        readonly type: "bytes32";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "returnData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Result[]";
+        readonly name: "returnData";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getBasefee";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "basefee";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "blockNumber";
+        readonly type: "uint256";
+    }];
+    readonly name: "getBlockHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "blockHash";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getBlockNumber";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "blockNumber";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getChainId";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "chainid";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getCurrentBlockCoinbase";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "coinbase";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getCurrentBlockDifficulty";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "difficulty";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getCurrentBlockGasLimit";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "gaslimit";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    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 name: "getLastBlockHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "blockHash";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "requireSuccess";
+        readonly type: "bool";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Call[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "tryAggregate";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "returnData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Result[]";
+        readonly name: "returnData";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "requireSuccess";
+        readonly type: "bool";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "callData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Call[]";
+        readonly name: "calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "tryBlockAndAggregate";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "blockNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "blockHash";
+        readonly type: "bytes32";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bool";
+            readonly name: "success";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "returnData";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Multicall3.Result[]";
+        readonly name: "returnData";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+/**
+ * Type-safe ABI for Multicall3_json
+ */
+export type Multicall3_jsonAbi = typeof Multicall3_jsonAbi;
+/**
+ * Contract instance type for Multicall3_json
+ */
+export type Multicall3_jsonContract = any;
+/**
+ * Multicall3_json Contract Class
+ *
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ * import { Multicall3_json } from 'Multicall3_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new Multicall3_json('0x...', { publicClient, walletClient });
+ *
+ * // Read functions
+ * const result = await contract.balanceOf('0x...');
+ *
+ * // Write functions
+ * const hash = await contract.transfer('0x...', 1000n);
+ *
+ * // Simulate transactions (dry-run)
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
+ * console.log('Gas estimate:', simulation.request.gas);
+ *
+ * // Watch events
+ * const unwatch = contract.watch.Transfer((event) => {
+ *   console.log('Transfer event:', event);
+ * });
+ * ```
+ */
+export declare class Multicall3_json {
+    private contract;
+    private contractAddress;
+    private publicClient;
+    constructor(address: Address, clients: {
+        publicClient: PublicClient;
+        walletClient?: WalletClient;
+    });
+    /**
+     * Get the contract address
+     */
+    get address(): Address;
+    /**
+     * Get the underlying viem contract instance
+     */
+    getContract(): Multicall3_jsonContract;
+    /**
+     * getBasefee
+     * view
+     */
+    getBasefee(): Promise<bigint>;
+    /**
+     * getBlockHash
+     * view
+     */
+    getBlockHash(blockNumber: bigint): Promise<`0x${string}`>;
+    /**
+     * getBlockNumber
+     * view
+     */
+    getBlockNumber(): Promise<bigint>;
+    /**
+     * getChainId
+     * view
+     */
+    getChainId(): Promise<bigint>;
+    /**
+     * getCurrentBlockCoinbase
+     * view
+     */
+    getCurrentBlockCoinbase(): Promise<`0x${string}`>;
+    /**
+     * getCurrentBlockDifficulty
+     * view
+     */
+    getCurrentBlockDifficulty(): Promise<bigint>;
+    /**
+     * getCurrentBlockGasLimit
+     * view
+     */
+    getCurrentBlockGasLimit(): Promise<bigint>;
+    /**
+     * getCurrentBlockTimestamp
+     * view
+     */
+    getCurrentBlockTimestamp(): Promise<bigint>;
+    /**
+     * getEthBalance
+     * view
+     */
+    getEthBalance(addr: `0x${string}`): Promise<bigint>;
+    /**
+     * getLastBlockHash
+     * view
+     */
+    getLastBlockHash(): Promise<`0x${string}`>;
+    /**
+     * aggregate
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    aggregate(calls: Multicall3_Call[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * aggregate3
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    aggregate3(calls: Multicall3_Call3[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * aggregate3Value
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    aggregate3Value(calls: Multicall3_Call3Value[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * blockAndAggregate
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    blockAndAggregate(calls: Multicall3_Call[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * tryAggregate
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    tryAggregate(requireSuccess: boolean, calls: Multicall3_Call[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * tryBlockAndAggregate
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall3_Call[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * Simulate contract write operations (dry-run without sending transaction)
+     *
+     * @example
+     * const result = await contract.simulate.transfer('0x...', 1000n);
+     * console.log('Gas estimate:', result.request.gas);
+     * console.log('Would succeed:', result.result);
+     */
+    get simulate(): {
+        /**
+         * Simulate aggregate
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        aggregate(calls: Multicall3_Call[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<[bigint, `0x${string}`[]]>;
+        /**
+         * Simulate aggregate3
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        aggregate3(calls: Multicall3_Call3[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<Multicall3_Result[]>;
+        /**
+         * Simulate aggregate3Value
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        aggregate3Value(calls: Multicall3_Call3Value[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<Multicall3_Result[]>;
+        /**
+         * Simulate blockAndAggregate
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        blockAndAggregate(calls: Multicall3_Call[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<[bigint, `0x${string}`, Multicall3_Result[]]>;
+        /**
+         * Simulate tryAggregate
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        tryAggregate(requireSuccess: boolean, calls: Multicall3_Call[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<Multicall3_Result[]>;
+        /**
+         * Simulate tryBlockAndAggregate
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall3_Call[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<[bigint, `0x${string}`, Multicall3_Result[]]>;
+    };
+    /**
+     * Watch contract events
+     *
+     * Note: This contract has no events, so watch returns an empty object.
+     */
+    get watch(): {};
+}