@atomiqlabs/sdk 8.1.8 → 8.3.1

package/dist/swapper/SwapperUtils.js

@@ -14,47 +14,55 @@ const LNURLWithdraw_1 = require("../types/lnurl/LNURLWithdraw");
 const LNURLPay_1 = require("../types/lnurl/LNURLPay");
 const BitcoinWalletUtils_1 = require("../utils/BitcoinWalletUtils");
 /**
- * Utility class providing helper methods for swap operations
+ * Utility class providing helper methods for address parsing, token balances, serialization
+ *  and other miscellaneous things.
+ *
  * @category Core
  */
 class SwapperUtils {
     constructor(root) {
-        this.bitcoinNetwork = root.bitcoinNetwork;
+        this.bitcoinNetwork = root._btcNetwork;
         this.root = root;
     }
+    /**
+     * Checks whether a passed address is a valid address on the smart chain
+     *
+     * @param address Address
+     * @param chainId Smart chain identifier string to check the address for
+     */
     isValidSmartChainAddress(address, chainId) {
         if (chainId != null) {
-            if (this.root.chains[chainId] == null)
+            if (this.root._chains[chainId] == null)
                 throw new Error(`Unknown chain id: ${chainId}`);
-            return this.root.chains[chainId].chainInterface.isValidAddress(address);
+            return this.root._chains[chainId].chainInterface.isValidAddress(address);
         }
         for (let chainId of this.root.getSmartChains()) {
-            if (this.root.chains[chainId].chainInterface.isValidAddress(address))
+            if (this.root._chains[chainId].chainInterface.isValidAddress(address))
                 return true;
         }
         return false;
     }
     /**
-     * Returns true if string is a valid BOLT11 bitcoin lightning invoice
+     * Checks whether an address is a valid BOLT11 bitcoin lightning invoice
      *
-     * @param lnpr
+     * @param address Address to check
      */
-    isLightningInvoice(lnpr) {
+    isLightningInvoice(address) {
         try {
-            (0, bolt11_1.decode)(lnpr);
+            (0, bolt11_1.decode)(address);
             return true;
         }
         catch (e) { }
         return false;
     }
     /**
-     * Returns true if string is a valid bitcoin address
+     * Checks whether an address is a valid bitcoin address
      *
-     * @param addr
+     * @param address Address to check
      */
-    isValidBitcoinAddress(addr) {
+    isValidBitcoinAddress(address) {
         try {
-            (0, btc_signer_1.Address)(this.bitcoinNetwork).decode(addr);
+            (0, btc_signer_1.Address)(this.bitcoinNetwork).decode(address);
             return true;
         }
         catch (e) {
@@ -62,13 +70,13 @@ class SwapperUtils {
         }
     }
     /**
-     * Returns true if string is a valid BOLT11 bitcoin lightning invoice WITH AMOUNT
+     * Checks whether an address is a valid BOLT11 bitcoin lightning invoice WITH AMOUNT
      *
-     * @param lnpr
+     * @param address Address to check
      */
-    isValidLightningInvoice(lnpr) {
+    isValidLightningInvoice(address) {
         try {
-            const parsed = (0, bolt11_1.decode)(lnpr);
+            const parsed = (0, bolt11_1.decode)(address);
             if (parsed.millisatoshis != null)
                 return true;
         }
@@ -76,18 +84,18 @@ class SwapperUtils {
         return false;
     }
     /**
-     * Returns true if string is a valid LNURL (no checking on type is performed)
+     * Checks whether an address is a valid LNURL (no checking on type is performed)
      *
-     * @param lnurl
+     * @param address Address to check
      */
-    isValidLNURL(lnurl) {
-        return LNURL_1.LNURL.isLNURL(lnurl);
+    isValidLNURL(address) {
+        return LNURL_1.LNURL.isLNURL(address);
     }
     /**
      * Returns type and data about an LNURL
      *
-     * @param lnurl
-     * @param shouldRetry
+     * @param lnurl LNURL link to check, can be either `pay` or `withdraw` type
+     * @param shouldRetry Optional whether HTTP requests should retried on failure
      */
     getLNURLTypeAndData(lnurl, shouldRetry) {
         return LNURL_1.LNURL.getLNURLType(lnurl, shouldRetry);
@@ -194,7 +202,7 @@ class SwapperUtils {
     }
     parseSmartchainAddress(resultText) {
         for (let chainId of this.root.getSmartChains()) {
-            if (this.root.chains[chainId].chainInterface.isValidAddress(resultText)) {
+            if (this.root._chains[chainId].chainInterface.isValidAddress(resultText)) {
                 return {
                     address: resultText,
                     type: chainId,
@@ -205,12 +213,12 @@ class SwapperUtils {
         return null;
     }
     /**
-     * General parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, also fetches LNURL data
-     *  (hence returns Promise)
+     * General parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses. Also fetches LNURL data
+     *  (hence async and returns Promise).
      *
      * @param addressString Address to parse
      * @throws {Error} Error in address parsing
-     * @returns Address data or null if address doesn't conform to any known format
+     * @returns Address data or `null` if address doesn't conform to any known format
      */
     async parseAddress(addressString) {
         if (addressString.startsWith("bitcoin:")) {
@@ -242,11 +250,11 @@ class SwapperUtils {
     }
     /**
      * Synchronous general parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, doesn't fetch
-     *  LNURL data, reports swapType: null instead to prevent returning a Promise
+     *  LNURL data, returns `swapType: null` instead to prevent returning a Promise
      *
      * @param addressString Address to parse
      * @throws {Error} Error in address parsing
-     * @returns Address data or null if address doesn't conform to any known format
+     * @returns Address data or `null` if address doesn't conform to any known format
      */
     parseAddressSync(addressString) {
         if (addressString.startsWith("bitcoin:")) {
@@ -277,14 +285,15 @@ class SwapperUtils {
         return this.parseSmartchainAddress(addressString);
     }
     /**
-     * Returns a random PSBT that can be used for fee estimation, the last output (the LP output) is omitted
-     *  to allow for coinselection algorithm to determine maximum sendable amount there
+     * Returns a random PSBT that can be used for fee estimation for SPV vault (UTXO-controlled vault) based swaps
+     *  {@link SwapType.SPV_VAULT_FROM_BTC}, the last output (the LP output) is omitted to allow for coinselection
+     *  algorithm to determine maximum sendable amount there
      *
-     * @param chainIdentifier
-     * @param includeGasToken   Whether to return the PSBT also with the gas token amount (increases the vSize by 8)
+     * @param chainIdentifier Smart chain to swap to
+     * @param includeGasToken Whether to return the PSBT also with the gas token amount (increases the vSize by 8)
      */
     getRandomSpvVaultPsbt(chainIdentifier, includeGasToken) {
-        const wrapper = this.root.chains[chainIdentifier].wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC];
+        const wrapper = this.root._chains[chainIdentifier].wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC];
         if (wrapper == null)
             throw new Error("Chain doesn't support spv vault swaps!");
         return wrapper.getDummySwapPsbt(includeGasToken);
@@ -292,17 +301,19 @@ class SwapperUtils {
     /**
      * Returns the spendable balance of a bitcoin wallet
      *
-     * @param wallet
-     * @param targetChain
+     * @param wallet Bitcoin wallet to check the spendable balance for, can either be a simple
+     *  bitcoin address string or a wallet object
+     * @param targetChain Destination smart chain for the swap, the ensures proper spendable balance
+     *  is estimated taking into consideration different swap primitives available on different chains
      * @param options Additional options
      */
     async getBitcoinSpendableBalance(wallet, targetChain, options) {
         let bitcoinWallet;
         if (typeof (wallet) === "string") {
-            bitcoinWallet = new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(this.root.bitcoinRpc, this.bitcoinNetwork, { address: wallet, publicKey: "" });
+            bitcoinWallet = new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(this.root._bitcoinRpc, this.bitcoinNetwork, { address: wallet, publicKey: "" });
         }
         else {
-            bitcoinWallet = (0, BitcoinWalletUtils_1.toBitcoinWallet)(wallet, this.root.bitcoinRpc, this.bitcoinNetwork);
+            bitcoinWallet = (0, BitcoinWalletUtils_1.toBitcoinWallet)(wallet, this.root._bitcoinRpc, this.bitcoinNetwork);
         }
         let feeRate = options?.feeRate ?? await bitcoinWallet.getFeeRate();
         if (options?.minFeeRate != null)
@@ -320,12 +331,13 @@ class SwapperUtils {
         };
     }
     /**
-     * Returns the maximum spendable balance of the wallet, deducting the fee needed to initiate a swap for native balances
+     * Returns the maximum spendable balance of the smart chain wallet, deducting the fee needed
+     *  to initiate a swap for native balances
      */
     async getSpendableBalance(wallet, token, options) {
-        if (this.root.chains[token.chainId] == null)
+        if (this.root._chains[token.chainId] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + token.chainId);
-        const { swapContract, chainInterface } = this.root.chains[token.chainId];
+        const { swapContract, chainInterface } = this.root._chains[token.chainId];
         let signer;
         if (typeof (wallet) === "string") {
             signer = wallet;
@@ -353,12 +365,12 @@ class SwapperUtils {
         return (0, TokenAmount_1.toTokenAmount)(finalBalance, token, this.root.prices);
     }
     /**
-     * Returns the address of the native currency of the chain
+     * Returns the address of the native currency of the smart chain
      */
     getNativeToken(chainIdentifier) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.tokens[chainIdentifier][this.root.chains[chainIdentifier].chainInterface.getNativeCurrencyAddress()];
+        return this.root._tokens[chainIdentifier][this.root._chains[chainIdentifier].chainInterface.getNativeCurrencyAddress()];
     }
     /**
      * Returns a random signer for a given smart chain
@@ -366,9 +378,9 @@ class SwapperUtils {
      * @param chainIdentifier
      */
     randomSigner(chainIdentifier) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.randomSigner();
+        return this.root._chains[chainIdentifier].chainInterface.randomSigner();
     }
     /**
      * Returns a random address for a given smart chain
@@ -376,45 +388,80 @@ class SwapperUtils {
      * @param chainIdentifier
      */
     randomAddress(chainIdentifier) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.randomAddress();
+        return this.root._chains[chainIdentifier].chainInterface.randomAddress();
     }
     /**
      * Signs and broadcasts the supplied smart chain transaction
+     *
+     * @param chainIdentifier Smart chain identifier string
+     * @param signer Signer to use for signing the transactions
+     * @param txs An array of transactions to sign
+     * @param abortSignal Abort signal
+     * @param onBeforePublish Callback invoked before a transaction is sent (invoked for every transaction to be sent)
      */
     sendAndConfirm(chainIdentifier, signer, txs, abortSignal, onBeforePublish) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.sendAndConfirm(signer, txs, true, abortSignal, false, onBeforePublish);
+        return this.root._chains[chainIdentifier].chainInterface.sendAndConfirm(signer, txs, true, abortSignal, false, onBeforePublish);
     }
     /**
      * Broadcasts already signed smart chain transactions
+     *
+     * @param chainIdentifier Smart chain identifier string
+     * @param txs An array of already signed transactions
+     * @param abortSignal Abort signal
+     * @param onBeforePublish Callback invoked before a transaction is sent (invoked for every transaction to be sent)
      */
     sendSignedAndConfirm(chainIdentifier, txs, abortSignal, onBeforePublish) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.sendSignedAndConfirm(txs, true, abortSignal, false, onBeforePublish);
+        return this.root._chains[chainIdentifier].chainInterface.sendSignedAndConfirm(txs, true, abortSignal, false, onBeforePublish);
     }
+    /**
+     * Serializes an unsigned smart chain transaction
+     *
+     * @param chainIdentifier Smart chain string identifier
+     * @param tx An unsigned transaction to serialize
+     */
     serializeUnsignedTransaction(chainIdentifier, tx) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.serializeTx(tx);
+        return this.root._chains[chainIdentifier].chainInterface.serializeTx(tx);
     }
+    /**
+     * Deserializes an unsigned smart chain transaction
+     *
+     * @param chainIdentifier Smart chain string identifier
+     * @param tx Serialized unsigned transaction
+     */
     deserializeUnsignedTransaction(chainIdentifier, tx) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.deserializeTx(tx);
+        return this.root._chains[chainIdentifier].chainInterface.deserializeTx(tx);
     }
+    /**
+     * Serializes a signed smart chain transaction
+     *
+     * @param chainIdentifier Smart chain string identifier
+     * @param tx A signed transaction to serialize
+     */
     serializeSignedTransaction(chainIdentifier, tx) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.serializeSignedTx(tx);
+        return this.root._chains[chainIdentifier].chainInterface.serializeSignedTx(tx);
     }
+    /**
+     * Deserializes a signed smart chain transaction
+     *
+     * @param chainIdentifier Smart chain string identifier
+     * @param tx Serialized signed transaction
+     */
     deserializeSignedTransaction(chainIdentifier, tx) {
-        if (this.root.chains[chainIdentifier] == null)
+        if (this.root._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        return this.root.chains[chainIdentifier].chainInterface.deserializeSignedTx(tx);
+        return this.root._chains[chainIdentifier].chainInterface.deserializeSignedTx(tx);
     }
 }
 exports.SwapperUtils = SwapperUtils;