btc-wallet 0.3.5 → 0.3.7

package/dist/config.d.ts

@@ -1,7 +1,8 @@
 export declare const walletConfig: Record<string, {
     base_url: string;
     token: string;
-    contractId: string;
+    accountContractId: string;
+    bridgeContractId: string;
     walletUrl: string;
 }>;
 export declare const nearRpcUrls: {

package/dist/core/btcUtils.d.ts

@@ -1,16 +1,35 @@
 export declare function getBtcGasPrice(): Promise<number>;
 export declare function getBtcBalance(): Promise<{
+    rawBalance: number;
+    balance: number;
+    maxSpendableBalance: number;
+    availableBalance?: undefined;
+} | {
     rawBalance: any;
     balance: number;
+    availableBalance: number;
+    maxSpendableBalance?: undefined;
 }>;
-export declare function sendBitcoin(address: string, amount: string, feeRate: number): Promise<string>;
-interface ExecuteBurrowSupplyParams {
-    /** btc amount, e.g. 0.01 */
-    amount: string;
+export declare function sendBitcoin(address: string, amount: number, feeRate: number): Promise<string>;
+export declare function estimateDepositAmount(amount: string, option?: {
+    isDev: boolean;
+}): Promise<string>;
+interface ExecuteBTCDepositAndActionParams {
+    action: {
+        receiver_id: string;
+        amount: string;
+        msg: string;
+    };
     /** fee rate, if not provided, will use the recommended fee rate from the btc node */
     feeRate?: number;
     /** is dev environment */
     isDev?: boolean;
 }
-export declare function executeBurrowSupply({ amount, feeRate, isDev, }: ExecuteBurrowSupplyParams): Promise<void>;
+export declare function executeBTCDepositAndAction({ action, feeRate, isDev, }: ExecuteBTCDepositAndActionParams): Promise<{
+    result: string;
+    error?: undefined;
+} | {
+    result: string;
+    error: any;
+}>;
 export {};

package/dist/core/btcWalletSelectorContext.d.ts

@@ -4,10 +4,10 @@ export declare function BtcWalletSelectorContextProvider({ children, }: {
     autoConnect?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function useBtcWalletSelector(): {
-    login: () => Promise<string | null>;
+    login: () => Promise<string>;
     autoConnect: () => Promise<void>;
     logout: () => void;
-    account: string | null;
+    account: string;
     getPublicKey: () => any;
     signMessage: (msg: string) => any;
     getContext: () => any;

package/dist/index.js

@@ -90,7 +90,8 @@ __export(src_exports, {
   UnisatConnector: () => UnisatConnector,
   WizzConnector: () => WizzConnector,
   XverseConnector: () => XverseConnector,
-  executeBurrowSupply: () => executeBurrowSupply,
+  estimateDepositAmount: () => estimateDepositAmount,
+  executeBTCDepositAndAction: () => executeBTCDepositAndAction,
   getBtcBalance: () => getBtcBalance,
   getBtcGasPrice: () => getBtcGasPrice,
   getVersion: () => getVersion,
@@ -2497,7 +2498,7 @@ function useBtcWalletSelector() {
         publicKey.current = res;
       });
     }
-  }, [provider]);
+  }, [getPublicKey, provider]);
   (0, import_react11.useEffect)(() => {
     signMessageFn.current = signMessage;
   }, [signMessage]);
@@ -2519,18 +2520,15 @@ function useBtcWalletSelector() {
         connector.removeListener("accountsChanged", fn);
       }
     };
