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

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

@@ -1,18 +1,8 @@
 "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.SwapInit = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const base_1 = require("@atomiqlabs/base");
-const BN = require("bn.js");
 const SolanaAction_1 = require("../../base/SolanaAction");
 const spl_token_1 = require("@solana/spl-token");
 const SolanaSwapModule_1 = require("../SolanaSwapModule");
@@ -32,33 +22,40 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param timeout
      * @private
      */
-    Init(swapData, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const claimerAta = (0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.claimer);
-            const paymentHash = buffer_1.Buffer.from(swapData.paymentHash, "hex");
-            const accounts = {
-                claimer: swapData.claimer,
-                offerer: swapData.offerer,
-                escrowState: this.root.SwapEscrowState(paymentHash),
-                mint: swapData.token,
-                systemProgram: web3_js_1.SystemProgram.programId,
-                claimerAta: swapData.payOut ? claimerAta : null,
-                claimerUserData: !swapData.payOut ? this.root.SwapUserVault(swapData.claimer, swapData.token) : null
-            };
-            if (swapData.payIn) {
-                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.offerer);
-                return new SolanaAction_1.SolanaAction(swapData.offerer, this.root, yield this.program.methods
-                    .offererInitializePayIn(swapData.toSwapDataStruct(), [...buffer_1.Buffer.alloc(32, 0)], timeout)
-                    .accounts(Object.assign(Object.assign({}, accounts), { offererAta: ata, vault: this.root.SwapVault(swapData.token), vaultAuthority: this.root.SwapVaultAuthority, tokenProgram: spl_token_1.TOKEN_PROGRAM_ID }))
-                    .instruction(), SwapInit.CUCosts.INIT_PAY_IN);
-            }
-            else {
-                return new SolanaAction_1.SolanaAction(swapData.claimer, this.root, yield this.program.methods
-                    .offererInitialize(swapData.toSwapDataStruct(), swapData.securityDeposit, swapData.claimerBounty, [...(swapData.txoHash != null ? buffer_1.Buffer.from(swapData.txoHash, "hex") : buffer_1.Buffer.alloc(32, 0))], new BN(timeout))
-                    .accounts(Object.assign(Object.assign({}, accounts), { offererUserData: this.root.SwapUserVault(swapData.offerer, swapData.token) }))
-                    .instruction(), SwapInit.CUCosts.INIT);
-            }
-        });
+    async Init(swapData, timeout) {
+        const claimerAta = (0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.claimer);
+        const paymentHash = buffer_1.Buffer.from(swapData.paymentHash, "hex");
+        const accounts = {
+            claimer: swapData.claimer,
+            offerer: swapData.offerer,
+            escrowState: this.root.SwapEscrowState(paymentHash),
+            mint: swapData.token,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            claimerAta: swapData.payOut ? claimerAta : null,
+            claimerUserData: !swapData.payOut ? this.root.SwapUserVault(swapData.claimer, swapData.token) : null
+        };
+        if (swapData.payIn) {
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.offerer);
+            return new SolanaAction_1.SolanaAction(swapData.offerer, this.root, await this.program.methods
+                .offererInitializePayIn(swapData.toSwapDataStruct(), [...buffer_1.Buffer.alloc(32, 0)], (0, Utils_1.toBN)(timeout))
+                .accounts({
+                ...accounts,
+                offererAta: ata,
+                vault: this.root.SwapVault(swapData.token),
+                vaultAuthority: this.root.SwapVaultAuthority,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            })
+                .instruction(), SwapInit.CUCosts.INIT_PAY_IN);
+        }
+        else {
+            return new SolanaAction_1.SolanaAction(swapData.claimer, this.root, await this.program.methods
+                .offererInitialize(swapData.toSwapDataStruct(), swapData.securityDeposit, swapData.claimerBounty, [...(swapData.txoHash != null ? buffer_1.Buffer.from(swapData.txoHash, "hex") : buffer_1.Buffer.alloc(32, 0))], (0, Utils_1.toBN)(timeout))
+                .accounts({
+                ...accounts,
+                offererUserData: this.root.SwapUserVault(swapData.offerer, swapData.token),
+            })
+                .instruction(), SwapInit.CUCosts.INIT);
+        }
     }
     /**
      * InitPayIn action which includes SOL to WSOL wrapping if indicated by the fee rate
@@ -69,16 +66,14 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @constructor
      * @private
      */
