@dynamic-labs/bitcoin 4.52.4 → 4.53.0

package/CHANGELOG.md

@@ -1,4 +1,34 @@
 
+## [4.53.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.52.5...v4.53.0) (2026-01-13)
+
+
+### Features
+
+* add contract deployment bundle into first transaction ([#10089](https://github.com/dynamic-labs/dynamic-auth/issues/10089)) ([1291f2a](https://github.com/dynamic-labs/dynamic-auth/commit/1291f2ae2d4881c047a3e6e4e6cf4281a868f626))
+* add ton balance to wallet connector ([#10186](https://github.com/dynamic-labs/dynamic-auth/issues/10186)) ([7b1bdf3](https://github.com/dynamic-labs/dynamic-auth/commit/7b1bdf38f9685cb74974de0592e0e824146d343d))
+* add waas btc support in demo ([#10192](https://github.com/dynamic-labs/dynamic-auth/issues/10192)) ([36aedd6](https://github.com/dynamic-labs/dynamic-auth/commit/36aedd614b7fe781c7150efb4c1a77a5fe55a1ae))
+* merge waas-bitcoin to existing bitcoin package ([#10190](https://github.com/dynamic-labs/dynamic-auth/issues/10190)) ([70dfc6b](https://github.com/dynamic-labs/dynamic-auth/commit/70dfc6baca4f69af56a10ad29faca0fb361ec17b))
+* update sdk-react-core to support btc from waas ([#10191](https://github.com/dynamic-labs/dynamic-auth/issues/10191)) ([c39a99c](https://github.com/dynamic-labs/dynamic-auth/commit/c39a99c544e567a75f43e9b83d4969b70d3c01d1))
+
+
+### Bug Fixes
+
+* udpate ESM compatibility issues in build scripts for iconic ([#10201](https://github.com/dynamic-labs/dynamic-auth/issues/10201)) ([55059ad](https://github.com/dynamic-labs/dynamic-auth/commit/55059ad8c874b7f04699c277467242783f5d6eff))
+
+### [4.52.5](https://github.com/dynamic-labs/dynamic-auth/compare/v4.52.4...v4.52.5) (2026-01-08)
+
+
+### Features
+
+* add generate ton connect proof method to demo v2 ([#9989](https://github.com/dynamic-labs/dynamic-auth/issues/9989)) ([9727e2e](https://github.com/dynamic-labs/dynamic-auth/commit/9727e2e25742c4a2b0345c8c4a83159cc88892d7))
+* add waas ton to demo v2 ([#9988](https://github.com/dynamic-labs/dynamic-auth/issues/9988)) ([8edda43](https://github.com/dynamic-labs/dynamic-auth/commit/8edda43aeb58b5a77aef197d6cf20c1b633d1610))
+
+
+### Bug Fixes
+
+* trigger onAuthSuccess callback for passkey MFA flows ([#10174](https://github.com/dynamic-labs/dynamic-auth/issues/10174)) ([a37753a](https://github.com/dynamic-labs/dynamic-auth/commit/a37753afd6f3b814198d2acf6dc267feb11021e2))
+* **wallet-book:** add mobile app IDs for Binance Wallet to fix mobile filtering ([#10176](https://github.com/dynamic-labs/dynamic-auth/issues/10176)) ([010a48f](https://github.com/dynamic-labs/dynamic-auth/commit/010a48fd28a49861a26b9188babe4a174cefeedb))
+
 ### [4.52.4](https://github.com/dynamic-labs/dynamic-auth/compare/v4.52.3...v4.52.4) (2026-01-07)
 
 ### [4.52.3](https://github.com/dynamic-labs/dynamic-auth/compare/v4.52.2...v4.52.3) (2026-01-06)

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.52.4";
+var version = "4.53.0";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.52.4";
+var version = "4.53.0";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/bitcoin",
-  "version": "4.52.4",
+  "version": "4.53.0",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,18 +18,23 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
+    "@dynamic-labs-wallet/browser-wallet-client": "0.0.237",
+    "@bitcoinerlab/secp256k1": "1.1.1",
     "@btckit/types": "0.0.19",
     "@dynamic-labs/sdk-api-core": "0.0.843",
     "@wallet-standard/app": "1.0.1",
     "@wallet-standard/base": "1.0.1",
     "bitcoinjs-lib": "6.1.5",
+    "ecpair": "2.1.0",
     "sats-connect": "4.2.0",
     "jsontokens": "4.0.1",
-    "@dynamic-labs/assert-package-version": "4.52.4",
-    "@dynamic-labs/types": "4.52.4",
-    "@dynamic-labs/utils": "4.52.4",
-    "@dynamic-labs/wallet-book": "4.52.4",
-    "@dynamic-labs/wallet-connector-core": "4.52.4",
+    "@dynamic-labs/assert-package-version": "4.53.0",
+    "@dynamic-labs/logger": "4.53.0",
+    "@dynamic-labs/types": "4.53.0",
+    "@dynamic-labs/utils": "4.53.0",
+    "@dynamic-labs/waas": "4.53.0",
+    "@dynamic-labs/wallet-book": "4.53.0",
+    "@dynamic-labs/wallet-connector-core": "4.53.0",
     "eventemitter3": "5.0.1"
   },
   "peerDependencies": {}

package/src/connectors/BitcoinSatsConnectConnector/BitcoinSatsConnectConnector.js

@@ -1,7 +1,7 @@
 'use client'
 import { __awaiter } from '../../../_virtual/_tslib.js';
 import { Psbt } from 'bitcoinjs-lib';
-import { BitcoinNetworkType, addListener, request, AddressPurpose, signMultipleTransactions } from 'sats-connect';
+import { BitcoinNetworkType, request, AddressPurpose, signMultipleTransactions, addListener } from 'sats-connect';
 import { isMobile, template, PlatformService } from '@dynamic-labs/utils';
 import { logger, eventListenerHandlers } from '@dynamic-labs/wallet-connector-core';
 import { convertNetworkTypeForPsbt } from '../../utils/psbt/bitcoinNetworkTypeToNetworks.js';

package/src/connectors/BitcoinWalletConnector.cjs

@@ -201,6 +201,14 @@ class BitcoinWalletConnector extends walletConnectorCore.WalletConnectorBase {
             return undefined;
         });
     }
+    // not all wallets support buildPsbt method
+    // so we have a default implementation that returns undefined
+    buildPsbt(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            walletConnectorCore.logger.debug('buildPsbt - function not implemented', transaction);
+            return undefined;
+        });
+    }
     getProvider() {
         var _a;
         return (_a = this.bitcoinProviderHelper) === null || _a === void 0 ? void 0 : _a.getProvider();

package/src/connectors/BitcoinWalletConnector.d.ts

@@ -41,6 +41,7 @@ export declare abstract class BitcoinWalletConnector extends WalletConnectorBase
     setAdditionalAddresses(mainAddress: string, additionalAddresses: WalletAdditionalAddress[]): Promise<void>;
     sendRawTransaction(rawTransaction: string): Promise<string>;
     sendBitcoin(transaction: BitcoinTransaction): Promise<string | undefined>;
+    buildPsbt(transaction: BitcoinTransaction): Promise<string | undefined>;
     getProvider<T>(): T & EventEmitter<string | symbol, any>;
     abstract signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse | undefined>;
     signPsbts(requests: BitcoinSignPsbtRequest[]): Promise<string[] | undefined>;

package/src/connectors/BitcoinWalletConnector.js

@@ -1,9 +1,9 @@
 'use client'
 import { __awaiter } from '../../_virtual/_tslib.js';
 import { AddressPurpose } from 'sats-connect';
-import { WalletConnectorBase, isConnectorMethodSupported, eventListenerHandlers, logger } from '@dynamic-labs/wallet-connector-core';
+import { WalletConnectorBase, isConnectorMethodSupported, logger, eventListenerHandlers } from '@dynamic-labs/wallet-connector-core';
 import { getWalletBookWallet } from '@dynamic-labs/wallet-book';
-import { isLedgerAddressViaVerifiedCredentials, DynamicError } from '@dynamic-labs/utils';
+import { DynamicError, isLedgerAddressViaVerifiedCredentials } from '@dynamic-labs/utils';
 import { WalletAddressType } from '@dynamic-labs/sdk-api-core';
 import { BitcoinLocalStorageCache } from '../BitcoinLocalStorageCache.js';
 import { BitcoinProviderHelper } from '../bitcoinProviderHelper.js';
@@ -197,6 +197,14 @@ class BitcoinWalletConnector extends WalletConnectorBase {
             return undefined;
         });
     }
+    // not all wallets support buildPsbt method
+    // so we have a default implementation that returns undefined
+    buildPsbt(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('buildPsbt - function not implemented', transaction);
+            return undefined;
+        });
+    }
     getProvider() {
         var _a;
         return (_a = this.bitcoinProviderHelper) === null || _a === void 0 ? void 0 : _a.getProvider();

package/src/connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.cjs

@@ -0,0 +1,464 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger$1 = require('@dynamic-labs/logger');
+var utils = require('@dynamic-labs/utils');
+var waas = require('@dynamic-labs/waas');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var BitcoinWalletConnector = require('../BitcoinWalletConnector.cjs');
+var MempoolApiService = require('../../services/MempoolApiService.cjs');
+var PsbtBuilderService = require('../../services/PsbtBuilderService.cjs');
+var PsbtParser = require('../../utils/psbtParser/PsbtParser.cjs');
+require('sats-connect');
+require('bitcoinjs-lib');
+require('jsontokens');
+var btcToSatoshis = require('../../utils/btcToSatoshis/btcToSatoshis.cjs');
+
+const logger = new logger$1.Logger('DynamicWaasConnector');
+/**
+ * Bitcoin connector for Dynamic WaaS (Wallet as a Service)
+ * Extends BitcoinWalletConnector with WaaS functionality for Bitcoin transactions
+ */
+class DynamicWaasBitcoinConnector extends waas.withDynamicWaas(BitcoinWalletConnector.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.MempoolApiService();
+        this.psbtBuilderService = new PsbtBuilderService.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 _tslib.__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 utils.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 _tslib.__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 _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new utils.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 utils.DynamicError('Signed session ID is required');
+            }
+            const mfaToken = yield ((_b = this.getMfaToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                mfaAction: sdkApiCore.MFAAction.WalletWaasSign,
+            }));
+            if (request.signature && request.signature.length > 0) {
+                throw new utils.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new utils.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new utils.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 utils.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 _tslib.__awaiter(this, arguments, void 0, function* ({ thresholdSignatureScheme = 'TWO_OF_TWO', password, bitcoinConfig, } = {}) {
+            if (!bitcoinConfig || !bitcoinConfig.addressType) {
+                throw new utils.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 _tslib.__awaiter(this, arguments, void 0, function* ({ privateKey, thresholdSignatureScheme = 'TWO_OF_TWO', publicAddressCheck, addressType, }) {
+            if (!addressType) {
+                throw new utils.DynamicError('addressType is required for BTC importPrivateKey');
+            }
+            const validAddressTypes = ['native_segwit', 'taproot'];
+            if (!validAddressTypes.includes(addressType)) {
+                throw new utils.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 _tslib.__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 _tslib.__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 utils.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 utils.DynamicError('Account not found');
+            }
+            const isWalletActive = walletConnectorCore.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 _tslib.__awaiter(this, arguments, void 0, function* ({ message, context, }) {
+            var _b, _c;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new utils.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 utils.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.activeAccountAddress) {
+                throw new utils.DynamicError('Active account address is required');
+            }
+            const publicKeyHex = yield this.getPublicKey();
+            const buildOptions = PsbtBuilderService.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.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.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.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.activeAccountAddress) {
+                throw new utils.DynamicError('No active account address');
+            }
+            const allCredentials = (_a = this.verifiedCredentials) !== null && _a !== void 0 ? _a : [];
+            if (allCredentials.length === 0) {
+                throw new utils.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 utils.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.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new utils.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 utils.DynamicError('Signed session ID is required');
+            }
+            const mfaToken = yield ((_b = this.getMfaToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                mfaAction: sdkApiCore.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,
+            });
+        });
+    }
+}
+
+exports.DynamicWaasBitcoinConnector = DynamicWaasBitcoinConnector;