@atomiqlabs/chain-evm 1.0.0-dev.22

package/dist/evm/spv_swap/SpvVaultContractTypechain.d.ts

@@ -0,0 +1,450 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../typechain/common";
+export type SpvVaultParametersStruct = {
+    btcRelayContract: AddressLike;
+    token0: AddressLike;
+    token1: AddressLike;
+    token0Multiplier: BigNumberish;
+    token1Multiplier: BigNumberish;
+    confirmations: BigNumberish;
+};
+export type SpvVaultParametersStructOutput = [
+    btcRelayContract: string,
+    token0: string,
+    token1: string,
+    token0Multiplier: bigint,
+    token1Multiplier: bigint,
+    confirmations: bigint
+] & {
+    btcRelayContract: string;
+    token0: string;
+    token1: string;
+    token0Multiplier: bigint;
+    token1Multiplier: bigint;
+    confirmations: bigint;
+};
+export type StoredBlockHeaderStruct = {
+    data: [BytesLike, BytesLike, BytesLike, BytesLike, BytesLike];
+};
+export type StoredBlockHeaderStructOutput = [
+    data: [string, string, string, string, string]
+] & {
+    data: [string, string, string, string, string];
+};
+export type BitcoinVaultTransactionDataStruct = {
+    recipient: AddressLike;
+    amount0: BigNumberish;
+    amount1: BigNumberish;
+    callerFee0: BigNumberish;
+    callerFee1: BigNumberish;
+    frontingFee0: BigNumberish;
+    frontingFee1: BigNumberish;
+    executionHandlerFeeAmount0: BigNumberish;
+    executionHash: BytesLike;
+    executionExpiry: BigNumberish;
+};
+export type BitcoinVaultTransactionDataStructOutput = [
+    recipient: string,
+    amount0: bigint,
+    amount1: bigint,
+    callerFee0: bigint,
+    callerFee1: bigint,
+    frontingFee0: bigint,
+    frontingFee1: bigint,
+    executionHandlerFeeAmount0: bigint,
+    executionHash: string,
+    executionExpiry: bigint
+] & {
+    recipient: string;
+    amount0: bigint;
+    amount1: bigint;
+    callerFee0: bigint;
+    callerFee1: bigint;
+    frontingFee0: bigint;
+    frontingFee1: bigint;
+    executionHandlerFeeAmount0: bigint;
+    executionHash: string;
+    executionExpiry: bigint;
+};
+export type SpvVaultStateStruct = {
+    spvVaultParametersCommitment: BytesLike;
+    utxoTxHash: BytesLike;
+    utxoVout: BigNumberish;
+    openBlockheight: BigNumberish;
+    withdrawCount: BigNumberish;
+    depositCount: BigNumberish;
+    token0Amount: BigNumberish;
+    token1Amount: BigNumberish;
+};
+export type SpvVaultStateStructOutput = [
+    spvVaultParametersCommitment: string,
+    utxoTxHash: string,
+    utxoVout: bigint,
+    openBlockheight: bigint,
+    withdrawCount: bigint,
+    depositCount: bigint,
+    token0Amount: bigint,
+    token1Amount: bigint
+] & {
+    spvVaultParametersCommitment: string;
+    utxoTxHash: string;
+    utxoVout: bigint;
+    openBlockheight: bigint;
+    withdrawCount: bigint;
+    depositCount: bigint;
+    token0Amount: bigint;
+    token1Amount: bigint;
+};
+export interface SpvVaultManagerInterface extends Interface {
+    getFunction(nameOrSignature: "claim" | "deposit" | "front" | "getFronterAddress" | "getFronterById" | "getVault" | "open" | "parseBitcoinTx"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Claimed" | "Closed" | "Deposited" | "Fronted" | "Opened"): EventFragment;
+    encodeFunctionData(functionFragment: "claim", values: [
+        AddressLike,
+        BigNumberish,
+        SpvVaultParametersStruct,
+        BytesLike,
+        StoredBlockHeaderStruct,
+        BytesLike[],
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "deposit", values: [
+        AddressLike,
+        BigNumberish,
+        SpvVaultParametersStruct,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "front", values: [
+        AddressLike,
+        BigNumberish,
+        SpvVaultParametersStruct,
+        BigNumberish,
+        BytesLike,
+        BitcoinVaultTransactionDataStruct
+    ]): string;
+    encodeFunctionData(functionFragment: "getFronterAddress", values: [
+        AddressLike,
+        BigNumberish,
+        BytesLike,
+        BitcoinVaultTransactionDataStruct
+    ]): string;
+    encodeFunctionData(functionFragment: "getFronterById", values: [AddressLike, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "getVault", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "open", values: [BigNumberish, SpvVaultParametersStruct, BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "parseBitcoinTx", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "front", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getFronterAddress", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getFronterById", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getVault", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "open", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "parseBitcoinTx", data: BytesLike): Result;
+}
+export declare namespace ClaimedEvent {
+    type InputTuple = [
+        ownerAndVaultId: BytesLike,
+        recipient: AddressLike,
+        btcTxHash: BytesLike,
+        caller: AddressLike,
+        executionHash: BytesLike,
+        frontingAddress: AddressLike,
+        withdrawCount: BigNumberish,
+        amount0: BigNumberish,
+        amount1: BigNumberish
+    ];
+    type OutputTuple = [
+        ownerAndVaultId: string,
+        recipient: string,
+        btcTxHash: string,
+        caller: string,
+        executionHash: string,
+        frontingAddress: string,
+        withdrawCount: bigint,
+        amount0: bigint,
+        amount1: bigint
+    ];
+    interface OutputObject {
+        ownerAndVaultId: string;
+        recipient: string;
+        btcTxHash: string;
+        caller: string;
+        executionHash: string;
+        frontingAddress: string;
+        withdrawCount: bigint;
+        amount0: bigint;
+        amount1: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ClosedEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        btcTxHash: BytesLike,
+        error: BytesLike
+    ];
+    type OutputTuple = [
+        owner: string,
+        vaultId: bigint,
+        btcTxHash: string,
+        error: string
+    ];
+    interface OutputObject {
+        owner: string;
+        vaultId: bigint;
+        btcTxHash: string;
+        error: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace DepositedEvent {
+    type InputTuple = [
+        ownerAndVaultId: BytesLike,
+        depositCount: BigNumberish,
+        amount0: BigNumberish,
+        amount1: BigNumberish
+    ];
+    type OutputTuple = [
+        ownerAndVaultId: string,
+        depositCount: bigint,
+        amount0: bigint,
+        amount1: bigint
+    ];
+    interface OutputObject {
+        ownerAndVaultId: string;
+        depositCount: bigint;
+        amount0: bigint;
+        amount1: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace FrontedEvent {
+    type InputTuple = [
+        ownerAndVaultId: BytesLike,
+        recipient: AddressLike,
+        btcTxHash: BytesLike,
+        caller: AddressLike,
+        executionHash: BytesLike,
+        amount0: BigNumberish,
+        amount1: BigNumberish
+    ];
+    type OutputTuple = [
+        ownerAndVaultId: string,
+        recipient: string,
+        btcTxHash: string,
+        caller: string,
+        executionHash: string,
+        amount0: bigint,
+        amount1: bigint
+    ];
+    interface OutputObject {
+        ownerAndVaultId: string;
+        recipient: string;
+        btcTxHash: string;
+        caller: string;
+        executionHash: string;
+        amount0: bigint;
+        amount1: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace OpenedEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        btcTxHash: BytesLike,
+        vout: BigNumberish,
+        params: SpvVaultParametersStruct
+    ];
+    type OutputTuple = [
+        owner: string,
+        vaultId: bigint,
+        btcTxHash: string,
+        vout: bigint,
+        params: SpvVaultParametersStructOutput
+    ];
+    interface OutputObject {
+        owner: string;
+        vaultId: bigint;
+        btcTxHash: string;
+        vout: bigint;
+        params: SpvVaultParametersStructOutput;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface SpvVaultManager extends BaseContract {
+    connect(runner?: ContractRunner | null): SpvVaultManager;
+    waitForDeployment(): Promise<this>;
+    interface: SpvVaultManagerInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    claim: TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        transaction: BytesLike,
+        blockheader: StoredBlockHeaderStruct,
+        merkleProof: BytesLike[],
+        position: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    deposit: TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        rawToken0: BigNumberish,
+        rawToken1: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    front: TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        withdrawalSequence: BigNumberish,
+        btcTxHash: BytesLike,
+        data: BitcoinVaultTransactionDataStruct
+    ], [
+        void
+    ], "payable">;
+    getFronterAddress: TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        btcTxHash: BytesLike,
+        data: BitcoinVaultTransactionDataStruct
+    ], [
+        string
+    ], "view">;
+    getFronterById: TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        frontingId: BytesLike
+    ], [
+        string
+    ], "view">;
+    getVault: TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish
+    ], [
+        SpvVaultStateStructOutput
+    ], "view">;
+    open: TypedContractMethod<[
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        utxoTxHash: BytesLike,
+        utxoVout: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    parseBitcoinTx: TypedContractMethod<[
+        transaction: BytesLike
+    ], [
+        BitcoinVaultTransactionDataStructOutput
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "claim"): TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        transaction: BytesLike,
+        blockheader: StoredBlockHeaderStruct,
+        merkleProof: BytesLike[],
+        position: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        rawToken0: BigNumberish,
+        rawToken1: BigNumberish
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "front"): TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        withdrawalSequence: BigNumberish,
+        btcTxHash: BytesLike,
+        data: BitcoinVaultTransactionDataStruct
+    ], [
+        void
+    ], "payable">;
+    getFunction(nameOrSignature: "getFronterAddress"): TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        btcTxHash: BytesLike,
+        data: BitcoinVaultTransactionDataStruct
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "getFronterById"): TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish,
+        frontingId: BytesLike
+    ], [
+        string
+    ], "view">;
+    getFunction(nameOrSignature: "getVault"): TypedContractMethod<[
+        owner: AddressLike,
+        vaultId: BigNumberish
+    ], [
+        SpvVaultStateStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "open"): TypedContractMethod<[
+        vaultId: BigNumberish,
+        vaultParams: SpvVaultParametersStruct,
+        utxoTxHash: BytesLike,
+        utxoVout: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "parseBitcoinTx"): TypedContractMethod<[
+        transaction: BytesLike
+    ], [
+        BitcoinVaultTransactionDataStructOutput
+    ], "view">;
+    getEvent(key: "Claimed"): TypedContractEvent<ClaimedEvent.InputTuple, ClaimedEvent.OutputTuple, ClaimedEvent.OutputObject>;
+    getEvent(key: "Closed"): TypedContractEvent<ClosedEvent.InputTuple, ClosedEvent.OutputTuple, ClosedEvent.OutputObject>;
+    getEvent(key: "Deposited"): TypedContractEvent<DepositedEvent.InputTuple, DepositedEvent.OutputTuple, DepositedEvent.OutputObject>;
+    getEvent(key: "Fronted"): TypedContractEvent<FrontedEvent.InputTuple, FrontedEvent.OutputTuple, FrontedEvent.OutputObject>;
+    getEvent(key: "Opened"): TypedContractEvent<OpenedEvent.InputTuple, OpenedEvent.OutputTuple, OpenedEvent.OutputObject>;
+    filters: {
+        "Claimed(bytes32,address,bytes32,address,bytes32,address,uint32,uint64,uint64)": TypedContractEvent<ClaimedEvent.InputTuple, ClaimedEvent.OutputTuple, ClaimedEvent.OutputObject>;
+        Claimed: TypedContractEvent<ClaimedEvent.InputTuple, ClaimedEvent.OutputTuple, ClaimedEvent.OutputObject>;
+        "Closed(address,uint96,bytes32,bytes)": TypedContractEvent<ClosedEvent.InputTuple, ClosedEvent.OutputTuple, ClosedEvent.OutputObject>;
+        Closed: TypedContractEvent<ClosedEvent.InputTuple, ClosedEvent.OutputTuple, ClosedEvent.OutputObject>;
+        "Deposited(bytes32,uint32,uint64,uint64)": TypedContractEvent<DepositedEvent.InputTuple, DepositedEvent.OutputTuple, DepositedEvent.OutputObject>;
+        Deposited: TypedContractEvent<DepositedEvent.InputTuple, DepositedEvent.OutputTuple, DepositedEvent.OutputObject>;
+        "Fronted(bytes32,address,bytes32,address,bytes32,uint64,uint64)": TypedContractEvent<FrontedEvent.InputTuple, FrontedEvent.OutputTuple, FrontedEvent.OutputObject>;
+        Fronted: TypedContractEvent<FrontedEvent.InputTuple, FrontedEvent.OutputTuple, FrontedEvent.OutputObject>;
+        "Opened(address,uint96,bytes32,uint32,tuple)": TypedContractEvent<OpenedEvent.InputTuple, OpenedEvent.OutputTuple, OpenedEvent.OutputObject>;
+        Opened: TypedContractEvent<OpenedEvent.InputTuple, OpenedEvent.OutputTuple, OpenedEvent.OutputObject>;
+    };
+}

package/dist/evm/spv_swap/SpvVaultContractTypechain.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/evm/swaps/EVMSwapContract.d.ts

@@ -0,0 +1,192 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainSwapType, IntermediaryReputationType, RelaySynchronizer, SignatureData, SwapCommitState, SwapContract, TransactionConfirmationOptions } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+import { IClaimHandler } from "./handlers/claim/ClaimHandlers";
+import { IHandler } from "./handlers/IHandler";
+import { EVMContractBase } from "../contract/EVMContractBase";
+import { EscrowManager } from "./EscrowManagerTypechain";
+import { EVMSwapData } from "./EVMSwapData";
+import { EVMTx } from "../chain/modules/EVMTransactions";
+import { EVMSigner } from "../wallet/EVMSigner";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import { EVMBtcRelay } from "../btcrelay/EVMBtcRelay";
+import { EVMBtcStoredHeader } from "../btcrelay/headers/EVMBtcStoredHeader";
+import { EVMLpVault } from "./modules/EVMLpVault";
+import { EVMPreFetchVerification, EVMSwapInit } from "./modules/EVMSwapInit";
+import { EVMSwapRefund } from "./modules/EVMSwapRefund";
+import { EVMSwapClaim } from "./modules/EVMSwapClaim";
+export declare class EVMSwapContract<ChainId extends string = string> extends EVMContractBase<EscrowManager> implements SwapContract<EVMSwapData, EVMTx, never, EVMPreFetchVerification, EVMSigner, ChainId> {
+    readonly chainId: ChainId;
+    readonly claimWithSecretTimeout: number;
+    readonly claimWithTxDataTimeout: number;
+    readonly refundTimeout: number;
+    readonly claimGracePeriod: number;
+    readonly refundGracePeriod: number;
+    readonly authGracePeriod: number;
+    readonly Init: EVMSwapInit;
+    readonly Refund: EVMSwapRefund;
+    readonly Claim: EVMSwapClaim;
+    readonly LpVault: EVMLpVault;
+    readonly claimHandlersByAddress: {
+        [address: string]: IClaimHandler<any, any>;
+    };
+    readonly claimHandlersBySwapType: {
+        [type in ChainSwapType]?: IClaimHandler<any, any>;
+    };
+    readonly refundHandlersByAddress: {
+        [address: string]: IHandler<any, any>;
+    };
+    readonly timelockRefundHandler: IHandler<any, any>;
+    readonly btcRelay: EVMBtcRelay<any>;
+    constructor(chainInterface: EVMChainInterface<ChainId>, btcRelay: EVMBtcRelay<any>, contractAddress: string, handlerAddresses: {
+        refund: {
+            timelock: string;
+        };
+        claim: {
+            [type in ChainSwapType]: string;
+        };
+    });
+    start(): Promise<void>;
+    preFetchForInitSignatureVerification(): Promise<EVMPreFetchVerification>;
+    getInitSignature(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number, preFetchedBlockData?: never, feeRate?: string): Promise<SignatureData>;
+    isValidInitAuthorization(sender: string, swapData: EVMSwapData, { timeout, prefix, signature }: {
+        timeout: any;
+        prefix: any;
+        signature: any;
+    }, feeRate?: string, preFetchedData?: EVMPreFetchVerification): Promise<Buffer>;
+    getInitAuthorizationExpiry(swapData: EVMSwapData, { timeout, prefix, signature }: {
+        timeout: any;
+        prefix: any;
+        signature: any;
+    }, preFetchedData?: EVMPreFetchVerification): Promise<number>;
+    isInitAuthorizationExpired(swapData: EVMSwapData, { timeout, prefix, signature }: {
+        timeout: any;
+        prefix: any;
+        signature: any;
+    }): Promise<boolean>;
+    getRefundSignature(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number): Promise<SignatureData>;
+    isValidRefundAuthorization(swapData: EVMSwapData, { timeout, prefix, signature }: {
+        timeout: any;
+        prefix: any;
+        signature: any;
+    }): Promise<Buffer>;
+    getDataSignature(signer: EVMSigner, data: Buffer): Promise<string>;
+    isValidDataSignature(data: Buffer, signature: string, publicKey: string): Promise<boolean>;
+    /**
+     * Checks whether the claim is claimable by us, that means not expired, we are claimer & the swap is commited
+     *
+     * @param signer
+     * @param data
+     */
+    isClaimable(signer: string, data: EVMSwapData): Promise<boolean>;
+    /**
+     * Checks whether a swap is commited, i.e. the swap still exists on-chain and was not claimed nor refunded
+     *
+     * @param swapData
+     */
+    isCommited(swapData: EVMSwapData): Promise<boolean>;
+    /**
+     * Checks whether the swap is expired, takes into consideration possible on-chain time skew, therefore for claimer
+     *  the swap expires a bit sooner than it should've & for the offerer it expires a bit later
+     *
+     * @param signer
+     * @param data
+     */
+    isExpired(signer: string, data: EVMSwapData): Promise<boolean>;
+    /**
+     * Checks if the swap is refundable by us, checks if we are offerer, if the swap is already expired & if the swap
+     *  is still commited
+     *
+     * @param signer
+     * @param data
+     */
+    isRequestRefundable(signer: string, data: EVMSwapData): Promise<boolean>;
+    getHashForTxId(txId: string, confirmations: number): Buffer;
+    /**
+     * Get the swap payment hash to be used for an on-chain swap, uses poseidon hash of the value
+     *
+     * @param outputScript output script required to claim the swap
+     * @param amount sats sent required to claim the swap
+     * @param confirmations
+     * @param nonce swap nonce uniquely identifying the transaction to prevent replay attacks
+     */
+    getHashForOnchain(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
+    /**
+     * Get the swap payment hash to be used for a lightning htlc swap, uses poseidon hash of the sha256 hash of the preimage
+     *
+     * @param paymentHash payment hash of the HTLC
+     */
+    getHashForHtlc(paymentHash: Buffer): Buffer;
+    getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
+    /**
+     * Gets the status of the specific swap, this also checks if we are offerer/claimer & checks for expiry (to see
+     *  if swap is refundable)
+     *
+     * @param signer
+     * @param data
+     */
+    getCommitStatus(signer: string, data: EVMSwapData): Promise<SwapCommitState>;
+    /**
+     * Returns the data committed for a specific payment hash, or null if no data is currently commited for
+     *  the specific swap
+     *
+     * @param paymentHashHex
+     */
+    getCommitedData(paymentHashHex: string): Promise<EVMSwapData>;
+    createSwapData(type: ChainSwapType, offerer: string, claimer: string, token: string, amount: bigint, paymentHash: string, sequence: bigint, expiry: bigint, payIn: boolean, payOut: boolean, securityDeposit: bigint, claimerBounty: bigint, depositToken?: string): Promise<EVMSwapData>;
+    getBalance(signer: string, tokenAddress: string, inContract?: boolean): Promise<bigint>;
+    getIntermediaryData(address: string, token: string): Promise<{
+        balance: bigint;
+        reputation: IntermediaryReputationType;
+    }>;
+    getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
+    getIntermediaryBalance(address: string, token: string): Promise<bigint>;
+    txsClaimWithSecret(signer: string | EVMSigner, swapData: EVMSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<EVMTx[]>;
+    txsClaimWithTxData(signer: string | EVMSigner, swapData: EVMSwapData, tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+        height: number;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: EVMBtcStoredHeader, synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>, initAta?: boolean, feeRate?: string): Promise<EVMTx[] | null>;
+    txsRefund(signer: string, swapData: EVMSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    txsRefundWithAuthorization(signer: string, swapData: EVMSwapData, { timeout, prefix, signature }: {
+        timeout: any;
+        prefix: any;
+        signature: any;
+    }, check?: boolean, initAta?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    txsInit(signer: string, swapData: EVMSwapData, { timeout, prefix, signature }: {
+        timeout: any;
+        prefix: any;
+        signature: any;
+    }, skipChecks?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]>;
+    txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]>;
+    claimWithSecret(signer: EVMSigner, swapData: EVMSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    claimWithTxData(signer: EVMSigner, swapData: EVMSwapData, tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+        height: number;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: EVMBtcStoredHeader, synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    refund(signer: EVMSigner, swapData: EVMSwapData, check?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    refundWithAuthorization(signer: EVMSigner, swapData: EVMSwapData, signature: SignatureData, check?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    init(signer: EVMSigner, swapData: EVMSwapData, signature: SignatureData, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    withdraw(signer: EVMSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    deposit(signer: EVMSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
+    getInitFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
+    getRefundFeeRate(swapData: EVMSwapData): Promise<string>;
+    getClaimFeeRate(signer: string, swapData: EVMSwapData): Promise<string>;
+    getClaimFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+    /**
+     * Get the estimated solana fee of the commit transaction
+     */
+    getCommitFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+    /**
+     * Get the estimated solana transaction fee of the refund transaction
+     */
+    getRefundFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+}