-    InitPayIn(swapData, timeout, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!swapData.isPayIn())
-                throw new Error("Must be payIn==true");
-            const action = new SolanaAction_1.SolanaAction(swapData.offerer, this.root);
-            if (this.shouldWrapOnInit(swapData, feeRate))
-                action.addAction(this.Wrap(swapData, feeRate));
-            action.addAction(yield this.Init(swapData, timeout));
-            return action;
-        });
+    async InitPayIn(swapData, timeout, feeRate) {
+        if (!swapData.isPayIn())
+            throw new Error("Must be payIn==true");
+        const action = new SolanaAction_1.SolanaAction(swapData.offerer, this.root);
+        if (this.shouldWrapOnInit(swapData, feeRate))
+            action.addAction(this.Wrap(swapData, feeRate));
+        action.addAction(await this.Init(swapData, timeout));
+        return action;
     }
     /**
      * InitNotPayIn action with additional createAssociatedTokenAccountIdempotentInstruction instruction, such that
@@ -89,21 +84,19 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @constructor
      * @private
      */
-    InitNotPayIn(swapData, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (swapData.isPayIn())
-                throw new Error("Must be payIn==false");
-            const action = new SolanaAction_1.SolanaAction(swapData.claimer, this.root);
-            action.addIx((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(swapData.claimer, swapData.claimerAta, swapData.claimer, swapData.token));
-            action.addAction(yield this.Init(swapData, timeout));
-            return action;
-        });
+    async InitNotPayIn(swapData, timeout) {
+        if (swapData.isPayIn())
+            throw new Error("Must be payIn==false");
+        const action = new SolanaAction_1.SolanaAction(swapData.claimer, this.root);
+        action.addIx((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(swapData.claimer, swapData.claimerAta, swapData.claimer, swapData.token));
+        action.addAction(await this.Init(swapData, timeout));
+        return action;
     }
     Wrap(swapData, feeRate) {
         const data = this.extractAtaDataFromFeeRate(feeRate);
         if (data == null)
             throw new Error("Tried to add wrap instruction, but feeRate malformed: " + feeRate);
-        return this.root.Tokens.Wrap(swapData.offerer, swapData.amount.sub(data.balance), data.initAta);
+        return this.root.Tokens.Wrap(swapData.offerer, swapData.getAmount() - data.balance, data.initAta);
     }
     /**
      * Extracts data about SOL to WSOL wrapping from the fee rate, fee rate is used to convey this information from
@@ -121,7 +114,7 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
         if (arr.length <= 1)
             return null;
         return {
-            balance: new BN(arr[1]),
+            balance: BigInt(arr[1]),
             initAta: arr[0] === "1"
         };
     }
@@ -137,7 +130,7 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
         const data = this.extractAtaDataFromFeeRate(feeRate);
         if (data == null)
             return false;
-        return data.balance.lt(swapData.amount);
+        return data.balance < swapData.getAmount();
     }
     /**
      * Returns the transaction to be signed as an initialization signature from the intermediary, also adds
@@ -148,14 +141,12 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param feeRate
      * @private
      */
-    getTxToSign(swapData, timeout, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const action = swapData.isPayIn() ?
-                yield this.InitPayIn(swapData, new BN(timeout), feeRate) :
-                yield this.InitNotPayIn(swapData, new BN(timeout));
-            const tx = (yield action.tx(feeRate)).tx;
-            return tx;
-        });
+    async getTxToSign(swapData, timeout, feeRate) {
+        const action = swapData.isPayIn() ?
+            await this.InitPayIn(swapData, BigInt(timeout), feeRate) :
+            await this.InitNotPayIn(swapData, BigInt(timeout));
+        const tx = (await action.tx(feeRate)).tx;
+        return tx;
     }
     /**
      * Returns auth prefix to be used with a specific swap, payIn=true & payIn=false use different prefixes (these
@@ -206,34 +197,30 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      *
      * @param data
      */
