btc-wallet 0.3.10 → 0.3.12

package/dist/index.js

@@ -2572,7 +2572,7 @@ 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_utils5 = require("@near-js/utils");
+var import_utils6 = require("@near-js/utils");
 var import_bs58 = __toESM(require("bs58"), 1);
 var import_js_sha256 = require("js-sha256");
 
@@ -2754,9 +2754,7 @@ var nearRpcUrls = {
     "https://near.drpc.org"
   ],
   testnet: [
-    "https://rpc.testnet.near.org",
-    "https://near-testnet.lava.build",
-    "https://near-testnet.drpc.org"
+    "https://rpc.testnet.near.org"
   ]
 };
 var btcRpcUrls = {
@@ -2764,6 +2762,73 @@ var btcRpcUrls = {
   testnet: "https://mempool.space/testnet/api"
 };
 
+// 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 result = yield provider.txStatus(hash, "unused", "FINAL");
+          if (result && result.status) {
+            console.log(`Transaction ${hash} result:`, result);
+            results.set(hash, result);
+            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);
+      }
+    }
+    return hashes.map((hash) => results.get(hash));
+  });
+}
+
+// src/core/setupBTCWallet.ts
+var import_big2 = __toESM(require("big.js"), 1);
+
+// src/core/btcUtils.ts
+var import_big = __toESM(require("big.js"), 1);
+
 // src/utils/request.ts
 var cache = /* @__PURE__ */ new Map();
 var defaultCacheTimeout = 3e3;
@@ -2804,18 +2869,20 @@ function request(url, options) {
       if (!res.ok)
         throw new Error(res.statusText);
       const data = yield res.json();
+      if (options == null ? void 0 : options.shouldStopPolling) {
+        if (options.shouldStopPolling(data)) {
+          return data;
+        }
+        throw new Error("Polling should continue");
+      }
       if (cacheKey) {
         cache.set(cacheKey, { timestamp: Date.now(), data });
         setTimeout(() => {
           cache.delete(cacheKey);
         }, cacheTimeout);
       }
-      if ((options == null ? void 0 : options.shouldStopPolling) && options.shouldStopPolling(data)) {
-        return data;
-      }
       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 }));
@@ -2829,65 +2896,471 @@ function request(url, options) {
           }));
         }
       }
-      return Promise.reject(err);
+      throw err;
     }
   });
 }
 
-// src/utils/nearUtils.ts
-var import_near_api_js = require("near-api-js");
-function nearCallFunction(contractId, methodName, args, options) {
+// src/utils/satoshi.ts
+function getNonce(url, accountId) {
   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 { result_code, result_message, result_data } = yield request(
+      `${url}/v1/nonce?csna=${accountId}`
     );
-    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"
+    if (result_code !== 0) {
+      throw new Error(result_message);
+    }
+    return result_data;
+  });
+}
+function getNearNonce(url, accountId) {
+  return __async(this, null, function* () {
+    const { result_code, result_message, result_data } = yield request(
+      `${url}/v1/nonceNear?csna=${accountId}`
+    );
+    if (result_code !== 0) {
+      throw new Error(result_message);
+    }
+    return result_data;
+  });
+}
+function receiveTransaction(url, data) {
+  return __async(this, null, function* () {
+    const { result_code, result_message, result_data } = yield request(
+      `${url}/v1/receiveTransaction`,
+      {
+        method: "POST",
+        body: data
+      }
+    );
+    if (result_code !== 0) {
+      throw new Error(result_message);
+    }
+    return result_data;
+  });
+}
+function receiveDepositMsg(_0, _1) {
+  return __async(this, arguments, function* (url, {
+    btcPublicKey,
+    txHash,
+    depositType = 1,
+    postActions,
+    extraMsg
+  }) {
+    const { result_code, result_message, result_data } = yield request(
+      `${url}/v1/receiveDepositMsg`,
+      {
+        method: "POST",
+        body: { btcPublicKey, txHash, depositType, postActions, extraMsg }
+      }
+    );
+    console.log("receiveDepositMsg resp:", { result_code, result_message, result_data });
+    if (result_code !== 0) {
+      throw new Error(result_message);
+    }
+    return result_data;
+  });
+}
+function checkBridgeTransactionStatus(url, txHash) {
+  return __async(this, null, function* () {
+    const { result_code, result_message, result_data } = yield request(`${url}/v1/bridgeFromTx?fromTxHash=${txHash}&fromChainId=1`, {
+      timeout: 3e5,
+      pollingInterval: 5e3,
+      maxPollingAttempts: 30,
+      shouldStopPolling: (res) => {
+        var _a;
+        return res.result_code === 0 && [4, 102].includes(((_a = res.result_data) == null ? void 0 : _a.status) || 0);
+      }
     });
-    return JSON.parse(Buffer.from(res.result).toString());
+    console.log("checkTransactionStatus resp:", { result_code, result_message, result_data });
+    if ((result_data == null ? void 0 : result_data.status) !== 4) {
+      throw new Error(result_message);
+    }
+    return result_data;
   });
 }
