@dynamic-labs/bitcoin 4.52.5 → 4.53.0

package/src/connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js

@@ -0,0 +1,460 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { MFAAction } from '@dynamic-labs/sdk-api-core';
+import { Logger } from '@dynamic-labs/logger';
+import { DynamicError } from '@dynamic-labs/utils';
+import { withDynamicWaas } from '@dynamic-labs/waas';
+import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
+import { BitcoinWalletConnector } from '../BitcoinWalletConnector.js';
+import { MempoolApiService } from '../../services/MempoolApiService.js';
+import { PsbtBuilderService } from '../../services/PsbtBuilderService.js';
+import { PsbtParser } from '../../utils/psbtParser/PsbtParser.js';
+import 'sats-connect';
+import 'bitcoinjs-lib';
+import 'jsontokens';
+import { btcToSatoshis } from '../../utils/btcToSatoshis/btcToSatoshis.js';
+
+const logger = new Logger('DynamicWaasConnector');
+/**
+ * Bitcoin connector for Dynamic WaaS (Wallet as a Service)
+ * Extends BitcoinWalletConnector with WaaS functionality for Bitcoin transactions
+ */
+class DynamicWaasBitcoinConnector extends withDynamicWaas(BitcoinWalletConnector) {
+    // Override the key getter to avoid undefined name issues
+    get key() {
+        return this.overrideKey || 'dynamicwaas';
+    }
+    /**
+     * @param props - Constructor properties including walletUiUtils
+     */
+    constructor(props) {
+        super(props);
+        this.name = 'Dynamic Waas';
+        this.logger = logger;
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this.connectedChain = 'BTC';
+        this.walletUiUtils = props.walletUiUtils;
+        this.mempoolApiService = new MempoolApiService();
+        this.psbtBuilderService = new PsbtBuilderService(this.mempoolApiService);
+    }
+    set verifiedCredential(verifiedCredential) {
+        this._verifiedCredential = verifiedCredential;
+    }
+    get verifiedCredential() {
+        return this._verifiedCredential;
+    }
+    /**
+     * Override setVerifiedCredentials to filter and set Bitcoin WaaS credentials
+     * Filters for credentials with walletName === 'dynamicwaas' and chain === 'bip122'
+     * The base class already has verifiedCredentials property, so we just filter and set it
+     */
+    setVerifiedCredentials(verifiedCredentials) {
+        const dynamicWaasBitcoinVerifiedCredentials = verifiedCredentials === null || verifiedCredentials === void 0 ? void 0 : verifiedCredentials.reduce((acc, vc) => {
+            if (vc.walletName === 'dynamicwaas' && vc.chain === 'bip122') {
+                acc.push(vc);
+            }
+            return acc;
+        }, []);
+        const [dynamicWaasBitcoinVerifiedCredential] = dynamicWaasBitcoinVerifiedCredentials;
+        const didDynamicWaasBitcoinVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredentials) !==
+            JSON.stringify(dynamicWaasBitcoinVerifiedCredentials);
+        if (!didDynamicWaasBitcoinVerifiedCredentialsChanged) {
+            return;
+        }
+        // Set the filtered credentials using the base class property
+        this.verifiedCredentials = dynamicWaasBitcoinVerifiedCredentials;
+        // Set the primary credential
+        this.verifiedCredential = dynamicWaasBitcoinVerifiedCredential;
+    }
+    /**
+     * Gets the active wallet address
+     * Falls back to verified credential address if no active account is set
+     * @returns The wallet address or undefined
+     * @throws {DynamicError} If no active wallet address is found
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const activeAccount = this.getActiveAccount();
+            if (!activeAccount || !activeAccount.address) {
+                if ((_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address) {
+                    const { address } = this.verifiedCredential;
+                    this.setActiveAccount(address);
+                    return address;
+                }
+                throw new DynamicError('No active wallet address found');
+            }
+            return activeAccount.address;
+        });
+    }
+    /**
+     * Gets all connected account addresses
+     * @returns Array of connected account addresses (currently returns single active address)
+     */
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                return [];
+            }
+            return [this.activeAccountAddress];
+        });
+    }
+    /**
+     * Gets the current Bitcoin network
+     * @returns The network name ('mainnet' for Bitcoin)
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 'mainnet';
+        });
+    }
+    /**
+     * Signs a message using the wallet UI utils for user interaction
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     */
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => __awaiter(this, void 0, void 0, function* () { return this.internalSignMessage(message); }),
+                message,
+                walletConnector: this,
+            });
+        });
+    }
+    /**
+     * Signs a Partially Signed Bitcoin Transaction (PSBT)
+     * @param request - The PSBT signing request containing the unsigned PSBT
+     * @returns The signed PSBT response
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available or signature is provided
+     */
+    signPsbt(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            const mfaToken = yield ((_b = this.getMfaToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            if (request.signature && request.signature.length > 0) {
+                throw new DynamicError('Signature is not supported for waas at the moment');
+            }
+            const signedTransaction = yield walletClient.signTransaction({
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                mfaToken,
+                senderAddress: this.activeAccountAddress,
+                signedSessionId,
+                transaction: request.unsignedPsbtBase64,
+            });
+            return {
+                signedPsbt: signedTransaction,
+            };
+        });
+    }
+    /**
+     * Sends a raw Bitcoin transaction to the mempool
+     * @param rawTransaction - The raw transaction in hex format
+     * @returns The transaction ID
+     * @throws {DynamicError} If no transaction is specified or sending fails
+     */
+    sendRawTransaction(rawTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            return this.mempoolApiService.sendRawTransaction(this.activeAccountAddress, rawTransaction);
+        });
+    }
+    /**
+     * Sends Bitcoin to a recipient address
+     * This method combines buildPsbt, signPsbt, and sendRawTransaction into a single flow
+     * @param transaction - The Bitcoin transaction containing recipient address and amount
+     * @returns The transaction ID
+     * @throws {DynamicError} If any step in the process fails
+     */
+    sendBitcoin(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            // Step 1: Build the PSBT
+            const unsignedPsbt = yield this.buildPsbt(transaction);
+            // Step 2: Sign the PSBT
+            // SIGHASH_ALL (0x01) is the most common sighash type for Bitcoin transactions (Eventually can be configurable)
+            const signedPsbtResponse = yield this.signPsbt({
+                allowedSighash: [0x01],
+                unsignedPsbtBase64: unsignedPsbt,
+            });
+            if (!signedPsbtResponse) {
+                throw new DynamicError('Failed to sign PSBT');
+            }
+            // Step 3: Convert signed PSBT to raw transaction
+            const signedTransactionHex = signedPsbtResponse.signedPsbt;
+            // Step 4: Send the raw transaction
+            return this.sendRawTransaction(signedTransactionHex);
+        });
+    }
+    /**
+     * Creates a new Bitcoin wallet account with Bitcoin-specific defaults
+     * @param thresholdSignatureScheme - The threshold signature scheme (default: 'TWO_OF_TWO')
+     * @param password - Optional password for the wallet
+     * @param bitcoinConfig - Bitcoin configuration (required for Bitcoin)
+     * @returns The created wallet account information
+     */
+    createWalletAccount() {
+        const _super = Object.create(null, {
+            createWalletAccount: { get: () => super.createWalletAccount }
+        });
+        return __awaiter(this, arguments, void 0, function* ({ thresholdSignatureScheme = 'TWO_OF_TWO', password, bitcoinConfig, } = {}) {
+            if (!bitcoinConfig || !bitcoinConfig.addressType) {
+                throw new DynamicError('Bitcoin config with address type is required for Bitcoin');
+            }
+            const finalBitcoinConfig = {
+                addressType: bitcoinConfig.addressType,
+                network: yield this.getNetwork(),
+            };
+            return _super.createWalletAccount.call(this, {
+                bitcoinConfig: finalBitcoinConfig,
+                password,
+                thresholdSignatureScheme,
+            });
+        });
+    }
+    /**
+     * Override importPrivateKey to require and validate addressType for Bitcoin
+     * @param privateKey - The private key to import (WIF format for Bitcoin)
+     * @param thresholdSignatureScheme - The threshold signature scheme (default: 'TWO_OF_TWO')
+     * @param publicAddressCheck - Optional public address to verify against
+     * @param addressType - Required address type for Bitcoin ('native_segwit' or 'taproot')
+     * @throws {DynamicError} If addressType is missing or invalid for BTC
+     */
+    importPrivateKey(_a) {
+        const _super = Object.create(null, {
+            importPrivateKey: { get: () => super.importPrivateKey }
+        });
+        return __awaiter(this, arguments, void 0, function* ({ privateKey, thresholdSignatureScheme = 'TWO_OF_TWO', publicAddressCheck, addressType, }) {
+            if (!addressType) {
+                throw new DynamicError('addressType is required for BTC importPrivateKey');
+            }
+            const validAddressTypes = ['native_segwit', 'taproot'];
+            if (!validAddressTypes.includes(addressType)) {
+                throw new DynamicError(`Invalid addressType: ${addressType}. Must be one of: ${validAddressTypes.join(', ')}`);
+            }
+            return _super.importPrivateKey.call(this, {
+                addressType,
+                privateKey,
+                publicAddressCheck,
+                thresholdSignatureScheme,
+            });
+        });
+    }
+    /**
+     * Gets the wallet client for a specific account address and sets it as active
+     * @param accountAddress - The Bitcoin account address
+     * @returns The WaaS wallet client instance
+     */
+    getWalletClientByAddress({ accountAddress }) {
+        this.setActiveAccountAddress(accountAddress);
+        return this.getWaasWalletClient();
+    }
+    /**
+     * Gets the currently active account address
+     * @returns The active account address or undefined if not set
+     */
+    getActiveAccountAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    /**
+     * Validates that the expected wallet address matches the active wallet
+     * Updates the active account address if it doesn't match
+     * @param expectedAddress - The expected wallet address to validate
+     * @throws {DynamicError} If signed session ID is not available or account is not found
+     */
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            const targetWallet = yield walletClient.getWallet({
+                accountAddress: expectedAddress,
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                signedSessionId,
+            });
+            if (!targetWallet) {
+                throw new DynamicError('Account not found');
+            }
+            const isWalletActive = isSameAddress(targetWallet.accountAddress, this.activeAccountAddress || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.activeAccountAddress = targetWallet.accountAddress;
+            }
+        });
+    }
+    /**
+     * Signs a message with additional context information
+     * @param message - The message to sign (string or object with raw property)
+     * @param context - Additional context for the message signing
+     * @returns The signed message as a string
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    signMessageWithContext(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ message, context, }) {
+            var _b, _c;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const signedSessionId = yield ((_b = this.getSignedSessionId) === null || _b === void 0 ? void 0 : _b.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            const messageString = typeof message === 'string' ? message : message.raw;
+            return walletClient.signMessage({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                context,
+                message: messageString,
+                signedSessionId,
+            });
+        });
+    }
+    /**
+     * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis to send
+     * @returns A PSBT in Base64 format
+     * @throws {DynamicError} If no active account address, insufficient funds, or other errors
+     */
+    buildPsbt(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const publicKeyHex = yield this.getPublicKey();
+            const buildOptions = PsbtBuilderService.createBuildOptions(this.activeAccountAddress, transaction, publicKeyHex);
+            return this.psbtBuilderService.buildPsbt(buildOptions);
+        });
+    }
+    /**
+     * 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, or null if parsing fails
+     */
+    parsePsbt(psbtInput) {
+        return PsbtParser.parsePsbt(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, or null if parsing fails
+     */
+    parseHexPsbt(psbtHex) {
+        return PsbtParser.parseHexPsbt(psbtHex);
+    }
+    /**
+     * 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, or null if parsing fails
+     */
+    parseBase64Psbt(psbtBase64) {
+        return PsbtParser.parseBase64Psbt(psbtBase64);
+    }
+    /**
+     * Gets the public key for the active account
+     * Falls back to the account address if public key retrieval fails
+     * @returns The public key or account address as fallback
+     * @throws {DynamicError} If no active account address is set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    getPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('No active account address');
+            }
+            const allCredentials = (_a = this.verifiedCredentials) !== null && _a !== void 0 ? _a : [];
+            if (allCredentials.length === 0) {
+                throw new DynamicError(`No verified credentials found. The address ${this.activeAccountAddress} may not be properly registered.`);
+            }
+            for (const credential of allCredentials) {
+                const { walletAdditionalAddresses } = credential !== null && credential !== void 0 ? credential : {};
+                if (!walletAdditionalAddresses) {
+                    continue;
+                }
+                const additionalAddress = walletAdditionalAddresses.find((address) => address.address === this.activeAccountAddress);
+                if (additionalAddress === null || additionalAddress === void 0 ? void 0 : additionalAddress.publicKey) {
+                    return additionalAddress.publicKey;
+                }
+            }
+            const allAvailableAddresses = allCredentials
+                .flatMap((cred) => { var _a; return (_a = cred.walletAdditionalAddresses) !== null && _a !== void 0 ? _a : []; })
+                .map((addr) => addr.address)
+                .join(', ');
+            throw new DynamicError(`No additional address found for ${this.activeAccountAddress}. Available addresses: ${allAvailableAddresses || 'none'}`);
+        });
+    }
+    /**
+     * 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
+     */
+    btcToSatoshis(btcAmount) {
+        return btcToSatoshis(btcAmount);
+    }
+    /**
+     * Sets the active account address for this connector
+     * @param accountAddress - The Bitcoin account address to set as active
+     */
+    setActiveAccountAddress(accountAddress) {
+        this.activeAccountAddress = accountAddress;
+    }
+    /**
+     * Internal method to sign a message with MFA token
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    internalSignMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            const mfaToken = yield ((_b = this.getMfaToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            return walletClient.signMessage({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                bitcoinConfig: {
+                    network: yield this.getNetwork(),
+                },
+                message,
+                mfaToken,
+                signedSessionId,
+            });
+        });
+    }
+}
+
+export { DynamicWaasBitcoinConnector };

package/src/connectors/DynamicWaasBitcoinConnector/index.d.ts

@@ -0,0 +1 @@
+export * from './DynamicWaasBitcoinConnector';

package/src/connectors/index.d.ts

@@ -9,3 +9,4 @@ export * from './OylConnector';
 export * from './UnisatConnector';
 export * from './FallbackBitcoinConnector';
 export * from './BinanceConnector';
+export * from './DynamicWaasBitcoinConnector';

package/src/const.cjs

@@ -9,10 +9,23 @@ const HTTP_STATUS_TOO_MANY_REQUESTS = 429;
 const HTTP_STATUS_NOT_FOUND = 404;
 const MEMPOOL_API_URL = 'https://mempool.space/api';
 const MEMPOOL_API_URL_TESTNET = 'https://mempool.space/testnet/api';
+// WaaS Bitcoin constants
+const SATOSHIS_PER_BTC = 100000000;
+const DUST_LIMIT = 546; // Bitcoin's dust limit in satoshis
+const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
+const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+const MIN_RELAY_FEE = 111;
+const DEFAULT_FEE_ESTIMATE = 1000; // Conservative default fee estimate in satoshis
 
 exports.BTCKIT_INTERFACE = BTCKIT_INTERFACE;
+exports.DEFAULT_FEE_ESTIMATE = DEFAULT_FEE_ESTIMATE;
+exports.DUST_LIMIT = DUST_LIMIT;
 exports.HTTP_STATUS_NOT_FOUND = HTTP_STATUS_NOT_FOUND;
 exports.HTTP_STATUS_TOO_MANY_REQUESTS = HTTP_STATUS_TOO_MANY_REQUESTS;
+exports.INPUT_BYTE_SIZE_UPPER_BOUND = INPUT_BYTE_SIZE_UPPER_BOUND;
 exports.MEMPOOL_API_URL = MEMPOOL_API_URL;
 exports.MEMPOOL_API_URL_TESTNET = MEMPOOL_API_URL_TESTNET;
+exports.MIN_RELAY_FEE = MIN_RELAY_FEE;
+exports.OUTPUT_BYTE_SIZE_UPPER_BOUND = OUTPUT_BYTE_SIZE_UPPER_BOUND;
+exports.SATOSHIS_PER_BTC = SATOSHIS_PER_BTC;
 exports.SATSCONNECT_FEATURE = SATSCONNECT_FEATURE;

package/src/const.d.ts

@@ -5,3 +5,9 @@ export declare const HTTP_STATUS_TOO_MANY_REQUESTS = 429;
 export declare const HTTP_STATUS_NOT_FOUND = 404;
 export declare const MEMPOOL_API_URL = "https://mempool.space/api";
 export declare const MEMPOOL_API_URL_TESTNET = "https://mempool.space/testnet/api";
+export declare const SATOSHIS_PER_BTC = 100000000;
+export declare const DUST_LIMIT = 546;
+export declare const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
+export declare const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+export declare const MIN_RELAY_FEE = 111;
+export declare const DEFAULT_FEE_ESTIMATE = 1000;

package/src/const.js

@@ -5,5 +5,12 @@ const HTTP_STATUS_TOO_MANY_REQUESTS = 429;
 const HTTP_STATUS_NOT_FOUND = 404;
 const MEMPOOL_API_URL = 'https://mempool.space/api';
 const MEMPOOL_API_URL_TESTNET = 'https://mempool.space/testnet/api';
+// WaaS Bitcoin constants
+const SATOSHIS_PER_BTC = 100000000;
+const DUST_LIMIT = 546; // Bitcoin's dust limit in satoshis
+const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
+const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+const MIN_RELAY_FEE = 111;
+const DEFAULT_FEE_ESTIMATE = 1000; // Conservative default fee estimate in satoshis
 
-export { BTCKIT_INTERFACE, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_TOO_MANY_REQUESTS, MEMPOOL_API_URL, MEMPOOL_API_URL_TESTNET, SATSCONNECT_FEATURE };
+export { BTCKIT_INTERFACE, DEFAULT_FEE_ESTIMATE, DUST_LIMIT, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_TOO_MANY_REQUESTS, INPUT_BYTE_SIZE_UPPER_BOUND, MEMPOOL_API_URL, MEMPOOL_API_URL_TESTNET, MIN_RELAY_FEE, OUTPUT_BYTE_SIZE_UPPER_BOUND, SATOSHIS_PER_BTC, SATSCONNECT_FEATURE };

package/src/index.cjs

@@ -20,6 +20,7 @@ var OylConnector = require('./connectors/OylConnector/OylConnector.cjs');
 var UnisatConnector = require('./connectors/UnisatConnector/UnisatConnector.cjs');
 var FallbackBitcoinConnector = require('./connectors/FallbackBitcoinConnector/FallbackBitcoinConnector.cjs');
 var BinanceConnector = require('./connectors/BinanceConnector/BinanceConnector.cjs');
+var DynamicWaasBitcoinConnector = require('./connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.cjs');
 var BitgetConnector = require('./connectors/BitgetConnector/BitgetConnector.cjs');
 var fetchBtcKitConnectors = require('./utils/fetchBtcKitConnectors/fetchBtcKitConnectors.cjs');
 var fetchSatsConnectConnectors = require('./utils/fetchSatsConnectConnectors/fetchSatsConnectConnectors.cjs');
@@ -27,6 +28,9 @@ var hasSatsConnectFeature = require('./utils/hasSatsConnectFeature.cjs');
 var getMempoolApiUrl = require('./utils/getMempoolApiUrl.cjs');
 var createSignPsbtOptions = require('./utils/psbt/createSignPsbtOptions.cjs');
 var satoshisToBtc = require('./utils/satoshisToBtc/satoshisToBtc.cjs');
+var btcToSatoshis = require('./utils/btcToSatoshis/btcToSatoshis.cjs');
+var getBitcoinNetwork = require('./utils/getBitcoinNetwork/getBitcoinNetwork.cjs');
+var PsbtParser = require('./utils/psbtParser/PsbtParser.cjs');
 var BitcoinWallet = require('./wallet/BitcoinWallet.cjs');
 var isBitcoinWallet = require('./wallet/isBitcoinWallet/isBitcoinWallet.cjs');
 var bitcoinProviderHelper = require('./bitcoinProviderHelper.cjs');
@@ -45,17 +49,22 @@ const BitcoinWalletConnectors = (props) => [
     BitgetConnector.BitgetConnector,
     BinanceConnector.BinanceConnector,
     FallbackBitcoinConnector.FallbackBitcoinConnector,
+    DynamicWaasBitcoinConnector.DynamicWaasBitcoinConnector,
 ];
 
 exports.BitcoinWalletConnector = BitcoinWalletConnector.BitcoinWalletConnector;
 exports.BitcoinSatsConnectConnector = BitcoinSatsConnectConnector.BitcoinSatsConnectConnector;
 exports.UnisatConnector = UnisatConnector.UnisatConnector;
+exports.DynamicWaasBitcoinConnector = DynamicWaasBitcoinConnector.DynamicWaasBitcoinConnector;
 exports.fetchBtcKitConnectors = fetchBtcKitConnectors.fetchBtcKitConnectors;
 exports.fetchSatsConnectConnectors = fetchSatsConnectConnectors.fetchSatsConnectConnectors;
 exports.hasSatsConnectFeature = hasSatsConnectFeature.hasSatsConnectFeature;
 exports.getMempoolApiUrl = getMempoolApiUrl.getMempoolApiUrl;
 exports.createPsbtOptions = createSignPsbtOptions.createPsbtOptions;
 exports.satoshisToBtc = satoshisToBtc.satoshisToBtc;
+exports.btcToSatoshis = btcToSatoshis.btcToSatoshis;
+exports.getBitcoinNetwork = getBitcoinNetwork.getBitcoinNetwork;
+exports.PsbtParser = PsbtParser.PsbtParser;
 exports.BitcoinWallet = BitcoinWallet.BitcoinWallet;
 exports.isBitcoinWallet = isBitcoinWallet.isBitcoinWallet;
 exports.BitcoinProviderHelper = bitcoinProviderHelper.BitcoinProviderHelper;

package/src/index.d.ts

@@ -1,9 +1,9 @@
 import { OkxConnector } from './connectors';
-export { BitcoinWalletConnector } from './connectors';
+export { BitcoinWalletConnector, type BitcoinWalletConnectorOpts, } from './connectors';
 export type { BitcoinTransaction, BitcoinSignProtocol, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse, BitcoinWalletStandardMethods, SignPsbtOptions, } from './types';
 export * from './utils';
 export * from './wallet';
-export { UnisatConnector, BitcoinSatsConnectConnector } from './connectors';
+export { UnisatConnector, BitcoinSatsConnectConnector, DynamicWaasBitcoinConnector, } from './connectors';
 export declare const BitcoinWalletConnectors: (props: any) => (import("dist/packages/wallet-connector-core/src").WalletConnectorConstructor | typeof OkxConnector)[];
 export { BitcoinProviderHelper } from './bitcoinProviderHelper';
 export { HTTP_STATUS_NOT_FOUND, HTTP_STATUS_TOO_MANY_REQUESTS } from './const';

package/src/index.js

@@ -17,6 +17,8 @@ import { UnisatConnector } from './connectors/UnisatConnector/UnisatConnector.js
 export { UnisatConnector } from './connectors/UnisatConnector/UnisatConnector.js';
 import { FallbackBitcoinConnector } from './connectors/FallbackBitcoinConnector/FallbackBitcoinConnector.js';
 import { BinanceConnector } from './connectors/BinanceConnector/BinanceConnector.js';
+import { DynamicWaasBitcoinConnector } from './connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js';
+export { DynamicWaasBitcoinConnector } from './connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js';
 import { BitgetConnector } from './connectors/BitgetConnector/BitgetConnector.js';
 import { fetchBtcKitConnectors } from './utils/fetchBtcKitConnectors/fetchBtcKitConnectors.js';
 export { fetchBtcKitConnectors } from './utils/fetchBtcKitConnectors/fetchBtcKitConnectors.js';
@@ -26,6 +28,9 @@ export { hasSatsConnectFeature } from './utils/hasSatsConnectFeature.js';
 export { getMempoolApiUrl } from './utils/getMempoolApiUrl.js';
 export { createPsbtOptions } from './utils/psbt/createSignPsbtOptions.js';
 export { satoshisToBtc } from './utils/satoshisToBtc/satoshisToBtc.js';
+export { btcToSatoshis } from './utils/btcToSatoshis/btcToSatoshis.js';
+export { getBitcoinNetwork } from './utils/getBitcoinNetwork/getBitcoinNetwork.js';
+export { PsbtParser } from './utils/psbtParser/PsbtParser.js';
 export { BitcoinWallet } from './wallet/BitcoinWallet.js';
 export { isBitcoinWallet } from './wallet/isBitcoinWallet/isBitcoinWallet.js';
 export { BitcoinProviderHelper } from './bitcoinProviderHelper.js';
@@ -44,6 +49,7 @@ const BitcoinWalletConnectors = (props) => [
     BitgetConnector,
     BinanceConnector,
     FallbackBitcoinConnector,
+    DynamicWaasBitcoinConnector,
 ];
 
 export { BitcoinWalletConnectors };