-    preFetchForInitSignatureVerification(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [latestSlot, txBlock] = yield Promise.all([
-                this.root.Slots.getSlotAndTimestamp("processed"),
-                this.root.Blocks.getParsedBlock(data.slot)
-            ]);
-            return {
-                latestSlot,
-                transactionSlot: {
-                    slot: data.slot,
-                    blockhash: txBlock.blockhash
-                }
-            };
-        });
+    async preFetchForInitSignatureVerification(data) {
+        const [latestSlot, txBlock] = await Promise.all([
+            this.root.Slots.getSlotAndTimestamp("processed"),
+            this.root.Blocks.getParsedBlock(data.slot)
+        ]);
+        return {
+            latestSlot,
+            transactionSlot: {
+                slot: data.slot,
+                blockhash: txBlock.blockhash
+            }
+        };
     }
     /**
      * Pre-fetches block data required for signing the init message by the LP, this can happen in parallel before
      *  signing takes place making the quoting quicker
      */
-    preFetchBlockDataForSignatures() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const latestParsedBlock = yield this.root.Blocks.findLatestParsedBlock("finalized");
-            return {
-                block: latestParsedBlock.block,
-                slot: latestParsedBlock.slot,
-                timestamp: Date.now()
-            };
-        });
+    async preFetchBlockDataForSignatures() {
+        const latestParsedBlock = await this.root.Blocks.findLatestParsedBlock("finalized");
+        return {
+            block: latestParsedBlock.block,
+            slot: latestParsedBlock.slot,
+            timestamp: Date.now()
+        };
     }
     /**
      * Signs swap initialization authorization, using data from preFetchedBlockData if provided & still valid (subject
@@ -246,28 +233,26 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param preFetchedBlockData
      * @public
      */
-    signSwapInitialization(signer, swapData, authorizationTimeout, preFetchedBlockData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (signer.keypair == null)
-                throw new Error("Unsupported");
-            if (!signer.getPublicKey().equals(swapData.isPayIn() ? swapData.claimer : swapData.offerer))
-                throw new Error("Invalid signer, wrong public key!");
-            if (preFetchedBlockData != null && Date.now() - preFetchedBlockData.timestamp > this.SIGNATURE_PREFETCH_DATA_VALIDITY)
-                preFetchedBlockData = null;
-            const { block: latestBlock, slot: latestSlot } = preFetchedBlockData || (yield this.root.Blocks.findLatestParsedBlock("finalized"));
-            const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
-            const txToSign = yield this.getTxToSign(swapData, authTimeout.toString(10), feeRate);
-            txToSign.feePayer = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
-            txToSign.recentBlockhash = latestBlock.blockhash;
-            txToSign.sign(signer.keypair);
-            this.logger.debug("signSwapInitialization(): Signed tx: ", txToSign);
-            const sig = txToSign.signatures.find(e => e.publicKey.equals(signer.getPublicKey()));
-            return {
-                prefix: this.getAuthPrefix(swapData),
-                timeout: authTimeout.toString(10),
-                signature: latestSlot + ";" + sig.signature.toString("hex")
-            };
-        });
+    async signSwapInitialization(signer, swapData, authorizationTimeout, preFetchedBlockData, feeRate) {
+        if (signer.keypair == null)
+            throw new Error("Unsupported");
+        if (!signer.getPublicKey().equals(swapData.isPayIn() ? swapData.claimer : swapData.offerer))
+            throw new Error("Invalid signer, wrong public key!");
+        if (preFetchedBlockData != null && Date.now() - preFetchedBlockData.timestamp > this.SIGNATURE_PREFETCH_DATA_VALIDITY)
+            preFetchedBlockData = null;
+        const { block: latestBlock, slot: latestSlot } = preFetchedBlockData || await this.root.Blocks.findLatestParsedBlock("finalized");
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const txToSign = await this.getTxToSign(swapData, authTimeout.toString(10), feeRate);
+        txToSign.feePayer = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+        txToSign.recentBlockhash = latestBlock.blockhash;
+        txToSign.sign(signer.keypair);
+        this.logger.debug("signSwapInitialization(): Signed tx: ", txToSign);
+        const sig = txToSign.signatures.find(e => e.publicKey.equals(signer.getPublicKey()));
+        return {
+            prefix: this.getAuthPrefix(swapData),
+            timeout: authTimeout.toString(10),
+            signature: latestSlot + ";" + sig.signature.toString("hex")
+        };
     }
     /**
      * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
@@ -280,39 +265,37 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param preFetchedData
      * @public
      */
