btc-wallet 0.5.19-beta → 0.5.21-beta

package/dist/utils/satoshi.d.ts

@@ -38,6 +38,23 @@ export declare function getAccountInfo({ csna, env }: {
     csna: string;
     env: ENV;
 }): Promise<AccountInfo | undefined>;
+export declare function getBridgeConfig({ env }: {
+    env: ENV;
+}): Promise<{
+    min_withdraw_amount: string;
+    withdraw_bridge_fee: {
+        fee_rate: number;
+        fee_min: string;
+    };
+    max_btc_gas_fee: string;
+    change_address: string;
+    min_change_amount: string;
+    deposit_bridge_fee: {
+        fee_rate: number;
+        fee_min: string;
+    };
+    min_deposit_amount: string;
+}>;
 export declare function getTokenBalance({ csna, tokenId, env, }: {
     csna: string;
     tokenId: string;
@@ -69,4 +86,22 @@ export declare function calculateGasStrategy({ csna, transactions, env, }: Calcu
     useNearPayGas: boolean;
     gasLimit: string;
 }>;
+interface CalculateWithdrawParams {
+    amount: string | number;
+    feeRate?: number;
+    csna: string;
+    btcAddress: string;
+    env: ENV;
+}
+interface CalculateWithdrawResult {
+    withdrawFee: number;
+    gasFee?: number;
+    inputs?: any[];
+    outputs?: any[];
+    fromAmount?: number;
+    receiveAmount?: string;
+    isError: boolean;
+    errorMsg?: string;
+}
+export declare function calculateWithdraw({ amount, feeRate, csna, btcAddress, env, }: CalculateWithdrawParams): Promise<CalculateWithdrawResult>;
 export {};

package/esm/index.js

@@ -19,6 +19,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -2963,7 +2975,6 @@ function request(url, options) {
       }
       return data;
     } catch (err) {
-      console.error(err);
       if (retryCount > 0) {
         console.log(`Retrying... attempts left: ${retryCount}`);
         return request(url, __spreadProps(__spreadValues({}, options), { retryCount: retryCount - 1 }));
@@ -2977,6 +2988,7 @@ function request(url, options) {
           }));
         }
       }
+      console.error(err);
       return Promise.reject(err);
     }
   });
@@ -3149,6 +3161,7 @@ var state_default = {
 };
 
 // src/utils/satoshi.ts
+import coinselect from "coinselect";
 function getNonce(url, accountId) {
   return __async(this, null, function* () {
     const { result_code, result_message, result_data } = yield request(
@@ -3226,12 +3239,13 @@ function checkBridgeTransactionStatus(url, txHash) {
       maxPollingAttempts: 60,
       shouldStopPolling: (res) => {
         var _a;
-        return res.result_code === 0 && [4, 102].includes(((_a = res.result_data) == null ? void 0 : _a.Status) || 0);
+        const status = ((_a = res.result_data) == null ? void 0 : _a.Status) || 0;
+        return res.result_code === 0 && (status === 4 || status >= 50);
       }
     });
     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);
+      throw new Error(result_message || `Transaction failed, status: ${result_data == null ? void 0 : result_data.Status}`);
     }
     return result_data;
   });
@@ -3244,12 +3258,13 @@ function checkBtcTransactionStatus(url, sig) {
       maxPollingAttempts: 60,
       shouldStopPolling: (res) => {
         var _a;
-        return res.result_code === 0 && [3, 101, 102].includes(((_a = res.result_data) == null ? void 0 : _a.Status) || 0);
+        const status = ((_a = res.result_data) == null ? void 0 : _a.Status) || 0;
+        return res.result_code === 0 && (status === 3 || status >= 10);
       }
     });
     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);
+      throw new Error(result_message || `Transaction failed, status: ${result_data == null ? void 0 : result_data.Status}`);
     }
     return result_data;
   });
@@ -3276,10 +3291,16 @@ function getAccountInfo(_0) {
     ).catch((error) => {
       return void 0;
     });
-    console.log("get_account accountInfo:", accountInfo);
     return accountInfo;
   });
 }
