@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/index.node.d.cts

@@ -1,41 +1,319 @@
-import { SparkWallet as SparkWallet$1 } from './index.cjs';
-export { AuthenticationError, ConfigurationError, InternalValidationError, NetworkError, NotImplementedError, RPCError, SparkSDKError, ValidationError } from './index.cjs';
-import { I as InitWalletResponse } from './index-B2AwKW5J.cjs';
-export { a6 as BroadcastConfig, a7 as BroadcastResult, C as CreateLightningInvoiceParams, U as DEFAULT_FEE_SATS, D as DepositParams, a4 as FeeBumpTxChain, a3 as FeeBumpTxPackage, a2 as FeeRate, a0 as LeafInfo, P as PayLightningInvoiceParams, c as SparkWalletEvents, S as SparkWalletProps, b as TokenBalanceMap, a as TokenMetadata, T as TransferParams, a5 as TxChain, a1 as Utxo, t as addPrivateKeys, q as addPublicKeys, e as applyAdaptorToSignature, r as applyAdditiveTweakToPublicKey, N as calculateAvailableTokenAmount, O as checkIfSelectedOutputsAreAvailable, Z as checkIfValidSequence, B as collectResponses, f as computeTaprootKeyNoScript, ab as constructFeeBumpTx, aa as constructUnilateralExitFeeBumpPackages, a9 as constructUnilateralExitTxs, W as createRefundTx, K as createSigningCommitment, F as createSigningNonce, M as decodeBytesToSigningCommitment, J as decodeBytesToSigningNonce, L as encodeSigningCommitmentToBytes, H as encodeSigningNonceToBytes, Q as filterTokenBalanceForTokenPublicKey, d as generateAdaptorFromSignature, g as generateSignatureFromExistingAdaptor, X as getCurrentTimelock, $ as getEphemeralAnchorOutput, y as getLatestDepositTxId, _ as getNextTransactionSequence, j as getP2TRAddressFromPkScript, i as getP2TRAddressFromPublicKey, h as getP2TRScriptFromPublicKey, k as getP2WPKHAddressFromPublicKey, E as getRandomSigningNonce, n as getSigHashFromTx, G as getSigningCommitmentFromNonce, ac as getSparkAddressFromTaproot, Y as getTransactionSequence, R as getTransferPackageSigningPayload, m as getTxFromRawTxBytes, l as getTxFromRawTxHex, o as getTxId, p as getTxIdNoReverse, a8 as isEphemeralAnchorOutput, z as isTxBroadcast, x as lastKeyWithTarget, V as maybeApplyFee, A as proofOfPossessionMessageHashForDepositAddress, u as subtractPrivateKeys, s as subtractPublicKeys, w as sumOfPrivateKeys, v as validateOutboundAdaptorSignature } from './index-B2AwKW5J.cjs';
-export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, N as Network, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress, e as getNetworkFromString } from './network-CqgsdUF2.cjs';
-export { V as VerifiableSecretShare, d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from './signer-DKS0AJkw.cjs';
-import './RequestLightningSendInput-Du0z7Om7.cjs';
-import '@lightsparkdev/core';
-import './BitcoinNetwork-TnABML0T.cjs';
-import './LightningSendFeeEstimateInput-BgOhEAI-.cjs';
-import './spark-dM7EYXYQ.cjs';
-import '@bufbuild/protobuf/wire';
-import 'nice-grpc-common';
-import './services/config.cjs';
-import '@buildonspark/lrc20-sdk';
-import './services/wallet-config.cjs';
-import './services/connection.cjs';
+import { N as Network, T as TokenBalanceMap, b as SparkAddressFormat, W as WalletConfigService, c as ConnectionManager } from './spark-wallet-BAFPpPtY.cjs';
+export { C as ConfigOptions, t as CreateLightningInvoiceParams, D as DecodedSparkAddressData, v as DepositParams, H as HumanReadableTokenIdentifier, q as HumanReadableTokenIdentifierData, I as InitWalletResponse, L as LRC_WALLET_NETWORK, m as LRC_WALLET_NETWORK_TYPE, k as NetworkToProto, j as NetworkType, P as PayLightningInvoiceParams, e as SparkAddressData, S as SparkWallet, w as SparkWalletEvents, a as SparkWalletProps, u as TransferParams, U as UserTokenMetadata, d as WalletConfig, s as decodeHumanReadableTokenIdentifier, g as decodeSparkAddress, r as encodeHumanReadableTokenIdentifier, f as encodeSparkAddress, l as getNetwork, n as getNetworkFromAddress, o as getNetworkFromString, h as isValidPublicKey, i as isValidSparkAddress, p as protoToNetwork } from './spark-wallet-BAFPpPtY.cjs';
+import { Y as SigningNonce, Q as SigningCommitment } from './client-CvpTRpcw.cjs';
+export { ac as AggregateFrostParams, Z as DefaultSparkSigner, ae as DerivedHDKey, af as KeyPair, ab as SignFrostParams, K as SparkSigner, ad as SplitSecretWithProofsParams, $ as TaprootOutputKeysGenerator, _ as TaprootSparkSigner, W as VerifiableSecretShare, aa as bigIntToPrivateKey, a4 as computerLagrangeCoefficients, a2 as evaluatePolynomial, a3 as fieldDiv, a5 as generatePolynomialForSecretSharing, a0 as getRandomBigInt, a1 as modInverse, a8 as recoverSecret, a6 as splitSecret, a7 as splitSecretWithProofs, a9 as validateShare } from './client-CvpTRpcw.cjs';
+export { TokenSigner } from '@buildonspark/lrc20-sdk';
+export { MultisigReceiptInput } from '@buildonspark/lrc20-sdk/lrc/types';
+import * as btc from '@scure/btc-signer';
+import { Transaction } from '@scure/btc-signer';
+import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
+import { j as OutputWithPreviousTransactionData, k as TransferPackage, g as SparkServiceClient, T as TokenTransaction, l as TokenTransactionWithStatus } from './spark-BbUrbvZz.cjs';
+import { TokenTransaction as TokenTransaction$1, TokenTransactionWithStatus as TokenTransactionWithStatus$1 } from './proto/spark_token.cjs';
+import 'bitcoinjs-lib';
 import 'nice-grpc';
 import 'nice-grpc-web';
-import './proto/spark_token.cjs';
-import './services/lrc-connection.cjs';
-import './proto/lrc20.cjs';
-import '@scure/btc-signer';
+import '@bufbuild/protobuf/wire';
+import 'nice-grpc-common';
 import 'eventemitter3';
-import './address/index.cjs';
-import './sdk-types-B0SwjolI.cjs';
-import '@scure/btc-signer/psbt';
-import 'bitcoinjs-lib';
+import './sdk-types-XUeQMLFP.cjs';
+import '@lightsparkdev/core';
 import '@scure/bip32';
-import './types-C-Rp0Oo7.cjs';
-import '@buildonspark/lrc20-sdk/lrc/types';
+import './types-BADxR3bm.cjs';
+
+declare class SparkSDKError extends Error {
+    readonly context: Record<string, unknown>;
+    readonly originalError?: Error;
+    constructor(message: string, context?: Record<string, unknown>, originalError?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * NetworkError should be used for any errors related to network communication,
+ * such as failed HTTP requests, timeouts, or connection issues.
+ * This includes:
+ * - Failed API calls
+ * - Network timeouts
+ * - Connection refused
+ * - DNS resolution failures
+ * - SSL/TLS errors
+ */
+declare class NetworkError extends SparkSDKError {
+    constructor(message: string, context?: {
+        url?: string;
+        method?: string;
+        statusCode?: number;
+        response?: unknown;
+        errorCount?: number;
+        errors?: string;
+        operation?: string;
+        nodeSignaturesCount?: number;
+    }, originalError?: Error);
+}
+/**
+ * ValidationError should be used for any errors related to data validation in regards to the user's input,
+ * This includes:
+ * - Invalid signatures
+ * - Malformed addresses
+ * - Invalid proof of possession
+ * - Invalid cryptographic parameters
+ * - Data format validation failures
+ */
+declare class ValidationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        field?: string;
+        value?: unknown;
+        expected?: unknown;
+        expectedLength?: number;
+        actualLength?: number;
+        rValue?: bigint;
+        fieldPrime?: bigint;
+        sValue?: bigint;
+        groupOrder?: bigint;
+        index?: number;
+        treeLength?: number;
+        addressNodesLength?: number;
+    }, originalError?: Error);
+}
+/**
+ * InternalValidationError should be used for any errors related to internal data validation
+ * that is not related to the user's input.
+ * This includes:
+ * - Invalid SO responses
+ */
+declare class InternalValidationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        field?: string;
+        value?: unknown;
+        expected?: unknown;
+        outputIndex?: number;
+        keyshareInfo?: unknown;
+        signingOperators?: unknown;
+    }, originalError?: Error);
+}
+/**
+ * AuthenticationError should be used specifically for authentication and authorization failures,
+ * such as invalid credentials or insufficient permissions.
+ * This includes:
+ * - Invalid API keys
+ * - Expired tokens
+ * - Insufficient permissions
+ * - Authentication token validation failures
+ * - Authorization failures
+ */
+declare class AuthenticationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        endpoint?: string;
+        reason?: string;
+    }, originalError?: Error);
+}
+/**
+ * RPCError should be used for errors that occur during RPC (Remote Procedure Call) operations,
+ * such as invalid RPC parameters or RPC-specific failures.
+ * This includes:
+ * - Invalid RPC method calls
+ * - RPC parameter validation failures
+ * - RPC-specific error codes
+ * - RPC protocol errors
+ */
+declare class RPCError extends SparkSDKError {
+    constructor(message: string, context?: {
+        method?: string;
+        params?: unknown;
+        code?: number;
+    }, originalError?: Error);
+}
+/**
+ * ConfigurationError should be used for errors related to SDK configuration,
+ * such as missing or invalid configuration values.
+ * This includes:
+ * - Missing required configuration
+ * - Invalid configuration values
+ * - Configuration format errors
+ * - Environment-specific configuration issues
+ */
+declare class ConfigurationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        configKey?: string;
+        value?: unknown;
+    }, originalError?: Error);
+}
+/***
+ * NotImplementedError should be used for any errors related to features that are not yet implemented.
+ */
+declare class NotImplementedError extends SparkSDKError {
+    constructor(message: string, context?: Record<string, unknown>, originalError?: Error);
+}
+
+declare function generateSignatureFromExistingAdaptor(signature: Uint8Array, adaptorPrivateKeyBytes: Uint8Array): Uint8Array;
+declare function generateAdaptorFromSignature(signature: Uint8Array): {
+    adaptorSignature: Uint8Array;
+    adaptorPrivateKey: Uint8Array;
+};
+declare function validateOutboundAdaptorSignature(pubkey: Uint8Array, hash: Uint8Array, signature: Uint8Array, adaptorPubkey: Uint8Array): boolean;
+declare function applyAdaptorToSignature(pubkey: Uint8Array, hash: Uint8Array, signature: Uint8Array, adaptorPrivateKeyBytes: Uint8Array): Uint8Array;
+
+declare function computeTaprootKeyNoScript(pubkey: Uint8Array): Uint8Array;
+declare function getP2TRScriptFromPublicKey(pubKey: Uint8Array, network: Network): Uint8Array;
+declare function getP2TRAddressFromPublicKey(pubKey: Uint8Array, network: Network): string;
+declare function getP2TRAddressFromPkScript(pkScript: Uint8Array, network: Network): string;
+declare function getP2WPKHAddressFromPublicKey(pubKey: Uint8Array, network: Network): string;
+declare function getTxFromRawTxHex(rawTxHex: string): btc.Transaction;
+declare function getTxFromRawTxBytes(rawTxBytes: Uint8Array): btc.Transaction;
+declare function getSigHashFromTx(tx: btc.Transaction, inputIndex: number, prevOutput: TransactionOutput): Uint8Array;
+declare function getTxId(tx: btc.Transaction): string;
+declare function getTxIdNoReverse(tx: btc.Transaction): string;
 
