@atomiqlabs/chain-evm 2.0.7 → 2.0.8

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

@@ -41,9 +41,21 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
     protected Deposit(signer: string, vault: EVMSpvVaultData, rawAmounts: bigint[], feeRate: string): Promise<TransactionRequest>;
     protected Front(signer: string, vault: EVMSpvVaultData, data: EVMSpvWithdrawalData, withdrawalSequence: number, feeRate: string): Promise<TransactionRequest>;
     protected Claim(signer: string, vault: EVMSpvVaultData, data: EVMSpvWithdrawalData, blockheader: EVMBtcStoredHeader, merkle: Buffer[], position: number, feeRate: string): Promise<TransactionRequest>;
+    /**
+     * @inheritDoc
+     */
     checkWithdrawalTx(tx: SpvWithdrawalTransactionData): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     createVaultData(owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]): Promise<EVMSpvVaultData>;
+    /**
+     * @inheritDoc
+     */
     getFronterAddress(owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData): Promise<string | null>;
+    /**
+     * @inheritDoc
+     */
     getFronterAddresses(withdrawals: {
         owner: string;
         vaultId: bigint;
@@ -52,7 +64,13 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
         [btcTxId: string]: string | null;
     }>;
     private vaultParamsCache;
+    /**
+     * @inheritDoc
+     */
     getVaultData(owner: string, vaultId: bigint): Promise<EVMSpvVaultData | null>;
+    /**
+     * @inheritDoc
+     */
     getMultipleVaultData(vaults: {
         owner: string;
         vaultId: bigint;
@@ -61,7 +79,13 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
             [vaultId: string]: EVMSpvVaultData | null;
         };
     }>;
+    /**
+     * @inheritDoc
+     */
     getVaultLatestUtxo(owner: string, vaultId: bigint): Promise<string | null>;
+    /**
+     * @inheritDoc
+     */
     getVaultLatestUtxos(vaults: {
         owner: string;
         vaultId: bigint;
@@ -70,16 +94,31 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
             [vaultId: string]: string | null;
         };
     }>;
+    /**
+     * @inheritDoc
+     */
     getAllVaults(owner?: string): Promise<EVMSpvVaultData[]>;
     private parseWithdrawalEvent;
+    /**
+     * @inheritDoc
+     */
     getWithdrawalState(withdrawalTx: EVMSpvWithdrawalData, scStartHeight?: number): Promise<SpvWithdrawalState>;
+    /**
+     * @inheritDoc
+     */
     getWithdrawalStates(withdrawalTxs: {
         withdrawal: EVMSpvWithdrawalData;
         scStartBlockheight?: number;
     }[]): Promise<{
         [btcTxId: string]: SpvWithdrawalState;
     }>;
+    /**
+     * @inheritDoc
+     */
     getWithdrawalData(btcTx: BtcTx): Promise<EVMSpvWithdrawalData>;
+    /**
+     * @inheritDoc
+     */
     fromOpReturnData(data: Buffer): {
         recipient: string;
         rawAmounts: bigint[];
@@ -90,24 +129,57 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
         rawAmounts: bigint[];
         executionHash?: string;
     };
+    /**
+     * @inheritDoc
+     */
     toOpReturnData(recipient: string, rawAmounts: bigint[], executionHash?: string): Buffer;
     static toOpReturnData(recipient: string, rawAmounts: bigint[], executionHash?: string): Buffer;
+    /**
+     * @inheritDoc
+     */
     claim(signer: EVMSigner, vault: EVMSpvVaultData, txs: {
         tx: EVMSpvWithdrawalData;
         storedHeader?: EVMBtcStoredHeader;
     }[], synchronizer?: RelaySynchronizer<any, any, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     deposit(signer: EVMSigner, vault: EVMSpvVaultData, rawAmounts: bigint[], txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     frontLiquidity(signer: EVMSigner, vault: EVMSpvVaultData, realWithdrawalTx: EVMSpvWithdrawalData, withdrawSequence: number, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     open(signer: EVMSigner, vault: EVMSpvVaultData, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     txsClaim(signer: string, vault: EVMSpvVaultData, txs: {
         tx: EVMSpvWithdrawalData;
         storedHeader?: EVMBtcStoredHeader;
     }[], synchronizer?: RelaySynchronizer<any, any, any>, initAta?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsDeposit(signer: string, vault: EVMSpvVaultData, rawAmounts: bigint[], feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsFrontLiquidity(signer: string, vault: EVMSpvVaultData, realWithdrawalTx: EVMSpvWithdrawalData, withdrawSequence: number, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsOpen(signer: string, vault: EVMSpvVaultData, feeRate?: string): Promise<EVMTx[]>;
     getClaimGas(signer: string, vault?: EVMSpvVaultData, data?: EVMSpvWithdrawalData): number;
     getFrontGas(signer: string, vault: EVMSpvVaultData, data?: EVMSpvWithdrawalData): number;
+    /**
+     * @inheritDoc
+     */
     getClaimFee(signer: string, vault?: EVMSpvVaultData, withdrawalData?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     getFrontFee(signer: string, vault?: EVMSpvVaultData, withdrawalData?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
 }

package/dist/evm/spv_swap/EVMSpvVaultContract.js

@@ -94,11 +94,17 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         EVMFees_1.EVMFees.applyFeeRate(tx, this.getClaimGas(signer, vault, data), feeRate);
         return tx;
     }
+    /**
+     * @inheritDoc
+     */
     async checkWithdrawalTx(tx) {
         const result = await this.contract.parseBitcoinTx(buffer_1.Buffer.from(tx.btcTx.hex, "hex"));
         if (result == null)
             throw new Error("Failed to parse transaction!");
     }
+    /**
+     * @inheritDoc
+     */
     createVaultData(owner, vaultId, utxo, confirmations, tokenData) {
         if (tokenData.length !== 2)
             throw new Error("Must specify 2 tokens in tokenData!");
@@ -123,12 +129,18 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         }, vaultParams, utxo));
     }
     //Getters
+    /**
+     * @inheritDoc
+     */
     async getFronterAddress(owner, vaultId, withdrawal) {
         const frontingAddress = await this.contract.getFronterById(owner, vaultId, "0x" + withdrawal.getFrontingId());
         if (frontingAddress === ethers_1.ZeroAddress)
             return null;
         return frontingAddress;
     }
+    /**
+     * @inheritDoc
+     */
     async getFronterAddresses(withdrawals) {
         const result = {};
         let promises = [];
@@ -145,6 +157,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         await Promise.all(promises);
         return result;
     }
+    /**
+     * @inheritDoc
+     */
     async getVaultData(owner, vaultId) {
         const vaultState = await this.contract.getVault(owner, vaultId);
         if (vaultState.spvVaultParametersCommitment === ethers_1.ZeroHash)
@@ -164,6 +179,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             return null;
         return new EVMSpvVaultData_1.EVMSpvVaultData(owner, vaultId, vaultState, vaultParams);
     }
+    /**
+     * @inheritDoc
+     */
     async getMultipleVaultData(vaults) {
         const result = {};
         let promises = [];
@@ -181,6 +199,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         await Promise.all(promises);
         return result;
     }
+    /**
+     * @inheritDoc
+     */
     async getVaultLatestUtxo(owner, vaultId) {
         const vaultState = await this.contract.getVault(owner, vaultId);
         const utxo = (0, EVMSpvVaultData_1.getVaultUtxoFromState)(vaultState);
@@ -188,6 +209,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             return null;
         return utxo;
     }
+    /**
+     * @inheritDoc
+     */
     async getVaultLatestUtxos(vaults) {
         const result = {};
         let promises = [];
@@ -205,6 +229,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         await Promise.all(promises);
         return result;
     }
+    /**
+     * @inheritDoc
+     */
     async getAllVaults(owner) {
         const openedVaults = new Map();
         await this.Events.findInContractEventsForward(["Opened", "Closed"], owner == null ? null : [
@@ -268,6 +295,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
                 return null;
         }
     }
+    /**
+     * @inheritDoc
+     */
     async getWithdrawalState(withdrawalTx, scStartHeight) {
         const txHash = buffer_1.Buffer.from(withdrawalTx.getTxId(), "hex").reverse();
         const events = ["Fronted", "Claimed", "Closed"];
@@ -298,6 +328,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         });
         return result;
     }
+    /**
+     * @inheritDoc
+     */
     async getWithdrawalStates(withdrawalTxs) {
         var _a;
         const result = {};
@@ -365,10 +398,16 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         }
         return result;
     }
+    /**
+     * @inheritDoc
+     */
     getWithdrawalData(btcTx) {
         return Promise.resolve(new EVMSpvWithdrawalData_1.EVMSpvWithdrawalData(btcTx));
     }
     //OP_RETURN data encoding/decoding
+    /**
+     * @inheritDoc
+     */
     fromOpReturnData(data) {
         return EVMSpvVaultContract.fromOpReturnData(data);
     }
@@ -400,6 +439,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             throw new Error("Invalid recipient specified");
         return { executionHash, rawAmounts: [rawAmount0, rawAmount1], recipient: (0, ethers_1.getAddress)(recipient) };
     }
+    /**
+     * @inheritDoc
+     */
     toOpReturnData(recipient, rawAmounts, executionHash) {
         return EVMSpvVaultContract.toOpReturnData(recipient, rawAmounts, executionHash);
     }
@@ -432,27 +474,42 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         ]);
     }
     //Actions