+function getBridgeConfig(_0) {
+  return __async(this, arguments, function* ({ env }) {
+    const config = getWalletConfig(env);
+    const bridgeConfig = yield nearCallFunction(config.bridgeContractId, "get_config", {}, { network: config.network });
+    return bridgeConfig;
+  });
+}
 function getTokenBalance(_0) {
   return __async(this, arguments, function* ({
     csna,
@@ -3578,11 +3599,196 @@ function getPredictedGasAmount(_0) {
     return gasAmount.toString();
   });
 }
+function calculateWithdraw(_0) {
+  return __async(this, arguments, function* ({
+    amount,
+    feeRate,
+    csna,
+    btcAddress,
+    env
+  }) {
+    console.log("calculateWithdraw feeRate:", feeRate);
+    try {
+      const config = getWalletConfig(env);
+      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
+      });
+      let satoshis = Number(amount);
+      if (Number(gasLimit) > 0) {
+        satoshis = new Big(amount).minus(gasLimit).toNumber();
+      }
+      const brgConfig = yield getBridgeConfig({ env });
+      const allUTXO = yield nearCallFunction(config.bridgeContractId, "get_utxos_paged", {}, { network: config.network });
+      if (brgConfig.min_withdraw_amount) {
+        if (Number(satoshis) < Number(brgConfig.min_withdraw_amount)) {
+          return {
+            withdrawFee: 0,
+            isError: true,
+            errorMsg: "Mini withdraw amount is " + (Number(brgConfig.min_withdraw_amount) + Number(gasLimit))
+          };
+        }
+      }
+      const feePercent = Number(brgConfig.withdraw_bridge_fee.fee_rate) * Number(satoshis);
+      const withdrawFee = feePercent > Number(brgConfig.withdraw_bridge_fee.fee_min) ? feePercent : Number(brgConfig.withdraw_bridge_fee.fee_min);
+      const withdrawChangeAddress = brgConfig.change_address;
+      const utxos = Object.keys(allUTXO).map((key) => {
+        const txid = key.split("@");
+        return {
+          txid: txid[0],
+          vout: allUTXO[key].vout,
+          value: Number(allUTXO[key].balance),
+          script: allUTXO[key].script
+        };
+      }).filter((utxo) => utxo.value > Number(brgConfig.min_change_amount));
+      if (!utxos || utxos.length === 0) {
+        return {
+          withdrawFee,
+          isError: true,
+          errorMsg: "The network is busy, please try again later."
+        };
+      }
+      const userSatoshis = Number(satoshis);
+      const maxBtcFee = Number(brgConfig.max_btc_gas_fee);
+      const { inputs, outputs, fee } = coinselect(
+        utxos,
+        [{ address: btcAddress, value: userSatoshis }],
+        Math.ceil(feeRate || 0)
+      );
+      const newInputs = inputs;
+      let newOutputs = outputs;
+      let newFee = fee;
+      if (!newOutputs || newOutputs.length === 0) {
+        return {
+          withdrawFee,
+          isError: true,
+          errorMsg: "The network is busy, please try again later."
+        };
+      }
+      let userOutput, noUserOutput;
+      for (let i = 0; i < newOutputs.length; i++) {
+        const output = newOutputs[i];
+        if (output.value.toString() === userSatoshis.toString()) {
+          userOutput = output;
+        } else {
+          noUserOutput = output;
+        }
+        if (!output.address) {
+          output.address = withdrawChangeAddress;
+        }
+      }
+      let dis = 0;
+      if (newFee > maxBtcFee) {
+        dis = newFee - maxBtcFee;
+        newFee = maxBtcFee;
+        return {
+          gasFee: newFee,
+          withdrawFee,
+          isError: true,
+          errorMsg: "Gas exceeds maximum value"
+        };
+      }
+      userOutput.value = new Big(userOutput.value).minus(newFee).minus(withdrawFee).toNumber();
+      if (userOutput.value < 0) {
+        return {
+          gasFee: newFee,
+          withdrawFee,
+          isError: true,
+          errorMsg: "Not enough gas"
+        };
+      }
+      if (noUserOutput) {
+        if (!noUserOutput.address) {
+          noUserOutput.address = withdrawChangeAddress;
+        }
+        noUserOutput.value = new Big(noUserOutput.value).plus(newFee).plus(withdrawFee).plus(dis).toNumber();
+      } else {
+        noUserOutput = {
+          address: withdrawChangeAddress,
+          value: new Big(newFee).plus(withdrawFee).plus(dis).toNumber()
+        };
+        newOutputs.push(noUserOutput);
+      }
+      let minValue = Math.min(...newInputs.map((input) => input.value));
+      let totalNoUserOutputValue = noUserOutput.value;
+      while (totalNoUserOutputValue >= minValue && minValue > 0 && newInputs.length > 0) {
+        totalNoUserOutputValue -= minValue;
+        noUserOutput.value = totalNoUserOutputValue;
+        const minValueIndex = newInputs.findIndex((input) => input.value === minValue);
+        if (minValueIndex > -1) {
+          newInputs.splice(minValueIndex, 1);
+        }
+        minValue = Math.min(...newInputs.map((input) => input.value));
+      }
+      let gasMore = 0;
+      if (noUserOutput.value === 0) {
+        newOutputs = newOutputs.filter((item) => item.value !== 0);
+      } else if (noUserOutput.value < Number(brgConfig.min_change_amount)) {
+        gasMore = Number(brgConfig.min_change_amount) - noUserOutput.value;
+        userOutput.value -= gasMore;
+        noUserOutput.value = Number(brgConfig.min_change_amount);
+      }
+      const insufficientOutput = newOutputs.some((item) => item.value < 0);
+      if (insufficientOutput) {
+        return {
+          gasFee: newFee,
+          withdrawFee,
+          isError: true,
+          errorMsg: "Not enough gas"
+        };
+      }
+      const inputSum = newInputs.reduce((sum, cur) => sum + Number(cur.value), 0);
+      const outputSum = newOutputs.reduce((sum, cur) => sum + Number(cur.value), 0);
+      if (newFee + outputSum !== inputSum) {
+        return {
+          withdrawFee,
+          isError: true,
+          errorMsg: "Service busy, please try again later"
+        };
+      }
+      return {
+        withdrawFee: new Big(withdrawFee).plus(gasLimit).plus(gasMore).toNumber(),
+        gasFee: new Big(newFee).toNumber(),
+        inputs: newInputs,
+        outputs: newOutputs,
+        fromAmount: satoshis,
+        receiveAmount: userOutput.value,
+        isError: false
+      };
+    } catch (error) {
+      return {
+        withdrawFee: 0,
+        isError: true,
+        errorMsg: error.message
+      };
+    }
+  });
+}
 
 // src/core/btcUtils.ts
 import bitcoin from "bitcoinjs-lib";
 import * as ecc from "@bitcoinerlab/secp256k1";
