@leofcoin/chain 1.10.9 → 1.10.11

package/exports/browser/beacon-envelope.js

@@ -0,0 +1,163 @@
+import { w as weierstrass, r as randomBytes, c as concatBytes, F as Field, m as mod, p as pow2, s as sha256 } from './weierstrass-C-jX_jly.js';
+import { h as hmac, a as hkdf } from './hkdf-DhdhLAAv.js';
+
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// connects noble-curves to noble-hashes
+function getHash(hash) {
+    return {
+        hash,
+        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),
+        randomBytes,
+    };
+}
+function createCurve(curveDef, defHash) {
+    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });
+    return Object.freeze({ ...create(defHash), create });
+}
+
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');
+const secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const divNearest = (a, b) => (a + b / _2n) / b;
+/**
+ * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.
+ * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]
+ */
+function sqrtMod(y) {
+    const P = secp256k1P;
+    // prettier-ignore
+    const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+    // prettier-ignore
+    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+    const b2 = (y * y * y) % P; // x^3, 11
+    const b3 = (b2 * b2 * y) % P; // x^7
+    const b6 = (pow2(b3, _3n, P) * b3) % P;
+    const b9 = (pow2(b6, _3n, P) * b3) % P;
+    const b11 = (pow2(b9, _2n, P) * b2) % P;
+    const b22 = (pow2(b11, _11n, P) * b11) % P;
+    const b44 = (pow2(b22, _22n, P) * b22) % P;
+    const b88 = (pow2(b44, _44n, P) * b44) % P;
+    const b176 = (pow2(b88, _88n, P) * b88) % P;
+    const b220 = (pow2(b176, _44n, P) * b44) % P;
+    const b223 = (pow2(b220, _3n, P) * b3) % P;
+    const t1 = (pow2(b223, _23n, P) * b22) % P;
+    const t2 = (pow2(t1, _6n, P) * b2) % P;
+    const root = pow2(t2, _2n, P);
+    if (!Fp.eql(Fp.sqr(root), y))
+        throw new Error('Cannot find square root');
+    return root;
+}
+const Fp = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
+const secp256k1 = createCurve({
+    a: BigInt(0),
+    b: BigInt(7),
+    Fp,
+    n: secp256k1N,
+    // Base point (x, y) aka generator point
+    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),
+    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),
+    h: BigInt(1),
+    lowS: true,
+    /**
+     * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
+     * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
+     * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
+     * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
+     */
+    endo: {
+        beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
+        splitScalar: (k) => {
+            const n = secp256k1N;
+            const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');
+            const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');
+            const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');
+            const b2 = a1;
+            const POW_2_128 = BigInt('0x100000000000000000000000000000000'); // (2n**128n).toString(16)
+            const c1 = divNearest(b2 * k, n);
+            const c2 = divNearest(-b1 * k, n);
+            let k1 = mod(k - c1 * a1 - c2 * a2, n);
+            let k2 = mod(-c1 * b1 - c2 * b2, n);
+            const k1neg = k1 > POW_2_128;
+            const k2neg = k2 > POW_2_128;
+            if (k1neg)
+                k1 = n - k1;
+            if (k2neg)
+                k2 = n - k2;
+            if (k1 > POW_2_128 || k2 > POW_2_128) {
+                throw new Error('splitScalar: Endomorphism failed, k=' + k);
+            }
+            return { k1neg, k1, k2neg, k2 };
+        },
+    },
+}, sha256);
+// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.
+// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
+BigInt(0);
+secp256k1.ProjectivePoint;
+
+const encoder = new TextEncoder();
+const SCALAR_BYTES = 32;
+const context = (network, epoch, sender, recipient) => {
+  if (!network || epoch < 0n || !sender || !recipient || sender === recipient) {
+    throw new TypeError("invalid beacon share envelope context");
+  }
+  return encoder.encode(`leofcoin-beacon-share-v1:${network}:${epoch}:${sender}:${recipient}`);
+};
+const scalarBytes = (share) => {
+  if (share <= 0n || share >= secp256k1.CURVE.n) throw new RangeError("invalid beacon secret share");
+  const output = new Uint8Array(SCALAR_BYTES);
+  let value = share;
+  for (let index = output.length - 1; index >= 0; index -= 1) {
+    output[index] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return output;
+};
+const bytesScalar = (bytes) => {
+  if (bytes.length !== SCALAR_BYTES) throw new Error("invalid decrypted beacon share length");
+  let value = 0n;
+  for (const byte of bytes) value = value << 8n | BigInt(byte);
+  if (value <= 0n || value >= secp256k1.CURVE.n) throw new Error("invalid decrypted beacon share");
+  return value;
+};
+const encryptionKey = (privateKey, publicKey, aad) => {
+  if (!secp256k1.utils.isValidPrivateKey(privateKey)) throw new Error("invalid beacon encryption private key");
+  const sharedSecret = secp256k1.getSharedSecret(privateKey, publicKey, true);
+  return hkdf(sha256, sharedSecret, sha256(aad), aad, 32);
+};
+const importAesKey = (key, usage) => globalThis.crypto.subtle.importKey("raw", key, { name: "AES-GCM" }, false, [usage]);
+const createBeaconEncryptionKey = (randomPrivateKey = () => secp256k1.utils.randomPrivateKey()) => {
+  const privateKey = randomPrivateKey();
+  if (!secp256k1.utils.isValidPrivateKey(privateKey)) throw new Error("invalid generated beacon encryption key");
+  return { privateKey, publicKey: secp256k1.getPublicKey(privateKey, true) };
+};
+const encryptBeaconShare = async (share, recipientPublicKey, network, epoch, sender, recipient, randomPrivateKey, randomNonce = () => globalThis.crypto.getRandomValues(new Uint8Array(12))) => {
+  const aad = context(network, epoch, sender, recipient);
+  const ephemeral = createBeaconEncryptionKey(randomPrivateKey);
+  const nonce = randomNonce();
+  if (nonce.length !== 12) throw new Error("beacon share nonce must contain 12 bytes");
+  const key = await importAesKey(encryptionKey(ephemeral.privateKey, recipientPublicKey, aad), "encrypt");
+  const ciphertext = await globalThis.crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: nonce, additionalData: aad, tagLength: 128 },
+    key,
+    scalarBytes(share)
+  );
+  return { ciphertext: new Uint8Array(ciphertext), ephemeralPublicKey: ephemeral.publicKey, nonce };
+};
+const decryptBeaconShare = async (envelope, recipientPrivateKey, network, epoch, sender, recipient) => {
+  if (envelope.ephemeralPublicKey.length !== 33 || envelope.nonce.length !== 12 || envelope.ciphertext.length !== 48) {
+    throw new Error("invalid beacon share envelope");
+  }
+  const aad = context(network, epoch, sender, recipient);
+  const key = await importAesKey(encryptionKey(recipientPrivateKey, envelope.ephemeralPublicKey, aad), "decrypt");
+  const plaintext = await globalThis.crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: envelope.nonce, additionalData: aad, tagLength: 128 },
+    key,
+    envelope.ciphertext
+  );
+  return bytesScalar(new Uint8Array(plaintext));
+};
+
+export { createBeaconEncryptionKey, decryptBeaconShare, encryptBeaconShare };

