@leofcoin/chain 1.10.10 → 1.10.12

package/exports/beacon-envelope.js

@@ -0,0 +1,68 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { hkdf } from '@noble/hashes/hkdf';
+import { sha256 } from '@noble/hashes/sha256';
+
+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/beacon-epoch.js

@@ -0,0 +1,117 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { toBase58, fromBase58 } from '@vandeurenglenn/typed-array-utils';
+import { deriveBeaconGroupPublicKey } from './beacon.js';
+import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
+import '@noble/curves/bls12-381';
+
+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/beacon-lifecycle.js

@@ -0,0 +1,155 @@
+import { hkdf } from '@noble/hashes/hkdf';
+import { sha256 } from '@noble/hashes/sha256';
+import { canonicalBeaconEpochConfig, beaconEpochDigest } from './beacon-epoch.js';
+import '@vandeurenglenn/typed-array-utils';
+import './beacon.js';
+import '@noble/curves/bls12-381';
+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/beacon-round.js

@@ -0,0 +1,77 @@
+import { fromBase58, toBase58 } from '@vandeurenglenn/typed-array-utils';
+import { beaconMessage, deriveBeaconPublicShare, verifyBeaconSignatureShare, reconstructBeaconSignature, verifyBeaconProof, beaconRandomness } from './beacon.js';
+import { canonicalBeaconEpochConfig, beaconParticipants, beaconEpochGroupPublicKey } from './beacon-epoch.js';
+import '@noble/curves/bls12-381';
+import '@noble/hashes/sha256';
+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/beacon-wire.js

@@ -0,0 +1,98 @@
+import { signTransaction, createTransactionHash } from '@leofcoin/lib';
+import MultiWallet from '@leofcoin/multi-wallet';
+import { fromBase58 } from '@vandeurenglenn/typed-array-utils';
+
+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 };

package/exports/beacon.js

