@buildonspark/spark-sdk 0.0.14 → 0.0.16

package/src/utils/token-hashing.ts

@@ -0,0 +1,163 @@
+import { sha256 } from "@scure/btc-signer/utils";
+import {
+  OperatorSpecificTokenTransactionSignablePayload,
+  TokenTransaction,
+} from "../proto/spark.js";
+
+export function hashTokenTransaction(
+  tokenTransaction: TokenTransaction,
+  partialHash: boolean = false,
+): Uint8Array {
+  if (!tokenTransaction) {
+    throw new Error("token transaction cannot be nil");
+  }
+
+  let allHashes: Uint8Array[] = [];
+
+  // Hash input leaves if a transfer
+  if (tokenTransaction.tokenInput?.$case === "transferInput") {
+    // Hash leaves_to_spend
+    for (const leaf of tokenTransaction.tokenInput!.transferInput!
+      .leavesToSpend || []) {
+      const hashObj = sha256.create();
+
+      if (leaf.prevTokenTransactionHash) {
+        hashObj.update(leaf.prevTokenTransactionHash);
+      }
+
+      const voutBytes = new Uint8Array(4);
+      new DataView(voutBytes.buffer).setUint32(
+        0,
+        leaf.prevTokenTransactionLeafVout,
+        false,
+      ); // false for big-endian
+      hashObj.update(voutBytes);
+
+      allHashes.push(hashObj.digest());
+    }
+  }
+
+  // Hash input issuance if an issuance
+  if (tokenTransaction.tokenInput?.$case === "mintInput") {
+    const hashObj = sha256.create();
+    if (tokenTransaction.tokenInput.mintInput!.issuerPublicKey) {
+      hashObj.update(tokenTransaction.tokenInput.mintInput!.issuerPublicKey);
+    }
+    if (tokenTransaction.tokenInput.mintInput!.issuerProvidedTimestamp) {
+      const timestampBytes = new Uint8Array(8);
+      new DataView(timestampBytes.buffer).setBigUint64(
+        0,
+        BigInt(tokenTransaction.tokenInput.mintInput!.issuerProvidedTimestamp),
+        true, // true for little-endian to match Go implementation
+      );
+      hashObj.update(timestampBytes);
+    }
+    allHashes.push(hashObj.digest());
+  }
+
+  // Hash output leaves
+  for (const leaf of tokenTransaction.outputLeaves || []) {
+    const hashObj = sha256.create();
+
+    // Only hash ID if it's not empty and not in partial hash mode
+    if (leaf.id && !partialHash) {
+      hashObj.update(new TextEncoder().encode(leaf.id));
+    }
+    if (leaf.ownerPublicKey) {
+      hashObj.update(leaf.ownerPublicKey);
+    }
+    if (leaf.revocationPublicKey && !partialHash) {
+      hashObj.update(leaf.revocationPublicKey);
+    }
+
+    if (leaf.withdrawBondSats && !partialHash) {
+      const bondBytes = new Uint8Array(8);
+      new DataView(bondBytes.buffer).setBigUint64(
+        0,
+        BigInt(leaf.withdrawBondSats!),
+        false,
+      );
+      hashObj.update(bondBytes);
+    }
+
+    if (leaf.withdrawRelativeBlockLocktime && !partialHash) {
+      const locktimeBytes = new Uint8Array(8);
+      new DataView(locktimeBytes.buffer).setBigUint64(
+        0,
+        BigInt(leaf.withdrawRelativeBlockLocktime!),
+        false,
+      );
+      hashObj.update(locktimeBytes);
+    }
+
+    if (leaf.tokenPublicKey) {
+      hashObj.update(leaf.tokenPublicKey);
+    }
+    if (leaf.tokenAmount) {
+      hashObj.update(leaf.tokenAmount);
+    }
+
+    allHashes.push(hashObj.digest());
+  }
+
+  // Sort operator public keys before hashing
+  const sortedPubKeys = [
+    ...(tokenTransaction.sparkOperatorIdentityPublicKeys || []),
+  ].sort((a, b) => {
+    for (let i = 0; i < a.length && i < b.length; i++) {
+      // @ts-ignore - i < a and b length
+      if (a[i] !== b[i]) return a[i] - b[i];
+    }
+    return a.length - b.length;
+  });
+
+  // Hash spark operator identity public keys
+  for (const pubKey of sortedPubKeys) {
+    const hashObj = sha256.create();
+    if (pubKey) {
+      hashObj.update(pubKey);
+    }
+    allHashes.push(hashObj.digest());
+  }
+
+  // Final hash of all concatenated hashes
+  const finalHashObj = sha256.create();
+  const concatenatedHashes = new Uint8Array(
+    allHashes.reduce((sum, hash) => sum + hash.length, 0),
+  );
+  let offset = 0;
+  for (const hash of allHashes) {
+    concatenatedHashes.set(hash, offset);
+    offset += hash.length;
+  }
+  finalHashObj.update(concatenatedHashes);
+  return finalHashObj.digest();
+}
+
+export function hashOperatorSpecificTokenTransactionSignablePayload(
+  payload: OperatorSpecificTokenTransactionSignablePayload,
+): Uint8Array {
+  if (!payload) {
+    throw new Error("revocation keyshare signable payload cannot be nil");
+  }
+
+  let allHashes = new Uint8Array(0);
+
+  // Hash final_token_transaction_hash
+  const hash1 = sha256(payload.finalTokenTransactionHash || new Uint8Array(0));
+  allHashes = concatenateUint8Arrays(allHashes, hash1);
+
+  // Hash operator_identity_public_key
+  const hash2 = sha256(payload.operatorIdentityPublicKey || new Uint8Array(0));
+  allHashes = concatenateUint8Arrays(allHashes, hash2);
+
+  // Final hash of all concatenated hashes
+  return sha256(allHashes);
+}
+
+function concatenateUint8Arrays(array1: Uint8Array, array2: Uint8Array) {
+  const result = new Uint8Array(array1.length + array2.length);
+  result.set(array1, 0);
+  result.set(array2, array1.length);
+  return result;
+}