-    isSignatureValid(swapData, timeout, prefix, signature, feeRate, preFetchedData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
-            const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
-            if (!swapData.isPayIn() && this.root.isExpired(sender.toString(), swapData)) {
-                throw new base_1.SignatureVerificationError("Swap will expire too soon!");
-            }
-            if (prefix !== this.getAuthPrefix(swapData))
-                throw new base_1.SignatureVerificationError("Invalid prefix");
-            const currentTimestamp = new BN(Math.floor(Date.now() / 1000));
-            const isExpired = new BN(timeout).sub(currentTimestamp).lt(new BN(this.root.authGracePeriod));
-            if (isExpired)
-                throw new base_1.SignatureVerificationError("Authorization expired!");
-            const [transactionSlot, signatureString] = signature.split(";");
-            const txSlot = parseInt(transactionSlot);
-            const [latestSlot, blockhash] = yield Promise.all([
-                this.getSlotForSignature(preFetchedData),
-                this.getBlockhashForSignature(txSlot, preFetchedData)
-            ]);
-            const lastValidTransactionSlot = txSlot + this.root.TX_SLOT_VALIDITY;
-            const slotsLeft = lastValidTransactionSlot - latestSlot - this.SIGNATURE_SLOT_BUFFER;
-            if (slotsLeft < 0)
-                throw new base_1.SignatureVerificationError("Authorization expired!");
-            const txToSign = yield this.getTxToSign(swapData, timeout, feeRate);
-            txToSign.feePayer = sender;
-            txToSign.recentBlockhash = blockhash;
-            txToSign.addSignature(signer, buffer_1.Buffer.from(signatureString, "hex"));
-            this.logger.debug("isSignatureValid(): Signed tx: ", txToSign);
-            const valid = txToSign.verifySignatures(false);
-            if (!valid)
-                throw new base_1.SignatureVerificationError("Invalid signature!");
-            return buffer_1.Buffer.from(blockhash);
-        });
+    async isSignatureValid(swapData, timeout, prefix, signature, feeRate, preFetchedData) {
+        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+        const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
+        if (!swapData.isPayIn() && await this.root.isExpired(sender.toString(), swapData)) {
+            throw new base_1.SignatureVerificationError("Swap will expire too soon!");
+        }
+        if (prefix !== this.getAuthPrefix(swapData))
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (BigInt(timeout) - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const [transactionSlot, signatureString] = signature.split(";");
+        const txSlot = parseInt(transactionSlot);
+        const [latestSlot, blockhash] = await Promise.all([
+            this.getSlotForSignature(preFetchedData),
+            this.getBlockhashForSignature(txSlot, preFetchedData)
+        ]);
+        const lastValidTransactionSlot = txSlot + this.root.TX_SLOT_VALIDITY;
+        const slotsLeft = lastValidTransactionSlot - latestSlot - this.SIGNATURE_SLOT_BUFFER;
+        if (slotsLeft < 0)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const txToSign = await this.getTxToSign(swapData, timeout, feeRate);
+        txToSign.feePayer = sender;
+        txToSign.recentBlockhash = blockhash;
+        txToSign.addSignature(signer, buffer_1.Buffer.from(signatureString, "hex"));
+        this.logger.debug("isSignatureValid(): Signed tx: ", txToSign);
+        const valid = txToSign.verifySignatures(false);
+        if (!valid)
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        return buffer_1.Buffer.from(blockhash);
     }
     /**
      * Gets expiry of the provided signature data, this is a minimum of slot expiry & swap signature expiry
@@ -322,21 +305,19 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param preFetchedData
      * @public
      */
-    getSignatureExpiry(timeout, signature, preFetchedData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [transactionSlotStr, signatureString] = signature.split(";");
-            const txSlot = parseInt(transactionSlotStr);
-            const latestSlot = yield this.getSlotForSignature(preFetchedData);
-            const lastValidTransactionSlot = txSlot + this.root.TX_SLOT_VALIDITY;
-            const slotsLeft = lastValidTransactionSlot - latestSlot - this.SIGNATURE_SLOT_BUFFER;
-            const now = Date.now();
-            const slotExpiryTime = now + (slotsLeft * this.root.SLOT_TIME);
-            const timeoutExpiryTime = (parseInt(timeout) - this.root.authGracePeriod) * 1000;
-            const expiry = Math.min(slotExpiryTime, timeoutExpiryTime);
-            if (expiry < now)
-                return 0;
-            return expiry;
-        });
+    async getSignatureExpiry(timeout, signature, preFetchedData) {
+        const [transactionSlotStr, signatureString] = signature.split(";");
+        const txSlot = parseInt(transactionSlotStr);
+        const latestSlot = await this.getSlotForSignature(preFetchedData);
+        const lastValidTransactionSlot = txSlot + this.root.TX_SLOT_VALIDITY;
+        const slotsLeft = lastValidTransactionSlot - latestSlot - this.SIGNATURE_SLOT_BUFFER;
+        const now = Date.now();
+        const slotExpiryTime = now + (slotsLeft * this.root.SLOT_TIME);
+        const timeoutExpiryTime = (parseInt(timeout) - this.root.authGracePeriod) * 1000;
+        const expiry = Math.min(slotExpiryTime, timeoutExpiryTime);
+        if (expiry < now)
+            return 0;
+        return expiry;
     }
     /**
      * Checks whether signature is expired for good (uses "finalized" slot)
@@ -345,19 +326,17 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param timeout
      * @public
      */
