@atomiqlabs/chain-solana 7.2.0

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

@@ -0,0 +1,255 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaDataAccount = exports.StoredDataAccount = void 0;
+const SolanaSwapModule_1 = require("../SolanaSwapModule");
+const web3_js_1 = require("@solana/web3.js");
+const SolanaAction_1 = require("../../base/SolanaAction");
+const Utils_1 = require("../../../utils/Utils");
+const randomBytes = require("randombytes");
+const SolanaSigner_1 = require("../../wallet/SolanaSigner");
+const BN = require("bn.js");
+class StoredDataAccount {
+    constructor(accountKeyOrData, owner) {
+        if (accountKeyOrData instanceof web3_js_1.PublicKey) {
+            this.accountKey = accountKeyOrData;
+            this.owner = owner;
+        }
+        else {
+            this.accountKey = new web3_js_1.PublicKey(accountKeyOrData.accountKey);
+            this.owner = new web3_js_1.PublicKey(accountKeyOrData.owner);
+        }
+    }
+    serialize() {
+        return {
+            accountKey: this.accountKey.toBase58(),
+            owner: this.owner.toBase58()
+        };
+    }
+}
+exports.StoredDataAccount = StoredDataAccount;
+class SolanaDataAccount extends SolanaSwapModule_1.SolanaSwapModule {
+    /**
+     * Action for initialization of the data account
+     *
+     * @param signer
+     * @param accountKey
+     * @param dataLength
+     * @private
+     */
+    InitDataAccount(signer, accountKey, dataLength) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountSize = 32 + dataLength;
+            const lamportsDeposit = yield (0, Utils_1.tryWithRetries)(() => this.connection.getMinimumBalanceForRentExemption(accountSize), this.retryPolicy);
+            return new SolanaAction_1.SolanaAction(signer, this.root, [
+                web3_js_1.SystemProgram.createAccount({
+                    fromPubkey: signer,
+                    newAccountPubkey: accountKey.publicKey,
+                    lamports: lamportsDeposit,
+                    space: accountSize,
+                    programId: this.program.programId
+                }),
+                yield this.program.methods
+                    .initData()
+                    .accounts({
+                    signer,
+                    data: accountKey.publicKey
+                })
+                    .instruction(),
+            ], SolanaDataAccount.CUCosts.DATA_CREATE, null, [accountKey]);
+        });
+    }
+    /**
+     * Action for closing the specific data account
+     *
+     * @param signer
+     * @param publicKey
+     */
+    CloseDataAccount(signer, publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new SolanaAction_1.SolanaAction(signer, this.root, yield this.program.methods
+                .closeData()
+                .accounts({
+                signer,
+                data: publicKey
+            })
+                .instruction(), SolanaDataAccount.CUCosts.DATA_REMOVE, yield this.root.Fees.getFeeRate([signer, publicKey]));
+        });
+    }
+    /**
+     * Action for writing data to a data account, writes up to sizeLimit starting from the offset position of the
+     *  provided writeData buffer
+     *
+     * @param signer
+     * @param accountKey account public key to write to
+     * @param writeData buffer holding the write data
+     * @param offset data from buffer starting at offset are written
+     * @param sizeLimit maximum amount of data to be written to the data account in this action
+     * @private
+     * @returns {Promise<{bytesWritten: number, action: SolanaAction}>} bytes written to the data account & action
+     */
+    WriteData(signer, accountKey, writeData, offset, sizeLimit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const writeLen = Math.min(writeData.length - offset, sizeLimit);
+            return {
+                bytesWritten: writeLen,
+                action: new SolanaAction_1.SolanaAction(signer, this.root, yield this.program.methods
+                    .writeData(offset, writeData.slice(offset, offset + writeLen))
+                    .accounts({
+                    signer,
+                    data: accountKey.publicKey
+                })
+                    .instruction(), SolanaDataAccount.CUCosts.DATA_WRITE)
+            };
+        });
+    }
+    constructor(root, storage) {
+        super(root);
+        this.SwapTxDataAlt = this.root.keypair((reversedTxId, signer) => [Buffer.from(signer.secretKey), reversedTxId]);
+        this.SwapTxDataAltBuffer = this.root.keypair((reversedTxId, secret) => [secret, reversedTxId]);
+        this.storage = storage;
+    }
+    /**
+     * Saves data account to the storage, the storage is required such that we are able to close the accounts later
+     *  manually in case the claim doesn't happen (expires due to fees, etc.)
+     *
+     * @param signer
+     * @param publicKey
+     * @private
+     */
+    saveDataAccount(signer, publicKey) {
+        return this.storage.saveData(publicKey.toBase58(), new StoredDataAccount(publicKey, signer));
+    }
+    /**
+     * Initializes the data account handler, loads the existing data accounts which should be checked and closed
+     */
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.storage.init();
+            const loadedData = yield this.storage.loadData(StoredDataAccount);
+            this.logger.info("init(): initialized & loaded stored data accounts, count: " + loadedData.length);
+        });
+    }
+    /**
+     * Removes data account from the list of accounts that should be checked for reclaiming the locked SOL, this should
+     *  be called after a batch of transactions claiming the swap was confirmed
+     *
+     * @param publicKey
+     */
+    removeDataAccount(publicKey) {
+        return this.storage.removeData(publicKey.toBase58());
+    }
+    getDataAccountsInfo(signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const closePublicKeys = [];
+            let totalLocked = new BN(0);
+            for (let key in this.storage.data) {
+                const { accountKey, owner } = this.storage.data[key];
+                if (!owner.equals(signer))
+                    continue;
+                try {
+                    const fetchedDataAccount = yield this.connection.getAccountInfo(accountKey);
+                    if (fetchedDataAccount == null) {
+                        yield this.removeDataAccount(accountKey);
+                        continue;
+                    }
+                    closePublicKeys.push(accountKey);
+                    totalLocked = totalLocked.add(new BN(fetchedDataAccount.lamports));
+                }
+                catch (e) { }
+            }
+            return {
+                closePublicKeys,
+                count: closePublicKeys.length,
+                totalValue: totalLocked
+            };
+        });
+    }
+    /**
+     * Sweeps all old data accounts, reclaiming the SOL locked in the PDAs
+     */
+    sweepDataAccounts(signer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { closePublicKeys, totalValue } = yield this.getDataAccountsInfo(signer.getPublicKey());
+            if (closePublicKeys.length === 0) {
+                this.logger.debug("sweepDataAccounts(): no old data accounts found, no need to close any!");
+                return;
+            }
+            this.logger.debug("sweepDataAccounts(): closing old data accounts: ", closePublicKeys);
+            let txns = [];
+            for (let publicKey of closePublicKeys) {
+                yield (yield this.CloseDataAccount(signer.getPublicKey(), publicKey)).addToTxs(txns);
+            }
+            const result = yield this.root.Transactions.sendAndConfirm(signer, txns, true, null, true);
+            this.logger.info("sweepDataAccounts(): old data accounts closed: " +
+                closePublicKeys.map(pk => pk.toBase58()).join());
+            for (let publicKey of closePublicKeys) {
+                yield this.removeDataAccount(publicKey);
+            }
+            return {
+                txIds: result,
+                count: closePublicKeys.length,
+                totalValue: totalValue
+            };
+        });
+    }
+    /**
+     * Adds the transactions writing (and also initializing if it doesn't exist) data to the data account
+     *
+     * @param signer
+     * @param reversedTxId reversed btc tx id is used to derive the data account address
+     * @param writeData full data to be written to the data account
+     * @param txs solana transactions array, where txns for writing & initializing will be added
+     * @param feeRate fee rate to use for the transactions
+     */
+    addTxsWriteData(signer, reversedTxId, writeData, txs, feeRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let txDataKey;
+            let fetchedDataAccount = null;
+            if (signer instanceof SolanaSigner_1.SolanaSigner && signer.keypair != null) {
+                txDataKey = this.SwapTxDataAlt(reversedTxId, signer.keypair);
+                fetchedDataAccount = yield (0, Utils_1.tryWithRetries)(() => this.connection.getAccountInfo(txDataKey.publicKey), this.retryPolicy);
+            }
+            else {
+                const secret = randomBytes(32);
+                txDataKey = this.SwapTxDataAltBuffer(reversedTxId, secret);
+            }
+            const signerKey = signer instanceof SolanaSigner_1.SolanaSigner ? signer.getPublicKey() : signer;
+            let pointer = 0;
+            if (fetchedDataAccount == null) {
+                const action = new SolanaAction_1.SolanaAction(signerKey, this.root);
+                action.add(yield this.InitDataAccount(signerKey, txDataKey, writeData.length));
+                const { bytesWritten, action: writeAction } = yield this.WriteData(signerKey, txDataKey, writeData, pointer, 420);
+                this.logger.debug("addTxsWriteData(): Write partial data (" + pointer + " .. " + (pointer + bytesWritten) + ")/" + writeData.length +
+                    " key: " + txDataKey.publicKey.toBase58());
+                pointer += bytesWritten;
+                action.add(writeAction);
+                yield action.addToTxs(txs, feeRate);
+                yield this.saveDataAccount(signerKey, txDataKey.publicKey);
+            }
+            while (pointer < writeData.length) {
+                const { bytesWritten, action } = yield this.WriteData(signerKey, txDataKey, writeData, pointer, 950);
+                this.logger.debug("addTxsWriteData(): Write partial data (" + pointer + " .. " + (pointer + bytesWritten) + ")/" + writeData.length +
+                    " key: " + txDataKey.publicKey.toBase58());
+                pointer += bytesWritten;
+                yield action.addToTxs(txs, feeRate);
+            }
+            return txDataKey.publicKey;
+        });
+    }
+}
+exports.SolanaDataAccount = SolanaDataAccount;
+SolanaDataAccount.CUCosts = {
+    DATA_REMOVE: 50000,
+    DATA_CREATE_AND_WRITE: 15000,
+    DATA_CREATE: 5000,
+    DATA_WRITE: 15000
+};

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

