btc-wallet 0.5.11-beta → 0.5.12-beta

package/dist/utils/nearUtils.d.ts

@@ -1,7 +1,13 @@
 import type { ProviderService } from '@near-wallet-selector/core/src/lib/services';
 import { providers } from 'near-api-js';
-export declare function nearCallFunction<T>(contractId: string, methodName: string, args: any, options: {
+export declare function getNearProvider(option: {
     network?: string;
     provider?: ProviderService;
+}): ProviderService | providers.FailoverRpcProvider;
+export declare function nearCallFunction<T>(contractId: string, methodName: string, args: any, options?: {
+    network?: string;
+    provider?: ProviderService;
+    cacheTimeout?: number;
+    skipCache?: boolean;
 }): Promise<T>;
 export declare function pollTransactionStatuses(network: string, hashes: string[]): Promise<providers.FinalExecutionOutcome[]>;

package/dist/utils/request.d.ts

@@ -7,5 +7,6 @@ interface RequestOptions<T> extends RequestInit {
     maxPollingAttempts?: number;
     shouldStopPolling?: (response: T) => boolean;
 }
+export declare function withCache<T>(key: string, fetcher: () => Promise<T>, timeout?: number): Promise<T>;
 export default function request<T>(url: string, options?: RequestOptions<T>): Promise<T>;
 export {};

package/esm/index.js

@@ -368,11 +368,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) {
@@ -390,9 +390,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;
@@ -2820,7 +2834,10 @@ import { sha256 } from "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",
@@ -2828,7 +2845,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",
@@ -2836,7 +2856,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",
@@ -2844,7 +2867,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",
@@ -2870,69 +2896,24 @@ import Big from "big.js";
 
 // src/utils/nearUtils.ts
 import { providers } from "near-api-js";
-function nearCallFunction(contractId, methodName, args, options) {
-  return __async(this, null, function* () {
-    const nearProvider = (options == null ? void 0 : options.provider) || new providers.FailoverRpcProvider(
-      nearRpcUrls[options == null ? void 0 : options.network].map(
-        (url) => new 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 providers.FailoverRpcProvider(
-      Object.values(nearRpcUrls[network]).map(
-        (url) => new 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;
@@ -2974,13 +2955,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 });
@@ -2990,6 +2965,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 }));
@@ -3003,8 +2979,85 @@ function request(url, options) {
           }));
         }
       }
-      throw err;
+      return Promise.reject(err);
+    }
+  });
+}
+
+// src/utils/nearUtils.ts
+function getNearProvider(option) {
+  return option.provider || new providers.FailoverRpcProvider(
+    nearRpcUrls[option == null ? void 0 : option.network].map(
+      (url) => new 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 providers.FailoverRpcProvider(
+      Object.values(nearRpcUrls[network]).map(
+        (url) => new 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;
   });
 }
 
@@ -3161,9 +3214,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;
@@ -3172,16 +3226,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 Big(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 Big(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");
     }
@@ -3262,18 +3346,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 Big(rawBalance).div(__pow(10, 8)).round(8, Big.roundDown).toNumber();
-    const rawAvailableBalance = new Big(rawBalance).minus(1e3).toNumber();
-    const availableBalance = new Big(rawAvailableBalance).div(__pow(10, 8)).round(8, Big.roundDown).toNumber();
-    return { balance, availableBalance, rawBalance, rawAvailableBalance };
-  });
-}
 function sendBitcoin(address, amount, feeRate) {
   return __async(this, null, function* () {
     const { sendBitcoin: sendBitcoin2 } = getBtcProvider();
@@ -3293,7 +3365,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 {
@@ -3372,7 +3444,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) {
@@ -3386,12 +3458,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
         };
@@ -3597,7 +3669,7 @@ function getWithdrawTransaction(_0) {
     };
     const csna = yield getCsnaAccountId(env);
     const transaction = {
-      receiverId: config.token,
+      receiverId: config.btcToken,
       signerId: csna,
       actions: [
         {
@@ -4141,20 +4213,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);
       }
@@ -4162,14 +4230,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
@@ -4182,7 +4250,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;
@@ -4190,12 +4258,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;
     });
   }
@@ -4203,7 +4268,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",
@@ -4231,7 +4296,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)]
         );
       }
@@ -4252,31 +4317,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 Big2(0), btc: new Big2(0) }
+      );
+      const nearAvailableBalance = new Big2(nearBalance).minus(transferAmount.near).toNumber();
+      const btcAvailableBalance = new Big2(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);
@@ -4294,7 +4389,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 Big2(gasTokenBalance).gte(adjustedGas)) {
@@ -4410,7 +4505,7 @@ function setupBTCWallet({
 
 // src/index.ts
 var getVersion = () => {
-  return "0.5.11-beta";
+  return "0.5.12-beta";
 };
 if (typeof window !== "undefined") {
   window.__BTC_WALLET_VERSION = getVersion();
@@ -4440,7 +4535,7 @@ export {
   getConfig,
   getCsnaAccountId,
   getDepositAmount,
-  getNBTCBalance,
+  getTokenBalance,
   getVersion,
   getWithdrawTransaction,
   sendBitcoin,