@buildonspark/spark-sdk 0.0.15 → 0.0.17

package/src/services/wallet-config.ts

@@ -0,0 +1,143 @@
+import { hexToBytes } from "@noble/curves/abstract/utils";
+import { NetworkType } from "../utils/network.js";
+
+export type SigningOperator = {
+  readonly id: number;
+  readonly identifier: string;
+  readonly address: string;
+  readonly identityPublicKey: Uint8Array;
+};
+
+export type ConfigOptions = {
+  readonly network?: NetworkType;
+  readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
+  readonly coodinatorIdentifier?: string;
+  readonly frostSignerAddress?: string;
+  readonly lrc20Address?: string;
+  readonly threshold?: number;
+  readonly useTokenTransactionSchnorrSignatures?: boolean;
+  readonly enableLrc20?: boolean;
+};
+
+const BASE_CONFIG: Required<ConfigOptions> = {
+  network: "LOCAL",
+  lrc20Address: "http://127.0.0.1:18530",
+  coodinatorIdentifier:
+    "0000000000000000000000000000000000000000000000000000000000000001",
+  frostSignerAddress: "unix:///tmp/frost_0.sock",
+  threshold: 3,
+  signingOperators: getLocalSigningOperators(),
+  useTokenTransactionSchnorrSignatures: true,
+  enableLrc20: true,
+};
+
+export const LOCAL_WALLET_CONFIG: Required<ConfigOptions> = {
+  ...BASE_CONFIG,
+};
+
+export const LOCAL_WALLET_CONFIG_SCHNORR: Required<ConfigOptions> = {
+  ...BASE_CONFIG,
+};
+
+export const LOCAL_WALLET_CONFIG_ECDSA: Required<ConfigOptions> = {
+  ...BASE_CONFIG,
+  useTokenTransactionSchnorrSignatures: false,
+};
+
+export const REGTEST_WALLET_CONFIG: Required<ConfigOptions> = {
+  ...BASE_CONFIG,
+  network: "REGTEST",
+  signingOperators: getRegtestSigningOperators(),
+};
+
+export const MAINNET_WALLET_CONFIG: Required<ConfigOptions> = {
+  ...BASE_CONFIG,
+  network: "MAINNET",
+  signingOperators: getRegtestSigningOperators(),
+};
+
+export function getRegtestSigningOperators(): Record<string, SigningOperator> {
+  const pubkeys = [
+    "03acd9a5a88db102730ff83dee69d69088cc4c9d93bbee893e90fd5051b7da9651",
+    "02d2d103cacb1d6355efeab27637c74484e2a7459e49110c3fe885210369782e23",
+    "0350f07ffc21bfd59d31e0a7a600e2995273938444447cb9bc4c75b8a895dbb853",
+  ];
+
+  const pubkeyBytesArray = pubkeys.map((pubkey) => hexToBytes(pubkey));
+
+  return {
+    "0000000000000000000000000000000000000000000000000000000000000001": {
+      id: 0,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000001",
+      address: "https://0.spark.dev.dev.sparkinfra.net",
+
+      identityPublicKey: pubkeyBytesArray[0]!,
+    },
+    "0000000000000000000000000000000000000000000000000000000000000002": {
+      id: 1,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000002",
+      address: "https://1.spark.dev.dev.sparkinfra.net",
+
+      identityPublicKey: pubkeyBytesArray[1]!,
+    },
+    "0000000000000000000000000000000000000000000000000000000000000003": {
+      id: 2,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000003",
+      address: "https://2.spark.dev.dev.sparkinfra.net",
+      identityPublicKey: pubkeyBytesArray[2]!,
+    },
+  };
+}
+
+export function getLocalSigningOperators(): Record<string, SigningOperator> {
+  const pubkeys = [
+    "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
+    "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
+    "0305ab8d485cc752394de4981f8a5ae004f2becfea6f432c9a59d5022d8764f0a6",
+    "0352aef4d49439dedd798ac4aef1e7ebef95f569545b647a25338398c1247ffdea",
+    "02c05c88cc8fc181b1ba30006df6a4b0597de6490e24514fbdd0266d2b9cd3d0ba",
+  ];
+
+  const pubkeyBytesArray = pubkeys.map((pubkey) => hexToBytes(pubkey));
+
+  return {
+    "0000000000000000000000000000000000000000000000000000000000000001": {
+      id: 0,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000001",
+      address: "https://localhost:8535",
+      identityPublicKey: pubkeyBytesArray[0]!,
+    },
+    "0000000000000000000000000000000000000000000000000000000000000002": {
+      id: 1,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000002",
+      address: "https://localhost:8536",
+      identityPublicKey: pubkeyBytesArray[1]!,
+    },
+    "0000000000000000000000000000000000000000000000000000000000000003": {
+      id: 2,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000003",
+      address: "https://localhost:8537",
+      identityPublicKey: pubkeyBytesArray[2]!,
+    },
+    "0000000000000000000000000000000000000000000000000000000000000004": {
+      id: 3,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000004",
+      address: "https://localhost:8538",
+      identityPublicKey: pubkeyBytesArray[3]!,
+    },
+    "0000000000000000000000000000000000000000000000000000000000000005": {
+      id: 4,
+      identifier:
+        "0000000000000000000000000000000000000000000000000000000000000005",
+      address: "https://localhost:8539",
+      identityPublicKey: pubkeyBytesArray[4]!,
+    },
+  };
+}