package/src/utils/token-keyshares.ts

@@ -0,0 +1,31 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import {
+  bigIntToPrivateKey,
+  recoverSecret,
+  VerifiableSecretShare,
+} from "./secret-sharing.js";
+
+export interface KeyshareWithOperatorIndex {
+  index: number;
+  keyshare: Uint8Array;
+}
+
+export function recoverPrivateKeyFromKeyshares(
+  keyshares: KeyshareWithOperatorIndex[],
+  threshold: number,
+): Uint8Array {
+  // Convert keyshares to secret shares format
+  const shares: VerifiableSecretShare[] = keyshares.map((keyshare) => ({
+    fieldModulus: BigInt("0x" + secp256k1.CURVE.n.toString(16)), // secp256k1 curve order
+    threshold,
+    index: BigInt(keyshare.index),
+    share: BigInt("0x" + Buffer.from(keyshare.keyshare).toString("hex")),
+    proofs: [],
+  }));
+
+  // Recover the secret
+  const recoveredKey = recoverSecret(shares);
+
+  // Convert to bytes
+  return bigIntToPrivateKey(recoveredKey);
+}

package/src/utils/token-transactions.ts

@@ -0,0 +1,71 @@
+import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
+import {
+  LeafWithPreviousTransactionData,
+  TokenTransaction,
+} from "../proto/spark.js";
+import { hashTokenTransaction } from "./token-hashing.js";
+
+export function getTokenLeavesSum(
+  leaves: LeafWithPreviousTransactionData[],
+): bigint {
+  return leaves.reduce(
+    (sum, leaf) => sum + BigInt(bytesToNumberBE(leaf.leaf!.tokenAmount!)),
+    BigInt(0),
+  );
+}
+
+export function extractOutputLeaves(
+  fullTokenTransaction: TokenTransaction,
+): LeafWithPreviousTransactionData[] {
+  const outputLeaves: LeafWithPreviousTransactionData[] = [];
+  const hash = hashTokenTransaction(fullTokenTransaction, true);
+
+  fullTokenTransaction.outputLeaves!.forEach((output, index) => {
+    outputLeaves.push({
+      leaf: output,
+      previousTransactionHash: hash!,
+      previousTransactionVout: index,
+    });
+  });
+  return outputLeaves;
+}
+
+export function calculateAvailableTokenAmount(
+  outputLeaves: LeafWithPreviousTransactionData[],
+): bigint {
+  return outputLeaves.reduce(
+    (sum, leaf) => sum + BigInt(bytesToNumberBE(leaf.leaf!.tokenAmount!)),
+    BigInt(0),
+  );
+}
+
+export function checkIfSelectedLeavesAreAvailable(
+  selectedLeaves: LeafWithPreviousTransactionData[],
+  tokenLeaves: Map<string, LeafWithPreviousTransactionData[]>,
+  tokenPublicKey: Uint8Array,
+) {
+  const tokenPubKeyHex = bytesToHex(tokenPublicKey);
+  const tokenLeavesAvailable = tokenLeaves.get(tokenPubKeyHex);
+  if (!tokenLeavesAvailable) {
+    return false;
+  }
+  if (
+    selectedLeaves.length === 0 ||
+    tokenLeavesAvailable.length < selectedLeaves.length
+  ) {
+    return false;
+  }
+
+  // Create a Set of available leaf IDs for O(n + m) lookup
+  const availableLeafIds = new Set(
+    tokenLeavesAvailable.map((leaf) => leaf.leaf!.id),
+  );
+
+  for (const selectedLeaf of selectedLeaves) {
+    if (!selectedLeaf.leaf?.id || !availableLeafIds.has(selectedLeaf.leaf.id)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/utils/transaction.ts

@@ -0,0 +1,45 @@
+import { Transaction } from "@scure/btc-signer";
+import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt";
+import { getP2TRScriptFromPublicKey } from "./bitcoin.js";
+import { Network } from "./network.js";
+
+const TIME_LOCK_INTERVAL = 100;
+
+export function createRefundTx(
+  sequence: number,
+  nodeOutPoint: TransactionInput,
+  amountSats: bigint,
+  receivingPubkey: Uint8Array,
+  network: Network,
+): Transaction {
+  const newRefundTx = new Transaction({ allowUnknownOutputs: true });
+  newRefundTx.addInput({
+    ...nodeOutPoint,
+    sequence,
+  });
+
+  const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
+
+  newRefundTx.addOutput({
+    script: refundPkScript,
+    amount: amountSats,
+  });
+  newRefundTx.addOutput(getEphemeralAnchorOutput());
+
+  return newRefundTx;
+}
+
+export function getNextTransactionSequence(currSequence?: number): number {
+  const currentTimelock = (currSequence || 0) & 0xffff;
+  if (currentTimelock - TIME_LOCK_INTERVAL <= 0) {
+    throw new Error("timelock interval is less or equal to 0");
+  }
+  return (1 << 30) | (currentTimelock - TIME_LOCK_INTERVAL);
+}
+
+export function getEphemeralAnchorOutput(): TransactionOutput {
+  return {
+    script: new Uint8Array([0x51]), // OP_TRUE
+    amount: 0n,
+  };
+}

package/src/utils/wasm-wrapper.ts

@@ -0,0 +1,57 @@
+import init, { InitOutput } from "../wasm/spark_bindings.js";
+
+export async function initWasm(): Promise<InitOutput> {
+  let wasmModule: InitOutput;
+
+  try {
+    if (typeof window === "undefined") {
+      // Node.js environment
+      try {
+        // Dynamic imports for Node.js modules to avoid browser compatibility issues
+        const fs = await import("fs/promises");
+        const path = await import("path");
+        const url = await import("url");
+
+        const __filename = url.fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+
+        const wasmPath = path.resolve(
+          __dirname,
+          "../wasm/spark_bindings_bg.wasm",
+        );
+
+        const wasmBuffer = await fs.readFile(wasmPath);
+
+        // Initialize with proper memory configuration for Node.js
+        wasmModule = await init({ module_or_path: wasmBuffer }).catch((e) => {
+          console.error("WASM initialization error:", e);
+          throw e;
+        });
+
+        return wasmModule;
+      } catch (e) {
+        console.error(
+          "Error with Node.js-specific WASM loading, falling back to standard initialization:",
+          e,
+        );
+        // Fall back to standard initialization if dynamic imports fail
+        wasmModule = await init();
+        return wasmModule;
+      }
+    } else {
+      // Browser environment
+      const response = await fetch(
+        new URL("../wasm/spark_bindings_bg.wasm", import.meta.url),
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to load WASM file: ${response.statusText}`);
+      }
+      const wasmBuffer = await response.arrayBuffer();
+      wasmModule = await init({ module_or_path: wasmBuffer });
+      return wasmModule;
+    }
+  } catch (e) {
+    console.error("WASM initialization error:", e);
+    throw e;
+  }
+}

package/src/utils/wasm.ts

@@ -0,0 +1,154 @@
+import {
+  construct_node_tx,
+  construct_refund_tx,
+  construct_split_tx,
+  create_dummy_tx,
+  decrypt_ecies,
+  DummyTx,
+  encrypt_ecies,
+  KeyPackage,
+  SigningCommitment,
+  SigningNonce,
+  TransactionResult,
+  wasm_aggregate_frost,
+  wasm_sign_frost,
+} from "../wasm/spark_bindings.js";
+
+export type SignFrostParams = {
+  msg: Uint8Array;
+  keyPackage: KeyPackage;
+  nonce: SigningNonce;
+  selfCommitment: SigningCommitment;
+  statechainCommitments: any;
+  adaptorPubKey?: Uint8Array | undefined;
+};
+
+export type AggregateFrostParams = {
+  msg: Uint8Array;
+  statechainCommitments: any;
+  selfCommitment: SigningCommitment;
+  statechainSignatures: any;
+  selfSignature: Uint8Array;
+  statechainPublicKeys: any;
+  selfPublicKey: Uint8Array;
+  verifyingKey: Uint8Array;
+  adaptorPubKey?: Uint8Array | undefined;
+};
+
+export type ConstructNodeTxParams = {
+  tx: Uint8Array;
+  vout: number;
+  address: string;
+  locktime: number;
+};
+
+export function signFrost({
+  msg,
+  keyPackage,
+  nonce,
+  selfCommitment,
+  statechainCommitments,
+  adaptorPubKey,
+}: SignFrostParams): Uint8Array {
+  return wasm_sign_frost(
+    msg,
+    keyPackage,
+    nonce,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+  );
+}
+
+export function aggregateFrost({
+  msg,
+  statechainCommitments,
+  selfCommitment,
+  statechainSignatures,
+  selfSignature,
+  statechainPublicKeys,
+  selfPublicKey,
+  verifyingKey,
+  adaptorPubKey,
+}: AggregateFrostParams): Uint8Array {
+  return wasm_aggregate_frost(
+    msg,
+    statechainCommitments,
+    selfCommitment,
+    statechainSignatures,
+    selfSignature,
+    statechainPublicKeys,
+    selfPublicKey,
+    verifyingKey,
+    adaptorPubKey,
+  );
+}
+
+export function constructNodeTx({
+  tx,
+  vout,
+  address,
+  locktime,
+}: ConstructNodeTxParams): TransactionResult {
+  return construct_node_tx(tx, vout, address, locktime);
+}
+
+export function constructRefundTx({
+  tx,
+  vout,
+  pubkey,
+  network,
+  locktime,
+}: {
+  tx: Uint8Array;
+  vout: number;
+  pubkey: Uint8Array;
+  network: string;
+  locktime: number;
+}): TransactionResult {
+  return construct_refund_tx(tx, vout, pubkey, network, locktime);
+}
+
+export function constructSplitTx({
+  tx,
+  vout,
+  addresses,
+  locktime,
+}: {
+  tx: Uint8Array;
+  vout: number;
+  addresses: string[];
+  locktime: number;
+}): TransactionResult {
+  return construct_split_tx(tx, vout, addresses, locktime);
+}
+
+export function createDummyTx({
+  address,
+  amountSats,
+}: {
+  address: string;
+  amountSats: bigint;
+}): DummyTx {
+  return create_dummy_tx(address, amountSats);
+}
+
+export function encryptEcies({
+  msg,
+  publicKey,
+}: {
+  msg: Uint8Array;
+  publicKey: Uint8Array;
+}): Uint8Array {
+  return encrypt_ecies(msg, publicKey);
+}
+
+export function decryptEcies({
+  encryptedMsg,
+  privateKey,
+}: {
+  encryptedMsg: Uint8Array;
+  privateKey: Uint8Array;
+}): Uint8Array {
+  return decrypt_ecies(encryptedMsg, privateKey);
+}