@across-protocol/sdk 4.3.165-beta.1 → 4.3.165

package/dist/cjs/src/utils/abi/typechain/TronMulticallHandler.d.ts

@@ -0,0 +1,153 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export declare namespace MulticallHandler {
+    type CallStruct = {
+        target: string;
+        callData: BytesLike;
+        value: BigNumberish;
+    };
+    type CallStructOutput = [string, string, BigNumber] & {
+        target: string;
+        callData: string;
+        value: BigNumber;
+    };
+    type ReplacementStruct = {
+        token: string;
+        offset: BigNumberish;
+    };
+    type ReplacementStructOutput = [string, BigNumber] & {
+        token: string;
+        offset: BigNumber;
+    };
+}
+export interface TronMulticallHandlerInterface extends utils.Interface {
+    functions: {
+        "attemptCalls((address,bytes,uint256)[])": FunctionFragment;
+        "drainLeftoverTokens(address,address)": FunctionFragment;
+        "handleV3AcrossMessage(address,uint256,address,bytes)": FunctionFragment;
+        "makeCallWithBalance(address,bytes,uint256,(address,uint256)[])": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "attemptCalls" | "drainLeftoverTokens" | "handleV3AcrossMessage" | "makeCallWithBalance"): FunctionFragment;
+    encodeFunctionData(functionFragment: "attemptCalls", values: [MulticallHandler.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "drainLeftoverTokens", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "handleV3AcrossMessage", values: [string, BigNumberish, string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "makeCallWithBalance", values: [
+        string,
+        BytesLike,
+        BigNumberish,
+        MulticallHandler.ReplacementStruct[]
+    ]): string;
+    decodeFunctionResult(functionFragment: "attemptCalls", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "drainLeftoverTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "handleV3AcrossMessage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "makeCallWithBalance", data: BytesLike): Result;
+    events: {
+        "CallsFailed((address,bytes,uint256)[],address)": EventFragment;
+        "DrainedTokens(address,address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "CallsFailed"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DrainedTokens"): EventFragment;
+}
+export interface CallsFailedEventObject {
+    calls: MulticallHandler.CallStructOutput[];
+    fallbackRecipient: string;
+}
+export type CallsFailedEvent = TypedEvent<[
+    MulticallHandler.CallStructOutput[],
+    string
+], CallsFailedEventObject>;
+export type CallsFailedEventFilter = TypedEventFilter<CallsFailedEvent>;
+export interface DrainedTokensEventObject {
+    recipient: string;
+    token: string;
+    amount: BigNumber;
+}
+export type DrainedTokensEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber
+], DrainedTokensEventObject>;
+export type DrainedTokensEventFilter = TypedEventFilter<DrainedTokensEvent>;
+export interface TronMulticallHandler extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: TronMulticallHandlerInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        attemptCalls(calls: MulticallHandler.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        drainLeftoverTokens(token: string, destination: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        handleV3AcrossMessage(token: string, arg1: BigNumberish, arg2: string, message: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        makeCallWithBalance(target: string, callData: BytesLike, value: BigNumberish, replacement: MulticallHandler.ReplacementStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    attemptCalls(calls: MulticallHandler.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    drainLeftoverTokens(token: string, destination: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    handleV3AcrossMessage(token: string, arg1: BigNumberish, arg2: string, message: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    makeCallWithBalance(target: string, callData: BytesLike, value: BigNumberish, replacement: MulticallHandler.ReplacementStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        attemptCalls(calls: MulticallHandler.CallStruct[], overrides?: CallOverrides): Promise<void>;
+        drainLeftoverTokens(token: string, destination: string, overrides?: CallOverrides): Promise<void>;
+        handleV3AcrossMessage(token: string, arg1: BigNumberish, arg2: string, message: BytesLike, overrides?: CallOverrides): Promise<void>;
+        makeCallWithBalance(target: string, callData: BytesLike, value: BigNumberish, replacement: MulticallHandler.ReplacementStruct[], overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "CallsFailed((address,bytes,uint256)[],address)"(calls?: null, fallbackRecipient?: string | null): CallsFailedEventFilter;
+        CallsFailed(calls?: null, fallbackRecipient?: string | null): CallsFailedEventFilter;
+        "DrainedTokens(address,address,uint256)"(recipient?: string | null, token?: string | null, amount?: BigNumberish | null): DrainedTokensEventFilter;
+        DrainedTokens(recipient?: string | null, token?: string | null, amount?: BigNumberish | null): DrainedTokensEventFilter;
+    };
+    estimateGas: {
+        attemptCalls(calls: MulticallHandler.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        drainLeftoverTokens(token: string, destination: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        handleV3AcrossMessage(token: string, arg1: BigNumberish, arg2: string, message: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        makeCallWithBalance(target: string, callData: BytesLike, value: BigNumberish, replacement: MulticallHandler.ReplacementStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        attemptCalls(calls: MulticallHandler.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        drainLeftoverTokens(token: string, destination: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        handleV3AcrossMessage(token: string, arg1: BigNumberish, arg2: string, message: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        makeCallWithBalance(target: string, callData: BytesLike, value: BigNumberish, replacement: MulticallHandler.ReplacementStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/cjs/src/utils/abi/typechain/TronMulticallHandler.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TronMulticallHandler.js.map

package/dist/cjs/src/utils/abi/typechain/TronMulticallHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TronMulticallHandler.js","sourceRoot":"","sources":["../../../../../../src/utils/abi/typechain/TronMulticallHandler.ts"],"names":[],"mappings":""}

package/dist/cjs/src/utils/abi/typechain/factories/TronMulticallHandler__factory.d.ts

@@ -0,0 +1,231 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { TronMulticallHandler, TronMulticallHandlerInterface } from "../TronMulticallHandler";
+export declare class TronMulticallHandler__factory {
+    static readonly abi: readonly [{
+        readonly type: "receive";
+        readonly stateMutability: "payable";
+    }, {
+        readonly type: "function";
+        readonly name: "attemptCalls";
+        readonly inputs: readonly [{
+            readonly name: "calls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MulticallHandler.Call[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "value";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "drainLeftoverTokens";
+        readonly inputs: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "destination";
+            readonly type: "address";
+            readonly internalType: "address payable";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "handleV3AcrossMessage";
+        readonly inputs: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "message";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "makeCallWithBalance";
+        readonly inputs: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "replacement";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MulticallHandler.Replacement[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "offset";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "event";
+        readonly name: "CallsFailed";
+        readonly inputs: readonly [{
+            readonly name: "calls";
+            readonly type: "tuple[]";
+            readonly indexed: false;
+            readonly internalType: "struct MulticallHandler.Call[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "value";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "fallbackRecipient";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "DrainedTokens";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "token";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+            readonly indexed: true;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "error";
+        readonly name: "CallReverted";
+        readonly inputs: readonly [{
+            readonly name: "index";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "calls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MulticallHandler.Call[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "value";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }, {
+        readonly type: "error";
+        readonly name: "CalldataTooShort";
+        readonly inputs: readonly [{
+            readonly name: "callDataLength";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "offset";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }, {
+        readonly type: "error";
+        readonly name: "InvalidCall";
+        readonly inputs: readonly [{
+            readonly name: "index";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "calls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MulticallHandler.Call[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "value";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }, {
+        readonly type: "error";
+        readonly name: "NotSelf";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "ReplacementCallFailed";
+        readonly inputs: readonly [{
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly type: "error";
+        readonly name: "TronTransferBalanceMismatch";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "TronTransferCallReverted";
+        readonly inputs: readonly [];
+    }];
+    static createInterface(): TronMulticallHandlerInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): TronMulticallHandler;
+}

package/dist/cjs/src/utils/abi/typechain/factories/TronMulticallHandler__factory.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TronMulticallHandler__factory = void 0;
+const ethers_1 = require("ethers");
+const _abi = [
+    {
+        type: "receive",
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        name: "attemptCalls",
+        inputs: [
+            {
+                name: "calls",
+                type: "tuple[]",
+                internalType: "struct MulticallHandler.Call[]",
+                components: [
+                    {
+                        name: "target",
+                        type: "address",
+                        internalType: "address",
+                    },
+                    {
+                        name: "callData",
+                        type: "bytes",
+                        internalType: "bytes",
+                    },
+                    {
+                        name: "value",
+                        type: "uint256",
+                        internalType: "uint256",
+                    },
+                ],
+            },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "drainLeftoverTokens",
+        inputs: [
+            {
+                name: "token",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "destination",
+                type: "address",
+                internalType: "address payable",
+            },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "handleV3AcrossMessage",
+        inputs: [
+            {
+                name: "token",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "message",
+                type: "bytes",
+                internalType: "bytes",
+            },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "makeCallWithBalance",
+        inputs: [
+            {
+                name: "target",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "callData",
+                type: "bytes",
+                internalType: "bytes",
+            },
+            {
+                name: "value",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "replacement",
+                type: "tuple[]",
+                internalType: "struct MulticallHandler.Replacement[]",
+                components: [
+                    {
+                        name: "token",
+                        type: "address",
+                        internalType: "address",
+                    },
+                    {
+                        name: "offset",
+                        type: "uint256",
+                        internalType: "uint256",
+                    },
+                ],
+            },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "event",
+        name: "CallsFailed",
+        inputs: [
+            {
+                name: "calls",
+                type: "tuple[]",
+                indexed: false,
+                internalType: "struct MulticallHandler.Call[]",
+                components: [
+                    {
+                        name: "target",
+                        type: "address",
+                        internalType: "address",
+                    },
+                    {
+                        name: "callData",
+                        type: "bytes",
+                        internalType: "bytes",
+                    },
+                    {
+                        name: "value",
+                        type: "uint256",
+                        internalType: "uint256",
+                    },
+                ],
+            },
+            {
+                name: "fallbackRecipient",
+                type: "address",
+                indexed: true,
+                internalType: "address",
+            },
+        ],
+        anonymous: false,
+    },
+    {
+        type: "event",
+        name: "DrainedTokens",
+        inputs: [
+            {
+                name: "recipient",
+                type: "address",
+                indexed: true,
+                internalType: "address",
+            },
+            {
+                name: "token",
+                type: "address",
+                indexed: true,
+                internalType: "address",
+            },
+            {
+                name: "amount",
+                type: "uint256",
+                indexed: true,
+                internalType: "uint256",
+            },
+        ],
+        anonymous: false,
+    },
+    {
+        type: "error",
+        name: "CallReverted",
+        inputs: [
+            {
+                name: "index",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "calls",
+                type: "tuple[]",
+                internalType: "struct MulticallHandler.Call[]",
+                components: [
+                    {
+                        name: "target",
+                        type: "address",
+                        internalType: "address",
+                    },
+                    {
+                        name: "callData",
+                        type: "bytes",
+                        internalType: "bytes",
+                    },
+                    {
+                        name: "value",
+                        type: "uint256",
+                        internalType: "uint256",
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "CalldataTooShort",
+        inputs: [
+            {
+                name: "callDataLength",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "offset",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "InvalidCall",
+        inputs: [
+            {
+                name: "index",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "calls",
+                type: "tuple[]",
+                internalType: "struct MulticallHandler.Call[]",
+                components: [
+                    {
+                        name: "target",
+                        type: "address",
+                        internalType: "address",
+                    },
+                    {
+                        name: "callData",
+                        type: "bytes",
+                        internalType: "bytes",
+                    },
+                    {
+                        name: "value",
+                        type: "uint256",
+                        internalType: "uint256",
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "NotSelf",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "ReplacementCallFailed",
+        inputs: [
+            {
+                name: "callData",
+                type: "bytes",
+                internalType: "bytes",
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "TronTransferBalanceMismatch",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "TronTransferCallReverted",
+        inputs: [],
+    },
+];
+class TronMulticallHandler__factory {
+    static abi = _abi;
+    static createInterface() {
+        return new ethers_1.utils.Interface(_abi);
+    }
+    static connect(address, signerOrProvider) {
+        return new ethers_1.Contract(address, _abi, signerOrProvider);
+    }
+}
+exports.TronMulticallHandler__factory = TronMulticallHandler__factory;
+//# sourceMappingURL=TronMulticallHandler__factory.js.map