@atomiqlabs/lp-lib 11.0.5 → 12.0.0-beta.0

package/dist/swaps/frombtc_abstract/FromBtcAbs.js

@@ -1,16 +1,6 @@
 "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.FromBtcAbs = void 0;
-const BN = require("bn.js");
 const FromBtcSwapAbs_1 = require("./FromBtcSwapAbs");
 const SwapHandler_1 = require("../SwapHandler");
 const base_1 = require("@atomiqlabs/base");
@@ -27,21 +17,12 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
     constructor(storageDirectory, path, chains, bitcoin, swapPricing, config) {
         super(storageDirectory, path, chains, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC;
+        this.swapType = base_1.ChainSwapType.CHAIN;
         this.bitcoin = bitcoin;
-        this.config = Object.assign(Object.assign({}, config), { swapTsCsvDelta: new BN(config.swapCsvDelta).mul(config.bitcoinBlocktime.div(config.safetyFactor)) });
-    }
-    /**
-     * Returns the TXO hash of the specific address and amount - sha256(u64le(amount) + outputScript(address))
-     *
-     * @param address
-     * @param amount
-     */
-    getTxoHash(address, amount) {
-        const parsedOutputScript = this.bitcoin.toOutputScript(address);
-        return (0, crypto_1.createHash)("sha256").update(Buffer.concat([
-            Buffer.from(amount.toArray("le", 8)),
-            parsedOutputScript
-        ])).digest();
+        this.config = {
+            ...config,
+            swapTsCsvDelta: BigInt(config.swapCsvDelta) * (config.bitcoinBlocktime / config.safetyFactor)
+        };
     }
     /**
      * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
@@ -53,7 +34,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
     getHash(chainIdentifier, address, amount) {
         const parsedOutputScript = this.bitcoin.toOutputScript(address);
         const { swapContract } = this.getChain(chainIdentifier);
-        return swapContract.getHashForOnchain(parsedOutputScript, amount, new BN(0));
+        return swapContract.getHashForOnchain(parsedOutputScript, amount, this.config.confirmations, 0n);
     }
     /**
      * Processes past swap
@@ -62,61 +43,57 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      * @protected
      * @returns true if the swap should be refunded, false if nothing should be done
      */
-    processPastSwap(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { swapContract, signer } = this.getChain(swap.chainIdentifier);
-            //Once authorization expires in CREATED state, the user can no more commit it on-chain
-            if (swap.state === FromBtcSwapAbs_1.FromBtcSwapState.CREATED) {
-                if (!(yield swapContract.isInitAuthorizationExpired(swap.data, swap)))
-                    return false;
-                const isCommited = yield swapContract.isCommited(swap.data);
-                if (isCommited) {
-                    this.swapLogger.info(swap, "processPastSwap(state=CREATED): swap was commited, but processed from watchdog, address: " + swap.address);
-                    yield swap.setState(FromBtcSwapAbs_1.FromBtcSwapState.COMMITED);
-                    yield this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
-                    return false;
-                }
-                this.swapLogger.info(swap, "processPastSwap(state=CREATED): removing past swap due to authorization expiry, address: " + swap.address);
-                yield this.bitcoin.addUnusedAddress(swap.address);
-                yield this.removeSwapData(swap, FromBtcSwapAbs_1.FromBtcSwapState.CANCELED);
+    async processPastSwap(swap) {
+        const { swapContract, signer } = this.getChain(swap.chainIdentifier);
+        //Once authorization expires in CREATED state, the user can no more commit it on-chain
+        if (swap.state === FromBtcSwapAbs_1.FromBtcSwapState.CREATED) {
+            if (!await swapContract.isInitAuthorizationExpired(swap.data, swap))
+                return false;
+            const isCommited = await swapContract.isCommited(swap.data);
+            if (isCommited) {
+                this.swapLogger.info(swap, "processPastSwap(state=CREATED): swap was commited, but processed from watchdog, address: " + swap.address);
+                await swap.setState(FromBtcSwapAbs_1.FromBtcSwapState.COMMITED);
+                await this.saveSwapData(swap);
                 return false;
             }
-            //Check if commited swap expired by now
-            if (swap.state === FromBtcSwapAbs_1.FromBtcSwapState.COMMITED) {
-                if (!swapContract.isExpired(signer.getAddress(), swap.data))
-                    return false;
-                const isCommited = yield swapContract.isCommited(swap.data);
-                if (isCommited) {
-                    this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap expired, will refund, address: " + swap.address);
-                    return true;
-                }
-                this.swapLogger.warn(swap, "processPastSwap(state=COMMITED): commited swap expired and not committed anymore (already refunded?), address: " + swap.address);
-                yield this.removeSwapData(swap, FromBtcSwapAbs_1.FromBtcSwapState.CANCELED);
+            this.swapLogger.info(swap, "processPastSwap(state=CREATED): removing past swap due to authorization expiry, address: " + swap.address);
+            await this.bitcoin.addUnusedAddress(swap.address);
+            await this.removeSwapData(swap, FromBtcSwapAbs_1.FromBtcSwapState.CANCELED);
+            return false;
+        }
+        //Check if commited swap expired by now
+        if (swap.state === FromBtcSwapAbs_1.FromBtcSwapState.COMMITED) {
+            if (!await swapContract.isExpired(signer.getAddress(), swap.data))
                 return false;
+            const isCommited = await swapContract.isCommited(swap.data);
+            if (isCommited) {
+                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap expired, will refund, address: " + swap.address);
+                return true;
             }
-        });
+            this.swapLogger.warn(swap, "processPastSwap(state=COMMITED): commited swap expired and not committed anymore (already refunded?), address: " + swap.address);
+            await this.removeSwapData(swap, FromBtcSwapAbs_1.FromBtcSwapState.CANCELED);
+            return false;
+        }
     }
     /**
      * Checks past swaps, refunds and deletes ones that are already expired.
      */
-    processPastSwaps() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const queriedData = yield this.storageManager.query([
-                {
-                    key: "state",
-                    value: [
-                        FromBtcSwapAbs_1.FromBtcSwapState.CREATED,
-                        FromBtcSwapAbs_1.FromBtcSwapState.COMMITED
-                    ]
-                }
-            ]);
-            const refundSwaps = [];
-            for (let swap of queriedData) {
-                if (yield this.processPastSwap(swap))
-                    refundSwaps.push(swap);
+    async processPastSwaps() {
+        const queriedData = await this.storageManager.query([
+            {
+                key: "state",
+                value: [
+                    FromBtcSwapAbs_1.FromBtcSwapState.CREATED,
+                    FromBtcSwapAbs_1.FromBtcSwapState.COMMITED
+                ]
             }
-            yield this.refundSwaps(refundSwaps);
-        });
+        ]);
+        const refundSwaps = [];
+        for (let { obj: swap } of queriedData) {
+            if (await this.processPastSwap(swap))
+                refundSwaps.push(swap);
+        }
+        await this.refundSwaps(refundSwaps);
     }
     /**
      * Refunds all swaps (calls SC on-chain refund function)
@@ -124,78 +101,37 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      * @param refundSwaps
      * @protected
      */
-    refundSwaps(refundSwaps) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let refundSwap of refundSwaps) {
-                const { swapContract, signer } = this.getChain(refundSwap.chainIdentifier);
-                const unlock = refundSwap.lock(swapContract.refundTimeout);
-                if (unlock == null)
-                    continue;
-                this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
-                yield swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
-                this.swapLogger.info(refundSwap, "refundSwaps(): swap refunded, address: " + refundSwap.address);
-                //The swap should be removed by the event handler
-                yield refundSwap.setState(FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
-                unlock();
-            }
-        });
+    async refundSwaps(refundSwaps) {
+        for (let refundSwap of refundSwaps) {
+            const { swapContract, signer } = this.getChain(refundSwap.chainIdentifier);
+            const unlock = refundSwap.lock(swapContract.refundTimeout);
+            if (unlock == null)
+                continue;
+            this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
+            await swapContract.refund(signer, refundSwap.data, true, false, { waitForConfirmation: true });
+            this.swapLogger.info(refundSwap, "refundSwaps(): swap refunded, address: " + refundSwap.address);
+            //The swap should be removed by the event handler
+            await refundSwap.setState(FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
+            unlock();
+        }
     }
-    processInitializeEvent(chainIdentifier, event) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            //Only process on-chain requests
-            if (event.swapType !== base_1.ChainSwapType.CHAIN)
-                return;
-            const swapData = yield event.swapData();
-            const { signer } = this.getChain(chainIdentifier);
-            if (!swapData.isOfferer(signer.getAddress()))
-                return;
-            //Only process requests that don't pay in from the program
-            if (swapData.isPayIn())
-                return;
-            const paymentHash = event.paymentHash;
-            const savedSwap = yield this.storageManager.getData(paymentHash, event.sequence);
-            if (savedSwap == null || savedSwap.chainIdentifier !== chainIdentifier)
-                return;
-            savedSwap.txIds.init = (_a = event.meta) === null || _a === void 0 ? void 0 : _a.txId;
-            if (savedSwap.metadata != null)
-                savedSwap.metadata.times.initTxReceived = Date.now();
-            this.swapLogger.info(savedSwap, "SC: InitializeEvent: swap initialized by the client, address: " + savedSwap.address);
-            if (savedSwap.state === FromBtcSwapAbs_1.FromBtcSwapState.CREATED) {
-                yield savedSwap.setState(FromBtcSwapAbs_1.FromBtcSwapState.COMMITED);
-                savedSwap.data = swapData;
-                yield this.storageManager.saveData(paymentHash, event.sequence, savedSwap);
-            }
-        });
+    async processInitializeEvent(chainIdentifier, savedSwap, event) {
+        this.swapLogger.info(savedSwap, "SC: InitializeEvent: swap initialized by the client, address: " + savedSwap.address);
+        if (savedSwap.state === FromBtcSwapAbs_1.FromBtcSwapState.CREATED) {
+            await savedSwap.setState(FromBtcSwapAbs_1.FromBtcSwapState.COMMITED);
+            await this.saveSwapData(savedSwap);
+        }
     }
