@did-btcr2/bitcoin 0.3.2 → 0.3.3

package/dist/types/musig2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"musig2.d.ts","sourceRoot":"","sources":["../../src/musig2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAIxC,OAAO,EAAS,KAAK,EAAmB,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAY,IAAI,EAAE,MAAM,eAAe,CAAC;AAG/C,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB,YAAY,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC5B,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;CAC5B;AAED,UAAU,uBAAuB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC;CAClB;AAED,UAAU,qBAAqB;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,GAAG,CAAC;CAC5B;AAED,UAAU,yBAAyB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,qBAAa,iBAAiB;IACrB,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC;IACtB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC;gBAEZ,SAAS,CAAC,EAAE,UAAU;IAK3B,aAAa,IAAI,uBAAuB;IAWxC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,GAAG,yBAAyB;CAsBxF;AAED,qBAAa,iBAAiB;IACrB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAa;IAEjD,YAAY,CAAC,OAAO,EAAE,uBAAuB;IAK7C,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,qBAAqB;IAezD,gBAAgB,CAAC,IAAI,EAAE,yBAAyB;IAOhD,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;CAI/C"}

package/dist/types/taproot.d.ts

@@ -1,34 +0,0 @@
-import { payments } from 'bitcoinjs-lib';
-/**
- * TapRootMultiSig: builds Taproot outputs and trees for multisig and MuSig branches
- */
-export declare class TapRootMultiSig {
-    readonly points: Uint8Array[];
-    readonly k: number;
-    readonly defaultInternalPubkey: Uint8Array;
-    constructor(points: Uint8Array[], k: number);
-    /**
-     * Single multisig leaf as the only script path
-     */
-    singleLeaf(locktime?: number, sequence?: number): payments.Payment;
-    /**
-     * All k-of-n multisig combinations as separate leaf scripts, combined into one tree
-     */
-    multiLeafTree(locktime?: number, sequence?: number): payments.Payment;
-    /**
-     * MuSig key-path scripts for each k-of-n combination in the script tree
-     */
-    musigTree(): payments.Payment;
-    /**
-     * A two-branch tree: one branch is the singleLeaf script, the other is the muSig tree
-     */
-    musigAndSingleLeafTree(locktime?: number, sequence?: number): payments.Payment;
-    /**
-     * Nested tree of singleLeaf, multiLeafTree, and musigTree
-     */
-    everythingTree(locktime?: number, sequence?: number): payments.Payment;
-    /**
-     * Degrading multisig: k-of-n initially, then (k-1)-of-n after delay, ... until 1-of-n
-     */
-    degradingMultisigTree(sequenceBlockInterval?: number, sequenceTimeInterval?: number): payments.Payment;
-}

package/dist/types/taproot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"taproot.d.ts","sourceRoot":"","sources":["../../src/taproot.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAmB,MAAM,eAAe,CAAC;AAsG1D;;GAEG;AACH,qBAAa,eAAe;IAC1B,SAAgB,MAAM,EAAE,UAAU,EAAE,CAAC;IACrC,SAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAgB,qBAAqB,EAAE,UAAU,CAAC;gBAEtC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM;IAU3C;;OAEG;IACH,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAQ/C;;OAEG;IACH,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAYlD;;OAEG;IACH,SAAS;IAYT;;OAEG;IACH,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAgB3D;;OAEG;IACH,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAyBnD;;OAEG;IACH,qBAAqB,CACnB,qBAAqB,CAAC,EAAE,MAAM,EAC9B,oBAAoB,CAAC,EAAE,MAAM;CAsBhC"}

package/src/musig2.ts