package/exports/browser/beacon-epoch.js

@@ -0,0 +1,116 @@
+import { s as sha256 } from './weierstrass-C-jX_jly.js';
+import { t as toBase58, f as fromBase58 } from './index-CvKt4UDE.js';
+import { deriveBeaconGroupPublicKey } from './beacon.js';
+import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
+
+const encoder = new TextEncoder();
+const lengthPrefix = (bytes) => {
+  if (bytes.length > 65535) throw new Error("beacon config field is too large");
+  const output = new Uint8Array(bytes.length + 2);
+  new DataView(output.buffer).setUint16(0, bytes.length, false);
+  output.set(bytes, 2);
+  return output;
+};
+const concatenate = (parts) => {
+  const output = new Uint8Array(parts.reduce((size, part) => size + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    output.set(part, offset);
+    offset += part.length;
+  }
+  return output;
+};
+const uint64 = (value) => {
+  if (value < 0n || value > 0xffffffffffffffffn) throw new RangeError("beacon epoch is outside uint64");
+  const bytes = new Uint8Array(8);
+  new DataView(bytes.buffer).setBigUint64(0, value, false);
+  return bytes;
+};
+const beaconParticipants = (validators) => {
+  const sorted = [...validators].sort();
+  if (sorted.length < 2 || new Set(sorted).size !== sorted.length || sorted.some((validator) => !validator)) {
+    throw new Error("beacon requires at least two unique validators");
+  }
+  return new Map(sorted.map((validator, index) => [validator, BigInt(index + 1)]));
+};
+const validateBeaconEpochConfig = (config) => {
+  try {
+    if (config.epoch < 0n) return false;
+    const participants = beaconParticipants(config.validators);
+    const validators = [...participants.keys()];
+    if (config.threshold !== quorumThreshold(validators.length) || config.dealers.length < config.threshold)
+      return false;
+    const dealers = [...config.dealers].sort((left, right) => left.validator.localeCompare(right.validator));
+    if (new Set(dealers.map(({ validator }) => validator)).size !== dealers.length) return false;
+    return dealers.every(({ validator, commitments }) => {
+      if (!participants.has(validator) || commitments.length !== config.threshold) return false;
+      return commitments.every((commitment) => fromBase58(commitment).length === 48);
+    });
+  } catch {
+    return false;
+  }
+};
+const canonicalBeaconEpochConfig = (config) => {
+  if (!validateBeaconEpochConfig(config)) throw new Error("invalid beacon epoch config");
+  return {
+    epoch: config.epoch,
+    threshold: config.threshold,
+    validators: [...config.validators].sort(),
+    dealers: [...config.dealers].map((dealer) => ({ validator: dealer.validator, commitments: [...dealer.commitments] })).sort((left, right) => left.validator.localeCompare(right.validator))
+  };
+};
+const encodeBeaconEpochConfig = (input) => {
+  const config = canonicalBeaconEpochConfig(input);
+  const parts = [encoder.encode("leofcoin-beacon-config-v1"), uint64(config.epoch), uint64(BigInt(config.threshold))];
+  parts.push(uint64(BigInt(config.validators.length)));
+  for (const validator of config.validators) parts.push(lengthPrefix(encoder.encode(validator)));
+  parts.push(uint64(BigInt(config.dealers.length)));
+  for (const dealer of config.dealers) {
+    parts.push(lengthPrefix(encoder.encode(dealer.validator)));
+    for (const commitment of dealer.commitments) parts.push(lengthPrefix(fromBase58(commitment)));
+  }
+  return concatenate(parts);
+};
+const beaconEpochDigest = (config) => toBase58(sha256(encodeBeaconEpochConfig(config)));
+const beaconEpochGroupPublicKey = (config) => {
+  const canonical = canonicalBeaconEpochConfig(config);
+  return toBase58(
+    deriveBeaconGroupPublicKey(
+      canonical.dealers.map(({ commitments }) => commitments.map((commitment) => fromBase58(commitment)))
+    )
+  );
+};
+class BeaconEpochVotes {
+  #votes = /* @__PURE__ */ new Map();
+  #equivocations = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = canonicalBeaconEpochConfig(config);
+    this.configDigest = beaconEpochDigest(this.config);
+  }
+  add(vote) {
+    if (vote.epoch !== this.config.epoch || !this.config.validators.includes(vote.from) || !vote.signature || vote.configDigest !== this.configDigest) {
+      const existing2 = this.#votes.get(vote.from);
+      if (existing2 && vote.epoch === existing2.epoch && vote.configDigest !== existing2.configDigest) {
+        this.#equivocations.set(vote.from, [existing2, vote]);
+        return "equivocation";
+      }
+      return "invalid";
+    }
+    const existing = this.#votes.get(vote.from);
+    if (existing) return existing.signature === vote.signature ? "duplicate" : "equivocation";
+    this.#votes.set(vote.from, Object.freeze({ ...vote }));
+    return "accepted";
+  }
+  get ready() {
+    return this.#votes.size >= this.config.threshold;
+  }
+  certificate() {
+    if (!this.ready) throw new Error("beacon epoch does not have a quorum certificate");
+    return [...this.#votes.values()].sort((left, right) => left.from.localeCompare(right.from));
+  }
+  equivocation(validator) {
+    return this.#equivocations.get(validator);
+  }
+}
+
+export { BeaconEpochVotes, beaconEpochDigest, beaconEpochGroupPublicKey, beaconParticipants, canonicalBeaconEpochConfig, encodeBeaconEpochConfig, validateBeaconEpochConfig };

package/exports/browser/beacon-lifecycle.js

@@ -0,0 +1,154 @@
+import { a as hkdf } from './hkdf-DhdhLAAv.js';
+import { s as sha256 } from './weierstrass-C-jX_jly.js';
+import { canonicalBeaconEpochConfig, beaconEpochDigest } from './beacon-epoch.js';
+import './index-CvKt4UDE.js';
+import './beacon.js';
+import './quorum-S_qdgiAY.js';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const PRIVATE_PREFIX = "beacon/private/";
+const PUBLIC_PREFIX = "beacon/public/";
+const parse = (value) => {
+  const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+  return JSON.parse(decoder.decode(bytes));
+};
+const stringify = (value) => encoder.encode(JSON.stringify(value, (_, item) => typeof item === "bigint" ? `${item}n` : item));
+const revive = (value) => {
+  if (Array.isArray(value)) return value.map(revive);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, revive(item)]));
+  }
+  if (typeof value === "string" && /^\d+n$/.test(value)) return BigInt(value.slice(0, -1));
+  return value;
+};
+const storageKey = (prefix, network, epoch) => `${prefix}${network}/${epoch}`;
+const sealingContext = (network, validator) => encoder.encode(`leofcoin-beacon-storage-v1:${network}:${validator}`);
+const sealingKey = async (network, validator, sign) => {
+  const context = sealingContext(network, validator);
+  const signature = await sign(sha256(context));
+  return hkdf(sha256, signature, sha256(context), context, 32);
+};
+const aesKey = (raw, usage) => globalThis.crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, [usage]);
+const validateCertificate = (config, certificate) => {
+  const digest = beaconEpochDigest(config);
+  const voters = /* @__PURE__ */ new Set();
+  for (const vote of certificate) {
+    if (vote.epoch !== config.epoch || vote.configDigest !== digest || !config.validators.includes(vote.from) || !vote.signature || voters.has(vote.from))
+      throw new Error("invalid beacon epoch certificate");
+    voters.add(vote.from);
+  }
+  if (voters.size < config.threshold) throw new Error("beacon epoch certificate is below threshold");
+};
+const persistPublicBeaconEpoch = async (store, network, active) => {
+  const config = canonicalBeaconEpochConfig(active.config);
+  validateCertificate(config, active.certificate);
+  await store.put(
+    storageKey(PUBLIC_PREFIX, network, config.epoch),
+    stringify({ config, certificate: active.certificate })
+  );
+};
+const loadPublicBeaconEpoch = async (store, network, epoch) => {
+  const key = storageKey(PUBLIC_PREFIX, network, epoch);
+  if (!await store.has(key)) return void 0;
+  const active = revive(parse(await store.get(key)));
+  const config = canonicalBeaconEpochConfig(active.config);
+  validateCertificate(config, active.certificate);
+  return { config, certificate: active.certificate };
+};
+const persistPrivateBeaconEpoch = async (store, network, validator, record, sign, randomNonce = () => globalThis.crypto.getRandomValues(new Uint8Array(12))) => {
+  const nonce = randomNonce();
+  if (nonce.length !== 12) throw new Error("beacon storage nonce must contain 12 bytes");
+  const context = sealingContext(network, validator);
+  const key = await aesKey(await sealingKey(network, validator, sign), "encrypt");
+  const ciphertext = await globalThis.crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: nonce, additionalData: context, tagLength: 128 },
+    key,
+    stringify(record)
+  );
+  const sealed = { version: 1, nonce: [...nonce], ciphertext: [...new Uint8Array(ciphertext)] };
+  await store.put(storageKey(PRIVATE_PREFIX, network, record.epoch), stringify(sealed));
+};
+const loadPrivateBeaconEpoch = async (store, network, validator, epoch, sign) => {
+  const storage = storageKey(PRIVATE_PREFIX, network, epoch);
+  if (!await store.has(storage)) return void 0;
+  const sealed = parse(await store.get(storage));
+  if (sealed.version !== 1 || sealed.nonce.length !== 12 || sealed.ciphertext.length < 17) {
+    throw new Error("invalid sealed beacon epoch record");
+  }
+  const context = sealingContext(network, validator);
+  const key = await aesKey(await sealingKey(network, validator, sign), "decrypt");
+  const plaintext = await globalThis.crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: new Uint8Array(sealed.nonce), additionalData: context, tagLength: 128 },
+    key,
+    new Uint8Array(sealed.ciphertext)
+  );
+  const record = revive(parse(new Uint8Array(plaintext)));
+  if (record.epoch !== epoch) throw new Error("sealed beacon epoch does not match its storage key");
+  return record;
+};
+const clearBeaconEpochStorage = async (stores, network) => {
+  for (const store of stores) {
+    for (const key of await store.keys()) {
+      if (key.startsWith(`${PRIVATE_PREFIX}${network}/`) || key.startsWith(`${PUBLIC_PREFIX}${network}/`)) {
+        await store.delete(key);
+      }
+    }
+  }
+};
+class BeaconLifecycle {
+  #active;
+  #pending = /* @__PURE__ */ new Map();
+  constructor(epochLength) {
+    if (!Number.isSafeInteger(epochLength) || epochLength < 2)
+      throw new RangeError("beacon epoch length must be at least 2");
+    this.epochLength = epochLength;
+  }
+  epochAtHeight(height) {
+    if (!Number.isSafeInteger(height) || height < 0) throw new RangeError("invalid block height");
+    return BigInt(Math.floor(height / this.epochLength));
+  }
+  ceremonyEpoch(height) {
+    return this.epochAtHeight(height) + 1n;
+  }
+  stage(active) {
+    const config = canonicalBeaconEpochConfig(active.config);
+    validateCertificate(config, active.certificate);
+    this.#pending.set(config.epoch, { config, certificate: [...active.certificate] });
+  }
+  restore(active) {
+    const config = canonicalBeaconEpochConfig(active.config);
+    validateCertificate(config, active.certificate);
+    this.#active = { config, certificate: [...active.certificate] };
+  }
+  advance(height) {
+    const epoch = this.epochAtHeight(height);
+    const pending = this.#pending.get(epoch);
+    if (pending) {
+      this.#active = pending;
+      this.#pending.delete(epoch);
+    }
+    return this.#active;
+  }
+  get active() {
+    return this.#active;
+  }
+}
+const storedEpochs = async (store, prefix, network) => {
+  const scoped = `${prefix}${network}/`;
+  return (await store.keys()).filter((key) => key.startsWith(scoped)).map((key) => key.slice(scoped.length)).filter((epoch) => /^\d+$/.test(epoch)).map(BigInt).sort((left, right) => left > right ? -1 : left < right ? 1 : 0);
+};
+const restoreBeaconLifecycle = async (publicStore, privateStore, network, validator, height, epochLength, sign) => {
+  const lifecycle = new BeaconLifecycle(epochLength);
+  const currentEpoch = lifecycle.epochAtHeight(height);
+  const epochs = await storedEpochs(publicStore, PUBLIC_PREFIX, network);
+  const activeEpoch = epochs.find((epoch) => epoch <= currentEpoch);
+  if (activeEpoch === void 0) return { lifecycle };
+  const active = await loadPublicBeaconEpoch(publicStore, network, activeEpoch);
+  if (!active) throw new Error("beacon public epoch disappeared during restore");
+  lifecycle.restore(active);
+  const privateEpoch = await loadPrivateBeaconEpoch(privateStore, network, validator, activeEpoch, sign);
+  return privateEpoch ? { lifecycle, privateEpoch } : { lifecycle };
+};
+
+export { BeaconLifecycle, clearBeaconEpochStorage, loadPrivateBeaconEpoch, loadPublicBeaconEpoch, persistPrivateBeaconEpoch, persistPublicBeaconEpoch, restoreBeaconLifecycle };

