@across-protocol/sdk 4.3.121 → 4.3.122

package/dist/esm/src/utils/abi/typechain/IBlast.d.ts

@@ -0,0 +1,98 @@
+import type { BaseContract, BigNumber, 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 IBlastInterface extends utils.Interface {
+    functions: {
+        "claimAllYield(address,address)": FunctionFragment;
+        "claimMaxGas(address,address)": FunctionFragment;
+        "configureClaimableGas()": FunctionFragment;
+        "configureClaimableYield()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "claimAllYield" | "claimMaxGas" | "configureClaimableGas" | "configureClaimableYield"): FunctionFragment;
+    encodeFunctionData(functionFragment: "claimAllYield", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "claimMaxGas", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "configureClaimableGas", values?: undefined): string;
+    encodeFunctionData(functionFragment: "configureClaimableYield", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "claimAllYield", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimMaxGas", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "configureClaimableGas", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "configureClaimableYield", data: BytesLike): Result;
+    events: {};
+}
+export interface IBlast extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IBlastInterface;
+    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: {
+        claimAllYield(contractAddress: string, recipientOfYield: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        claimMaxGas(contractAddress: string, recipientOfGas: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        configureClaimableGas(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        configureClaimableYield(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    claimAllYield(contractAddress: string, recipientOfYield: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    claimMaxGas(contractAddress: string, recipientOfGas: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    configureClaimableGas(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    configureClaimableYield(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        claimAllYield(contractAddress: string, recipientOfYield: string, overrides?: CallOverrides): Promise<BigNumber>;
+        claimMaxGas(contractAddress: string, recipientOfGas: string, overrides?: CallOverrides): Promise<BigNumber>;
+        configureClaimableGas(overrides?: CallOverrides): Promise<void>;
+        configureClaimableYield(overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        claimAllYield(contractAddress: string, recipientOfYield: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        claimMaxGas(contractAddress: string, recipientOfGas: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        configureClaimableGas(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        configureClaimableYield(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        claimAllYield(contractAddress: string, recipientOfYield: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        claimMaxGas(contractAddress: string, recipientOfGas: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        configureClaimableGas(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        configureClaimableYield(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IBlast.js

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

package/dist/esm/src/utils/abi/typechain/IBlast.js.map

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

package/dist/esm/src/utils/abi/typechain/IBridgeMessageReceiver.d.ts

@@ -0,0 +1,50 @@
+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 IBridgeMessageReceiverInterface extends utils.Interface {
+    functions: {
+        "onMessageReceived(address,uint32,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "onMessageReceived"): FunctionFragment;
+    encodeFunctionData(functionFragment: "onMessageReceived", values: [string, BigNumberish, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "onMessageReceived", data: BytesLike): Result;
+    events: {};
+}
+export interface IBridgeMessageReceiver extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IBridgeMessageReceiverInterface;
+    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: {
+        onMessageReceived(originAddress: string, originNetwork: BigNumberish, data: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    onMessageReceived(originAddress: string, originNetwork: BigNumberish, data: BytesLike, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        onMessageReceived(originAddress: string, originNetwork: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        onMessageReceived(originAddress: string, originNetwork: BigNumberish, data: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        onMessageReceived(originAddress: string, originNetwork: BigNumberish, data: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IBridgeMessageReceiver.js

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

package/dist/esm/src/utils/abi/typechain/IBridgeMessageReceiver.js.map

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

package/dist/esm/src/utils/abi/typechain/IDestinationSettler.d.ts

@@ -0,0 +1,50 @@
+import type { BaseContract, BigNumber, 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 IDestinationSettlerInterface extends utils.Interface {
+    functions: {
+        "fill(bytes32,bytes,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "fill"): FunctionFragment;
+    encodeFunctionData(functionFragment: "fill", values: [BytesLike, BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "fill", data: BytesLike): Result;
+    events: {};
+}
+export interface IDestinationSettler extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IDestinationSettlerInterface;
+    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: {
+        fill(orderId: BytesLike, originData: BytesLike, fillerData: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    fill(orderId: BytesLike, originData: BytesLike, fillerData: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        fill(orderId: BytesLike, originData: BytesLike, fillerData: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        fill(orderId: BytesLike, originData: BytesLike, fillerData: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        fill(orderId: BytesLike, originData: BytesLike, fillerData: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IDestinationSettler.js

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

package/dist/esm/src/utils/abi/typechain/IDestinationSettler.js.map

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

package/dist/esm/src/utils/abi/typechain/IERC1822Proxiable.d.ts

@@ -0,0 +1,42 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, 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 IERC1822ProxiableInterface extends utils.Interface {
+    functions: {
+        "proxiableUUID()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "proxiableUUID"): FunctionFragment;
+    encodeFunctionData(functionFragment: "proxiableUUID", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "proxiableUUID", data: BytesLike): Result;
+    events: {};
+}
+export interface IERC1822Proxiable extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IERC1822ProxiableInterface;
+    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: {
+        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
+    };
+    proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IERC1822Proxiable.js

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

package/dist/esm/src/utils/abi/typechain/IERC1822Proxiable.js.map

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

package/dist/esm/src/utils/abi/typechain/IERC1822ProxiableUpgradeable.d.ts

@@ -0,0 +1,42 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, 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 IERC1822ProxiableUpgradeableInterface extends utils.Interface {
+    functions: {
+        "proxiableUUID()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "proxiableUUID"): FunctionFragment;
+    encodeFunctionData(functionFragment: "proxiableUUID", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "proxiableUUID", data: BytesLike): Result;
+    events: {};
+}
+export interface IERC1822ProxiableUpgradeable extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IERC1822ProxiableUpgradeableInterface;
+    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: {
+        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
+    };
+    proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IERC1822ProxiableUpgradeable.js

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

package/dist/esm/src/utils/abi/typechain/IERC1822ProxiableUpgradeable.js.map

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

package/dist/esm/src/utils/abi/typechain/IERC20Rebasing.d.ts

@@ -0,0 +1,74 @@
+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 IERC20RebasingInterface extends utils.Interface {
+    functions: {
+        "claim(address,uint256)": FunctionFragment;
+        "configure(uint8)": FunctionFragment;
+        "getClaimableAmount(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "claim" | "configure" | "getClaimableAmount"): FunctionFragment;
+    encodeFunctionData(functionFragment: "claim", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "configure", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getClaimableAmount", values: [string]): string;
+    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "configure", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getClaimableAmount", data: BytesLike): Result;
+    events: {};
+}
+export interface IERC20Rebasing extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IERC20RebasingInterface;
+    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: {
+        claim(recipient: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        configure(yieldMode: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        getClaimableAmount(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    claim(recipient: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    configure(yieldMode: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    getClaimableAmount(account: string, overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        claim(recipient: string, amount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        configure(yieldMode: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getClaimableAmount(account: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {};
+    estimateGas: {
+        claim(recipient: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        configure(yieldMode: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        getClaimableAmount(account: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        claim(recipient: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        configure(yieldMode: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        getClaimableAmount(account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IERC20Rebasing.js

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

package/dist/esm/src/utils/abi/typechain/IERC20Rebasing.js.map

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

package/dist/esm/src/utils/abi/typechain/IEndpoint.d.ts

@@ -0,0 +1,42 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, 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 IEndpointInterface extends utils.Interface {
+    functions: {
+        "eid()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "eid"): FunctionFragment;
+    encodeFunctionData(functionFragment: "eid", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "eid", data: BytesLike): Result;
+    events: {};
+}
+export interface IEndpoint extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IEndpointInterface;
+    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: {
+        eid(overrides?: CallOverrides): Promise<[number]>;
+    };
+    eid(overrides?: CallOverrides): Promise<number>;
+    callStatic: {
+        eid(overrides?: CallOverrides): Promise<number>;
+    };
+    filters: {};
+    estimateGas: {
+        eid(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        eid(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IEndpoint.js

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

package/dist/esm/src/utils/abi/typechain/IEndpoint.js.map

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

package/dist/esm/src/utils/abi/typechain/IFxMessageProcessor.d.ts

@@ -0,0 +1,50 @@
+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 IFxMessageProcessorInterface extends utils.Interface {
+    functions: {
+        "processMessageFromRoot(uint256,address,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "processMessageFromRoot"): FunctionFragment;
+    encodeFunctionData(functionFragment: "processMessageFromRoot", values: [BigNumberish, string, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "processMessageFromRoot", data: BytesLike): Result;
+    events: {};
+}
+export interface IFxMessageProcessor extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IFxMessageProcessorInterface;
+    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: {
+        processMessageFromRoot(stateId: BigNumberish, rootMessageSender: string, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    processMessageFromRoot(stateId: BigNumberish, rootMessageSender: string, data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        processMessageFromRoot(stateId: BigNumberish, rootMessageSender: string, data: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        processMessageFromRoot(stateId: BigNumberish, rootMessageSender: string, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        processMessageFromRoot(stateId: BigNumberish, rootMessageSender: string, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IFxMessageProcessor.js

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

package/dist/esm/src/utils/abi/typechain/IFxMessageProcessor.js.map

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

package/dist/esm/src/utils/abi/typechain/IFxStateSender.d.ts

@@ -0,0 +1,50 @@
+import type { BaseContract, BigNumber, 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 IFxStateSenderInterface extends utils.Interface {
+    functions: {
+        "sendMessageToChild(address,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "sendMessageToChild"): FunctionFragment;
+    encodeFunctionData(functionFragment: "sendMessageToChild", values: [string, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "sendMessageToChild", data: BytesLike): Result;
+    events: {};
+}
+export interface IFxStateSender extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IFxStateSenderInterface;
+    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: {
+        sendMessageToChild(_receiver: string, _data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    sendMessageToChild(_receiver: string, _data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        sendMessageToChild(_receiver: string, _data: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        sendMessageToChild(_receiver: string, _data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        sendMessageToChild(_receiver: string, _data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/esm/src/utils/abi/typechain/IFxStateSender.js

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

package/dist/esm/src/utils/abi/typechain/IFxStateSender.js.map

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

package/dist/esm/src/utils/abi/typechain/IHubPool.d.ts

@@ -0,0 +1,70 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, 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 HubPoolInterface {
+    type RootBundleStruct = {
+        poolRebalanceRoot: BytesLike;
+        relayerRefundRoot: BytesLike;
+        slowRelayRoot: BytesLike;
+        claimedBitMap: BigNumberish;
+        proposer: string;
+        unclaimedPoolRebalanceLeafCount: BigNumberish;
+        challengePeriodEndTimestamp: BigNumberish;
+    };
+    type RootBundleStructOutput = [
+        string,
+        string,
+        string,
+        BigNumber,
+        string,
+        number,
+        number
+    ] & {
+        poolRebalanceRoot: string;
+        relayerRefundRoot: string;
+        slowRelayRoot: string;
+        claimedBitMap: BigNumber;
+        proposer: string;
+        unclaimedPoolRebalanceLeafCount: number;
+        challengePeriodEndTimestamp: number;
+    };
+}
+export interface IHubPoolInterface extends utils.Interface {
+    functions: {
+        "rootBundleProposal()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "rootBundleProposal"): FunctionFragment;
+    encodeFunctionData(functionFragment: "rootBundleProposal", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "rootBundleProposal", data: BytesLike): Result;
+    events: {};
+}
+export interface IHubPool extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IHubPoolInterface;
+    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: {
+        rootBundleProposal(overrides?: CallOverrides): Promise<[HubPoolInterface.RootBundleStructOutput]>;
+    };
+    rootBundleProposal(overrides?: CallOverrides): Promise<HubPoolInterface.RootBundleStructOutput>;
+    callStatic: {
+        rootBundleProposal(overrides?: CallOverrides): Promise<HubPoolInterface.RootBundleStructOutput>;
+    };
+    filters: {};
+    estimateGas: {
+        rootBundleProposal(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        rootBundleProposal(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}