@atomiqlabs/chain-solana 7.3.8 → 8.0.0-beta.0

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

@@ -6,7 +6,6 @@ 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;
@@ -107,11 +106,12 @@ export declare class SwapClaim extends SolanaSwapModule {
      * @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: {
+    txsClaimWithTxData(signer: PublicKey | SolanaSigner, swapData: SolanaSwapData, tx: {
         blockhash: string;
         confirmations: number;
         txid: string;
         hex: string;
+        height: number;
     }, vout: number, commitedHeader?: SolanaBtcStoredHeader, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, storageAccHolder?: {
         storageAcc: PublicKey;
     }, feeRate?: string): Promise<SolanaTx[] | null>;
@@ -120,9 +120,9 @@ export declare class SwapClaim extends SolanaSwapModule {
      * 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<BN>;
+    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<BN>;
+    getRawClaimFee(signer: PublicKey, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
 }

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

@@ -1,13 +1,4 @@
 "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.SwapClaim = void 0;
 const SolanaSwapModule_1 = require("../SolanaSwapModule");
@@ -16,35 +7,43 @@ const spl_token_1 = require("@solana/spl-token");
 const base_1 = require("@atomiqlabs/base");
 const web3_js_1 = require("@solana/web3.js");
 const Utils_1 = require("../../../utils/Utils");
-const BN = require("bn.js");
 const SolanaSigner_1 = require("../../wallet/SolanaSigner");
+const SolanaTokens_1 = require("../../base/modules/SolanaTokens");
+const BN = require("bn.js");
 class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
-    Claim(signer, swapData, secretOrDataKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isDataKey = typeof (secretOrDataKey) !== "string";
-            const accounts = {
-                signer,
-                initializer: swapData.isPayIn() ? swapData.offerer : swapData.claimer,
-                escrowState: this.root.SwapEscrowState(Buffer.from(swapData.paymentHash, "hex")),
-                ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
-                data: isDataKey ? secretOrDataKey : null,
-            };
-            let secretBuffer = isDataKey ?
-                Buffer.alloc(0) :
-                Buffer.from(secretOrDataKey, "hex");
-            if (swapData.isPayOut()) {
-                return new SolanaAction_1.SolanaAction(signer, this.root, yield this.program.methods
-                    .claimerClaimPayOut(secretBuffer)
-                    .accounts(Object.assign(Object.assign({}, accounts), { claimerAta: swapData.claimerAta, vault: this.root.SwapVault(swapData.token), vaultAuthority: this.root.SwapVaultAuthority, tokenProgram: spl_token_1.TOKEN_PROGRAM_ID }))
-                    .instruction(), this.getComputeBudget(swapData));
-            }
-            else {
-                return new SolanaAction_1.SolanaAction(signer, this.root, yield this.program.methods
-                    .claimerClaim(secretBuffer)
-                    .accounts(Object.assign(Object.assign({}, accounts), { claimerUserData: this.root.SwapUserVault(swapData.claimer, swapData.token) }))
-                    .instruction(), this.getComputeBudget(swapData));
-            }
-        });
+    async Claim(signer, swapData, secretOrDataKey) {
+        const isDataKey = typeof (secretOrDataKey) !== "string";
+        const accounts = {
+            signer,
+            initializer: swapData.isPayIn() ? swapData.offerer : swapData.claimer,
+            escrowState: this.root.SwapEscrowState(Buffer.from(swapData.paymentHash, "hex")),
+            ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            data: isDataKey ? secretOrDataKey : null,
+        };
+        let secretBuffer = isDataKey ?
+            Buffer.alloc(0) :
+            Buffer.from(secretOrDataKey, "hex");
+        if (swapData.isPayOut()) {
+            return new SolanaAction_1.SolanaAction(signer, this.root, await this.program.methods
+                .claimerClaimPayOut(secretBuffer)
+                .accounts({
+                ...accounts,
+                claimerAta: swapData.claimerAta,
+                vault: this.root.SwapVault(swapData.token),
+                vaultAuthority: this.root.SwapVaultAuthority,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            })
+                .instruction(), this.getComputeBudget(swapData));
+        }
+        else {
+            return new SolanaAction_1.SolanaAction(signer, this.root, await this.program.methods
+                .claimerClaim(secretBuffer)
+                .accounts({
+                ...accounts,
+                claimerUserData: this.root.SwapUserVault(swapData.claimer, swapData.token)
+            })
+                .instruction(), this.getComputeBudget(swapData));
+        }
     }
     /**
      * Verify and claim action required for BTC on-chain swaps verified through btc relay, adds the btc relay verify
@@ -59,13 +58,11 @@ class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
      * @constructor
      * @private
      */
-    VerifyAndClaim(signer, swapData, storeDataKey, merkleProof, commitedHeader) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const action = yield this.btcRelay.Verify(signer, merkleProof.reversedTxId, swapData.confirmations, merkleProof.pos, merkleProof.merkle, commitedHeader);
-            action.addAction(yield this.Claim(signer, swapData, storeDataKey));
-            action.computeBudget = null;
-            return action;
-        });
+    async VerifyAndClaim(signer, swapData, storeDataKey, merkleProof, commitedHeader) {
+        const action = await this.btcRelay.Verify(signer, merkleProof.reversedTxId, swapData.confirmations, merkleProof.pos, merkleProof.merkle, commitedHeader);
+        action.addAction(await this.Claim(signer, swapData, storeDataKey));
+        action.computeBudget = null;
+        return action;
     }
     constructor(root, btcRelay) {
         super(root);
@@ -101,26 +98,24 @@ class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
      *  to the required blockheight
      * @private
      */
-    getCommitedHeaderAndSynchronize(signer, txBlockheight, requiredConfirmations, blockhash, txs, synchronizer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const requiredBlockheight = txBlockheight + requiredConfirmations - 1;
-            const result = yield (0, Utils_1.tryWithRetries)(() => this.btcRelay.retrieveLogAndBlockheight({
-                blockhash: blockhash
-            }, requiredBlockheight), this.retryPolicy);
-            if (result != null)
-                return result.header;
-            //Need to synchronize
-            if (synchronizer == null)
-                return null;
-            //TODO: We don't have to synchronize to tip, only to our required blockheight
-            const resp = yield synchronizer.syncToLatestTxs(signer.toString());
-            this.logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, " +
-                "synchronizing ourselves in " + resp.txs.length + " txs");
-            this.logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ", resp.computedHeaderMap);
-            resp.txs.forEach(tx => txs.push(tx));
-            //Retrieve computed header
-            return resp.computedHeaderMap[txBlockheight];
-        });
+    async getCommitedHeaderAndSynchronize(signer, txBlockheight, requiredConfirmations, blockhash, txs, synchronizer) {
+        const requiredBlockheight = txBlockheight + requiredConfirmations - 1;
+        const result = await (0, Utils_1.tryWithRetries)(() => this.btcRelay.retrieveLogAndBlockheight({
+            blockhash: blockhash
+        }, requiredBlockheight), this.retryPolicy);
+        if (result != null)
+            return result.header;
+        //Need to synchronize
+        if (synchronizer == null)
+            return null;
+        //TODO: We don't have to synchronize to tip, only to our required blockheight
+        const resp = await synchronizer.syncToLatestTxs(signer.toString());
+        this.logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, " +
+            "synchronizing ourselves in " + resp.txs.length + " txs");
+        this.logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ", resp.computedHeaderMap);
+        resp.txs.forEach(tx => txs.push(tx));
+        //Retrieve computed header
+        return resp.computedHeaderMap[txBlockheight];
     }
     /**
      * Adds the transactions required for initialization and writing of transaction data to the data account
@@ -151,7 +146,7 @@ class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
      */
     shouldUnwrap(signer, swapData) {
         return swapData.isPayOut() &&
-            swapData.token.equals(this.root.Tokens.WSOL_ADDRESS) &&
+            swapData.token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS) &&
             swapData.claimer.equals(signer);
     }
     /**
@@ -166,33 +161,31 @@ class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
      * @param feeRate fee rate to use for the transaction
      * @param skipAtaCheck whether to check if ATA exists
      */