package/exports/browser/beacon-round.js

@@ -0,0 +1,76 @@
+import { f as fromBase58, t as toBase58 } from './index-CvKt4UDE.js';
+import { beaconMessage, deriveBeaconPublicShare, verifyBeaconSignatureShare, reconstructBeaconSignature, verifyBeaconProof, beaconRandomness } from './beacon.js';
+import { canonicalBeaconEpochConfig, beaconParticipants, beaconEpochGroupPublicKey } from './beacon-epoch.js';
+import './weierstrass-C-jX_jly.js';
+import './quorum-S_qdgiAY.js';
+
+class BeaconRound {
+  #config;
+  #groupPublicKey;
+  #message;
+  #participants;
+  #publicShares = /* @__PURE__ */ new Map();
+  #shares = /* @__PURE__ */ new Map();
+  #equivocations = /* @__PURE__ */ new Map();
+  constructor(network, configInput, round, previousProof) {
+    if (round < 0n || previousProof.length !== 96) throw new Error("invalid beacon round input");
+    this.#config = canonicalBeaconEpochConfig(configInput);
+    this.epoch = this.#config.epoch;
+    this.round = round;
+    this.#participants = beaconParticipants(this.#config.validators);
+    this.#groupPublicKey = fromBase58(beaconEpochGroupPublicKey(this.#config));
+    this.#message = beaconMessage(network, this.epoch, round, previousProof);
+    const dealerCommitments = this.#config.dealers.map(
+      ({ commitments }) => commitments.map((commitment) => fromBase58(commitment))
+    );
+    for (const [validator, participant] of this.#participants) {
+      this.#publicShares.set(validator, deriveBeaconPublicShare(participant, dealerCommitments));
+    }
+  }
+  add(share) {
+    const expectedParticipant = this.#participants.get(share.from);
+    if (expectedParticipant === void 0 || expectedParticipant !== share.participant || !share.signature)
+      return "invalid";
+    const existing = this.#shares.get(share.from);
+    if (existing) {
+      if (existing.signature === share.signature) return "duplicate";
+      this.#equivocations.set(share.from, [existing, share]);
+      return "equivocation";
+    }
+    let signature;
+    try {
+      signature = fromBase58(share.signature);
+    } catch {
+      return "invalid";
+    }
+    if (!verifyBeaconSignatureShare(signature, this.#message, this.#publicShares.get(share.from))) return "invalid";
+    this.#shares.set(share.from, Object.freeze({ ...share }));
+    return "accepted";
+  }
+  get ready() {
+    return this.#shares.size >= this.#config.threshold;
+  }
+  finalize() {
+    if (!this.ready) throw new Error("beacon round has not reached threshold");
+    const shares = [...this.#shares.values()].map(({ participant, signature }) => ({
+      participant,
+      signature: fromBase58(signature)
+    }));
+    const proof = reconstructBeaconSignature(shares, this.#config.threshold);
+    if (!verifyBeaconProof(proof, this.#message, this.#groupPublicKey)) {
+      throw new Error("reconstructed beacon proof does not match the activated group key");
+    }
+    return Object.freeze({
+      epoch: this.epoch,
+      round: this.round,
+      proof: toBase58(proof),
+      randomness: toBase58(beaconRandomness(proof)),
+      signers: [...this.#shares.keys()].sort()
+    });
+  }
+  equivocation(validator) {
+    return this.#equivocations.get(validator);
+  }
+}
+
+export { BeaconRound };

package/exports/browser/beacon-wire.js

@@ -0,0 +1,99 @@
+import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-D7FUx7Dd.js';
+import { f as fromBase58 } from './index-CvKt4UDE.js';
+import './proposal.proto-BcUgd885.js';
+import 'crypto';
+
+const validInteger = (value, minimum = 0n) => {
+  try {
+    return BigInt(value) >= minimum;
+  } catch {
+    return false;
+  }
+};
+const validateBeaconCommitmentData = (message) => {
+  if (!validInteger(message.epoch) || !validInteger(message.participant, 1n) || !validInteger(message.threshold, 2n) || typeof message.from !== "string" || !message.from || !Array.isArray(message.commitments)) {
+    return false;
+  }
+  const threshold = Number(message.threshold);
+  if (!Number.isSafeInteger(threshold) || message.commitments.length !== threshold) return false;
+  return message.commitments.every((commitment) => {
+    if (typeof commitment !== "string" || commitment.length > 128) return false;
+    try {
+      return fromBase58(commitment).length === 48;
+    } catch {
+      return false;
+    }
+  });
+};
+const validateBeaconShareData = (message) => {
+  if (!validInteger(message.epoch) || !validInteger(message.round) || !validInteger(message.participant, 1n) || typeof message.from !== "string" || !message.from || typeof message.signatureShare !== "string" || message.signatureShare.length > 256) {
+    return false;
+  }
+  try {
+    return fromBase58(message.signatureShare).length === 96;
+  } catch {
+    return false;
+  }
+};
+const validateBeaconActivationData = (message) => {
+  if (!validInteger(message.epoch) || typeof message.from !== "string" || !message.from || typeof message.configDigest !== "string" || message.configDigest.length > 64)
+    return false;
+  try {
+    return fromBase58(message.configDigest).length === 32;
+  } catch {
+    return false;
+  }
+};
+const commitmentSignableData = (validatorsAddress, message) => ({
+  from: String(message.from),
+  to: validatorsAddress,
+  method: "beacon:commitment",
+  params: [
+    String(message.epoch),
+    String(message.threshold),
+    String(message.participant),
+    ...message.commitments.map(String)
+  ],
+  timestamp: 0
+});
+const shareSignableData = (validatorsAddress, message) => ({
+  from: String(message.from),
+  to: validatorsAddress,
+  method: "beacon:share",
+  params: [String(message.epoch), String(message.round), String(message.participant), String(message.signatureShare)],
+  timestamp: 0
+});
+const activationSignableData = (validatorsAddress, message) => ({
+  from: String(message.from),
+  to: validatorsAddress,
+  method: "beacon:activation",
+  params: [String(message.epoch), String(message.configDigest)],
+  timestamp: 0
+});
+const signBeaconCommitmentMessage = async (validatorsAddress, message, identity) => {
+  if (!validateBeaconCommitmentData(message)) throw new Error("invalid beacon commitment");
+  return (await signTransaction(commitmentSignableData(validatorsAddress, message), identity)).signature;
+};
+const signBeaconShareMessage = async (validatorsAddress, message, identity) => {
+  if (!validateBeaconShareData(message)) throw new Error("invalid beacon signature share");
+  return (await signTransaction(shareSignableData(validatorsAddress, message), identity)).signature;
+};
+const signBeaconActivationMessage = async (validatorsAddress, message, identity) => {
+  if (!validateBeaconActivationData(message)) throw new Error("invalid beacon activation");
+  return (await signTransaction(activationSignableData(validatorsAddress, message), identity)).signature;
+};
+const verifyIdentitySignature = async (message, signable, network) => {
+  if (typeof message.signature !== "string" || !message.signature) return false;
+  try {
+    const verifier = new MultiWallet(network);
+    await verifier.fromAddress(message.from, null, network);
+    return verifier.verify(fromBase58(message.signature), await createTransactionHash(signable));
+  } catch {
+    return false;
+  }
+};
+const verifyBeaconCommitmentMessage = async (validatorsAddress, message, network) => validateBeaconCommitmentData(message) && verifyIdentitySignature(message, commitmentSignableData(validatorsAddress, message), network);
+const verifyBeaconShareMessage = async (validatorsAddress, message, network) => validateBeaconShareData(message) && verifyIdentitySignature(message, shareSignableData(validatorsAddress, message), network);
+const verifyBeaconActivationMessage = async (validatorsAddress, message, network) => validateBeaconActivationData(message) && verifyIdentitySignature(message, activationSignableData(validatorsAddress, message), network);
+
+export { signBeaconActivationMessage, signBeaconCommitmentMessage, signBeaconShareMessage, validateBeaconActivationData, validateBeaconCommitmentData, validateBeaconShareData, verifyBeaconActivationMessage, verifyBeaconCommitmentMessage, verifyBeaconShareMessage };