@7h3/protocol 0.5.0 → 0.5.1

package/sdk/rust/tests/keys.rs

@@ -1,189 +0,0 @@
-use protocol_7h3::keys::{
-    KeyEntry, KeyRotationManager, ManagedKeyPair, RevocationRegistry, WellKnownKeysDocument,
-};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn now_ms() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_millis() as u64
-}
-
-fn make_key_entry(id: &str, revoked: Option<bool>, expires: Option<u64>) -> KeyEntry {
-    KeyEntry {
-        id: id.to_string(),
-        algorithm: "Ed25519".to_string(),
-        public_key: "dGVzdC1wdWJsaWMta2V5".to_string(),
-        created: now_ms() - 1000,
-        expires,
-        revoked,
-        revoked_at: None,
-    }
-}
-
-// 1. WellKnownKeysDocument round-trip JSON serialization
-#[test]
-fn test_well_known_document_json_round_trip() {
-    let entry = make_key_entry("key-1", None, None);
-    let doc = WellKnownKeysDocument::new(vec![entry]);
-
-    let json = doc.to_json().expect("serialization should succeed");
-    let restored = WellKnownKeysDocument::from_json(&json).expect("deserialization should succeed");
-
-    assert_eq!(restored.version, "7h3/0.1");
-    assert_eq!(restored.keys.len(), 1);
-    assert_eq!(restored.keys[0].id, "key-1");
-    assert_eq!(restored.keys[0].algorithm, "Ed25519");
-}
-
-// 2. get_active_key finds non-revoked keys
-#[test]
-fn test_get_active_key_finds_active() {
-    let entry = make_key_entry("key-active", None, None);
-    let doc = WellKnownKeysDocument::new(vec![entry]);
-
-    let found = doc.get_active_key("key-active");
-    assert!(found.is_some(), "should find an active key");
-    assert_eq!(found.unwrap().id, "key-active");
-}
-
-// 3. get_active_key ignores revoked keys
-#[test]
-fn test_get_active_key_ignores_revoked() {
-    let revoked = make_key_entry("key-revoked", Some(true), None);
-    let doc = WellKnownKeysDocument::new(vec![revoked]);
-
-    let found = doc.get_active_key("key-revoked");
-    assert!(found.is_none(), "should NOT find a revoked key");
-}
-
-// 3b. get_active_key ignores expired keys
-#[test]
-fn test_get_active_key_ignores_expired() {
-    // expires 10 seconds in the past
-    let expired = make_key_entry("key-expired", None, Some(now_ms() - 10_000));
-    let doc = WellKnownKeysDocument::new(vec![expired]);
-
-    let found = doc.get_active_key("key-expired");
-    assert!(found.is_none(), "should NOT find an expired key");
-}
-
-// 4. KeyRotationManager: add_key + get_current_key
-#[test]
-fn test_rotation_manager_add_and_get_current() {
-    let mgr = KeyRotationManager::new(86_400_000, 3_600_000);
-
-    let pair = ManagedKeyPair {
-        id: "rot-key-1".to_string(),
-        public_key: "pub1".to_string(),
-        private_key: "priv1".to_string(),
-        created: now_ms(),
-        expires_at: None,
-    };
-    mgr.add_key(pair);
-
-    let current = mgr.get_current_key();
-    assert!(current.is_some(), "should return current key");
-    assert_eq!(current.unwrap().id, "rot-key-1");
-}
-
-// 4b. get_current_key returns the most recent non-expired key
-#[test]
-fn test_rotation_manager_returns_most_recent() {
-    let mgr = KeyRotationManager::new(86_400_000, 3_600_000);
-    let base = now_ms();
-
-    mgr.add_key(ManagedKeyPair {
-        id: "older".to_string(),
-        public_key: "pub-older".to_string(),
-        private_key: "priv-older".to_string(),
-        created: base - 5000,
-        expires_at: None,
-    });
-    mgr.add_key(ManagedKeyPair {
-        id: "newer".to_string(),
-        public_key: "pub-newer".to_string(),
-        private_key: "priv-newer".to_string(),
-        created: base,
-        expires_at: None,
-    });
-
-    let current = mgr.get_current_key().expect("should have a current key");
-    assert_eq!(current.id, "newer");
-}
-
-// 4c. get_current_key excludes expired keys
-#[test]
-fn test_rotation_manager_excludes_expired() {
-    let mgr = KeyRotationManager::new(86_400_000, 3_600_000);
-
-    mgr.add_key(ManagedKeyPair {
-        id: "exp-key".to_string(),
-        public_key: "pub-exp".to_string(),
-        private_key: "priv-exp".to_string(),
-        created: now_ms() - 2000,
-        expires_at: Some(now_ms() - 1000), // already expired
-    });
-
-    let current = mgr.get_current_key();
-    assert!(current.is_none(), "expired key should not be returned as current");
-}
-
-// 5. KeyRotationManager: get_well_known_document structure
-#[test]
-fn test_rotation_manager_well_known_document() {
-    let mgr = KeyRotationManager::new(86_400_000, 3_600_000);
-
-    mgr.add_key(ManagedKeyPair {
-        id: "doc-key-1".to_string(),
-        public_key: "pub-doc".to_string(),
-        private_key: "priv-doc".to_string(),
-        created: now_ms(),
-        expires_at: None,
-    });
-
-    let doc = mgr.get_well_known_document();
-    assert_eq!(doc.version, "7h3/0.1");
-    assert_eq!(doc.keys.len(), 1);
-    assert_eq!(doc.keys[0].id, "doc-key-1");
-    assert_eq!(doc.keys[0].algorithm, "Ed25519");
-    assert_eq!(doc.keys[0].public_key, "pub-doc");
-    // non-expired key should not be marked revoked
-    assert!(doc.keys[0].revoked.is_none() || !doc.keys[0].revoked.unwrap());
-}
-
-// 6. RevocationRegistry: revoke + is_revoked
-#[test]
-fn test_revocation_registry_revoke_and_check() {
-    let registry = RevocationRegistry::new();
-
-    assert!(!registry.is_revoked("key-x"), "should not be revoked initially");
-    registry.revoke("key-x", Some("compromised"));
-    assert!(registry.is_revoked("key-x"), "should be revoked after revoke()");
-    assert!(!registry.is_revoked("key-y"), "unrelated key should not be revoked");
-}
-
-// 7. RevocationRegistry: get_list contains correct fields
-#[test]
-fn test_revocation_registry_get_list() {
-    let registry = RevocationRegistry::new();
-    registry.revoke("key-a", Some("expired"));
-    registry.revoke("key-b", None);
-
-    let list = registry.get_list();
-
-    assert_eq!(list["version"], "7h3/0.1");
-    let revoked_keys = list["revokedKeys"].as_array().expect("revokedKeys should be array");
-    assert_eq!(revoked_keys.len(), 2);
-
-    // Find key-a in the list
-    let key_a = revoked_keys.iter().find(|e| e["id"] == "key-a").expect("key-a should be in list");
-    assert!(key_a["revokedAt"].as_u64().unwrap() > 0, "revokedAt should be a positive timestamp");
-    assert_eq!(key_a["reason"], "expired");
-
-    // Find key-b in the list — no reason
-    let key_b = revoked_keys.iter().find(|e| e["id"] == "key-b").expect("key-b should be in list");
-    assert!(key_b["revokedAt"].as_u64().unwrap() > 0);
-    assert!(key_b.get("reason").is_none() || key_b["reason"].is_null());
-}

package/sdk/threshold/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/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/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/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));
-}