@buildonspark/spark-sdk 0.0.14 → 0.0.16

package/src/services/deposit.ts

@@ -0,0 +1,327 @@
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import * as btc from "@scure/btc-signer";
+import { p2tr, Transaction } from "@scure/btc-signer";
+import { equalBytes, sha256 } from "@scure/btc-signer/utils";
+import { SignatureIntent } from "../proto/common.js";
+import {
+  Address,
+  FinalizeNodeSignaturesResponse,
+  GenerateDepositAddressResponse,
+  StartTreeCreationResponse,
+} from "../proto/spark.js";
+import {
+  getP2TRAddressFromPublicKey,
+  getSigHashFromTx,
+  getTxId,
+} from "../utils/bitcoin.js";
+import { subtractPublicKeys } from "../utils/keys.js";
+import { getNetwork } from "../utils/network.js";
+import { proofOfPossessionMessageHashForDepositAddress } from "../utils/proof.js";
+import { createWasmSigningCommitment } from "../utils/signing.js";
+import { WalletConfigService } from "./config.js";
+import { ConnectionManager } from "./connection.js";
+type ValidateDepositAddressParams = {
+  address: Address;
+  userPubkey: Uint8Array;
+};
+
+export type GenerateDepositAddressParams = {
+  signingPubkey: Uint8Array;
+};
+
+export type CreateTreeRootParams = {
+  signingPubKey: Uint8Array;
+  verifyingKey: Uint8Array;
+  depositTx: Transaction;
+  vout: number;
+};
+
+const INITIAL_TIME_LOCK = 2000;
+
+export class DepositService {
+  private readonly config: WalletConfigService;
+  private readonly connectionManager: ConnectionManager;
+
+  constructor(
+    config: WalletConfigService,
+    connectionManager: ConnectionManager,
+  ) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+
+  private async validateDepositAddress({
+    address,
+    userPubkey,
+  }: ValidateDepositAddressParams) {
+    if (
+      !address.depositAddressProof ||
+      !address.depositAddressProof.proofOfPossessionSignature ||
+      !address.depositAddressProof.addressSignatures
+    ) {
+      throw new Error(
+        "proof of possession signature or address signatures is null",
+      );
+    }
+
+    const operatorPubkey = subtractPublicKeys(address.verifyingKey, userPubkey);
+    const msg = proofOfPossessionMessageHashForDepositAddress(
+      await this.config.signer.getIdentityPublicKey(),
+      operatorPubkey,
+      address.address,
+    );
+
+    const taprootKey = p2tr(
+      operatorPubkey.slice(1, 33),
+      undefined,
+      getNetwork(this.config.getNetwork()),
+    ).tweakedPubkey;
+
+    const isVerified = schnorr.verify(
+      address.depositAddressProof.proofOfPossessionSignature,
+      msg,
+      taprootKey,
+    );
+
+    if (!isVerified) {
+      throw new Error("proof of possession signature verification failed");
+    }
+
+    const addrHash = sha256(address.address);
+    for (const operator of Object.values(this.config.getSigningOperators())) {
+      if (operator.identifier === this.config.getCoordinatorIdentifier()) {
+        continue;
+      }
+
+      const operatorPubkey = operator.identityPublicKey;
+      const operatorSig =
+        address.depositAddressProof.addressSignatures[operator.identifier];
+      if (!operatorSig) {
+        throw new Error("operator signature not found");
+      }
+      const sig = secp256k1.Signature.fromDER(operatorSig);
+
+      const isVerified = secp256k1.verify(sig, addrHash, operatorPubkey);
+      if (!isVerified) {
+        throw new Error("signature verification failed");
+      }
+    }
+  }
+
+  async generateDepositAddress({
+    signingPubkey,
+  }: GenerateDepositAddressParams): Promise<GenerateDepositAddressResponse> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let depositResp: GenerateDepositAddressResponse;
+    try {
+      depositResp = await sparkClient.generate_deposit_address({
+        signingPublicKey: signingPubkey,
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        network: this.config.getNetworkProto(),
+      });
+    } catch (error) {
+      throw new Error(`Error generating deposit address: ${error}`);
+    }
+
+    if (!depositResp.depositAddress) {
+      throw new Error("No deposit address response from coordinator");
+    }
+
+    await this.validateDepositAddress({
+      address: depositResp.depositAddress,
+      userPubkey: signingPubkey,
+    });
+
+    return depositResp;
+  }
+
+  async createTreeRoot({
+    signingPubKey,
+    verifyingKey,
+    depositTx,
+    vout,
+  }: CreateTreeRootParams) {
+    // Create a root tx
+    const rootTx = new Transaction();
+    const output = depositTx.getOutput(vout);
+    if (!output) {
+      throw new Error("No output found in deposit tx");
+    }
+    const script = output.script;
+    const amount = output.amount;
+    if (!script || !amount) {
+      throw new Error("No script or amount found in deposit tx");
+    }
+
+    rootTx.addInput({
+      txid: getTxId(depositTx),
+      index: vout,
+    });
+
+    rootTx.addOutput({
+      script,
+      amount,
+    });
+
+    const rootNonceCommitment =
+      await this.config.signer.getRandomSigningCommitment();
+    const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
+
+    // Create a refund tx
+    const refundTx = new Transaction();
+    const sequence = (1 << 30) | INITIAL_TIME_LOCK;
+    refundTx.addInput({
+      txid: getTxId(rootTx),
+      index: 0,
+      sequence,
+    });
+
+    const refundP2trAddress = getP2TRAddressFromPublicKey(
+      signingPubKey,
+      this.config.getNetwork(),
+    );
+    const refundAddress = btc
+      .Address(getNetwork(this.config.getNetwork()))
+      .decode(refundP2trAddress);
+    const refundPkScript = btc.OutScript.encode(refundAddress);
+
+    refundTx.addOutput({
+      script: refundPkScript,
+      amount: amount,
+    });
+
+    const refundNonceCommitment =
+      await this.config.signer.getRandomSigningCommitment();
+    const refundTxSighash = getSigHashFromTx(refundTx, 0, output);
+
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let treeResp: StartTreeCreationResponse;
+
+    try {
+      treeResp = await sparkClient.start_tree_creation({
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        onChainUtxo: {
+          vout: vout,
+          rawTx: depositTx.toBytes(),
+          network: this.config.getNetworkProto(),
+        },
+        rootTxSigningJob: {
+          rawTx: rootTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: rootNonceCommitment,
+        },
+        refundTxSigningJob: {
+          rawTx: refundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: refundNonceCommitment,
+        },
+      });
+    } catch (error) {
+      throw new Error(`Error starting tree creation: ${error}`);
+    }
+
+    if (!treeResp.rootNodeSignatureShares?.verifyingKey) {
+      throw new Error("No verifying key found in tree response");
+    }
+
+    if (
+      !treeResp.rootNodeSignatureShares.nodeTxSigningResult
+        ?.signingNonceCommitments
+    ) {
+      throw new Error("No signing nonce commitments found in tree response");
+    }
+
+    if (
+      !treeResp.rootNodeSignatureShares.refundTxSigningResult
+        ?.signingNonceCommitments
+    ) {
+      throw new Error("No signing nonce commitments found in tree response");
+    }
+
+    if (
+      !equalBytes(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)
+    ) {
+      throw new Error("Verifying key does not match");
+    }
+
+    const rootSignature = await this.config.signer.signFrost({
+      message: rootTxSighash,
+      publicKey: signingPubKey,
+      privateAsPubKey: signingPubKey,
+      verifyingKey,
+      selfCommitment: rootNonceCommitment,
+      statechainCommitments:
+        treeResp.rootNodeSignatureShares.nodeTxSigningResult
+          .signingNonceCommitments,
+      adaptorPubKey: new Uint8Array(),
+    });
+
+    const refundSignature = await this.config.signer.signFrost({
+      message: refundTxSighash,
+      publicKey: signingPubKey,
+      privateAsPubKey: signingPubKey,
+      verifyingKey,
+      selfCommitment: refundNonceCommitment,
+      statechainCommitments:
+        treeResp.rootNodeSignatureShares.refundTxSigningResult
+          .signingNonceCommitments,
+      adaptorPubKey: new Uint8Array(),
+    });
+
+    const rootAggregate = await this.config.signer.aggregateFrost({
+      message: rootTxSighash,
+      statechainSignatures:
+        treeResp.rootNodeSignatureShares.nodeTxSigningResult.signatureShares,
+      statechainPublicKeys:
+        treeResp.rootNodeSignatureShares.nodeTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments:
+        treeResp.rootNodeSignatureShares.nodeTxSigningResult
+          .signingNonceCommitments,
+      selfCommitment: createWasmSigningCommitment(rootNonceCommitment),
+      publicKey: signingPubKey,
+      selfSignature: rootSignature!,
+      adaptorPubKey: new Uint8Array(),
+    });
+
+    const refundAggregate = await this.config.signer.aggregateFrost({
+      message: refundTxSighash,
+      statechainSignatures:
+        treeResp.rootNodeSignatureShares.refundTxSigningResult.signatureShares,
+      statechainPublicKeys:
+        treeResp.rootNodeSignatureShares.refundTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments:
+        treeResp.rootNodeSignatureShares.refundTxSigningResult
+          .signingNonceCommitments,
+      selfCommitment: createWasmSigningCommitment(refundNonceCommitment),
+      publicKey: signingPubKey,
+      selfSignature: refundSignature,
+      adaptorPubKey: new Uint8Array(),
+    });
+
+    let finalizeResp: FinalizeNodeSignaturesResponse;
+    try {
+      finalizeResp = await sparkClient.finalize_node_signatures({
+        intent: SignatureIntent.CREATION,
+        nodeSignatures: [
+          {
+            nodeId: treeResp.rootNodeSignatureShares.nodeId,
+            nodeTxSignature: rootAggregate,
+            refundTxSignature: refundAggregate,
+          },
+        ],
+      });
+    } catch (error) {
+      throw new Error(`Error finalizing node signatures in deposit: ${error}`);
+    }
+
+    return finalizeResp;
+  }
+}

