@7h3/protocol 0.5.0 → 0.5.1

package/sdk/threshold/package.json

@@ -1,39 +0,0 @@
-{
-  "name": "@7h3/protocol-threshold",
-  "version": "0.5.0",
-  "description": "7h3 Protocol — M-of-N threshold signatures via BLS12-381",
-  "type": "module",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js"
-    }
-  },
-  "dependencies": {
-    "@noble/curves": "^1.4.0"
-  },
-  "peerDependencies": {
-    "@7h3/protocol": "^0.5.0"
-  },
-  "devDependencies": {
-    "@types/node": "^26.1.0",
-    "typescript": "~6.0.3",
-    "vitest": "^4.1.8"
-  },
-  "scripts": {
-    "test": "vitest run src/index.test.ts",
-    "build": "tsc"
-  },
-  "license": "MIT",
-  "keywords": [
-    "7h3",
-    "protocol",
-    "threshold",
-    "bls",
-    "bls12-381",
-    "m-of-n",
-    "multisig"
-  ]
-}

package/sdk/threshold/src/index.d.ts

@@ -1,68 +0,0 @@
-export interface ProtocolHeader {
-    version: string;
-    messageId: string;
-    timestampMs: number;
-    ttlMs: number;
-    sender: string;
-    recipient?: string;
-    nonce: string;
-}
-export interface ProtocolBody {
-    intent: string;
-    content: string;
-    capability?: string;
-    correlationId?: string;
-}
-export interface ProtocolEnvelope {
-    header: ProtocolHeader;
-    body: ProtocolBody;
-}
-export interface BlsKeyPair {
-    publicKey: string;
-    privateKey: string;
-}
-export interface ThresholdConfig {
-    m: number;
-    n: number;
-}
-export interface ThresholdSignature {
-    alg: 'BLS-G2-2';
-    keyId: string;
-    value: string;
-    signerIds: string[];
-    threshold: ThresholdConfig;
-}
-export interface ThresholdEnvelope extends ProtocolEnvelope {
-    thresholdSignature: ThresholdSignature;
-}
-/**
- * Canonical serialization of a protocol envelope for signing.
- * Must match the canonical format in @7h3/protocol.
- */
-export declare function canonicalizeEnvelopeForBls(envelope: ProtocolEnvelope): string;
-export declare function generateBlsKeyPair(): BlsKeyPair;
-export declare function signEnvelopeBls(envelope: ProtocolEnvelope, privateKeyBase64Url: string, signerId: string): Promise<{
-    signerId: string;
-    partialSig: string;
-    canonicalHash: string;
-}>;
-export declare function aggregateSignatures(partialSigs: Array<{
-    signerId: string;
-    partialSig: string;
-}>, publicKeys: Record<string, string>, // signerId → BLS public key (base64url)
-envelope: ProtocolEnvelope, config: ThresholdConfig): Promise<ThresholdEnvelope>;
-export declare function verifyThresholdEnvelope(envelope: ThresholdEnvelope, participantPublicKeys: Record<string, string>, config: ThresholdConfig): Promise<boolean>;
-/**
- * Split a BLS private key into N shares using Shamir's Secret Sharing.
- * Any M shares can reconstruct the original key.
- * Returns N shares as base64url strings.
- * Share format: 1 byte index (1-based) || 32 bytes value
- */
-export declare function splitPrivateKey(privateKeyBase64Url: string, m: number, n: number): string[];
-/**
- * Reconstruct a BLS private key from M or more shares using Lagrange interpolation.
- * @param shares - array of share strings (base64url, at least m of them)
- * @param m - minimum number of shares required (used for validation only)
- */
-export declare function reconstructPrivateKey(shares: string[], m: number): string;
-//# sourceMappingURL=index.d.ts.map

