@dynamic-labs/bitcoin 4.52.5 → 4.53.0

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

@@ -0,0 +1,314 @@
+import { BitcoinConfig, BitcoinNetwork } from '@dynamic-labs-wallet/browser-wallet-client';
+import { JwtVerifiedCredential, MFAAction, SignMessageContext } from '@dynamic-labs/sdk-api-core';
+import { Logger } from '@dynamic-labs/logger';
+import { WalletUiUtils } from '@dynamic-labs/types';
+import { IDynamicWaasConnector, InternalWalletConnector, Chain, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from '@dynamic-labs/wallet-connector-core';
+import { BitcoinTransaction } from '../../types';
+import { BitcoinWalletConnector } from '../BitcoinWalletConnector';
+import type { ParsedTransaction, DynamicWaasBitcoinConnectorProps } from '../../types';
+declare const DynamicWaasBitcoinConnector_base: (abstract new (...args: any[]) => {
+    [x: string]: any;
+    name: string;
+    overrideKey: string;
+    isEmbeddedWallet: boolean;
+    getSignedSessionId?: (() => Promise<string>) | undefined;
+    getMfaToken?: ((props?: {
+        mfaAction?: MFAAction | undefined;
+    } | undefined) => Promise<string | undefined>) | undefined;
+    getAuthToken?: (() => string) | undefined;
+    environmentId?: string | undefined;
+    baseApiUrl?: string | undefined;
+    relayUrl?: string | undefined;
+    baseClientKeysharesRelayApiUrl?: string | undefined;
+    dynamicWaasClient: import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient | undefined;
+    chainName: string;
+    authMode: "cookie" | "header";
+    logger: Logger;
+    __exportHandler: import("@dynamic-labs/waas").WaasExportHandler;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    setGetAuthTokenFunction(getAuthToken: () => string): void;
+    setWaasAuthMode(authMode: "cookie" | "header"): void;
+    setGetMfaTokenFunction(getMfaToken: (props?: {
+        mfaAction?: MFAAction | undefined;
+    } | undefined) => Promise<string | undefined>): void;
+    setEnvironmentId(environmentId: string): void;
+    setBaseApiUrl(baseApiUrl: string): void;
+    setBaseClientKeysharesRelayApiUrl(baseClientKeysharesRelayApiUrl?: string | undefined): void;
+    setRelayUrl(relayUrl: string): void;
+    setGetSignedSessionIdFunction(getSignedSessionId: () => Promise<string>): void;
+    delegateKeyShares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    createDynamicWaasClient(traceContext?: import("dist/packages/waas/utils/instrumentation").TraceContext | undefined): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    getWaasWalletClient(traceContext?: import("dist/packages/waas/utils/instrumentation").TraceContext | undefined): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    createWalletAccount({ thresholdSignatureScheme, password, bitcoinConfig, }?: {
+        thresholdSignatureScheme?: string | undefined;
+        password?: string | undefined;
+        bitcoinConfig?: BitcoinConfig | undefined;
+    } | undefined): Promise<{
+        chainName: string;
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: string | Uint8Array | undefined;
+    }>;
+    importPrivateKey({ privateKey, thresholdSignatureScheme, publicAddressCheck, addressType, }: {
+        privateKey: string;
+        thresholdSignatureScheme?: string | undefined;
+        publicAddressCheck?: string | undefined;
+        addressType?: string | undefined;
+    }): Promise<void>;
+    exportPrivateKey({ accountAddress, displayContainer, password, }?: {
+        accountAddress?: string | undefined;
+        displayContainer?: HTMLIFrameElement | undefined;
+        password?: string | undefined;
+    } | undefined): Promise<void>;
+    getExportHandler(): {
+        clear: () => void;
+    };
+    exportClientKeyshares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    backupKeySharesToGoogleDrive({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    exportClientKeysharesFromGoogleDrive({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    refreshWalletAccountShares({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    reshareWalletAccountShares({ accountAddress, thresholdSignatureScheme, password, }: {
+        accountAddress: string;
+        thresholdSignatureScheme: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    revokeDelegation({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    updatePassword({ accountAddress, existingPassword, newPassword, }: {
+        accountAddress: string;
+        existingPassword: string;
+        newPassword: string;
+    }): Promise<void>;
+    signRawMessage({ accountAddress, message, password, }: {
+        accountAddress: string;
+        message: string;
+        password?: string | undefined;
+    }): Promise<string>;
+    endSession(): Promise<void>;
+    getActiveAccountAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    generateTraceId(): string;
+    instrument(message: string, context: import("@dynamic-labs/logger").InstrumentOptions & import("dist/packages/waas/utils/instrumentation").InstrumentContext & Record<string, any>): void;
+    instrumentAsync<T_1>({ operation, resource, fn, context, }: {
+        operation: string;
+        resource: string;
+        fn: (timing: import("dist/packages/waas/utils/instrumentation").InstrumentationTimer) => Promise<T_1>;
+        context?: Record<string, any> | undefined;
+    }): Promise<T_1>;
+}) & typeof BitcoinWalletConnector;
+/**
+ * Bitcoin connector for Dynamic WaaS (Wallet as a Service)
+ * Extends BitcoinWalletConnector with WaaS functionality for Bitcoin transactions
+ */
+export declare class DynamicWaasBitcoinConnector extends DynamicWaasBitcoinConnector_base implements IDynamicWaasConnector {
+    name: string;
+    logger: Logger;
+    overrideKey: string;
+    isEmbeddedWallet: boolean;
+    connectedChain: Chain;
+    get key(): string;
+    activeAccountAddress: string | undefined;
+    protected walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+    /**
+     * The primary/active verified credential (first from the filtered array)
+     * This is used for the active account address
+     */
+    private _verifiedCredential;
+    private mempoolApiService;
+    private psbtBuilderService;
+    /**
+     * @param props - Constructor properties including walletUiUtils
+     */
+    constructor(props: DynamicWaasBitcoinConnectorProps);
+    set verifiedCredential(verifiedCredential: JwtVerifiedCredential | undefined);
+    get verifiedCredential(): JwtVerifiedCredential | undefined;
+    /**
+     * 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: JwtVerifiedCredential[]): void;
+    /**
+     * 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(): Promise<string | undefined>;
+    /**
+     * Gets all connected account addresses
+     * @returns Array of connected account addresses (currently returns single active address)
+     */
+    getConnectedAccounts(): Promise<string[]>;
+    /**
+     * Gets the current Bitcoin network
+     * @returns The network name ('mainnet' for Bitcoin)
+     */
+    getNetwork(): Promise<BitcoinNetwork>;
+    /**
+     * 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: string): Promise<string>;
+    /**
+     * 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: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse>;
+    /**
+     * 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: string): Promise<string>;
+    /**
+     * 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: BitcoinTransaction): Promise<string | undefined>;
+    /**
+     * 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({ thresholdSignatureScheme, password, bitcoinConfig, }?: {
+        thresholdSignatureScheme?: string;
+        password?: string;
+        bitcoinConfig?: BitcoinConfig;
+    }): Promise<{
+        chainName: string;
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: string | Uint8Array | undefined;
+    }>;
+    /**
+     * 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({ privateKey, thresholdSignatureScheme, publicAddressCheck, addressType, }: {
+        privateKey: string;
+        thresholdSignatureScheme?: string;
+        publicAddressCheck?: string;
+        addressType?: string;
+    }): Promise<void>;
+    /**
+     * 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 }: {
+        accountAddress: string;
+    }): Promise<import("@dynamic-labs-wallet/browser-wallet-client").DynamicWalletClient>;
+    /**
+     * Gets the currently active account address
+     * @returns The active account address or undefined if not set
+     */
+    getActiveAccountAddress(): Promise<string | undefined>;
+    /**
+     * 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: string): Promise<void>;
+    /**
+     * 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({ message, context, }: {
+        message: string | {
+            raw: string;
+        };
+        context: SignMessageContext;
+    }): Promise<string>;
+    /**
+     * 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: BitcoinTransaction): Promise<string>;
+    /**
+     * 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: string): ParsedTransaction | null;
+    /**
+     * 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: string): ParsedTransaction | null;
+    /**
+     * 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: string): ParsedTransaction | null;
+    /**
+     * 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(): Promise<string>;
+    /**
+     * 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: number): bigint;
+    /**
+     * Sets the active account address for this connector
+     * @param accountAddress - The Bitcoin account address to set as active
+     */
+    private setActiveAccountAddress;
+    /**
+     * 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
+     */
+    private internalSignMessage;
+}
+export {};