@0xsquid/react-hooks 8.10.0 → 8.10.1-beta-bitcoin-coralv2.0

package/dist/core/connectors/bitcoin/wallets/keplr.d.ts

@@ -8,4 +8,7 @@ export declare class KeplrConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }

package/dist/core/connectors/bitcoin/wallets/phantom.d.ts

@@ -22,6 +22,8 @@ export declare class PhantomConnector implements BitcoinConnector {
     sendBTC(to: string, amount: number): Promise<{
         txHash: string;
     }>;
-    private signPsbt;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }
 export {};

package/dist/core/connectors/bitcoin/wallets/unisat.d.ts

@@ -1,7 +1,19 @@
 import { BitcoinConnector } from "../../../../core/types/bitcoin";
+interface UnisatSignPsbtOptions {
+    autoFinalized?: boolean;
+    toSignInputs?: Array<{
+        index: number;
+        address?: string;
+        publicKey?: string;
+        sighashTypes?: number[];
+        disableTweakSigner?: boolean;
+    }>;
+}
 interface UnisatProvider {
     sendBitcoin: (to: string, amount: number) => Promise<string>;
     requestAccounts: () => Promise<string[]>;
+    signPsbt: (psbtHex: string, options?: UnisatSignPsbtOptions) => Promise<string>;
+    pushPsbt: (psbtHex: string) => Promise<string>;
 }
 export declare class UnisatConnector implements BitcoinConnector {
     get getProvider(): UnisatProvider;
@@ -11,5 +23,8 @@ export declare class UnisatConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
 }
 export {};

package/dist/core/types/bitcoin.d.ts

@@ -2,6 +2,9 @@ export interface BitcoinConnector {
     sendBTC(to: string, amount: number): Promise<{
         txHash: string;
     }>;
+    signPsbt(psbtHex: string): Promise<{
+        txHash: string;
+    }>;
     requestAccount(): Promise<{
         address: string;
     }>;

package/dist/{index-Dzir2lUQ.js → index-Cw1rn5LQ.js}

@@ -4764,6 +4764,25 @@ class KeplrConnector {
             address: account,
         };
     }
+    async signPsbt(psbtHex) {
+        // Keplr follows the UniSat-style Bitcoin provider API: `signPsbt` signs and,
+        // with `autoFinalized` (the default), finalizes every input, returning the
+        // signed PSBT as a hex string.
+        // https://docs.keplr.app/api/bitcoin
+        const signedPsbtHex = await this.getProvider.signPsbt(psbtHex, {
+            autoFinalized: true,
+        });
+        // Keplr only exposes `pushTx`, so extract the finalized raw transaction from
+        // the signed PSBT before broadcasting it.
+        const rawTxHex = bitcoin__namespace.Psbt.fromHex(signedPsbtHex)
+            .extractTransaction()
+            .toHex();
+        const txHash = await this.getProvider.pushTx(rawTxHex);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
 }
 
 bitcoin__namespace.initEccLib(ecc__namespace);
@@ -4878,10 +4897,8 @@ class PhantomConnector {
     async sendBTC(to, amount) {
         const { address } = await this.requestAccount();
         const { psbtHex } = await createSendBtcPsbt(address, to, amount);
-        const { txId } = await this.signPsbt(psbtHex);
-        if (!txId)
-            throw new BitcoinConnectorTransactionFailedError();
-        return { txHash: txId };
+        const { txHash } = await this.signPsbt(psbtHex);
+        return { txHash };
     }
     async signPsbt(psbtHex) {
         const { address: paymentAddress } = await this.requestAccount();
@@ -4902,8 +4919,10 @@ class PhantomConnector {
         const signedPsbt = bitcoin__namespace.Psbt.fromBuffer(signedPsbtBytes);
         signedPsbt.finalizeAllInputs();
         const tx = signedPsbt.extractTransaction();
-        const txId = await broadcastTx(tx.toHex());
-        return { txId };
+        const txHash = await broadcastTx(tx.toHex());
+        if (!txHash)
+            throw new BitcoinConnectorTransactionFailedError();
+        return { txHash };
     }
 }
 
@@ -4932,6 +4951,21 @@ class UnisatConnector {
             address: account,
         };
     }
+    async signPsbt(psbtHex) {
+        // UniSat signs and, with `autoFinalized` (the default), finalizes every
+        // input, returning the signed PSBT as a hex string.
+        // https://docs.unisat.io/dev/unisat-developer-center/unisat-wallet/api-list
+        const signedPsbtHex = await this.getProvider.signPsbt(psbtHex, {
+            autoFinalized: true,
+        });
+        // `pushPsbt` extracts the finalized transaction from the signed PSBT and
+        // broadcasts it, returning the transaction id.
+        const txHash = await this.getProvider.pushPsbt(signedPsbtHex);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
 }
 
 var XrplTransactionType;