@@ -0,0 +1,72 @@
+import { SolanaSwapModule } from "../SolanaSwapModule";
+import * as BN from "bn.js";
+import { PublicKey } from "@solana/web3.js";
+import { SolanaTx } from "../../base/modules/SolanaTransactions";
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+export declare class SolanaLpVault extends SolanaSwapModule {
+    private static readonly CUCosts;
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Withdraw;
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Deposit;
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryData(address: PublicKey, token: PublicKey): Promise<{
+        balance: BN;
+        reputation: IntermediaryReputationType;
+    }>;
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryReputation(address: PublicKey, token: PublicKey): Promise<IntermediaryReputationType>;
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryBalance(address: PublicKey, token: PublicKey): Promise<BN>;
+    /**
+     * 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
+     */
+    txsWithdraw(signer: PublicKey, token: PublicKey, amount: BN, feeRate?: string): Promise<SolanaTx[]>;
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    txsDeposit(signer: PublicKey, token: PublicKey, amount: BN, feeRate?: string): Promise<SolanaTx[]>;
+    getFeeRate(signer: PublicKey, token: PublicKey): Promise<string>;
+}

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

@@ -0,0 +1,196 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaLpVault = void 0;
+const SolanaSwapModule_1 = require("../SolanaSwapModule");
+const SolanaAction_1 = require("../../base/SolanaAction");
+const BN = require("bn.js");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const Utils_1 = require("../../../utils/Utils");
+class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    Withdraw(signer, token, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+            return new SolanaAction_1.SolanaAction(signer, this.root, yield this.program.methods
+                .withdraw(new BN(amount))
+                .accounts({
+                signer,
+                signerAta: ata,
+                userData: this.root.SwapUserVault(signer, token),
+                vault: this.root.SwapVault(token),
+                vaultAuthority: this.root.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
+     * @constructor
+     * @private
+     */
+    Deposit(signer, token, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+            return new SolanaAction_1.SolanaAction(signer, this.root, yield this.program.methods
+                .deposit(new BN(amount))
+                .accounts({
+                signer,
+                signerAta: ata,
+                userData: this.root.SwapUserVault(signer, token),
+                vault: this.root.SwapVault(token),
+                vaultAuthority: this.root.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
+     */
+    getIntermediaryData(address, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.program.account.userAccount.fetchNullable(this.root.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: data.amount,
+                reputation: response
+            };
+        });
+    }
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryReputation(address, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const intermediaryData = yield this.getIntermediaryData(address, token);
+            return intermediaryData === null || intermediaryData === void 0 ? void 0 : intermediaryData.reputation;
+        });
+    }
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryBalance(address, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const intermediaryData = yield this.getIntermediaryData(address, token);
+            const balance = intermediaryData === null || intermediaryData === void 0 ? void 0 : intermediaryData.balance;
+            this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: " + token.toString() +
+                " address: " + address + " amount: " + (balance == null ? "null" : balance.toString()));
+            return intermediaryData === null || intermediaryData === void 0 ? void 0 : intermediaryData.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
+     */
+    txsWithdraw(signer, token, amount, feeRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ata = yield (0, spl_token_1.getAssociatedTokenAddress)(token, signer);
+            feeRate = feeRate || (yield this.getFeeRate(signer, token));
+            const action = new SolanaAction_1.SolanaAction(signer, this.root);
+            if (!(yield this.root.Tokens.ataExists(ata))) {
+                action.add(this.root.Tokens.InitAta(signer, signer, token));
+            }
+            action.add(yield this.Withdraw(signer, token, amount));
+            const shouldUnwrap = token.equals(this.root.Tokens.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 [yield 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
+     */
+    txsDeposit(signer, token, amount, feeRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+            feeRate = feeRate || (yield this.getFeeRate(signer, token));
+            const action = new SolanaAction_1.SolanaAction(signer, this.root);
+            let wrapping = false;
+            if (token.equals(this.root.Tokens.WSOL_ADDRESS)) {
+                const account = yield (0, Utils_1.tryWithRetries)(() => this.root.Tokens.getATAOrNull(ata), this.retryPolicy);
+                let balance = account == null ? new BN(0) : new BN(account.amount.toString());
+                if (balance.lt(amount)) {
+                    action.add(this.root.Tokens.Wrap(signer, amount.sub(balance), account == null));
+                    wrapping = true;
+                }
+            }
+            action.addAction(yield this.Deposit(signer, token, amount));
+            this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
+                " amount: " + amount.toString(10) + " wrapping: " + wrapping);
+            return [yield action.tx(feeRate)];
+        });
+    }
+    getFeeRate(signer, token) {
+        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
+        return this.root.Fees.getFeeRate([
+            signer,
+            ata,
+            this.root.SwapUserVault(signer, token),
+            this.root.SwapVault(token)
+        ]);
+    }
+}
+exports.SolanaLpVault = SolanaLpVault;
+SolanaLpVault.CUCosts = {
+    WITHDRAW: 50000,
+    DEPOSIT: 50000
+};

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

@@ -0,0 +1,129 @@
+import { SolanaSwapModule } from "../SolanaSwapModule";
+import { SolanaSwapData } from "../SolanaSwapData";
+import { RelaySynchronizer } from "@atomiqlabs/base";
+import { PublicKey } from "@solana/web3.js";
+import { SolanaTx } from "../../base/modules/SolanaTransactions";
+import { SolanaBtcStoredHeader } from "../../btcrelay/headers/SolanaBtcStoredHeader";
+import { SolanaBtcRelay } from "../../btcrelay/SolanaBtcRelay";
+import { SolanaSwapProgram } from "../SolanaSwapProgram";
+import * as BN from "bn.js";
+import { SolanaSigner } from "../../wallet/SolanaSigner";
+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
+     * @constructor
+     * @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
+     * @constructor
+     * @private
+     */
+    private VerifyAndClaim;
+    constructor(root: 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 blockheight blockheight of the bitcoin transaction
+     * @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 storageAccHolder an object holder filled in with the created data account where tx data is written
+     * @param feeRate fee rate to be used for the transactions
+     */
+    txsClaimWithTxData(signer: PublicKey | SolanaSigner, swapData: SolanaSwapData, blockheight: number, tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+    }, vout: number, commitedHeader?: SolanaBtcStoredHeader, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, storageAccHolder?: {
+        storageAcc: PublicKey;
+    }, feeRate?: string): Promise<SolanaTx[] | null>;
+    getClaimFeeRate(signer: PublicKey, swapData: SolanaSwapData): Promise<string>;
+    /**
+     * Get the estimated solana transaction fee of the claim transaction, this fee might be negative since it
+     *  includes the rebate for closing the swap PDA
+     */
+    getClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    /**
+     * 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)
+     */
+    getRawClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+}