symbiosis-js-sdk 3.7.5 → 3.7.6

package/dist/crosschain/contracts/MetaRouter.d.ts

@@ -0,0 +1,202 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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 MetaRouteStructs {
+    type MetaMintTransactionStruct = {
+        stableBridgingFee: BigNumberish;
+        amount: BigNumberish;
+        crossChainID: BytesLike;
+        externalID: BytesLike;
+        tokenReal: string;
+        chainID: BigNumberish;
+        to: string;
+        swapTokens: string[];
+        secondDexRouter: string;
+        secondSwapCalldata: BytesLike;
+        finalReceiveSide: string;
+        finalCalldata: BytesLike;
+        finalOffset: BigNumberish;
+    };
+    type MetaMintTransactionStructOutput = [
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        string,
+        BigNumber,
+        string,
+        string[],
+        string,
+        string,
+        string,
+        string,
+        BigNumber
+    ] & {
+        stableBridgingFee: BigNumber;
+        amount: BigNumber;
+        crossChainID: string;
+        externalID: string;
+        tokenReal: string;
+        chainID: BigNumber;
+        to: string;
+        swapTokens: string[];
+        secondDexRouter: string;
+        secondSwapCalldata: string;
+        finalReceiveSide: string;
+        finalCalldata: string;
+        finalOffset: BigNumber;
+    };
+    type MetaRouteTransactionStruct = {
+        firstSwapCalldata: BytesLike;
+        secondSwapCalldata: BytesLike;
+        approvedTokens: string[];
+        firstDexRouter: string;
+        secondDexRouter: string;
+        amount: BigNumberish;
+        nativeIn: boolean;
+        relayRecipient: string;
+        otherSideCalldata: BytesLike;
+    };
+    type MetaRouteTransactionStructOutput = [
+        string,
+        string,
+        string[],
+        string,
+        string,
+        BigNumber,
+        boolean,
+        string,
+        string
+    ] & {
+        firstSwapCalldata: string;
+        secondSwapCalldata: string;
+        approvedTokens: string[];
+        firstDexRouter: string;
+        secondDexRouter: string;
+        amount: BigNumber;
+        nativeIn: boolean;
+        relayRecipient: string;
+        otherSideCalldata: string;
+    };
+}
+export interface MetaRouterInterface extends utils.Interface {
+    functions: {
+        "externalCall(address,uint256,address,bytes,uint256,address)": FunctionFragment;
+        "metaMintSwap((uint256,uint256,bytes32,bytes32,address,uint256,address,address[],address,bytes,address,bytes,uint256))": FunctionFragment;
+        "metaRoute((bytes,bytes,address[],address,address,uint256,bool,address,bytes))": FunctionFragment;
+        "metaRouterGateway()": FunctionFragment;
+        "returnSwap(address,uint256,address,bytes,address,address,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "externalCall" | "metaMintSwap" | "metaRoute" | "metaRouterGateway" | "returnSwap"): FunctionFragment;
+    encodeFunctionData(functionFragment: "externalCall", values: [string, BigNumberish, string, BytesLike, BigNumberish, string]): string;
+    encodeFunctionData(functionFragment: "metaMintSwap", values: [MetaRouteStructs.MetaMintTransactionStruct]): string;
+    encodeFunctionData(functionFragment: "metaRoute", values: [MetaRouteStructs.MetaRouteTransactionStruct]): string;
+    encodeFunctionData(functionFragment: "metaRouterGateway", values?: undefined): string;
+    encodeFunctionData(functionFragment: "returnSwap", values: [string, BigNumberish, string, BytesLike, string, string, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "externalCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "metaMintSwap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "metaRoute", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "metaRouterGateway", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "returnSwap", data: BytesLike): Result;
+    events: {
+        "TransitTokenSent(address,uint256,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "TransitTokenSent"): EventFragment;
+}
+export interface TransitTokenSentEventObject {
+    to: string;
+    amount: BigNumber;
+    token: string;
+}
+export type TransitTokenSentEvent = TypedEvent<[
+    string,
+    BigNumber,
+    string
+], TransitTokenSentEventObject>;
+export type TransitTokenSentEventFilter = TypedEventFilter<TransitTokenSentEvent>;
+export interface MetaRouter extends BaseContract {
+    contractName: "MetaRouter";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MetaRouterInterface;
+    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: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, _to: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        metaMintSwap(_metaMintTransaction: MetaRouteStructs.MetaMintTransactionStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        metaRoute(_metarouteTransaction: MetaRouteStructs.MetaRouteTransactionStruct, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        metaRouterGateway(overrides?: CallOverrides): Promise<[string]>;
+        returnSwap(_token: string, _amount: BigNumberish, _router: string, _swapCalldata: BytesLike, _burnToken: string, _synthesis: string, _burnCalldata: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, _to: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    metaMintSwap(_metaMintTransaction: MetaRouteStructs.MetaMintTransactionStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    metaRoute(_metarouteTransaction: MetaRouteStructs.MetaRouteTransactionStruct, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    metaRouterGateway(overrides?: CallOverrides): Promise<string>;
+    returnSwap(_token: string, _amount: BigNumberish, _router: string, _swapCalldata: BytesLike, _burnToken: string, _synthesis: string, _burnCalldata: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, _to: string, overrides?: CallOverrides): Promise<void>;
+        metaMintSwap(_metaMintTransaction: MetaRouteStructs.MetaMintTransactionStruct, overrides?: CallOverrides): Promise<void>;
+        metaRoute(_metarouteTransaction: MetaRouteStructs.MetaRouteTransactionStruct, overrides?: CallOverrides): Promise<void>;
+        metaRouterGateway(overrides?: CallOverrides): Promise<string>;
+        returnSwap(_token: string, _amount: BigNumberish, _router: string, _swapCalldata: BytesLike, _burnToken: string, _synthesis: string, _burnCalldata: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "TransitTokenSent(address,uint256,address)"(to?: null, amount?: null, token?: null): TransitTokenSentEventFilter;
+        TransitTokenSent(to?: null, amount?: null, token?: null): TransitTokenSentEventFilter;
+    };
+    estimateGas: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, _to: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        metaMintSwap(_metaMintTransaction: MetaRouteStructs.MetaMintTransactionStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        metaRoute(_metarouteTransaction: MetaRouteStructs.MetaRouteTransactionStruct, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        metaRouterGateway(overrides?: CallOverrides): Promise<BigNumber>;
+        returnSwap(_token: string, _amount: BigNumberish, _router: string, _swapCalldata: BytesLike, _burnToken: string, _synthesis: string, _burnCalldata: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, _to: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        metaMintSwap(_metaMintTransaction: MetaRouteStructs.MetaMintTransactionStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        metaRoute(_metarouteTransaction: MetaRouteStructs.MetaRouteTransactionStruct, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        metaRouterGateway(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        returnSwap(_token: string, _amount: BigNumberish, _router: string, _swapCalldata: BytesLike, _burnToken: string, _synthesis: string, _burnCalldata: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/MetaRouter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MetaRouter.js.map

package/dist/crosschain/contracts/MetaRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetaRouter.js","sourceRoot":"","sources":["../../../src/crosschain/contracts/MetaRouter.ts"],"names":[],"mappings":""}

package/dist/crosschain/contracts/Multicall.d.ts

@@ -0,0 +1,219 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export declare namespace Multicall2 {
+    type CallStruct = {
+        target: string;
+        callData: BytesLike;
+    };
+    type CallStructOutput = [string, string] & {
+        target: string;
+        callData: string;
+    };
+    type ResultStruct = {
+        success: boolean;
+        returnData: BytesLike;
+    };
+    type ResultStructOutput = [boolean, string] & {
+        success: boolean;
+        returnData: string;
+    };
+}
+export interface MulticallInterface extends utils.Interface {
+    functions: {
+        "aggregate((address,bytes)[])": FunctionFragment;
+        "blockAndAggregate((address,bytes)[])": FunctionFragment;
+        "getBlockHash(uint256)": FunctionFragment;
+        "getBlockNumber()": FunctionFragment;
+        "getCurrentBlockCoinbase()": FunctionFragment;
+        "getCurrentBlockDifficulty()": FunctionFragment;
+        "getCurrentBlockGasLimit()": FunctionFragment;
+        "getCurrentBlockTimestamp()": FunctionFragment;
+        "getEthBalance(address)": FunctionFragment;
+        "getLastBlockHash()": FunctionFragment;
+        "tryAggregate(bool,(address,bytes)[])": FunctionFragment;
+        "tryBlockAndAggregate(bool,(address,bytes)[])": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "aggregate" | "blockAndAggregate" | "getBlockHash" | "getBlockNumber" | "getCurrentBlockCoinbase" | "getCurrentBlockDifficulty" | "getCurrentBlockGasLimit" | "getCurrentBlockTimestamp" | "getEthBalance" | "getLastBlockHash" | "tryAggregate" | "tryBlockAndAggregate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "aggregate", values: [Multicall2.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "blockAndAggregate", values: [Multicall2.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "getBlockHash", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getBlockNumber", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockCoinbase", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockDifficulty", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockGasLimit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCurrentBlockTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getEthBalance", values: [string]): string;
+    encodeFunctionData(functionFragment: "getLastBlockHash", values?: undefined): string;
+    encodeFunctionData(functionFragment: "tryAggregate", values: [boolean, Multicall2.CallStruct[]]): string;
+    encodeFunctionData(functionFragment: "tryBlockAndAggregate", values: [boolean, Multicall2.CallStruct[]]): string;
+    decodeFunctionResult(functionFragment: "aggregate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "blockAndAggregate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getBlockHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getBlockNumber", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockCoinbase", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockDifficulty", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockGasLimit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentBlockTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getEthBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastBlockHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tryAggregate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "tryBlockAndAggregate", data: BytesLike): Result;
+    events: {};
+}
+export interface Multicall extends BaseContract {
+    contractName: "Multicall";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MulticallInterface;
+    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: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
+            blockHash: string;
+        }>;
+        getBlockNumber(overrides?: CallOverrides): Promise<[BigNumber] & {
+            blockNumber: BigNumber;
+        }>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<[string] & {
+            coinbase: string;
+        }>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<[BigNumber] & {
+            difficulty: BigNumber;
+        }>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<[BigNumber] & {
+            gaslimit: BigNumber;
+        }>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<[BigNumber] & {
+            timestamp: BigNumber;
+        }>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<[BigNumber] & {
+            balance: BigNumber;
+        }>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<[string] & {
+            blockHash: string;
+        }>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    getBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+    getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<string>;
+    getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<BigNumber>;
+    getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<BigNumber>;
+    getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    getEthBalance(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+    getLastBlockHash(overrides?: CallOverrides): Promise<string>;
+    tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string[]
+        ] & {
+            blockNumber: BigNumber;
+            returnData: string[];
+        }>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string,
+            Multicall2.ResultStructOutput[]
+        ] & {
+            blockNumber: BigNumber;
+            blockHash: string;
+            returnData: Multicall2.ResultStructOutput[];
+        }>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        getBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<string>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<string>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<Multicall2.ResultStructOutput[]>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: CallOverrides): Promise<[
+            BigNumber,
+            string,
+            Multicall2.ResultStructOutput[]
+        ] & {
+            blockNumber: BigNumber;
+            blockHash: string;
+            returnData: Multicall2.ResultStructOutput[];
+        }>;
+    };
+    filters: {};
+    estimateGas: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<BigNumber>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<BigNumber>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        aggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        blockAndAggregate(calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        getBlockHash(blockNumber: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getBlockNumber(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockCoinbase(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockDifficulty(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockGasLimit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getCurrentBlockTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getEthBalance(addr: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getLastBlockHash(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        tryAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        tryBlockAndAggregate(requireSuccess: boolean, calls: Multicall2.CallStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/Multicall.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Multicall.js.map

package/dist/crosschain/contracts/Multicall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Multicall.js","sourceRoot":"","sources":["../../../src/crosschain/contracts/Multicall.ts"],"names":[],"mappings":""}

package/dist/crosschain/contracts/MulticallRouter.d.ts

@@ -0,0 +1,58 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface MulticallRouterInterface extends utils.Interface {
+    functions: {
+        "multicall(uint256,bytes[],address[],address[],uint256[],address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "multicall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "multicall", values: [
+        BigNumberish,
+        BytesLike[],
+        string[],
+        string[],
+        BigNumberish[],
+        string
+    ]): string;
+    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+    events: {};
+}
+export interface MulticallRouter extends BaseContract {
+    contractName: "MulticallRouter";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MulticallRouterInterface;
+    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: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _to: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _to: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _to: string, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _to: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _to: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/MulticallRouter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MulticallRouter.js.map

package/dist/crosschain/contracts/MulticallRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MulticallRouter.js","sourceRoot":"","sources":["../../../src/crosschain/contracts/MulticallRouter.ts"],"names":[],"mappings":""}

package/dist/crosschain/contracts/MulticallRouterV2.d.ts

@@ -0,0 +1,59 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface MulticallRouterV2Interface extends utils.Interface {
+    functions: {
+        "multicall(uint256,bytes[],address[],address[],uint256[],bool[],address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "multicall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "multicall", values: [
+        BigNumberish,
+        BytesLike[],
+        string[],
+        string[],
+        BigNumberish[],
+        boolean[],
+        string
+    ]): string;
+    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+    events: {};
+}
+export interface MulticallRouterV2 extends BaseContract {
+    contractName: "MulticallRouterV2";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MulticallRouterV2Interface;
+    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: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _isNativeIn: boolean[], _to: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _isNativeIn: boolean[], _to: string, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _isNativeIn: boolean[], _to: string, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _isNativeIn: boolean[], _to: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        multicall(_amountIn: BigNumberish, _calldata: BytesLike[], _receiveSides: string[], _path: string[], _offset: BigNumberish[], _isNativeIn: boolean[], _to: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/MulticallRouterV2.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MulticallRouterV2.js.map

package/dist/crosschain/contracts/MulticallRouterV2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MulticallRouterV2.js","sourceRoot":"","sources":["../../../src/crosschain/contracts/MulticallRouterV2.ts"],"names":[],"mappings":""}