-function pollTransactionStatuses(network, hashes) {
+function checkBtcTransactionStatus(url, sig) {
   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 { result_code, result_message, result_data } = yield request(`${url}/v1/btcTx?sig=${sig}`, {
+      timeout: 3e5,
+      pollingInterval: 5e3,
+      maxPollingAttempts: 30,
+      shouldStopPolling: (res) => {
+        var _a;
+        return res.result_code === 0 && [3, 101, 102].includes(((_a = res.result_data) == null ? void 0 : _a.status) || 0);
+      }
+    });
+    console.log("checkBtcTransactionStatus resp:", { result_code, result_message, result_data });
+    if ((result_data == null ? void 0 : result_data.status) !== 3) {
+      throw new Error(result_message);
+    }
+    return result_data;
+  });
+}
+
+// src/core/btcUtils.ts
+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(isDev) {
+  return __async(this, null, function* () {
+    const network = yield getNetwork();
+    return walletConfig[isDev ? "dev" : network];
+  });
+}
+function nearCall(contractId, methodName, args) {
+  return __async(this, null, function* () {
+    const network = yield getNetwork();
+    return nearCallFunction(contractId, methodName, args, { network });
+  });
+}
+function getBtcGasPrice() {
+  return __async(this, null, function* () {
+    const defaultFeeRate = 100;
+    try {
+      const btcRpcUrl = yield getBtcRpcUrl();
+      const res = yield fetch(`${btcRpcUrl}/v1/fees/recommended`).then((res2) => res2.json());
+      const feeRate = res.fastestFee;
+      return feeRate || defaultFeeRate;
+    } catch (error) {
+      return defaultFeeRate;
+    }
+  });
+}
+function getBtcBalance() {
+  return __async(this, null, function* () {
+    const { account } = yield retryOperation(getBtcProvider, (res) => !!res.account);
+    if (!account) {
+      console.error("BTC Account is not available.");
+      return { rawBalance: 0, balance: 0, maxSpendableBalance: 0 };
+    }
+    const btcRpcUrl = yield getBtcRpcUrl();
+    const utxos = yield fetch(`${btcRpcUrl}/address/${account}/utxo`).then((res) => res.json());
+    const rawBalance = (utxos == null ? void 0 : utxos.reduce((acc, cur) => acc + cur.value, 0)) || 0;
+    const balance = rawBalance / __pow(10, 8);
+    const feeRate = yield getBtcGasPrice();
+    const inputSize = ((utxos == null ? void 0 : utxos.length) || 0) * 66;
+    const outputSize = 34;
+    const overheadSize = 10;
+    const estimatedTxSize = inputSize + outputSize + overheadSize;
+    const estimatedFee = estimatedTxSize * feeRate / __pow(10, 8);
+    console.log("estimated fee:", estimatedFee);
+    const availableBalance = Math.max(0, balance - estimatedFee);
+    return {
+      rawBalance,
+      balance,
+      availableBalance
+    };
+  });
+}
+function sendBitcoin(address, amount, feeRate) {
+  return __async(this, null, function* () {
+    const { sendBitcoin: sendBitcoin2 } = getBtcProvider();
+    const txHash = yield sendBitcoin2(address, amount, { feeRate });
+    return txHash;
+  });
+}
+function estimateDepositAmount(amount, option) {
+  return __async(this, null, function* () {
+    const config = yield getConfig((option == null ? void 0 : option.isDev) || false);
+    const {
+      deposit_bridge_fee: { fee_min, fee_rate }
+    } = yield nearCall(
+      config.bridgeContractId,
+      "get_config",
+      {}
     );
-    const maxAttempts = 3;
-    const pollStatus = (hash) => __async(this, null, function* () {
-      let attempt = 0;
-      while (attempt < maxAttempts) {
-        attempt++;
-        try {
-          const result = yield provider.txStatus(hash, "unused", "FINAL");
-          if (result && result.status) {
-            console.log(`Transaction ${hash} result:`, result);
-            return result;
-          }
-        } catch (error) {
-          console.error(`Failed to fetch transaction status for ${hash}: ${error.message}`);
+    const fee = Math.max(Number(fee_min), Number(amount) * fee_rate);
+    return new import_big.default(amount).minus(fee).toFixed(0);
+  });
+}
+function executeBTCDepositAndAction(_0) {
+  return __async(this, arguments, function* ({
+    action,
+    feeRate,
+    isDev = false
+  }) {
+    try {
+      const { getPublicKey } = getBtcProvider();
+      const config = yield getConfig(isDev);
+      const btcPublicKey = yield getPublicKey();
+      if (!btcPublicKey) {
+        throw new Error("BTC Public Key is not available.");
+      }
+      if (!action.receiver_id) {
+        throw new Error("receiver_id is required");
+      }
+      if (!action.amount) {
+        throw new Error("amount is required");
+      }
+      const csna = yield nearCall(
+        config.accountContractId,
+        "get_chain_signature_near_account_id",
+        {
+          btc_public_key: btcPublicKey
         }
-        if (attempt === maxAttempts) {
-          throw new Error(`Transaction not found after max attempts: ${hash}`);
+      );
+      const depositMsg = {
+        recipient_id: csna,
+        post_actions: [
+          __spreadProps(__spreadValues({}, action), {
+            gas: new import_big.default(100).mul(__pow(10, 12)).toFixed(0)
+          })
+        ]
+      };
+      const storageDepositMsg = {};
+      const accountInfo = yield nearCall(
+        config.accountContractId,
+        "get_account",
+        {
+          account_id: csna
         }
-        yield delay(1e4);
-        console.log(`RPC request failed for ${hash}, retrying ${maxAttempts - attempt} more times`);
+      );
+      if (!(accountInfo == null ? void 0 : accountInfo.nonce)) {
+        storageDepositMsg.btc_public_key = btcPublicKey;
       }
-    });
-    const results = yield Promise.all(hashes.map((hash) => pollStatus(hash)));
-    return results;
+      const registerRes = yield nearCall(action.receiver_id, "storage_balance_of", {
+        account_id: csna
+      });
+      if (!(registerRes == null ? void 0 : registerRes.available)) {
+        storageDepositMsg.storage_deposit_msg = {
+          contract_id: action.receiver_id,
+          deposit: new import_big.default(0.25).mul(__pow(10, 24)).toFixed(0),
+          registration_only: true
+        };
+      }
+      if (Object.keys(storageDepositMsg).length > 0) {
+        depositMsg.extra_msg = JSON.stringify(storageDepositMsg);
+      }
+      console.log("get_user_deposit_address params:", { deposit_msg: depositMsg });
+      const userDepositAddress = yield nearCall(
+        config.bridgeContractId,
+        "get_user_deposit_address",
+        { deposit_msg: depositMsg }
+      );
+      const _feeRate = feeRate || (yield getBtcGasPrice());
+      const minDepositAmount = 5e3;
+      const sendAmount = Math.max(minDepositAmount, new import_big.default(action.amount).toNumber());
+      console.log("user deposit address:", userDepositAddress);
+      console.log("send amount:", sendAmount);
+      console.log("fee rate:", _feeRate);
+      const txHash = yield sendBitcoin(userDepositAddress, sendAmount, _feeRate);
+      yield receiveDepositMsg(config.base_url, {
+        btcPublicKey,
+        txHash,
+        postActions: JSON.stringify(depositMsg.post_actions),
+        extraMsg: depositMsg.extra_msg
+      });
+      const checkTransactionStatusRes = yield checkBridgeTransactionStatus(config.base_url, txHash);
+      console.log("checkBridgeTransactionStatus resp:", checkTransactionStatusRes);
+      const network = yield getNetwork();
+      const result = yield pollTransactionStatuses(network, [checkTransactionStatusRes.ToTxHash]);
+      return result;
+    } catch (error) {
+      console.error("executeBTCDepositAndAction error:", error);
+      throw error;
+    }
   });
 }
 
+// src/utils/Dialog.ts
+var Dialog = class {
+  static injectStyles() {
+    if (!document.querySelector("#dialog-styles")) {
+      const styleSheet = document.createElement("style");
+      styleSheet.id = "dialog-styles";
+      styleSheet.textContent = this.style;
+      document.head.appendChild(styleSheet);
+    }
+  }
+  static confirm(options) {
+    return new Promise((resolve) => {
+      this.injectStyles();
+      const container = document.createElement("div");
+      container.innerHTML = this.template;
+      document.body.appendChild(container);
+      const titleEl = container.querySelector(".dialog-title");
+      const messageEl = container.querySelector(".dialog-message");
+      const confirmBtn = container.querySelector(".dialog-confirm-btn");
+      const cancelBtn = container.querySelector(".dialog-cancel-btn");
+      if (options.title) {
+        titleEl.textContent = options.title;
+      } else {
+        titleEl.style.display = "none";
+      }
+      messageEl.textContent = options.message;
+      const cleanup = () => {
+        document.body.removeChild(container);
+      };
+      confirmBtn.addEventListener("click", () => {
+        cleanup();
+        resolve(true);
+      });
+      cancelBtn.addEventListener("click", () => {
+        cleanup();
+        resolve(false);
+      });
+    });
+  }
+  static alert(options) {
+    return new Promise((resolve) => {
+      this.injectStyles();
+      const container = document.createElement("div");
+      container.innerHTML = this.template;
+      document.body.appendChild(container);
+      const titleEl = container.querySelector(".dialog-title");
+      const messageEl = container.querySelector(".dialog-message");
+      const confirmBtn = container.querySelector(".dialog-confirm-btn");
+      const cancelBtn = container.querySelector(".dialog-cancel-btn");
+      if (options.title) {
+        titleEl.textContent = options.title;
+      } else {
+        titleEl.style.display = "none";
+      }
+      messageEl.textContent = options.message;
+      cancelBtn.style.display = "none";
+      const cleanup = () => {
+        document.body.removeChild(container);
+      };
+      confirmBtn.addEventListener("click", () => {
+        cleanup();
+        resolve();
+      });
+    });
+  }
+};
+Dialog.template = `
+    <div class="dialog-overlay">
+      <div class="dialog-container">
+        <div class="dialog-content">
+          <div class="dialog-title"></div>
+          <div class="dialog-message"></div>
+          <div class="dialog-buttons">
+            <button class="dialog-cancel-btn">Cancel</button>
+            <button class="dialog-confirm-btn">Confirm</button>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+Dialog.style = `
+    .dialog-overlay {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background-color: rgba(0, 0, 0, 0.75);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 999999;
+      backdrop-filter: blur(4px);
+    }
+    .dialog-container {
+      background: #21232f;
+      border-radius: 12px;
+      padding: 24px;
+      width: 350px;
+      box-shadow: 0 4px 24px rgba(0, 0, 0, 0.3);
+    }
+    .dialog-title {
+      font-size: 18px;
+      font-weight: 600;
+      margin-bottom: 16px;
+      color: #ffffff;
+    }
+    .dialog-message {
+      margin-bottom: 24px;
+      line-height: 1.6;
+      color: rgba(255, 255, 255, 0.8);
+      font-size: 14px;
+    }
+    .dialog-buttons {
+      display: flex;
+      justify-content: flex-end;
+      gap: 12px;
+    }
+    .dialog-confirm-btn {
+      padding: 8px 24px;
+      background-color: #ff7a00;
+      color: white;
+      border: none;
+      border-radius: 6px;
+      cursor: pointer;
+      font-size: 14px;
+      font-weight: 500;
+      transition: all 0.2s ease;
+    }
+    .dialog-confirm-btn:hover {
+      background-color: #ff8f1f;
+      transform: translateY(-1px);
+    }
+    .dialog-confirm-btn:active {
+      transform: translateY(0);
+    }
+    .dialog-cancel-btn {
+      padding: 8px 24px;
+      background-color: rgba(255, 255, 255, 0.1);
+      color: rgba(255, 255, 255, 0.8);
+      border: none;
+      border-radius: 6px;
+      cursor: pointer;
+      font-size: 14px;
+      font-weight: 500;
+      transition: all 0.2s ease;
+    }
+    .dialog-cancel-btn:hover {
+      background-color: rgba(255, 255, 255, 0.15);
+      transform: translateY(-1px);
+    }
+    .dialog-cancel-btn:active {
+      transform: translateY(0);
+    }
+    
+    .dialog-overlay {
+      animation: fadeIn 0.2s ease;
+    }
+    .dialog-container {
+      animation: slideIn 0.2s ease;
+    }
+    @keyframes fadeIn {
+      from {
+        opacity: 0;
+      }
+      to {
+        opacity: 1;
+      }
+    }
+    @keyframes slideIn {
+      from {
+        transform: translateY(-20px);
+        opacity: 0;
+      }
+      to {
+        transform: translateY(0);
+        opacity: 1;
+      }
+    }
+  `;
+
 // src/core/setupBTCWallet.ts
-var import_big = __toESM(require("big.js"), 1);
 var { transfer, functionCall } = import_transactions.actionCreators;
 var state = {
   saveAccount(account) {
@@ -2937,6 +3410,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   id,
   provider
 }) {
+  var _a;
   const wallet = {
     signIn,
     signOut,
@@ -2946,8 +3420,9 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
     signAndSendTransaction,
     signAndSendTransactions
   };
-  const currentConfig = "isDev" in metadata && metadata.isDev ? walletConfig.dev : walletConfig[options.network.networkId];
-  const walletNetwork = "isDev" in metadata && metadata.isDev ? "dev" : options.network.networkId;
+  const isDev = (_a = "isDev" in metadata && metadata.isDev) != null ? _a : false;
+  const currentConfig = isDev ? walletConfig.dev : walletConfig[options.network.networkId];
+  const walletNetwork = isDev ? "dev" : options.network.networkId;
   initWalletButton(walletNetwork, wallet);
   if (!inter) {
     inter = setInterval(() => __async(void 0, null, function* () {
@@ -3085,105 +3560,140 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
     });
   }
   function signAndSendTransactions(params) {
-    return __async(this, null, function* () {
-      const btcContext = window.btcContext;
-      const accountId = state.getAccount();
-      const publicKey = state.getPublicKey();
-      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"
-      });
-      const accessKey = __spreadProps(__spreadValues({}, rawAccessKey), {
-        nonce: BigInt(rawAccessKey.nonce || 0)
-      });
-      const publicKeyFormat = import_key_pair.PublicKey.from(publicKey);
-      const { result_data: nearNonceFromApi } = yield getNearNonceFromApi(
-        currentConfig.base_url,
-        accountId
-      );
-      const { transferGasTransaction, useNearPayGas } = yield getGasConfig();
-      console.log("transferGasTransaction:", transferGasTransaction);
-      console.log("useNearPayGas:", useNearPayGas);
-      if (!useNearPayGas && transferGasTransaction) {
-        params.transactions.unshift(transferGasTransaction);
-      }
-      console.log("raw transactions:", params.transactions);
-      const newTransactions = params.transactions.map((transaction, index) => {
-        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_utils5.baseDecode)(header.hash)
-        );
-        const txBytes = (0, import_transaction.encodeTransaction)(_transaction);
-        const txHex = Array.from(
-          txBytes,
-          (byte) => ("0" + (byte & 255).toString(16)).slice(-2)
-        ).join("");
-        console.log("txHex:", txHex);
-        const hash = import_bs58.default.encode(new Uint8Array(import_js_sha256.sha256.array(txBytes)));
-        return { txBytes, txHex, hash };
-      });
-      const accountInfo = yield nearCall2(
-        currentConfig.accountContractId,
-        "get_account",
-        { account_id: accountId }
+    return __async(this, null, function* () {
+      const btcContext = window.btcContext;
+      const accountId = state.getAccount();
+      const accountInfo = yield getAccountInfo();
+      yield checkGasTokenArrears(accountInfo.debt_info);
+      const trans = [...params.transactions];
+      console.log("raw trans:", trans);
+      const gasTokenBalance = accountInfo.gas_token[currentConfig.token] || "0";
+      const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy(
+        gasTokenBalance,
+        trans
       );
-      const { result_data: nonceFromApi } = yield getNonceFromApi(
-        currentConfig.base_url,
-        accountId
+      console.log("transferGasTransaction:", transferGasTransaction);
+      console.log("useNearPayGas:", useNearPayGas);
+      console.log("gasLimit:", gasLimit);
+      if (transferGasTransaction) {
+        trans.unshift(transferGasTransaction);
+      }
+      console.log("calculateGasStrategy trans:", trans);
+      const newTrans = yield Promise.all(
+        trans.map((transaction, index) => convertTransactionToTxHex(transaction, index))
       );
+      const nonceFromApi = yield getNonce(currentConfig.base_url, accountId);
       const nonce = Number(nonceFromApi) > Number(accountInfo.nonce) ? String(nonceFromApi) : String(accountInfo.nonce);
       const intention = {
         chain_id: "397",
         csna: accountId,
-        near_transactions: newTransactions.map((t) => t.txHex),
+        near_transactions: newTrans.map((t) => t.txHex),
         gas_token: currentConfig.token,
-        gas_limit: currentConfig.gasTokenLimit,
+        gas_limit: gasLimit,
         use_near_pay_gas: useNearPayGas,
         nonce
       };
       const strIntention = JSON.stringify(intention);
       const signature = yield btcContext.signMessage(strIntention);
-      const result = yield uploadBTCTx(currentConfig.base_url, {
+      yield receiveTransaction(currentConfig.base_url, {
         sig: signature,
         btcPubKey: state.getBtcPublicKey(),
         data: toHex(strIntention)
       });
-      if (result.result_code === 0) {
-        const hash = newTransactions.map((t) => t.hash);
-        console.log("txHash:", hash);
-        const result2 = yield pollTransactionStatuses(options.network.networkId, hash);
-        return result2;
+      yield checkBtcTransactionStatus(currentConfig.base_url, signature);
+      const hash = newTrans.map((t) => t.hash);
+      console.log("txHash:", hash);
+      const result = yield pollTransactionStatuses(options.network.networkId, hash);
+      return result;
+    });
+  }
+  function checkGasTokenArrears(debtInfo) {
+    return __async(this, null, function* () {
+      const transferAmount = (debtInfo == null ? void 0 : debtInfo.transfer_amount) || "0";
+      console.log("get_account debtInfo:", debtInfo);
+      if (transferAmount === "0")
+        return;
+      const confirmed = yield Dialog.confirm({
+        title: "Has gas token arrears",
+        message: "You have gas token arrears, please deposit gas token to continue."
+      });
+      if (confirmed) {
+        const action = {
+          receiver_id: currentConfig.token,
+          amount: transferAmount,
+          msg: JSON.stringify("Deposit")
+        };
+        yield executeBTCDepositAndAction({ action, isDev });
+        yield Dialog.alert({
+          title: "Deposit success",
+          message: "Deposit success, will continue to execute transaction."
+        });
+      } else {
+        throw new Error("Deposit failed, please deposit gas token first.");
+      }
+    });
+  }
+  function getAccountInfo() {
+    return __async(this, null, function* () {
+      const accountId = state.getAccount();
+      const accountInfo = yield nearCall2(currentConfig.accountContractId, "get_account", { account_id: accountId });
+      return accountInfo;
+    });
+  }
+  function createGasTokenTransfer(accountId, amount) {
+    return __async(this, null, function* () {
+      return {
+        signerId: accountId,
+        receiverId: currentConfig.token,
+        actions: [
+          {
+            type: "FunctionCall",
+            params: {
+              methodName: "ft_transfer_call",
+              args: {
+                receiver_id: currentConfig.accountContractId,
+                amount,
+                msg: JSON.stringify("Deposit")
+              },
+              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 {
-        return null;
+        newGasLimit = yield getPredictedGasAmount(
+          currentConfig.accountContractId,
+          currentConfig.token,
+          [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);
+      console.log("predictedGas:", predictedGasAmount);
+      return predictedGasAmount;
     });
   }
-  function getGasConfig() {
+  function calculateGasStrategy(gasTokenBalance, transactions2) {
     return __async(this, null, function* () {
+      var _a2;
       const accountId = state.getAccount();
       const nearAccount = yield provider.query({
         request_type: "view_account",
@@ -3191,39 +3701,102 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         finality: "final"
       });
       const availableBalance = parseFloat(nearAccount.amount) / __pow(10, 24);
+      console.log("available near balance:", availableBalance);
+      console.log("available gas token balance:", gasTokenBalance);
+      const convertTx = yield Promise.all(
+        transactions2.map((transaction, index) => convertTransactionToTxHex(transaction, index))
+      );
       if (availableBalance > 0.2) {
-        return { useNearPayGas: true };
+        const gasTokens = yield nearCall2(
+          currentConfig.accountContractId,
+          "list_gas_token",
+          { token_ids: [currentConfig.token] }
+        );
+        console.log("list_gas_token gas tokens:", gasTokens);
+        const perTxFee = Math.max(
+          Number(((_a2 = gasTokens[currentConfig.token]) == null ? void 0 : _a2.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 {
-        const gasTokenBalance = yield nearCall2(currentConfig.token, "ft_balance_of", {
-          account_id: accountId
-        });
-        if (new import_big.default(gasTokenBalance).gt(currentConfig.gasTokenLimit)) {
-          const transferGasTransaction = {
-            signerId: accountId,
-            receiverId: currentConfig.token,
-            actions: [
-              {
-                type: "FunctionCall",
-                params: {
-                  methodName: "ft_transfer_call",
-                  args: {
-                    receiver_id: currentConfig.accountContractId,
-                    amount: currentConfig.gasTokenLimit,
-                    msg: "Deposit"
-                  },
-                  gas: new import_big.default(50).mul(__pow(10, 12)).toFixed(0),
-                  deposit: "1"
-                }
-              }
-            ]
-          };
-          return { transferGasTransaction, useNearPayGas: false };
+        console.log("near balance is not enough, predict the gas token amount required");
+        const adjustedGas = yield getPredictedGasAmount(
+          currentConfig.accountContractId,
+          currentConfig.token,
+          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 {
-          throw new Error("No enough gas token balance");
+          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"
+      });
+      const accessKey = __spreadProps(__spreadValues({}, rawAccessKey), {
+        nonce: BigInt(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_utils6.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 initWalletButton(network, wallet2) {
     return __async(this, null, function* () {
       const checkAndSetupWalletButton = () => {
@@ -3244,17 +3817,13 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
   }
   return wallet;
 });
-function getNonceFromApi(url, accountId) {
-  return request(`${url}/v1/nonce?csna=${accountId}`);
-}
-function getNearNonceFromApi(url, accountId) {
-  return request(`${url}/v1/nonceNear?csna=${accountId}`);
-}
-function uploadBTCTx(url, data) {
-  return request(`${url}/v1/receiveTransaction`, {
-    method: "POST",
-    body: data
-  });
+function toHex(originalString) {
+  const charArray = originalString.split("");
+  const asciiArray = charArray.map((char) => char.charCodeAt(0));
+  const hexArray = asciiArray.map((code) => code.toString(16));
+  let hexString = hexArray.join("");
+  hexString = hexString.replace(/(^0+)/g, "");
+  return hexString;
 }
 function setupBTCWallet({
   iconUrl = "https://assets.deltatrade.ai/assets/chain/btc.svg",
@@ -3283,232 +3852,10 @@ function setupBTCWallet({
   });
   return btcWallet;
 }
-function toHex(originalString) {
-  const charArray = originalString.split("");
-  const asciiArray = charArray.map((char) => char.charCodeAt(0));
-  const hexArray = asciiArray.map((code) => code.toString(16));
-  let hexString = hexArray.join("");
-  hexString = hexString.replace(/(^0+)/g, "");
-  return hexString;
-}
-
-// src/core/btcUtils.ts
-var import_big2 = __toESM(require("big.js"), 1);
-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(isDev) {
-  return __async(this, null, function* () {
-    const network = yield getNetwork();
-    return walletConfig[isDev ? "dev" : network];
-  });
-}
-function nearCall(contractId, methodName, args) {
-  return __async(this, null, function* () {
-    const network = yield getNetwork();
-    return nearCallFunction(contractId, methodName, args, { network });
-  });
-}
-function receiveDepositMsg(_0, _1) {
-  return __async(this, arguments, function* (baseUrl, {
-    btcPublicKey,
-    txHash,
-    depositType = 1,
-    postActions,
-    extraMsg
-  }) {
-    const res = yield request(`${baseUrl}/v1/receiveDepositMsg`, {
-      method: "POST",
-      body: { btcPublicKey, txHash, depositType, postActions, extraMsg }
-    });
-    console.log("receiveDepositMsg resp:", res);
-    return res;
-  });
-}
-function checkTransactionStatus(baseUrl, txHash) {
-  return __async(this, null, function* () {
-    const res = yield request(
-      `${baseUrl}/v1/bridgeFromTx?fromTxHash=${txHash}&fromChainId=1`,
-      {
-        timeout: 6e4,
-        pollingInterval: 5e3,
-        maxPollingAttempts: 10,
-        shouldStopPolling: (res2) => res2.result_code === 0
-      }
-    );
-    return res;
-  });
-}
-function getBtcGasPrice() {
-  return __async(this, null, function* () {
-    const defaultFeeRate = 100;
-    try {
-      const btcRpcUrl = yield getBtcRpcUrl();
-      const res = yield fetch(`${btcRpcUrl}/v1/fees/recommended`).then((res2) => res2.json());
-      const feeRate = res.fastestFee;
-      return feeRate || defaultFeeRate;
-    } catch (error) {
-      return defaultFeeRate;
-    }
-  });
-}
-function getBtcBalance() {
-  return __async(this, null, function* () {
-    const { account } = yield retryOperation(getBtcProvider, (res2) => !!res2.account);
-    if (!account) {
-      console.error("BTC Account is not available.");
-      return { rawBalance: 0, balance: 0, maxSpendableBalance: 0 };
-    }
-    const btcRpcUrl = yield getBtcRpcUrl();
-    const res = yield fetch(`${btcRpcUrl}/address/${account}/utxo`).then((res2) => res2.json());
-    const rawBalance = res == null ? void 0 : res.reduce((acc, cur) => acc + cur.value, 0);
-    const balance = rawBalance / __pow(10, 8);
-    const feeRate = yield getBtcGasPrice();
-    const maxGasFee = feeRate * 350 / __pow(10, 8);
-    const availableBalance = Math.max(0, balance - maxGasFee);
-    return {
-      rawBalance,
-      balance,
-      availableBalance
-    };
-  });
-}
-function sendBitcoin(address, amount, feeRate) {
-  return __async(this, null, function* () {
-    const { sendBitcoin: sendBitcoin2 } = getBtcProvider();
-    const txHash = yield sendBitcoin2(address, amount, { feeRate });
-    return txHash;
-  });
-}
-function estimateDepositAmount(amount, option) {
-  return __async(this, null, function* () {
-    const config = yield getConfig((option == null ? void 0 : option.isDev) || false);
-    const {
-      deposit_bridge_fee: { fee_min, fee_rate }
-    } = yield nearCall(
-      config.bridgeContractId,
-      "get_config",
-      {}
-    );
-    const fee = Math.max(Number(fee_min), Number(amount) * fee_rate);
-    return new import_big2.default(amount).minus(fee).toFixed(0);
-  });
-}
-function executeBTCDepositAndAction(_0) {
-  return __async(this, arguments, function* ({
-    action,
-    feeRate,
-    isDev = false
-  }) {
-    try {
-      const { getPublicKey } = getBtcProvider();
-      const config = yield getConfig(isDev);
-      const btcPublicKey = yield getPublicKey();
-      const _action = Object.assign(
-        {},
-        __spreadProps(__spreadValues({}, action), {
-          gas: new import_big2.default(100).mul(__pow(10, 12)).toFixed(0)
-        })
-      );
-      if (!btcPublicKey) {
-        throw new Error("BTC Public Key is not available.");
-      }
-      if (!_action.receiver_id) {
-        throw new Error("action.receiver_id is required");
-      }
-      const amountWithFee = yield estimateDepositAmount(_action.amount, {
-        isDev
-      });
-      _action.amount = amountWithFee;
-      if (!_action.amount || !new import_big2.default(_action.amount || 0).gt(0)) {
-        throw new Error("action.amount is required or deposit amount is not enough");
-      }
-      const csna = yield nearCall(
-        config.accountContractId,
-        "get_chain_signature_near_account_id",
-        {
-          btc_public_key: btcPublicKey
-        }
-      );
-      const depositMsg = {
-        recipient_id: csna,
-        post_actions: [_action]
-      };
-      const storageDepositMsg = {};
-      const accountInfo = yield nearCall(
-        config.accountContractId,
-        "get_account",
-        {
-          account_id: csna
-        }
-      );
-      if (!(accountInfo == null ? void 0 : accountInfo.nonce)) {
-        storageDepositMsg.btc_public_key = btcPublicKey;
-      }
-      const registerRes = yield nearCall(action.receiver_id, "storage_balance_of", {
-        account_id: csna
-      });
-      if (!(registerRes == null ? void 0 : registerRes.available)) {
-        storageDepositMsg.storage_deposit_msg = {
-          contract_id: action.receiver_id,
-          deposit: new import_big2.default(0.25).mul(__pow(10, 24)).toFixed(0),
-          registration_only: true
-        };
-      }
-      if (Object.keys(storageDepositMsg).length > 0) {
-        depositMsg.extra_msg = JSON.stringify(storageDepositMsg);
-      }
-      console.log("get_user_deposit_address params:", { deposit_msg: depositMsg });
-      const userDepositAddress = yield nearCall(
-        config.bridgeContractId,
-        "get_user_deposit_address",
-        { deposit_msg: depositMsg }
-      );
-      const _feeRate = feeRate || (yield getBtcGasPrice());
-      console.log("user deposit address:", userDepositAddress);
-      console.log("deposit amount:", new import_big2.default(action.amount).toNumber());
-      console.log("receive amount:", new import_big2.default(_action.amount).toNumber());
-      console.log("fee rate:", _feeRate);
-      const txHash = yield sendBitcoin(
-        userDepositAddress,
-        new import_big2.default(action.amount).toNumber(),
-        _feeRate
-      );
-      yield receiveDepositMsg(config.base_url, {
-        btcPublicKey,
-        txHash,
-        postActions: JSON.stringify(depositMsg.post_actions),
-        extraMsg: depositMsg.extra_msg
-      });
-      const checkTransactionStatusRes = yield checkTransactionStatus(config.base_url, txHash);
-      console.log("checkTransactionStatus resp:", checkTransactionStatusRes);
-      return checkTransactionStatusRes.result_code === 0 ? { result: "success" } : { result: "failed", error: checkTransactionStatusRes.result_message };
-    } catch (error) {
-      console.error("Error executing Bridge+BurrowSupply:", error);
-      return { result: "failed", error: error.message };
-    }
-  });
-}
 
 // src/index.ts
 var getVersion = () => {
-  return "0.3.10";
+  return "0.3.12";
 };
 if (typeof window !== "undefined") {
   window.__PARTICLE_BTC_CONNECT_VERSION = getVersion();