@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/src/services/connection.ts

@@ -1,4 +1,4 @@
-import { isNode } from "@lightsparkdev/core";
+import { isError, isNode } from "@lightsparkdev/core";
 import { sha256 } from "@noble/hashes/sha2";
 import type { Channel, ClientFactory } from "nice-grpc";
 import { retryMiddleware } from "nice-grpc-client-middleware-retry";
@@ -23,6 +23,10 @@ import {
   SparkTokenServiceDefinition,
 } from "../proto/spark_token.js";
 
+type SparkAuthnServiceClientWithClose = SparkAuthnServiceClient & {
+  close?: () => void;
+};
+
 export class ConnectionManager {
   private config: WalletConfigService;
   private clients: Map<
@@ -52,6 +56,9 @@ export class ConnectionManager {
     }
   > = new Map();
 
+  // Tracks in-flight authenticate() promises so concurrent callers share one
+  private authPromises: Map<string, Promise<string>> = new Map();
+
   constructor(config: WalletConfigService) {
     this.config = config;
   }
@@ -231,57 +238,105 @@ export class ConnectionManager {
   }
 
   private async authenticate(address: string, certPath?: string) {
-    try {
-      const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-      const sparkAuthnClient = await this.createSparkAuthnGrpcConnection(
-        address,
-        certPath,
-      );
+    const existing = this.authPromises.get(address);
+    if (existing) {
+      return existing;
+    }
+
+    const authPromise = (async () => {
+      const MAX_ATTEMPTS = 3;
+      let lastError: Error | undefined;
+
+      /* React Native can cause some outgoing requests to be paused which can result
+         in challenges expiring, so we'll retry any authentication failures: */
+      for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        let sparkAuthnClient: SparkAuthnServiceClientWithClose | undefined;
+        try {
+          const identityPublicKey =
+            await this.config.signer.getIdentityPublicKey();
+          sparkAuthnClient = await this.createSparkAuthnGrpcConnection(
+            address,
+            certPath,
+          );
 
-      const challengeResp = await sparkAuthnClient.get_challenge({
-        publicKey: identityPublicKey,
-      });
+          const challengeResp = await sparkAuthnClient.get_challenge({
+            publicKey: identityPublicKey,
+          });
 
-      if (!challengeResp.protectedChallenge?.challenge) {
-        throw new AuthenticationError("Invalid challenge response", {
-          endpoint: "get_challenge",
-          reason: "Missing challenge in response",
-        });
-      }
+          if (!challengeResp.protectedChallenge?.challenge) {
+            throw new AuthenticationError("Invalid challenge response", {
+              endpoint: "get_challenge",
+              reason: "Missing challenge in response",
+            });
+          }
 
-      const challengeBytes = Challenge.encode(
-        challengeResp.protectedChallenge.challenge,
-      ).finish();
-      const hash = sha256(challengeBytes);
+          const challengeBytes = Challenge.encode(
+            challengeResp.protectedChallenge.challenge,
+          ).finish();
+          const hash = sha256(challengeBytes);
 
-      const derSignatureBytes =
-        await this.config.signer.signMessageWithIdentityKey(hash);
+          const derSignatureBytes =
+            await this.config.signer.signMessageWithIdentityKey(hash);
 
-      const verifyResp = await sparkAuthnClient.verify_challenge({
-        protectedChallenge: challengeResp.protectedChallenge,
-        signature: derSignatureBytes,
-        publicKey: identityPublicKey,
-      });
+          const verifyResp = await sparkAuthnClient.verify_challenge({
+            protectedChallenge: challengeResp.protectedChallenge,
+            signature: derSignatureBytes,
+            publicKey: identityPublicKey,
+          });
+
+          sparkAuthnClient.close?.();
+          return verifyResp.sessionToken;
+        } catch (error: unknown) {
+          if (isError(error)) {
+            sparkAuthnClient?.close?.();
+
+            if (error.message.includes("challenge expired")) {
+              console.warn(
+                `Authentication attempt ${attempt + 1} failed due to expired challenge, retrying...`,
+              );
+              lastError = error;
+              continue;
+            }
+
+            throw new AuthenticationError(
+              "Authentication failed",
+              {
+                endpoint: "authenticate",
+                reason: error.message,
+              },
+              error,
+            );
+          } else {
+            lastError = new Error(
+              `Unknown error during authentication: ${String(error)}`,
+            );
+          }
+        }
+      }
 
-      sparkAuthnClient.close?.();
-      return verifyResp.sessionToken;
-    } catch (error: any) {
-      console.error("Authentication error:", error);
       throw new AuthenticationError(
-        "Authentication failed",
+        "Authentication failed after retrying expired challenges",
         {
           endpoint: "authenticate",
-          reason: error.message,
+          reason: lastError?.message ?? "Unknown error",
         },
-        error,
+        lastError,
       );
+    })();
+
+    this.authPromises.set(address, authPromise);
+
+    try {
+      return await authPromise;
+    } finally {
+      this.authPromises.delete(address);
     }
   }
 
   private async createSparkAuthnGrpcConnection(
     address: string,
     certPath?: string,
-  ): Promise<SparkAuthnServiceClient & { close?: () => void }> {
+  ): Promise<SparkAuthnServiceClientWithClose> {
     const channel = await this.createChannelWithTLS(address, certPath);
     const authnMiddleware = this.createAuthnMiddleware();
     return this.createGrpcClient<SparkAuthnServiceClient>(
@@ -335,6 +390,32 @@ export class ConnectionManager {
     }
   }
 
+  private async *handleMiddlewareError(
+    error: unknown,
+    address: string,
+    call: ClientMiddlewareCall<any, any>,
+    metadata: Metadata,
+    options: SparkCallOptions,
+  ) {
+    if (isError(error)) {
+      if (error.message.includes("token has expired")) {
+        const newAuthToken = await this.authenticate(address);
+        const clientData = this.clients.get(address);
+        if (!clientData) {
+          throw new Error(`No client found for address: ${address}`);
+        }
+        clientData.authToken = newAuthToken;
+
+        return yield* call.next(call.request, {
+          ...options,
+          metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`),
+        });
+      }
+    }
+
+    throw error;
+  }
+
   private createNodeMiddleware(address: string, initialAuthToken: string) {
     return async function* (
       this: ConnectionManager,
@@ -353,21 +434,14 @@ export class ConnectionManager {
             `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`,
           ),
         });
-      } catch (error: any) {
-        if (error.message?.includes("token has expired")) {
-          const newAuthToken = await this.authenticate(address);
-          const clientData = this.clients.get(address);
-          if (!clientData) {
-            throw new Error(`No client found for address: ${address}`);
-          }
-          clientData.authToken = newAuthToken;
-
-          return yield* call.next(call.request, {
-            ...options,
-            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`),
-          });
-        }
-        throw error;
+      } catch (error: unknown) {
+        return yield* this.handleMiddlewareError(
+          error,
+          address,
+          call,
+          metadata,
+          options,
+        );
       }
     }.bind(this);
   }