-    isSignatureExpired(signature, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [transactionSlotStr, signatureString] = signature.split(";");
-            const txSlot = parseInt(transactionSlotStr);
-            const lastValidTransactionSlot = txSlot + this.root.TX_SLOT_VALIDITY;
-            const latestSlot = yield this.root.Slots.getSlot("finalized");
-            const slotsLeft = lastValidTransactionSlot - latestSlot + this.SIGNATURE_SLOT_BUFFER;
-            if (slotsLeft < 0)
-                return true;
-            if ((parseInt(timeout) + this.root.authGracePeriod) * 1000 < Date.now())
-                return true;
-            return false;
-        });
+    async isSignatureExpired(signature, timeout) {
+        const [transactionSlotStr, signatureString] = signature.split(";");
+        const txSlot = parseInt(transactionSlotStr);
+        const lastValidTransactionSlot = txSlot + this.root.TX_SLOT_VALIDITY;
+        const latestSlot = await this.root.Slots.getSlot("finalized");
+        const slotsLeft = lastValidTransactionSlot - latestSlot + this.SIGNATURE_SLOT_BUFFER;
+        if (slotsLeft < 0)
+            return true;
+        if ((parseInt(timeout) + this.root.authGracePeriod) * 1000 < Date.now())
+            return true;
+        return false;
     }
     /**
      * Creates init transaction (InitPayIn) with a valid signature from an LP, also adds a SOL to WSOL wrapping ix to
@@ -371,38 +350,36 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param skipChecks whether to skip signature validity checks
      * @param feeRate fee rate to use for the transaction
      */