-    txsClaimWithSecret(signer, swapData, secret, checkExpiry, initAta, feeRate, skipAtaCheck) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //We need to be sure that this transaction confirms in time, otherwise we reveal the secret to the counterparty
-            // and won't claim the funds
-            if (checkExpiry && this.root.isExpired(swapData.claimer.toString(), swapData)) {
-                throw new base_1.SwapDataVerificationError("Not enough time to reliably pay the invoice");
-            }
-            const shouldInitAta = !skipAtaCheck && swapData.isPayOut() && !(yield this.root.Tokens.ataExists(swapData.claimerAta));
-            if (shouldInitAta && !initAta)
-                throw new base_1.SwapDataVerificationError("ATA not initialized");
-            if (feeRate == null)
-                feeRate = yield this.getClaimFeeRate(signer, swapData);
-            const action = new SolanaAction_1.SolanaAction(signer, this.root);
-            const shouldUnwrap = this.shouldUnwrap(signer, swapData);
-            if (shouldInitAta) {
-                const initAction = this.root.Tokens.InitAta(signer, swapData.claimer, swapData.token, swapData.claimerAta);
-                if (initAction == null)
-                    throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
-                action.add(initAction);
-            }
-            action.add(yield this.Claim(signer, swapData, secret));
-            if (shouldUnwrap)
-                action.add(this.root.Tokens.Unwrap(signer));
-            this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getHash() +
-                " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap);
-            return [yield action.tx(feeRate)];
-        });
+    async txsClaimWithSecret(signer, swapData, secret, checkExpiry, initAta, feeRate, skipAtaCheck) {
+        //We need to be sure that this transaction confirms in time, otherwise we reveal the secret to the counterparty
+        // and won't claim the funds
+        if (checkExpiry && await this.root.isExpired(swapData.claimer.toString(), swapData)) {
+            throw new base_1.SwapDataVerificationError("Not enough time to reliably pay the invoice");
+        }
+        const shouldInitAta = !skipAtaCheck && swapData.isPayOut() && !await this.root.Tokens.ataExists(swapData.claimerAta);
+        if (shouldInitAta && !initAta)
+            throw new base_1.SwapDataVerificationError("ATA not initialized");
+        if (feeRate == null)
+            feeRate = await this.getClaimFeeRate(signer, swapData);
+        const action = new SolanaAction_1.SolanaAction(signer, this.root);
+        const shouldUnwrap = this.shouldUnwrap(signer, swapData);
+        if (shouldInitAta) {
+            const initAction = this.root.Tokens.InitAta(signer, swapData.claimer, swapData.token, swapData.claimerAta);
+            if (initAction == null)
+                throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
+            action.add(initAction);
+        }
+        action.add(await this.Claim(signer, swapData, secret));
+        if (shouldUnwrap)
+            action.add(this.root.Tokens.Unwrap(signer));
+        this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getClaimHash() +
+            " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap);
+        return [await action.tx(feeRate)];
     }
     /**
      * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
@@ -208,37 +201,35 @@ class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
      * @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, swapData, blockheight, tx, vout, commitedHeader, synchronizer, initAta, storageAccHolder, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const shouldInitAta = swapData.isPayOut() && !(yield this.root.Tokens.ataExists(swapData.claimerAta));
-            if (shouldInitAta && !initAta)
-                throw new base_1.SwapDataVerificationError("ATA not initialized");
-            const signerKey = signer instanceof SolanaSigner_1.SolanaSigner ? signer.getPublicKey() : signer;
-            if (feeRate == null)
-                feeRate = yield this.getClaimFeeRate(signerKey, swapData);
-            const merkleProof = yield this.btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
-            this.logger.debug("txsClaimWithTxData(): merkle proof computed: ", merkleProof);
-            const txs = [];
-            if (commitedHeader == null)
-                commitedHeader = yield this.getCommitedHeaderAndSynchronize(signerKey, blockheight, swapData.getConfirmations(), tx.blockhash, txs, synchronizer);
-            const storeDataKey = yield this.addTxsWriteTransactionData(signer, tx, vout, feeRate, txs);
-            if (storageAccHolder != null)
-                storageAccHolder.storageAcc = storeDataKey;
-            const shouldUnwrap = this.shouldUnwrap(signerKey, swapData);
-            if (shouldInitAta) {
-                const initAction = this.root.Tokens.InitAta(signerKey, swapData.claimer, swapData.token, swapData.claimerAta);
-                if (initAction == null)
-                    throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
-                yield initAction.addToTxs(txs, feeRate);
-            }
-            const claimAction = yield this.VerifyAndClaim(signerKey, swapData, storeDataKey, merkleProof, commitedHeader);
-            yield claimAction.addToTxs(txs, feeRate);
-            if (shouldUnwrap)
-                yield this.root.Tokens.Unwrap(signerKey).addToTxs(txs, feeRate);
-            this.logger.debug("txsClaimWithTxData(): creating claim transaction, swap: " + swapData.getHash() +
-                " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap + " num txns: " + txs.length);
-            return txs;
-        });
+    async txsClaimWithTxData(signer, swapData, tx, vout, commitedHeader, synchronizer, initAta, storageAccHolder, feeRate) {
+        const shouldInitAta = swapData.isPayOut() && !await this.root.Tokens.ataExists(swapData.claimerAta);
+        if (shouldInitAta && !initAta)
+            throw new base_1.SwapDataVerificationError("ATA not initialized");
+        const signerKey = signer instanceof SolanaSigner_1.SolanaSigner ? signer.getPublicKey() : signer;
+        if (feeRate == null)
+            feeRate = await this.getClaimFeeRate(signerKey, swapData);
+        const merkleProof = await this.btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
+        this.logger.debug("txsClaimWithTxData(): merkle proof computed: ", merkleProof);
+        const txs = [];
+        if (commitedHeader == null)
+            commitedHeader = await this.getCommitedHeaderAndSynchronize(signerKey, tx.height, swapData.confirmations, tx.blockhash, txs, synchronizer);
+        const storeDataKey = await this.addTxsWriteTransactionData(signer, tx, vout, feeRate, txs);
+        if (storageAccHolder != null)
+            storageAccHolder.storageAcc = storeDataKey;
+        const shouldUnwrap = this.shouldUnwrap(signerKey, swapData);
+        if (shouldInitAta) {
+            const initAction = this.root.Tokens.InitAta(signerKey, swapData.claimer, swapData.token, swapData.claimerAta);
+            if (initAction == null)
+                throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
+            await initAction.addToTxs(txs, feeRate);
+        }
+        const claimAction = await this.VerifyAndClaim(signerKey, swapData, storeDataKey, merkleProof, commitedHeader);
+        await claimAction.addToTxs(txs, feeRate);
+        if (shouldUnwrap)
+            await this.root.Tokens.Unwrap(signerKey).addToTxs(txs, feeRate);
+        this.logger.debug("txsClaimWithTxData(): creating claim transaction, swap: " + swapData.getClaimHash() +
+            " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap + " num txns: " + txs.length);
+        return txs;
     }
     getClaimFeeRate(signer, swapData) {
         const accounts = [signer];
@@ -276,22 +267,19 @@ class SwapClaim extends SolanaSwapModule_1.SolanaSwapModule {
      * 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, swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new BN(swapData == null || swapData.payOut ? this.root.Tokens.SPL_ATA_RENT_EXEMPT : 0).add(yield this.getRawClaimFee(signer, swapData, feeRate));
-        });
+    async getClaimFee(signer, swapData, feeRate) {
+        return BigInt(swapData == null || swapData.payOut ? SolanaTokens_1.SolanaTokens.SPL_ATA_RENT_EXEMPT : 0) +
+            await this.getRawClaimFee(signer, swapData, feeRate);
     }
     /**
      * Get the estimated solana transaction fee of the claim transaction, without
      */
