symbiosis-js-sdk 3.7.5 → 3.7.6

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

@@ -0,0 +1,343 @@
+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 DepositoryTypes {
+    type DepositStruct = {
+        token: string;
+        amount: BigNumberish;
+        nonce: BigNumberish;
+    };
+    type DepositStructOutput = [string, BigNumber, BigNumber] & {
+        token: string;
+        amount: BigNumber;
+        nonce: BigNumber;
+    };
+    type UnlockConditionStruct = {
+        unlocker: string;
+        condition: BytesLike;
+    };
+    type UnlockConditionStructOutput = [string, string] & {
+        unlocker: string;
+        condition: string;
+    };
+    type BlockchainStateStruct = {
+        blockNumber: BigNumberish;
+        timestamp: BigNumberish;
+    };
+    type BlockchainStateStructOutput = [BigNumber, BigNumber] & {
+        blockNumber: BigNumber;
+        timestamp: BigNumber;
+    };
+}
+export interface IDepositoryInterface extends utils.Interface {
+    functions: {
+        "UPGRADE_INTERFACE_VERSION()": FunctionFragment;
+        "acceptOwnership()": FunctionFragment;
+        "depositID((address,uint256,uint256),(address,bytes),(uint256,uint256))": FunctionFragment;
+        "depositStatus(bytes32)": FunctionFragment;
+        "initialize()": FunctionFragment;
+        "lock((address,uint256,uint256),(address,bytes))": FunctionFragment;
+        "owner()": FunctionFragment;
+        "pendingOwner()": FunctionFragment;
+        "proxiableUUID()": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "router()": FunctionFragment;
+        "setRouter(address)": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "unlock((address,uint256,uint256),(address,bytes),(uint256,uint256),bytes)": FunctionFragment;
+        "upgradeToAndCall(address,bytes)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "UPGRADE_INTERFACE_VERSION" | "acceptOwnership" | "depositID" | "depositStatus" | "initialize" | "lock" | "owner" | "pendingOwner" | "proxiableUUID" | "renounceOwnership" | "router" | "setRouter" | "transferOwnership" | "unlock" | "upgradeToAndCall"): FunctionFragment;
+    encodeFunctionData(functionFragment: "UPGRADE_INTERFACE_VERSION", values?: undefined): string;
+    encodeFunctionData(functionFragment: "acceptOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "depositID", values: [
+        DepositoryTypes.DepositStruct,
+        DepositoryTypes.UnlockConditionStruct,
+        DepositoryTypes.BlockchainStateStruct
+    ]): string;
+    encodeFunctionData(functionFragment: "depositStatus", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "initialize", values?: undefined): string;
+    encodeFunctionData(functionFragment: "lock", values: [
+        DepositoryTypes.DepositStruct,
+        DepositoryTypes.UnlockConditionStruct
+    ]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "proxiableUUID", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "router", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setRouter", values: [string]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
+    encodeFunctionData(functionFragment: "unlock", values: [
+        DepositoryTypes.DepositStruct,
+        DepositoryTypes.UnlockConditionStruct,
+        DepositoryTypes.BlockchainStateStruct,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [string, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "UPGRADE_INTERFACE_VERSION", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "acceptOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositID", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositStatus", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "proxiableUUID", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRouter", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
+    events: {
+        "DepositLocked(bytes32,(address,uint256,uint256),(address,bytes),(uint256,uint256))": EventFragment;
+        "DepositUnlocked(bytes32)": EventFragment;
+        "Initialized(uint64)": EventFragment;
+        "OwnershipTransferStarted(address,address)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+        "SetRouter(address,address)": EventFragment;
+        "Upgraded(address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "DepositLocked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DepositUnlocked"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SetRouter"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+}
+export interface DepositLockedEventObject {
+    depositID: string;
+    deposit: DepositoryTypes.DepositStructOutput;
+    unlocker: DepositoryTypes.UnlockConditionStructOutput;
+    blockchainState: DepositoryTypes.BlockchainStateStructOutput;
+}
+export type DepositLockedEvent = TypedEvent<[
+    string,
+    DepositoryTypes.DepositStructOutput,
+    DepositoryTypes.UnlockConditionStructOutput,
+    DepositoryTypes.BlockchainStateStructOutput
+], DepositLockedEventObject>;
+export type DepositLockedEventFilter = TypedEventFilter<DepositLockedEvent>;
+export interface DepositUnlockedEventObject {
+    depositID: string;
+}
+export type DepositUnlockedEvent = TypedEvent<[
+    string
+], DepositUnlockedEventObject>;
+export type DepositUnlockedEventFilter = TypedEventFilter<DepositUnlockedEvent>;
+export interface InitializedEventObject {
+    version: BigNumber;
+}
+export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>;
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface OwnershipTransferStartedEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferStartedEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferStartedEventObject>;
+export type OwnershipTransferStartedEventFilter = TypedEventFilter<OwnershipTransferStartedEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface SetRouterEventObject {
+    oldRouter: string;
+    newRouter: string;
+}
+export type SetRouterEvent = TypedEvent<[string, string], SetRouterEventObject>;
+export type SetRouterEventFilter = TypedEventFilter<SetRouterEvent>;
+export interface UpgradedEventObject {
+    implementation: string;
+}
+export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
+export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
+export interface IDepository extends BaseContract {
+    contractName: "IDepository";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IDepositoryInterface;
+    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: {
+        UPGRADE_INTERFACE_VERSION(overrides?: CallOverrides): Promise<[string]>;
+        acceptOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        depositID(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, overrides?: CallOverrides): Promise<[string]>;
+        depositStatus(arg0: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+        initialize(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        lock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        router(overrides?: CallOverrides): Promise<[string]>;
+        setRouter(_router: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        unlock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    UPGRADE_INTERFACE_VERSION(overrides?: CallOverrides): Promise<string>;
+    acceptOwnership(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    depositID(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, overrides?: CallOverrides): Promise<string>;
+    depositStatus(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    initialize(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    lock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    pendingOwner(overrides?: CallOverrides): Promise<string>;
+    proxiableUUID(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    router(overrides?: CallOverrides): Promise<string>;
+    setRouter(_router: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    transferOwnership(newOwner: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    unlock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, solution: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        UPGRADE_INTERFACE_VERSION(overrides?: CallOverrides): Promise<string>;
+        acceptOwnership(overrides?: CallOverrides): Promise<void>;
+        depositID(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, overrides?: CallOverrides): Promise<string>;
+        depositStatus(arg0: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+        initialize(overrides?: CallOverrides): Promise<void>;
+        lock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, overrides?: CallOverrides): Promise<void>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        pendingOwner(overrides?: CallOverrides): Promise<string>;
+        proxiableUUID(overrides?: CallOverrides): Promise<string>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        router(overrides?: CallOverrides): Promise<string>;
+        setRouter(_router: string, overrides?: CallOverrides): Promise<void>;
+        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
+        unlock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, solution: BytesLike, overrides?: CallOverrides): Promise<void>;
+        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "DepositLocked(bytes32,(address,uint256,uint256),(address,bytes),(uint256,uint256))"(depositID?: BytesLike | null, deposit?: null, unlocker?: null, blockchainState?: null): DepositLockedEventFilter;
+        DepositLocked(depositID?: BytesLike | null, deposit?: null, unlocker?: null, blockchainState?: null): DepositLockedEventFilter;
+        "DepositUnlocked(bytes32)"(depositID?: BytesLike | null): DepositUnlockedEventFilter;
+        DepositUnlocked(depositID?: BytesLike | null): DepositUnlockedEventFilter;
+        "Initialized(uint64)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+        "OwnershipTransferStarted(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferStartedEventFilter;
+        OwnershipTransferStarted(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferStartedEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+        "SetRouter(address,address)"(oldRouter?: string | null, newRouter?: string | null): SetRouterEventFilter;
+        SetRouter(oldRouter?: string | null, newRouter?: string | null): SetRouterEventFilter;
+        "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
+        Upgraded(implementation?: string | null): UpgradedEventFilter;
+    };
+    estimateGas: {
+        UPGRADE_INTERFACE_VERSION(overrides?: CallOverrides): Promise<BigNumber>;
+        acceptOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        depositID(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        depositStatus(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        lock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        router(overrides?: CallOverrides): Promise<BigNumber>;
+        setRouter(_router: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        unlock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        UPGRADE_INTERFACE_VERSION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        acceptOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        depositID(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        depositStatus(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        lock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        router(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setRouter(_router: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        unlock(deposit: DepositoryTypes.DepositStruct, condition: DepositoryTypes.UnlockConditionStruct, blockchainState: DepositoryTypes.BlockchainStateStruct, solution: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/IDepository.js

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

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

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

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

@@ -0,0 +1,67 @@
+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 IRouterInterface extends utils.Interface {
+    functions: {
+        "externalCall(address,uint256,address,bytes,uint256)": FunctionFragment;
+        "transferNative(address,address,uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "externalCall" | "transferNative"): FunctionFragment;
+    encodeFunctionData(functionFragment: "externalCall", values: [string, BigNumberish, string, BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferNative", values: [string, string, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "externalCall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferNative", data: BytesLike): Result;
+    events: {};
+}
+export interface IRouter extends BaseContract {
+    contractName: "IRouter";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IRouterInterface;
+    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, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        transferNative(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    transferNative(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        transferNative(token: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {};
+    estimateGas: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        transferNative(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        externalCall(_token: string, _amount: BigNumberish, _receiveSide: string, _calldata: BytesLike, _offset: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        transferNative(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/IRouter.js

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

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

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

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

@@ -0,0 +1,229 @@
+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 interface IzumiFactoryInterface extends utils.Interface {
+    functions: {
+        "chargeReceiver()": FunctionFragment;
+        "enableFeeAmount(uint24,uint24)": FunctionFragment;
+        "fee2pointDelta(uint24)": FunctionFragment;
+        "flashModule()": FunctionFragment;
+        "limitOrderModule()": FunctionFragment;
+        "liquidityModule()": FunctionFragment;
+        "modifyChargeReceiver(address)": FunctionFragment;
+        "newPool(address,address,uint24,int24)": FunctionFragment;
+        "only_addr_()": FunctionFragment;
+        "owner()": FunctionFragment;
+        "pool(address,address,uint24)": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "swapX2YModule()": FunctionFragment;
+        "swapY2XModule()": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "chargeReceiver" | "enableFeeAmount" | "fee2pointDelta" | "flashModule" | "limitOrderModule" | "liquidityModule" | "modifyChargeReceiver" | "newPool" | "only_addr_" | "owner" | "pool" | "renounceOwnership" | "swapX2YModule" | "swapY2XModule" | "transferOwnership"): FunctionFragment;
+    encodeFunctionData(functionFragment: "chargeReceiver", values?: undefined): string;
+    encodeFunctionData(functionFragment: "enableFeeAmount", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "fee2pointDelta", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "flashModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "limitOrderModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "liquidityModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "modifyChargeReceiver", values: [string]): string;
+    encodeFunctionData(functionFragment: "newPool", values: [string, string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "only_addr_", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pool", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "swapX2YModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "swapY2XModule", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
+    decodeFunctionResult(functionFragment: "chargeReceiver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enableFeeAmount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "fee2pointDelta", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "flashModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "limitOrderModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "liquidityModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "modifyChargeReceiver", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "newPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "only_addr_", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapX2YModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapY2XModule", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    events: {
+        "NewPool(address,address,uint24,uint24,address)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "NewPool"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+export interface NewPoolEventObject {
+    tokenX: string;
+    tokenY: string;
+    fee: number;
+    pointDelta: number;
+    pool: string;
+}
+export type NewPoolEvent = TypedEvent<[
+    string,
+    string,
+    number,
+    number,
+    string
+], NewPoolEventObject>;
+export type NewPoolEventFilter = TypedEventFilter<NewPoolEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface IzumiFactory extends BaseContract {
+    contractName: "IzumiFactory";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IzumiFactoryInterface;
+    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: {
+        chargeReceiver(overrides?: CallOverrides): Promise<[string]>;
+        enableFeeAmount(fee: BigNumberish, pointDelta: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        fee2pointDelta(arg0: BigNumberish, overrides?: CallOverrides): Promise<[number]>;
+        flashModule(overrides?: CallOverrides): Promise<[string]>;
+        limitOrderModule(overrides?: CallOverrides): Promise<[string]>;
+        liquidityModule(overrides?: CallOverrides): Promise<[string]>;
+        modifyChargeReceiver(_chargeReceiver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        newPool(tokenX: string, tokenY: string, fee: BigNumberish, currentPoint: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        only_addr_(overrides?: CallOverrides): Promise<[string]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        pool(arg0: string, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapX2YModule(overrides?: CallOverrides): Promise<[string]>;
+        swapY2XModule(overrides?: CallOverrides): Promise<[string]>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    chargeReceiver(overrides?: CallOverrides): Promise<string>;
+    enableFeeAmount(fee: BigNumberish, pointDelta: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    fee2pointDelta(arg0: BigNumberish, overrides?: CallOverrides): Promise<number>;
+    flashModule(overrides?: CallOverrides): Promise<string>;
+    limitOrderModule(overrides?: CallOverrides): Promise<string>;
+    liquidityModule(overrides?: CallOverrides): Promise<string>;
+    modifyChargeReceiver(_chargeReceiver: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    newPool(tokenX: string, tokenY: string, fee: BigNumberish, currentPoint: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    only_addr_(overrides?: CallOverrides): Promise<string>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    pool(arg0: string, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapX2YModule(overrides?: CallOverrides): Promise<string>;
+    swapY2XModule(overrides?: CallOverrides): Promise<string>;
+    transferOwnership(newOwner: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        chargeReceiver(overrides?: CallOverrides): Promise<string>;
+        enableFeeAmount(fee: BigNumberish, pointDelta: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        fee2pointDelta(arg0: BigNumberish, overrides?: CallOverrides): Promise<number>;
+        flashModule(overrides?: CallOverrides): Promise<string>;
+        limitOrderModule(overrides?: CallOverrides): Promise<string>;
+        liquidityModule(overrides?: CallOverrides): Promise<string>;
+        modifyChargeReceiver(_chargeReceiver: string, overrides?: CallOverrides): Promise<void>;
+        newPool(tokenX: string, tokenY: string, fee: BigNumberish, currentPoint: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        only_addr_(overrides?: CallOverrides): Promise<string>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        pool(arg0: string, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        swapX2YModule(overrides?: CallOverrides): Promise<string>;
+        swapY2XModule(overrides?: CallOverrides): Promise<string>;
+        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "NewPool(address,address,uint24,uint24,address)"(tokenX?: string | null, tokenY?: string | null, fee?: BigNumberish | null, pointDelta?: null, pool?: null): NewPoolEventFilter;
+        NewPool(tokenX?: string | null, tokenY?: string | null, fee?: BigNumberish | null, pointDelta?: null, pool?: null): NewPoolEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+    };
+    estimateGas: {
+        chargeReceiver(overrides?: CallOverrides): Promise<BigNumber>;
+        enableFeeAmount(fee: BigNumberish, pointDelta: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        fee2pointDelta(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        flashModule(overrides?: CallOverrides): Promise<BigNumber>;
+        limitOrderModule(overrides?: CallOverrides): Promise<BigNumber>;
+        liquidityModule(overrides?: CallOverrides): Promise<BigNumber>;
+        modifyChargeReceiver(_chargeReceiver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        newPool(tokenX: string, tokenY: string, fee: BigNumberish, currentPoint: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        only_addr_(overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        pool(arg0: string, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapX2YModule(overrides?: CallOverrides): Promise<BigNumber>;
+        swapY2XModule(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        chargeReceiver(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        enableFeeAmount(fee: BigNumberish, pointDelta: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        fee2pointDelta(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        flashModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        limitOrderModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        liquidityModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        modifyChargeReceiver(_chargeReceiver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        newPool(tokenX: string, tokenY: string, fee: BigNumberish, currentPoint: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        only_addr_(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pool(arg0: string, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapX2YModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        swapY2XModule(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}