@across-protocol/sdk 4.3.123 → 4.3.124

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

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

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

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

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

@@ -0,0 +1,288 @@
+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 HubPoolInterface {
+    type PoolRebalanceLeafStruct = {
+        chainId: BigNumberish;
+        bundleLpFees: BigNumberish[];
+        netSendAmounts: BigNumberish[];
+        runningBalances: BigNumberish[];
+        groupIndex: BigNumberish;
+        leafId: BigNumberish;
+        l1Tokens: string[];
+    };
+    type PoolRebalanceLeafStructOutput = [
+        BigNumber,
+        BigNumber[],
+        BigNumber[],
+        BigNumber[],
+        BigNumber,
+        number,
+        string[]
+    ] & {
+        chainId: BigNumber;
+        bundleLpFees: BigNumber[];
+        netSendAmounts: BigNumber[];
+        runningBalances: BigNumber[];
+        groupIndex: BigNumber;
+        leafId: number;
+        l1Tokens: string[];
+    };
+}
+export declare namespace SpokePoolInterface {
+    type RelayerRefundLeafStruct = {
+        amountToReturn: BigNumberish;
+        chainId: BigNumberish;
+        refundAmounts: BigNumberish[];
+        leafId: BigNumberish;
+        l2TokenAddress: string;
+        refundAddresses: string[];
+    };
+    type RelayerRefundLeafStructOutput = [
+        BigNumber,
+        BigNumber,
+        BigNumber[],
+        number,
+        string,
+        string[]
+    ] & {
+        amountToReturn: BigNumber;
+        chainId: BigNumber;
+        refundAmounts: BigNumber[];
+        leafId: number;
+        l2TokenAddress: string;
+        refundAddresses: string[];
+    };
+}
+export declare namespace MockV2SpokePoolInterface {
+    type RelayDataStruct = {
+        depositor: BytesLike;
+        recipient: BytesLike;
+        destinationToken: BytesLike;
+        amount: BigNumberish;
+        originChainId: BigNumberish;
+        destinationChainId: BigNumberish;
+        realizedLpFeePct: BigNumberish;
+        relayerFeePct: BigNumberish;
+        depositId: BigNumberish;
+        message: BytesLike;
+    };
+    type RelayDataStructOutput = [
+        string,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        number,
+        string
+    ] & {
+        depositor: string;
+        recipient: string;
+        destinationToken: string;
+        amount: BigNumber;
+        originChainId: BigNumber;
+        destinationChainId: BigNumber;
+        realizedLpFeePct: BigNumber;
+        relayerFeePct: BigNumber;
+        depositId: number;
+        message: string;
+    };
+    type SlowFillStruct = {
+        relayData: MockV2SpokePoolInterface.RelayDataStruct;
+        payoutAdjustmentPct: BigNumberish;
+    };
+    type SlowFillStructOutput = [
+        MockV2SpokePoolInterface.RelayDataStructOutput,
+        BigNumber
+    ] & {
+        relayData: MockV2SpokePoolInterface.RelayDataStructOutput;
+        payoutAdjustmentPct: BigNumber;
+    };
+}
+export declare namespace V3SpokePoolInterface {
+    type V3RelayDataStruct = {
+        depositor: BytesLike;
+        recipient: BytesLike;
+        exclusiveRelayer: BytesLike;
+        inputToken: BytesLike;
+        outputToken: BytesLike;
+        inputAmount: BigNumberish;
+        outputAmount: BigNumberish;
+        originChainId: BigNumberish;
+        depositId: BigNumberish;
+        fillDeadline: BigNumberish;
+        exclusivityDeadline: BigNumberish;
+        message: BytesLike;
+    };
+    type V3RelayDataStructOutput = [
+        string,
+        string,
+        string,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        number,
+        number,
+        string
+    ] & {
+        depositor: string;
+        recipient: string;
+        exclusiveRelayer: string;
+        inputToken: string;
+        outputToken: string;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
+        originChainId: BigNumber;
+        depositId: BigNumber;
+        fillDeadline: number;
+        exclusivityDeadline: number;
+        message: string;
+    };
+    type V3SlowFillStruct = {
+        relayData: V3SpokePoolInterface.V3RelayDataStruct;
+        chainId: BigNumberish;
+        updatedOutputAmount: BigNumberish;
+    };
+    type V3SlowFillStructOutput = [
+        V3SpokePoolInterface.V3RelayDataStructOutput,
+        BigNumber,
+        BigNumber
+    ] & {
+        relayData: V3SpokePoolInterface.V3RelayDataStructOutput;
+        chainId: BigNumber;
+        updatedOutputAmount: BigNumber;
+    };
+}
+export interface MerkleLibTestInterface extends utils.Interface {
+    functions: {
+        "claimedBitMap(uint256)": FunctionFragment;
+        "claimedBitMap1D()": FunctionFragment;
+        "isClaimed(uint256)": FunctionFragment;
+        "isClaimed1D(uint8)": FunctionFragment;
+        "setClaimed(uint256)": FunctionFragment;
+        "setClaimed1D(uint8)": FunctionFragment;
+        "verifyPoolRebalance(bytes32,(uint256,uint256[],int256[],int256[],uint256,uint8,address[]),bytes32[])": FunctionFragment;
+        "verifyRelayerRefund(bytes32,(uint256,uint256,uint256[],uint32,address,address[]),bytes32[])": FunctionFragment;
+        "verifySlowRelayFulfillment(bytes32,((bytes32,bytes32,bytes32,uint256,uint256,uint256,int64,int64,uint32,bytes),int256),bytes32[])": FunctionFragment;
+        "verifyV3SlowRelayFulfillment(bytes32,((bytes32,bytes32,bytes32,bytes32,bytes32,uint256,uint256,uint256,uint256,uint32,uint32,bytes),uint256,uint256),bytes32[])": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "claimedBitMap" | "claimedBitMap1D" | "isClaimed" | "isClaimed1D" | "setClaimed" | "setClaimed1D" | "verifyPoolRebalance" | "verifyRelayerRefund" | "verifySlowRelayFulfillment" | "verifyV3SlowRelayFulfillment"): FunctionFragment;
+    encodeFunctionData(functionFragment: "claimedBitMap", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "claimedBitMap1D", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isClaimed", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "isClaimed1D", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setClaimed", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setClaimed1D", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "verifyPoolRebalance", values: [BytesLike, HubPoolInterface.PoolRebalanceLeafStruct, BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "verifyRelayerRefund", values: [BytesLike, SpokePoolInterface.RelayerRefundLeafStruct, BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "verifySlowRelayFulfillment", values: [BytesLike, MockV2SpokePoolInterface.SlowFillStruct, BytesLike[]]): string;
+    encodeFunctionData(functionFragment: "verifyV3SlowRelayFulfillment", values: [BytesLike, V3SpokePoolInterface.V3SlowFillStruct, BytesLike[]]): string;
+    decodeFunctionResult(functionFragment: "claimedBitMap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimedBitMap1D", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isClaimed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isClaimed1D", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setClaimed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setClaimed1D", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifyPoolRebalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifyRelayerRefund", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifySlowRelayFulfillment", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifyV3SlowRelayFulfillment", data: BytesLike): Result;
+    events: {};
+}
+export interface MerkleLibTest extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MerkleLibTestInterface;
+    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: {
+        claimedBitMap(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        claimedBitMap1D(overrides?: CallOverrides): Promise<[BigNumber]>;
+        isClaimed(index: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
+        isClaimed1D(index: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
+        setClaimed(index: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setClaimed1D(index: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        verifyPoolRebalance(root: BytesLike, rebalance: HubPoolInterface.PoolRebalanceLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<[boolean]>;
+        verifyRelayerRefund(root: BytesLike, refund: SpokePoolInterface.RelayerRefundLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<[boolean]>;
+        verifySlowRelayFulfillment(root: BytesLike, slowFill: MockV2SpokePoolInterface.SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<[boolean]>;
+        verifyV3SlowRelayFulfillment(root: BytesLike, slowFill: V3SpokePoolInterface.V3SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    claimedBitMap(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    claimedBitMap1D(overrides?: CallOverrides): Promise<BigNumber>;
+    isClaimed(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+    isClaimed1D(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+    setClaimed(index: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setClaimed1D(index: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    verifyPoolRebalance(root: BytesLike, rebalance: HubPoolInterface.PoolRebalanceLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+    verifyRelayerRefund(root: BytesLike, refund: SpokePoolInterface.RelayerRefundLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+    verifySlowRelayFulfillment(root: BytesLike, slowFill: MockV2SpokePoolInterface.SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+    verifyV3SlowRelayFulfillment(root: BytesLike, slowFill: V3SpokePoolInterface.V3SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        claimedBitMap(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        claimedBitMap1D(overrides?: CallOverrides): Promise<BigNumber>;
+        isClaimed(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        isClaimed1D(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        setClaimed(index: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        setClaimed1D(index: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        verifyPoolRebalance(root: BytesLike, rebalance: HubPoolInterface.PoolRebalanceLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+        verifyRelayerRefund(root: BytesLike, refund: SpokePoolInterface.RelayerRefundLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+        verifySlowRelayFulfillment(root: BytesLike, slowFill: MockV2SpokePoolInterface.SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+        verifyV3SlowRelayFulfillment(root: BytesLike, slowFill: V3SpokePoolInterface.V3SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<boolean>;
+    };
+    filters: {};
+    estimateGas: {
+        claimedBitMap(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        claimedBitMap1D(overrides?: CallOverrides): Promise<BigNumber>;
+        isClaimed(index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        isClaimed1D(index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        setClaimed(index: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setClaimed1D(index: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        verifyPoolRebalance(root: BytesLike, rebalance: HubPoolInterface.PoolRebalanceLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>;
+        verifyRelayerRefund(root: BytesLike, refund: SpokePoolInterface.RelayerRefundLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>;
+        verifySlowRelayFulfillment(root: BytesLike, slowFill: MockV2SpokePoolInterface.SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>;
+        verifyV3SlowRelayFulfillment(root: BytesLike, slowFill: V3SpokePoolInterface.V3SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        claimedBitMap(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        claimedBitMap1D(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isClaimed(index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isClaimed1D(index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setClaimed(index: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setClaimed1D(index: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        verifyPoolRebalance(root: BytesLike, rebalance: HubPoolInterface.PoolRebalanceLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        verifyRelayerRefund(root: BytesLike, refund: SpokePoolInterface.RelayerRefundLeafStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        verifySlowRelayFulfillment(root: BytesLike, slowFill: MockV2SpokePoolInterface.SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        verifyV3SlowRelayFulfillment(root: BytesLike, slowFill: V3SpokePoolInterface.V3SlowFillStruct, proof: BytesLike[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

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

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

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

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