package/sdk/threshold/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,cAAc,CAAA;IACtB,IAAI,EAAE,YAAY,CAAA;CACnB;AAID,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,UAAU,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,SAAS,EAAE,eAAe,CAAA;CAC3B;AAED,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACzD,kBAAkB,EAAE,kBAAkB,CAAA;CACvC;AAuBD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAyB7E;AAID,wBAAgB,kBAAkB,IAAI,UAAU,CAO/C;AAID,wBAAsB,eAAe,CACnC,QAAQ,EAAE,gBAAgB,EAC1B,mBAAmB,EAAE,MAAM,EAC3B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAW1E;AAID,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAC5D,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAG,wCAAwC;AAC7E,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,iBAAiB,CAAC,CAkC5B;AAID,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,iBAAiB,EAC3B,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7C,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,OAAO,CAAC,CA2BlB;AA+DD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,mBAAmB,EAAE,MAAM,EAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,EAAE,CA6BV;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAqCzE"}

package/sdk/threshold/src/index.js

@@ -1,254 +0,0 @@
-import { bls12_381 } from '@noble/curves/bls12-381';
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-function toBase64Url(bytes) {
-    const base64 = Buffer.from(bytes).toString('base64');
-    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
-}
-function fromBase64Url(value) {
-    const padded = value
-        .replace(/-/g, '+')
-        .replace(/_/g, '/')
-        .padEnd(Math.ceil(value.length / 4) * 4, '=');
-    return new Uint8Array(Buffer.from(padded, 'base64'));
-}
-async function sha256(data) {
-    const encoder = new TextEncoder();
-    const buf = await crypto.subtle.digest('SHA-256', encoder.encode(data));
-    return new Uint8Array(buf);
-}
-/**
- * Canonical serialization of a protocol envelope for signing.
- * Must match the canonical format in @7h3/protocol.
- */
-export function canonicalizeEnvelopeForBls(envelope) {
-    const h = envelope.header;
-    const b = envelope.body;
-    const headerParts = [
-        `"messageId":${JSON.stringify(h.messageId)}`,
-        `"nonce":${JSON.stringify(h.nonce)}`,
-    ];
-    if (h.recipient !== undefined) {
-        headerParts.push(`"recipient":${JSON.stringify(h.recipient)}`);
-    }
-    headerParts.push(`"sender":${JSON.stringify(h.sender)}`);
-    headerParts.push(`"timestampMs":${h.timestampMs}`);
-    headerParts.push(`"ttlMs":${h.ttlMs}`);
-    headerParts.push(`"version":${JSON.stringify(h.version)}`);
-    const headerStr = `{${headerParts.join(',')}}`;
-    const bodyParts = [];
-    if (b.capability !== undefined)
-        bodyParts.push(`"capability":${JSON.stringify(b.capability)}`);
-    bodyParts.push(`"content":${JSON.stringify(b.content)}`);
-    if (b.correlationId !== undefined)
-        bodyParts.push(`"correlationId":${JSON.stringify(b.correlationId)}`);
-    bodyParts.push(`"intent":${JSON.stringify(b.intent)}`);
-    const bodyStr = `{${bodyParts.join(',')}}`;
-    return `{"body":${bodyStr},"header":${headerStr}}`;
-}
-// ─── Key Generation ──────────────────────────────────────────────────────────
-export function generateBlsKeyPair() {
-    const privateKeyBytes = bls12_381.utils.randomPrivateKey();
-    const publicKeyBytes = bls12_381.getPublicKey(privateKeyBytes);
-    return {
-        publicKey: toBase64Url(publicKeyBytes),
-        privateKey: toBase64Url(privateKeyBytes),
-    };
-}
-// ─── Partial Signing ─────────────────────────────────────────────────────────
-export async function signEnvelopeBls(envelope, privateKeyBase64Url, signerId) {
-    const canonical = canonicalizeEnvelopeForBls(envelope);
-    const msgHash = await sha256(canonical);
-    const privateKeyBytes = fromBase64Url(privateKeyBase64Url);
-    // BLS sign: signature is a G2 point (96 bytes)
-    const sigBytes = bls12_381.sign(msgHash, privateKeyBytes);
-    return {
-        signerId,
-        partialSig: toBase64Url(sigBytes),
-        canonicalHash: toBase64Url(msgHash),
-    };
-}
-// ─── Aggregation ─────────────────────────────────────────────────────────────
-export async function aggregateSignatures(partialSigs, publicKeys, // signerId → BLS public key (base64url)
-envelope, config) {
-    if (partialSigs.length < config.m) {
-        throw new Error(`Threshold not met: need ${config.m} signatures, got ${partialSigs.length}`);
-    }
-    // Use exactly m signatures (first m)
-    const selected = partialSigs.slice(0, config.m);
-    const signerIds = selected.map((s) => s.signerId);
-    const sigBytesArr = selected.map((s) => fromBase64Url(s.partialSig));
-    const pubKeyBytesArr = signerIds.map((id) => {
-        const pk = publicKeys[id];
-        if (!pk)
-            throw new Error(`Missing public key for signer: ${id}`);
-        return fromBase64Url(pk);
-    });
-    const aggregatedSig = bls12_381.aggregateSignatures(sigBytesArr);
-    const aggregatedPubKey = bls12_381.aggregatePublicKeys(pubKeyBytesArr);
-    // Fingerprint: first 16 bytes of aggregated pubkey as base64url
-    const keyId = toBase64Url(aggregatedPubKey.slice(0, 16));
-    return {
-        ...envelope,
-        thresholdSignature: {
-            alg: 'BLS-G2-2',
-            keyId,
-            value: toBase64Url(aggregatedSig),
-            signerIds,
-            threshold: config,
-        },
-    };
-}
-// ─── Verification ────────────────────────────────────────────────────────────
-export async function verifyThresholdEnvelope(envelope, participantPublicKeys, config) {
-    try {
-        const { thresholdSignature } = envelope;
-        if (!thresholdSignature)
-            return false;
-        if (thresholdSignature.alg !== 'BLS-G2-2')
-            return false;
-        if (thresholdSignature.signerIds.length < config.m)
-            return false;
-        const canonical = canonicalizeEnvelopeForBls({
-            header: envelope.header,
-            body: envelope.body,
-        });
-        const msgHash = await sha256(canonical);
-        const signerIds = thresholdSignature.signerIds;
-        const pubKeyBytesArr = signerIds.map((id) => {
-            const pk = participantPublicKeys[id];
-            if (!pk)
-                throw new Error(`Missing public key for signer: ${id}`);
-            return fromBase64Url(pk);
-        });
-        const aggregatedPubKey = bls12_381.aggregatePublicKeys(pubKeyBytesArr);
-        const sigBytes = fromBase64Url(thresholdSignature.value);
-        return bls12_381.verify(sigBytes, msgHash, aggregatedPubKey);
-    }
-    catch {
-        return false;
-    }
-}
-// ─── Shamir Secret Sharing ───────────────────────────────────────────────────
-// Operates over the BLS12-381 scalar field (Fr), prime order r.
-// BLS12-381 scalar field order r
-const FIELD_ORDER = BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001');
-function fieldMod(n) {
-    return ((n % FIELD_ORDER) + FIELD_ORDER) % FIELD_ORDER;
-}
-function fieldAdd(a, b) {
-    return fieldMod(a + b);
-}
-function fieldMul(a, b) {
-    return fieldMod(a * b);
-}
-// Modular inverse via Fermat's little theorem (field is prime order)
-function fieldInv(a) {
-    if (a === 0n)
-        throw new Error('Cannot invert zero');
-    return fieldPow(a, FIELD_ORDER - 2n);
-}
-function fieldPow(base, exp) {
-    let result = 1n;
-    base = fieldMod(base);
-    while (exp > 0n) {
-        if (exp & 1n)
-            result = fieldMul(result, base);
-        base = fieldMul(base, base);
-        exp >>= 1n;
-    }
-    return result;
-}
-function bigintToBytes32(n) {
-    const hex = n.toString(16).padStart(64, '0');
-    const bytes = new Uint8Array(32);
-    for (let i = 0; i < 32; i++) {
-        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-}
-function bytes32ToBigint(bytes) {
-    let hex = '';
-    for (const b of bytes) {
-        hex += b.toString(16).padStart(2, '0');
-    }
-    return BigInt('0x' + hex);
-}
-// Generate a cryptographically random field element
-function randomFieldElement() {
-    const bytes = new Uint8Array(32);
-    crypto.getRandomValues(bytes);
-    return fieldMod(bytes32ToBigint(bytes));
-}
-/**
- * Split a BLS private key into N shares using Shamir's Secret Sharing.
- * Any M shares can reconstruct the original key.
- * Returns N shares as base64url strings.
- * Share format: 1 byte index (1-based) || 32 bytes value
- */
-export function splitPrivateKey(privateKeyBase64Url, m, n) {
-    if (m < 2 || m > n)
-        throw new Error(`Invalid threshold: m=${m}, n=${n}`);
-    const secretBytes = fromBase64Url(privateKeyBase64Url);
-    const secret = fieldMod(bytes32ToBigint(secretBytes));
-    // Build polynomial: f(x) = secret + a1*x + a2*x^2 + ... + a_{m-1}*x^{m-1}
-    const coefficients = [secret];
-    for (let i = 1; i < m; i++) {
-        coefficients.push(randomFieldElement());
-    }
-    // Evaluate at x = 1..n
-    const shares = [];
-    for (let x = 1; x <= n; x++) {
-        let y = 0n;
-        let xPow = 1n;
-        for (const coeff of coefficients) {
-            y = fieldAdd(y, fieldMul(coeff, xPow));
-            xPow = fieldMul(xPow, BigInt(x));
-        }
-        // Encode share: index byte + 32-byte value
-        const shareBytes = new Uint8Array(33);
-        shareBytes[0] = x;
-        shareBytes.set(bigintToBytes32(y), 1);
-        shares.push(toBase64Url(shareBytes));
-    }
-    return shares;
-}
-/**
- * Reconstruct a BLS private key from M or more shares using Lagrange interpolation.
- * @param shares - array of share strings (base64url, at least m of them)
- * @param m - minimum number of shares required (used for validation only)
- */
-export function reconstructPrivateKey(shares, m) {
-    if (shares.length < m) {
-        throw new Error(`Need at least ${m} shares, got ${shares.length}`);
-    }
-    // Decode shares — take exactly m
-    const decoded = shares.slice(0, m).map((s) => {
-        const bytes = fromBase64Url(s);
-        if (bytes.length !== 33)
-            throw new Error('Invalid share format');
-        const x = BigInt(bytes[0]);
-        const y = bytes32ToBigint(bytes.slice(1));
-        return { x, y };
-    });
-    // Lagrange interpolation at x=0 to recover secret
-    let secret = 0n;
-    for (let i = 0; i < decoded.length; i++) {
-        const xi = decoded[i].x;
-        const yi = decoded[i].y;
-        // Compute Lagrange basis polynomial l_i(0)
-        let num = 1n;
-        let den = 1n;
-        for (let j = 0; j < decoded.length; j++) {
-            if (i === j)
-                continue;
-            const xj = decoded[j].x;
-            // num *= (0 - xj) = -xj
-            num = fieldMul(num, fieldMod(-xj));
-            // den *= (xi - xj)
-            den = fieldMul(den, fieldMod(xi - xj));
-        }
-        const lagrangeBasis = fieldMul(num, fieldInv(den));
-        secret = fieldAdd(secret, fieldMul(yi, lagrangeBasis));
-    }
-    return toBase64Url(bigintToBytes32(secret));
-}

package/sdk/threshold/src/index.test.ts

@@ -1,238 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  generateBlsKeyPair,
-  signEnvelopeBls,
-  aggregateSignatures,
-  verifyThresholdEnvelope,
-  splitPrivateKey,
-  reconstructPrivateKey,
-  type ThresholdConfig,
-  type ThresholdEnvelope,
-  type ProtocolEnvelope,
-} from './index.js'
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function makeEnvelope(): Omit<ProtocolEnvelope, never> {
-  return {
-    header: {
-      version: '7h3/0.1',
-      messageId: 'msg-test-001',
-      timestampMs: Date.now(),
-      ttlMs: 60_000,
-      sender: 'agent-alpha',
-      recipient: 'agent-beta',
-      nonce: 'nonce-abc',
-    },
-    body: {
-      intent: 'TASK',
-      content: 'approve-transaction-001',
-    },
-  }
-}
-
-function fromBase64Url(value: string): Uint8Array {
-  const padded = value
-    .replace(/-/g, '+')
-    .replace(/_/g, '/')
-    .padEnd(Math.ceil(value.length / 4) * 4, '=')
-  return new Uint8Array(Buffer.from(padded, 'base64'))
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe('generateBlsKeyPair', () => {
-  it('returns a 48-byte G1 public key and 32-byte private key (base64url)', () => {
-    const kp = generateBlsKeyPair()
-    expect(kp.publicKey).toBeTypeOf('string')
-    expect(kp.privateKey).toBeTypeOf('string')
-
-    const pubBytes = fromBase64Url(kp.publicKey)
-    const privBytes = fromBase64Url(kp.privateKey)
-    expect(pubBytes.length).toBe(48)
-    expect(privBytes.length).toBe(32)
-  })
-})
-
-describe('3-of-5 threshold round trip', () => {
-  it('aggregates 3 signatures and verifies successfully', async () => {
-    const config: ThresholdConfig = { m: 3, n: 5 }
-    const envelope = makeEnvelope()
-
-    // Generate 5 keypairs
-    const keypairs: Array<{ id: string; publicKey: string; privateKey: string }> = []
-    for (let i = 0; i < 5; i++) {
-      const kp = generateBlsKeyPair()
-      keypairs.push({ id: `agent-${i}`, ...kp })
-    }
-
-    const publicKeys: Record<string, string> = {}
-    for (const kp of keypairs) publicKeys[kp.id] = kp.publicKey
-
-    // Sign with first 3 agents
-    const partialSigs = await Promise.all(
-      keypairs.slice(0, 3).map((kp) =>
-        signEnvelopeBls(envelope, kp.privateKey, kp.id),
-      ),
-    )
-
-    const thresholdEnvelope = await aggregateSignatures(
-      partialSigs,
-      publicKeys,
-      envelope,
-      config,
-    )
-
-    expect(thresholdEnvelope.thresholdSignature.alg).toBe('BLS-G2-2')
-    expect(thresholdEnvelope.thresholdSignature.signerIds).toHaveLength(3)
-
-    const valid = await verifyThresholdEnvelope(thresholdEnvelope, publicKeys, config)
-    expect(valid).toBe(true)
-  })
-
-  it('throws when only 2 partial sigs are provided for 3-of-5', async () => {
-    const config: ThresholdConfig = { m: 3, n: 5 }
-    const envelope = makeEnvelope()
-
-    const keypairs = [generateBlsKeyPair(), generateBlsKeyPair()]
-    const ids = ['a0', 'a1']
-    const publicKeys: Record<string, string> = {}
-    ids.forEach((id, i) => { publicKeys[id] = keypairs[i].publicKey })
-
-    const partialSigs = await Promise.all(
-      keypairs.map((kp, i) => signEnvelopeBls(envelope, kp.privateKey, ids[i])),
-    )
-
-    await expect(
-      aggregateSignatures(partialSigs, publicKeys, envelope, config),
-    ).rejects.toThrow('Threshold not met')
-  })
-})
-
-describe('verifyThresholdEnvelope', () => {
-  async function build3of5() {
-    const config: ThresholdConfig = { m: 3, n: 5 }
-    const envelope = makeEnvelope()
-    const keypairs = Array.from({ length: 5 }, (_, i) => ({
-      id: `p${i}`,
-      ...generateBlsKeyPair(),
-    }))
-    const publicKeys: Record<string, string> = {}
-    for (const kp of keypairs) publicKeys[kp.id] = kp.publicKey
-
-    const partialSigs = await Promise.all(
-      keypairs.slice(0, 3).map((kp) =>
-        signEnvelopeBls(envelope, kp.privateKey, kp.id),
-      ),
-    )
-
-    const thresholdEnvelope = await aggregateSignatures(
-      partialSigs,
-      publicKeys,
-      envelope,
-      config,
-    )
-
-    return { thresholdEnvelope, publicKeys, config }
-  }
-
-  it('valid 3-of-5 envelope returns true', async () => {
-    const { thresholdEnvelope, publicKeys, config } = await build3of5()
-    const result = await verifyThresholdEnvelope(thresholdEnvelope, publicKeys, config)
-    expect(result).toBe(true)
-  })
-
-  it('tampered envelope body returns false', async () => {
-    const { thresholdEnvelope, publicKeys, config } = await build3of5()
-    const tampered: ThresholdEnvelope = {
-      ...thresholdEnvelope,
-      body: { ...thresholdEnvelope.body, content: 'tampered-content-99999' },
-    }
-    const result = await verifyThresholdEnvelope(tampered, publicKeys, config)
-    expect(result).toBe(false)
-  })
-
-  it('wrong public keys returns false', async () => {
-    const { thresholdEnvelope, config } = await build3of5()
-    // Replace all public keys with fresh unrelated ones
-    const wrongKeys: Record<string, string> = {}
-    for (const id of thresholdEnvelope.thresholdSignature.signerIds) {
-      wrongKeys[id] = generateBlsKeyPair().publicKey
-    }
-    const result = await verifyThresholdEnvelope(thresholdEnvelope, wrongKeys, config)
-    expect(result).toBe(false)
-  })
-})
-
-describe('Shamir Secret Sharing', () => {
-  it('splitPrivateKey(key, 3, 5) returns 5 shares', () => {
-    const kp = generateBlsKeyPair()
-    const shares = splitPrivateKey(kp.privateKey, 3, 5)
-    expect(shares).toHaveLength(5)
-    for (const s of shares) {
-      expect(s).toBeTypeOf('string')
-      expect(fromBase64Url(s).length).toBe(33) // 1 index byte + 32 value bytes
-    }
-  })
-
-  it('reconstructPrivateKey with any 3 shares recovers original key', () => {
-    const kp = generateBlsKeyPair()
-    const shares = splitPrivateKey(kp.privateKey, 3, 5)
-
-    // Try shares [0,1,2]
-    const rec1 = reconstructPrivateKey([shares[0], shares[1], shares[2]], 3)
-    expect(rec1).toBe(kp.privateKey)
-
-    // Try shares [1,3,4]
-    const rec2 = reconstructPrivateKey([shares[1], shares[3], shares[4]], 3)
-    expect(rec2).toBe(kp.privateKey)
-  })
-
-  it('different 3-share combinations produce the same key', () => {
-    const kp = generateBlsKeyPair()
-    const shares = splitPrivateKey(kp.privateKey, 3, 5)
-
-    const rec1 = reconstructPrivateKey([shares[0], shares[2], shares[4]], 3)
-    const rec2 = reconstructPrivateKey([shares[1], shares[2], shares[3]], 3)
-    expect(rec1).toBe(rec2)
-  })
-
-  it('only 2 shares cannot reconstruct the correct key', () => {
-    const kp = generateBlsKeyPair()
-    const shares = splitPrivateKey(kp.privateKey, 3, 5)
-
-    // With only 2 shares we underdetermine the polynomial — result will be wrong
-    const wrong = reconstructPrivateKey([shares[0], shares[1]], 2)
-    expect(wrong).not.toBe(kp.privateKey)
-  })
-})
-
-describe('2-of-2 simple multisig round trip', () => {
-  it('both agents sign, aggregate, verify — passes', async () => {
-    const config: ThresholdConfig = { m: 2, n: 2 }
-    const envelope = makeEnvelope()
-
-    const kp1 = { id: 'alice', ...generateBlsKeyPair() }
-    const kp2 = { id: 'bob', ...generateBlsKeyPair() }
-    const publicKeys: Record<string, string> = {
-      alice: kp1.publicKey,
-      bob: kp2.publicKey,
-    }
-
-    const partialSigs = await Promise.all([
-      signEnvelopeBls(envelope, kp1.privateKey, kp1.id),
-      signEnvelopeBls(envelope, kp2.privateKey, kp2.id),
-    ])
-
-    const thresholdEnvelope = await aggregateSignatures(
-      partialSigs,
-      publicKeys,
-      envelope,
-      config,
-    )
-
-    expect(thresholdEnvelope.thresholdSignature.threshold).toEqual(config)
-    const valid = await verifyThresholdEnvelope(thresholdEnvelope, publicKeys, config)
-    expect(valid).toBe(true)
-  })
-})