@@ -393,20 +467,13 @@ export class ConnectionManager {
           ),
         });
       } catch (error: any) {
-        if (error.message?.includes("token has expired")) {
-          const newAuthToken = await this.authenticate(address);
-          const clientData = this.clients.get(address);
-          if (!clientData) {
-            throw new Error(`No client found for address: ${address}`);
-          }
-          clientData.authToken = newAuthToken;
-
-          return yield* call.next(call.request, {
-            ...options,
-            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`),
-          });
-        }
-        throw error;
+        return yield* this.handleMiddlewareError(
+          error,
+          address,
+          call,
+          metadata,
+          options,
+        );
       }
     }.bind(this);
   }

package/src/services/lightning.ts

@@ -25,8 +25,6 @@ import { SigningService } from "./signing.js";
 import type { LeafKeyTweak } from "./transfer.js";
 import { decodeInvoice } from "./bolt11-spark.js";
 
-const crypto = getCrypto();
-
 export type CreateLightningInvoiceParams = {
   invoiceCreator: (
     amountSats: number,
@@ -76,6 +74,7 @@ export class LightningService {
     receiverIdentityPubkey,
     descriptionHash,
   }: CreateLightningInvoiceParams): Promise<LightningReceiveRequest> {
+    const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
     const preimage = numberToBytesBE(
       bytesToNumberBE(randBytes) % secp256k1.CURVE.n,

package/src/services/token-transactions.ts

@@ -20,7 +20,7 @@ import {
   hashTokenTransaction,
 } from "../utils/token-hashing.js";
 import {
-  calculateAvailableTokenAmount,
+  sumAvailableTokens,
   checkIfSelectedOutputsAreAvailable,
 } from "../utils/token-transactions.js";
 import {
@@ -36,7 +36,7 @@ import {
 } from "../errors/types.js";
 import { SigningOperator } from "./wallet-config.js";
 import { hexToBytes } from "@noble/hashes/utils";
-import { decodeSparkAddress } from "../address/index.js";
+import { decodeSparkAddress } from "../utils/address.js";
 import {
   TokenTransaction,
   SignatureWithIndex,
@@ -142,7 +142,7 @@ export class TokenTransactionService {
 
       // Take only the first MAX_TOKEN_OUTPUTS and calculate their total
       const maxOutputsToUse = sortedOutputs.slice(0, MAX_TOKEN_OUTPUTS);
-      const maxAmount = calculateAvailableTokenAmount(maxOutputsToUse);
+      const maxAmount = sumAvailableTokens(maxOutputsToUse);
 
       throw new ValidationError(
         `Cannot transfer more than ${MAX_TOKEN_OUTPUTS} TTXOs in a single transaction (${outputsToUse.length} selected). Maximum transferable amount is: ${maxAmount}`,
@@ -204,7 +204,7 @@ export class TokenTransactionService {
       (a, b) => a.previousTransactionVout - b.previousTransactionVout,
     );
 
-    const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
+    const availableTokenAmount = sumAvailableTokens(selectedOutputs);
     const totalRequestedAmount = tokenOutputData.reduce(
       (sum, output) => sum + output.tokenAmount,
       0n,
@@ -255,7 +255,7 @@ export class TokenTransactionService {
       (a, b) => a.previousTransactionVout - b.previousTransactionVout,
     );
 
-    const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
+    const availableTokenAmount = sumAvailableTokens(selectedOutputs);
     const totalRequestedAmount = tokenOutputData.reduce(
       (sum, output) => sum + output.tokenAmount,
       0n,
@@ -1106,10 +1106,10 @@ export class TokenTransactionService {
     tokenAmount: bigint,
     strategy: "SMALL_FIRST" | "LARGE_FIRST",
   ): OutputWithPreviousTransactionData[] {
-    if (calculateAvailableTokenAmount(tokenOutputs) < tokenAmount) {
+    if (sumAvailableTokens(tokenOutputs) < tokenAmount) {
       throw new ValidationError("Insufficient token amount", {
         field: "tokenAmount",
-        value: calculateAvailableTokenAmount(tokenOutputs),
+        value: sumAvailableTokens(tokenOutputs),
         expected: tokenAmount,
       });
     }

package/src/services/transfer.ts

@@ -36,7 +36,7 @@ import {
   TransferType,
   TreeNode,
 } from "../proto/spark.js";
-import { SigningCommitment } from "../signer/signer.js";
+import type { SigningCommitment } from "../signer/types.js";
 import {
   getSigHashFromTx,
   getTxFromRawTxBytes,

package/src/services/tree-creation.ts

@@ -16,7 +16,7 @@ import {
   SigningJob,
   TreeNode,
 } from "../proto/spark.js";
-import { SigningCommitment } from "../signer/signer.js";
+import { SigningCommitment } from "../signer/types.js";
 import {
   getP2TRAddressFromPublicKey,
   getSigHashFromTx,

package/src/services/wallet-config.ts

@@ -52,7 +52,7 @@ export const ELECTRS_CREDENTIALS = {
 export function getElectrsUrl(network: NetworkType): string {
   switch (network) {
     case "LOCAL":
-      return isHermeticTest()
+      return isHermeticTest
         ? "http://mempool.minikube.local/api"
         : URL_CONFIG.LOCAL.ELECTRS;
     case "REGTEST":
@@ -106,7 +106,7 @@ export function getSspIdentityPublicKey(network: NetworkType): string {
 export function getSspUrl(network: NetworkType): string {
   switch (network) {
     case "LOCAL":
-      return isHermeticTest()
+      return isHermeticTest
         ? "http://app.minikube.local"
         : URL_CONFIG.LOCAL.SSP;
     case "REGTEST":
@@ -163,10 +163,10 @@ const PROD_PUBKEYS = [
 ];
 
 function getLocalFrostSignerAddress(): string {
-  return isHermeticTest() ? "localhost:9999" : "unix:///tmp/frost_0.sock";
+  return isHermeticTest ? "localhost:9999" : "unix:///tmp/frost_0.sock";
 }
 
-export const BASE_CONFIG: Required<ConfigOptions> = {
+const BASE_CONFIG: Required<ConfigOptions> = {
   network: "LOCAL",
   lrc20Address: getLrc20Url("LOCAL"),
   coodinatorIdentifier:
@@ -175,7 +175,7 @@ export const BASE_CONFIG: Required<ConfigOptions> = {
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
-  tokenTransactionVersion: "V0",
+  tokenTransactionVersion: "V1",
   tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 10000,
@@ -192,23 +192,23 @@ export const BASE_CONFIG: Required<ConfigOptions> = {
   },
 };
 
-export const LOCAL_WALLET_CONFIG: Required<ConfigOptions> = {
+const LOCAL_WALLET_CONFIG: Required<ConfigOptions> = {
   ...BASE_CONFIG,
   threshold: 3,
 };
 
-export const LOCAL_WALLET_CONFIG_SCHNORR: Required<ConfigOptions> = {
+const LOCAL_WALLET_CONFIG_SCHNORR: Required<ConfigOptions> = {
   ...LOCAL_WALLET_CONFIG,
   threshold: 3, // 3 for issuance tests.
 };
 
-export const LOCAL_WALLET_CONFIG_ECDSA: Required<ConfigOptions> = {
+const LOCAL_WALLET_CONFIG_ECDSA: Required<ConfigOptions> = {
   ...LOCAL_WALLET_CONFIG,
   tokenSignatures: "ECDSA",
   threshold: 3, // 3 for issuance tests.
 };
 
-export const REGTEST_WALLET_CONFIG: Required<ConfigOptions> = {
+const REGTEST_WALLET_CONFIG: Required<ConfigOptions> = {
   ...BASE_CONFIG,
   network: "REGTEST",
   lrc20Address: getLrc20Url("REGTEST"),
@@ -227,7 +227,7 @@ export const REGTEST_WALLET_CONFIG: Required<ConfigOptions> = {
   },
 };
 
-export const MAINNET_WALLET_CONFIG: Required<ConfigOptions> = {
+const MAINNET_WALLET_CONFIG: Required<ConfigOptions> = {
   ...BASE_CONFIG,
   network: "MAINNET",
   lrc20Address: getLrc20Url("MAINNET"),
@@ -245,6 +245,14 @@ export const MAINNET_WALLET_CONFIG: Required<ConfigOptions> = {
   },
 };
 
+export const WalletConfig = {
+  LOCAL: LOCAL_WALLET_CONFIG,
+  LOCAL_SCHNORR: LOCAL_WALLET_CONFIG_SCHNORR,
+  LOCAL_ECDSA: LOCAL_WALLET_CONFIG_ECDSA,
+  REGTEST: REGTEST_WALLET_CONFIG,
+  MAINNET: MAINNET_WALLET_CONFIG,
+};
+
 function getSigningOperators(): Record<string, SigningOperator> {
   return {
     "0000000000000000000000000000000000000000000000000000000000000001": {

package/src/signer/signer.react-native.ts

@@ -2,11 +2,8 @@ import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { ValidationError } from "../errors/index.js";
 import { NativeSparkFrost } from "../spark_bindings/native/index.js";
 import { IKeyPackage } from "../spark_bindings/types.js";
-import {
-  AggregateFrostParams,
-  DefaultSparkSigner,
-  SignFrostParams,
-} from "./signer.js";
+import { DefaultSparkSigner } from "./signer.js";
+import type { AggregateFrostParams, SignFrostParams } from "./types.js";
 
 export class ReactNativeSparkSigner extends DefaultSparkSigner {
   async signFrost({

package/src/signer/signer.ts

@@ -12,7 +12,7 @@ import * as ecies from "eciesjs";
 import { isReactNative } from "../constants.js";
 import { ConfigurationError, ValidationError } from "../errors/types.js";
 import { TreeNode } from "../proto/spark.js";
-import { IKeyPackage, ISigningCommitment } from "../spark_bindings/types.js";
+import { IKeyPackage } from "../spark_bindings/types.js";
 import { generateAdaptorFromSignature } from "../utils/adaptor-signature.js";
 import { subtractPrivateKeys } from "../utils/keys.js";
 import {
@@ -23,19 +23,6 @@ import {
   getRandomSigningNonce,
   getSigningCommitmentFromNonce,
 } from "../utils/signing.js";
-
-let sparkFrostModule: any = undefined;
-const getSparkFrostModule = async () => {
-  if (isReactNative) {
-    return undefined;
-  }
-  if (!sparkFrostModule) {
-    // Use dynamic import
-    sparkFrostModule = await import("../spark_bindings/wasm/index.js");
-  }
-  return sparkFrostModule;
-};
-
 import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
 import {
   fromPrivateKey,
@@ -47,53 +34,26 @@ import { sha256 } from "@noble/hashes/sha2";
 import { Transaction } from "@scure/btc-signer";
 import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
 import type { Psbt } from "bitcoinjs-lib";
+import type {
+  AggregateFrostParams,
+  DerivedHDKey,
+  KeyPair,
+  SignFrostParams,
+  SigningCommitment,
+  SigningNonce,
+  SplitSecretWithProofsParams,
+} from "./types.js";
 
-export { Receipt, PARITY, fromPrivateKey } from "@buildonspark/lrc20-sdk";
-export { MultisigReceiptInput } from "@buildonspark/lrc20-sdk/lrc/types";
-
-export type SigningNonce = {
-  binding: Uint8Array;
-  hiding: Uint8Array;
-};
-
-export type SigningCommitment = {
-  binding: Uint8Array;
-  hiding: Uint8Array;
-};
-
-export type SignFrostParams = {
-  message: Uint8Array;
-  privateAsPubKey: Uint8Array;
-  publicKey: Uint8Array;
-  verifyingKey: Uint8Array;
-  selfCommitment: ISigningCommitment;
-  statechainCommitments?: { [key: string]: ISigningCommitment } | undefined;
-  adaptorPubKey?: Uint8Array | undefined;
-};
-
-export type AggregateFrostParams = Omit<SignFrostParams, "privateAsPubKey"> & {
-  selfSignature: Uint8Array;
-  statechainSignatures?: { [key: string]: Uint8Array } | undefined;
-  statechainPublicKeys?: { [key: string]: Uint8Array } | undefined;
-};
-
-export type SplitSecretWithProofsParams = {
-  secret: Uint8Array;
-  curveOrder: bigint;
-  threshold: number;
-  numShares: number;
-  isSecretPubkey?: boolean;
-};
-
-type DerivedHDKey = {
-  hdKey: HDKey;
-  privateKey: Uint8Array;
-  publicKey: Uint8Array;
-};
-
-type KeyPair = {
-  privateKey: Uint8Array;
-  publicKey: Uint8Array;
+let sparkFrostModule: any = undefined;
+const getSparkFrostModule = async () => {
+  if (isReactNative) {
+    return undefined;
+  }
+  if (!sparkFrostModule) {
+    // Use dynamic import
+    sparkFrostModule = await import("../spark_bindings/wasm/index.js");
+  }
+  return sparkFrostModule;
 };
 
 interface SparkKeysGenerator {
@@ -178,6 +138,80 @@ class DefaultSparkKeysGenerator implements SparkKeysGenerator {
   }
 }
 
+class DerivationPathKeysGenerator implements SparkKeysGenerator {
+  constructor(private readonly derivationPathTemplate: string) {}
+
+  async deriveKeysFromSeed(
+    seed: Uint8Array,
+    accountNumber: number,
+  ): Promise<{
+    masterPublicKey: Uint8Array;
+    identityKey: KeyPair;
+    signingHDKey: DerivedHDKey;
+    depositKey: KeyPair;
+    staticDepositHDKey: DerivedHDKey;
+  }> {
+    const hdkey = HDKey.fromMasterSeed(seed);
+
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new ValidationError("Failed to derive keys from seed", {
+        field: "hdkey",
+        value: seed,
+      });
+    }
+
+    const derivationPath = this.derivationPathTemplate.replaceAll(
+      "?",
+      accountNumber.toString(),
+    );
+
+    const identityKey = hdkey.derive(derivationPath);
+    const signingKey = hdkey.derive(`${derivationPath}/1'`);
+    const depositKey = hdkey.derive(`${derivationPath}/2'`);
+    const staticDepositKey = hdkey.derive(`${derivationPath}/3'`);
+
+    if (
+      !identityKey.privateKey ||
+      !identityKey.publicKey ||
+      !signingKey.privateKey ||
+      !signingKey.publicKey ||
+      !depositKey.privateKey ||
+      !depositKey.publicKey ||
+      !staticDepositKey.privateKey ||
+      !staticDepositKey.publicKey
+    ) {
+      throw new ValidationError(
+        "Failed to derive all required keys from seed",
+        {
+          field: "derivedKeys",
+        },
+      );
+    }
+
+    return {
+      masterPublicKey: hdkey.publicKey,
+      identityKey: {
+        privateKey: identityKey.privateKey,
+        publicKey: identityKey.publicKey,
+      },
+      signingHDKey: {
+        hdKey: signingKey,
+        privateKey: signingKey.privateKey,
+        publicKey: signingKey.publicKey,
+      },
+      depositKey: {
+        privateKey: depositKey.privateKey,
+        publicKey: depositKey.publicKey,
+      },
+      staticDepositHDKey: {
+        hdKey: staticDepositKey,
+        privateKey: staticDepositKey.privateKey,
+        publicKey: staticDepositKey.publicKey,
+      },
+    };
+  }
+}
+
 class TaprootOutputKeysGenerator implements SparkKeysGenerator {
   constructor(private readonly useAddressIndex: boolean = false) {}
 
@@ -931,10 +965,50 @@ class DefaultSparkSigner implements SparkSigner {
 }
 
 class TaprootSparkSigner extends DefaultSparkSigner {
-  constructor() {
-    super({ sparkKeysGenerator: new TaprootOutputKeysGenerator() });
+  constructor(useAddressIndex = false) {
+    super({
+      sparkKeysGenerator: new TaprootOutputKeysGenerator(useAddressIndex),
+    });
+  }
+}
+
+class NativeSegwitSparkSigner extends DefaultSparkSigner {
+  constructor(useAddressIndex = false) {
+    super({
+      sparkKeysGenerator: new DerivationPathKeysGenerator(
+        useAddressIndex ? "m/84'/0'/0'/0/?" : "m/84'/0'/?'/0/0",
+      ),
+    });
+  }
+}
+
+class WrappedSegwitSparkSigner extends DefaultSparkSigner {
+  constructor(useAddressIndex = false) {
+    super({
+      sparkKeysGenerator: new DerivationPathKeysGenerator(
+        useAddressIndex ? "m/49'/0'/0'/0/?" : "m/49'/0'/?'/0/0",
+      ),
+    });
   }
 }
 
-export { DefaultSparkSigner, TaprootSparkSigner, TaprootOutputKeysGenerator };
-export type { SparkSigner, TokenSigner };
+class LegacyBitcoinSparkSigner extends DefaultSparkSigner {
+  constructor(useAddressIndex = false) {
+    super({
+      sparkKeysGenerator: new DerivationPathKeysGenerator(
+        useAddressIndex ? "m/44'/0'/0'/0/?" : "m/44'/0'/?'/0/0",
+      ),
+    });
+  }
+}
+
+export {
+  DefaultSparkSigner,
+  TaprootSparkSigner,
+  NativeSegwitSparkSigner,
+  WrappedSegwitSparkSigner,
+  LegacyBitcoinSparkSigner,
+  TaprootOutputKeysGenerator,
+  type SparkSigner,
+  type TokenSigner,
+};