@@ -23605,7 +23639,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-ICina23f.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-6H3XQVCV.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -27279,7 +27313,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-Bjc92sC_.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CElL9N4g.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30738,7 +30772,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-BPXYaraD.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DQyW9YL5.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -37465,47 +37499,91 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
-        if (!depositAddress) {
-            throw new Error(`Invalid deposit address: ${depositAddress}`);
-        }
-        if (!sendAmount) {
-            throw new Error(`Invalid send amount: ${sendAmount}`);
+        console.log("Validating route", {
+            bitcoinSigner,
+            route,
+        });
+        if (!bitcoinSigner || !route?.transactionRequest) {
+            throw new Error("Need all parameters");
         }
-        const allParamsValid = route && bitcoinSigner && depositAddress && sendAmount;
-        await changeNetworkIfNeeded.mutateAsync();
-        if (allParamsValid) {
-            dispatchSignatureRequestEvent(route);
-            const { txHash } = await bitcoinSigner.sendBTC(depositAddress, Number(sendAmount));
-            if (txHash) {
-                resetQueriesAfterTxSigned();
+        switch (route.transactionRequest.type) {
+            case squidTypes.SquidDataType.ChainflipDepositAddress: {
+                const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+                const allParamsValid = route && bitcoinSigner && depositAddress && sendAmount;
+                if (!allParamsValid) {
+                    throw new Error("Need all parameters");
+                }
+                await changeNetworkIfNeeded.mutateAsync();
+                dispatchSignatureRequestEvent(route);
+                const { txHash } = await bitcoinSigner.sendBTC(depositAddress, Number(sendAmount));
+                if (txHash) {
+                    resetQueriesAfterTxSigned();
+                }
+                // Dispatch event so it can be listened from outside the widget
+                WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+                if (route.transactionRequest) {
+                    const txParams = setTransactionState({
+                        route,
+                        txHash,
+                        // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
+                        // instead of the Bitcoin transaction hash
+                        transactionIdForStatus: statusTrackingId,
+                        userAddress: sourceUserAddress,
+                        status: exports.TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: exports.TransactionStatus.ONGOING,
+                        axelarUrl: undefined,
+                        id,
+                    });
+                    if (txParams) {
+                        addSwapTransaction({
+                            ...txParams,
+                            params: route.params,
+                            estimate: route.estimate,
+                        });
+                    }
+                }
+                break;
             }
-            // Dispatch event so it can be listened from outside the widget
-            WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-            if (route.transactionRequest) {
-                const txParams = setTransactionState({
-                    route,
-                    txHash,
-                    // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
-                    // instead of the Bitcoin transaction hash
-                    transactionIdForStatus: statusTrackingId,
-                    userAddress: sourceUserAddress,
-                    status: exports.TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: exports.TransactionStatus.ONGOING,
-                    axelarUrl: undefined,
-                    id,
-                });
-                if (txParams) {
-                    addSwapTransaction({
-                        ...txParams,
-                        params: route.params,
-                        estimate: route.estimate,
+            case squidTypes.SquidDataType.DepositAddressCalldata: {
+                console.log(`Route type: ${route.transactionRequest?.type}`);
+                if (!isOnChainTxData(route.transactionRequest)) {
+                    console.log("Invalid route data", route.transactionRequest);
+                    throw new Error("Invalid route data");
+                }
+                const { data: transactionHex } = route.transactionRequest;
+                await changeNetworkIfNeeded.mutateAsync();
+                dispatchSignatureRequestEvent(route);
+                console.log("Signing psbt", { transactionHex });
+                const { txHash } = await bitcoinSigner.signPsbt(transactionHex);
+                console.log("Signed psbt", { txHash });
+                if (txHash) {
+                    resetQueriesAfterTxSigned();
+                }
+                // Dispatch event so it can be listened from outside the widget
+                WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+                if (route.transactionRequest) {
+                    const txParams = setTransactionState({
+                        route,
+                        txHash,
+                        userAddress: sourceUserAddress,
+                        status: exports.TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: exports.TransactionStatus.ONGOING,
+                        axelarUrl: undefined,
+                        id,
                     });
+                    if (txParams) {
+                        addSwapTransaction({
+                            ...txParams,
+                            params: route.params,
+                            estimate: route.estimate,
+                        });
+                    }
                 }
+                break;
+            }
+            default: {
+                throw new Error(`Unhandled route type ${route.transactionRequest.type}`);
             }
-        }
-        else {
-            throw new Error("Need all parameters");
         }
     });
     const swapMutationXrpl = reactQuery.useMutation(async ({ id, route }) => {
@@ -38932,4 +39010,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-Dzir2lUQ.js.map
+//# sourceMappingURL=index-Cw1rn5LQ.js.map