-    txsInitPayIn(swapData, timeout, prefix, signature, skipChecks, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!skipChecks) {
-                const [_, payStatus] = yield Promise.all([
-                    (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError),
-                    (0, Utils_1.tryWithRetries)(() => this.root.getPaymentHashStatus(swapData.paymentHash), this.retryPolicy)
-                ]);
-                if (payStatus !== base_1.SwapCommitStatus.NOT_COMMITED)
-                    throw new base_1.SwapDataVerificationError("Invoice already being paid for or paid");
-            }
-            const [slotNumber, signatureStr] = signature.split(";");
-            const block = yield (0, Utils_1.tryWithRetries)(() => this.root.Blocks.getParsedBlock(parseInt(slotNumber)), this.retryPolicy);
-            const txs = [];
-            let isWrapping = false;
-            const isWrappedInSignedTx = feeRate != null && feeRate.split("#").length > 1;
-            if (!isWrappedInSignedTx && swapData.token.equals(this.root.Tokens.WSOL_ADDRESS)) {
-                const ataAcc = yield (0, Utils_1.tryWithRetries)(() => this.root.Tokens.getATAOrNull(swapData.offererAta), this.retryPolicy);
-                const balance = ataAcc == null ? new BN(0) : new BN(ataAcc.amount.toString());
-                if (balance.lt(swapData.amount)) {
-                    //Need to wrap more SOL to WSOL
-                    yield this.root.Tokens.Wrap(swapData.offerer, swapData.amount.sub(balance), ataAcc == null)
-                        .addToTxs(txs, feeRate, block);
-                    isWrapping = true;
-                }
+    async txsInitPayIn(swapData, timeout, prefix, signature, skipChecks, feeRate) {
+        if (!skipChecks) {
+            const [_, payStatus] = await Promise.all([
+                (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError),
+                (0, Utils_1.tryWithRetries)(() => this.root.getClaimHashStatus(swapData.getClaimHash()), this.retryPolicy)
+            ]);
+            if (payStatus !== base_1.SwapCommitStatus.NOT_COMMITED)
+                throw new base_1.SwapDataVerificationError("Invoice already being paid for or paid");
+        }
+        const [slotNumber, signatureStr] = signature.split(";");
+        const block = await (0, Utils_1.tryWithRetries)(() => this.root.Blocks.getParsedBlock(parseInt(slotNumber)), this.retryPolicy);
+        const txs = [];
+        let isWrapping = false;
+        const isWrappedInSignedTx = feeRate != null && feeRate.split("#").length > 1;
+        if (!isWrappedInSignedTx && swapData.token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS)) {
+            const ataAcc = await (0, Utils_1.tryWithRetries)(() => this.root.Tokens.getATAOrNull(swapData.offererAta), this.retryPolicy);
+            const balance = ataAcc == null ? 0n : ataAcc.amount;
+            if (balance < swapData.getAmount()) {
+                //Need to wrap more SOL to WSOL
+                await this.root.Tokens.Wrap(swapData.offerer, swapData.getAmount() - balance, ataAcc == null)
+                    .addToTxs(txs, feeRate, block);
+                isWrapping = true;
             }
-            const initTx = yield (yield this.InitPayIn(swapData, new BN(timeout), feeRate)).tx(feeRate, block);
-            initTx.tx.addSignature(swapData.claimer, buffer_1.Buffer.from(signatureStr, "hex"));
-            txs.push(initTx);
-            this.logger.debug("txsInitPayIn(): create swap init TX, swap: " + swapData.getHash() +
-                " wrapping client-side: " + isWrapping + " feerate: " + feeRate);
-            return txs;
-        });
+        }
+        const initTx = await (await this.InitPayIn(swapData, BigInt(timeout), feeRate)).tx(feeRate, block);
+        initTx.tx.addSignature(swapData.claimer, buffer_1.Buffer.from(signatureStr, "hex"));
+        txs.push(initTx);
+        this.logger.debug("txsInitPayIn(): create swap init TX, swap: " + swapData.getClaimHash() +
+            " wrapping client-side: " + isWrapping + " feerate: " + feeRate);
+        return txs;
     }
     /**
      * Creates init transactions (InitNotPayIn) with a valid signature from an intermediary
@@ -414,18 +391,16 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param skipChecks whether to skip signature validity checks
      * @param feeRate fee rate to use for the transaction
      */
-    txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!skipChecks) {
-                yield (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
-            }
-            const [slotNumber, signatureStr] = signature.split(";");
-            const block = yield (0, Utils_1.tryWithRetries)(() => this.root.Blocks.getParsedBlock(parseInt(slotNumber)), this.retryPolicy);
-            const initTx = yield (yield this.InitNotPayIn(swapData, new BN(timeout))).tx(feeRate, block);
-            initTx.tx.addSignature(swapData.offerer, buffer_1.Buffer.from(signatureStr, "hex"));
-            this.logger.debug("txsInit(): create swap init TX, swap: " + swapData.getHash() + " feerate: " + feeRate);
-            return [initTx];
-        });
+    async txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate) {
+        if (!skipChecks) {
+            await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        }
+        const [slotNumber, signatureStr] = signature.split(";");
+        const block = await (0, Utils_1.tryWithRetries)(() => this.root.Blocks.getParsedBlock(parseInt(slotNumber)), this.retryPolicy);
+        const initTx = await (await this.InitNotPayIn(swapData, BigInt(timeout))).tx(feeRate, block);
+        initTx.tx.addSignature(swapData.offerer, buffer_1.Buffer.from(signatureStr, "hex"));
+        this.logger.debug("txsInit(): create swap init TX, swap: " + swapData.getClaimHash() + " feerate: " + feeRate);
+        return [initTx];
     }
     /**
      * Returns the fee rate to be used for a specific init transaction, also adding indication whether the WSOL ATA
@@ -436,36 +411,34 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param token
      * @param paymentHash
      */