-import coinselect from "coinselect";
 bitcoin.initEccLib(ecc);
 var NEAR_STORAGE_DEPOSIT_AMOUNT = "1250000000000000000000";
 var NBTC_STORAGE_DEPOSIT_AMOUNT = "3000";
@@ -3706,7 +3912,6 @@ 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 = getWalletConfig(env);
     const csna = yield getCsnaAccountId(env);
     const accountInfo = yield getAccountInfo({ csna, env });
     const debtAction = yield checkGasTokenDebt(csna, env, false);
@@ -3714,7 +3919,7 @@ function getDepositAmount(amount, option) {
     const {
       deposit_bridge_fee: { fee_min, fee_rate },
       min_deposit_amount
-    } = yield nearCall(config.bridgeContractId, "get_config", {});
+    } = yield getBridgeConfig({ env });
     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;
@@ -3906,190 +4111,52 @@ function getWithdrawTransaction(_0) {
     feeRate,
     env = "mainnet"
   }) {
-    console.log("=== Start getWithdrawTransaction ===");
+    const config = getWalletConfig(env);
     const provider = getBtcProvider();
     const btcAddress = provider.account;
-    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)) {
-        throw new Error("Mini withdraw amount is " + brgConfig.min_withdraw_amount);
-      }
-    }
-    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({
+    const _feeRate = feeRate || (yield getBtcGasPrice());
+    const _a = yield calculateWithdraw({
+      amount,
+      feeRate: _feeRate,
       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"
-              }
-            }
-          ]
-        }
-      ],
+      btcAddress,
       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.");
+    }), { inputs, outputs, isError, errorMsg } = _a, rest = __objRest(_a, ["inputs", "outputs", "isError", "errorMsg"]);
+    if (isError || !inputs || !outputs) {
+      throw new Error(errorMsg);
     }
