@leofcoin/chain 1.10.9 → 1.10.11

package/exports/workers/{worker-CZqErLI7-BxofVJAn.js → worker-DMCj1e6z-CTYVa2yX.js}

@@ -7929,6 +7929,21 @@ const blockchainCodecs = [
     }
 ];
 const consensusCodecs = [
+    {
+        name: 'beacon-activation-message',
+        codec: '0x62616d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'beacon-commitment-message',
+        codec: '0x62636d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'beacon-share-message',
+        codec: '0x62736d',
+        hashAlg: 'keccak-256'
+    },
     {
         name: 'proposal-message',
         codec: '0x70726d',
@@ -9053,6 +9068,20 @@ var proto$2 = {
     reward: BigInt(0)
 };
 
+({
+    epoch: BigInt(0)});
+
+({
+    epoch: BigInt(0),
+    threshold: BigInt(0),
+    participant: BigInt(0),
+    commitments: Array()});
+
+({
+    epoch: BigInt(0),
+    round: BigInt(0),
+    participant: BigInt(0)});
+
 var proto$1 = {
     creator: String(),
     contract: new Uint8Array(),
@@ -9207,4 +9236,4 @@ class EasyWorker {
     }
 }
 
-export { EasyWorker as E, FormatInterface as F, index$2 as a, proto$2 as b, jsonStringifyBigInt$1 as c, proto$1 as d, proto as e, index$3 as i, jsonParseBigInt$1 as j, proto$3 as p };
+export { EasyWorker as E, FormatInterface as F, index$2 as a, proto$2 as b, jsonParseBigInt$1 as c, proto$1 as d, proto as e, index$3 as i, jsonStringifyBigInt$1 as j, proto$3 as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.10.9",
+  "version": "1.10.11",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {
@@ -12,6 +12,30 @@
       "import": "./exports/chain.js",
       "types": "./exports/chain.d.ts"
     },
+    "./consensus/beacon": {
+      "import": "./exports/beacon.js",
+      "types": "./types/beacon.d.ts"
+    },
+    "./consensus/beacon-wire": {
+      "import": "./exports/beacon-wire.js",
+      "types": "./types/beacon-wire.d.ts"
+    },
+    "./consensus/beacon-envelope": {
+      "import": "./exports/beacon-envelope.js",
+      "types": "./types/beacon-envelope.d.ts"
+    },
+    "./consensus/beacon-epoch": {
+      "import": "./exports/beacon-epoch.js",
+      "types": "./types/beacon-epoch.d.ts"
+    },
+    "./consensus/beacon-round": {
+      "import": "./exports/beacon-round.js",
+      "types": "./types/beacon-round.d.ts"
+    },
+    "./consensus/beacon-lifecycle": {
+      "import": "./exports/beacon-lifecycle.js",
+      "types": "./types/beacon-lifecycle.d.ts"
+    },
     "./browser/node": {
       "import": "./exports/browser/node.js",
       "types": "./exports/node.d.ts"
@@ -25,6 +49,7 @@
   "type": "module",
   "files": [
     "./exports",
+    "./types",
     "LICENSE.txt"
   ],
   "scripts": {
@@ -62,6 +87,8 @@
     "tslib": "^2.8.1"
   },
   "dependencies": {
+    "@noble/curves": "^1.2.0",
+    "@noble/hashes": "^1.3.2",
     "@leofcoin/addresses": "^1.0.60",
     "@leofcoin/codecs": "^1.1.4",
     "@leofcoin/contracts": "^0.1.21",
@@ -71,7 +98,7 @@
     "@leofcoin/messages": "^1.6.1",
     "@leofcoin/multi-wallet": "^3.1.9",
     "@leofcoin/networks": "^1.1.30",
-    "@leofcoin/peernet": "^1.2.27",
+    "@leofcoin/peernet": "^1.2.28",
     "@leofcoin/storage": "^3.5.38",
     "@leofcoin/utils": "^1.1.45",
     "@leofcoin/workers": "^1.5.34",

package/types/beacon-envelope.d.ts

@@ -0,0 +1,27 @@
+export type BeaconShareEnvelope = {
+  ciphertext: Uint8Array
+  ephemeralPublicKey: Uint8Array
+  nonce: Uint8Array
+}
+export function createBeaconEncryptionKey(randomPrivateKey?: () => Uint8Array): {
+  privateKey: Uint8Array
+  publicKey: Uint8Array
+}
+export function encryptBeaconShare(
+  share: bigint,
+  recipientPublicKey: Uint8Array,
+  network: string,
+  epoch: bigint,
+  sender: string,
+  recipient: string,
+  randomPrivateKey?: () => Uint8Array,
+  randomNonce?: () => Uint8Array
+): Promise<BeaconShareEnvelope>
+export function decryptBeaconShare(
+  envelope: BeaconShareEnvelope,
+  recipientPrivateKey: Uint8Array,
+  network: string,
+  epoch: bigint,
+  sender: string,
+  recipient: string
+): Promise<bigint>

package/types/beacon-epoch.d.ts

@@ -0,0 +1,28 @@
+export type BeaconEpochDealer = { commitments: string[]; validator: string }
+export type BeaconEpochConfig = {
+  dealers: BeaconEpochDealer[]
+  epoch: bigint
+  threshold: number
+  validators: string[]
+}
+export type BeaconActivationVote = {
+  configDigest: string
+  epoch: bigint
+  from: string
+  signature: string
+}
+export function beaconParticipants(validators: string[]): Map<string, bigint>
+export function validateBeaconEpochConfig(config: BeaconEpochConfig): boolean
+export function canonicalBeaconEpochConfig(config: BeaconEpochConfig): BeaconEpochConfig
+export function encodeBeaconEpochConfig(config: BeaconEpochConfig): Uint8Array
+export function beaconEpochDigest(config: BeaconEpochConfig): string
+export function beaconEpochGroupPublicKey(config: BeaconEpochConfig): string
+export class BeaconEpochVotes {
+  constructor(config: BeaconEpochConfig)
+  readonly config: BeaconEpochConfig
+  readonly configDigest: string
+  add(vote: BeaconActivationVote): 'accepted' | 'duplicate' | 'equivocation' | 'invalid'
+  readonly ready: boolean
+  certificate(): BeaconActivationVote[]
+  equivocation(validator: string): BeaconActivationVote[] | undefined
+}

package/types/beacon-lifecycle.d.ts

@@ -0,0 +1,40 @@
+import type { BeaconActivationVote, BeaconEpochConfig } from './beacon-epoch.d.ts'
+export type ActiveBeaconEpoch = { certificate: BeaconActivationVote[]; config: BeaconEpochConfig }
+export type PrivateBeaconEpoch = { encryptionPrivateKey: string; epoch: bigint; secretShare: string }
+export function persistPublicBeaconEpoch(store: object, network: string, active: ActiveBeaconEpoch): Promise<void>
+export function loadPublicBeaconEpoch(store: object, network: string, epoch: bigint): Promise<ActiveBeaconEpoch | undefined>
+export function persistPrivateBeaconEpoch(
+  store: object,
+  network: string,
+  validator: string,
+  record: PrivateBeaconEpoch,
+  sign: (bytes: Uint8Array) => Promise<Uint8Array>,
+  randomNonce?: () => Uint8Array
+): Promise<void>
+export function loadPrivateBeaconEpoch(
+  store: object,
+  network: string,
+  validator: string,
+  epoch: bigint,
+  sign: (bytes: Uint8Array) => Promise<Uint8Array>
+): Promise<PrivateBeaconEpoch | undefined>
+export function clearBeaconEpochStorage(stores: object[], network: string): Promise<void>
+export function restoreBeaconLifecycle(
+  publicStore: object,
+  privateStore: object,
+  network: string,
+  validator: string,
+  height: number,
+  epochLength: number,
+  sign: (bytes: Uint8Array) => Promise<Uint8Array>
+): Promise<{ lifecycle: BeaconLifecycle; privateEpoch?: PrivateBeaconEpoch }>
+export class BeaconLifecycle {
+  constructor(epochLength: number)
+  readonly epochLength: number
+  epochAtHeight(height: number): bigint
+  ceremonyEpoch(height: number): bigint
+  stage(active: ActiveBeaconEpoch): void
+  restore(active: ActiveBeaconEpoch): void
+  advance(height: number): ActiveBeaconEpoch | undefined
+  readonly active: ActiveBeaconEpoch | undefined
+}

package/types/beacon-round.d.ts

@@ -0,0 +1,18 @@
+import type { BeaconEpochConfig } from './beacon-epoch.d.ts'
+export type AcceptedBeaconShare = { from: string; participant: bigint; signature: string }
+export type FinalizedBeaconRound = {
+  epoch: bigint
+  proof: string
+  randomness: string
+  round: bigint
+  signers: string[]
+}
+export class BeaconRound {
+  constructor(network: string, config: BeaconEpochConfig, round: bigint, previousProof: Uint8Array)
+  readonly epoch: bigint
+  readonly round: bigint
+  add(share: AcceptedBeaconShare): 'accepted' | 'duplicate' | 'equivocation' | 'invalid'
+  readonly ready: boolean
+  finalize(): FinalizedBeaconRound
+  equivocation(validator: string): AcceptedBeaconShare[] | undefined
+}

package/types/beacon-wire.d.ts

@@ -0,0 +1,31 @@
+export type BeaconCommitmentData = {
+  commitments: unknown
+  epoch: unknown
+  from: unknown
+  participant: unknown
+  signature?: unknown
+  threshold: unknown
+}
+export type BeaconShareData = {
+  epoch: unknown
+  from: unknown
+  participant: unknown
+  round: unknown
+  signature?: unknown
+  signatureShare: unknown
+}
+export type BeaconActivationData = {
+  configDigest: unknown
+  epoch: unknown
+  from: unknown
+  signature?: unknown
+}
+export function validateBeaconActivationData(message: BeaconActivationData): boolean
+export function validateBeaconCommitmentData(message: BeaconCommitmentData): boolean
+export function validateBeaconShareData(message: BeaconShareData): boolean
+export function signBeaconCommitmentMessage(validators: string, message: BeaconCommitmentData, identity: object): Promise<string>
+export function signBeaconShareMessage(validators: string, message: BeaconShareData, identity: object): Promise<string>
+export function verifyBeaconCommitmentMessage(validators: string, message: BeaconCommitmentData, network: string): Promise<boolean>
+export function verifyBeaconShareMessage(validators: string, message: BeaconShareData, network: string): Promise<boolean>
+export function signBeaconActivationMessage(validators: string, message: BeaconActivationData, identity: object): Promise<string>
+export function verifyBeaconActivationMessage(validators: string, message: BeaconActivationData, network: string): Promise<boolean>

package/types/beacon.d.ts

@@ -0,0 +1,24 @@
+export type BeaconDealerContribution = {
+  commitments: Uint8Array[]
+  shares: Map<bigint, bigint>
+}
+export type BeaconSignatureShare = { participant: bigint; signature: Uint8Array }
+export function createBeaconContribution(
+  participants: bigint[],
+  threshold: number,
+  randomScalar: () => bigint
+): BeaconDealerContribution
+export function verifyBeaconShare(participant: bigint, share: bigint, commitments: Uint8Array[]): boolean
+export function combineBeaconShares(shares: bigint[]): bigint
+export function deriveBeaconPublicShare(participant: bigint, commitments: Uint8Array[][]): Uint8Array
+export function deriveBeaconGroupPublicKey(commitments: Uint8Array[][]): Uint8Array
+export function beaconMessage(network: string, epoch: bigint, round: bigint, previousProof: Uint8Array): Uint8Array
+export function signBeaconRound(secretShare: bigint, message: Uint8Array): Uint8Array
+export function verifyBeaconSignatureShare(
+  signature: Uint8Array,
+  message: Uint8Array,
+  publicShare: Uint8Array
+): boolean
+export function reconstructBeaconSignature(shares: BeaconSignatureShare[], threshold: number): Uint8Array
+export function verifyBeaconProof(proof: Uint8Array, message: Uint8Array, groupPublicKey: Uint8Array): boolean
+export function beaconRandomness(proof: Uint8Array): Uint8Array