package/src/signer/signer.ts

@@ -0,0 +1,532 @@
+import {
+  bytesToHex,
+  bytesToNumberBE,
+  hexToBytes,
+} from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { HDKey } from "@scure/bip32";
+import * as bip39 from "@scure/bip39";
+import { generateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { sha256 } from "@scure/btc-signer/utils";
+import { Buffer } from "buffer";
+import * as ecies from "eciesjs";
+import { TreeNode } from "../proto/spark.js";
+import { generateAdaptorFromSignature } from "../utils/adaptor-signature.js";
+import { getMasterHDKeyFromSeed, subtractPrivateKeys } from "../utils/keys.js";
+import { Network } from "../utils/network.js";
+import {
+  splitSecretWithProofs,
+  VerifiableSecretShare,
+} from "../utils/secret-sharing.js";
+import {
+  createWasmSigningCommitment,
+  createWasmSigningNonce,
+  getRandomSigningNonce,
+  getSigningCommitmentFromNonce,
+} from "../utils/signing.js";
+import { aggregateFrost, signFrost } from "../utils/wasm.js";
+import { KeyPackage } from "../wasm/spark_bindings.js";
+globalThis.Buffer = Buffer;
+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: SigningCommitment;
+  statechainCommitments?: { [key: string]: SigningCommitment } | 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;
+};
+
+// TODO: Properly clean up keys when they are no longer needed
+interface SparkSigner {
+  getIdentityPublicKey(): Promise<Uint8Array>;
+  getDepositSigningKey(): Promise<Uint8Array>;
+
+  generateMnemonic(): Promise<string>;
+  mnemonicToSeed(mnemonic: string): Promise<Uint8Array>;
+
+  createSparkWalletFromSeed(
+    seed: Uint8Array | string,
+    network: Network,
+  ): Promise<string>;
+
+  restoreSigningKeysFromLeafs(leafs: TreeNode[]): Promise<void>;
+  getTrackedPublicKeys(): Promise<Uint8Array[]>;
+  // Generates a new private key, and returns the public key
+  generatePublicKey(hash?: Uint8Array): Promise<Uint8Array>;
+  // Called when a public key is no longer needed
+  removePublicKey(publicKey: Uint8Array): Promise<void>;
+  getSchnorrPublicKey(publicKey: Uint8Array): Promise<Uint8Array>;
+
+  signSchnorr(message: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+  signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array>;
+
+  subtractPrivateKeysGivenPublicKeys(
+    first: Uint8Array,
+    second: Uint8Array,
+  ): Promise<Uint8Array>;
+  splitSecretWithProofs(
+    params: SplitSecretWithProofsParams,
+  ): Promise<VerifiableSecretShare[]>;
+
+  signFrost(params: SignFrostParams): Promise<Uint8Array>;
+  aggregateFrost(params: AggregateFrostParams): Promise<Uint8Array>;
+
+  signMessageWithPublicKey(
+    message: Uint8Array,
+    publicKey: Uint8Array,
+    compact?: boolean,
+  ): Promise<Uint8Array>;
+  // If compact is true, the signature should be in ecdsa compact format else it should be in DER format
+  signMessageWithIdentityKey(
+    message: Uint8Array,
+    compact?: boolean,
+  ): Promise<Uint8Array>;
+
+  encryptLeafPrivateKeyEcies(
+    receiverPublicKey: Uint8Array,
+    publicKey: Uint8Array,
+  ): Promise<Uint8Array>;
+  decryptEcies(ciphertext: Uint8Array): Promise<Uint8Array>;
+
+  getRandomSigningCommitment(): Promise<SigningCommitment>;
+  getSspIdentityPublicKey(network: Network): Promise<Uint8Array>;
+
+  hashRandomPrivateKey(): Promise<Uint8Array>;
+  generateAdaptorFromSignature(signature: Uint8Array): Promise<{
+    adaptorSignature: Uint8Array;
+    adaptorPublicKey: Uint8Array;
+  }>;
+
+  getDepositSigningKey(): Promise<Uint8Array>;
+}
+
+class DefaultSparkSigner implements SparkSigner {
+  private masterKey: HDKey | null = null;
+  private identityKey: HDKey | null = null;
+  private signingKey: HDKey | null = null;
+  private depositKey: HDKey | null = null;
+
+  // <hex, hex>
+  private publicKeyToPrivateKeyMap: Map<string, string> = new Map();
+
+  private commitmentToNonceMap: Map<SigningCommitment, SigningNonce> =
+    new Map();
+
+  private deriveSigningKey(hash: Uint8Array): Uint8Array {
+    if (!this.masterKey) {
+      throw new Error("Private key is not set");
+    }
+
+    const view = new DataView(hash.buffer);
+    const amount = (view.getUint32(0, false) % 0x80000000) + 0x80000000;
+
+    const newPrivateKey = this.signingKey?.deriveChild(amount).privateKey;
+
+    if (!newPrivateKey) {
+      throw new Error("Failed to recover signing key");
+    }
+
+    return newPrivateKey;
+  }
+
+  async restoreSigningKeysFromLeafs(leafs: TreeNode[]) {
+    if (!this.masterKey) {
+      throw new Error("Private key is not set");
+    }
+
+    for (const leaf of leafs) {
+      const hash = sha256(leaf.id);
+      const privateKey = this.deriveSigningKey(hash);
+
+      const publicKey = secp256k1.getPublicKey(privateKey);
+      this.publicKeyToPrivateKeyMap.set(
+        bytesToHex(publicKey),
+        bytesToHex(privateKey),
+      );
+    }
+  }
+
+  async getSchnorrPublicKey(publicKey: Uint8Array): Promise<Uint8Array> {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+
+    return schnorr.getPublicKey(hexToBytes(privateKey));
+  }
+
+  async signSchnorr(
+    message: Uint8Array,
+    publicKey: Uint8Array,
+  ): Promise<Uint8Array> {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+
+    return schnorr.sign(message, hexToBytes(privateKey));
+  }
+
+  async signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array> {
+    if (!this.identityKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+
+    const signature = schnorr.sign(message, this.identityKey.privateKey);
+
+    return signature;
+  }
+
+  async getIdentityPublicKey(): Promise<Uint8Array> {
+    if (!this.identityKey?.publicKey) {
+      throw new Error("Private key is not set");
+    }
+
+    return this.identityKey.publicKey;
+  }
+
+  async getDepositSigningKey(): Promise<Uint8Array> {
+    if (!this.depositKey?.publicKey) {
+      throw new Error("Deposit key is not set");
+    }
+
+    return this.depositKey.publicKey;
+  }
+
+  async generateMnemonic(): Promise<string> {
+    return generateMnemonic(wordlist);
+  }
+
+  async mnemonicToSeed(mnemonic: string): Promise<Uint8Array> {
+    return await bip39.mnemonicToSeed(mnemonic);
+  }
+
+  async getTrackedPublicKeys(): Promise<Uint8Array[]> {
+    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(hexToBytes);
+  }
+
+  async generatePublicKey(hash?: Uint8Array): Promise<Uint8Array> {
+    if (!this.masterKey) {
+      throw new Error("Private key is not set");
+    }
+
+    let newPrivateKey: Uint8Array | null = null;
+    if (hash) {
+      newPrivateKey = this.deriveSigningKey(hash);
+    } else {
+      newPrivateKey = secp256k1.utils.randomPrivateKey();
+    }
+
+    if (!newPrivateKey) {
+      throw new Error("Failed to generate new private key");
+    }
+
+    const publicKey = secp256k1.getPublicKey(newPrivateKey);
+
+    const pubKeyHex = bytesToHex(publicKey);
+    const privKeyHex = bytesToHex(newPrivateKey);
+    this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
+
+    return publicKey;
+  }
+
+  async removePublicKey(publicKey: Uint8Array): Promise<void> {
+    this.publicKeyToPrivateKeyMap.delete(bytesToHex(publicKey));
+  }
+
+  async subtractPrivateKeysGivenPublicKeys(
+    first: Uint8Array,
+    second: Uint8Array,
+  ): Promise<Uint8Array> {
+    const firstPubKeyHex = bytesToHex(first);
+    const secondPubKeyHex = bytesToHex(second);
+
+    const firstPrivateKeyHex =
+      this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
+    const secondPrivateKeyHex =
+      this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
+
+    if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
+      throw new Error("Private key is not set");
+    }
+
+    const firstPrivateKey = hexToBytes(firstPrivateKeyHex);
+    const secondPrivateKey = hexToBytes(secondPrivateKeyHex);
+
+    const resultPrivKey = subtractPrivateKeys(
+      firstPrivateKey,
+      secondPrivateKey,
+    );
+    const resultPubKey = secp256k1.getPublicKey(resultPrivKey);
+
+    const resultPrivKeyHex = bytesToHex(resultPrivKey);
+    const resultPubKeyHex = bytesToHex(resultPubKey);
+    this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
+    return resultPubKey;
+  }
+
+  async splitSecretWithProofs({
+    secret,
+    curveOrder,
+    threshold,
+    numShares,
+    isSecretPubkey = false,
+  }: SplitSecretWithProofsParams): Promise<VerifiableSecretShare[]> {
+    if (isSecretPubkey) {
+      const pubKeyHex = bytesToHex(secret);
+      const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
+      if (!privateKey) {
+        throw new Error("Private key is not set");
+      }
+      secret = hexToBytes(privateKey);
+    }
+    const secretAsInt = bytesToNumberBE(secret);
+    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
+  }
+
+  async signFrost({
+    message,
+    privateAsPubKey,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+  }: SignFrostParams): Promise<Uint8Array> {
+    const privateAsPubKeyHex = bytesToHex(privateAsPubKey);
+    const signingPrivateKey =
+      this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
+
+    if (!signingPrivateKey) {
+      throw new Error("Private key is not set");
+    }
+
+    const nonce = this.commitmentToNonceMap.get(selfCommitment);
+    if (!nonce) {
+      throw new Error("Nonce is not set");
+    }
+
+    const keyPackage = new KeyPackage(
+      hexToBytes(signingPrivateKey),
+      publicKey,
+      verifyingKey,
+    );
+
+    return signFrost({
+      msg: message,
+      keyPackage,
+      nonce: createWasmSigningNonce(nonce),
+      selfCommitment: createWasmSigningCommitment(selfCommitment),
+      statechainCommitments,
+      adaptorPubKey,
+    });
+  }
+
+  async aggregateFrost({
+    message,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+    selfSignature,
+    statechainSignatures,
+    statechainPublicKeys,
+  }: AggregateFrostParams): Promise<Uint8Array> {
+    return aggregateFrost({
+      msg: message,
+      statechainSignatures,
+      statechainPublicKeys,
+      verifyingKey,
+      statechainCommitments,
+      selfCommitment: createWasmSigningCommitment(selfCommitment),
+      selfPublicKey: publicKey,
+      selfSignature,
+      adaptorPubKey,
+    });
+  }
+
+  async createSparkWalletFromSeed(
+    seed: Uint8Array | string,
+    network: Network,
+  ): Promise<string> {
+    if (typeof seed === "string") {
+      seed = hexToBytes(seed);
+    }
+
+    const hdkey = getMasterHDKeyFromSeed(seed);
+
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new Error("Could not derive private key from seed");
+    }
+
+    const accountType = network === Network.REGTEST ? 0 : 1;
+    const identityKey = hdkey.derive(`m/8797555'/${accountType}'/0'`);
+    const signingKey = hdkey.derive(`m/8797555'/${accountType}'/1'`);
+    const depositKey = hdkey.derive(`m/8797555'/${accountType}'/2'`);
+
+    if (
+      !identityKey.privateKey ||
+      !depositKey.privateKey ||
+      !signingKey.privateKey ||
+      !identityKey.publicKey ||
+      !depositKey.publicKey ||
+      !signingKey.publicKey
+    ) {
+      throw new Error("Could not derive keys from seed");
+    }
+
+    this.masterKey = hdkey;
+    this.identityKey = identityKey;
+    this.depositKey = depositKey;
+    this.signingKey = signingKey;
+
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex(identityKey.publicKey),
+      bytesToHex(identityKey.privateKey),
+    );
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex(depositKey.publicKey),
+      bytesToHex(depositKey.privateKey),
+    );
+
+    return bytesToHex(identityKey.publicKey);
+  }
+
+  async signMessageWithPublicKey(
+    message: Uint8Array,
+    publicKey: Uint8Array,
+    compact?: boolean,
+  ): Promise<Uint8Array> {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex(publicKey));
+    if (!privateKey) {
+      throw new Error(
+        `No private key found for public key: ${bytesToHex(publicKey)}`,
+      );
+    }
+
+    const signature = secp256k1.sign(message, hexToBytes(privateKey));
+
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+
+    return signature.toDERRawBytes();
+  }
+
+  async signMessageWithIdentityKey(
+    message: Uint8Array,
+    compact?: boolean,
+  ): Promise<Uint8Array> {
+    if (!this.identityKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+
+    const signature = secp256k1.sign(message, this.identityKey.privateKey);
+
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+
+    return signature.toDERRawBytes();
+  }
+
+  async encryptLeafPrivateKeyEcies(
+    receiverPublicKey: Uint8Array,
+    publicKey: Uint8Array,
+  ): Promise<Uint8Array> {
+    const publicKeyHex = bytesToHex(publicKey);
+    const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+
+    return ecies.encrypt(receiverPublicKey, hexToBytes(privateKey));
+  }
+
+  async decryptEcies(ciphertext: Uint8Array): Promise<Uint8Array> {
+    if (!this.identityKey?.privateKey) {
+      throw new Error("Private key is not set");
+    }
+    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
+      bytesToHex(this.identityKey.privateKey),
+    );
+    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
+    const publicKey = secp256k1.getPublicKey(privateKey);
+    const publicKeyHex = bytesToHex(publicKey);
+    const privateKeyHex = bytesToHex(privateKey);
+    this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
+    return publicKey;
+  }
+
+  async getRandomSigningCommitment(): Promise<SigningCommitment> {
+    const nonce = getRandomSigningNonce();
+    const commitment = getSigningCommitmentFromNonce(nonce);
+    this.commitmentToNonceMap.set(commitment, nonce);
+    return commitment;
+  }
+
+  // Hardcode this for default ssp
+  async getSspIdentityPublicKey(network: Network): Promise<Uint8Array> {
+    if (network === Network.MAINNET) {
+      return hexToBytes(
+        "02e0b8d42c5d3b5fe4c5beb6ea796ab3bc8aaf28a3d3195407482c67e0b58228a5",
+      );
+    } else {
+      return hexToBytes(
+        "028c094a432d46a0ac95349d792c2e3730bd60c29188db716f56a99e39b95338b4",
+      );
+    }
+  }
+
+  async hashRandomPrivateKey(): Promise<Uint8Array> {
+    return sha256(secp256k1.utils.randomPrivateKey());
+  }
+
+  async generateAdaptorFromSignature(signature: Uint8Array): Promise<{
+    adaptorSignature: Uint8Array;
+    adaptorPublicKey: Uint8Array;
+  }> {
+    const adaptor = generateAdaptorFromSignature(signature);
+
+    const adaptorPublicKey = secp256k1.getPublicKey(adaptor.adaptorPrivateKey);
+
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex(adaptorPublicKey),
+      bytesToHex(adaptor.adaptorPrivateKey),
+    );
+
+    return {
+      adaptorSignature: signature,
+      adaptorPublicKey: adaptorPublicKey,
+    };
+  }
+}
+export { DefaultSparkSigner };
+export type { SparkSigner };