+    /**
+     * @inheritDoc
+     */
     async claim(signer, vault, txs, synchronizer, initAta, txOptions) {
         const result = await this.txsClaim(signer.getAddress(), vault, txs, synchronizer, initAta, txOptions?.feeRate);
         const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return signature;
     }
+    /**
+     * @inheritDoc
+     */
     async deposit(signer, vault, rawAmounts, txOptions) {
         const result = await this.txsDeposit(signer.getAddress(), vault, rawAmounts, txOptions?.feeRate);
         const txHashes = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return txHashes[txHashes.length - 1];
     }
+    /**
+     * @inheritDoc
+     */
     async frontLiquidity(signer, vault, realWithdrawalTx, withdrawSequence, txOptions) {
         const result = await this.txsFrontLiquidity(signer.getAddress(), vault, realWithdrawalTx, withdrawSequence, txOptions?.feeRate);
         const txHashes = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return txHashes[txHashes.length - 1];
     }
+    /**
+     * @inheritDoc
+     */
     async open(signer, vault, txOptions) {
         const result = await this.txsOpen(signer.getAddress(), vault, txOptions?.feeRate);
         const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return signature;
     }
     //Transactions
+    /**
+     * @inheritDoc
+     */
     async txsClaim(signer, vault, txs, synchronizer, initAta, feeRate) {
         if (!vault.isOpened())
             throw new Error("Cannot claim from a closed vault!");
@@ -487,6 +544,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             " vaultId: " + vault.getVaultId().toString(10));
         return evmTxs;
     }