@@ -1,117 +0,0 @@
-import { Hex } from '@did-btcr2/common';
-import { Secp256k1SecretKey } from '@did-btcr2/keypair';
-import { schnorr } from '@noble/curves/secp256k1';
-import { bytesToHex } from '@noble/hashes/utils.js';
-import { CURVE, Point, ProjectivePoint } from '@noble/secp256k1';
-import { payments, Psbt } from 'bitcoinjs-lib';
-import { taggedHash } from 'bitcoinjs-lib/src/crypto';
-
-interface MuSig2Session {
-  sessionId: string;
-  beaconAddress: string;
-  participants: Hex[];
-  publicNonces: Map<Hex, Hex>; // pubkey => nonce
-  aggregatedNonce?: Hex;
-  messageToSign?: Uint8Array;
-  partialSigs: Map<Hex, Hex>; // pubkey => sig
-}
-
-interface MuSig2NonceContribution {
-  sessionId: string;
-  beaconAddress: string;
-  noncePoints: Hex;
-}
-
-interface AggregatedMuSig2Nonce {
-  sessionId: string;
-  beaconAddress: string;
-  aggregatedNoncePoints: Hex;
-}
-
-interface BeaconSignalAuthorization {
-  sessionId: string;
-  beaconAddress: string;
-  txSig: Hex;
-}
-
-export class MuSig2Participant {
-  public secretKey: Uint8Array;
-  public publicKey: Uint8Array;
-  public nonce?: Uint8Array;
-  public noncePub?: Point;
-
-  constructor(secretKey?: Uint8Array) {
-    this.secretKey = secretKey ?? Secp256k1SecretKey.random();
-    this.publicKey = schnorr.getPublicKey(this.secretKey);
-  }
-
-  public generateNonce(): MuSig2NonceContribution {
-    this.nonce = Secp256k1SecretKey.random();
-    this.noncePub = ProjectivePoint.fromPrivateKey(this.nonce);
-
-    return {
-      sessionId     : 'SESSION_ID',
-      beaconAddress : Buffer.from(this.publicKey).toString('hex'),
-      noncePoints   : this.noncePub.toHex(true), // compressed
-    };
-  }
-
-  public sign(message: Uint8Array, aggregatedNonceHex: string): BeaconSignalAuthorization {
-    const R = ProjectivePoint.fromHex(aggregatedNonceHex);
-    const L = ProjectivePoint.fromHex(this.publicKey);
-
-    const e = taggedHash('BIP0340/challenge', new Uint8Array([
-      ...R.toRawBytes(true),
-      ...L.toRawBytes(true),
-      ...message,
-    ]));
-
-    const eNum = BigInt('0x' + bytesToHex(e));
-    const rNum = BigInt('0x' + bytesToHex(this.nonce!));
-    const xNum = BigInt('0x' + bytesToHex(this.secretKey));
-
-    const s = (rNum + eNum * xNum) % CURVE.n;
-
-    return {
-      sessionId     : crypto.randomUUID(),
-      beaconAddress : payments.p2tr({ internalPubkey: this.publicKey }).address || '',
-      txSig         : s.toString(16).padStart(64, '0'),
-    };
-  }
-}
-
-export class MuSig2Coordinator {
-  public sessions: Map<string, MuSig2Session> = new Map();
-
-  public receiveNonce(contrib: MuSig2NonceContribution) {
-    const session = this.sessions.get(contrib.sessionId);
-    session?.publicNonces.set(contrib.beaconAddress, contrib.noncePoints);
-  }
-
-  public aggregateNonces(sessionId: string): AggregatedMuSig2Nonce {
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new Error('Session not found');
-
-    const points = Array.from(session.publicNonces.values()).map(nonceHex => ProjectivePoint.fromHex(nonceHex));
-    const aggregated = points.reduce((acc, pt) => acc.add(pt), ProjectivePoint.ZERO);
-    session.aggregatedNonce = aggregated.toHex();
-
-    return {
-      sessionId,
-      beaconAddress         : session.beaconAddress,
-      aggregatedNoncePoints : session.aggregatedNonce,
-    };
-  }
-
-  public collectSignature(auth: BeaconSignalAuthorization) {
-    const session = this.sessions.get(auth.sessionId);
-    if (session) {
-      session.partialSigs.set(auth.beaconAddress, auth.txSig);
-    }
-  }
-
-  public finalizeTransaction(psbt: Psbt): string {
-    // Combine partial signatures (assuming MuSig2 multi-party logic handled externally)
-    return psbt.toHex();
-  }
-}

package/src/taproot.ts