@@ -0,0 +1,141 @@
+import { bls12_381 } from '@noble/curves/bls12-381';
+import { sha256 } from '@noble/hashes/sha256';
+
+const encoder = new TextEncoder();
+const Fr = bls12_381.fields.Fr;
+const G1 = bls12_381.G1.ProjectivePoint;
+const G2 = bls12_381.G2.ProjectivePoint;
+const assertParticipant = (participant) => {
+  if (typeof participant !== "bigint" || participant <= 0n || participant >= Fr.ORDER) {
+    throw new TypeError("beacon participant identifiers must be non-zero field elements");
+  }
+};
+const assertThreshold = (threshold, participantCount) => {
+  if (!Number.isSafeInteger(threshold) || threshold < 2 || threshold > participantCount) {
+    throw new RangeError("beacon threshold must be between 2 and the participant count");
+  }
+};
+const assertUniqueParticipants = (participants) => {
+  for (const participant of participants) assertParticipant(participant);
+  if (new Set(participants).size !== participants.length) throw new Error("duplicate beacon participant");
+};
+const evaluatePolynomial = (coefficients, x) => {
+  let result = 0n;
+  for (let index = coefficients.length - 1; index >= 0; index -= 1) {
+    result = Fr.add(Fr.mul(result, x), coefficients[index]);
+  }
+  return result;
+};
+const evaluateCommitments = (commitments, x) => {
+  let result = G1.ZERO;
+  let power = 1n;
+  for (const encoded of commitments) {
+    const commitment = G1.fromHex(encoded);
+    commitment.assertValidity();
+    result = result.add(commitment.multiply(power));
+    power = Fr.mul(power, x);
+  }
+  return result;
+};
+const sumPoints = (points) => {
+  let result = G1.ZERO;
+  for (const encoded of points) {
+    const point = G1.fromHex(encoded);
+    point.assertValidity();
+    result = result.add(point);
+  }
+  return result;
+};
+const lagrangeAtZero = (participant, participants) => {
+  let numerator = 1n;
+  let denominator = 1n;
+  for (const other of participants) {
+    if (other === participant) continue;
+    numerator = Fr.mul(numerator, Fr.neg(other));
+    denominator = Fr.mul(denominator, Fr.sub(participant, other));
+  }
+  return Fr.mul(numerator, Fr.inv(denominator));
+};
+const createBeaconContribution = (participants, threshold, randomScalar) => {
+  assertUniqueParticipants(participants);
+  assertThreshold(threshold, participants.length);
+  const coefficients = Array.from({ length: threshold }, () => {
+    const scalar = Fr.create(randomScalar());
+    if (scalar === 0n) throw new Error("beacon contribution contains a zero coefficient");
+    return scalar;
+  });
+  return {
+    commitments: coefficients.map((coefficient) => G1.BASE.multiply(coefficient).toRawBytes(true)),
+    shares: new Map(participants.map((participant) => [participant, evaluatePolynomial(coefficients, participant)]))
+  };
+};
+const verifyBeaconShare = (participant, share, commitments) => {
+  try {
+    assertParticipant(participant);
+    if (commitments.length < 2) return false;
+    return G1.BASE.multiply(Fr.create(share)).equals(evaluateCommitments(commitments, participant));
+  } catch {
+    return false;
+  }
+};
+const combineBeaconShares = (shares) => {
+  if (shares.length < 2) throw new Error("at least two dealer shares are required");
+  return shares.reduce((total, share) => Fr.add(total, Fr.create(share)), 0n);
+};
+const deriveBeaconPublicShare = (participant, dealerCommitments) => {
+  assertParticipant(participant);
+  if (dealerCommitments.length < 2) throw new Error("at least two dealer commitments are required");
+  return sumPoints(
+    dealerCommitments.map((commitments) => evaluateCommitments(commitments, participant).toRawBytes(true))
+  ).toRawBytes(true);
+};
+const deriveBeaconGroupPublicKey = (dealerCommitments) => {
+  if (dealerCommitments.length < 2 || dealerCommitments.some((commitments) => commitments.length < 2)) {
+    throw new Error("invalid beacon dealer commitments");
+  }
+  return sumPoints(dealerCommitments.map((commitments) => commitments[0])).toRawBytes(true);
+};
+const beaconMessage = (network, epoch, round, previousProof) => {
+  if (!network || epoch < 0n || round < 0n) throw new TypeError("invalid beacon round");
+  const prefix = encoder.encode(`leofcoin-beacon-v1:${network}:${epoch}:${round}:`);
+  const message = new Uint8Array(prefix.length + previousProof.length);
+  message.set(prefix);
+  message.set(previousProof, prefix.length);
+  return message;
+};
+const signBeaconRound = (secretShare, message) => bls12_381.sign(message, Fr.create(secretShare));
+const verifyBeaconSignatureShare = (signature, message, publicShare) => {
+  try {
+    return bls12_381.verify(signature, message, publicShare);
+  } catch {
+    return false;
+  }
+};
+const reconstructBeaconSignature = (rawShares, threshold) => {
+  if (!Number.isSafeInteger(threshold) || threshold < 2) throw new RangeError("invalid beacon threshold");
+  const shares = [...rawShares].sort((left, right) => left.participant < right.participant ? -1 : 1);
+  if (shares.length < threshold) throw new Error("not enough beacon signature shares");
+  const selected = shares.slice(0, threshold);
+  const participants = selected.map(({ participant }) => participant);
+  assertUniqueParticipants(participants);
+  let signature = G2.ZERO;
+  for (const share of selected) {
+    const point = bls12_381.Signature.fromHex(share.signature);
+    point.assertValidity();
+    signature = signature.add(point.multiply(lagrangeAtZero(share.participant, participants)));
+  }
+  return bls12_381.Signature.toRawBytes(signature);
+};
+const verifyBeaconProof = (proof, message, groupPublicKey) => {
+  try {
+    return bls12_381.verify(proof, message, groupPublicKey);
+  } catch {
+    return false;
+  }
+};
+const beaconRandomness = (proof) => {
+  if (proof.length !== 96) throw new Error("invalid BLS beacon proof length");
+  return sha256(proof);
+};
+
+export { beaconMessage, beaconRandomness, combineBeaconShares, createBeaconContribution, deriveBeaconGroupPublicKey, deriveBeaconPublicShare, reconstructBeaconSignature, signBeaconRound, verifyBeaconProof, verifyBeaconShare, verifyBeaconSignatureShare };