-  }, [connector]);
+  }, [connector, context, getPublicKey]);
   const hook = (0, import_react11.useMemo)(() => {
     return {
       login: () => __async(this, null, function* () {
-        const account = accounts && accounts.length ? accounts[0] : null;
-        if (account) {
-          return account;
-        }
-        if (openConnectModal) {
-          yield openConnectModal();
+        const account = accounts == null ? void 0 : accounts[0];
+        if (!account) {
+          openConnectModal == null ? void 0 : openConnectModal();
         }
-        return null;
+        return account;
       }),
       autoConnect: () => __async(this, null, function* () {
         requestDirectAccount(connectorRef.current).catch((e) => {
@@ -2538,13 +2536,13 @@ function useBtcWalletSelector() {
         });
       }),
       logout: () => {
-        const accountId = accounts && accounts.length ? accounts[0] : null;
+        const accountId = accounts == null ? void 0 : accounts[0];
         if (!accountId)
           return;
         disconnect == null ? void 0 : disconnect();
         context.emit("btcLogOut");
       },
-      account: accounts && accounts.length ? accounts[0] : null,
+      account: accounts == null ? void 0 : accounts[0],
       getPublicKey: () => {
         return publicKey.current;
       },
@@ -2570,7 +2568,7 @@ function useBtcWalletSelector() {
 }
 
 // src/core/setupBTCWallet.ts
-var import_near_api_js = require("near-api-js");
+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");
@@ -2725,20 +2723,23 @@ function removeWalletButton() {
 var walletConfig = {
   dev: {
     base_url: "https://api.dev.satoshibridge.top",
-    token: "nbtc1-nsp.testnet",
-    contractId: "dev1-nsp.testnet",
+    token: "nbtc-dev.testnet",
+    accountContractId: "acc-dev.testnet",
+    bridgeContractId: "brg-dev.testnet",
     walletUrl: "https://wallet-dev.satoshibridge.top"
   },
   testnet: {
     base_url: "https://api.testnet.satoshibridge.top",
     token: "nbtc2-nsp.testnet",
-    contractId: "dev2-nsp.testnet",
+    accountContractId: "dev2-nsp.testnet",
+    bridgeContractId: "brg2-nsp.testnet",
     walletUrl: "https://wallet-test.satoshibridge.top"
   },
   mainnet: {
     base_url: "https://api.mainnet.satoshibridge.top",
     token: "",
-    contractId: "",
+    accountContractId: "",
+    bridgeContractId: "",
     walletUrl: "https://wallet.satoshibridge.top"
   }
 };
@@ -2750,8 +2751,8 @@ var nearRpcUrls = {
     "https://near.drpc.org"
   ],
   testnet: [
-    "https://near-testnet.lava.build",
     "https://rpc.testnet.near.org",
+    "https://near-testnet.lava.build",
     "https://near-testnet.drpc.org"
   ]
 };
@@ -2830,6 +2831,58 @@ function request(url, options) {
   });
 }
 
+// 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 = 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}`);
+        }
+        if (attempt === maxAttempts) {
+          throw new Error(`Transaction not found after max attempts: ${hash}`);
+        }
+        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;
+  });
+}
+
 // src/core/setupBTCWallet.ts
 var { transfer, functionCall } = import_transactions.actionCreators;
 var state = {
@@ -2927,28 +2980,23 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
       }
     }), 500);
   }