+    /**
+     * @inheritDoc
+     */
     async txsDeposit(signer, vault, rawAmounts, feeRate) {
         var _a;
         if (!vault.isOpened())
@@ -518,6 +578,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             " token1: " + vault.token1.token + " rawAmount1: " + (rawAmounts[1] ?? 0n).toString(10) + " amount1: " + realAmount1.toString(10));
         return txs;
     }
+    /**
+     * @inheritDoc
+     */
     async txsFrontLiquidity(signer, vault, realWithdrawalTx, withdrawSequence, feeRate) {
         var _a;
         if (!vault.isOpened())
@@ -551,6 +614,9 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             " token1: " + vault.token1.token + " rawAmount1: " + (rawAmounts[1] ?? 0n).toString(10) + " amount1: " + realAmount1.toString(10));
         return txs;
     }
+    /**
+     * @inheritDoc
+     */
     async txsOpen(signer, vault, feeRate) {
         if (vault.isOpened())
             throw new Error("Cannot open an already opened vault!");
@@ -598,10 +664,16 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             totalGas += EVMSpvVaultContract.GasCosts.FRONT_EXECUTION_SCHEDULE;
         return totalGas;
     }
+    /**
+     * @inheritDoc
+     */
     async getClaimFee(signer, vault, withdrawalData, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
         return EVMFees_1.EVMFees.getGasFee(this.getClaimGas(signer, vault, withdrawalData), feeRate);
     }
