btc-wallet 0.3.10 → 0.3.11

package/dist/utils/nearUtils.d.ts

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

package/esm/index.js

@@ -2714,9 +2714,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 = {
@@ -2820,29 +2818,38 @@ function pollTransactionStatuses(network, hashes) {
         (url) => new providers.JsonRpcProvider({ url })
       )
     );
-    const maxAttempts = 3;
-    const pollStatus = (hash) => __async(this, null, function* () {
-      let attempt = 0;
-      while (attempt < maxAttempts) {
-        attempt++;
+    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);
-            return result;
+            results.set(hash, result);
+            pendingHashes.delete(hash);
           }
         } catch (error) {
           console.error(`Failed to fetch transaction status for ${hash}: ${error.message}`);
         }
-        if (attempt === maxAttempts) {
-          throw new Error(`Transaction not found after max attempts: ${hash}`);
+      }));
+      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);
-        console.log(`RPC request failed for ${hash}, retrying ${maxAttempts - attempt} more times`);
       }
-    });
-    const results = yield Promise.all(hashes.map((hash) => pollStatus(hash)));
-    return results;
+    }
+    return hashes.map((hash) => results.get(hash));
   });
 }
 
@@ -3048,80 +3055,31 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
     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 = PublicKey.from(publicKey);
-      const { result_data: nearNonceFromApi } = yield getNearNonceFromApi(
-        currentConfig.base_url,
-        accountId
-      );
-      const { transferGasTransaction, useNearPayGas } = yield getGasConfig();
+      const trans = [...params.transactions];
+      console.log("raw trans:", trans);
+      const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy(trans);
       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 = transactions.createTransaction(
-          accountId,
-          publicKeyFormat,
-          transaction.receiverId,
-          BigInt(nearNonceNumber) + BigInt(index),
-          newActions,
-          baseDecode(header.hash)
-        );
-        const txBytes = encodeTransaction(_transaction);
-        const txHex = Array.from(
-          txBytes,
-          (byte) => ("0" + (byte & 255).toString(16)).slice(-2)
-        ).join("");
-        console.log("txHex:", txHex);
-        const hash = bs58.encode(new Uint8Array(sha256.array(txBytes)));
-        return { txBytes, txHex, hash };
-      });
-      const accountInfo = yield nearCall2(
-        currentConfig.accountContractId,
-        "get_account",
-        { account_id: accountId }
+      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 { result_data: nonceFromApi } = yield getNonceFromApi(
         currentConfig.base_url,
         accountId
       );
+      const accountInfo = yield getAccountInfo();
       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
       };
@@ -3133,7 +3091,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         data: toHex(strIntention)
       });
       if (result.result_code === 0) {
-        const hash = newTransactions.map((t) => t.hash);
+        const hash = newTrans.map((t) => t.hash);
         console.log("txHash:", hash);
         const result2 = yield pollTransactionStatuses(options.network.networkId, hash);
         return result2;
@@ -3142,8 +3100,71 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       }
     });
   }
-  function getGasConfig() {
+  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 Big(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 Big(perTxFee).mul(transactions2.length + 1).toFixed(0);
+      } else {
+        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 Big(predictedGas).mul(1.2).toFixed(0);
+      console.log("predictedGas:", predictedGasAmount);
+      return predictedGasAmount;
+    });
+  }
+  function calculateGasStrategy(transactions2) {
     return __async(this, null, function* () {
+      var _a;
       const accountId = state.getAccount();
       const nearAccount = yield provider.query({
         request_type: "view_account",
@@ -3151,39 +3172,107 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         finality: "final"
       });
       const availableBalance = parseFloat(nearAccount.amount) / __pow(10, 24);
+      console.log("available near balance:", availableBalance);
+      const accountInfo = yield getAccountInfo();
+      const gasTokenBalance = accountInfo.gas_token[currentConfig.token] || "0";
+      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(((_a = gasTokens[currentConfig.token]) == null ? void 0 : _a.per_tx_protocol_fee) || 0),
+          100
+        );
+        console.log("perTxFee:", perTxFee);
+        const protocolFee = new Big(perTxFee || "0").mul(convertTx.length).toFixed(0);
+        console.log("protocolFee:", protocolFee);
+        if (new Big(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 Big(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 Big(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 Big(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 = 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 { result_data: nearNonceFromApi } = yield getNearNonceFromApi(
+        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 = transactions.createTransaction(
+        accountId,
+        publicKeyFormat,
+        transaction.receiverId,
+        BigInt(nearNonceNumber) + BigInt(index),
+        newActions,
+        baseDecode(header.hash)
+      );
+      const txBytes = encodeTransaction(_transaction);
+      const txHex = Array.from(txBytes, (byte) => ("0" + (byte & 255).toString(16)).slice(-2)).join(
+        ""
+      );
+      const hash = bs58.encode(new Uint8Array(sha256.array(txBytes)));
+      return { txBytes, txHex, hash };
+    });
+  }
   function initWalletButton(network, wallet2) {
     return __async(this, null, function* () {
       const checkAndSetupWalletButton = () => {
@@ -3216,6 +3305,14 @@ function uploadBTCTx(url, data) {
     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",
   deprecated = false,
@@ -3243,14 +3340,6 @@ 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
 import Big2 from "big.js";
@@ -3330,18 +3419,23 @@ function getBtcGasPrice() {
 }
 function getBtcBalance() {
   return __async(this, null, function* () {
-    const { account } = yield retryOperation(getBtcProvider, (res2) => !!res2.account);
+    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 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 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 maxGasFee = feeRate * 350 / __pow(10, 8);
-    const availableBalance = Math.max(0, balance - maxGasFee);
+    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,
@@ -3468,7 +3562,7 @@ function executeBTCDepositAndAction(_0) {
 
 // src/index.ts
 var getVersion = () => {
-  return "0.3.10";
+  return "0.3.11";
 };
 if (typeof window !== "undefined") {
   window.__PARTICLE_BTC_CONNECT_VERSION = getVersion();