@dynamic-labs/bitcoin 4.52.4 → 4.53.0

package/src/utils/btcToSatoshis/btcToSatoshis.js

@@ -0,0 +1,20 @@
+'use client'
+import { DynamicError } from '@dynamic-labs/utils';
+import { SATOSHIS_PER_BTC } from '../../const.js';
+
+/**
+ * Helper function to convert BTC amount to satoshis
+ * @param btcAmount - The Bitcoin amount to convert (number)
+ * @returns The amount in satoshis as a BigInt
+ * @throws {DynamicError} If the amount is negative
+ */
+const btcToSatoshis = (btcAmount) => {
+    if (btcAmount < 0) {
+        throw new DynamicError('BTC amount cannot be negative');
+    }
+    // Convert to satoshis and return as BigInt
+    const satoshis = Math.floor(btcAmount * SATOSHIS_PER_BTC);
+    return BigInt(satoshis);
+};
+
+export { btcToSatoshis };

package/src/utils/btcToSatoshis/index.d.ts

@@ -0,0 +1 @@
+export { btcToSatoshis } from './btcToSatoshis';

package/src/utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.cjs

@@ -14,6 +14,7 @@ var _const = require('../../const.cjs');
 require('bitcoinjs-lib');
 var BitcoinSatsConnectConnector = require('../../connectors/BitcoinSatsConnectConnector/BitcoinSatsConnectConnector.cjs');
 require('jsontokens');