@@ -1,237 +0,0 @@
-import * as tinysecp from 'tiny-secp256k1';
-import { payments, script, opcodes } from 'bitcoinjs-lib';
-import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
-
-/**
- * Aggregate an array of public keys by point addition
- */
-function aggregatePubkeys(pubkeys: Uint8Array[]): Uint8Array {
-  if (pubkeys.length === 1) return pubkeys[0];
-  return pubkeys.reduce((sum: Uint8Array, pk: Uint8Array) => {
-    const added = tinysecp.pointAdd(sum, pk);
-    if (!added) throw new Error('Point addition failed');
-    return added;
-  }, pubkeys[0]);
-}
-
-/**
- * Build a P2TR script leaf for a k-of-n multisig with optional locktime/sequence
- */
-function buildTapLeafScript(
-  pubkeys: Uint8Array[],
-  k: number,
-  locktime?: number,
-  sequence?: number
-): Uint8Array {
-  const ops: (Uint8Array | number)[] = [];
-
-  // absolute timelock
-  if (locktime !== undefined) {
-    ops.push(script.number.encode(locktime));
-    ops.push(opcodes.OP_CHECKLOCKTIMEVERIFY);
-    ops.push(opcodes.OP_DROP);
-  }
-  // relative timelock
-  if (sequence !== undefined) {
-    ops.push(script.number.encode(sequence));
-    ops.push(opcodes.OP_CHECKSEQUENCEVERIFY);
-    ops.push(opcodes.OP_DROP);
-  }
-
-  // push each key as x-only pubkey
-  for (const pk of pubkeys) {
-    const [xOnly] = new CompressedSecp256k1PublicKey(pk).xOnly;
-    ops.push(xOnly);
-  }
-  // push threshold k and total keys n
-  ops.push(script.number.encode(k));
-  ops.push(script.number.encode(pubkeys.length));
-  ops.push(opcodes.OP_CHECKMULTISIG);
-
-  return script.compile(ops);
-}
-
-/**
- * Build a P2TR script leaf for a aggregated MuSig key (key-path only)
- */
-function buildMusigLeafScript(pubkeys: Uint8Array[]): Uint8Array {
-  const agg = aggregatePubkeys(pubkeys);
-  const [xOnly] = new CompressedSecp256k1PublicKey(agg).xOnly;
-  // In a taproot script path, OP_CHECKSIG runs schnorr
-  return script.compile([xOnly, opcodes.OP_CHECKSIG]);
-}
-
-/**
- * Recursively combine an array of leaves into a balanced Merkle tree structure
- */
-function buildMerkleTree(nodes: Uint8Array[]): any {
-  if (nodes.length === 1) return { output: nodes[0] };
-  const next: any[] = [];
-  for (let i = 0; i < nodes.length; i += 2) {
-    if (i + 1 === nodes.length) {
-      next.push({ output: nodes[i] });
-    } else {
-      next.push([
-        { output: nodes[i] },
-        { output: nodes[i + 1] },
-      ]);
-    }
-  }
-  return buildMerkleTree(next);
-}
-
-/**
- * Generate combinations of length k from an array
- */
-function* combinations<T>(array: T[], k: number): Generator<T[]> {
-  const n = array.length;
-  if (k > n || k < 0) return;
-  const indices = Array.from({ length: k }, (_, i) => i);
-  while (true) {
-    yield indices.map(i => array[i]!);
-    let i = k - 1;
-    while (i >= 0 && indices[i] === i + n - k) {
-      i--;
-    }
-    if (i < 0) break;
-    indices[i]++;
-    for (let j = i + 1; j < k; j++) {
-      indices[j] = indices[j - 1] + 1;
-    }
-  }
-}
-
-/**
- * TapRootMultiSig: builds Taproot outputs and trees for multisig and MuSig branches
- */
-export class TapRootMultiSig {
-  public readonly points: Uint8Array[];
-  public readonly k: number;
-  public readonly defaultInternalPubkey: Uint8Array;
-
-  constructor(points: Uint8Array[], k: number) {
-    if (points.length < k || k < 1) {
-      throw new Error(`${k} is invalid for ${points.length} keys`);
-    }
-    this.points = points;
-    this.k = k;
-    // MuSig aggregation for default internal key
-    this.defaultInternalPubkey = aggregatePubkeys(points);
-  }
-
-  /**
-   * Single multisig leaf as the only script path
-   */
-  singleLeaf(locktime?: number, sequence?: number) {
-    const leaf = buildTapLeafScript(this.points, this.k, locktime, sequence);
-    return payments.p2tr({
-      internalPubkey : this.defaultInternalPubkey,
-      scriptTree     : { output: leaf },
-    });
-  }
-
-  /**
-   * All k-of-n multisig combinations as separate leaf scripts, combined into one tree
-   */
-  multiLeafTree(locktime?: number, sequence?: number) {
-    const leaves: Uint8Array[] = [];
-    for (const combo of combinations(this.points, this.k)) {
-      leaves.push(buildTapLeafScript(combo, this.k, locktime, sequence));
-    }
-    const tree = buildMerkleTree(leaves);
-    return payments.p2tr({
-      internalPubkey : this.defaultInternalPubkey,
-      scriptTree     : tree,
-    });
-  }
-
-  /**
-   * MuSig key-path scripts for each k-of-n combination in the script tree
-   */
-  musigTree() {
-    const leaves: Uint8Array[] = [];
-    for (const combo of combinations(this.points, this.k)) {
-      leaves.push(buildMusigLeafScript(combo));
-    }
-    const tree = buildMerkleTree(leaves);
-    return payments.p2tr({
-      internalPubkey : this.defaultInternalPubkey,
-      scriptTree     : tree,
-    });
-  }
-
-  /**
-   * A two-branch tree: one branch is the singleLeaf script, the other is the muSig tree
-   */
-  musigAndSingleLeafTree(locktime?: number, sequence?: number) {
-    const single = buildTapLeafScript(this.points, this.k, locktime, sequence);
-    const musigLeaves: Uint8Array[] = [];
-    for (const combo of combinations(this.points, this.k)) {
-      musigLeaves.push(buildMusigLeafScript(combo));
-    }
-    const tree = {
-      output     : single,
-      scriptTree : buildMerkleTree(musigLeaves),
-    };
-    return payments.p2tr({
-      internalPubkey : this.defaultInternalPubkey,
-      scriptTree     : tree,
-    });
-  }
-
-  /**
-   * Nested tree of singleLeaf, multiLeafTree, and musigTree
-   */
-  everythingTree(locktime?: number, sequence?: number) {
-    const single = buildTapLeafScript(this.points, this.k, locktime, sequence);
-
-    const multiLeaves: Uint8Array[] = [];
-    for (const combo of combinations(this.points, this.k)) {
-      multiLeaves.push(buildTapLeafScript(combo, this.k, locktime, sequence));
-    }
-    const multiTree = buildMerkleTree(multiLeaves);
-
-    const musigLeaves: Uint8Array[] = [];
-    for (const combo of combinations(this.points, this.k)) {
-      musigLeaves.push(buildMusigLeafScript(combo));
-    }
-    const musigTree = buildMerkleTree(musigLeaves);
-
-    const tree = {
-      output     : single,
-      scriptTree : [multiTree, musigTree],
-    };
-    return payments.p2tr({
-      internalPubkey : this.defaultInternalPubkey,
-      scriptTree     : tree,
-    });
-  }
-
-  /**
-   * Degrading multisig: k-of-n initially, then (k-1)-of-n after delay, ... until 1-of-n
-   */
-  degradingMultisigTree(
-    sequenceBlockInterval?: number,
-    sequenceTimeInterval?: number
-  ) {
-    const leaves: Uint8Array[] = [];
-    for (let num = this.k; num >= 1; num--) {
-      let seq: number | undefined;
-      if (num === this.k) {
-        seq = undefined;
-      } else if (sequenceBlockInterval != null) {
-        seq = sequenceBlockInterval * (this.k - num);
-      } else if (sequenceTimeInterval != null) {
-        seq = sequenceTimeInterval * (this.k - num);
-      }
-      for (const combo of combinations(this.points, num)) {
-        leaves.push(buildTapLeafScript(combo, num, undefined, seq));
-      }
-    }
-    const tree = buildMerkleTree(leaves);
-    return payments.p2tr({
-      internalPubkey : this.defaultInternalPubkey,
-      scriptTree     : tree,
-    });
-  }
-}