-    const utxos = Object.keys(allUTXO).map((key) => {
-      const txid = key.split("@");
-      return {
-        txid: txid[0],
-        vout: allUTXO[key].vout,
-        value: Number(allUTXO[key].balance),
-        script: allUTXO[key].script
-      };
-    });
-    console.log("Formatted UTXOs:", utxos);
-    const _feeRate = feeRate || (yield getBtcGasPrice());
-    console.log("Fee Rate:", _feeRate);
-    const coinSelectResult = coinselect(
-      utxos,
-      [{ address: btcAddress, value: Number(finalAmount) }],
-      Math.ceil(_feeRate)
+    console.log("inputs:", JSON.stringify(inputs));
+    console.log("outputs:", JSON.stringify(outputs));
+    console.log("inputs - outputs = gas");
+    console.log(
+      `(${inputs.map((item) => item.value).join(" + ")}) - (${outputs.map((item) => item.value).join(" + ")}) = ${rest.gasFee}`
     );
-    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;
-    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() === finalAmount.toString()) {
-        recipientOutput = output;
-      } else {
-        changeOutput = output;
-      }
-      if (!output.address) {
-        output.address = brgConfig.change_address;
-      }
-    }
-    console.log("Initial Outputs:", { recipientOutput, changeOutput });
-    recipientOutput.value = new Big2(recipientOutput.value).minus(transactionFee).minus(withdrawFee).toNumber();
-    if (changeOutput) {
-      changeOutput.value = new Big2(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;
-        const smallestInputIndex = remainingInputs.findIndex(
-          (input) => input.value === smallestInput
-        );
-        if (smallestInputIndex > -1) {
-          remainingInputs.splice(smallestInputIndex, 1);
-        }
-        smallestInput = Math.min.apply(
-          null,
-          remainingInputs.map((input) => input.value)
-        );
-        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) {
-        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: brgConfig.change_address,
-        value: new Big2(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();
     const btcNetwork = network === "mainnet" ? bitcoin.networks.bitcoin : bitcoin.networks.testnet;
     const psbt = new bitcoin.Psbt({ network: btcNetwork });
     const btcRpcUrl = yield getBtcRpcUrl();
-    for (let i = 0; i < inputs.length; i++) {
-      const input = inputs[i];
-      const txData = yield fetch(`${btcRpcUrl}/tx/${input.txid}`).then((res) => res.json());
-      const inputOptions = {
-        hash: input.txid,
-        index: input.vout,
-        sequence: 4294967293,
-        witnessUtxo: {
-          script: Buffer.from(txData.vout[input.vout].scriptpubkey, "hex"),
-          value: input.value
-        }
-      };
-      psbt.addInput(inputOptions);
-    }
+    Promise.all(
+      inputs.map((input) => __async(this, null, function* () {
+        const txData = yield fetch(`${btcRpcUrl}/tx/${input.txid}`).then((res) => res.json());
+        const inputOptions = {
+          hash: input.txid,
+          index: input.vout,
+          sequence: 4294967293,
+          witnessUtxo: {
+            script: Buffer.from(txData.vout[input.vout].scriptpubkey, "hex"),
+            value: input.value
+          }
+        };
+        psbt.addInput(inputOptions);
+      }))
+    );
     outputs.forEach((output) => {
       psbt.addOutput({
         address: output.address,
         value: output.value
       });
     });
-    console.log("outputs:", JSON.stringify(outputs));
     const _inputs = inputs.map((item) => {
       return `${item.txid}:${item.vout}`;
     });
@@ -4573,6 +4640,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       const btcContext = window.btcContext;
       const csna = state_default.getAccount();
       const accountInfo = yield getAccountInfo({ csna, env });
+      yield checkGasTokenDebt(csna, env, true);
       const trans = [...params.transactions];
       console.log("signAndSendTransactions raw trans:", trans);
       const { transferGasTransaction, useNearPayGas, gasLimit } = yield calculateGasStrategy({
@@ -4673,7 +4741,7 @@ function setupBTCWallet({
 
 // src/index.ts
 var getVersion = () => {
-  return "0.5.19-beta";
+  return "0.5.21-beta";
 };
 if (typeof window !== "undefined") {
   window.__BTC_WALLET_VERSION = getVersion();