btc-wallet 0.3.4 → 0.3.6

package/dist/utils/index.d.ts

@@ -5,3 +5,7 @@ export declare const defaultTokenIcon = "https://static.particle.network/token-l
 export declare const ipfsToSrc: (ipfs: string) => string;
 export declare const checkBTCVersion: (accountContracts: AAOptions["accountContracts"], accountContractKey: string, version: string) => boolean;
 export declare const delay: (ms: number) => Promise<unknown>;
+export declare function retryOperation<T>(operation: () => Promise<T> | T, shouldStop: (result: T) => boolean, { maxRetries, delayMs, }?: {
+    maxRetries?: number;
+    delayMs?: number;
+}): Promise<T>;

package/dist/utils/nearUtils.d.ts

@@ -0,0 +1,7 @@
+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)[]>;

package/esm/index.js

@@ -470,7 +470,7 @@ var _network2, _event2;
 var MagicEdenConnector = class extends BaseConnector {
   constructor() {
     super();
-    __privateAdd(this, _network2, "Testnet");
+    __privateAdd(this, _network2, "Mainnet");
     __privateAdd(this, _event2, new EventEmitter2());
     this.metadata = {
       id: "magicEden",
@@ -1309,6 +1309,27 @@ var checkBTCVersion = (accountContracts, accountContractKey, version) => {
   return accountContracts[accountContractKey].some((item) => item.version === version);
 };
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function retryOperation(_0, _1) {
+  return __async(this, arguments, function* (operation, shouldStop, {
+    maxRetries = 3,
+    delayMs = 1e3
+  } = {}) {
+    let retries = 0;
+    while (retries <= maxRetries) {
+      const result = yield operation();
+      if (shouldStop(result)) {
+        return result;
+      }
+      if (retries === maxRetries) {
+        console.warn("Max retries reached");
+        return result;
+      }
+      retries++;
+      yield delay(delayMs);
+    }
+    throw new Error("Unexpected execution path");
+  });
+}
 
 // src/utils/ethereumUtils.ts
 import {
@@ -2437,7 +2458,7 @@ function useBtcWalletSelector() {
         publicKey.current = res;
       });
     }
-  }, [provider]);
+  }, [getPublicKey, provider]);
   useEffect6(() => {
     signMessageFn.current = signMessage;
   }, [signMessage]);
@@ -2459,18 +2480,15 @@ function useBtcWalletSelector() {
         connector.removeListener("accountsChanged", fn);
       }
     };
