@atomiqlabs/chain-evm 2.0.7 → 2.0.9

package/src/evm/spv_swap/EVMSpvVaultContract.ts

@@ -171,11 +171,17 @@ export class EVMSpvVaultContract<ChainId extends string>
         return tx;
     }
 
+    /**
+     * @inheritDoc
+     */
     async checkWithdrawalTx(tx: SpvWithdrawalTransactionData): Promise<void> {
         const result = await this.contract.parseBitcoinTx(Buffer.from(tx.btcTx.hex, "hex"));
         if(result==null) throw new Error("Failed to parse transaction!");
     }
 
+    /**
+     * @inheritDoc
+     */
     createVaultData(
         owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]
     ): Promise<EVMSpvVaultData> {
@@ -208,12 +214,18 @@ export class EVMSpvVaultContract<ChainId extends string>
     }
 
     //Getters
+    /**
+     * @inheritDoc
+     */
     async getFronterAddress(owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData): Promise<string | null> {
         const frontingAddress = await this.contract.getFronterById(owner, vaultId, "0x"+withdrawal.getFrontingId());
         if(frontingAddress===ZeroAddress) return null;
         return frontingAddress;
     }
 
+    /**
+     * @inheritDoc
+     */
     async getFronterAddresses(withdrawals: {owner: string, vaultId: bigint, withdrawal: EVMSpvWithdrawalData}[]): Promise<{[btcTxId: string]: string | null}> {
         const result: {
             [btcTxId: string]: string | null
@@ -235,6 +247,9 @@ export class EVMSpvVaultContract<ChainId extends string>
 
     private vaultParamsCache: PromiseLruCache<string, SpvVaultParametersStructOutput> = new PromiseLruCache<string, SpvVaultParametersStructOutput>(5000);
 
+    /**
+     * @inheritDoc
+     */
     async getVaultData(owner: string, vaultId: bigint): Promise<EVMSpvVaultData | null> {
         const vaultState = await this.contract.getVault(owner, vaultId);
 
@@ -264,6 +279,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return new EVMSpvVaultData(owner, vaultId, vaultState, vaultParams);
     }
 
+    /**
+     * @inheritDoc
+     */
     async getMultipleVaultData(vaults: {owner: string, vaultId: bigint}[]): Promise<{[owner: string]: {[vaultId: string]: EVMSpvVaultData | null}}> {
         const result: {[owner: string]: {[vaultId: string]: EVMSpvVaultData | null}} = {};
         let promises: Promise<void>[] = [];
@@ -282,6 +300,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return result;
     }
 
+    /**
+     * @inheritDoc
+     */
     async getVaultLatestUtxo(owner: string, vaultId: bigint): Promise<string | null> {
         const vaultState = await this.contract.getVault(owner, vaultId);
         const utxo = getVaultUtxoFromState(vaultState);
@@ -289,6 +310,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return utxo;
     }
 
+    /**
+     * @inheritDoc
+     */
     async getVaultLatestUtxos(vaults: {owner: string, vaultId: bigint}[]): Promise<{[owner: string]: {[vaultId: string]: string | null}}> {
         const result: {[owner: string]: {[vaultId: string]: string | null}} = {};
         let promises: Promise<void>[] = [];
@@ -307,6 +331,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return result;
     }
 
+    /**
+     * @inheritDoc
+     */
     async getAllVaults(owner?: string): Promise<EVMSpvVaultData[]> {
         const openedVaults = new Map<string, SpvVaultParametersStructOutput>();
         await this.Events.findInContractEventsForward(
@@ -376,6 +403,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         }
     }
 
+    /**
+     * @inheritDoc
+     */
     async getWithdrawalState(withdrawalTx: EVMSpvWithdrawalData, scStartHeight?: number): Promise<SpvWithdrawalState> {
         const txHash = Buffer.from(withdrawalTx.getTxId(), "hex").reverse();
 
@@ -413,6 +443,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return result;
     }
 
+    /**
+     * @inheritDoc
+     */
     async getWithdrawalStates(withdrawalTxs: {withdrawal: EVMSpvWithdrawalData, scStartBlockheight?: number}[]): Promise<{[btcTxId: string]: SpvWithdrawalState}> {
         const result: {[btcTxId: string]: SpvWithdrawalState} = {};
 
@@ -490,11 +523,17 @@ export class EVMSpvVaultContract<ChainId extends string>
         return result;
     }
 
+    /**
+     * @inheritDoc
+     */
     getWithdrawalData(btcTx: BtcTx): Promise<EVMSpvWithdrawalData> {
         return Promise.resolve(new EVMSpvWithdrawalData(btcTx));
     }
 
     //OP_RETURN data encoding/decoding
+    /**
+     * @inheritDoc
+     */
     fromOpReturnData(data: Buffer): { recipient: string; rawAmounts: bigint[]; executionHash?: string } {
         return EVMSpvVaultContract.fromOpReturnData(data);
     }
@@ -524,6 +563,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return {executionHash, rawAmounts: [rawAmount0, rawAmount1], recipient: getAddress(recipient)};
     }
 
+    /**
+     * @inheritDoc
+     */
     toOpReturnData(recipient: string, rawAmounts: bigint[], executionHash?: string): Buffer {
         return EVMSpvVaultContract.toOpReturnData(recipient, rawAmounts, executionHash);
     }
@@ -553,24 +595,36 @@ export class EVMSpvVaultContract<ChainId extends string>
     }
 
     //Actions