-declare class SparkWallet extends SparkWallet$1 {
-    private tracer;
-    protected wrapWithOtelSpan<T>(name: string, fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T>;
-    protected initializeTracer(tracerName: string): Promise<void>;
-    private wrapSparkWalletWithTracing;
-    protected initWallet(mnemonicOrSeed?: Uint8Array | string, accountNumber?: number): Promise<InitWalletResponse | undefined>;
+declare function addPublicKeys(a: Uint8Array, b: Uint8Array): Uint8Array;
+declare function applyAdditiveTweakToPublicKey(pubkey: Uint8Array, tweak: Uint8Array): Uint8Array<ArrayBufferLike>;
+declare function subtractPublicKeys(a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBufferLike>;
+declare function addPrivateKeys(a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBufferLike>;
+declare function subtractPrivateKeys(a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBufferLike>;
+declare function sumOfPrivateKeys(keys: Uint8Array[]): Uint8Array<ArrayBufferLike>;
+declare function lastKeyWithTarget(target: Uint8Array, keys: Uint8Array[]): Uint8Array<ArrayBufferLike>;
+
+declare function getLatestDepositTxId(address: string): Promise<string | null>;
+declare function isTxBroadcast(txid: string, baseUrl: string, network?: any): Promise<boolean>;
+
+declare function proofOfPossessionMessageHashForDepositAddress(userPubkey: Uint8Array, operatorPubkey: Uint8Array, depositAddress: string): Uint8Array;
+
+declare function collectResponses<T>(responses: PromiseSettledResult<T>[]): T[];
+
+declare function getRandomSigningNonce(): SigningNonce;
+declare function createSigningNonce(binding: Uint8Array, hiding: Uint8Array): SigningNonce;
+declare function getSigningCommitmentFromNonce(nonce: SigningNonce): SigningCommitment;
+declare function encodeSigningNonceToBytes(nonce: SigningNonce): Uint8Array;
+declare function decodeBytesToSigningNonce(bytes: Uint8Array): SigningNonce;
+declare function createSigningCommitment(binding: Uint8Array, hiding: Uint8Array): SigningCommitment;
+declare function encodeSigningCommitmentToBytes(commitment: SigningCommitment): Uint8Array;
+declare function decodeBytesToSigningCommitment(bytes: Uint8Array): SigningCommitment;
+
+declare function sumAvailableTokens(outputs: OutputWithPreviousTransactionData[]): bigint;
+declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData[], tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>, tokenPublicKey: Uint8Array): boolean;
+declare function filterTokenBalanceForTokenPublicKey(tokenBalances: TokenBalanceMap, publicKey: string): {
+    balance: bigint;
+};
+
+declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
+
+declare const DEFAULT_FEE_SATS: number;
+/**
+ * Subtracts the default fee from the amount if it's greater than the fee.
+ * Returns the original amount if it's less than or equal to the fee.
+ */
+declare function maybeApplyFee(amount: bigint): bigint;
+declare function createRefundTx(sequence: number, nodeOutPoint: TransactionInput, amountSats: bigint, receivingPubkey: Uint8Array, network: Network): Transaction;
+declare function getCurrentTimelock(currSequence?: number): number;
+declare function getTransactionSequence(currSequence?: number): number;
+declare function checkIfValidSequence(currSequence?: number): void;
+declare function getNextTransactionSequence(currSequence?: number, forRefresh?: boolean): {
+    nextSequence: number;
+    needRefresh: boolean;
+};
+declare function getEphemeralAnchorOutput(): TransactionOutput;
+
+interface LeafInfo {
+    leafId: string;
+    nodeTx: string;
+    refundTx: string;
+}
+interface Utxo {
+    txid: string;
+    vout: number;
+    value: bigint;
+    script: string;
+    publicKey: string;
+}
+interface FeeRate {
+    satPerVbyte: number;
+}
+interface FeeBumpTxPackage {
+    tx: string;
+    feeBumpPsbt?: string;
+}
+interface FeeBumpTxChain {
+    leafId: string;
+    txPackages: FeeBumpTxPackage[];
+}
+interface TxChain {
+    leafId: string;
+    transactions: string[];
+}
+interface BroadcastConfig {
+    bitcoinCoreRpcUrl?: string;
+    rpcUsername?: string;
+    rpcPassword?: string;
+    autoBroadcast?: boolean;
+    network?: "MAINNET" | "REGTEST" | "TESTNET" | "SIGNET" | "LOCAL";
+}
+interface BroadcastResult {
+    success: boolean;
+    txids?: string[];
+    error?: string;
+    broadcastedPackages?: number;
+}
+declare function isEphemeralAnchorOutput(script?: Uint8Array, amount?: bigint): boolean;
+declare function constructUnilateralExitTxs(nodeHexStrings: string[], sparkClient?: SparkServiceClient, network?: any): Promise<TxChain[]>;
+declare function constructUnilateralExitFeeBumpPackages(nodeHexStrings: string[], utxos: Utxo[], feeRate: FeeRate, electrsUrl: string, sparkClient?: SparkServiceClient, network?: any): Promise<FeeBumpTxChain[]>;
+declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
+    feeBumpPsbt: string;
+    usedUtxos: Utxo[];
+    correctedParentTx?: string;
+};
+
+declare function getSparkAddressFromTaproot(taprootAddress: string): SparkAddressFormat;
+
+interface FetchOwnedTokenOutputsParams {
+    ownerPublicKeys: Uint8Array[];
+    issuerPublicKeys?: Uint8Array[];
+    tokenIdentifiers?: Uint8Array[];
+}
+interface QueryTokenTransactionsParams {
+    ownerPublicKeys?: string[];
+    issuerPublicKeys?: string[];
+    tokenTransactionHashes?: string[];
+    tokenIdentifiers?: string[];
+    outputIds?: string[];
+}
+declare class TokenTransactionService {
+    protected readonly config: WalletConfigService;
+    protected readonly connectionManager: ConnectionManager;
+    constructor(config: WalletConfigService, connectionManager: ConnectionManager);
+    tokenTransfer(tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>, receiverOutputs: {
+        tokenPublicKey: string;
+        tokenAmount: bigint;
+        receiverSparkAddress: string;
+    }[], outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST", selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
+    constructTransferTokenTransactionV0(selectedOutputs: OutputWithPreviousTransactionData[], tokenOutputData: Array<{
+        receiverSparkAddress: Uint8Array;
+        tokenPublicKey: Uint8Array;
+        tokenAmount: bigint;
+    }>): Promise<TokenTransaction>;
+    constructTransferTokenTransaction(selectedOutputs: OutputWithPreviousTransactionData[], tokenOutputData: Array<{
+        receiverSparkAddress: Uint8Array;
+        tokenPublicKey: Uint8Array;
+        tokenAmount: bigint;
+    }>): Promise<TokenTransaction$1>;
+    collectOperatorIdentityPublicKeys(): Uint8Array[];
+    broadcastTokenTransaction(tokenTransaction: TokenTransaction | TokenTransaction$1, outputsToSpendSigningPublicKeys?: Uint8Array[], outputsToSpendCommitments?: Uint8Array[]): Promise<string>;
+    private broadcastTokenTransactionV0;
+    private broadcastTokenTransactionV1;
+    private startTokenTransactionV0;
+    private startTokenTransaction;
+    private signTokenTransactionV0;
+    private signTokenTransaction;
+    fetchOwnedTokenOutputs(params: FetchOwnedTokenOutputsParams): Promise<OutputWithPreviousTransactionData[]>;
+    queryTokenTransactions(params: QueryTokenTransactionsParams): Promise<TokenTransactionWithStatus[] | TokenTransactionWithStatus$1[]>;
+    private fetchOwnedTokenOutputsV0;
+    private fetchOwnedTokenOutputsV1;
+    private queryTokenTransactionsV0;
+    private queryTokenTransactionsV1;
+    syncTokenOutputs(tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>): Promise<void>;
+    selectTokenOutputs(tokenOutputs: OutputWithPreviousTransactionData[], tokenAmount: bigint, strategy: "SMALL_FIRST" | "LARGE_FIRST"): OutputWithPreviousTransactionData[];
+    private sortTokenOutputsByStrategy;
+    private signMessageWithKey;
+    private finalizeTokenTransaction;
+    private createSignaturesForOperators;
 }
 
-export { InitWalletResponse, SparkWallet };
+export { AuthenticationError, type BroadcastConfig, type BroadcastResult, ConfigurationError, ConnectionManager, DEFAULT_FEE_SATS, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, InternalValidationError, type LeafInfo, Network, NetworkError, NotImplementedError, RPCError, SigningCommitment, SigningNonce, SparkAddressFormat, SparkSDKError, TokenBalanceMap, TokenTransactionService, type TxChain, type Utxo, ValidationError, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, lastKeyWithTarget, maybeApplyFee, proofOfPossessionMessageHashForDepositAddress, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, validateOutboundAdaptorSignature };