@0xsquid/react-hooks 8.3.1-beta-update-ethers.0 → 8.3.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(_: 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

@@ -11,5 +11,8 @@ export declare class UnisatConnector implements BitcoinConnector {
     requestAccount(): Promise<{
         address: string;
     }>;
+    signPsbt(_: 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-qAOvcSon.js → index-D9ejMike.js}

@@ -4752,6 +4752,9 @@ class KeplrConnector {
             address: account,
         };
     }
+    async signPsbt(_) {
+        throw new Error("Method not implemented.");
+    }
 }
 
 bitcoin__namespace.initEccLib(ecc__namespace);
@@ -4866,10 +4869,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();
@@ -4890,8 +4891,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 };
     }
 }
 
@@ -4920,6 +4923,9 @@ class UnisatConnector {
             address: account,
         };
     }
+    async signPsbt(_) {
+        throw new Error("Method not implemented.");
+    }
 }
 
 var XrplTransactionType;
@@ -22174,6 +22180,20 @@ function isChainflipBridgeTransaction(actions = []) {
     return actions.some((action) => action.type === squidTypes.ActionType.BRIDGE &&
         action.data?.type === squidTypes.BridgeType.CHAINFLIP);
 }
+/**
+ * Checks if a route is of type {@link OnChainExecutionData}
+ *
+ * On-chain routes require calling a smart contract to execute
+ */
+function isOnChainTxData(squidData) {
+    return [
+        squidTypes.SquidDataType.OnChainExecution,
+        squidTypes.SquidDataType.DepositAddressWithSignature,
+        squidTypes.SquidDataType.DepositAddressCalldata,
+        squidTypes.SquidDataType.DepositAddressWithSignature,
+        squidTypes.SquidDataType.DepositAddressWithMemo,
+    ].includes(squidData.type);
+}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case exports.HistoryTxType.SWAP:
@@ -23153,7 +23173,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-B_-XWo1F.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-0aEFG8v1.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26438,7 +26458,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');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-sRzC5VSD.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-BUoaW_gK.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27938,7 +27958,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-Cu_QQTg-.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-BWWDAnQe.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -35626,47 +35646,91 @@ const useExecuteTransaction = (squidRoute) => {
         },
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = 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, chainflipStatusTrackingId, } = 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: chainflipStatusTrackingId,
+                        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: chainflipStatusTrackingId,
-                    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 }) => {
@@ -36933,6 +36997,7 @@ exports.isHistoryTransactionEnded = isHistoryTransactionEnded;
 exports.isHistoryTransactionFailed = isHistoryTransactionFailed;
 exports.isHistoryTransactionPending = isHistoryTransactionPending;
 exports.isHistoryTransactionWarning = isHistoryTransactionWarning;
+exports.isOnChainTxData = isOnChainTxData;
 exports.isProblematicConnector = isProblematicConnector;
 exports.isSolanaAddressValid = isSolanaAddressValid;
 exports.isStatusError = isStatusError;
@@ -37048,4 +37113,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-qAOvcSon.js.map
+//# sourceMappingURL=index-D9ejMike.js.map