+    /**
+     * @inheritDoc
+     */
     async getFrontFee(signer, vault, withdrawalData, feeRate) {
         vault ?? (vault = EVMSpvVaultData_1.EVMSpvVaultData.randomVault());
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());

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

@@ -8,15 +8,27 @@ import { BitcoinVaultTransactionDataStruct } from "./SpvVaultContractTypechain";
  */
 export declare class EVMSpvWithdrawalData extends SpvWithdrawalTransactionData {
     private getExecutionHashWith0x;
+    /**
+     * @inheritDoc
+     */
     protected fromOpReturnData(data: Buffer): {
         recipient: string;
         rawAmounts: bigint[];
         executionHash?: string;
     };
+    /**
+     * @inheritDoc
+     */
     isRecipient(address: string): boolean;
+    /**
+     * @inheritDoc
+     */
     getFrontingId(): string;
     getTxHash(): string;
     getFrontingAmount(): bigint[];
+    /**
+     * @inheritDoc
+     */
     serialize(): any;
     serializeToStruct(): BitcoinVaultTransactionDataStruct;
 }

package/dist/evm/spv_swap/EVMSpvWithdrawalData.js

@@ -12,12 +12,21 @@ class EVMSpvWithdrawalData extends base_1.SpvWithdrawalTransactionData {
     getExecutionHashWith0x() {
         return this.executionHash == null ? ethers_1.ZeroHash : (this.executionHash.startsWith("0x") ? this.executionHash : "0x" + this.executionHash);
     }
+    /**
+     * @inheritDoc
+     */
     fromOpReturnData(data) {
         return EVMSpvVaultContract_1.EVMSpvVaultContract.fromOpReturnData(data);
     }
+    /**
+     * @inheritDoc
+     */
     isRecipient(address) {
         return this.getRecipient().toLowerCase() === address.toLowerCase();
     }
+    /**
+     * @inheritDoc
+     */
     getFrontingId() {
         const callerFee = this.getCallerFee();
         const frontingFee = this.getFrontingFee();
@@ -30,6 +39,9 @@ class EVMSpvWithdrawalData extends base_1.SpvWithdrawalTransactionData {
     getFrontingAmount() {
         return [this.rawAmounts[0] + this.getExecutionFee()[0], this.rawAmounts[1]];
     }
+    /**
+     * @inheritDoc
+     */
     serialize() {
         return {
             type: "EVM",

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

@@ -51,85 +51,118 @@ export declare class EVMSwapContract<ChainId extends string = string> extends EV
             [type in ChainSwapType]: string;
         };
     });
+    /**
+     * @inheritDoc
+     */
     start(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     preFetchForInitSignatureVerification(): Promise<EVMPreFetchVerification>;
+    /**
+     * @inheritDoc
+     */
     getInitSignature(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number, preFetchedBlockData?: never, feeRate?: string): Promise<SignatureData>;
+    /**
+     * @inheritDoc
+     */
     isValidInitAuthorization(sender: string, swapData: EVMSwapData, signature: SignatureData, feeRate?: string, preFetchedData?: EVMPreFetchVerification): Promise<Buffer | null>;
+    /**
+     * @inheritDoc
+     */
     getInitAuthorizationExpiry(swapData: EVMSwapData, signature: SignatureData, preFetchedData?: EVMPreFetchVerification): Promise<number>;
+    /**
+     * @inheritDoc
+     */
     isInitAuthorizationExpired(swapData: EVMSwapData, signature: SignatureData): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
     getRefundSignature(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number): Promise<SignatureData>;
+    /**
+     * @inheritDoc
+     */
     isValidRefundAuthorization(swapData: EVMSwapData, signature: SignatureData): Promise<Buffer | null>;
+    /**
+     * @inheritDoc
+     */
     getDataSignature(signer: EVMSigner, data: Buffer): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     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
+     * @inheritDoc
      */
     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
+     * @inheritDoc
      */
     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
+     * @inheritDoc
      */
     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
+     * @inheritDoc
      */
     isRequestRefundable(signer: string, data: EVMSwapData): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
     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
+     * @inheritDoc
      */
     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
+     * @inheritDoc
      */
     getHashForHtlc(paymentHash: Buffer): Buffer;
+    /**
+     * @inheritDoc
+     */
     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
+     * @inheritDoc
      */
     getCommitStatus(signer: string, data: EVMSwapData): Promise<SwapCommitState>;
+    /**
+     * @inheritDoc
+     */
     getCommitStatuses(request: {
         signer: string;
         swapData: EVMSwapData;
     }[]): Promise<{
         [p: string]: SwapCommitState;
     }>;
+    /**
+     * @inheritDoc
+     */
     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>;
+    /**
+     * @inheritDoc
+     */
     getBalance(signer: string, tokenAddress: string, inContract?: boolean): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     getIntermediaryData(address: string, token: string): Promise<{
         balance: bigint;
         reputation: IntermediaryReputationType;
     }>;
+    /**
+     * @inheritDoc
+     */
     getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
     getIntermediaryBalance(address: string, token: string): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     txsClaimWithSecret(signer: string | EVMSigner, swapData: EVMSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsClaimWithTxData(signer: string | EVMSigner, swapData: EVMSwapData, tx: {
         blockhash: string;
         confirmations: number;
@@ -137,12 +170,33 @@ export declare class EVMSwapContract<ChainId extends string = string> extends EV
         hex: string;
         height: number;
     }, requiredConfirmations: number, vout: number, commitedHeader?: EVMBtcStoredHeader, synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>, initAta?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsRefund(signer: string, swapData: EVMSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsRefundWithAuthorization(signer: string, swapData: EVMSwapData, signature: SignatureData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsInit(signer: string, swapData: EVMSwapData, signature: SignatureData, skipChecks?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * @inheritDoc
+     */
     claimWithSecret(signer: EVMSigner, swapData: EVMSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     claimWithTxData(signer: EVMSigner, swapData: EVMSwapData, tx: {
         blockhash: string;
         confirmations: number;
@@ -150,22 +204,52 @@ export declare class EVMSwapContract<ChainId extends string = string> extends EV
         hex: string;
         height: number;
     }, requiredConfirmations: number, vout: number, commitedHeader?: EVMBtcStoredHeader, synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     refund(signer: EVMSigner, swapData: EVMSwapData, check?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     refundWithAuthorization(signer: EVMSigner, swapData: EVMSwapData, signature: SignatureData, check?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     init(signer: EVMSigner, swapData: EVMSwapData, signature: SignatureData, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     withdraw(signer: EVMSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     deposit(signer: EVMSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     getInitFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     getRefundFeeRate(swapData: EVMSwapData): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     getClaimFeeRate(signer: string, swapData: EVMSwapData): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     getClaimFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
     /**
-     * Get the estimated fee of the commit transaction
+     * @inheritDoc
      */
     getCommitFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
     /**
-     * Get the estimated transaction fee of the refund transaction
+     * @inheritDoc
      */
     getRefundFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
 }