-    processClaimEvent(chainIdentifier, event) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const paymentHashHex = event.paymentHash;
-            const savedSwap = yield this.storageManager.getData(paymentHashHex, event.sequence);
-            if (savedSwap == null || savedSwap.chainIdentifier !== chainIdentifier)
-                return;
-            savedSwap.txId = Buffer.from(event.secret, "hex").reverse().toString("hex");
-            savedSwap.txIds.claim = (_a = event.meta) === null || _a === void 0 ? void 0 : _a.txId;
-            if (savedSwap.metadata != null)
-                savedSwap.metadata.times.claimTxReceived = Date.now();
-            this.swapLogger.info(savedSwap, "SC: ClaimEvent: swap successfully claimed by the client, address: " + savedSwap.address);
-            yield this.removeSwapData(savedSwap, FromBtcSwapAbs_1.FromBtcSwapState.CLAIMED);
-        });
+    async processClaimEvent(chainIdentifier, savedSwap, event) {
+        savedSwap.txId = Buffer.from(event.result, "hex").reverse().toString("hex");
+        this.swapLogger.info(savedSwap, "SC: ClaimEvent: swap successfully claimed by the client, address: " + savedSwap.address);
+        await this.removeSwapData(savedSwap, FromBtcSwapAbs_1.FromBtcSwapState.CLAIMED);
     }