-    getInitPayInFeeRate(offerer, claimer, token, paymentHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accounts = [];
+    async getInitPayInFeeRate(offerer, claimer, token, paymentHash) {
+        const accounts = [];
+        if (offerer != null)
+            accounts.push(offerer);
+        if (token != null) {
+            accounts.push(this.root.SwapVault(token));
             if (offerer != null)
-                accounts.push(offerer);
-            if (token != null) {
-                accounts.push(this.root.SwapVault(token));
-                if (offerer != null)
-                    accounts.push((0, spl_token_1.getAssociatedTokenAddressSync)(token, offerer));
-                if (claimer != null)
-                    accounts.push(this.root.SwapUserVault(claimer, token));
-            }
-            if (paymentHash != null)
-                accounts.push(this.root.SwapEscrowState(buffer_1.Buffer.from(paymentHash, "hex")));
-            const shouldCheckWSOLAta = token != null && offerer != null && token.equals(this.root.Tokens.WSOL_ADDRESS);
-            let [feeRate, _account] = yield Promise.all([
-                this.root.Fees.getFeeRate(accounts),
-                shouldCheckWSOLAta ?
-                    this.root.Tokens.getATAOrNull((0, spl_token_1.getAssociatedTokenAddressSync)(token, offerer)) :
-                    Promise.resolve(null)
-            ]);
-            if (shouldCheckWSOLAta) {
-                const account = _account;
-                const balance = account == null ? new BN(0) : new BN(account.amount.toString());
-                //Add an indication about whether the ATA is initialized & balance it contains
-                feeRate += "#" + (account != null ? "0" : "1") + ";" + balance.toString(10);
-            }
-            this.logger.debug("getInitPayInFeeRate(): feerate computed: " + feeRate);
-            return feeRate;
-        });
+                accounts.push((0, spl_token_1.getAssociatedTokenAddressSync)(token, offerer));
+            if (claimer != null)
+                accounts.push(this.root.SwapUserVault(claimer, token));
+        }
+        if (paymentHash != null)
+            accounts.push(this.root.SwapEscrowState(buffer_1.Buffer.from(paymentHash, "hex")));
+        const shouldCheckWSOLAta = token != null && offerer != null && token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS);
+        let [feeRate, _account] = await Promise.all([
+            this.root.Fees.getFeeRate(accounts),
+            shouldCheckWSOLAta ?
+                this.root.Tokens.getATAOrNull((0, spl_token_1.getAssociatedTokenAddressSync)(token, offerer)) :
+                Promise.resolve(null)
+        ]);
+        if (shouldCheckWSOLAta) {
+            const account = _account;
+            const balance = account == null ? 0n : account.amount;
+            //Add an indication about whether the ATA is initialized & balance it contains
+            feeRate += "#" + (account != null ? "0" : "1") + ";" + balance.toString(10);
+        }
+        this.logger.debug("getInitPayInFeeRate(): feerate computed: " + feeRate);
+        return feeRate;
     }
     /**
      * Returns the fee rate to be used for a specific init transaction
@@ -489,50 +462,46 @@ class SwapInit extends SolanaSwapModule_1.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, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (swapData == null)
-                return new BN(this.root.ESCROW_STATE_RENT_EXEMPT).add(yield this.getRawInitFee(swapData, feeRate));
-            feeRate = feeRate ||
-                (swapData.payIn
-                    ? yield this.getInitPayInFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash)
-                    : yield this.getInitFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash));
-            const [rawFee, initAta] = yield Promise.all([
-                this.getRawInitFee(swapData, feeRate),
-                swapData != null && swapData.payOut ?
-                    this.root.Tokens.getATAOrNull((0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.claimer)).then(acc => acc == null) :
-                    Promise.resolve(null)
-            ]);
-            let resultingFee = new BN(this.root.ESCROW_STATE_RENT_EXEMPT).add(rawFee);
-            if (initAta)
-                resultingFee = resultingFee.add(new BN(this.root.Tokens.SPL_ATA_RENT_EXEMPT));
-            if (swapData.payIn && this.shouldWrapOnInit(swapData, feeRate) && this.extractAtaDataFromFeeRate(feeRate).initAta) {
-                resultingFee = resultingFee.add(new BN(this.root.Tokens.SPL_ATA_RENT_EXEMPT));
-            }
-            return resultingFee;
-        });
+    async getInitFee(swapData, feeRate) {
+        if (swapData == null)
+            return BigInt(this.root.ESCROW_STATE_RENT_EXEMPT) + await this.getRawInitFee(swapData, feeRate);
+        feeRate = feeRate ||
+            (swapData.payIn
+                ? await this.getInitPayInFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash)
+                : await this.getInitFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash));
+        const [rawFee, initAta] = await Promise.all([
+            this.getRawInitFee(swapData, feeRate),
+            swapData != null && swapData.payOut ?
+                this.root.Tokens.getATAOrNull((0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.claimer)).then(acc => acc == null) :
+                Promise.resolve(null)
+        ]);
+        let resultingFee = BigInt(this.root.ESCROW_STATE_RENT_EXEMPT) + rawFee;
+        if (initAta)
+            resultingFee += BigInt(SolanaTokens_1.SolanaTokens.SPL_ATA_RENT_EXEMPT);
+        if (swapData.payIn && this.shouldWrapOnInit(swapData, feeRate) && this.extractAtaDataFromFeeRate(feeRate).initAta) {
+            resultingFee += BigInt(SolanaTokens_1.SolanaTokens.SPL_ATA_RENT_EXEMPT);
+        }
+        return resultingFee;
     }
     /**
      * Get the estimated solana fee of the init transaction, without the required deposit for creating swap PDA
      */