+    /**
+     * @inheritDoc
+     */
     async claim(signer: EVMSigner, vault: EVMSpvVaultData, txs: {tx: EVMSpvWithdrawalData, storedHeader?: EVMBtcStoredHeader}[], synchronizer?: RelaySynchronizer<any, any, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string> {
         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: EVMSigner, vault: EVMSpvVaultData, rawAmounts: bigint[], txOptions?: TransactionConfirmationOptions): Promise<string> {
         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: EVMSigner, vault: EVMSpvVaultData, realWithdrawalTx: EVMSpvWithdrawalData, withdrawSequence: number, txOptions?: TransactionConfirmationOptions): Promise<string> {
         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: EVMSigner, vault: EVMSpvVaultData, txOptions?: TransactionConfirmationOptions): Promise<string> {
         const result = await this.txsOpen(signer.getAddress(), vault, txOptions?.feeRate);
         const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
@@ -578,6 +632,9 @@ export class EVMSpvVaultContract<ChainId extends string>
     }
 
     //Transactions
+    /**
+     * @inheritDoc
+     */
     async txsClaim(
         signer: string, vault: EVMSpvVaultData, txs: {
             tx: EVMSpvWithdrawalData,
@@ -629,6 +686,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return evmTxs;
     }
 
+    /**
+     * @inheritDoc
+     */
     async txsDeposit(signer: string, vault: EVMSpvVaultData, rawAmounts: bigint[], feeRate?: string): Promise<EVMTx[]> {
         if(!vault.isOpened()) throw new Error("Cannot deposit to a closed vault!");
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -668,6 +728,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return txs;
     }
 
+    /**
+     * @inheritDoc
+     */
     async txsFrontLiquidity(signer: string, vault: EVMSpvVaultData, realWithdrawalTx: EVMSpvWithdrawalData, withdrawSequence: number, feeRate?: string): Promise<EVMTx[]> {
         if(!vault.isOpened()) throw new Error("Cannot front on a closed vault!");
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -709,6 +772,9 @@ export class EVMSpvVaultContract<ChainId extends string>
         return txs;
     }
 
+    /**
+     * @inheritDoc
+     */
     async txsOpen(signer: string, vault: EVMSpvVaultData, feeRate?: string): Promise<EVMTx[]> {
         if(vault.isOpened()) throw new Error("Cannot open an already opened vault!");
         feeRate ??= await this.Chain.Fees.getFeeRate();
@@ -759,11 +825,17 @@ export class EVMSpvVaultContract<ChainId extends string>
         return totalGas;
     }
 
+    /**
+     * @inheritDoc
+     */
     async getClaimFee(signer: string, vault?: EVMSpvVaultData, withdrawalData?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
         return EVMFees.getGasFee(this.getClaimGas(signer, vault, withdrawalData), feeRate);
     }
 
+    /**
+     * @inheritDoc
+     */
     async getFrontFee(signer: string, vault?: EVMSpvVaultData, withdrawalData?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint> {
         vault ??= EVMSpvVaultData.randomVault();
         feeRate ??= await this.Chain.Fees.getFeeRate();

package/src/evm/spv_swap/EVMSpvWithdrawalData.ts

@@ -13,14 +13,23 @@ export class EVMSpvWithdrawalData extends SpvWithdrawalTransactionData {
         return this.executionHash==null ? ZeroHash : (this.executionHash.startsWith("0x") ? this.executionHash : "0x"+this.executionHash)
     }
 
+    /**
+     * @inheritDoc
+     */
     protected fromOpReturnData(data: Buffer): { recipient: string; rawAmounts: bigint[]; executionHash?: string } {
         return EVMSpvVaultContract.fromOpReturnData(data);
     }
 
+    /**
+     * @inheritDoc
+     */
     isRecipient(address: string): boolean {
         return this.getRecipient().toLowerCase()===address.toLowerCase();
     }
 
+    /**
+     * @inheritDoc
+     */
     getFrontingId(): string {
         const callerFee = this.getCallerFee();
         const frontingFee = this.getFrontingFee();
@@ -42,6 +51,9 @@ export class EVMSpvWithdrawalData extends SpvWithdrawalTransactionData {
         return [this.rawAmounts[0] + this.getExecutionFee()[0], this.rawAmounts[1]];
     }
 
+    /**
+     * @inheritDoc
+     */
     serialize(): any {
         return {
             type: "EVM",

package/src/evm/swaps/EVMSwapContract.ts

@@ -109,43 +109,73 @@ export class EVMSwapContract<ChainId extends string = string>
         this.refundHandlersByAddress[this.timelockRefundHandler.address.toLowerCase()] = this.timelockRefundHandler;
     }
 
+    /**
+     * @inheritDoc
+     */
     async start(): Promise<void> {
     }
 
     ////////////////////////////////////////////
     //// Signatures
+    /**
+     * @inheritDoc
+     */
     preFetchForInitSignatureVerification(): Promise<EVMPreFetchVerification> {
         return this.Init.preFetchForInitSignatureVerification();
     }
 
+    /**
+     * @inheritDoc
+     */
     getInitSignature(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number, preFetchedBlockData?: never, feeRate?: string): Promise<SignatureData> {
         return this.Init.signSwapInitialization(signer, swapData, authorizationTimeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     isValidInitAuthorization(sender: string, swapData: EVMSwapData, signature: SignatureData, feeRate?: string, preFetchedData?: EVMPreFetchVerification): Promise<Buffer | null> {
         return this.Init.isSignatureValid(sender, swapData, signature.timeout, signature.prefix, signature.signature, preFetchedData);
     }
 
+    /**
+     * @inheritDoc
+     */
     getInitAuthorizationExpiry(swapData: EVMSwapData, signature: SignatureData, preFetchedData?: EVMPreFetchVerification): Promise<number> {
         return this.Init.getSignatureExpiry(signature.timeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     isInitAuthorizationExpired(swapData: EVMSwapData, signature: SignatureData): Promise<boolean> {
         return this.Init.isSignatureExpired(signature.timeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     getRefundSignature(signer: EVMSigner, swapData: EVMSwapData, authorizationTimeout: number): Promise<SignatureData> {
         return this.Refund.signSwapRefund(signer, swapData, authorizationTimeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     isValidRefundAuthorization(swapData: EVMSwapData, signature: SignatureData): Promise<Buffer |  null> {
         return this.Refund.isSignatureValid(swapData, signature.timeout, signature.prefix, signature.signature);
     }
 
+    /**
+     * @inheritDoc
+     */
     getDataSignature(signer: EVMSigner, data: Buffer): Promise<string> {
         return this.Chain.Signatures.getDataSignature(signer, data);
     }
 
+    /**
+     * @inheritDoc
+     */
     isValidDataSignature(data: Buffer, signature: string, publicKey: string): Promise<boolean> {
         return this.Chain.Signatures.isValidDataSignature(data, signature, publicKey);
     }
@@ -153,10 +183,7 @@ export class EVMSwapContract<ChainId extends string = string>
     ////////////////////////////////////////////
     //// Swap data utils
     /**
-     * Checks whether the claim is claimable by us, that means not expired, we are claimer & the swap is commited
-     *
-     * @param signer
-     * @param data
+     * @inheritDoc
      */
     async isClaimable(signer: string, data: EVMSwapData): Promise<boolean> {
         if(!data.isClaimer(signer)) return false;
@@ -165,9 +192,7 @@ export class EVMSwapContract<ChainId extends string = string>
     }
 
     /**
-     * Checks whether a swap is commited, i.e. the swap still exists on-chain and was not claimed nor refunded
-     *
-     * @param swapData
+     * @inheritDoc
      */
     async isCommited(swapData: EVMSwapData): Promise<boolean> {
         const data = await this.contract.getHashState("0x"+swapData.getEscrowHash());
@@ -175,11 +200,7 @@ export class EVMSwapContract<ChainId extends string = string>
     }
 
     /**
-     * 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> {
         let currentTimestamp: bigint = BigInt(Math.floor(Date.now()/1000));
@@ -189,11 +210,7 @@ export class EVMSwapContract<ChainId extends string = string>
     }
 
     /**
-     * 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
      */
     async isRequestRefundable(signer: string, data: EVMSwapData): Promise<boolean> {
         //Swap can only be refunded by the offerer
@@ -202,6 +219,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return await this.isCommited(data);
     }
 
+    /**
+     * @inheritDoc
+     */
     getHashForTxId(txId: string, confirmations: number) {
         const chainTxIdHandler = this.claimHandlersBySwapType[ChainSwapType.CHAIN_TXID];
         if(chainTxIdHandler==null) throw new Error("Claim handler for CHAIN_TXID not found!");
@@ -213,12 +233,7 @@ export class EVMSwapContract<ChainId extends string = string>
     }
 
     /**
-     * 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 {
         let result: string;
@@ -246,9 +261,7 @@ export class EVMSwapContract<ChainId extends string = string>
     }
 
     /**
-     * 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 {
         const htlcHandler = this.claimHandlersBySwapType[ChainSwapType.HTLC];
@@ -256,6 +269,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return Buffer.from(htlcHandler.getCommitment(paymentHash).slice(2), "hex");
     }
 
+    /**
+     * @inheritDoc
+     */
     getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer {
         if(nonce==null) nonce = 0n;
         const txoHash = Buffer.from(sha256(Buffer.concat([
@@ -273,11 +289,7 @@ export class EVMSwapContract<ChainId extends string = string>
     ////////////////////////////////////////////
     //// Swap data getters
     /**
-     * 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
      */
     async getCommitStatus(signer: string, data: EVMSwapData): Promise<SwapCommitState> {
         const escrowHash = data.getEscrowHash();
@@ -342,6 +354,9 @@ export class EVMSwapContract<ChainId extends string = string>
         }
     }
 
+    /**
+     * @inheritDoc
+     */
     async getCommitStatuses(request: { signer: string; swapData: EVMSwapData }[]): Promise<{
         [p: string]: SwapCommitState
     }> {
@@ -365,6 +380,9 @@ export class EVMSwapContract<ChainId extends string = string>
 
     ////////////////////////////////////////////
     //// Swap data initializer
+    /**
+     * @inheritDoc
+     */
     createSwapData(
         type: ChainSwapType,
         offerer: string,
@@ -405,12 +423,18 @@ export class EVMSwapContract<ChainId extends string = string>
 
     ////////////////////////////////////////////
     //// Utils
+    /**
+     * @inheritDoc
+     */
     async getBalance(signer: string, tokenAddress: string, inContract?: boolean): Promise<bigint> {
         if(inContract) return await this.getIntermediaryBalance(signer, tokenAddress);
 
         return await this.Chain.getBalance(signer, tokenAddress);
     }
 
+    /**
+     * @inheritDoc
+     */
     getIntermediaryData(address: string, token: string): Promise<{
         balance: bigint,
         reputation: IntermediaryReputationType
@@ -418,6 +442,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return this.LpVault.getIntermediaryData(address, token);
     }
 
+    /**
+     * @inheritDoc
+     */
     getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType> {
         return this.LpVault.getIntermediaryReputation(address, token);
     }
@@ -428,6 +455,9 @@ export class EVMSwapContract<ChainId extends string = string>
 
     ////////////////////////////////////////////
     //// Transaction initializers
+    /**
+     * @inheritDoc
+     */
     async txsClaimWithSecret(
         signer: string | EVMSigner,
         swapData: EVMSwapData,
@@ -440,6 +470,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return this.Claim.txsClaimWithSecret(typeof(signer)==="string" ? signer : signer.getAddress(), swapData, secret, checkExpiry, feeRate)
     }
 
+    /**
+     * @inheritDoc
+     */
     async txsClaimWithTxData(
         signer: string | EVMSigner,
         swapData: EVMSwapData,
@@ -463,28 +496,46 @@ export class EVMSwapContract<ChainId extends string = string>
         );
     }
 
+    /**
+     * @inheritDoc
+     */
     txsRefund(signer: string, swapData: EVMSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<EVMTx[]> {
         return this.Refund.txsRefund(signer, swapData, check, feeRate);
     }
 
+    /**
+     * @inheritDoc
+     */
     txsRefundWithAuthorization(signer: string, swapData: EVMSwapData, signature: SignatureData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<EVMTx[]> {
         return this.Refund.txsRefundWithAuthorization(signer, swapData, signature.timeout, signature.prefix, signature.signature, check, feeRate);
     }
 
+    /**
+     * @inheritDoc
+     */
     txsInit(signer: string, swapData: EVMSwapData, signature: SignatureData, skipChecks?: boolean, feeRate?: string): Promise<EVMTx[]> {
         return this.Init.txsInit(signer, swapData, signature.timeout, signature.prefix, signature.signature, skipChecks, feeRate);
     }
 
+    /**
+     * @inheritDoc
+     */
     txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]> {
         return this.LpVault.txsWithdraw(signer, token, amount, feeRate);
     }
 
+    /**
+     * @inheritDoc
+     */
     txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<EVMTx[]> {
         return this.LpVault.txsDeposit(signer, token, amount, feeRate);
     }
 
     ////////////////////////////////////////////
     //// Executors
+    /**
+     * @inheritDoc
+     */
     async claimWithSecret(
         signer: EVMSigner,
         swapData: EVMSwapData,
@@ -498,6 +549,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return signature;
     }
 
+    /**
+     * @inheritDoc
+     */
     async claimWithTxData(
         signer: EVMSigner,
         swapData: EVMSwapData,
@@ -520,6 +574,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return txHashes[txHashes.length - 1];
     }
 
+    /**
+     * @inheritDoc
+     */
     async refund(
         signer: EVMSigner,
         swapData: EVMSwapData,
@@ -534,6 +591,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return signature;
     }
 
+    /**
+     * @inheritDoc
+     */
     async refundWithAuthorization(
         signer: EVMSigner,
         swapData: EVMSwapData,
@@ -549,6 +609,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return txSignature;
     }
 
+    /**
+     * @inheritDoc
+     */
     async init(
         signer: EVMSigner,
         swapData: EVMSwapData,
@@ -569,6 +632,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return txHashes[txHashes.length - 1];
     }
 
+    /**
+     * @inheritDoc
+     */
     async withdraw(
         signer: EVMSigner,
         token: string,
@@ -580,6 +646,9 @@ export class EVMSwapContract<ChainId extends string = string>
         return txId;
     }
 
+    /**
+     * @inheritDoc
+     */
     async deposit(
         signer: EVMSigner,
         token: string,
@@ -593,35 +662,50 @@ export class EVMSwapContract<ChainId extends string = string>
 
     ////////////////////////////////////////////
     //// Fees
+    /**
+     * @inheritDoc
+     */
     getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string> {
         return this.Chain.Fees.getFeeRate();
     }
 
+    /**
+     * @inheritDoc
+     */
     getInitFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string> {
         return this.Chain.Fees.getFeeRate();
     }
 
+    /**
+     * @inheritDoc
+     */
     getRefundFeeRate(swapData: EVMSwapData): Promise<string> {
         return this.Chain.Fees.getFeeRate();
     }
 
+    /**
+     * @inheritDoc
+     */
     getClaimFeeRate(signer: string, swapData: EVMSwapData): Promise<string> {
         return this.Chain.Fees.getFeeRate();
     }
 
+    /**
+     * @inheritDoc
+     */
     getClaimFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
         return this.Claim.getClaimFee(swapData, feeRate);
     }
 
     /**
-     * Get the estimated fee of the commit transaction
+     * @inheritDoc
      */
     getCommitFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
         return this.Init.getInitFee(swapData, feeRate);
     }
 
     /**
-     * Get the estimated transaction fee of the refund transaction
+     * @inheritDoc
      */
     getRefundFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
         return this.Refund.getRefundFee(swapData, feeRate);