-    processRefundEvent(chainIdentifier, event) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.paymentHash == null)
-                return;
-            const savedSwap = yield this.storageManager.getData(event.paymentHash, event.sequence);
-            if (savedSwap == null || savedSwap.chainIdentifier !== chainIdentifier)
-                return;
-            savedSwap.txIds.refund = (_a = event.meta) === null || _a === void 0 ? void 0 : _a.txId;
-            this.swapLogger.info(event, "SC: RefundEvent: swap refunded, address: " + savedSwap.address);
-            yield this.bitcoin.addUnusedAddress(savedSwap.address);
-            yield this.removeSwapData(savedSwap, FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
-        });
+    async processRefundEvent(chainIdentifier, savedSwap, event) {
+        savedSwap.txIds.refund = event.meta?.txId;
+        this.swapLogger.info(event, "SC: RefundEvent: swap refunded, address: " + savedSwap.address);
+        await this.bitcoin.addUnusedAddress(savedSwap.address);
+        await this.removeSwapData(savedSwap, FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
     }
     /**
      * Calculates the requested claimer bounty, based on client's request
@@ -206,33 +142,32 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      * @throws {DefinedRuntimeError} will throw an error if the plugin cancelled the request
      * @returns {Promise<BN>} resulting claimer bounty to be used with the swap
      */
-    getClaimerBounty(req, expiry, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parsedClaimerBounty = yield req.paramReader.getParams({
-                claimerBounty: {
-                    feePerBlock: SchemaVerifier_1.FieldTypeEnum.BN,
-                    safetyFactor: SchemaVerifier_1.FieldTypeEnum.BN,
-                    startTimestamp: SchemaVerifier_1.FieldTypeEnum.BN,
-                    addBlock: SchemaVerifier_1.FieldTypeEnum.BN,
-                    addFee: SchemaVerifier_1.FieldTypeEnum.BN,
-                },
-            }).catch(e => null);
-            signal.throwIfAborted();
-            if (parsedClaimerBounty == null || parsedClaimerBounty.claimerBounty == null) {
-                throw {
-                    code: 20043,
-                    msg: "Invalid claimerBounty"
-                };
-            }
-            const tsDelta = expiry.sub(parsedClaimerBounty.claimerBounty.startTimestamp);
-            const blocksDelta = tsDelta.div(this.config.bitcoinBlocktime).mul(parsedClaimerBounty.claimerBounty.safetyFactor);
-            const totalBlock = blocksDelta.add(parsedClaimerBounty.claimerBounty.addBlock);
-            return parsedClaimerBounty.claimerBounty.addFee.add(totalBlock.mul(parsedClaimerBounty.claimerBounty.feePerBlock));
-        });
+    async getClaimerBounty(req, expiry, signal) {
+        const parsedClaimerBounty = await req.paramReader.getParams({
+            claimerBounty: {
+                feePerBlock: SchemaVerifier_1.FieldTypeEnum.BigInt,
+                safetyFactor: SchemaVerifier_1.FieldTypeEnum.BigInt,
+                startTimestamp: SchemaVerifier_1.FieldTypeEnum.BigInt,
+                addBlock: SchemaVerifier_1.FieldTypeEnum.BigInt,
+                addFee: SchemaVerifier_1.FieldTypeEnum.BigInt,
+            },
+        }).catch(e => null);
+        signal.throwIfAborted();
+        if (parsedClaimerBounty == null || parsedClaimerBounty.claimerBounty == null) {
+            throw {
+                code: 20043,
+                msg: "Invalid claimerBounty"
+            };
+        }
+        const tsDelta = expiry - parsedClaimerBounty.claimerBounty.startTimestamp;
+        const blocksDelta = tsDelta / this.config.bitcoinBlocktime * parsedClaimerBounty.claimerBounty.safetyFactor;
+        const totalBlock = blocksDelta + parsedClaimerBounty.claimerBounty.addBlock;
+        return parsedClaimerBounty.claimerBounty.addFee + (totalBlock * parsedClaimerBounty.claimerBounty.feePerBlock);
     }
     getDummySwapData(chainIdentifier, useToken, address) {
         const { swapContract, signer } = this.getChain(chainIdentifier);
-        return swapContract.createSwapData(base_1.ChainSwapType.CHAIN, signer.getAddress(), address, useToken, null, null, null, null, new BN(0), this.config.confirmations, false, true, null, null);
+        const dummyAmount = BigInt(Math.floor(Math.random() * 0x1000000));
+        return swapContract.createSwapData(base_1.ChainSwapType.CHAIN, signer.getAddress(), address, useToken, dummyAmount, swapContract.getHashForOnchain((0, crypto_1.randomBytes)(32), dummyAmount, 3, null).toString("hex"), base_1.BigIntBufferUtils.fromBuffer((0, crypto_1.randomBytes)(8)), BigInt(Math.floor(Date.now() / 1000)) + this.config.swapTsCsvDelta, false, true, BigInt(Math.floor(Math.random() * 0x10000)), BigInt(Math.floor(Math.random() * 0x10000)));
     }
     /**
      * Sets up required listeners for the REST server
@@ -241,11 +176,12 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      */
     startRestServer(restServer) {
         restServer.use(this.path + "/getAddress", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
-        restServer.post(this.path + "/getAddress", (0, Utils_1.expressHandlerWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+        restServer.post(this.path + "/getAddress", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = (_a = req.query.chain) !== null && _a !== void 0 ? _a : this.chains.default;
+            const chainIdentifier = req.query.chain ?? this.chains.default;
             const { swapContract, signer } = this.getChain(chainIdentifier);
+            const depositToken = req.query.depositToken ?? swapContract.getNativeCurrencyAddress();
+            this.checkAllowedDepositToken(chainIdentifier, depositToken);
             metadata.times.requestReceived = Date.now();
             /**
              * address: string              solana address of the recipient
@@ -263,15 +199,15 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
              *  - addFee: string                Additional fee to add to the final claimer bounty
              * feeRate: string              Fee rate to be used for init signature
              */
-            const parsedBody = yield req.paramReader.getParams({
+            const parsedBody = await req.paramReader.getParams({
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
                     swapContract.isValidAddress(val) ? val : null,
-                amount: SchemaVerifier_1.FieldTypeEnum.BN,
+                amount: SchemaVerifier_1.FieldTypeEnum.BigInt,
                 token: (val) => val != null &&
                     typeof (val) === "string" &&
                     this.isTokenSupported(chainIdentifier, val) ? val : null,
-                sequence: SchemaVerifier_1.FieldTypeEnum.BN,
+                sequence: SchemaVerifier_1.FieldTypeEnum.BigInt,
                 exactOut: SchemaVerifier_1.FieldTypeEnum.BooleanOptional
             });
             if (parsedBody == null)
@@ -290,57 +226,57 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const useToken = parsedBody.token;
             //Check request params
             this.checkSequence(parsedBody.sequence);
-            const fees = yield this.preCheckAmounts(request, requestedAmount, useToken);
+            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
             metadata.times.requestChecked = Date.now();
             //Create abortController for parallel prefetches
             const responseStream = res.responseStream;
             const abortController = this.getAbortController(responseStream);
             //Pre-fetch data
-            const { pricePrefetchPromise, securityDepositPricePrefetchPromise } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, abortController);
+            const { pricePrefetchPromise, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
             const balancePrefetch = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const signDataPrefetchPromise = this.getSignDataPrefetch(chainIdentifier, abortController, responseStream);
-            const dummySwapData = yield this.getDummySwapData(chainIdentifier, useToken, parsedBody.address);
+            const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address);
             abortController.signal.throwIfAborted();
-            const baseSDPromise = this.getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, abortController);
+            const baseSDPromise = this.getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, depositToken, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise, abortController);
             //Check valid amount specified (min/max)
-            const { amountBD, swapFee, swapFeeInToken, totalInToken } = yield this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
+            const { amountBD, swapFee, swapFeeInToken, totalInToken } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
             metadata.times.priceCalculated = Date.now();
             //Check if we have enough funds to honor the request
-            yield this.checkBalance(totalInToken, balancePrefetch, abortController.signal);
+            await this.checkBalance(totalInToken, balancePrefetch, abortController.signal);
             metadata.times.balanceChecked = Date.now();
             //Create swap receive bitcoin address
-            const receiveAddress = yield this.bitcoin.getAddress();
+            const receiveAddress = await this.bitcoin.getAddress();
             abortController.signal.throwIfAborted();
             metadata.times.addressCreated = Date.now();
             const paymentHash = this.getHash(chainIdentifier, receiveAddress, amountBD);
-            const currentTimestamp = new BN(Math.floor(Date.now() / 1000));
+            const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
             const expiryTimeout = this.config.swapTsCsvDelta;
-            const expiry = currentTimestamp.add(expiryTimeout);
+            const expiry = currentTimestamp + expiryTimeout;
             //Calculate security deposit
-            const totalSecurityDeposit = yield this.getSecurityDeposit(chainIdentifier, amountBD, swapFee, expiryTimeout, baseSDPromise, securityDepositPricePrefetchPromise, abortController.signal, metadata);
+            const totalSecurityDeposit = await this.getSecurityDeposit(chainIdentifier, amountBD, swapFee, expiryTimeout, baseSDPromise, depositToken, depositTokenPricePrefetchPromise, abortController.signal, metadata);
             metadata.times.securityDepositCalculated = Date.now();
             //Calculate claimer bounty
-            const totalClaimerBounty = yield this.getClaimerBounty(req, expiry, abortController.signal);
+            const totalClaimerBounty = await this.getClaimerBounty(req, expiry, abortController.signal);
             metadata.times.claimerBountyCalculated = Date.now();
             //Create swap data
-            const data = yield swapContract.createSwapData(base_1.ChainSwapType.CHAIN, signer.getAddress(), parsedBody.address, useToken, totalInToken, paymentHash.toString("hex"), parsedBody.sequence, expiry, new BN(0), this.config.confirmations, false, true, totalSecurityDeposit, totalClaimerBounty);
-            data.setTxoHash(this.getTxoHash(receiveAddress, amountBD).toString("hex"));
+            const data = await swapContract.createSwapData(base_1.ChainSwapType.CHAIN, signer.getAddress(), parsedBody.address, useToken, totalInToken, paymentHash.toString("hex"), parsedBody.sequence, expiry, false, true, totalSecurityDeposit, totalClaimerBounty, depositToken);
+            data.setExtraData(swapContract.getExtraData(this.bitcoin.toOutputScript(receiveAddress), amountBD, this.config.confirmations).toString("hex"));
             abortController.signal.throwIfAborted();
             metadata.times.swapCreated = Date.now();
             //Sign the swap
-            const sigData = yield this.getFromBtcSignatureData(chainIdentifier, data, req, abortController.signal, signDataPrefetchPromise);
+            const sigData = await this.getFromBtcSignatureData(chainIdentifier, data, req, abortController.signal, signDataPrefetchPromise);
             metadata.times.swapSigned = Date.now();
-            const createdSwap = new FromBtcSwapAbs_1.FromBtcSwapAbs(chainIdentifier, receiveAddress, amountBD, swapFee, swapFeeInToken);
+            const createdSwap = new FromBtcSwapAbs_1.FromBtcSwapAbs(chainIdentifier, receiveAddress, this.config.confirmations, amountBD, swapFee, swapFeeInToken);
             createdSwap.data = data;
             createdSwap.metadata = metadata;
             createdSwap.prefix = sigData.prefix;
             createdSwap.timeout = sigData.timeout;
             createdSwap.signature = sigData.signature;
             createdSwap.feeRate = sigData.feeRate;
-            yield PluginManager_1.PluginManager.swapCreate(createdSwap);
-            yield this.storageManager.saveData(createdSwap.data.getHash(), createdSwap.data.getSequence(), createdSwap);
+            await PluginManager_1.PluginManager.swapCreate(createdSwap);
+            await this.saveSwapData(createdSwap);
             this.swapLogger.info(createdSwap, "REST: /getAddress: Created swap address: " + receiveAddress + " amount: " + amountBD.toString(10));
-            yield responseStream.writeParamsAndEnd({
+            await responseStream.writeParamsAndEnd({
                 code: 20000,
                 msg: "Success",
                 data: {
@@ -349,30 +285,29 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                     address: signer.getAddress(),
                     swapFee: swapFeeInToken.toString(10),
                     total: totalInToken.toString(10),
+                    confirmations: this.config.confirmations,
                     data: data.serialize(),
                     prefix: sigData.prefix,
                     timeout: sigData.timeout,
                     signature: sigData.signature
                 }
             });
-        })));
+        }));
         this.logger.info("REST: Started at path: ", this.path);
     }
     /**
      * Initializes swap handler, loads data and subscribes to chain events
      */
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.storageManager.loadData(FromBtcSwapAbs_1.FromBtcSwapAbs);
-            this.subscribeToEvents();
-            yield PluginManager_1.PluginManager.serviceInitialize(this);
-        });
+    async init() {
+        await this.loadData(FromBtcSwapAbs_1.FromBtcSwapAbs);
+        this.subscribeToEvents();
+        await PluginManager_1.PluginManager.serviceInitialize(this);
     }
     getInfoData() {
         return {
             confirmations: this.config.confirmations,
             cltv: this.config.swapCsvDelta,
-            timestampCltv: this.config.swapTsCsvDelta.toNumber()
+            timestampCltv: Number(this.config.swapTsCsvDelta)
         };
     }
 }

