@leofcoin/chain 1.10.16 → 1.10.17

package/exports/beacon-envelope.js

@@ -1,4 +1,4 @@
-import { secp256k1 } from '@noble/curves/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { hkdf } from '@noble/hashes/hkdf.js';
 import { sha256 } from '@noble/hashes/sha2.js';
 
@@ -11,7 +11,7 @@ const context = (network, epoch, sender, recipient) => {
   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");
+  if (share <= 0n || share >= secp256k1.Point.Fn.ORDER) 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) {
@@ -24,18 +24,18 @@ 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");
+  if (value <= 0n || value >= secp256k1.Point.Fn.ORDER) 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");
+  if (!secp256k1.utils.isValidSecretKey(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 createBeaconEncryptionKey = (randomPrivateKey = () => secp256k1.utils.randomSecretKey()) => {
   const privateKey = randomPrivateKey();
-  if (!secp256k1.utils.isValidPrivateKey(privateKey)) throw new Error("invalid generated beacon encryption key");
+  if (!secp256k1.utils.isValidSecretKey(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))) => {

package/exports/beacon-epoch.js

@@ -2,7 +2,7 @@ import { sha256 } from '@noble/hashes/sha2.js';
 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';
+import '@noble/curves/bls12-381.js';
 
 const encoder = new TextEncoder();
 const lengthPrefix = (bytes) => {

package/exports/beacon-lifecycle.js

@@ -3,7 +3,7 @@ import { sha256 } from '@noble/hashes/sha2.js';
 import { canonicalBeaconEpochConfig, beaconEpochDigest } from './beacon-epoch.js';
 import '@vandeurenglenn/typed-array-utils';
 import './beacon.js';
-import '@noble/curves/bls12-381';
+import '@noble/curves/bls12-381.js';
 import './quorum-S_qdgiAY.js';
 
 const encoder = new TextEncoder();

package/exports/beacon-round.js

@@ -1,7 +1,7 @@
 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/curves/bls12-381.js';
 import '@noble/hashes/sha2.js';
 import './quorum-S_qdgiAY.js';
 

package/exports/beacon.js

@@ -1,10 +1,11 @@
-import { bls12_381 } from '@noble/curves/bls12-381';
+import { bls12_381 } from '@noble/curves/bls12-381.js';
 import { sha256 } from '@noble/hashes/sha2.js';
 
 const encoder = new TextEncoder();
 const Fr = bls12_381.fields.Fr;
-const G1 = bls12_381.G1.ProjectivePoint;
-const G2 = bls12_381.G2.ProjectivePoint;
+const G1 = bls12_381.G1.Point;
+const G2 = bls12_381.G2.Point;
+const signatures = bls12_381.longSignatures;
 const assertParticipant = (participant) => {
   if (typeof participant !== "bigint" || participant <= 0n || participant >= Fr.ORDER) {
     throw new TypeError("beacon participant identifiers must be non-zero field elements");
@@ -30,7 +31,7 @@ const evaluateCommitments = (commitments, x) => {
   let result = G1.ZERO;
   let power = 1n;
   for (const encoded of commitments) {
-    const commitment = G1.fromHex(encoded);
+    const commitment = G1.fromBytes(encoded);
     commitment.assertValidity();
     result = result.add(commitment.multiply(power));
     power = Fr.mul(power, x);
@@ -40,7 +41,7 @@ const evaluateCommitments = (commitments, x) => {
 const sumPoints = (points) => {
   let result = G1.ZERO;
   for (const encoded of points) {
-    const point = G1.fromHex(encoded);
+    const point = G1.fromBytes(encoded);
     point.assertValidity();
     result = result.add(point);
   }
@@ -65,7 +66,7 @@ const createBeaconContribution = (participants, threshold, randomScalar) => {
     return scalar;
   });
   return {
-    commitments: coefficients.map((coefficient) => G1.BASE.multiply(coefficient).toRawBytes(true)),
+    commitments: coefficients.map((coefficient) => G1.BASE.multiply(coefficient).toBytes(true)),
     shares: new Map(participants.map((participant) => [participant, evaluatePolynomial(coefficients, participant)]))
   };
 };
@@ -86,14 +87,14 @@ 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);
+    dealerCommitments.map((commitments) => evaluateCommitments(commitments, participant).toBytes(true))
+  ).toBytes(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);
+  return sumPoints(dealerCommitments.map((commitments) => commitments[0])).toBytes(true);
 };
 const beaconMessage = (network, epoch, round, previousProof) => {
   if (!network || epoch < 0n || round < 0n) throw new TypeError("invalid beacon round");
@@ -103,10 +104,10 @@ const beaconMessage = (network, epoch, round, previousProof) => {
   message.set(previousProof, prefix.length);
   return message;
 };
-const signBeaconRound = (secretShare, message) => bls12_381.sign(message, Fr.create(secretShare));
+const signBeaconRound = (secretShare, message) => signatures.Signature.toBytes(signatures.sign(signatures.hash(message), Fr.toBytes(Fr.create(secretShare))));
 const verifyBeaconSignatureShare = (signature, message, publicShare) => {
   try {
-    return bls12_381.verify(signature, message, publicShare);
+    return signatures.verify(signature, signatures.hash(message), publicShare);
   } catch {
     return false;
   }
@@ -120,15 +121,15 @@ const reconstructBeaconSignature = (rawShares, threshold) => {
   assertUniqueParticipants(participants);
   let signature = G2.ZERO;
   for (const share of selected) {
-    const point = bls12_381.Signature.fromHex(share.signature);
+    const point = signatures.Signature.fromBytes(share.signature);
     point.assertValidity();
     signature = signature.add(point.multiply(lagrangeAtZero(share.participant, participants)));
   }
-  return bls12_381.Signature.toRawBytes(signature);
+  return signatures.Signature.toBytes(signature);
 };
 const verifyBeaconProof = (proof, message, groupPublicKey) => {
   try {
-    return bls12_381.verify(proof, message, groupPublicKey);
+    return signatures.verify(proof, signatures.hash(message), groupPublicKey);
   } catch {
     return false;
   }

package/exports/browser/_commonjsHelpers-B85MJLTf.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs as g };

package/exports/browser/beacon-envelope.js

@@ -1,108 +1,41 @@
-import { H as Hash, h as hash, t as toBytes, e as exists, b as bytes, w as weierstrass, r as randomBytes, c as concatBytes, F as Field, m as mod, p as pow2, s as sha256 } from './weierstrass-Q0QND1ZT.js';
-import { h as hkdf } from './hkdf-CnZvwpZ9.js';
-import { s as sha256$1 } from './sha2-piimb6xL.js';
+import { s as sha256 } from './sha2-BKcEJzgd.js';
+import { e as ecdsa, w as weierstrass, F as Field, p as pow2 } from './weierstrass-BVfhtHbl.js';
+import { h as hkdf } from './hkdf-BUHINPFj.js';
 
-// HMAC (RFC 2104)
-class HMAC extends Hash {
-    constructor(hash$1, _key) {
-        super();
-        this.finished = false;
-        this.destroyed = false;
-        hash(hash$1);
-        const key = toBytes(_key);
-        this.iHash = hash$1.create();
-        if (typeof this.iHash.update !== 'function')
-            throw new Error('Expected instance of class which extends utils.Hash');
-        this.blockLen = this.iHash.blockLen;
-        this.outputLen = this.iHash.outputLen;
-        const blockLen = this.blockLen;
-        const pad = new Uint8Array(blockLen);
-        // blockLen can be bigger than outputLen
-        pad.set(key.length > blockLen ? hash$1.create().update(key).digest() : key);
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36;
-        this.iHash.update(pad);
-        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
-        this.oHash = hash$1.create();
-        // Undo internal XOR && apply outer XOR
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36 ^ 0x5c;
-        this.oHash.update(pad);
-        pad.fill(0);
-    }
-    update(buf) {
-        exists(this);
-        this.iHash.update(buf);
-        return this;
-    }
-    digestInto(out) {
-        exists(this);
-        bytes(out, this.outputLen);
-        this.finished = true;
-        this.iHash.digestInto(out);
-        this.oHash.update(out);
-        this.oHash.digestInto(out);
-        this.destroy();
-    }
-    digest() {
-        const out = new Uint8Array(this.oHash.outputLen);
-        this.digestInto(out);
-        return out;
-    }
-    _cloneInto(to) {
-        // Create new instance without calling constructor since key already in state and we don't know it.
-        to || (to = Object.create(Object.getPrototypeOf(this), {}));
-        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-        to = to;
-        to.finished = finished;
-        to.destroyed = destroyed;
-        to.blockLen = blockLen;
-        to.outputLen = outputLen;
-        to.oHash = oHash._cloneInto(to.oHash);
-        to.iHash = iHash._cloneInto(to.iHash);
-        return to;
-    }
-    destroy() {
-        this.destroyed = true;
-        this.oHash.destroy();
-        this.iHash.destroy();
-    }
-}
 /**
- * HMAC: RFC2104 message authentication code.
- * @param hash - function that would be used e.g. sha256
- * @param key - message key
- * @param message - message data
+ * SECG secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).
+ *
+ * Belongs to Koblitz curves: it has efficiently-computable GLV endomorphism ψ,
+ * check out {@link EndomorphismOpts}. Seems to be rigid (not backdoored).
+ * @module
  */
-const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-hmac.create = (hash, key) => new HMAC(hash, key);
-
-/*! 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;
+// Seems like generator was produced from some seed:
+// `Pointk1.BASE.multiply(Pointk1.Fn.inv(2n, N)).toAffine().x`
+// // gives short x 0x3b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63n
+const secp256k1_CURVE = {
+    p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
+    n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),
+    h: BigInt(1),
+    a: BigInt(0),
+    b: BigInt(7),
+    Gx: BigInt('0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    Gy: BigInt('0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'),
+};
+const secp256k1_ENDO = {
+    beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
+    basises: [
+        [BigInt('0x3086d221a7d46bcde86c90e49284eb15'), -BigInt('0xe4437ed6010e88286f547fa90abfe4c3')],
+        [BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8'), BigInt('0x3086d221a7d46bcde86c90e49284eb15')],
+    ],
+};
+const _2n = /* @__PURE__ */ BigInt(2);
 /**
  * √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;
+    const P = secp256k1_CURVE.p;
     // prettier-ignore
     const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
     // prettier-ignore
@@ -121,57 +54,35 @@ function sqrtMod(y) {
     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))
+    if (!Fpk1.eql(Fpk1.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 Fpk1 = /* @__PURE__ */ Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+const Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
+    Fp: Fpk1,
+    endo: secp256k1_ENDO,
+});
+/**
+ * secp256k1 curve: ECDSA and ECDH methods.
+ *
+ * Uses sha256 to hash messages. To use a different hash,
+ * pass `{ prehash: false }` to sign / verify.
+ *
+ * @example
+ * Generate one secp256k1 keypair, sign a message, and verify it.
+ *
+ * ```js
+ * import { secp256k1 } from '@noble/curves/secp256k1.js';
+ * const { secretKey, publicKey } = secp256k1.keygen();
+ * // const publicKey = secp256k1.getPublicKey(secretKey);
+ * const msg = new TextEncoder().encode('hello noble');
+ * const sig = secp256k1.sign(msg, secretKey);
+ * const isValid = secp256k1.verify(sig, msg, publicKey);
+ * // const sigKeccak = secp256k1.sign(keccak256(msg), secretKey, { prehash: false });
+ * ```
+ */
+const secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
 
 const encoder = new TextEncoder();
 const SCALAR_BYTES = 32;
@@ -182,7 +93,7 @@ const context = (network, epoch, sender, recipient) => {
   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");
+  if (share <= 0n || share >= secp256k1.Point.Fn.ORDER) 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) {
@@ -195,18 +106,18 @@ 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");
+  if (value <= 0n || value >= secp256k1.Point.Fn.ORDER) 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");
+  if (!secp256k1.utils.isValidSecretKey(privateKey)) throw new Error("invalid beacon encryption private key");
   const sharedSecret = secp256k1.getSharedSecret(privateKey, publicKey, true);
-  return hkdf(sha256$1, sharedSecret, sha256$1(aad), aad, 32);
+  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 createBeaconEncryptionKey = (randomPrivateKey = () => secp256k1.utils.randomSecretKey()) => {
   const privateKey = randomPrivateKey();
-  if (!secp256k1.utils.isValidPrivateKey(privateKey)) throw new Error("invalid generated beacon encryption key");
+  if (!secp256k1.utils.isValidSecretKey(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))) => {

package/exports/browser/beacon-epoch.js

@@ -1,8 +1,8 @@
-import { s as sha256 } from './sha2-piimb6xL.js';
+import { s as sha256 } from './sha2-BKcEJzgd.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';
-import './weierstrass-Q0QND1ZT.js';
+import './weierstrass-BVfhtHbl.js';
 
 const encoder = new TextEncoder();
 const lengthPrefix = (bytes) => {

package/exports/browser/beacon-lifecycle.js

@@ -1,9 +1,9 @@
-import { h as hkdf } from './hkdf-CnZvwpZ9.js';
-import { s as sha256 } from './sha2-piimb6xL.js';
+import { h as hkdf } from './hkdf-BUHINPFj.js';
+import { s as sha256 } from './sha2-BKcEJzgd.js';
 import { canonicalBeaconEpochConfig, beaconEpochDigest } from './beacon-epoch.js';
+import './weierstrass-BVfhtHbl.js';
 import './index-CvKt4UDE.js';
 import './beacon.js';
-import './weierstrass-Q0QND1ZT.js';
 import './quorum-S_qdgiAY.js';
 
 const encoder = new TextEncoder();

package/exports/browser/beacon-round.js

@@ -1,8 +1,8 @@
 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-Q0QND1ZT.js';
-import './sha2-piimb6xL.js';
+import './sha2-BKcEJzgd.js';
+import './weierstrass-BVfhtHbl.js';
 import './quorum-S_qdgiAY.js';
 
 class BeaconRound {

package/exports/browser/beacon-wire.js

@@ -1,7 +1,7 @@
-import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-BC-KRBgE.js';
+import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-DmuI-29u.js';
 import { f as fromBase58 } from './index-CvKt4UDE.js';
-import './browser-crypto-CeE-yId5.js';
-import './sha2-piimb6xL.js';
+import './browser-crypto-CH0ua22L.js';
+import './sha2-BKcEJzgd.js';
 
 const validInteger = (value, minimum = 0n) => {
   try {