btc-wallet 0.5.11-beta → 0.5.13-beta

package/dist/index.js

@@ -102,7 +102,7 @@ __export(src_exports, {
   getConfig: () => getConfig,
   getCsnaAccountId: () => getCsnaAccountId,
   getDepositAmount: () => getDepositAmount,
-  getNBTCBalance: () => getNBTCBalance,
+  getTokenBalance: () => getTokenBalance,
   getVersion: () => getVersion,
   getWithdrawTransaction: () => getWithdrawTransaction,
   sendBitcoin: () => sendBitcoin,
@@ -432,11 +432,11 @@ var MobileWalletConnect = class {
   }
   static redirectToWallet(walletId) {
     return __async(this, null, function* () {
-      var _a;
       if (isMobile()) {
         const currentUrl = window.location.href;
         const universalLink = this.getUniversalLink(walletId, currentUrl);
-        if (!universalLink) {
+        const showGuideDialog = () => __async(this, null, function* () {
+          var _a;
           try {
             yield (_a = navigator.clipboard) == null ? void 0 : _a.writeText(currentUrl);
           } catch (error) {
@@ -454,9 +454,23 @@ var MobileWalletConnect = class {
           `,
             dangerouslyUseHTML: true
           });
+        });
+        if (!universalLink) {
+          yield showGuideDialog();
           return false;
         }
+        const openWallet = () => {
+          const iframe = document.createElement("iframe");
+          iframe.style.display = "none";
+          iframe.src = universalLink;
+          document.body.appendChild(iframe);
+          setTimeout(() => __async(this, null, function* () {
+            document.body.removeChild(iframe);
+            yield showGuideDialog();
+          }), 2e3);
+        };
         window.location.href = universalLink;
+        setTimeout(openWallet, 100);
         return true;
       }
       return false;
@@ -2870,7 +2884,10 @@ var import_js_sha256 = require("js-sha256");
 var walletConfig = {
   dev: {
     base_url: "https://api.dev.satoshibridge.top",
-    token: "nbtc-dev.testnet",
+    btcToken: "nbtc-dev.testnet",
+    btcTokenDecimals: 8,
+    nearToken: "wrap.testnet",
+    nearTokenDecimals: 24,
     accountContractId: "acc-dev.testnet",
     bridgeContractId: "brg-dev.testnet",
     walletUrl: "https://wallet-dev.satoshibridge.top",
@@ -2878,7 +2895,10 @@ var walletConfig = {
   },
   testnet: {
     base_url: "https://api.testnet.satoshibridge.top",
-    token: "nbtc2-nsp.testnet",
+    btcToken: "nbtc2-nsp.testnet",
+    btcTokenDecimals: 8,
+    nearToken: "wrap.testnet",
+    nearTokenDecimals: 24,
     accountContractId: "acc2-nsp.testnet",
     bridgeContractId: "brg2-nsp.testnet",
     walletUrl: "https://wallet-test.satoshibridge.top",
@@ -2886,7 +2906,10 @@ var walletConfig = {
   },
   private_mainnet: {
     base_url: "https://api.stg.satoshibridge.top",
-    token: "nbtc.toalice.near",
+    btcToken: "nbtc.toalice.near",
+    btcTokenDecimals: 8,
+    nearToken: "wrap.near",
+    nearTokenDecimals: 24,
     accountContractId: "acc.toalice.near",
     bridgeContractId: "brg.toalice.near",
     walletUrl: "https://wallet-stg.satoshibridge.top",
@@ -2894,7 +2917,10 @@ var walletConfig = {
   },
   mainnet: {
     base_url: "https://api.satos.network",
-    token: "nbtc.bridge.near",
+    btcToken: "nbtc.bridge.near",
+    btcTokenDecimals: 8,
+    nearToken: "wrap.near",
+    nearTokenDecimals: 24,
     accountContractId: "acc.ref-labs.near",
     bridgeContractId: "btc-connector.bridge.near",
     walletUrl: "https://wallet.satoshibridge.top",
@@ -2920,69 +2946,24 @@ var import_big = __toESM(require("big.js"), 1);
 
 // src/utils/nearUtils.ts
 var import_near_api_js = require("near-api-js");
-function nearCallFunction(contractId, methodName, args, options) {
-  return __async(this, null, function* () {
-    const nearProvider = (options == null ? void 0 : options.provider) || new import_near_api_js.providers.FailoverRpcProvider(
-      nearRpcUrls[options == null ? void 0 : options.network].map(
-        (url) => new import_near_api_js.providers.JsonRpcProvider({ url })
-      )
-    );
-    const res = yield nearProvider.query({
-      request_type: "call_function",
-      account_id: contractId,
-      method_name: methodName,
-      args_base64: Buffer.from(JSON.stringify(args)).toString("base64"),
-      finality: "final"
-    });
-    return JSON.parse(Buffer.from(res.result).toString());
-  });
-}
-function pollTransactionStatuses(network, hashes) {
-  return __async(this, null, function* () {
-    const provider = new import_near_api_js.providers.FailoverRpcProvider(
-      Object.values(nearRpcUrls[network]).map(
-        (url) => new import_near_api_js.providers.JsonRpcProvider({ url })
-      )
-    );
-    const maxAttempts = 30;
-    let currentAttempt = 0;
-    const pendingHashes = new Set(hashes);
-    const results = /* @__PURE__ */ new Map();
-    while (pendingHashes.size > 0 && currentAttempt < maxAttempts) {
-      currentAttempt++;
-      const promises = Array.from(pendingHashes).map((hash) => __async(this, null, function* () {
-        try {
-          const result2 = yield provider.txStatus(hash, "unused", "FINAL");
-          if (result2 && result2.status) {
-            console.log(`Transaction ${hash} result:`, result2);
-            results.set(hash, result2);
-            pendingHashes.delete(hash);
-          }
-        } catch (error) {
-          console.error(`Failed to fetch transaction status for ${hash}: ${error.message}`);
-        }
-      }));
-      yield Promise.all(promises);
-      if (pendingHashes.size > 0) {
-        if (currentAttempt === maxAttempts) {
-          throw new Error(
-            `Transactions not found after max attempts: ${Array.from(pendingHashes).join(", ")}`
-          );
-        }
-        console.log(
-          `Waiting for ${pendingHashes.size} transactions, retrying ${maxAttempts - currentAttempt} more times`
-        );
-        yield delay(1e4);
-      }
-    }
-    const result = hashes.map((hash) => results.get(hash)).filter(Boolean);
-    return result;
-  });
-}
 
 // src/utils/request.ts
 var cache = /* @__PURE__ */ new Map();
 var defaultCacheTimeout = 3e3;
+function withCache(key, fetcher, timeout = defaultCacheTimeout) {
+  const cached = cache.get(key);
+  const isCacheValid = cached && Date.now() - cached.timestamp < timeout;
+  if (isCacheValid) {
+    return Promise.resolve(cached.data);
+  }
+  return fetcher().then((data) => {
+    cache.set(key, { timestamp: Date.now(), data });
+    setTimeout(() => {
+      cache.delete(key);
+    }, timeout);
+    return data;
+  });
+}
 function request(url, options) {
   return __async(this, null, function* () {
     var _a;
@@ -3024,13 +3005,7 @@ function request(url, options) {
         if (options.shouldStopPolling(data)) {
           return data;
         }
-        if (options.maxPollingAttempts && options.maxPollingAttempts > 0) {
-          yield new Promise((resolve) => setTimeout(resolve, options.pollingInterval));
-          return request(url, __spreadProps(__spreadValues({}, options), {
-            maxPollingAttempts: options.maxPollingAttempts - 1
-          }));
-        }
-        throw new Error("Polling failed: maximum attempts reached without meeting the condition");
+        throw new Error("Polling should continue");
       }
       if (cacheKey) {
         cache.set(cacheKey, { timestamp: Date.now(), data });
@@ -3040,6 +3015,7 @@ function request(url, options) {
       }
       return data;
     } catch (err) {
+      console.error(err);
       if (retryCount > 0) {
         console.log(`Retrying... attempts left: ${retryCount}`);
         return request(url, __spreadProps(__spreadValues({}, options), { retryCount: retryCount - 1 }));
@@ -3053,8 +3029,85 @@ function request(url, options) {
           }));
         }
       }
-      throw err;
+      return Promise.reject(err);
+    }
+  });
+}
+
+// src/utils/nearUtils.ts
+function getNearProvider(option) {
+  return option.provider || new import_near_api_js.providers.FailoverRpcProvider(
+    nearRpcUrls[option == null ? void 0 : option.network].map(
+      (url) => new import_near_api_js.providers.JsonRpcProvider({ url })
+    )
+  );
+}
+function nearCallFunction(_0, _1, _2) {
+  return __async(this, arguments, function* (contractId, methodName, args, options = {}) {
+    if (!options.skipCache) {
+      const cacheKey = `near:${contractId}:${methodName}:${args ? JSON.stringify(args) : ""}`;
+      return withCache(
+        cacheKey,
+        () => executeNearCall(contractId, methodName, args, options),
+        options.cacheTimeout
+      );
+    }
+    return executeNearCall(contractId, methodName, args, options);
+  });
+}
+function executeNearCall(contractId, methodName, args, options) {
+  return __async(this, null, function* () {
+    const nearProvider = getNearProvider(options);
+    const res = yield nearProvider.query({
+      request_type: "call_function",
+      account_id: contractId,
+      method_name: methodName,
+      args_base64: Buffer.from(JSON.stringify(args)).toString("base64"),
+      finality: "final"
+    });
+    return JSON.parse(Buffer.from(res.result).toString());
+  });
+}
+function pollTransactionStatuses(network, hashes) {
+  return __async(this, null, function* () {
+    const provider = new import_near_api_js.providers.FailoverRpcProvider(
+      Object.values(nearRpcUrls[network]).map(
+        (url) => new import_near_api_js.providers.JsonRpcProvider({ url })
+      )
+    );
+    const maxAttempts = 30;
+    let currentAttempt = 0;
+    const pendingHashes = new Set(hashes);
+    const results = /* @__PURE__ */ new Map();
+    while (pendingHashes.size > 0 && currentAttempt < maxAttempts) {
+      currentAttempt++;
+      const promises = Array.from(pendingHashes).map((hash) => __async(this, null, function* () {
+        try {
+          const result2 = yield provider.txStatus(hash, "unused", "FINAL");
+          if (result2 && result2.status) {
+            console.log(`Transaction ${hash} result:`, result2);
+            results.set(hash, result2);
+            pendingHashes.delete(hash);
+          }
+        } catch (error) {
+          console.error(`Failed to fetch transaction status for ${hash}: ${error.message}`);
+        }
+      }));
+      yield Promise.all(promises);
+      if (pendingHashes.size > 0) {
+        if (currentAttempt === maxAttempts) {
+          throw new Error(
+            `Transactions not found after max attempts: ${Array.from(pendingHashes).join(", ")}`
+          );
+        }
+        console.log(
+          `Waiting for ${pendingHashes.size} transactions, retrying ${maxAttempts - currentAttempt} more times`
+        );
+        yield delay(1e4);
+      }
     }
+    const result = hashes.map((hash) => results.get(hash)).filter(Boolean);
+    return result;
   });
 }
 
@@ -3211,9 +3264,10 @@ function nearCall(contractId, methodName, args) {
     return nearCallFunction(contractId, methodName, args, { network });
   });
 }
-function getAccountInfo(csna, accountContractId) {
-  return __async(this, null, function* () {
-    const accountInfo = yield nearCall(accountContractId, "get_account", {
+function getAccountInfo(_0) {
+  return __async(this, arguments, function* ({ csna, env }) {
+    const config = yield getConfig(env);
+    const accountInfo = yield nearCall(config.accountContractId, "get_account", {
       account_id: csna
     }).catch((error) => {
       return void 0;
@@ -3222,16 +3276,46 @@ function getAccountInfo(csna, accountContractId) {
     return accountInfo;
   });
 }
-function checkGasTokenBalance(csna, gasToken, minAmount, env) {
+function getTokenBalance(_0) {
+  return __async(this, arguments, function* ({
+    csna,
+    tokenId,
+    env
+  }) {
+    const network = yield getNetwork();
+    const config = yield getConfig(env);
+    const nearProvider = getNearProvider({ network });
+    try {
+      if (tokenId === config.nearToken) {
+        const nearAccount = yield nearProvider.query({
+          request_type: "view_account",
+          account_id: csna,
+          finality: "final"
+        });
+        const balance = parseFloat(nearAccount.amount) / __pow(10, config.nearTokenDecimals);
+        return { balance, rawBalance: nearAccount.amount };
+      } else {
+        const res = yield nearCall(tokenId, "ft_balance_of", { account_id: csna });
+        const decimals = tokenId === config.btcToken ? config.btcTokenDecimals : (yield nearCall(tokenId, "ft_metadata", {})).decimals;
+        const balance = parseFloat(res) / __pow(10, decimals);
+        return { balance, rawBalance: res };
+      }
+    } catch (error) {
+      console.error("getTokenBalance error:", error);
+      return { balance: 0, rawBalance: "0" };
+    }
+  });
+}
+function checkGasTokenBalance(csna, minAmount, env) {
   return __async(this, null, function* () {
-    const amount = yield nearCall(gasToken, "ft_balance_of", { account_id: csna });
-    console.log("gas token balance:", amount);
-    if (new import_big.default(amount).lt(minAmount)) {
+    const config = yield getConfig(env);
+    const { rawBalance } = yield getTokenBalance({ csna, tokenId: config.btcToken, env });
+    console.log("gas token balance:", rawBalance);
+    if (new import_big.default(rawBalance).lt(minAmount)) {
       yield Dialog.confirm({
         title: "Gas token balance is insufficient",
         message: "Please deposit gas token to continue, will open bridge website."
       });
-      const config = yield getConfig(env);
       window.open(config.bridgeUrl, "_blank");
       throw new Error("Gas token balance is insufficient");
     }
@@ -3312,18 +3396,6 @@ function getBtcBalance() {
     };
   });
 }
-function getNBTCBalance(address, env) {
-  return __async(this, null, function* () {
-    const config = yield getConfig(env || "mainnet");
-    const rawBalance = yield nearCall(config.token, "ft_balance_of", {
-      account_id: address
-    });
-    const balance = new import_big.default(rawBalance).div(__pow(10, 8)).round(8, import_big.default.roundDown).toNumber();
-    const rawAvailableBalance = new import_big.default(rawBalance).minus(1e3).toNumber();
-    const availableBalance = new import_big.default(rawAvailableBalance).div(__pow(10, 8)).round(8, import_big.default.roundDown).toNumber();
-    return { balance, availableBalance, rawBalance, rawAvailableBalance };
-  });
-}
 function sendBitcoin(address, amount, feeRate) {
   return __async(this, null, function* () {
     const { sendBitcoin: sendBitcoin2 } = getBtcProvider();
@@ -3343,7 +3415,7 @@ function getDepositAmount(amount, option) {
     const _newAccountMinDepositAmount = (_a = option == null ? void 0 : option.newAccountMinDepositAmount) != null ? _a : true;
     const config = yield getConfig(env);
     const csna = yield getCsnaAccountId(env);
-    const accountInfo = yield getAccountInfo(csna, config.accountContractId);
+    const accountInfo = yield getAccountInfo({ csna, env });
     const debtAction = yield checkGasTokenDebt(accountInfo, env, false);
     const repayAmount = (debtAction == null ? void 0 : debtAction.amount) || 0;
     const {
@@ -3422,7 +3494,7 @@ function executeBTCDepositAndAction(_0) {
         env,
         newAccountMinDepositAmount
       });
-      const accountInfo = yield getAccountInfo(csna, config.accountContractId);
+      const accountInfo = yield getAccountInfo({ csna, env });
       const newActions = [];
       const debtAction = yield checkGasTokenDebt(accountInfo, env, false);
       if (debtAction) {
@@ -3436,12 +3508,12 @@ function executeBTCDepositAndAction(_0) {
         }));
       }
       const storageDepositMsg = {};
-      const registerRes = yield nearCall((action == null ? void 0 : action.receiver_id) || config.token, "storage_balance_of", {
+      const registerRes = yield nearCall((action == null ? void 0 : action.receiver_id) || config.btcToken, "storage_balance_of", {
         account_id: csna
       });
       if (!(registerRes == null ? void 0 : registerRes.available)) {
         storageDepositMsg.storage_deposit_msg = {
-          contract_id: (action == null ? void 0 : action.receiver_id) || config.token,
+          contract_id: (action == null ? void 0 : action.receiver_id) || config.btcToken,
           deposit: registerDeposit || NEAR_STORAGE_DEPOSIT_AMOUNT,
           registration_only: true
         };
@@ -3536,7 +3608,7 @@ function getWithdrawTransaction(_0) {
     env = "mainnet"
   }) {
     const provider = getBtcProvider();
-    const btcAddress = yield provider.account;
+    const btcAddress = provider.account;
     const config = yield getConfig(env);
     const brgConfig = yield nearCall(config.bridgeContractId, "get_config", {});
     if (brgConfig.min_withdraw_amount) {
@@ -3560,7 +3632,7 @@ function getWithdrawTransaction(_0) {
       };
     });
     const _feeRate = feeRate || (yield getBtcGasPrice());
-    const { inputs, outputs, fee } = (0, import_coinselect.default)(
+    let { inputs, outputs, fee } = (0, import_coinselect.default)(
       utxos,
       [{ address: btcAddress, value: Number(amount) }],
       Math.ceil(_feeRate)
@@ -3569,32 +3641,61 @@ function getWithdrawTransaction(_0) {
       throw new Error("The network is busy, please try again later.");
     }
     const maxBtcFee = Number(brgConfig.max_btc_gas_fee);
-    const newFee = fee;
-    const withdrawChangeAddress = brgConfig.change_address;
-    if (newFee > maxBtcFee) {
+    const transactionFee = fee;
+    const changeAddress = brgConfig.change_address;
+    if (transactionFee > maxBtcFee) {
       throw new Error("Gas exceeds maximum value");
     }
-    let userOutput, noUserOutput;
+    let recipientOutput, changeOutput;
     for (let i = 0; i < outputs.length; i++) {
       const output = outputs[i];
       if (output.value.toString() === amount.toString()) {
-        userOutput = output;
+        recipientOutput = output;
       } else {
-        noUserOutput = output;
+        changeOutput = output;
       }
       if (!output.address) {
-        output.address = withdrawChangeAddress;
+        output.address = changeAddress;
       }
     }
-    userOutput.value = new import_big.default(userOutput.value).minus(newFee).minus(withdrawFee).toNumber();
-    if (noUserOutput) {
-      noUserOutput.value = new import_big.default(noUserOutput.value).plus(newFee).plus(withdrawFee).toNumber();
+    recipientOutput.value = new import_big.default(recipientOutput.value).minus(transactionFee).minus(withdrawFee).toNumber();
+    if (changeOutput) {
+      changeOutput.value = new import_big.default(changeOutput.value).plus(transactionFee).plus(withdrawFee).toNumber();
+      const remainingInputs = [...inputs];
+      let smallestInput = Math.min.apply(
+        null,
+        remainingInputs.map((input) => input.value)
+      );
+      let remainingChangeAmount = changeOutput.value;
+      while (remainingChangeAmount >= smallestInput && smallestInput > 0 && remainingInputs.length > 0) {
+        remainingChangeAmount -= smallestInput;
+        changeOutput.value = remainingChangeAmount;
+        const smallestInputIndex = remainingInputs.findIndex(
+          (input) => input.value === smallestInput
+        );
+        if (smallestInputIndex > -1) {
+          remainingInputs.splice(smallestInputIndex, 1);
+        }
+        smallestInput = Math.min.apply(
+          null,
+          remainingInputs.map((input) => input.value)
+        );
+      }
+      const minChangeAmount = Number(brgConfig.min_change_amount);
+      let additionalFee = 0;
+      if (changeOutput.value === 0) {
+        outputs = outputs.filter((item) => item.value !== 0);
+      } else if (changeOutput.value < minChangeAmount) {
+        additionalFee = minChangeAmount - changeOutput.value;
+        recipientOutput.value -= additionalFee;
+        changeOutput.value = minChangeAmount;
+      }
     } else {
-      noUserOutput = {
-        address: withdrawChangeAddress,
-        value: new import_big.default(newFee).plus(withdrawFee).toNumber()
+      changeOutput = {
+        address: changeAddress,
+        value: new import_big.default(transactionFee).plus(withdrawFee).toNumber()
       };
-      outputs.push(noUserOutput);
+      outputs.push(changeOutput);
     }
     const insufficientOutput = outputs.some((item) => item.value < 0);
     if (insufficientOutput) {
@@ -3602,7 +3703,7 @@ function getWithdrawTransaction(_0) {
     }
     const inputSum = inputs.reduce((sum, cur) => sum + Number(cur.value), 0);
     const outputSum = outputs.reduce((sum, cur) => sum + Number(cur.value), 0);
-    if (newFee + outputSum !== inputSum) {
+    if (transactionFee + outputSum !== inputSum) {
       throw new Error("compute error");
     }
     const network = yield getNetwork();
@@ -3647,7 +3748,7 @@ function getWithdrawTransaction(_0) {
     };
     const csna = yield getCsnaAccountId(env);
     const transaction = {
-      receiverId: config.token,
+      receiverId: config.btcToken,
       signerId: csna,
       actions: [
         {
@@ -4191,20 +4292,16 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         throw new Error("Wallet state is invalid, please reconnect your wallet.");
       }
       const btcContext = window.btcContext;
-      const accountId = state.getAccount();
-      const accountInfo = yield getAccountInfo(accountId, currentConfig.accountContractId);
+      const csna = state.getAccount();
+      const accountInfo = yield getAccountInfo({ csna, env });
       yield checkGasTokenDebt(accountInfo, env, true);
       const trans = [...params.transactions];
       console.log("signAndSendTransactions raw trans:", trans);
-      const gasTokenBalance = (accountInfo == null ? void 0 : accountInfo.gas_token[currentConfig.token]) || "0";
-      const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy(
-        gasTokenBalance,
-        trans
-      );
+      const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy(trans);
       console.log("transferGasTransaction:", transferGasTransaction);
       console.log("useNearPayGas:", useNearPayGas);
       console.log("gasLimit:", gasLimit);
-      yield checkGasTokenBalance(accountId, currentConfig.token, gasLimit, env);
+      yield checkGasTokenBalance(csna, gasLimit, env);
       if (transferGasTransaction) {
         trans.unshift(transferGasTransaction);
       }
@@ -4212,14 +4309,14 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       const newTrans = yield Promise.all(
         trans.map((transaction, index) => convertTransactionToTxHex(transaction, index))
       );
-      const nonceFromApi = yield getNonce(currentConfig.base_url, accountId);
+      const nonceFromApi = yield getNonce(currentConfig.base_url, csna);
       const nonceFromContract = (accountInfo == null ? void 0 : accountInfo.nonce) || 0;
       const nonce = Number(nonceFromApi) > Number(nonceFromContract) ? String(nonceFromApi) : String(nonceFromContract);
       const intention = {
         chain_id: "397",
-        csna: accountId,
+        csna,
         near_transactions: newTrans.map((t) => t.txHex),
-        gas_token: currentConfig.token,
+        gas_token: currentConfig.btcToken,
         gas_limit: gasLimit,
         use_near_pay_gas: useNearPayGas,
         nonce
@@ -4232,7 +4329,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         data: toHex(strIntention)
       });
       yield checkBtcTransactionStatus(currentConfig.base_url, signature);
-      const hash = newTrans.map((t) => t.hash);
+      const hash = newTrans.slice(1).map((t) => t.hash);
       console.log("txHash:", hash);
       const result = yield pollTransactionStatuses(options.network.networkId, hash);
       return result;
@@ -4240,12 +4337,9 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   }
   function calculateGasLimit(params) {
     return __async(this, null, function* () {
-      const accountId = state.getAccount();
-      const accountInfo = yield getAccountInfo(accountId, currentConfig.accountContractId);
       const trans = [...params.transactions];
       console.log("raw trans:", trans);
-      const gasTokenBalance = (accountInfo == null ? void 0 : accountInfo.gas_token[currentConfig.token]) || "0";
-      const { gasLimit } = yield calculateGasStrategy(gasTokenBalance, trans);
+      const { gasLimit } = yield calculateGasStrategy(trans);
       return gasLimit;
     });
   }
@@ -4253,7 +4347,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
     return __async(this, null, function* () {
       return {
         signerId: accountId,
-        receiverId: currentConfig.token,
+        receiverId: currentConfig.btcToken,
         actions: [
           {
             type: "FunctionCall",
@@ -4281,7 +4375,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       } else {
         newGasLimit = yield getPredictedGasAmount(
           currentConfig.accountContractId,
-          currentConfig.token,
+          currentConfig.btcToken,
           [transferTxHex, ...transactions2.map((t) => t.txHex)]
         );
       }
@@ -4302,31 +4396,61 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       return gasAmount.toString();
     });
   }
-  function calculateGasStrategy(gasTokenBalance, transactions2) {
+  function calculateGasStrategy(transactions2) {
     return __async(this, null, function* () {
       var _a;
       const accountId = state.getAccount();
-      const nearAccount = yield provider.query({
-        request_type: "view_account",
-        account_id: accountId,
-        finality: "final"
+      const accountInfo = yield getAccountInfo({ csna: accountId, env });
+      const gasTokenBalance = (accountInfo == null ? void 0 : accountInfo.gas_token[currentConfig.btcToken]) || "0";
+      const { balance: nearBalance } = yield getTokenBalance({
+        csna: accountId,
+        tokenId: currentConfig.nearToken,
+        env
       });
-      const availableBalance = parseFloat(nearAccount.amount) / __pow(10, 24);
-      console.log("available near balance:", availableBalance);
+      const { balance: btcBalance } = yield getTokenBalance({
+        csna: accountId,
+        tokenId: currentConfig.btcToken,
+        env
+      });
+      const transferAmount = transactions2.reduce(
+        (acc, tx) => {
+          tx.actions.forEach((action) => {
+            if (action.params.deposit) {
+              const amount = Number(action.params.deposit) / __pow(10, currentConfig.nearTokenDecimals);
+              console.log("near deposit amount:", amount);
+              acc.near = acc.near.plus(amount);
+            }
+            if (tx.receiverId === currentConfig.btcToken && ["ft_transfer_call", "ft_transfer"].includes(action.params.methodName)) {
+              const amount = Number(action.params.args.amount) / __pow(10, currentConfig.btcTokenDecimals);
+              console.log("btc transfer amount:", amount);
+              acc.btc = acc.btc.plus(amount);
+            }
+          });
+          return acc;
+        },
+        { near: new import_big2.default(0), btc: new import_big2.default(0) }
+      );
+      const nearAvailableBalance = new import_big2.default(nearBalance).minus(transferAmount.near).toNumber();
+      const btcAvailableBalance = new import_big2.default(btcBalance).minus(transferAmount.btc).toNumber();
+      if (btcAvailableBalance < 8e-6) {
+        throw new Error("BTC balance is not enough, please deposit more BTC.");
+      }
+      console.log("available near balance:", nearAvailableBalance);
+      console.log("available btc balance:", btcAvailableBalance);
       console.log("available gas token balance:", gasTokenBalance);
       const convertTx = yield Promise.all(
         transactions2.map((transaction, index) => convertTransactionToTxHex(transaction, index))
       );
-      if (availableBalance > 0.5) {
+      if (nearAvailableBalance > 0.5) {
         console.log("near balance is enough, get the protocol fee of each transaction");
         const gasTokens = yield nearCall2(
           currentConfig.accountContractId,
           "list_gas_token",
-          { token_ids: [currentConfig.token] }
+          { token_ids: [currentConfig.btcToken] }
         );
         console.log("list_gas_token gas tokens:", gasTokens);
         const perTxFee = Math.max(
-          Number(((_a = gasTokens[currentConfig.token]) == null ? void 0 : _a.per_tx_protocol_fee) || 0),
+          Number(((_a = gasTokens[currentConfig.btcToken]) == null ? void 0 : _a.per_tx_protocol_fee) || 0),
           100
         );
         console.log("perTxFee:", perTxFee);
@@ -4344,7 +4468,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         console.log("near balance is not enough, predict the gas token amount required");
         const adjustedGas = yield getPredictedGasAmount(
           currentConfig.accountContractId,
-          currentConfig.token,
+          currentConfig.btcToken,
           convertTx.map((t) => t.txHex)
         );
         if (new import_big2.default(gasTokenBalance).gte(adjustedGas)) {
@@ -4460,7 +4584,7 @@ function setupBTCWallet({
 
 // src/index.ts
 var getVersion = () => {
-  return "0.5.11-beta";
+  return "0.5.13-beta";
 };
 if (typeof window !== "undefined") {
   window.__BTC_WALLET_VERSION = getVersion();