package/dist/swaps/frombtc_abstract/FromBtcSwapAbs.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-import * as BN from "bn.js";
 import { SwapData } from "@atomiqlabs/base";
 import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
 export declare enum FromBtcSwapState {
@@ -11,13 +9,13 @@ export declare enum FromBtcSwapState {
 }
 export declare class FromBtcSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcSwapState> {
     readonly address: string;
+    readonly confirmations: number;
     txId: string;
-    constructor(chainIdentifier: string, address: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
+    constructor(chainIdentifier: string, address: string, confirmations: number, amount: bigint, swapFee: bigint, swapFeeInToken: bigint);
     constructor(obj: any);
     serialize(): any;
-    getTxoHash(): Buffer;
     isInitiated(): boolean;
     isFailed(): boolean;
     isSuccess(): boolean;
-    getTotalInputAmount(): BN;
+    getTotalInputAmount(): bigint;
 }

package/dist/swaps/frombtc_abstract/FromBtcSwapAbs.js

@@ -12,15 +12,17 @@ var FromBtcSwapState;
     FromBtcSwapState[FromBtcSwapState["CLAIMED"] = 2] = "CLAIMED";
 })(FromBtcSwapState = exports.FromBtcSwapState || (exports.FromBtcSwapState = {}));
 class FromBtcSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
