@0xsquid/react-hooks 8.9.0 → 8.9.1-beta.0

package/dist/{index-DcBFug8t.js → index-sCLxPcqi.js}

@@ -5,6 +5,7 @@ var viem = require('viem');
 var React = require('react');
 var reactQuery = require('@tanstack/react-query');
 var encoding = require('@cosmjs/encoding');
+var core$1 = require('@wallet-standard/core');
 var bitcoin = require('bitcoinjs-lib');
 var ecc = require('@bitcoinerlab/secp256k1');
 var axios = require('axios');
@@ -25,7 +26,6 @@ var zustand = require('zustand');
 var middleware = require('zustand/middleware');
 var wagmi = require('wagmi');
 var SafeAppsSDK = require('@safe-global/safe-apps-sdk');
-var core$1 = require('@wallet-standard/core');
 var slushWallet = require('@mysten/slush-wallet');
 var stargate = require('@cosmjs/stargate');
 var client = require('@mysten/sui/client');
@@ -4730,6 +4730,11 @@ class BitcoinConnectorInvalidAccountError extends BitcoinConnectorError {
         super("Bitcoin account is invalid");
     }
 }
+class BitcoinConnectorFeatureNotSupportedError extends BitcoinConnectorError {
+    constructor(providerName, feature) {
+        super(`Bitcoin provider ${providerName} does not support ${feature}`);
+    }
+}
 
 class KeplrConnector {
     get getProvider() {
@@ -4758,6 +4763,20 @@ class KeplrConnector {
     }
 }
 
+const BitcoinConnect = "bitcoin:connect";
+const BitcoinSignTransaction = "bitcoin:signTransaction";
+const REQUIRED_BITCOIN_FEATURES = [
+    BitcoinConnect,
+    BitcoinSignTransaction,
+];
+/**
+ * Type guard: the wallet exposes the Bitcoin features this SDK needs (connect +
+ * signTransaction). Wallets advertising only a subset are treated as unsupported.
+ */
+function hasBitcoinFeatures(wallet) {
+    return REQUIRED_BITCOIN_FEATURES.every((feature) => feature in wallet.features);
+}
+
 bitcoin__namespace.initEccLib(ecc__namespace);
 const network = bitcoin__namespace.networks.bitcoin;
 const fromHexString = (hexString) => {
@@ -4847,55 +4866,100 @@ async function getTransactionStatus$1(txHash) {
 }
 
 const MAINNET = bitcoin__namespace.networks.bitcoin;
-class PhantomConnector {
-    get getProvider() {
-        const provider = window?.phantom?.bitcoin;
-        if (!provider) {
-            throw new BitcoinConnectorProviderNotFoundError("Phantom");
+/**
+ * Bitcoin connector backed by the Bitcoin Wallet Standard.
+ *
+ * Discovers the wallet from the Wallet Standard registry at call time (mirroring
+ * how Solana/Sui wallets are resolved) and connects/signs through the
+ * `bitcoin:connect` and `bitcoin:signTransaction` features instead of a
+ * wallet-specific injected provider. Configure it with a `walletName` to support
+ * any wallet exposing the Bitcoin Wallet Standard — Phantom is the first consumer.
+ */
+class BitcoinStandardConnector {
+    walletName;
+    constructor({ walletName }) {
+        this.walletName = walletName;
+    }
+    getWallet() {
+        const wallet = core$1.getWallets()
+            .get()
+            .find((candidate) => candidate.name.toLowerCase() === this.walletName.toLowerCase());
+        if (!wallet) {
+            throw new BitcoinConnectorProviderNotFoundError(this.walletName);
         }
-        return provider;
+        const bitcoinWallet = wallet;
+        if (!hasBitcoinFeatures(bitcoinWallet)) {
+            throw new BitcoinConnectorFeatureNotSupportedError(this.walletName, "Bitcoin Wallet Standard");
+        }
+        return bitcoinWallet;
     }
-    async requestAccount() {
-        const phantomAccounts = await this.getProvider.requestAccounts();
-        if (!phantomAccounts)
-            throw new BitcoinConnectorInvalidAccountError();
-        const paymentAccount = phantomAccounts.find((account) => account.purpose === "payment");
-        if (typeof paymentAccount?.address !== "string") {
+    async connectAccount(purpose) {
+        const wallet = this.getWallet();
+        const connect = wallet.features[BitcoinConnect]?.connect;
+        if (!connect) {
+            throw new BitcoinConnectorFeatureNotSupportedError(this.walletName, BitcoinConnect);
+        }
+        const { accounts } = await connect({ purposes: [purpose] });
+        // `purpose` is a user preference, not a guarantee (per Phantom's docs), but
+        // requesting a single purpose returns the matching account first.
+        const account = accounts[0];
+        if (typeof account?.address !== "string") {
             throw new BitcoinConnectorInvalidAccountError();
         }
+        return account;
+    }
+    async requestAccount() {
+        const account = await this.connectAccount("payment");
         return {
-            address: paymentAccount.address,
+            address: account.address,
         };
     }
     async sendBTC(to, amount) {
-        const { address } = await this.requestAccount();
-        const { psbtHex } = await createSendBtcPsbt(address, to, amount);
-        const { txId } = await this.signPsbt(psbtHex);
+        const account = await this.connectAccount("payment");
+        const { psbtHex } = await createSendBtcPsbt(account.address, to, amount);
+        const txId = await this.signAndBroadcast(psbtHex, account);
         if (!txId)
             throw new BitcoinConnectorTransactionFailedError();
         return { txHash: txId };
     }
-    async signPsbt(psbtHex) {
-        const { address: paymentAddress } = await this.requestAccount();
-        const toSignPsbt = bitcoin__namespace.Psbt.fromHex(String(psbtHex), {
-            network: MAINNET,
-        });
-        const inputs = toSignPsbt.data.inputs;
-        const inputsToSign = [
-            {
-                // Need to sign each input with the payment address
-                address: paymentAddress,
-                signingIndexes: inputs.map((_, index) => index),
-            },
-        ];
-        const signedPsbtBytes = await this.getProvider.signPSBT(fromHexString(psbtHex), {
-            inputsToSign,
+    async signAndBroadcast(psbtHex, account) {
+        const wallet = this.getWallet();
+        const signTransaction = wallet.features[BitcoinSignTransaction]?.signTransaction;
+        if (!signTransaction) {
+            throw new BitcoinConnectorFeatureNotSupportedError(this.walletName, BitcoinSignTransaction);
+        }
+        const unsignedPsbt = bitcoin__namespace.Psbt.fromHex(psbtHex, { network: MAINNET });
+        const signingIndexes = unsignedPsbt.data.inputs.map((_, index) => index);
+        const [result] = await signTransaction({
+            psbt: fromHexString(psbtHex),
+            inputsToSign: [
+                {
+                    // All inputs are funded from the payment account.
+                    account,
+                    signingIndexes,
+                },
+            ],
         });
-        const signedPsbt = bitcoin__namespace.Psbt.fromBuffer(signedPsbtBytes);
+        if (!result?.signedPsbt) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        const signedPsbt = bitcoin__namespace.Psbt.fromBuffer(result.signedPsbt);
         signedPsbt.finalizeAllInputs();
         const tx = signedPsbt.extractTransaction();
-        const txId = await broadcastTx(tx.toHex());
-        return { txId };
+        return broadcastTx(tx.toHex());
+    }
+}
+
+/**
+ * Phantom Bitcoin connector via the Bitcoin Wallet Standard.
+ *
+ * Phantom deprecated the injected `window.phantom.bitcoin` provider in favour of
+ * the Wallet Standard; this resolves Phantom from the registry by name and signs
+ * through the standard Bitcoin features. See {@link BitcoinStandardConnector}.
+ */
+class PhantomConnector extends BitcoinStandardConnector {
+    constructor() {
+        super({ walletName: "Phantom" });
     }
 }
 
@@ -23368,7 +23432,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-B1SDXLS1.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-C3jMjsK0.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26766,7 +26830,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-C4TLBEpm.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-SrhXgRGB.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30098,7 +30162,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-1XEAWjab.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-B2QD8f3q.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -37761,4 +37825,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-DcBFug8t.js.map
+//# sourceMappingURL=index-sCLxPcqi.js.map