-  function viewMethod(_02) {
-    return __async(this, arguments, function* ({ method, args = {} }) {
-      const res = yield provider.query({
-        request_type: "call_function",
-        account_id: currentConfig.contractId,
-        method_name: method,
-        args_base64: Buffer.from(JSON.stringify(args)).toString("base64"),
-        finality: "optimistic"
-      });
-      return JSON.parse(Buffer.from(res.result).toString());
+  function nearCall2(contractId, methodName, args) {
+    return __async(this, null, function* () {
+      return nearCallFunction(contractId, methodName, args, { provider });
     });
   }
   function getNearAccountByBtcPublicKey(btcPublicKey) {
     return __async(this, null, function* () {
-      const nearTempAddress = yield viewMethod({
-        method: "get_chain_signature_near_account",
-        args: { btc_public_key: btcPublicKey }
-      });
-      const nearTempPublicKey = yield viewMethod({
-        method: "get_chain_signature_near_account_public_key",
-        args: { btc_public_key: btcPublicKey }
-      });
+      const nearTempAddress = yield nearCall2(
+        currentConfig.accountContractId,
+        "get_chain_signature_near_account_id",
+        { btc_public_key: btcPublicKey }
+      );
+      const nearTempPublicKey = yield nearCall2(
+        currentConfig.accountContractId,
+        "get_chain_signature_near_account_public_key",
+        { btc_public_key: btcPublicKey }
+      );
       state.saveAccount(nearTempAddress);
       state.savePublicKey(nearTempPublicKey);
       state.saveBtcPublicKey(btcPublicKey);
@@ -3048,11 +3096,14 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         nonce: BigInt(rawAccessKey.nonce || 0)
       });
       const publicKeyFormat = import_key_pair.PublicKey.from(publicKey);
-      const nearNonceApi = yield getNearNonceFromApi(currentConfig.base_url, accountId);
+      const { result_data: nearNonceFromApi } = yield getNearNonceFromApi(
+        currentConfig.base_url,
+        accountId
+      );
       const newTransactions = params.transactions.map((transaction, index) => {
         let nearNonceNumber = accessKey.nonce + BigInt(1);
-        if (nearNonceApi) {
-          nearNonceNumber = BigInt(nearNonceApi.result_data) > nearNonceNumber ? BigInt(nearNonceApi.result_data) : nearNonceNumber;
+        if (nearNonceFromApi) {
+          nearNonceNumber = BigInt(nearNonceFromApi) > nearNonceNumber ? BigInt(nearNonceFromApi) : nearNonceNumber;
         }
         const newActions = transaction.actions.map((action) => {
           switch (action.type) {
@@ -3067,7 +3118,7 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
               return transfer(BigInt(action.params.deposit));
           }
         }).filter(Boolean);
-        const _transaction = import_near_api_js.transactions.createTransaction(
+        const _transaction = import_near_api_js2.transactions.createTransaction(
           accountId,
           publicKeyFormat,
           transaction.receiverId,
@@ -3084,20 +3135,34 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         const hash = import_bs58.default.encode(new Uint8Array(import_js_sha256.sha256.array(txBytes)));
         return { txBytes, txHex, hash };
       });
-      const accountInfo = yield viewMethod({
-        method: "get_account",
-        args: { account_id: accountId }
-      });
-      const nonceApi = yield getNonceFromApi(currentConfig.base_url, accountId);
-      const nonce = Number(nonceApi == null ? void 0 : nonceApi.result_data) > Number(accountInfo.nonce) ? String(nonceApi == null ? void 0 : nonceApi.result_data) : String(accountInfo.nonce);
+      const accountInfo = yield nearCall2(
+        currentConfig.accountContractId,
+        "get_account",
+        { account_id: accountId }
+      );
+      const { result_data: nonceFromApi } = yield getNonceFromApi(
+        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),
         gas_token: currentConfig.token,
         gas_limit: "3000",
+        use_near_pay_gas: false,
         nonce
       };
+      const nearAccount = yield provider.query({
+        request_type: "view_account",
+        account_id: accountId,
+        finality: "final"
+      });
+      const availableBalance = parseFloat(nearAccount.amount) / __pow(10, 24);
+      if (availableBalance > 0.2) {
+        intention.use_near_pay_gas = true;
+      }
       const strIntention = JSON.stringify(intention);
       const signature = yield btcContext.signMessage(strIntention);
       const result = yield uploadBTCTx(currentConfig.base_url, {
@@ -3182,41 +3247,8 @@ function toHex(originalString) {
   hexString = hexString.replace(/(^0+)/g, "");
   return hexString;
 }
-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 = 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}`);
-        }
-        if (attempt === maxAttempts) {
-          throw new Error(`Transaction not found after max attempts: ${hash}`);
-        }
-        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;
-  });
-}
 
 // src/core/btcUtils.ts
-var import_near_api_js2 = require("near-api-js");
 var import_big = __toESM(require("big.js"), 1);
 function getBtcProvider() {
   if (typeof window === "undefined" || !window.btcContext) {
@@ -3237,55 +3269,45 @@ function getBtcRpcUrl() {
     return btcRpcUrls[network];
   });
 }
-function nearViewMethod(contractId, methodName, args) {
+function getConfig(isDev) {
   return __async(this, null, function* () {
     const network = yield getNetwork();
-    const nearProvider = new import_near_api_js2.providers.FailoverRpcProvider(
-      nearRpcUrls[network].map(
-        (url) => new import_near_api_js2.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: "optimistic"
-    });
-    return JSON.parse(Buffer.from(res.result).toString());
+    return walletConfig[isDev ? "dev" : network];
   });
 }
-function getDepositAddress(btcPublicKey, contractId) {
+function nearCall(contractId, methodName, args) {
   return __async(this, null, function* () {
-    const res = yield nearViewMethod(contractId, "get_user_dapp_deposit_address", {
-      deposit_type: {
-        BtcPublicKey: { btc_public_key: btcPublicKey, dapp_operation: "Burrowland->Supply" }
-      }
-    });
-    return res;
+    const network = yield getNetwork();
+    return nearCallFunction(contractId, methodName, args, { network });
   });
 }
 function receiveDepositMsg(_0, _1) {
   return __async(this, arguments, function* (baseUrl, {
     btcPublicKey,
     txHash,
-    depositType = 1
+    depositType = 1,
+    postActions,
+    extraMsg
   }) {
     const res = yield request(`${baseUrl}/v1/receiveDepositMsg`, {
       method: "POST",
-      body: { btcPublicKey, txHash, depositType }
+      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}`, {
-      timeout: 6e4,
-      pollingInterval: 5e3,
-      maxPollingAttempts: 10,
-      shouldStopPolling: (res2) => res2.result_code === 0
-    });
+    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;
   });
 }
@@ -3304,61 +3326,141 @@ function getBtcGasPrice() {
 }
 function getBtcBalance() {
   return __async(this, null, function* () {
-    var _a;
     const { account } = yield retryOperation(getBtcProvider, (res2) => !!res2.account);
     if (!account) {
       console.error("BTC Account is not available.");
-      return { rawBalance: 0, balance: 0 };
+      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 = (_a = res.filter((item) => {
-      var _a2;
-      return (_a2 = item == null ? void 0 : item.status) == null ? void 0 : _a2.confirmed;
-    })) == null ? void 0 : _a.reduce((acc, cur) => acc + cur.value, 0);
+    const rawBalance = res == null ? void 0 : res.reduce((acc, cur) => acc + cur.value, 0);
     const balance = rawBalance / __pow(10, 8);
-    return { rawBalance, balance };
+    const feeRate = yield getBtcGasPrice();
+    const maxGasFee = feeRate * 250 / __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 satoshis = new import_big.default(amount).mul(__pow(10, 8)).toNumber();
-    const txHash = yield sendBitcoin2(address, satoshis, { feeRate });
+    const txHash = yield sendBitcoin2(address, amount, { feeRate });
     return txHash;
   });
 }
-function executeBurrowSupply(_0) {
+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_big.default(amount).minus(fee).toFixed(0);
+  });
+}
+function executeBTCDepositAndAction(_0) {
   return __async(this, arguments, function* ({
-    amount,
+    action,
     feeRate,
     isDev = false
   }) {
     try {
       const { getPublicKey } = getBtcProvider();
-      const network = yield getNetwork();
-      const config = walletConfig[isDev ? "dev" : network];
+      const config = yield getConfig(isDev);
       const btcPublicKey = yield getPublicKey();
+      const _action = Object.assign(
+        {},
+        __spreadProps(__spreadValues({}, action), {
+          gas: new import_big.default(100).mul(__pow(10, 12)).toFixed(0)
+        })
+      );
       if (!btcPublicKey) {
         throw new Error("BTC Public Key is not available.");
       }
-      const address = yield getDepositAddress(btcPublicKey, config.contractId);
+      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_big.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.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_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("deposit msg:", depositMsg);
+      const userDepositAddress = yield nearCall(
+        config.bridgeContractId,
+        "get_user_deposit_address",
+        { deposit_msg: depositMsg }
+      );
       const _feeRate = feeRate || (yield getBtcGasPrice());
-      console.log("feeRate", _feeRate);
-      const txHash = yield sendBitcoin(address, amount, _feeRate);
-      const receiveDepositMsgRes = yield receiveDepositMsg(config.base_url, { btcPublicKey, txHash });
-      console.log("receiveDepositMsg resp:", receiveDepositMsgRes);
+      console.log("user deposit address:", userDepositAddress);
+      console.log("deposit amount:", new import_big.default(action.amount).toNumber());
+      console.log("receive amount:", new import_big.default(_action.amount).toNumber());
+      console.log("fee rate:", _feeRate);
+      const txHash = yield sendBitcoin(
+        userDepositAddress,
+        new import_big.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.5";
+  return "0.3.7";
 };
 if (typeof window !== "undefined") {
   window.__PARTICLE_BTC_CONNECT_VERSION = getVersion();