+require('../../connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.cjs');
 
 const fetchSatsConnectConnectors = ({ walletBook, }) => {
     var _a;

package/src/utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.js

@@ -10,6 +10,7 @@ import { SATSCONNECT_FEATURE } from '../../const.js';
 import 'bitcoinjs-lib';
 import { BitcoinSatsConnectConnector } from '../../connectors/BitcoinSatsConnectConnector/BitcoinSatsConnectConnector.js';
 import 'jsontokens';
+import '../../connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js';
 
 const fetchSatsConnectConnectors = ({ walletBook, }) => {
     var _a;

package/src/utils/getBitcoinNetwork/getBitcoinNetwork.cjs

@@ -0,0 +1,15 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bitcoinjsLib = require('bitcoinjs-lib');
+
+/**
+ * Gets the Bitcoin network based on address prefix
+ * @param accountAddress - The Bitcoin address
+ * @returns The Bitcoin network (mainnet or testnet)
+ */
+const getBitcoinNetwork = (accountAddress) => accountAddress.startsWith('t') ? bitcoinjsLib.networks.testnet : bitcoinjsLib.networks.bitcoin;
+
+exports.getBitcoinNetwork = getBitcoinNetwork;

package/src/utils/getBitcoinNetwork/getBitcoinNetwork.d.ts

@@ -0,0 +1,7 @@
+import { type Network } from 'bitcoinjs-lib';
+/**
+ * Gets the Bitcoin network based on address prefix
+ * @param accountAddress - The Bitcoin address
+ * @returns The Bitcoin network (mainnet or testnet)
+ */
+export declare const getBitcoinNetwork: (accountAddress: string) => Network;

package/src/utils/getBitcoinNetwork/getBitcoinNetwork.js

@@ -0,0 +1,11 @@
+'use client'
+import { networks } from 'bitcoinjs-lib';
+
+/**
+ * Gets the Bitcoin network based on address prefix
+ * @param accountAddress - The Bitcoin address
+ * @returns The Bitcoin network (mainnet or testnet)
+ */
+const getBitcoinNetwork = (accountAddress) => accountAddress.startsWith('t') ? networks.testnet : networks.bitcoin;
+
+export { getBitcoinNetwork };

package/src/utils/getBitcoinNetwork/index.d.ts

@@ -0,0 +1 @@
+export { getBitcoinNetwork } from './getBitcoinNetwork';

package/src/utils/index.d.ts

@@ -4,3 +4,6 @@ export { hasSatsConnectFeature } from './hasSatsConnectFeature';
 export { getMempoolApiUrl } from './getMempoolApiUrl';
 export { createPsbtOptions } from './psbt/createSignPsbtOptions';
 export { satoshisToBtc } from './satoshisToBtc';
+export { btcToSatoshis } from './btcToSatoshis';
+export { getBitcoinNetwork } from './getBitcoinNetwork';
+export { PsbtParser } from './psbtParser';

package/src/utils/psbtParser/PsbtParser.cjs

@@ -0,0 +1,185 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bitcoinjsLib = require('bitcoinjs-lib');
+
+/**
+ * Utility class for parsing PSBTs and finalized Bitcoin transactions
+ */
+class PsbtParser {
+    /**
+     * Parse a PSBT or finalized transaction and extract transaction information
+     * Auto-detects format (hex/base64) and type (PSBT/finalized transaction)
+     * @param psbtInput - The PSBT or finalized transaction in Base64 or hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parsePsbt(psbtInput) {
+        const isHex = /^[0-9a-fA-F]+$/.test(psbtInput) && psbtInput.length > 100;
+        if (isHex) {
+            return PsbtParser.parseHexPsbt(psbtInput);
+        }
+        else {
+            return PsbtParser.parseBase64Psbt(psbtInput);
+        }
+    }
+    /**
+     * Parse a PSBT or finalized transaction from hex format
+     * @param psbtHex - The PSBT or finalized transaction in hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseHexPsbt(psbtHex) {
+        try {
+            try {
+                const psbt = bitcoinjsLib.Psbt.fromHex(psbtHex, { network: bitcoinjsLib.networks.bitcoin });
+                return PsbtParser.extractPsbtData(psbt);
+            }
+            catch (psbtError) {
+                return PsbtParser.parseFinalizedTransactionHex(psbtHex);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse hex PSBT: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Parse a PSBT or finalized transaction from base64 format
+     * @param psbtBase64 - The PSBT or finalized transaction in base64 format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseBase64Psbt(psbtBase64) {
+        try {
+            try {
+                const psbt = bitcoinjsLib.Psbt.fromBase64(psbtBase64, { network: bitcoinjsLib.networks.bitcoin });
+                return PsbtParser.extractPsbtData(psbt);
+            }
+            catch (psbtError) {
+                return PsbtParser.parseFinalizedTransactionBase64(psbtBase64);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse base64 PSBT: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Extract transaction data from a PSBT
+     * Shared logic used by both parseHexPsbt and parseBase64Psbt
+     * @param psbt - The parsed PSBT object
+     * @returns Parsed transaction data with inputs and outputs
+     */
+    static extractPsbtData(psbt) {
+        const inputs = [];
+        const outputs = [];
+        psbt.txInputs.forEach((txInput, index) => {
+            const input = psbt.data.inputs[index];
+            const inputData = {
+                txid: txInput.hash.reverse().toString('hex'),
+                vout: txInput.index,
+            };
+            if (input.witnessUtxo) {
+                inputData.value = input.witnessUtxo.value;
+                try {
+                    inputData.address = bitcoinjsLib.address.fromOutputScript(input.witnessUtxo.script, bitcoinjsLib.networks.bitcoin);
+                }
+                catch (e) {
+                    // Address extraction failed
+                }
+            }
+            else if (input.nonWitnessUtxo) {
+                try {
+                    const prevTx = bitcoinjsLib.Transaction.fromBuffer(input.nonWitnessUtxo);
+                    const prevOut = prevTx.outs[txInput.index];
+                    inputData.value = prevOut.value;
+                    try {
+                        inputData.address = bitcoinjsLib.address.fromOutputScript(prevOut.script, bitcoinjsLib.networks.bitcoin);
+                    }
+                    catch (e) {
+                        // Address extraction failed
+                    }
+                }
+                catch (e) {
+                    // Transaction parsing failed
+                }
+            }
+            inputs.push(inputData);
+        });
+        PsbtParser.extractOutputs(psbt.txOutputs, outputs);
+        return { inputs, outputs };
+    }
+    /**
+     * Extract outputs from transaction outputs
+     * Shared logic used by both PSBT and finalized transaction parsing
+     * @param txOutputs - Array of transaction outputs (from PSBT or Transaction)
+     * @param outputs - Array to populate with parsed output data
+     */
+    static extractOutputs(txOutputs, outputs) {
+        txOutputs.forEach((txOutput) => {
+            const outputData = {
+                value: txOutput.value,
+            };
+            try {
+                outputData.address = bitcoinjsLib.address.fromOutputScript(txOutput.script, bitcoinjsLib.networks.bitcoin);
+            }
+            catch (e) {
+                // Address extraction failed - continue without address
+            }
+            outputs.push(outputData);
+        });
+    }
+    /**
+     * Parse a finalized Bitcoin transaction from hex format
+     * @param txHex - The transaction in hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseFinalizedTransactionHex(txHex) {
+        try {
+            const tx = bitcoinjsLib.Transaction.fromHex(txHex);
+            return PsbtParser.extractTransactionData(tx);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse finalized transaction hex: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Parse a finalized Bitcoin transaction from base64 format
+     * @param txBase64 - The transaction in base64 format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseFinalizedTransactionBase64(txBase64) {
+        try {
+            const buffer = Buffer.from(txBase64, 'base64');
+            const tx = bitcoinjsLib.Transaction.fromBuffer(buffer);
+            return PsbtParser.extractTransactionData(tx);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse finalized transaction base64: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Extract transaction data from a finalized Transaction
+     * Shared logic used by both parseFinalizedTransactionHex and parseFinalizedTransactionBase64
+     * @param tx - The parsed Transaction object
+     * @returns Parsed transaction data with inputs and outputs
+     */
+    static extractTransactionData(tx) {
+        const inputs = [];
+        const outputs = [];
+        tx.ins.forEach((input) => {
+            const inputData = {
+                txid: input.hash.reverse().toString('hex'),
+                vout: input.index,
+            };
+            inputs.push(inputData);
+        });
+        PsbtParser.extractOutputs(tx.outs, outputs);
+        return { inputs, outputs };
+    }
+}
+
+exports.PsbtParser = PsbtParser;

package/src/utils/psbtParser/PsbtParser.d.ts

@@ -0,0 +1,63 @@
+import type { ParsedTransaction } from '../../types';
+/**
+ * Utility class for parsing PSBTs and finalized Bitcoin transactions
+ */
+export declare class PsbtParser {
+    /**
+     * Parse a PSBT or finalized transaction and extract transaction information
+     * Auto-detects format (hex/base64) and type (PSBT/finalized transaction)
+     * @param psbtInput - The PSBT or finalized transaction in Base64 or hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parsePsbt(psbtInput: string): ParsedTransaction;
+    /**
+     * Parse a PSBT or finalized transaction from hex format
+     * @param psbtHex - The PSBT or finalized transaction in hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseHexPsbt(psbtHex: string): ParsedTransaction;
+    /**
+     * Parse a PSBT or finalized transaction from base64 format
+     * @param psbtBase64 - The PSBT or finalized transaction in base64 format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseBase64Psbt(psbtBase64: string): ParsedTransaction;
+    /**
+     * Extract transaction data from a PSBT
+     * Shared logic used by both parseHexPsbt and parseBase64Psbt
+     * @param psbt - The parsed PSBT object
+     * @returns Parsed transaction data with inputs and outputs
+     */
+    private static extractPsbtData;
+    /**
+     * Extract outputs from transaction outputs
+     * Shared logic used by both PSBT and finalized transaction parsing
+     * @param txOutputs - Array of transaction outputs (from PSBT or Transaction)
+     * @param outputs - Array to populate with parsed output data
+     */
+    private static extractOutputs;
+    /**
+     * Parse a finalized Bitcoin transaction from hex format
+     * @param txHex - The transaction in hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    private static parseFinalizedTransactionHex;
+    /**
+     * Parse a finalized Bitcoin transaction from base64 format
+     * @param txBase64 - The transaction in base64 format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    private static parseFinalizedTransactionBase64;
+    /**
+     * Extract transaction data from a finalized Transaction
+     * Shared logic used by both parseFinalizedTransactionHex and parseFinalizedTransactionBase64
+     * @param tx - The parsed Transaction object
+     * @returns Parsed transaction data with inputs and outputs
+     */
+    private static extractTransactionData;
+}

package/src/utils/psbtParser/PsbtParser.js

@@ -0,0 +1,181 @@
+'use client'
+import { Psbt, networks, address, Transaction } from 'bitcoinjs-lib';
+
+/**
+ * Utility class for parsing PSBTs and finalized Bitcoin transactions
+ */
+class PsbtParser {
+    /**
+     * Parse a PSBT or finalized transaction and extract transaction information
+     * Auto-detects format (hex/base64) and type (PSBT/finalized transaction)
+     * @param psbtInput - The PSBT or finalized transaction in Base64 or hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parsePsbt(psbtInput) {
+        const isHex = /^[0-9a-fA-F]+$/.test(psbtInput) && psbtInput.length > 100;
+        if (isHex) {
+            return PsbtParser.parseHexPsbt(psbtInput);
+        }
+        else {
+            return PsbtParser.parseBase64Psbt(psbtInput);
+        }
+    }
+    /**
+     * Parse a PSBT or finalized transaction from hex format
+     * @param psbtHex - The PSBT or finalized transaction in hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseHexPsbt(psbtHex) {
+        try {
+            try {
+                const psbt = Psbt.fromHex(psbtHex, { network: networks.bitcoin });
+                return PsbtParser.extractPsbtData(psbt);
+            }
+            catch (psbtError) {
+                return PsbtParser.parseFinalizedTransactionHex(psbtHex);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse hex PSBT: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Parse a PSBT or finalized transaction from base64 format
+     * @param psbtBase64 - The PSBT or finalized transaction in base64 format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseBase64Psbt(psbtBase64) {
+        try {
+            try {
+                const psbt = Psbt.fromBase64(psbtBase64, { network: networks.bitcoin });
+                return PsbtParser.extractPsbtData(psbt);
+            }
+            catch (psbtError) {
+                return PsbtParser.parseFinalizedTransactionBase64(psbtBase64);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse base64 PSBT: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Extract transaction data from a PSBT
+     * Shared logic used by both parseHexPsbt and parseBase64Psbt
+     * @param psbt - The parsed PSBT object
+     * @returns Parsed transaction data with inputs and outputs
+     */
+    static extractPsbtData(psbt) {
+        const inputs = [];
+        const outputs = [];
+        psbt.txInputs.forEach((txInput, index) => {
+            const input = psbt.data.inputs[index];
+            const inputData = {
+                txid: txInput.hash.reverse().toString('hex'),
+                vout: txInput.index,
+            };
+            if (input.witnessUtxo) {
+                inputData.value = input.witnessUtxo.value;
+                try {
+                    inputData.address = address.fromOutputScript(input.witnessUtxo.script, networks.bitcoin);
+                }
+                catch (e) {
+                    // Address extraction failed
+                }
+            }
+            else if (input.nonWitnessUtxo) {
+                try {
+                    const prevTx = Transaction.fromBuffer(input.nonWitnessUtxo);
+                    const prevOut = prevTx.outs[txInput.index];
+                    inputData.value = prevOut.value;
+                    try {
+                        inputData.address = address.fromOutputScript(prevOut.script, networks.bitcoin);
+                    }
+                    catch (e) {
+                        // Address extraction failed
+                    }
+                }
+                catch (e) {
+                    // Transaction parsing failed
+                }
+            }
+            inputs.push(inputData);
+        });
+        PsbtParser.extractOutputs(psbt.txOutputs, outputs);
+        return { inputs, outputs };
+    }
+    /**
+     * Extract outputs from transaction outputs
+     * Shared logic used by both PSBT and finalized transaction parsing
+     * @param txOutputs - Array of transaction outputs (from PSBT or Transaction)
+     * @param outputs - Array to populate with parsed output data
+     */
+    static extractOutputs(txOutputs, outputs) {
+        txOutputs.forEach((txOutput) => {
+            const outputData = {
+                value: txOutput.value,
+            };
+            try {
+                outputData.address = address.fromOutputScript(txOutput.script, networks.bitcoin);
+            }
+            catch (e) {
+                // Address extraction failed - continue without address
+            }
+            outputs.push(outputData);
+        });
+    }
+    /**
+     * Parse a finalized Bitcoin transaction from hex format
+     * @param txHex - The transaction in hex format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseFinalizedTransactionHex(txHex) {
+        try {
+            const tx = Transaction.fromHex(txHex);
+            return PsbtParser.extractTransactionData(tx);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse finalized transaction hex: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Parse a finalized Bitcoin transaction from base64 format
+     * @param txBase64 - The transaction in base64 format
+     * @returns Parsed transaction data with inputs and outputs
+     * @throws Error if parsing fails
+     */
+    static parseFinalizedTransactionBase64(txBase64) {
+        try {
+            const buffer = Buffer.from(txBase64, 'base64');
+            const tx = Transaction.fromBuffer(buffer);
+            return PsbtParser.extractTransactionData(tx);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse finalized transaction base64: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Extract transaction data from a finalized Transaction
+     * Shared logic used by both parseFinalizedTransactionHex and parseFinalizedTransactionBase64
+     * @param tx - The parsed Transaction object
+     * @returns Parsed transaction data with inputs and outputs
+     */
+    static extractTransactionData(tx) {
+        const inputs = [];
+        const outputs = [];
+        tx.ins.forEach((input) => {
+            const inputData = {
+                txid: input.hash.reverse().toString('hex'),
+                vout: input.index,
+            };
+            inputs.push(inputData);
+        });
+        PsbtParser.extractOutputs(tx.outs, outputs);
+        return { inputs, outputs };
+    }
+}
+
+export { PsbtParser };

package/src/utils/psbtParser/index.d.ts

@@ -0,0 +1 @@
+export { PsbtParser } from './PsbtParser';

package/src/wallet/BitcoinWallet.cjs

@@ -85,6 +85,17 @@ class BitcoinWallet extends walletConnectorCore.Wallet {
             return this._connector.signPsbts(requests);
         });
     }
+    /**
+     * Builds a PSBT for a Bitcoin transaction
+     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis
+     * @returns A promise that resolves to a PSBT in Base64 format, or undefined if not supported
+     */
+    buildPsbt(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.buildPsbt(transaction);
+        });
+    }
 }
 
 exports.BitcoinWallet = BitcoinWallet;

package/src/wallet/BitcoinWallet.d.ts

@@ -48,4 +48,10 @@ export declare class BitcoinWallet extends Wallet<BitcoinWalletConnector> {
      * or undefined if no provider is available
      */
     signPsbts(requests: BitcoinSignPsbtRequest[]): Promise<string[] | undefined>;
+    /**
+     * Builds a PSBT for a Bitcoin transaction
+     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis
+     * @returns A promise that resolves to a PSBT in Base64 format, or undefined if not supported
+     */
+    buildPsbt(transaction: BitcoinTransaction): Promise<string | undefined>;
 }

package/src/wallet/BitcoinWallet.js

@@ -81,6 +81,17 @@ class BitcoinWallet extends Wallet {
             return this._connector.signPsbts(requests);
         });
     }
+    /**
+     * Builds a PSBT for a Bitcoin transaction
+     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis
+     * @returns A promise that resolves to a PSBT in Base64 format, or undefined if not supported
+     */
+    buildPsbt(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.buildPsbt(transaction);
+        });
+    }
 }
 
 export { BitcoinWallet };