-  }, [connector]);
+  }, [connector, context, getPublicKey]);
   const hook = useMemo6(() => {
     return {
       login: () => __async(this, null, function* () {
-        const account = accounts && accounts.length ? accounts[0] : null;
-        if (account) {
-          return account;
+        const account = accounts == null ? void 0 : accounts[0];
+        if (!account) {
+          openConnectModal == null ? void 0 : openConnectModal();
         }
-        if (openConnectModal) {
-          yield openConnectModal();
-        }
-        return null;
+        return account;
       }),
       autoConnect: () => __async(this, null, function* () {
         requestDirectAccount(connectorRef.current).catch((e) => {
@@ -2478,13 +2496,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;
       },
@@ -2510,7 +2528,7 @@ function useBtcWalletSelector() {
 }
 
 // src/core/setupBTCWallet.ts
-import { providers, transactions } from "near-api-js";
+import { transactions } from "near-api-js";
 import { actionCreators } from "@near-js/transactions";
 import { PublicKey } from "near-api-js/lib/utils/key_pair";
 import { encodeTransaction } from "near-api-js/lib/transaction";
@@ -2665,20 +2683,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"
   }
 };
@@ -2690,8 +2711,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"
   ]
 };
@@ -2729,7 +2750,7 @@ function request(url, options) {
       body,
       method
     });
-    const retryCount2 = (_a = options == null ? void 0 : options.retryCount) != null ? _a : 1;
+    const retryCount = (_a = options == null ? void 0 : options.retryCount) != null ? _a : 1;
     const controller = new AbortController();
     const timeout = (options == null ? void 0 : options.timeout) || 2e4;
     const timeoutId = setTimeout(() => controller.abort(), timeout);
@@ -2752,16 +2773,16 @@ function request(url, options) {
       return data;
     } catch (err) {
       console.error(err);
-      if (retryCount2 > 0) {
-        console.log(`Retrying... attempts left: ${retryCount2}`);
-        return request(url, __spreadProps(__spreadValues({}, options), { retryCount: retryCount2 - 1 }));
+      if (retryCount > 0) {
+        console.log(`Retrying... attempts left: ${retryCount}`);
+        return request(url, __spreadProps(__spreadValues({}, options), { retryCount: retryCount - 1 }));
       } else if ((options == null ? void 0 : options.pollingInterval) && (options == null ? void 0 : options.maxPollingAttempts)) {
         if (options.maxPollingAttempts > 0) {
           console.log(`Polling... attempts left: ${options.maxPollingAttempts}`);
           yield new Promise((resolve) => setTimeout(resolve, options.pollingInterval));
           return request(url, __spreadProps(__spreadValues({}, options), {
             maxPollingAttempts: options.maxPollingAttempts - 1,
-            retryCount: retryCount2
+            retryCount
           }));
         }
       }
@@ -2770,6 +2791,58 @@ function request(url, options) {
   });
 }
 
+// src/utils/nearUtils.ts
+import { providers } from "near-api-js";
+function nearCallFunction(contractId, methodName, args, options) {
+  return __async(this, null, function* () {
+    const nearProvider = (options == null ? void 0 : options.provider) || new providers.FailoverRpcProvider(
+      nearRpcUrls[options == null ? void 0 : options.network].map(
+        (url) => new 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 providers.FailoverRpcProvider(
+      Object.values(nearRpcUrls[network]).map(
+        (url) => new 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 } = actionCreators;
 var state = {
@@ -2867,28 +2940,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);
@@ -2912,8 +2980,15 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
           }
         ];
       }
-      const btcAccount = yield btcContext.login();
-      const btcPublicKey = yield btcContext.getPublicKey();
+      yield btcContext.login();
+      const btcPublicKey = yield retryOperation(btcContext.getPublicKey, (res) => !!res, {
+        maxRetries: 40,
+        delayMs: 3e3
+      });
+      console.log("btcPublicKey:", btcPublicKey);
+      if (!btcPublicKey) {
+        throw new Error("No connected BTC wallet, please connect your BTC wallet first.");
+      }
       const { nearTempAddress, nearTempPublicKey } = yield getNearAccountByBtcPublicKey(btcPublicKey);
       return [
         {
@@ -2981,11 +3056,14 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         nonce: BigInt(rawAccessKey.nonce || 0)
       });
       const publicKeyFormat = 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) {
@@ -3017,20 +3095,34 @@ var BTCWallet = (_0) => __async(void 0, [_0], function* ({
         const hash = bs58.encode(new Uint8Array(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, {
@@ -3115,41 +3207,8 @@ function toHex(originalString) {
   hexString = hexString.replace(/(^0+)/g, "");
   return hexString;
 }
-function pollTransactionStatuses(network, hashes) {
-  return __async(this, null, function* () {
-    const provider = new providers.FailoverRpcProvider(
-      Object.values(nearRpcUrls[network]).map(
-        (url) => new 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
-import { providers as providers2 } from "near-api-js";
 import Big from "big.js";
 function getBtcProvider() {
   if (typeof window === "undefined" || !window.btcContext) {
@@ -3170,55 +3229,39 @@ function getBtcRpcUrl() {
     return btcRpcUrls[network];
   });
 }
-function nearViewMethod(contractId, methodName, args) {
+function nearCall(contractId, methodName, args) {
   return __async(this, null, function* () {
     const network = yield getNetwork();
-    const nearProvider = new providers2.FailoverRpcProvider(
-      nearRpcUrls[network].map(
-        (url) => new providers2.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());
-  });
-}
-function getDepositAddress(btcPublicKey, contractId) {
-  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;
+    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;
   });
 }
@@ -3235,38 +3278,30 @@ function getBtcGasPrice() {
     }
   });
 }
-var retryCount = 0;
 function getBtcBalance() {
   return __async(this, null, function* () {
-    const { account } = getBtcProvider();
+    const { account } = yield retryOperation(getBtcProvider, (res2) => !!res2.account);
     if (!account) {
-      retryCount++;
-      if (retryCount > 3) {
-        throw new Error("BTC Account is not available.");
-      }
-      yield delay(1e3);
-      return getBtcBalance();
+      console.error("BTC Account is not available.");
+      return { rawBalance: 0, balance: 0 };
     }
-    retryCount = 0;
     const btcRpcUrl = yield getBtcRpcUrl();
     const res = yield fetch(`${btcRpcUrl}/address/${account}/utxo`).then((res2) => res2.json());
-    const rawBalance = res.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);
-    console.log("btc balance:", balance);
     return { rawBalance, balance };
   });
 }
 function sendBitcoin(address, amount, feeRate) {
   return __async(this, null, function* () {
     const { sendBitcoin: sendBitcoin2 } = getBtcProvider();
-    const satoshis = new Big(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 executeBTCDepositAndAction(_0) {
   return __async(this, arguments, function* ({
-    amount,
+    action,
     feeRate,
     isDev = false
   }) {
@@ -3275,26 +3310,75 @@ function executeBurrowSupply(_0) {
       const network = yield getNetwork();
       const config = walletConfig[isDev ? "dev" : network];
       const btcPublicKey = yield getPublicKey();
+      const _action = Object.assign({}, action);
       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");
+      }
+      if (!_action.amount || !new Big(_action.amount || 0).gt(0)) {
+        throw new Error("action.amount is required and must be greater than 0");
+      }
+      const csna = yield nearCall(
+        config.accountContractId,
+        "get_chain_signature_near_account_id",
+        {
+          btc_public_key: btcPublicKey
+        }
+      );
+      _action.amount = new Big(_action.amount).toString();
+      _action.gas = new Big(100).mul(__pow(10, 12)).toFixed(0);
+      const depositMsg = {
+        recipient_id: csna,
+        post_actions: [_action]
+      };
+      const registerRes = yield nearCall(action.receiver_id, "storage_balance_of", {
+        account_id: csna
+      });
+      if (!(registerRes == null ? void 0 : registerRes.available)) {
+        const storageDepositMsg = {
+          storage_deposit_msg: {
+            contract_id: action.receiver_id,
+            deposit: new Big(0.25).mul(__pow(10, 24)).toFixed(0),
+            registration_only: true
+          },
+          btc_public_key: btcPublicKey
+        };
+        depositMsg.extra_msg = JSON.stringify(storageDepositMsg);
+      }
+      console.log("depositMsg", depositMsg);
+      const userDepositAddress = yield nearCall(
+        config.bridgeContractId,
+        "get_user_deposit_address",
+        { deposit_msg: depositMsg }
+      );
+      console.log("userDepositAddress", userDepositAddress);
       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);
+      const txHash = yield sendBitcoin(
+        userDepositAddress,
+        new Big(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.4";
+  return "0.3.6";
 };
 if (typeof window !== "undefined") {
   window.__PARTICLE_BTC_CONNECT_VERSION = getVersion();
@@ -3312,7 +3396,7 @@ export {
   UnisatConnector,
   WizzConnector,
   XverseConnector,
-  executeBurrowSupply,
+  executeBTCDepositAndAction,
   getBtcBalance,
   getBtcGasPrice,
   getVersion,