-    getRawInitFee(swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (swapData == null)
-                return new BN(10000);
-            feeRate = feeRate ||
-                (swapData.payIn
-                    ? yield this.getInitPayInFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash)
-                    : yield this.getInitFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash));
-            let computeBudget = swapData.payIn ? SwapInit.CUCosts.INIT_PAY_IN : SwapInit.CUCosts.INIT;
-            if (swapData.payIn && this.shouldWrapOnInit(swapData, feeRate)) {
-                computeBudget += SolanaTokens_1.SolanaTokens.CUCosts.WRAP_SOL;
-                const data = this.extractAtaDataFromFeeRate(feeRate);
-                if (data.initAta)
-                    computeBudget += SolanaTokens_1.SolanaTokens.CUCosts.ATA_INIT;
-            }
-            const baseFee = swapData.payIn ? 10000 : 10000 + 5000;
-            return new BN(baseFee).add(this.root.Fees.getPriorityFee(computeBudget, feeRate));
-        });
+    async getRawInitFee(swapData, feeRate) {
+        if (swapData == null)
+            return 10000n;
+        feeRate = feeRate ||
+            (swapData.payIn
+                ? await this.getInitPayInFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash)
+                : await this.getInitFeeRate(swapData.offerer, swapData.claimer, swapData.token, swapData.paymentHash));
+        let computeBudget = swapData.payIn ? SwapInit.CUCosts.INIT_PAY_IN : SwapInit.CUCosts.INIT;
+        if (swapData.payIn && this.shouldWrapOnInit(swapData, feeRate)) {
+            computeBudget += SolanaTokens_1.SolanaTokens.CUCosts.WRAP_SOL;
+            const data = this.extractAtaDataFromFeeRate(feeRate);
+            if (data.initAta)
+                computeBudget += SolanaTokens_1.SolanaTokens.CUCosts.ATA_INIT;
+        }
+        const baseFee = swapData.payIn ? 10000n : 10000n + 5000n;
+        return baseFee + this.root.Fees.getPriorityFee(computeBudget, feeRate);
     }
 }
 exports.SwapInit = SwapInit;