-    constructor(prOrObj, address, amount, swapFee, swapFeeInToken) {
+    constructor(prOrObj, address, confirmations, amount, swapFee, swapFeeInToken) {
         if (typeof (prOrObj) === "string") {
             super(prOrObj, amount, swapFee, swapFeeInToken);
             this.state = FromBtcSwapState.CREATED;
             this.address = address;
+            this.confirmations = confirmations;
         }
         else {
             super(prOrObj);
             this.address = prOrObj.address;
+            this.confirmations = prOrObj.confirmations;
             this.txId = prOrObj.txId;
         }
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC;
@@ -28,12 +30,10 @@ class FromBtcSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.address = this.address;
+        partialSerialized.confirmations = this.confirmations;
         partialSerialized.txId = this.txId;
         return partialSerialized;
     }
-    getTxoHash() {
-        return Buffer.from(this.data.getTxoHash(), "hex");
-    }
     isInitiated() {
         return this.state !== FromBtcSwapState.CREATED;
     }

package/dist/swaps/frombtc_trusted/FromBtcTrusted.d.ts

@@ -3,7 +3,6 @@ import { FromBtcTrustedSwap, FromBtcTrustedSwapState } from "./FromBtcTrustedSwa
 import { BitcoinRpc, BtcBlock, BtcTx, ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
 import { Express } from "express";
 import { MultichainData, SwapHandlerType } from "../SwapHandler";
-import * as BN from "bn.js";
 import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
 import { ISwapPrice } from "../ISwapPrice";
 import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
@@ -14,11 +13,14 @@ export type FromBtcTrustedConfig = FromBtcBaseConfig & {
 };
 export type FromBtcTrustedRequestType = {
     address: string;
-    amount: BN;
-    exactOut?: boolean;
+    amount: bigint;
+    exactIn?: boolean;
+    refundAddress?: string;
+    token?: string;
 };
 export declare class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, FromBtcTrustedSwapState> {
     readonly type: SwapHandlerType;
+    readonly swapType: any;
     readonly config: FromBtcTrustedConfig;
     readonly bitcoin: IBitcoinWallet;
     readonly bitcoinRpc: BitcoinRpc<BtcBlock>;
@@ -29,8 +31,8 @@ export declare class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTruste
     readonly processedTxIds: Map<string, {
         scTxId: string;
         txId: string;
-        adjustedAmount: BN;
-        adjustedTotal: BN;
+        adjustedAmount: bigint;
+        adjustedTotal: bigint;
     }>;
     constructor(storageDirectory: IIntermediaryStorage<FromBtcTrustedSwap>, path: string, chains: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, bitcoinRpc: BitcoinRpc<BtcBlock>, config: FromBtcTrustedConfig);
     private getAllAncestors;
@@ -46,7 +48,7 @@ export declare class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTruste
     startWatchdog(): Promise<void>;
     init(): Promise<void>;
     getInfoData(): any;
-    protected processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void>;
-    protected processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void>;
-    protected processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void>;
+    protected processClaimEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: ClaimEvent<SwapData>): Promise<void>;
+    protected processInitializeEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: InitializeEvent<SwapData>): Promise<void>;
+    protected processRefundEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: RefundEvent<SwapData>): Promise<void>;
 }