package/src/services/lightning.ts

@@ -0,0 +1,341 @@
+import {
+  bytesToNumberBE,
+  hexToBytes,
+  numberToBytesBE,
+} from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { TransactionInput } from "@scure/btc-signer/psbt";
+import { sha256 } from "@scure/btc-signer/utils";
+import { decode } from "light-bolt11-decoder";
+import {
+  GetSigningCommitmentsResponse,
+  InitiatePreimageSwapRequest_Reason,
+  InitiatePreimageSwapResponse,
+  ProvidePreimageResponse,
+  QueryUserSignedRefundsResponse,
+  RequestedSigningCommitments,
+  Transfer,
+  UserSignedRefund,
+} from "../proto/spark.js";
+import {
+  getSigHashFromTx,
+  getTxFromRawTxBytes,
+  getTxId,
+} from "../utils/bitcoin.js";
+import { getCrypto } from "../utils/crypto.js";
+import {
+  createRefundTx,
+  getNextTransactionSequence,
+} from "../utils/transaction.js";
+import { WalletConfigService } from "./config.js";
+import { ConnectionManager } from "./connection.js";
+import { LeafKeyTweak } from "./transfer.js";
+
+const crypto = getCrypto();
+
+export type CreateLightningInvoiceParams = {
+  invoiceCreator: (
+    amountSats: number,
+    paymentHash: Uint8Array,
+    memo: string,
+  ) => Promise<string | undefined>;
+  amountSats: number;
+  memo: string;
+};
+
+export type CreateLightningInvoiceWithPreimageParams = {
+  preimage: Uint8Array;
+} & CreateLightningInvoiceParams;
+
+export type SwapNodesForPreimageParams = {
+  leaves: LeafKeyTweak[];
+  receiverIdentityPubkey: Uint8Array;
+  paymentHash: Uint8Array;
+  invoiceString?: string;
+  isInboundPayment: boolean;
+};
+
+export class LightningService {
+  private readonly config: WalletConfigService;
+  private readonly connectionManager: ConnectionManager;
+
+  constructor(
+    config: WalletConfigService,
+    connectionManager: ConnectionManager,
+  ) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+
+  async createLightningInvoice({
+    invoiceCreator,
+    amountSats,
+    memo,
+  }: CreateLightningInvoiceParams): Promise<string> {
+    const randBytes = crypto.getRandomValues(new Uint8Array(32));
+    const preimage = numberToBytesBE(
+      bytesToNumberBE(randBytes) % secp256k1.CURVE.n,
+      32,
+    );
+    return await this.createLightningInvoiceWithPreImage({
+      invoiceCreator,
+      amountSats,
+      memo,
+      preimage,
+    });
+  }
+
+  async createLightningInvoiceWithPreImage({
+    invoiceCreator,
+    amountSats,
+    memo,
+    preimage,
+  }: CreateLightningInvoiceWithPreimageParams): Promise<string> {
+    const paymentHash = sha256(preimage);
+    const invoice = await invoiceCreator(amountSats, paymentHash, memo);
+    if (!invoice) {
+      throw new Error("Error creating lightning invoice");
+    }
+
+    const shares = await this.config.signer.splitSecretWithProofs({
+      secret: preimage,
+      curveOrder: secp256k1.CURVE.n,
+      threshold: this.config.getThreshold(),
+      numShares: Object.keys(this.config.getSigningOperators()).length,
+    });
+
+    const errors: Error[] = [];
+    const promises = Object.entries(this.config.getSigningOperators()).map(
+      async ([_, operator]) => {
+        const share = shares[operator.id];
+        if (!share) {
+          throw new Error("Share not found");
+        }
+
+        const sparkClient = await this.connectionManager.createSparkClient(
+          operator.address,
+        );
+
+        try {
+          await sparkClient.store_preimage_share({
+            paymentHash,
+            preimageShare: {
+              secretShare: numberToBytesBE(share.share, 32),
+              proofs: share.proofs,
+            },
+            threshold: this.config.getThreshold(),
+            invoiceString: invoice,
+            userIdentityPublicKey:
+              await this.config.signer.getIdentityPublicKey(),
+          });
+        } catch (e: any) {
+          errors.push(e);
+        }
+      },
+    );
+
+    await Promise.all(promises);
+
+    if (errors.length > 0) {
+      throw new Error(`Error creating lightning invoice: ${errors[0]}`);
+    }
+
+    return invoice;
+  }
+
+  async swapNodesForPreimage({
+    leaves,
+    receiverIdentityPubkey,
+    paymentHash,
+    invoiceString,
+    isInboundPayment,
+  }: SwapNodesForPreimageParams): Promise<InitiatePreimageSwapResponse> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let signingCommitments: GetSigningCommitmentsResponse;
+    try {
+      signingCommitments = await sparkClient.get_signing_commitments({
+        nodeIds: leaves.map((leaf) => leaf.leaf.id),
+      });
+    } catch (error) {
+      throw new Error(`Error getting signing commitments: ${error}`);
+    }
+
+    const userSignedRefunds = await this.signRefunds(
+      leaves,
+      signingCommitments.signingCommitments,
+      receiverIdentityPubkey,
+    );
+
+    const transferId = crypto.randomUUID();
+    let bolt11String = "";
+    let amountSats: number = 0;
+    if (invoiceString) {
+      const decodedInvoice = decode(invoiceString);
+      let amountMsats = 0;
+      try {
+        amountMsats = Number(
+          decodedInvoice.sections.find((section) => section.name === "amount")
+            ?.value,
+        );
+      } catch (error) {
+        console.error("Error decoding invoice", error);
+      }
+
+      amountSats = amountMsats / 1000;
+      bolt11String = invoiceString;
+    }
+
+    const reason = isInboundPayment
+      ? InitiatePreimageSwapRequest_Reason.REASON_RECEIVE
+      : InitiatePreimageSwapRequest_Reason.REASON_SEND;
+
+    let response: InitiatePreimageSwapResponse;
+    try {
+      response = await sparkClient.initiate_preimage_swap({
+        paymentHash,
+        userSignedRefunds,
+        reason,
+        invoiceAmount: {
+          invoiceAmountProof: {
+            bolt11Invoice: bolt11String,
+          },
+          valueSats: amountSats,
+        },
+        transfer: {
+          transferId,
+          ownerIdentityPublicKey:
+            await this.config.signer.getIdentityPublicKey(),
+          receiverIdentityPublicKey: receiverIdentityPubkey,
+          expiryTime: new Date(Date.now() + 2 * 60 * 1000),
+        },
+        receiverIdentityPublicKey: receiverIdentityPubkey,
+        feeSats: 0,
+      });
+    } catch (error) {
+      throw new Error(`Error initiating preimage swap: ${error}`);
+    }
+
+    return response;
+  }
+
+  async queryUserSignedRefunds(
+    paymentHash: Uint8Array,
+  ): Promise<UserSignedRefund[]> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let response: QueryUserSignedRefundsResponse;
+    try {
+      response = await sparkClient.query_user_signed_refunds({
+        paymentHash,
+      });
+    } catch (error) {
+      throw new Error(`Error querying user signed refunds: ${error}`);
+    }
+
+    return response.userSignedRefunds;
+  }
+
+  validateUserSignedRefund(userSignedRefund: UserSignedRefund): bigint {
+    const refundTx = getTxFromRawTxBytes(userSignedRefund.refundTx);
+    // TODO: Should we assert that the amount is always defined here?
+    return refundTx.getOutput(0).amount || 0n;
+  }
+
+  async providePreimage(preimage: Uint8Array): Promise<Transfer> {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    const paymentHash = sha256(preimage);
+    let response: ProvidePreimageResponse;
+    try {
+      response = await sparkClient.provide_preimage({
+        preimage,
+        paymentHash,
+      });
+    } catch (error) {
+      throw new Error(`Error providing preimage: ${error}`);
+    }
+
+    if (!response.transfer) {
+      throw new Error("No transfer returned from coordinator");
+    }
+
+    return response.transfer;
+  }
+
+  private async signRefunds(
+    leaves: LeafKeyTweak[],
+    signingCommitments: RequestedSigningCommitments[],
+    receiverIdentityPubkey: Uint8Array,
+  ): Promise<UserSignedRefund[]> {
+    const userSignedRefunds: UserSignedRefund[] = [];
+    for (let i = 0; i < leaves.length; i++) {
+      const leaf = leaves[i];
+      if (!leaf?.leaf) {
+        throw new Error("Leaf not found in signRefunds");
+      }
+
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const nodeOutPoint: TransactionInput = {
+        txid: hexToBytes(getTxId(nodeTx)),
+        index: 0,
+      };
+
+      const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const nextSequence = getNextTransactionSequence(
+        currRefundTx.getInput(0).sequence,
+      );
+      const amountSats = currRefundTx.getOutput(0).amount;
+      if (amountSats === undefined) {
+        throw new Error("Amount not found in signRefunds");
+      }
+
+      const refundTx = createRefundTx(
+        nextSequence,
+        nodeOutPoint,
+        amountSats,
+        receiverIdentityPubkey,
+        this.config.getNetwork(),
+      );
+
+      const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
+
+      const signingCommitment =
+        await this.config.signer.getRandomSigningCommitment();
+
+      const signingNonceCommitments =
+        signingCommitments[i]?.signingNonceCommitments;
+      if (!signingNonceCommitments) {
+        throw new Error("Signing nonce commitments not found in signRefunds");
+      }
+      const signingResult = await this.config.signer.signFrost({
+        message: sighash,
+        publicKey: leaf.signingPubKey,
+        privateAsPubKey: leaf.signingPubKey,
+        selfCommitment: signingCommitment,
+        statechainCommitments: signingNonceCommitments,
+        adaptorPubKey: new Uint8Array(),
+        verifyingKey: leaf.leaf.verifyingPublicKey,
+      });
+
+      userSignedRefunds.push({
+        nodeId: leaf.leaf.id,
+        refundTx: refundTx.toBytes(),
+        userSignature: signingResult,
+        userSignatureCommitment: signingCommitment,
+        signingCommitments: {
+          signingCommitments: signingNonceCommitments,
+        },
+        network: this.config.getNetworkProto(),
+      });
+    }
+
+    return userSignedRefunds;
+  }
+}