-    getRawClaimFee(signer, swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (swapData == null)
-                return new BN(5000);
-            feeRate = feeRate || (yield this.getClaimFeeRate(signer, swapData));
-            //Include rent exempt in claim fee, to take into consideration worst case cost when user destroys ATA
-            return new BN(5000).add(this.root.Fees.getPriorityFee(this.getComputeBudget(swapData), feeRate));
-        });
+    async getRawClaimFee(signer, swapData, feeRate) {
+        if (swapData == null)
+            return 5000n;
+        feeRate = feeRate || await this.getClaimFeeRate(signer, swapData);
+        //Include rent exempt in claim fee, to take into consideration worst case cost when user destroys ATA
+        return 5000n + this.root.Fees.getPriorityFee(this.getComputeBudget(swapData), feeRate);
     }
 }
 exports.SwapClaim = SwapClaim;

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

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 import { ParsedAccountsModeBlockResponse, PublicKey } from "@solana/web3.js";
-import * as BN from "bn.js";
 import { SolanaSwapData } from "../SolanaSwapData";
 import { SolanaSwapModule } from "../SolanaSwapModule";
 import { SolanaTx } from "../../base/modules/SolanaTransactions";
@@ -209,9 +208,9 @@ export declare class SwapInit extends SolanaSwapModule {
      * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
      *  and also deposit for ATAs
      */
-    getInitFee(swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getInitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana fee of the init transaction, without the required deposit for creating swap PDA
      */
-    getRawInitFee(swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getRawInitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
 }