btc-wallet 0.5.14-beta → 0.5.16-beta

package/dist/index.js

@@ -91,18 +91,14 @@ __export(src_exports, {
   UnisatConnector: () => UnisatConnector,
   WizzConnector: () => WizzConnector,
   XverseConnector: () => XverseConnector,
-  checkGasTokenBalance: () => checkGasTokenBalance,
   checkGasTokenDebt: () => checkGasTokenDebt,
   checkSatoshiWhitelist: () => checkSatoshiWhitelist,
   estimateDepositAmount: () => estimateDepositAmount,
   executeBTCDepositAndAction: () => executeBTCDepositAndAction,
-  getAccountInfo: () => getAccountInfo,
   getBtcBalance: () => getBtcBalance,
   getBtcGasPrice: () => getBtcGasPrice,
-  getConfig: () => getConfig,
   getCsnaAccountId: () => getCsnaAccountId,
   getDepositAmount: () => getDepositAmount,
-  getTokenBalance: () => getTokenBalance,
   getVersion: () => getVersion,
   getWithdrawTransaction: () => getWithdrawTransaction,
   sendBitcoin: () => sendBitcoin,
@@ -2871,15 +2867,6 @@ function useBtcWalletSelector() {
   return hook;
 }
 
-// src/core/setupBTCWallet.ts
-var import_near_api_js2 = require("near-api-js");
-var import_transactions = require("@near-js/transactions");
-var import_key_pair = require("near-api-js/lib/utils/key_pair");
-var import_transaction = require("near-api-js/lib/transaction");
-var import_utils10 = require("@near-js/utils");
-var import_bs58 = __toESM(require("bs58"), 1);
-var import_js_sha256 = require("js-sha256");
-
 // src/config.ts
 var walletConfig = {
   dev: {
@@ -2927,6 +2914,13 @@ var walletConfig = {
     bridgeUrl: "https://ramp.satos.network"
   }
 };
+function getWalletConfig(env) {
+  const config = walletConfig[env];
+  const network = env === "mainnet" || env === "private_mainnet" ? "mainnet" : "testnet";
+  return __spreadProps(__spreadValues({}, config), {
+    network
+  });
+}
 var nearRpcUrls = {
   mainnet: [
     "https://near.lava.build",
@@ -2942,7 +2936,7 @@ var btcRpcUrls = {
 };
 
 // src/core/btcUtils.ts
-var import_big = __toESM(require("big.js"), 1);
+var import_big2 = __toESM(require("big.js"), 1);
 
 // src/utils/nearUtils.ts
 var import_near_api_js = require("near-api-js");
@@ -3049,7 +3043,7 @@ function nearCallFunction(_0, _1, _2) {
       return withCache(
         cacheKey,
         () => executeNearCall(contractId, methodName, args, options),
-        options.cacheTimeout
+        options.cacheTimeout || 5e3
       );
     }
     return executeNearCall(contractId, methodName, args, options);
@@ -3111,6 +3105,95 @@ function pollTransactionStatuses(network, hashes) {
   });
 }
 
+// src/utils/satoshi.ts
+var import_transactions = require("@near-js/transactions");
+var import_key_pair = require("near-api-js/lib/utils/key_pair");
+var import_transaction = require("near-api-js/lib/transaction");
+var import_utils9 = require("@near-js/utils");
+var import_bs58 = __toESM(require("bs58"), 1);
+var import_js_sha256 = require("js-sha256");
+var import_near_api_js2 = require("near-api-js");
+var import_big = __toESM(require("big.js"), 1);
+
+// src/core/setupBTCWallet/state.ts
+var STORAGE_KEYS = {
+  ACCOUNT: "btc-wallet-account",
+  PUBLIC_KEY: "btc-wallet-publickey",
+  BTC_PUBLIC_KEY: "btc-wallet-btc-publickey"
+};
+var state_default = {
+  saveAccount(account) {
+    if (!account) {
+      this.removeAccount();
+      return;
+    }
+    window.localStorage.setItem(STORAGE_KEYS.ACCOUNT, account);
+  },
+  removeAccount() {
+    window.localStorage.removeItem(STORAGE_KEYS.ACCOUNT);
+  },
+  savePublicKey(publicKey) {
+    if (!publicKey) {
+      this.removePublicKey();
+      return;
+    }
+    window.localStorage.setItem(STORAGE_KEYS.PUBLIC_KEY, publicKey);
+  },
+  removePublicKey() {
+    window.localStorage.removeItem(STORAGE_KEYS.PUBLIC_KEY);
+  },
+  saveBtcPublicKey(publicKey) {
+    if (!publicKey) {
+      this.removeBtcPublicKey();
+      return;
+    }
+    window.localStorage.setItem(STORAGE_KEYS.BTC_PUBLIC_KEY, publicKey);
+  },
+  removeBtcPublicKey() {
+    window.localStorage.removeItem(STORAGE_KEYS.BTC_PUBLIC_KEY);
+  },
+  clear() {
+    this.removeAccount();
+    this.removePublicKey();
+    this.removeBtcPublicKey();
+  },
+  save(account, publicKey) {
+    if (!account || !publicKey) {
+      this.clear();
+      return;
+    }
+    this.saveAccount(account);
+    this.savePublicKey(publicKey);
+  },
+  getAccount() {
+    return window.localStorage.getItem(STORAGE_KEYS.ACCOUNT) || "";
+  },
+  getPublicKey() {
+    return window.localStorage.getItem(STORAGE_KEYS.PUBLIC_KEY) || "";
+  },
+  getBtcPublicKey() {
+    return window.localStorage.getItem(STORAGE_KEYS.BTC_PUBLIC_KEY) || "";
+  },
+  isValid() {
+    const account = this.getAccount();
+    const publicKey = this.getPublicKey();
+    const btcPublicKey = this.getBtcPublicKey();
+    const allEmpty = !account && !publicKey && !btcPublicKey;
+    const allExist = account && publicKey && btcPublicKey;
+    return allEmpty || allExist;
+  },
+  syncSave(account, publicKey, btcPublicKey) {
+    if (!account || !publicKey || !btcPublicKey) {
+      this.clear();
+      return;
+    }
+    this.clear();
+    this.savePublicKey(publicKey);
+    this.saveBtcPublicKey(btcPublicKey);
+    this.saveAccount(account);
+  }
+};
+
 // src/utils/satoshi.ts
 function getNonce(url, accountId) {
   return __async(this, null, function* () {
@@ -3226,50 +3309,17 @@ function getWhitelist(url) {
     return data;
   });
 }
-
-// src/core/btcUtils.ts
-var import_bitcoinjs_lib = __toESM(require("bitcoinjs-lib"), 1);
-var import_coinselect = __toESM(require("coinselect"), 1);
-var NEAR_STORAGE_DEPOSIT_AMOUNT = "1250000000000000000000";
-var NBTC_STORAGE_DEPOSIT_AMOUNT = "3000";
-var GAS_LIMIT = "50000000000000";
-var NEW_ACCOUNT_MIN_DEPOSIT_AMOUNT = "1000";
-function getBtcProvider() {
-  if (typeof window === "undefined" || !window.btcContext) {
-    throw new Error("BTC Provider is not initialized.");
-  }
-  return window.btcContext;
-}
-function getNetwork() {
-  return __async(this, null, function* () {
-    const network = yield getBtcProvider().getNetwork();
-    console.log("btc network:", network);
-    return network === "livenet" ? "mainnet" : "testnet";
-  });
-}
-function getBtcRpcUrl() {
-  return __async(this, null, function* () {
-    const network = yield getNetwork();
-    return btcRpcUrls[network];
-  });
-}
-function getConfig(env) {
-  return __async(this, null, function* () {
-    return walletConfig[env];
-  });
-}
-function nearCall(contractId, methodName, args) {
-  return __async(this, null, function* () {
-    const network = yield getNetwork();
-    return nearCallFunction(contractId, methodName, args, { network });
-  });
-}
 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) => {
+    const config = getWalletConfig(env);
+    const accountInfo = yield nearCallFunction(
+      config.accountContractId,
+      "get_account",
+      {
+        account_id: csna
+      },
+      { network: config.network }
+    ).catch((error) => {
       return void 0;
     });
     console.log("get_account accountInfo:", accountInfo);
@@ -3282,9 +3332,8 @@ function getTokenBalance(_0) {
     tokenId,
     env
   }) {
-    const network = yield getNetwork();
-    const config = yield getConfig(env);
-    const nearProvider = getNearProvider({ network });
+    const config = getWalletConfig(env);
+    const nearProvider = getNearProvider({ network: config.network });
     try {
       if (tokenId === config.nearToken) {
         const nearAccount = yield nearProvider.query({
@@ -3295,8 +3344,18 @@ function getTokenBalance(_0) {
         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 res = yield nearCallFunction(
+          tokenId,
+          "ft_balance_of",
+          { account_id: csna },
+          { network: config.network }
+        );
+        const decimals = tokenId === config.btcToken ? config.btcTokenDecimals : (yield nearCallFunction(
+          tokenId,
+          "ft_metadata",
+          {},
+          { network: config.network }
+        )).decimals;
         const balance = parseFloat(res) / __pow(10, decimals);
         return { balance, rawBalance: res };
       }
@@ -3308,7 +3367,7 @@ function getTokenBalance(_0) {
 }
 function checkGasTokenBalance(csna, minAmount, env) {
   return __async(this, null, function* () {
-    const config = yield getConfig(env);
+    const config = getWalletConfig(env);
     const { rawBalance } = yield getTokenBalance({ csna, tokenId: config.btcToken, env });
     console.log("gas token balance:", rawBalance);
     if (new import_big.default(rawBalance).lt(minAmount)) {
@@ -3321,16 +3380,308 @@ function checkGasTokenBalance(csna, minAmount, env) {
     }
   });
 }
-function checkGasTokenDebt(accountInfo, env, autoDeposit) {
+var { functionCall, transfer } = import_transactions.actionCreators;
+function convertTransactionToTxHex(_0) {
+  return __async(this, arguments, function* ({
+    transaction,
+    accountId,
+    publicKey,
+    env,
+    index = 0
+  }) {
+    const publicKeyFormat = import_key_pair.PublicKey.from(publicKey);
+    const currentConfig = getWalletConfig(env);
+    const provider = getNearProvider({ network: currentConfig.network });
+    const { header } = yield provider.block({
+      finality: "final"
+    });
+    const rawAccessKey = yield provider.query({
+      request_type: "view_access_key",
+      account_id: accountId,
+      public_key: publicKey,
+      finality: "final"
+    }).catch((e) => {
+      console.log("view_access_key error:", e);
+      return void 0;
+    });
+    const accessKey = __spreadProps(__spreadValues({}, rawAccessKey), {
+      nonce: BigInt((rawAccessKey == null ? void 0 : rawAccessKey.nonce) || 0)
+    });
+    const nearNonceFromApi = yield getNearNonce(currentConfig.base_url, accountId);
+    let nearNonceNumber = accessKey.nonce + BigInt(1);
+    if (nearNonceFromApi) {
+      nearNonceNumber = BigInt(nearNonceFromApi) > nearNonceNumber ? BigInt(nearNonceFromApi) : nearNonceNumber;
+    }
+    const newActions = transaction.actions.map((action) => {
+      switch (action.type) {
+        case "FunctionCall":
+          return functionCall(
+            action.params.methodName,
+            action.params.args,
+            BigInt(action.params.gas),
+            BigInt(action.params.deposit)
+          );
+        case "Transfer":
+          return transfer(BigInt(action.params.deposit));
+      }
+    }).filter(Boolean);
+    const _transaction = import_near_api_js2.transactions.createTransaction(
+      accountId,
+      publicKeyFormat,
+      transaction.receiverId,
+      BigInt(nearNonceNumber) + BigInt(index),
+      newActions,
+      (0, import_utils9.baseDecode)(header.hash)
+    );
+    const txBytes = (0, import_transaction.encodeTransaction)(_transaction);
+    const txHex = Array.from(txBytes, (byte) => ("0" + (byte & 255).toString(16)).slice(-2)).join(
+      ""
+    );
+    const hash = import_bs58.default.encode(new Uint8Array(import_js_sha256.sha256.array(txBytes)));
+    return { txBytes, txHex, hash };
+  });
+}
+function calculateGasLimit(params) {
+  return __async(this, null, function* () {
+    const trans = [...params.transactions];
+    console.log("raw trans:", trans);
+    const { gasLimit } = yield calculateGasStrategy(params);
+    return gasLimit;
+  });
+}
+function calculateGasStrategy(_0) {
+  return __async(this, arguments, function* ({
+    csna,
+    transactions: transactions2,
+    env
+  }) {
+    var _a;
+    const currentConfig = getWalletConfig(env);
+    const accountInfo = yield getAccountInfo({ csna, env });
+    const gasTokenBalance = (accountInfo == null ? void 0 : accountInfo.gas_token[currentConfig.btcToken]) || "0";
+    const { balance: nearBalance } = yield getTokenBalance({
+      csna,
+      tokenId: currentConfig.nearToken,
+      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_big.default(0), btc: new import_big.default(0) }
+    );
+    const nearAvailableBalance = new import_big.default(nearBalance).minus(transferAmount.near).toNumber();
+    console.log("available near balance:", nearAvailableBalance);
+    console.log("available gas token balance:", gasTokenBalance);
+    const convertTx = yield Promise.all(
+      transactions2.map(
+        (transaction, index) => convertTransactionToTxHex({
+          transaction,
+          accountId: state_default.getAccount(),
+          publicKey: state_default.getPublicKey(),
+          index,
+          env
+        })
+      )
+    );
+    if (nearAvailableBalance > 0.5) {
+      console.log("near balance is enough, get the protocol fee of each transaction");
+      const gasTokens = yield nearCallFunction(
+        currentConfig.accountContractId,
+        "list_gas_token",
+        { token_ids: [currentConfig.btcToken] },
+        { network: currentConfig.network }
+      );
+      console.log("list_gas_token gas tokens:", gasTokens);
+      const perTxFee = Math.max(
+        Number(((_a = gasTokens[currentConfig.btcToken]) == null ? void 0 : _a.per_tx_protocol_fee) || 0),
+        100
+      );
+      console.log("perTxFee:", perTxFee);
+      const protocolFee = new import_big.default(perTxFee || "0").mul(convertTx.length).toFixed(0);
+      console.log("protocolFee:", protocolFee);
+      if (new import_big.default(gasTokenBalance).gte(protocolFee)) {
+        console.log("use near pay gas and enough gas token balance");
+        return { useNearPayGas: true, gasLimit: protocolFee };
+      } else {
+        console.log("use near pay gas and not enough gas token balance");
+        const transferTx = yield createGasTokenTransfer({ csna, amount: protocolFee, env });
+        return recalculateGasWithTransfer({
+          csna,
+          transferTx,
+          transactions: convertTx,
+          useNearPayGas: true,
+          perTxFee: perTxFee.toString(),
+          env
+        });
+      }
+    } else {
+      console.log("near balance is not enough, predict the gas token amount required");
+      const adjustedGas = yield getPredictedGasAmount({
+        accountContractId: currentConfig.accountContractId,
+        tokenId: currentConfig.btcToken,
+        transactions: convertTx.map((t) => t.txHex),
+        env
+      });
+      if (new import_big.default(gasTokenBalance).gte(adjustedGas)) {
+        console.log("use gas token and gas token balance is enough");
+        return { useNearPayGas: false, gasLimit: adjustedGas };
+      } else {
+        console.log("use gas token and gas token balance is not enough, need to transfer");
+        const transferTx = yield createGasTokenTransfer({ csna, amount: adjustedGas, env });
+        return recalculateGasWithTransfer({
+          csna,
+          transferTx,
+          transactions: convertTx,
+          useNearPayGas: false,
+          env
+        });
+      }
+    }
+  });
+}
+function createGasTokenTransfer(_0) {
+  return __async(this, arguments, function* ({
+    csna,
+    amount,
+    env
+  }) {
+    const currentConfig = getWalletConfig(env);
+    return {
+      signerId: csna,
+      receiverId: currentConfig.btcToken,
+      actions: [
+        {
+          type: "FunctionCall",
+          params: {
+            methodName: "ft_transfer_call",
+            args: {
+              receiver_id: currentConfig.accountContractId,
+              amount,
+              msg: JSON.stringify("Repay")
+            },
+            gas: new import_big.default(50).mul(__pow(10, 12)).toFixed(0),
+            deposit: "1"
+          }
+        }
+      ]
+    };
+  });
+}
+function recalculateGasWithTransfer(_0) {
+  return __async(this, arguments, function* ({
+    csna,
+    transferTx,
+    transactions: transactions2,
+    useNearPayGas,
+    perTxFee,
+    env
+  }) {
+    const currentConfig = getWalletConfig(env);
+    const { txHex: transferTxHex } = yield convertTransactionToTxHex({
+      transaction: transferTx,
+      accountId: state_default.getAccount(),
+      publicKey: state_default.getPublicKey(),
+      index: 0,
+      env
+    });
+    let newGasLimit;
+    if (useNearPayGas && perTxFee) {
+      newGasLimit = new import_big.default(perTxFee).mul(transactions2.length + 1).toFixed(0);
+    } else {
+      newGasLimit = yield getPredictedGasAmount({
+        accountContractId: currentConfig.accountContractId,
+        tokenId: currentConfig.btcToken,
+        transactions: [transferTxHex, ...transactions2.map((t) => t.txHex)],
+        env
+      });
+    }
+    transferTx.actions[0].params.args.amount = newGasLimit;
+    return { transferGasTransaction: transferTx, useNearPayGas, gasLimit: newGasLimit };
+  });
+}
+function getPredictedGasAmount(_0) {
+  return __async(this, arguments, function* ({
+    accountContractId,
+    tokenId,
+    transactions: transactions2,
+    env
+  }) {
+    const currentConfig = getWalletConfig(env);
+    const predictedGas = yield nearCallFunction(
+      accountContractId,
+      "predict_txs_gas_token_amount",
+      {
+        gas_token_id: tokenId,
+        near_transactions: transactions2
+      },
+      { network: currentConfig.network }
+    );
+    const predictedGasAmount = new import_big.default(predictedGas).mul(1.2).toFixed(0);
+    const miniGasAmount = 200 * transactions2.length;
+    const gasAmount = Math.max(Number(predictedGasAmount), miniGasAmount);
+    console.log("predictedGas:", predictedGasAmount);
+    return gasAmount.toString();
+  });
+}
+
+// src/core/btcUtils.ts
+var import_bitcoinjs_lib = __toESM(require("bitcoinjs-lib"), 1);
+var ecc = __toESM(require("@bitcoinerlab/secp256k1"), 1);
+var import_coinselect = __toESM(require("coinselect"), 1);
+import_bitcoinjs_lib.default.initEccLib(ecc);
+var NEAR_STORAGE_DEPOSIT_AMOUNT = "1250000000000000000000";
+var NBTC_STORAGE_DEPOSIT_AMOUNT = "3000";
+var GAS_LIMIT = "50000000000000";
+var NEW_ACCOUNT_MIN_DEPOSIT_AMOUNT = "1000";
+function getBtcProvider() {
+  if (typeof window === "undefined" || !window.btcContext) {
+    throw new Error("BTC Provider is not initialized.");
+  }
+  return window.btcContext;
+}
+function getNetwork() {
+  return __async(this, null, function* () {
+    const network = yield getBtcProvider().getNetwork();
+    console.log("btc network:", network);
+    return network === "livenet" ? "mainnet" : "testnet";
+  });
+}
+function getBtcRpcUrl() {
+  return __async(this, null, function* () {
+    const network = yield getNetwork();
+    return btcRpcUrls[network];
+  });
+}
+function nearCall(contractId, methodName, args) {
+  return __async(this, null, function* () {
+    const network = yield getNetwork();
+    return nearCallFunction(contractId, methodName, args, { network });
+  });
+}
+function checkGasTokenDebt(csna, env, autoDeposit) {
   return __async(this, null, function* () {
     var _a, _b, _c;
-    const debtAmount = new import_big.default(((_a = accountInfo == null ? void 0 : accountInfo.debt_info) == null ? void 0 : _a.near_gas_debt_amount) || 0).plus(((_b = accountInfo == null ? void 0 : accountInfo.debt_info) == null ? void 0 : _b.protocol_fee_debt_amount) || 0).toString();
+    const accountInfo = yield getAccountInfo({ csna, env });
+    const debtAmount = new import_big2.default(((_a = accountInfo == null ? void 0 : accountInfo.debt_info) == null ? void 0 : _a.near_gas_debt_amount) || 0).plus(((_b = accountInfo == null ? void 0 : accountInfo.debt_info) == null ? void 0 : _b.protocol_fee_debt_amount) || 0).toString();
     const relayerFeeAmount = !(accountInfo == null ? void 0 : accountInfo.nonce) ? NBTC_STORAGE_DEPOSIT_AMOUNT : ((_c = accountInfo == null ? void 0 : accountInfo.relayer_fee) == null ? void 0 : _c.amount) || 0;
-    const hasDebtArrears = new import_big.default(debtAmount).gt(0);
-    const hasRelayerFeeArrears = new import_big.default(relayerFeeAmount).gt(0);
+    const hasDebtArrears = new import_big2.default(debtAmount).gt(0);
+    const hasRelayerFeeArrears = new import_big2.default(relayerFeeAmount).gt(0);
     if (!hasDebtArrears && !hasRelayerFeeArrears)
       return;
-    const config = yield getConfig(env);
+    const config = getWalletConfig(env);
     const transferAmount = hasDebtArrears ? debtAmount : relayerFeeAmount;
     const action = {
       receiver_id: config.accountContractId,
@@ -3388,7 +3739,7 @@ function getBtcBalance() {
     const estimatedFee = Math.ceil(estimatedTxSize * feeRate);
     console.log("estimatedFee:", estimatedFee);
     const availableRawBalance = (rawBalance - estimatedFee).toFixed(0);
-    const availableBalance = new import_big.default(availableRawBalance).div(__pow(10, btcDecimals)).round(btcDecimals, import_big.default.roundDown).toNumber();
+    const availableBalance = new import_big2.default(availableRawBalance).div(__pow(10, btcDecimals)).round(btcDecimals, import_big2.default.roundDown).toNumber();
     return {
       rawBalance,
       balance,
@@ -3413,10 +3764,10 @@ function getDepositAmount(amount, option) {
     var _a;
     const env = (option == null ? void 0 : option.env) || "mainnet";
     const _newAccountMinDepositAmount = (_a = option == null ? void 0 : option.newAccountMinDepositAmount) != null ? _a : true;
-    const config = yield getConfig(env);
+    const config = getWalletConfig(env);
     const csna = yield getCsnaAccountId(env);
     const accountInfo = yield getAccountInfo({ csna, env });
-    const debtAction = yield checkGasTokenDebt(accountInfo, env, false);
+    const debtAction = yield checkGasTokenDebt(csna, env, false);
     const repayAmount = (debtAction == null ? void 0 : debtAction.amount) || 0;
     const {
       deposit_bridge_fee: { fee_min, fee_rate },
@@ -3425,7 +3776,7 @@ function getDepositAmount(amount, option) {
     const depositAmount = Math.max(Number(min_deposit_amount), Number(amount));
     const protocolFee = Math.max(Number(fee_min), Number(depositAmount) * fee_rate);
     const newAccountMinDepositAmount = !(accountInfo == null ? void 0 : accountInfo.nonce) && _newAccountMinDepositAmount ? NEW_ACCOUNT_MIN_DEPOSIT_AMOUNT : 0;
-    const totalDepositAmount = new import_big.default(depositAmount).plus(protocolFee).plus(repayAmount).plus(newAccountMinDepositAmount).round(0, import_big.default.roundDown).toNumber();
+    const totalDepositAmount = new import_big2.default(depositAmount).plus(protocolFee).plus(repayAmount).plus(newAccountMinDepositAmount).round(0, import_big2.default.roundDown).toNumber();
     return {
       depositAmount,
       totalDepositAmount,
@@ -3437,7 +3788,7 @@ function getDepositAmount(amount, option) {
 }
 function getCsnaAccountId(env) {
   return __async(this, null, function* () {
-    const config = yield getConfig(env);
+    const config = getWalletConfig(env);
     const { getPublicKey } = getBtcProvider();
     const btcPublicKey = yield getPublicKey();
     if (!btcPublicKey) {
@@ -3475,9 +3826,10 @@ function executeBTCDepositAndAction(_0) {
   }) {
     var _a;
     try {
+      console.log("executeBTCDepositAndAction start", amount);
       checkDepositDisabledAddress();
       const { getPublicKey } = getBtcProvider();
-      const config = yield getConfig(env);
+      const config = getWalletConfig(env);
       const btcPublicKey = yield getPublicKey();
       if (!btcPublicKey) {
         throw new Error("BTC Public Key is not available.");
@@ -3487,7 +3839,7 @@ function executeBTCDepositAndAction(_0) {
       }
       const csna = yield getCsnaAccountId(env);
       const depositAmount = (_a = action ? action.amount : amount) != null ? _a : "0";
-      if (new import_big.default(depositAmount).lt(0)) {
+      if (new import_big2.default(depositAmount).lt(0)) {
         throw new Error("amount must be greater than 0");
       }
       const { totalDepositAmount, protocolFee, repayAmount } = yield getDepositAmount(depositAmount, {
@@ -3496,7 +3848,7 @@ function executeBTCDepositAndAction(_0) {
       });
       const accountInfo = yield getAccountInfo({ csna, env });
       const newActions = [];
-      const debtAction = yield checkGasTokenDebt(accountInfo, env, false);
+      const debtAction = yield checkGasTokenDebt(csna, env, false);
       if (debtAction) {
         newActions.push(__spreadProps(__spreadValues({}, debtAction), {
           gas: GAS_LIMIT
@@ -3508,12 +3860,17 @@ function executeBTCDepositAndAction(_0) {
         }));
       }
       const storageDepositMsg = {};
-      const registerRes = yield nearCall((action == null ? void 0 : action.receiver_id) || config.btcToken, "storage_balance_of", {
+      const registerContractId = ((action == null ? void 0 : action.receiver_id) || config.btcToken).replace(
+        config.accountContractId,
+        config.btcToken
+      );
+      console.log("executeBTCDepositAndAction registerContractId", registerContractId);
+      const registerRes = yield nearCall(registerContractId, "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.btcToken,
+          contract_id: registerContractId,
           deposit: registerDeposit || NEAR_STORAGE_DEPOSIT_AMOUNT,
           registration_only: true
         };
@@ -3584,7 +3941,7 @@ function checkSatoshiWhitelist(btcAccountId, env = "mainnet") {
     }
     if (!btcAccountId)
       return;
-    const config = yield getConfig(env);
+    const config = getWalletConfig(env);
     const whitelist = yield getWhitelist(config.base_url);
     if (!(whitelist == null ? void 0 : whitelist.length))
       return;
@@ -3607,9 +3964,11 @@ function getWithdrawTransaction(_0) {
     feeRate,
     env = "mainnet"
   }) {
+    console.log("=== Start getWithdrawTransaction ===");
     const provider = getBtcProvider();
     const btcAddress = provider.account;
-    const config = yield getConfig(env);
+    const config = getWalletConfig(env);
+    const csna = yield getCsnaAccountId(env);
     const brgConfig = yield nearCall(config.bridgeContractId, "get_config", {});
     if (brgConfig.min_withdraw_amount) {
       if (Number(amount) < Number(brgConfig.min_withdraw_amount)) {
@@ -3618,7 +3977,39 @@ function getWithdrawTransaction(_0) {
     }
     const feePercent = Number(brgConfig.withdraw_bridge_fee.fee_rate) * Number(amount);
     const withdrawFee = feePercent > Number(brgConfig.withdraw_bridge_fee.fee_min) ? feePercent : Number(brgConfig.withdraw_bridge_fee.fee_min);
+    console.log("Withdrawal Fee:", {
+      feePercent,
+      withdrawFee,
+      minFee: brgConfig.withdraw_bridge_fee.fee_min
+    });
+    const gasLimit = yield calculateGasLimit({
+      csna,
+      transactions: [
+        {
+          signerId: "",
+          receiverId: config.btcToken,
+          actions: [
+            {
+              type: "FunctionCall",
+              params: {
+                methodName: "ft_transfer_call",
+                args: {
+                  receiver_id: config.btcToken,
+                  amount: "100",
+                  msg: ""
+                },
+                gas: "300000000000000",
+                deposit: "1"
+              }
+            }
+          ]
+        }
+      ],
+      env
+    });
+    const finalAmount = Number(gasLimit) > 0 ? Number(amount) - Number(gasLimit) : Number(amount);
     const allUTXO = yield nearCall(config.bridgeContractId, "get_utxos_paged", {});
+    console.log("All UTXOs:", allUTXO);
     if (!allUTXO || Object.keys(allUTXO).length === 0) {
       throw new Error("The network is busy, please try again later.");
     }
@@ -3631,42 +4022,48 @@ function getWithdrawTransaction(_0) {
         script: allUTXO[key].script
       };
     });
+    console.log("Formatted UTXOs:", utxos);
     const _feeRate = feeRate || (yield getBtcGasPrice());
-    let { inputs, outputs, fee } = (0, import_coinselect.default)(
+    console.log("Fee Rate:", _feeRate);
+    const coinSelectResult = (0, import_coinselect.default)(
       utxos,
-      [{ address: btcAddress, value: Number(amount) }],
+      [{ address: btcAddress, value: Number(finalAmount) }],
       Math.ceil(_feeRate)
     );
+    console.log("Coinselect Result:", coinSelectResult);
+    const { inputs, outputs, fee } = coinSelectResult;
     if (!outputs || !inputs) {
       throw new Error("The network is busy, please try again later.");
     }
     const maxBtcFee = Number(brgConfig.max_btc_gas_fee);
     const transactionFee = fee;
-    const changeAddress = brgConfig.change_address;
+    console.log("Transaction Fee:", { transactionFee, maxBtcFee });
     if (transactionFee > maxBtcFee) {
       throw new Error("Gas exceeds maximum value");
     }
     let recipientOutput, changeOutput;
     for (let i = 0; i < outputs.length; i++) {
       const output = outputs[i];
-      if (output.value.toString() === amount.toString()) {
+      if (output.value.toString() === finalAmount.toString()) {
         recipientOutput = output;
       } else {
         changeOutput = output;
       }
       if (!output.address) {
-        output.address = changeAddress;
+        output.address = brgConfig.change_address;
       }
     }
-    recipientOutput.value = new import_big.default(recipientOutput.value).minus(transactionFee).minus(withdrawFee).toNumber();
+    console.log("Initial Outputs:", { recipientOutput, changeOutput });
+    recipientOutput.value = new import_big2.default(recipientOutput.value).minus(transactionFee).minus(withdrawFee).toNumber();
     if (changeOutput) {
-      changeOutput.value = new import_big.default(changeOutput.value).plus(transactionFee).plus(withdrawFee).toNumber();
+      changeOutput.value = new import_big2.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;
+      console.log("Initial Change Processing:", { smallestInput, remainingChangeAmount });
       while (remainingChangeAmount >= smallestInput && smallestInput > 0 && remainingInputs.length > 0) {
         remainingChangeAmount -= smallestInput;
         changeOutput.value = remainingChangeAmount;
@@ -3680,30 +4077,50 @@ function getWithdrawTransaction(_0) {
           null,
           remainingInputs.map((input) => input.value)
         );
+        console.log("Change Processing Loop:", {
+          remainingChangeAmount,
+          smallestInput,
+          remainingInputsCount: remainingInputs.length
+        });
       }
       const minChangeAmount = Number(brgConfig.min_change_amount);
       let additionalFee = 0;
+      console.log("Checking minimum change amount:", {
+        changeValue: changeOutput.value,
+        minChangeAmount
+      });
+      let finalOutputs = [...outputs];
       if (changeOutput.value === 0) {
-        outputs = outputs.filter((item) => item.value !== 0);
+        finalOutputs = finalOutputs.filter((output) => output.value !== 0);
+        console.log("Removed zero-value change output", finalOutputs);
       } else if (changeOutput.value < minChangeAmount) {
         additionalFee = minChangeAmount - changeOutput.value;
         recipientOutput.value -= additionalFee;
         changeOutput.value = minChangeAmount;
+        console.log("Adjusted for minimum change amount:", {
+          additionalFee,
+          newRecipientValue: recipientOutput.value,
+          newChangeValue: changeOutput.value
+        });
       }
     } else {
       changeOutput = {
-        address: changeAddress,
-        value: new import_big.default(transactionFee).plus(withdrawFee).toNumber()
+        address: brgConfig.change_address,
+        value: new import_big2.default(transactionFee).plus(withdrawFee).toNumber()
       };
       outputs.push(changeOutput);
+      console.log("Created new change output:", changeOutput);
     }
     const insufficientOutput = outputs.some((item) => item.value < 0);
     if (insufficientOutput) {
+      console.error("Negative output value detected");
       throw new Error("Not enough gas");
     }
     const inputSum = inputs.reduce((sum, cur) => sum + Number(cur.value), 0);
     const outputSum = outputs.reduce((sum, cur) => sum + Number(cur.value), 0);
+    console.log("Balance verification:", { inputSum, outputSum, transactionFee });
     if (transactionFee + outputSum !== inputSum) {
+      console.error("Balance mismatch:", { inputSum, outputSum, transactionFee });
       throw new Error("compute error");
     }
     const network = yield getNetwork();
@@ -3730,6 +4147,7 @@ function getWithdrawTransaction(_0) {
         value: output.value
       });
     });
+    console.log("outputs:", JSON.stringify(outputs));
     const _inputs = inputs.map((item) => {
       return `${item.txid}:${item.vout}`;
     });
@@ -3746,7 +4164,6 @@ function getWithdrawTransaction(_0) {
         output: txOutputs
       }
     };
-    const csna = yield getCsnaAccountId(env);
     const transaction = {
       receiverId: config.btcToken,
       signerId: csna,
@@ -3766,6 +4183,7 @@ function getWithdrawTransaction(_0) {
         }
       ]
     };
+    console.log("=== End getWithdrawTransaction ===");
     return transaction;
   });
 }
@@ -4006,86 +4424,7 @@ function updateIframePosition(iframe, buttonRight, buttonBottom, windowWidth, wi
   iframe.style.bottom = `${iframeBottom}px`;
 }
 
-// src/core/setupBTCWallet.ts
-var import_big2 = __toESM(require("big.js"), 1);
-var { transfer, functionCall } = import_transactions.actionCreators;
-var STORAGE_KEYS = {
-  ACCOUNT: "btc-wallet-account",
-  PUBLIC_KEY: "btc-wallet-publickey",
-  BTC_PUBLIC_KEY: "btc-wallet-btc-publickey"
-};
-var state = {
-  saveAccount(account) {
-    if (!account) {
-      this.removeAccount();
-      return;
-    }
-    window.localStorage.setItem(STORAGE_KEYS.ACCOUNT, account);
-  },
-  removeAccount() {
-    window.localStorage.removeItem(STORAGE_KEYS.ACCOUNT);
-  },
-  savePublicKey(publicKey) {
-    if (!publicKey) {
-      this.removePublicKey();
-      return;
-    }
-    window.localStorage.setItem(STORAGE_KEYS.PUBLIC_KEY, publicKey);
-  },
-  removePublicKey() {
-    window.localStorage.removeItem(STORAGE_KEYS.PUBLIC_KEY);
-  },
-  saveBtcPublicKey(publicKey) {
-    if (!publicKey) {
-      this.removeBtcPublicKey();
-      return;
-    }
-    window.localStorage.setItem(STORAGE_KEYS.BTC_PUBLIC_KEY, publicKey);
-  },
-  removeBtcPublicKey() {
-    window.localStorage.removeItem(STORAGE_KEYS.BTC_PUBLIC_KEY);
-  },
-  clear() {
-    this.removeAccount();
-    this.removePublicKey();
-    this.removeBtcPublicKey();
-  },
-  save(account, publicKey) {
-    if (!account || !publicKey) {
-      this.clear();
-      return;
-    }
-    this.saveAccount(account);
-    this.savePublicKey(publicKey);
-  },
-  getAccount() {
-    return window.localStorage.getItem(STORAGE_KEYS.ACCOUNT);
-  },
-  getPublicKey() {
-    return window.localStorage.getItem(STORAGE_KEYS.PUBLIC_KEY);
-  },
-  getBtcPublicKey() {
-    return window.localStorage.getItem(STORAGE_KEYS.BTC_PUBLIC_KEY);
-  },
-  isValid() {
-    const account = this.getAccount();
-    const publicKey = this.getPublicKey();
-    const btcPublicKey = this.getBtcPublicKey();
-    const allEmpty = !account && !publicKey && !btcPublicKey;
-    const allExist = account && publicKey && btcPublicKey;
-    return allEmpty || allExist;
-  },
-  syncSave(account, publicKey, btcPublicKey) {
-    if (!account || !publicKey || !btcPublicKey) {
-      this.clear();
-      return;
-    }
-    this.clear();
-    this.savePublicKey(publicKey);
-    this.saveBtcPublicKey(btcPublicKey);
-    this.saveAccount(account);
-  }
-};
+// src/core/setupBTCWallet/index.ts
 var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   metadata,
   options,
@@ -4107,15 +4446,14 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
     calculateGasLimit
   };
   const env = metadata.env || options.network.networkId || "mainnet";
-  const currentConfig = walletConfig[env];
-  const walletNetwork = ["mainnet", "private_mainnet"].includes(env) ? "mainnet" : "testnet";
+  const currentConfig = getWalletConfig(env);
   yield initBtcContext();
   function validateWalletState() {
-    const accountId = state.getAccount();
-    const publicKey = state.getPublicKey();
-    const btcPublicKey = state.getBtcPublicKey();
+    const accountId = state_default.getAccount();
+    const publicKey = state_default.getPublicKey();
+    const btcPublicKey = state_default.getBtcPublicKey();
     if (!accountId && publicKey || accountId && !publicKey || !publicKey && btcPublicKey) {
-      state.clear();
+      state_default.clear();
       return false;
     }
     return true;
@@ -4123,9 +4461,9 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   function setupBtcContextListeners() {
     return __async(this, null, function* () {
       const handleConnectionUpdate = () => __async(this, null, function* () {
-        yield checkBtcNetwork(walletNetwork);
-        if (!state.isValid()) {
-          state.clear();
+        yield checkBtcNetwork(currentConfig.network);
+        if (!state_default.isValid()) {
+          state_default.clear();
           console.log("setupBtcContextListeners clear");
         }
         validateWalletState();
@@ -4148,7 +4486,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       const context = window.btcContext.getContext();
       context.on("updatePublicKey", (btcPublicKey) => __async(this, null, function* () {
         console.log("updatePublicKey");
-        state.clear();
+        state_default.clear();
         console.log("updatePublicKey clear");
         try {
           const { nearAddress, nearPublicKey } = yield getNearAccountByBtcPublicKey(btcPublicKey);
@@ -4167,7 +4505,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       }));
       context.on("btcLogOut", () => __async(this, null, function* () {
         console.log("btcLogOut");
-        state.clear();
+        state_default.clear();
         emitter.emit("accountsChanged", { accounts: [] });
         yield handleConnectionUpdate();
       }));
@@ -4211,7 +4549,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         "get_chain_signature_near_account_public_key",
         { btc_public_key: btcPublicKey }
       );
-      state.syncSave(csna, nearPublicKey, btcPublicKey);
+      state_default.syncSave(csna, nearPublicKey, btcPublicKey);
       return {
         nearAddress: csna,
         nearPublicKey
@@ -4221,8 +4559,8 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   function signIn(_02) {
     return __async(this, arguments, function* ({ contractId, methodNames }) {
       const btcContext = window.btcContext;
-      state.clear();
-      if (!state.getAccount() || !state.getPublicKey()) {
+      state_default.clear();
+      if (!state_default.getAccount() || !state_default.getPublicKey()) {
         yield btcContext.login();
       }
       const btcPublicKey = yield btcContext.getPublicKey();
@@ -4241,8 +4579,8 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   }
   function signOut() {
     return __async(this, null, function* () {
-      const accountId = state.getAccount();
-      const publicKey = state.getPublicKey();
+      const accountId = state_default.getAccount();
+      const publicKey = state_default.getPublicKey();
       if (!(accountId && publicKey)) {
         return;
       }
@@ -4250,19 +4588,19 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       if (metadata.syncLogOut) {
         btcContext.logout();
       }
-      state.clear();
+      state_default.clear();
       window.localStorage.removeItem("near-wallet-selector:selectedWalletId");
       removeWalletButton();
     });
   }
   function isSignedIn() {
-    const accountId = state.getAccount();
-    const publicKey = state.getPublicKey();
+    const accountId = state_default.getAccount();
+    const publicKey = state_default.getPublicKey();
     return accountId && publicKey;
   }
   function getAccounts() {
     return __async(this, null, function* () {
-      return [{ accountId: state.getAccount() }];
+      return [{ accountId: state_default.getAccount() }];
     });
   }
   function verifyOwner() {
@@ -4292,12 +4630,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 csna = state.getAccount();
+      const csna = state_default.getAccount();
       const accountInfo = yield getAccountInfo({ csna, env });
-      yield checkGasTokenDebt(accountInfo, env, true);
+      yield checkGasTokenDebt(csna, env, true);
       const trans = [...params.transactions];
       console.log("signAndSendTransactions raw trans:", trans);
-      const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy(trans);
+      const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy({
+        csna,
+        transactions: trans,
+        env
+      });
       console.log("transferGasTransaction:", transferGasTransaction);
       console.log("useNearPayGas:", useNearPayGas);
       console.log("gasLimit:", gasLimit);
@@ -4307,7 +4649,15 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       }
       console.log("calculateGasStrategy trans:", trans);
       const newTrans = yield Promise.all(
-        trans.map((transaction, index) => convertTransactionToTxHex(transaction, index))
+        trans.map(
+          (transaction, index) => convertTransactionToTxHex({
+            transaction,
+            accountId: state_default.getAccount(),
+            publicKey: state_default.getPublicKey(),
+            index,
+            env
+          })
+        )
       );
       const nonceFromApi = yield getNonce(currentConfig.base_url, csna);
       const nonceFromContract = (accountInfo == null ? void 0 : accountInfo.nonce) || 0;
@@ -4325,7 +4675,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       const signature = yield btcContext.signMessage(strIntention);
       yield receiveTransaction(currentConfig.base_url, {
         sig: signature,
-        btcPubKey: state.getBtcPublicKey(),
+        btcPubKey: state_default.getBtcPublicKey(),
         data: toHex(strIntention)
       });
       yield checkBtcTransactionStatus(currentConfig.base_url, signature);
@@ -4335,197 +4685,6 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       return result;
     });
   }
-  function calculateGasLimit(params) {
-    return __async(this, null, function* () {
-      const trans = [...params.transactions];
-      console.log("raw trans:", trans);
-      const { gasLimit } = yield calculateGasStrategy(trans);
-      return gasLimit;
-    });
-  }
-  function createGasTokenTransfer(accountId, amount) {
-    return __async(this, null, function* () {
-      return {
-        signerId: accountId,
-        receiverId: currentConfig.btcToken,
-        actions: [
-          {
-            type: "FunctionCall",
-            params: {
-              methodName: "ft_transfer_call",
-              args: {
-                receiver_id: currentConfig.accountContractId,
-                amount,
-                msg: JSON.stringify("Repay")
-              },
-              gas: new import_big2.default(50).mul(__pow(10, 12)).toFixed(0),
-              deposit: "1"
-            }
-          }
-        ]
-      };
-    });
-  }
-  function recalculateGasWithTransfer(transferTx, transactions2, useNearPayGas, perTxFee) {
-    return __async(this, null, function* () {
-      const { txHex: transferTxHex } = yield convertTransactionToTxHex(transferTx);
-      let newGasLimit;
-      if (useNearPayGas && perTxFee) {
-        newGasLimit = new import_big2.default(perTxFee).mul(transactions2.length + 1).toFixed(0);
-      } else {
-        newGasLimit = yield getPredictedGasAmount(
-          currentConfig.accountContractId,
-          currentConfig.btcToken,
-          [transferTxHex, ...transactions2.map((t) => t.txHex)]
-        );
-      }
-      transferTx.actions[0].params.args.amount = newGasLimit;
-      return { transferGasTransaction: transferTx, useNearPayGas, gasLimit: newGasLimit };
-    });
-  }
-  function getPredictedGasAmount(accountContractId, tokenId, transactions2) {
-    return __async(this, null, function* () {
-      const predictedGas = yield nearCall2(accountContractId, "predict_txs_gas_token_amount", {
-        gas_token_id: tokenId,
-        near_transactions: transactions2
-      });
-      const predictedGasAmount = new import_big2.default(predictedGas).mul(1.2).toFixed(0);
-      const miniGasAmount = 200 * transactions2.length;
-      const gasAmount = Math.max(Number(predictedGasAmount), miniGasAmount);
-      console.log("predictedGas:", predictedGasAmount);
-      return gasAmount.toString();
-    });
-  }
-  function calculateGasStrategy(transactions2) {
-    return __async(this, null, function* () {
-      var _a;
-      const accountId = state.getAccount();
-      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 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();
-      console.log("available near balance:", nearAvailableBalance);
-      console.log("available gas token balance:", gasTokenBalance);
-      const convertTx = yield Promise.all(
-        transactions2.map((transaction, index) => convertTransactionToTxHex(transaction, index))
-      );
-      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.btcToken] }
-        );
-        console.log("list_gas_token gas tokens:", gasTokens);
-        const perTxFee = Math.max(
-          Number(((_a = gasTokens[currentConfig.btcToken]) == null ? void 0 : _a.per_tx_protocol_fee) || 0),
-          100
-        );
-        console.log("perTxFee:", perTxFee);
-        const protocolFee = new import_big2.default(perTxFee || "0").mul(convertTx.length).toFixed(0);
-        console.log("protocolFee:", protocolFee);
-        if (new import_big2.default(gasTokenBalance).gte(protocolFee)) {
-          console.log("use near pay gas and enough gas token balance");
-          return { useNearPayGas: true, gasLimit: protocolFee };
-        } else {
-          console.log("use near pay gas and not enough gas token balance");
-          const transferTx = yield createGasTokenTransfer(accountId, protocolFee);
-          return recalculateGasWithTransfer(transferTx, convertTx, true, perTxFee.toString());
-        }
-      } else {
-        console.log("near balance is not enough, predict the gas token amount required");
-        const adjustedGas = yield getPredictedGasAmount(
-          currentConfig.accountContractId,
-          currentConfig.btcToken,
-          convertTx.map((t) => t.txHex)
-        );
-        if (new import_big2.default(gasTokenBalance).gte(adjustedGas)) {
-          console.log("use gas token and gas token balance is enough");
-          return { useNearPayGas: false, gasLimit: adjustedGas };
-        } else {
-          console.log("use gas token and gas token balance is not enough, need to transfer");
-          const transferTx = yield createGasTokenTransfer(accountId, adjustedGas);
-          return recalculateGasWithTransfer(transferTx, convertTx, false);
-        }
-      }
-    });
-  }
-  function convertTransactionToTxHex(transaction, index = 0) {
-    return __async(this, null, function* () {
-      const accountId = state.getAccount();
-      const publicKey = state.getPublicKey();
-      const publicKeyFormat = import_key_pair.PublicKey.from(publicKey);
-      const { header } = yield provider.block({
-        finality: "final"
-      });
-      const rawAccessKey = yield provider.query({
-        request_type: "view_access_key",
-        account_id: accountId,
-        public_key: publicKey,
-        finality: "final"
-      }).catch((e) => {
-        console.log("view_access_key error:", e);
-        return void 0;
-      });
-      const accessKey = __spreadProps(__spreadValues({}, rawAccessKey), {
-        nonce: BigInt((rawAccessKey == null ? void 0 : rawAccessKey.nonce) || 0)
-      });
-      const nearNonceFromApi = yield getNearNonce(currentConfig.base_url, accountId);
-      let nearNonceNumber = accessKey.nonce + BigInt(1);
-      if (nearNonceFromApi) {
-        nearNonceNumber = BigInt(nearNonceFromApi) > nearNonceNumber ? BigInt(nearNonceFromApi) : nearNonceNumber;
-      }
-      const newActions = transaction.actions.map((action) => {
-        switch (action.type) {
-          case "FunctionCall":
-            return functionCall(
-              action.params.methodName,
-              action.params.args,
-              BigInt(action.params.gas),
-              BigInt(action.params.deposit)
-            );
-          case "Transfer":
-            return transfer(BigInt(action.params.deposit));
-        }
-      }).filter(Boolean);
-      const _transaction = import_near_api_js2.transactions.createTransaction(
-        accountId,
-        publicKeyFormat,
-        transaction.receiverId,
-        BigInt(nearNonceNumber) + BigInt(index),
-        newActions,
-        (0, import_utils10.baseDecode)(header.hash)
-      );
-      const txBytes = (0, import_transaction.encodeTransaction)(_transaction);
-      const txHex = Array.from(txBytes, (byte) => ("0" + (byte & 255).toString(16)).slice(-2)).join(
-        ""
-      );
-      const hash = import_bs58.default.encode(new Uint8Array(import_js_sha256.sha256.array(txBytes)));
-      return { txBytes, txHex, hash };
-    });
-  }
   function checkBtcNetwork(network) {
     return __async(this, null, function* () {
       const btcContext = window.btcContext;
@@ -4574,7 +4733,7 @@ function setupBTCWallet({
 
 // src/index.ts
 var getVersion = () => {
-  return "0.5.14-beta";
+  return "0.5.16-beta";
 };
 if (typeof window !== "undefined") {
   window.__BTC_WALLET_VERSION = getVersion();