symbiosis-js-sdk 3.7.5 → 3.7.6

package/dist/crosschain/contracts/Synthesis.js

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

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

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

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

@@ -0,0 +1,256 @@
+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 THORChain_Router {
+    type CoinStruct = {
+        asset: string;
+        amount: BigNumberish;
+    };
+    type CoinStructOutput = [string, BigNumber] & {
+        asset: string;
+        amount: BigNumber;
+    };
+}
+export interface ThorRouterInterface extends utils.Interface {
+    functions: {
+        "RUNE()": FunctionFragment;
+        "deposit(address,address,uint256,string)": FunctionFragment;
+        "depositWithExpiry(address,address,uint256,string,uint256)": FunctionFragment;
+        "returnVaultAssets(address,address,(address,uint256)[],string)": FunctionFragment;
+        "transferAllowance(address,address,address,uint256,string)": FunctionFragment;
+        "transferOut(address,address,uint256,string)": FunctionFragment;
+        "transferOutAndCall(address,address,address,uint256,string)": FunctionFragment;
+        "vaultAllowance(address,address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "RUNE" | "deposit" | "depositWithExpiry" | "returnVaultAssets" | "transferAllowance" | "transferOut" | "transferOutAndCall" | "vaultAllowance"): FunctionFragment;
+    encodeFunctionData(functionFragment: "RUNE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [string, string, BigNumberish, string]): string;
+    encodeFunctionData(functionFragment: "depositWithExpiry", values: [string, string, BigNumberish, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "returnVaultAssets", values: [string, string, THORChain_Router.CoinStruct[], string]): string;
+    encodeFunctionData(functionFragment: "transferAllowance", values: [string, string, string, BigNumberish, string]): string;
+    encodeFunctionData(functionFragment: "transferOut", values: [string, string, BigNumberish, string]): string;
+    encodeFunctionData(functionFragment: "transferOutAndCall", values: [string, string, string, BigNumberish, string]): string;
+    encodeFunctionData(functionFragment: "vaultAllowance", values: [string, string]): string;
+    decodeFunctionResult(functionFragment: "RUNE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositWithExpiry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "returnVaultAssets", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferAllowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOut", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOutAndCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "vaultAllowance", data: BytesLike): Result;
+    events: {
+        "Deposit(address,address,uint256,string)": EventFragment;
+        "TransferAllowance(address,address,address,uint256,string)": EventFragment;
+        "TransferOut(address,address,address,uint256,string)": EventFragment;
+        "TransferOutAndCall(address,address,uint256,address,address,uint256,string)": EventFragment;
+        "VaultTransfer(address,address,(address,uint256)[],string)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TransferAllowance"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TransferOut"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TransferOutAndCall"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "VaultTransfer"): EventFragment;
+}
+export interface DepositEventObject {
+    to: string;
+    asset: string;
+    amount: BigNumber;
+    memo: string;
+}
+export type DepositEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    string
+], DepositEventObject>;
+export type DepositEventFilter = TypedEventFilter<DepositEvent>;
+export interface TransferAllowanceEventObject {
+    oldVault: string;
+    newVault: string;
+    asset: string;
+    amount: BigNumber;
+    memo: string;
+}
+export type TransferAllowanceEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    string
+], TransferAllowanceEventObject>;
+export type TransferAllowanceEventFilter = TypedEventFilter<TransferAllowanceEvent>;
+export interface TransferOutEventObject {
+    vault: string;
+    to: string;
+    asset: string;
+    amount: BigNumber;
+    memo: string;
+}
+export type TransferOutEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    string
+], TransferOutEventObject>;
+export type TransferOutEventFilter = TypedEventFilter<TransferOutEvent>;
+export interface TransferOutAndCallEventObject {
+    vault: string;
+    target: string;
+    amount: BigNumber;
+    finalAsset: string;
+    to: string;
+    amountOutMin: BigNumber;
+    memo: string;
+}
+export type TransferOutAndCallEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    string,
+    string,
+    BigNumber,
+    string
+], TransferOutAndCallEventObject>;
+export type TransferOutAndCallEventFilter = TypedEventFilter<TransferOutAndCallEvent>;
+export interface VaultTransferEventObject {
+    oldVault: string;
+    newVault: string;
+    coins: THORChain_Router.CoinStructOutput[];
+    memo: string;
+}
+export type VaultTransferEvent = TypedEvent<[
+    string,
+    string,
+    THORChain_Router.CoinStructOutput[],
+    string
+], VaultTransferEventObject>;
+export type VaultTransferEventFilter = TypedEventFilter<VaultTransferEvent>;
+export interface ThorRouter extends BaseContract {
+    contractName: "ThorRouter";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ThorRouterInterface;
+    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: {
+        RUNE(overrides?: CallOverrides): Promise<[string]>;
+        deposit(vault: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        depositWithExpiry(vault: string, asset: string, amount: BigNumberish, memo: string, expiration: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        returnVaultAssets(router: string, asgard: string, coins: THORChain_Router.CoinStruct[], memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferAllowance(router: string, newVault: string, asset: string, amount: BigNumberish, memo: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferOut(to: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferOutAndCall(aggregator: string, finalToken: string, to: string, amountOutMin: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        vaultAllowance(vault: string, token: string, overrides?: CallOverrides): Promise<[BigNumber] & {
+            amount: BigNumber;
+        }>;
+    };
+    RUNE(overrides?: CallOverrides): Promise<string>;
+    deposit(vault: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    depositWithExpiry(vault: string, asset: string, amount: BigNumberish, memo: string, expiration: BigNumberish, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    returnVaultAssets(router: string, asgard: string, coins: THORChain_Router.CoinStruct[], memo: string, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    transferAllowance(router: string, newVault: string, asset: string, amount: BigNumberish, memo: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    transferOut(to: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    transferOutAndCall(aggregator: string, finalToken: string, to: string, amountOutMin: BigNumberish, memo: string, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    vaultAllowance(vault: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        RUNE(overrides?: CallOverrides): Promise<string>;
+        deposit(vault: string, asset: string, amount: BigNumberish, memo: string, overrides?: CallOverrides): Promise<void>;
+        depositWithExpiry(vault: string, asset: string, amount: BigNumberish, memo: string, expiration: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        returnVaultAssets(router: string, asgard: string, coins: THORChain_Router.CoinStruct[], memo: string, overrides?: CallOverrides): Promise<void>;
+        transferAllowance(router: string, newVault: string, asset: string, amount: BigNumberish, memo: string, overrides?: CallOverrides): Promise<void>;
+        transferOut(to: string, asset: string, amount: BigNumberish, memo: string, overrides?: CallOverrides): Promise<void>;
+        transferOutAndCall(aggregator: string, finalToken: string, to: string, amountOutMin: BigNumberish, memo: string, overrides?: CallOverrides): Promise<void>;
+        vaultAllowance(vault: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "Deposit(address,address,uint256,string)"(to?: string | null, asset?: string | null, amount?: null, memo?: null): DepositEventFilter;
+        Deposit(to?: string | null, asset?: string | null, amount?: null, memo?: null): DepositEventFilter;
+        "TransferAllowance(address,address,address,uint256,string)"(oldVault?: string | null, newVault?: string | null, asset?: null, amount?: null, memo?: null): TransferAllowanceEventFilter;
+        TransferAllowance(oldVault?: string | null, newVault?: string | null, asset?: null, amount?: null, memo?: null): TransferAllowanceEventFilter;
+        "TransferOut(address,address,address,uint256,string)"(vault?: string | null, to?: string | null, asset?: null, amount?: null, memo?: null): TransferOutEventFilter;
+        TransferOut(vault?: string | null, to?: string | null, asset?: null, amount?: null, memo?: null): TransferOutEventFilter;
+        "TransferOutAndCall(address,address,uint256,address,address,uint256,string)"(vault?: string | null, target?: null, amount?: null, finalAsset?: null, to?: null, amountOutMin?: null, memo?: null): TransferOutAndCallEventFilter;
+        TransferOutAndCall(vault?: string | null, target?: null, amount?: null, finalAsset?: null, to?: null, amountOutMin?: null, memo?: null): TransferOutAndCallEventFilter;
+        "VaultTransfer(address,address,(address,uint256)[],string)"(oldVault?: string | null, newVault?: string | null, coins?: null, memo?: null): VaultTransferEventFilter;
+        VaultTransfer(oldVault?: string | null, newVault?: string | null, coins?: null, memo?: null): VaultTransferEventFilter;
+    };
+    estimateGas: {
+        RUNE(overrides?: CallOverrides): Promise<BigNumber>;
+        deposit(vault: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        depositWithExpiry(vault: string, asset: string, amount: BigNumberish, memo: string, expiration: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        returnVaultAssets(router: string, asgard: string, coins: THORChain_Router.CoinStruct[], memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        transferAllowance(router: string, newVault: string, asset: string, amount: BigNumberish, memo: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        transferOut(to: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        transferOutAndCall(aggregator: string, finalToken: string, to: string, amountOutMin: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        vaultAllowance(vault: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        RUNE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        deposit(vault: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        depositWithExpiry(vault: string, asset: string, amount: BigNumberish, memo: string, expiration: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        returnVaultAssets(router: string, asgard: string, coins: THORChain_Router.CoinStruct[], memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferAllowance(router: string, newVault: string, asset: string, amount: BigNumberish, memo: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferOut(to: string, asset: string, amount: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferOutAndCall(aggregator: string, finalToken: string, to: string, amountOutMin: BigNumberish, memo: string, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        vaultAllowance(vault: string, token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/ThorRouter.js

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

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

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

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

@@ -0,0 +1,170 @@
+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 TimedSwapUnlocker {
+    type ConditionStruct = {
+        outToken: string;
+        startMinPrice: BigNumberish;
+        duration: BigNumberish;
+        discount: BigNumberish;
+        target: string;
+        targetCalldata: BytesLike;
+        targetOffset: BigNumberish;
+    };
+    type ConditionStructOutput = [
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        string,
+        string,
+        BigNumber
+    ] & {
+        outToken: string;
+        startMinPrice: BigNumber;
+        duration: BigNumber;
+        discount: BigNumber;
+        target: string;
+        targetCalldata: string;
+        targetOffset: BigNumber;
+    };
+    type SolutionStruct = {
+        swapper: string;
+        swapCalldata: BytesLike;
+    };
+    type SolutionStructOutput = [string, string] & {
+        swapper: string;
+        swapCalldata: string;
+    };
+}
+export declare namespace DepositoryTypes {
+    type DepositStruct = {
+        token: string;
+        amount: BigNumberish;
+        nonce: BigNumberish;
+    };
+    type DepositStructOutput = [string, BigNumber, BigNumber] & {
+        token: string;
+        amount: BigNumber;
+        nonce: BigNumber;
+    };
+    type BlockchainStateStruct = {
+        blockNumber: BigNumberish;
+        timestamp: BigNumberish;
+    };
+    type BlockchainStateStructOutput = [BigNumber, BigNumber] & {
+        blockNumber: BigNumber;
+        timestamp: BigNumber;
+    };
+}
+export interface TimedSwapUnlockerInterface extends utils.Interface {
+    functions: {
+        "WAD()": FunctionFragment;
+        "decodeCondition(bytes)": FunctionFragment;
+        "encodeCondition((address,uint256,uint256,uint256,address,bytes,uint256))": FunctionFragment;
+        "encodeSolution((address,bytes))": FunctionFragment;
+        "unlock(address,(address,uint256,uint256),(uint256,uint256),bytes,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "WAD" | "decodeCondition" | "encodeCondition" | "encodeSolution" | "unlock"): FunctionFragment;
+    encodeFunctionData(functionFragment: "WAD", values?: undefined): string;
+    encodeFunctionData(functionFragment: "decodeCondition", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "encodeCondition", values: [TimedSwapUnlocker.ConditionStruct]): string;
+    encodeFunctionData(functionFragment: "encodeSolution", values: [TimedSwapUnlocker.SolutionStruct]): string;
+    encodeFunctionData(functionFragment: "unlock", values: [
+        string,
+        DepositoryTypes.DepositStruct,
+        DepositoryTypes.BlockchainStateStruct,
+        BytesLike,
+        BytesLike
+    ]): string;
+    decodeFunctionResult(functionFragment: "WAD", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decodeCondition", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "encodeCondition", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "encodeSolution", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
+    events: {
+        "TimedPricedSwap(address,uint256,uint256,uint256,uint256,address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "TimedPricedSwap"): EventFragment;
+}
+export interface TimedPricedSwapEventObject {
+    outToken: string;
+    delay: BigNumber;
+    providedPrice: BigNumber;
+    requiredPrice: BigNumber;
+    outAmount: BigNumber;
+    swapper: string;
+    target: string;
+}
+export type TimedPricedSwapEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    string,
+    string
+], TimedPricedSwapEventObject>;
+export type TimedPricedSwapEventFilter = TypedEventFilter<TimedPricedSwapEvent>;
+export interface TimedSwapUnlocker extends BaseContract {
+    contractName: "TimedSwapUnlocker";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: TimedSwapUnlockerInterface;
+    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: {
+        WAD(overrides?: CallOverrides): Promise<[BigNumber]>;
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<[TimedSwapUnlocker.ConditionStructOutput]>;
+        encodeCondition(c: TimedSwapUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<[string]>;
+        encodeSolution(s: TimedSwapUnlocker.SolutionStruct, overrides?: CallOverrides): Promise<[string]>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    WAD(overrides?: CallOverrides): Promise<BigNumber>;
+    decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<TimedSwapUnlocker.ConditionStructOutput>;
+    encodeCondition(c: TimedSwapUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<string>;
+    encodeSolution(s: TimedSwapUnlocker.SolutionStruct, overrides?: CallOverrides): Promise<string>;
+    unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        WAD(overrides?: CallOverrides): Promise<BigNumber>;
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<TimedSwapUnlocker.ConditionStructOutput>;
+        encodeCondition(c: TimedSwapUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<string>;
+        encodeSolution(s: TimedSwapUnlocker.SolutionStruct, overrides?: CallOverrides): Promise<string>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "TimedPricedSwap(address,uint256,uint256,uint256,uint256,address,address)"(outToken?: null, delay?: null, providedPrice?: null, requiredPrice?: null, outAmount?: null, swapper?: null, target?: null): TimedPricedSwapEventFilter;
+        TimedPricedSwap(outToken?: null, delay?: null, providedPrice?: null, requiredPrice?: null, outAmount?: null, swapper?: null, target?: null): TimedPricedSwapEventFilter;
+    };
+    estimateGas: {
+        WAD(overrides?: CallOverrides): Promise<BigNumber>;
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        encodeCondition(c: TimedSwapUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        encodeSolution(s: TimedSwapUnlocker.SolutionStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        WAD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        encodeCondition(c: TimedSwapUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        encodeSolution(s: TimedSwapUnlocker.SolutionStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/TimedSwapUnlocker.js

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

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

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

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

@@ -0,0 +1,131 @@
+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 DepositoryTypes {
+    type UnlockConditionStruct = {
+        unlocker: string;
+        condition: BytesLike;
+    };
+    type UnlockConditionStructOutput = [string, string] & {
+        unlocker: string;
+        condition: string;
+    };
+    type DepositStruct = {
+        token: string;
+        amount: BigNumberish;
+        nonce: BigNumberish;
+    };
+    type DepositStructOutput = [string, BigNumber, BigNumber] & {
+        token: string;
+        amount: BigNumber;
+        nonce: BigNumber;
+    };
+    type BlockchainStateStruct = {
+        blockNumber: BigNumberish;
+        timestamp: BigNumberish;
+    };
+    type BlockchainStateStructOutput = [BigNumber, BigNumber] & {
+        blockNumber: BigNumber;
+        timestamp: BigNumber;
+    };
+}
+export declare namespace TimedUnlocker {
+    type ConditionStruct = {
+        delay: BigNumberish;
+        next: DepositoryTypes.UnlockConditionStruct;
+    };
+    type ConditionStructOutput = [
+        BigNumber,
+        DepositoryTypes.UnlockConditionStructOutput
+    ] & {
+        delay: BigNumber;
+        next: DepositoryTypes.UnlockConditionStructOutput;
+    };
+}
+export interface TimedUnlockerInterface extends utils.Interface {
+    functions: {
+        "decodeCondition(bytes)": FunctionFragment;
+        "encodeCondition((uint256,(address,bytes)))": FunctionFragment;
+        "unlock(address,(address,uint256,uint256),(uint256,uint256),bytes,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "decodeCondition" | "encodeCondition" | "unlock"): FunctionFragment;
+    encodeFunctionData(functionFragment: "decodeCondition", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "encodeCondition", values: [TimedUnlocker.ConditionStruct]): string;
+    encodeFunctionData(functionFragment: "unlock", values: [
+        string,
+        DepositoryTypes.DepositStruct,
+        DepositoryTypes.BlockchainStateStruct,
+        BytesLike,
+        BytesLike
+    ]): string;
+    decodeFunctionResult(functionFragment: "decodeCondition", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "encodeCondition", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
+    events: {
+        "Unlocked(uint256,uint256,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Unlocked"): EventFragment;
+}
+export interface UnlockedEventObject {
+    currentTimestamp: BigNumber;
+    lockTimestamp: BigNumber;
+    delay: BigNumber;
+}
+export type UnlockedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber,
+    BigNumber
+], UnlockedEventObject>;
+export type UnlockedEventFilter = TypedEventFilter<UnlockedEvent>;
+export interface TimedUnlocker extends BaseContract {
+    contractName: "TimedUnlocker";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: TimedUnlockerInterface;
+    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: {
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<[TimedUnlocker.ConditionStructOutput]>;
+        encodeCondition(c: TimedUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<[string]>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<TimedUnlocker.ConditionStructOutput>;
+    encodeCondition(c: TimedUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<string>;
+    unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<TimedUnlocker.ConditionStructOutput>;
+        encodeCondition(c: TimedUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<string>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "Unlocked(uint256,uint256,uint256)"(currentTimestamp?: null, lockTimestamp?: null, delay?: null): UnlockedEventFilter;
+        Unlocked(currentTimestamp?: null, lockTimestamp?: null, delay?: null): UnlockedEventFilter;
+    };
+    estimateGas: {
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        encodeCondition(c: TimedUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        decodeCondition(condition: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        encodeCondition(c: TimedUnlocker.ConditionStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unlock(router: string, deposit: DepositoryTypes.DepositStruct, lockState: DepositoryTypes.BlockchainStateStruct, condition: BytesLike, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/TimedUnlocker.js

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

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

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