package/src/services/lrc20.ts

@@ -0,0 +1,42 @@
+import { LRCWallet, Lrc20TransactionDto } from "@buildonspark/lrc20-sdk";
+
+import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
+import { LeafWithPreviousTransactionData } from "../proto/spark.js";
+
+//TODO: dynamically set these for each leaf based on its metadata in the transaction that created it
+const WITHDRAW_BOND_SATS = 10000;
+const WITHDRAW_RELATIVE_BLOCK_LOCKTIME = 100;
+
+export async function broadcastL1Withdrawal(
+  lrcWallet: LRCWallet,
+  leavesToExit: LeafWithPreviousTransactionData[],
+  receiverPublicKey: string,
+  feeRateSatsPerVb: number = 2.0,
+): Promise<{ txid: string }> {
+  await lrcWallet.syncWallet();
+
+  let payments = leavesToExit.map(
+    ({ leaf, previousTransactionHash, previousTransactionVout }) => {
+      return {
+        amount: bytesToNumberBE(leaf!.tokenAmount),
+        tokenPubkey: bytesToHex(leaf!.tokenPublicKey),
+        sats: WITHDRAW_BOND_SATS,
+        cltvOutputLocktime: WITHDRAW_RELATIVE_BLOCK_LOCKTIME,
+        revocationKey: bytesToHex(leaf!.revocationPublicKey!),
+        expiryKey: receiverPublicKey,
+        metadata: {
+          token_tx_hash: bytesToHex(previousTransactionHash),
+          exit_leaf_index: previousTransactionVout,
+        },
+      };
+    },
+  );
+
+  const tx = await lrcWallet.prepareSparkExit(payments, feeRateSatsPerVb);
+
+  let txDto = Lrc20TransactionDto.fromLrc20Transaction(tx);
+
+  let txid = await lrcWallet.broadcast(txDto); //.broadcastRawBtcTransaction(tx.bitcoin_tx.toHex());
+
+  return { txid };
+}