@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/dist/solana/swaps/modules/SolanaLpVault.js

@@ -1,171 +1,171 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaLpVault = void 0;
-const SolanaSwapModule_1 = require("../SolanaSwapModule");
-const SolanaAction_1 = require("../../chain/SolanaAction");
-const web3_js_1 = require("@solana/web3.js");
-const spl_token_1 = require("@solana/spl-token");
-const Utils_1 = require("../../../utils/Utils");
-const SolanaTokens_1 = require("../../chain/modules/SolanaTokens");
-class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
-    /**
-     * Action for withdrawing funds from the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @private
-     */
-    async Withdraw(signer, token, amount) {
-        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
-        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
-            .withdraw((0, Utils_1.toBN)(amount))
-            .accounts({
-            signer,
-            signerAta: ata,
-            userData: this.program._SwapUserVault(signer, token),
-            vault: this.program._SwapVault(token),
-            vaultAuthority: this.program._SwapVaultAuthority,
-            mint: token,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
-        })
-            .instruction(), SolanaLpVault.CUCosts.WITHDRAW);
-    }
-    /**
-     * Action for depositing funds to the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @private
-     */
-    async Deposit(signer, token, amount) {
-        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
-        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
-            .deposit((0, Utils_1.toBN)(amount))
-            .accounts({
-            signer,
-            signerAta: ata,
-            userData: this.program._SwapUserVault(signer, token),
-            vault: this.program._SwapVault(token),
-            vaultAuthority: this.program._SwapVaultAuthority,
-            mint: token,
-            systemProgram: web3_js_1.SystemProgram.programId,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
-        })
-            .instruction(), SolanaLpVault.CUCosts.DEPOSIT);
-    }
-    /**
-     * Returns intermediary's reputation & vault balance for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    async getIntermediaryData(address, token) {
-        const data = await this.swapProgram.account.userAccount.fetchNullable(this.program._SwapUserVault(address, token));
-        if (data == null)
-            return null;
-        const response = [];
-        for (let i = 0; i < data.successVolume.length; i++) {
-            response[i] = {
-                successVolume: data.successVolume[i],
-                successCount: data.successCount[i],
-                failVolume: data.failVolume[i],
-                failCount: data.failCount[i],
-                coopCloseVolume: data.coopCloseVolume[i],
-                coopCloseCount: data.coopCloseCount[i]
-            };
-        }
-        return {
-            balance: (0, Utils_1.toBigInt)(data.amount),
-            reputation: response
-        };
-    }
-    /**
-     * Returns intermediary's reputation for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    async getIntermediaryReputation(address, token) {
-        const intermediaryData = await this.getIntermediaryData(address, token);
-        return intermediaryData?.reputation ?? null;
-    }
-    /**
-     * Returns the balance of the token an intermediary has in his LP vault
-     *
-     * @param address
-     * @param token
-     */
-    async getIntermediaryBalance(address, token) {
-        const intermediaryData = await this.getIntermediaryData(address, token);
-        const balance = intermediaryData?.balance ?? 0n;
-        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: " + token.toString() +
-            " address: " + address + " amount: " + balance.toString());
-        return balance;
-    }
-    /**
-     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
-     *  WSOL to SOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    async txsWithdraw(signer, token, amount, feeRate) {
-        const ata = await (0, spl_token_1.getAssociatedTokenAddress)(token, signer);
-        feeRate = feeRate || await this.getFeeRate(signer, token);
-        const action = new SolanaAction_1.SolanaAction(signer, this.root);
-        if (!await this.root.Tokens.ataExists(ata)) {
-            action.add(this.root.Tokens.InitAta(signer, signer, token));
-        }
-        action.add(await this.Withdraw(signer, token, amount));
-        const shouldUnwrap = token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS);
-        if (shouldUnwrap)
-            action.add(this.root.Tokens.Unwrap(signer));
-        this.logger.debug("txsWithdraw(): withdraw TX created, token: " + token.toString() +
-            " amount: " + amount.toString(10) + " unwrapping: " + shouldUnwrap);
-        return [await action.tx(feeRate)];
-    }
-    /**
-     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    async txsDeposit(signer, token, amount, feeRate) {
-        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
-        feeRate = feeRate || await this.getFeeRate(signer, token);
-        const action = new SolanaAction_1.SolanaAction(signer, this.root);
-        let wrapping = false;
-        if (token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS)) {
-            const account = await this.root.Tokens.getATAOrNull(ata);
-            let balance = account == null ? 0n : account.amount;
-            if (balance < amount) {
-                action.add(this.root.Tokens.Wrap(signer, amount - balance, account == null));
-                wrapping = true;
-            }
-        }
-        action.addAction(await this.Deposit(signer, token, amount));
-        this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
-            " amount: " + amount.toString(10) + " wrapping: " + wrapping);
-        return [await action.tx(feeRate)];
-    }
-    getFeeRate(signer, token) {
-        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
-        return this.root.Fees.getFeeRate([
-            signer,
-            ata,
-            this.program._SwapUserVault(signer, token),
-            this.program._SwapVault(token)
-        ]);
-    }
-}
-exports.SolanaLpVault = SolanaLpVault;
-SolanaLpVault.CUCosts = {
-    WITHDRAW: 50000,
-    DEPOSIT: 50000
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaLpVault = void 0;
+const SolanaSwapModule_1 = require("../SolanaSwapModule");
+const SolanaAction_1 = require("../../chain/SolanaAction");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const Utils_1 = require("../../../utils/Utils");
+const SolanaTokens_1 = require("../../chain/modules/SolanaTokens");
+class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @private
+     */
+    async Withdraw(signer, token, amount) {
+        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
+            .withdraw((0, Utils_1.toBN)(amount))
+            .accounts({
+            signer,
+            signerAta: ata,
+            userData: this.program._SwapUserVault(signer, token),
+            vault: this.program._SwapVault(token),
+            vaultAuthority: this.program._SwapVaultAuthority,
+            mint: token,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+        })
+            .instruction(), SolanaLpVault.CUCosts.WITHDRAW);
+    }
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @private
+     */
+    async Deposit(signer, token, amount) {
+        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
+            .deposit((0, Utils_1.toBN)(amount))
+            .accounts({
+            signer,
+            signerAta: ata,
+            userData: this.program._SwapUserVault(signer, token),
+            vault: this.program._SwapVault(token),
+            vaultAuthority: this.program._SwapVaultAuthority,
+            mint: token,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+        })
+            .instruction(), SolanaLpVault.CUCosts.DEPOSIT);
+    }
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    async getIntermediaryData(address, token) {
+        const data = await this.swapProgram.account.userAccount.fetchNullable(this.program._SwapUserVault(address, token));
+        if (data == null)
+            return null;
+        const response = [];
+        for (let i = 0; i < data.successVolume.length; i++) {
+            response[i] = {
+                successVolume: data.successVolume[i],
+                successCount: data.successCount[i],
+                failVolume: data.failVolume[i],
+                failCount: data.failCount[i],
+                coopCloseVolume: data.coopCloseVolume[i],
+                coopCloseCount: data.coopCloseCount[i]
+            };
+        }
+        return {
+            balance: (0, Utils_1.toBigInt)(data.amount),
+            reputation: response
+        };
+    }
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    async getIntermediaryReputation(address, token) {
+        const intermediaryData = await this.getIntermediaryData(address, token);
+        return intermediaryData?.reputation ?? null;
+    }
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    async getIntermediaryBalance(address, token) {
+        const intermediaryData = await this.getIntermediaryData(address, token);
+        const balance = intermediaryData?.balance ?? 0n;
+        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: " + token.toString() +
+            " address: " + address + " amount: " + balance.toString());
+        return balance;
+    }
+    /**
+     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
+     *  WSOL to SOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    async txsWithdraw(signer, token, amount, feeRate) {
+        const ata = await (0, spl_token_1.getAssociatedTokenAddress)(token, signer);
+        feeRate = feeRate || await this.getFeeRate(signer, token);
+        const action = new SolanaAction_1.SolanaAction(signer, this.root);
+        if (!await this.root.Tokens.ataExists(ata)) {
+            action.add(this.root.Tokens.InitAta(signer, signer, token));
+        }
+        action.add(await this.Withdraw(signer, token, amount));
+        const shouldUnwrap = token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS);
+        if (shouldUnwrap)
+            action.add(this.root.Tokens.Unwrap(signer));
+        this.logger.debug("txsWithdraw(): withdraw TX created, token: " + token.toString() +
+            " amount: " + amount.toString(10) + " unwrapping: " + shouldUnwrap);
+        return [await action.tx(feeRate)];
+    }
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    async txsDeposit(signer, token, amount, feeRate) {
+        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+        feeRate = feeRate || await this.getFeeRate(signer, token);
+        const action = new SolanaAction_1.SolanaAction(signer, this.root);
+        let wrapping = false;
+        if (token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS)) {
+            const account = await this.root.Tokens.getATAOrNull(ata);
+            let balance = account == null ? 0n : account.amount;
+            if (balance < amount) {
+                action.add(this.root.Tokens.Wrap(signer, amount - balance, account == null));
+                wrapping = true;
+            }
+        }
+        action.addAction(await this.Deposit(signer, token, amount));
+        this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
+            " amount: " + amount.toString(10) + " wrapping: " + wrapping);
+        return [await action.tx(feeRate)];
+    }
+    getFeeRate(signer, token) {
+        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+        return this.root.Fees.getFeeRate([
+            signer,
+            ata,
+            this.program._SwapUserVault(signer, token),
+            this.program._SwapVault(token)
+        ]);
+    }
+}
+exports.SolanaLpVault = SolanaLpVault;
+SolanaLpVault.CUCosts = {
+    WITHDRAW: 50000,
+    DEPOSIT: 50000
+};

package/dist/solana/swaps/modules/SwapClaim.d.ts

@@ -1,126 +1,126 @@
-import { SolanaSwapModule } from "../SolanaSwapModule";
-import { SolanaSwapData } from "../SolanaSwapData";
-import { RelaySynchronizer } from "@atomiqlabs/base";
-import { PublicKey } from "@solana/web3.js";
-import { SolanaTx } from "../../chain/modules/SolanaTransactions";
-import { SolanaBtcStoredHeader } from "../../btcrelay/headers/SolanaBtcStoredHeader";
-import { SolanaBtcRelay } from "../../btcrelay/SolanaBtcRelay";
-import { SolanaSwapProgram } from "../SolanaSwapProgram";
-import { SolanaSigner } from "../../wallet/SolanaSigner";
-import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
-export declare class SwapClaim extends SolanaSwapModule {
-    private static readonly CUCosts;
-    readonly btcRelay: SolanaBtcRelay<any>;
-    /**
-     * Claim action which uses the provided hex encoded secret for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param secret
-     * @private
-     */
-    private Claim;
-    /**
-     * Verify and claim action required for BTC on-chain swaps verified through btc relay, adds the btc relay verify
-     *  instruction to the 0th index in the transaction, also intentionally sets compute budget to null such that no
-     *  compute budget instruction is added, since that takes up too much space and txs are limited to 1232 bytes
-     *
-     * @param signer
-     * @param swapData
-     * @param storeDataKey
-     * @param merkleProof
-     * @param commitedHeader
-     * @private
-     */
-    private VerifyAndClaim;
-    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, btcRelay: SolanaBtcRelay<any>);
-    /**
-     * Gets the compute budget required for claiming the swap
-     *
-     * @param swapData
-     * @private
-     */
-    private getComputeBudget;
-    /**
-     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
-     *  requiredConfirmations
-     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
-     *  current chain tip & adds them to the txs array
-     *
-     * @param signer
-     * @param txBlockheight transaction blockheight
-     * @param requiredConfirmations required confirmation for the swap to be claimable with that TX
-     * @param blockhash blockhash of the block which includes the transaction
-     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
-     *  txns are added here
-     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
-     *  to the required blockheight
-     * @private
-     */
-    private getCommitedHeaderAndSynchronize;
-    /**
-     * Adds the transactions required for initialization and writing of transaction data to the data account
-     *
-     * @param signer
-     * @param tx transaction to be written
-     * @param vout vout of the transaction to use to satisfy swap conditions
-     * @param feeRate fee rate for the transactions
-     * @param txs solana transaction array, init & write transactions are added here
-     * @private
-     * @returns {Promise<PublicKey>} publicKey/address of the data account
-     */
-    private addTxsWriteTransactionData;
-    /**
-     * Checks whether we should unwrap the WSOL to SOL when claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @private
-     */
-    private shouldUnwrap;
-    /**
-     * Creates transactions claiming the swap using a secret (for HTLC swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param secret hex encoded secret pre-image to the HTLC hash
-     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
-     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
-     * @param initAta whether to init the claimer's ATA if it doesn't exist
-     * @param feeRate fee rate to use for the transaction
-     * @param skipAtaCheck whether to check if ATA exists
-     */
-    txsClaimWithSecret(signer: PublicKey, swapData: SolanaSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<SolanaTx[]>;
-    /**
-     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param tx bitcoin transaction that satisfies the swap condition
-     * @param vout vout of the bitcoin transaction that satisfies the swap condition
-     * @param commitedHeader commited header data from btc relay (fetched internally if null)
-     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
-     * @param initAta whether to initialize claimer's ATA
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsClaimWithTxData(signer: PublicKey | SolanaSigner, swapData: SolanaSwapData, tx: {
-        blockhash: string;
-        txid: string;
-        hex: string;
-        height: number;
-    }, vout: number, commitedHeader?: SolanaBtcStoredHeader | null, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, feeRate?: string): Promise<{
-        txs: SolanaTx[];
-        claimTxIndex: number;
-        storageAcc: PublicKey;
-    }>;
-    getClaimFeeRate(signer: PublicKey, swapData: SolanaSwapData): Promise<string>;
-    /**
-     * Get the estimated solana transaction fee of the claim transaction in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
-     */
-    getClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
-    /**
-     * Get the estimated solana transaction fee of the claim transaction, without
-     */
-    getRawClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
-}
+import { SolanaSwapModule } from "../SolanaSwapModule";
+import { SolanaSwapData } from "../SolanaSwapData";
+import { RelaySynchronizer } from "@atomiqlabs/base";
+import { PublicKey } from "@solana/web3.js";
+import { SolanaTx } from "../../chain/modules/SolanaTransactions";
+import { SolanaBtcStoredHeader } from "../../btcrelay/headers/SolanaBtcStoredHeader";
+import { SolanaBtcRelay } from "../../btcrelay/SolanaBtcRelay";
+import { SolanaSwapProgram } from "../SolanaSwapProgram";
+import { SolanaSigner } from "../../wallet/SolanaSigner";
+import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
+export declare class SwapClaim extends SolanaSwapModule {
+    private static readonly CUCosts;
+    readonly btcRelay: SolanaBtcRelay<any>;
+    /**
+     * Claim action which uses the provided hex encoded secret for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param secret
+     * @private
+     */
+    private Claim;
+    /**
+     * Verify and claim action required for BTC on-chain swaps verified through btc relay, adds the btc relay verify
+     *  instruction to the 0th index in the transaction, also intentionally sets compute budget to null such that no
+     *  compute budget instruction is added, since that takes up too much space and txs are limited to 1232 bytes
+     *
+     * @param signer
+     * @param swapData
+     * @param storeDataKey
+     * @param merkleProof
+     * @param commitedHeader
+     * @private
+     */
+    private VerifyAndClaim;
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, btcRelay: SolanaBtcRelay<any>);
+    /**
+     * Gets the compute budget required for claiming the swap
+     *
+     * @param swapData
+     * @private
+     */
+    private getComputeBudget;
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param txBlockheight transaction blockheight
+     * @param requiredConfirmations required confirmation for the swap to be claimable with that TX
+     * @param blockhash blockhash of the block which includes the transaction
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @private
+     */
+    private getCommitedHeaderAndSynchronize;
+    /**
+     * Adds the transactions required for initialization and writing of transaction data to the data account
+     *
+     * @param signer
+     * @param tx transaction to be written
+     * @param vout vout of the transaction to use to satisfy swap conditions
+     * @param feeRate fee rate for the transactions
+     * @param txs solana transaction array, init & write transactions are added here
+     * @private
+     * @returns {Promise<PublicKey>} publicKey/address of the data account
+     */
+    private addTxsWriteTransactionData;
+    /**
+     * Checks whether we should unwrap the WSOL to SOL when claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @private
+     */
+    private shouldUnwrap;
+    /**
+     * Creates transactions claiming the swap using a secret (for HTLC swaps)
+     *
+     * @param signer
+     * @param swapData swap to claim
+     * @param secret hex encoded secret pre-image to the HTLC hash
+     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
+     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
+     * @param initAta whether to init the claimer's ATA if it doesn't exist
+     * @param feeRate fee rate to use for the transaction
+     * @param skipAtaCheck whether to check if ATA exists
+     */
+    txsClaimWithSecret(signer: PublicKey, swapData: SolanaSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<SolanaTx[]>;
+    /**
+     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
+     *
+     * @param signer
+     * @param swapData swap to claim
+     * @param tx bitcoin transaction that satisfies the swap condition
+     * @param vout vout of the bitcoin transaction that satisfies the swap condition
+     * @param commitedHeader commited header data from btc relay (fetched internally if null)
+     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
+     * @param initAta whether to initialize claimer's ATA
+     * @param feeRate fee rate to be used for the transactions
+     */
+    txsClaimWithTxData(signer: PublicKey | SolanaSigner, swapData: SolanaSwapData, tx: {
+        blockhash: string;
+        txid: string;
+        hex: string;
+        height: number;
+    }, vout: number, commitedHeader?: SolanaBtcStoredHeader | null, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, feeRate?: string): Promise<{
+        txs: SolanaTx[];
+        claimTxIndex: number;
+        storageAcc: PublicKey;
+    }>;
+    getClaimFeeRate(signer: PublicKey, swapData: SolanaSwapData): Promise<string>;
+    /**
+     * Get the estimated solana transaction fee of the claim transaction in the worst case scenario in case where the
+     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     */
+    getClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+    /**
+     * Get the estimated solana transaction fee of the claim transaction, without
+     */
+    getRawClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+}