@leofcoin/chain 1.10.10 → 1.10.12

package/exports/browser/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/exports/chain.js

@@ -3,14 +3,15 @@ import { Codec } from '@leofcoin/codec-format-interface';
 import { jsonStringifyBigInt, jsonParseBigInt, formatBytes, parseUnits, formatUnits } from '@leofcoin/utils';
 import { TransactionMessage, BlockMessage, ContractMessage, LastBlockMessage, PrevoteMessage, PrecommitMessage, ProposalMessage, BWMessage, StateMessage } from '@leofcoin/messages';
 import addresses, { contractFactory, nativeToken } from '@leofcoin/addresses';
-import { MAX_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTIONS, createTransactionHash, calculateFee, createContractMessage, signTransaction, distributeTransactionFee, supportsTransactionFees, supportsMonetaryPolicy, validateBlockResourceLimits, calculateMonetaryPolicy, distributeAmount, aggregateValidatorFees, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
+import { MAX_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTIONS, createTransactionHash, calculateFee, createContractMessage, signTransaction, distributeTransactionFee, supportsTransactionFees, supportsMonetaryPolicy, validateBlockResourceLimits, calculateMonetaryPolicy, distributeAmount, aggregateValidatorFees, MONETARY_POLICY_AUTHORITY, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
 import MultiWallet from '@leofcoin/multi-wallet';
 import { fromBase58 } from '@vandeurenglenn/typed-array-utils';
 import semver from 'semver';
 import { randombytes } from '@leofcoin/crypto';
 import EasyWorker from '@vandeurenglenn/easy-worker';
 import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
-import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-D6gWzJZg.js';
+import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-CMYKv-Rt.js';
+import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
 import '@leofcoin/networks';
 
 const limit = 1800;
@@ -891,7 +892,7 @@ class Machine {
    * @param {Array} parameters
    * @returns Promise<message>
    */
-  async execute(contract, method, parameters, sender) {
+  async execute(contract, method, parameters, sender, execution) {
     try {
       if (contract === contractFactory && method === "registerContract") {
         if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`);
@@ -933,7 +934,10 @@ ${error.message}`);
           contract,
           method,
           params: parameters,
-          sender
+          sender,
+          executionSeed: execution?.seed,
+          executionTimestamp: execution?.timestamp,
+          executionRandomness: execution?.randomness
         }
       });
     });
@@ -1445,7 +1449,8 @@ class State extends Contract {
     if (!(block instanceof Uint8Array)) block = new Uint8Array(Object.values(block));
     block = await new BlockMessage(block);
     const resolvedHash = await block.hash();
-    if (resolvedHash !== hash) throw new ResolveError(`block hash mismatch: requested ${hash}, received ${resolvedHash}`);
+    if (resolvedHash !== hash)
+      throw new ResolveError(`block hash mismatch: requested ${hash}, received ${resolvedHash}`);
     const { index } = block.decoded;
     if (this.#blocks[index] && this.#blocks[index].hash !== resolvedHash) {
       throw new ResolveError(`conflicting block ${resolvedHash} @${index}`);
@@ -1787,7 +1792,7 @@ class State extends Contract {
   #loadBlockTransactions;
   #getLastTransactions;
   // todo throw error
-  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints) {
+  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints, blockTimestamp) {
     try {
       const hash = await transaction.hash();
       if (feesEnabled) {
@@ -1799,7 +1804,8 @@ class State extends Contract {
         transaction.decoded.to,
         transaction.decoded.method,
         transaction.decoded.params,
-        transaction.decoded.from
+        transaction.decoded.from,
+        { seed: hash, timestamp: Number(blockTimestamp) }
       );
     } catch (error) {
       console.log(error);
@@ -1850,7 +1856,13 @@ class State extends Contract {
             BigInt(await this.#machine.get(nativeToken, "targetSupply"))
           ) : { subsidy: 0n, burnBasisPoints: 1000n };
           for (const transaction of transactions) {
-            await this.#_executeTransaction(transaction, validators, feesEnabled, policy.burnBasisPoints);
+            await this.#_executeTransaction(
+              transaction,
+              validators,
+              feesEnabled,
+              policy.burnBasisPoints,
+              block.timestamp
+            );
           }
           if (monetaryPolicyEnabled && policy.subsidy > 0n) {
             await this.#machine.settleRewards([
@@ -2272,13 +2284,6 @@ class ConnectionMonitor {
   }
 }
 
-const quorumThreshold = (validatorCount) => {
-  if (!Number.isSafeInteger(validatorCount) || validatorCount < 1) {
-    throw new Error("validator count must be a positive safe integer");
-  }
-  return Math.floor(2 * validatorCount / 3) + 1;
-};
-
 const validateChainLink = (localTip, incoming) => {
   const localHash = localTip?.hash || "0x0";
   const localIndex = Number(localTip?.index ?? -1);
@@ -2377,6 +2382,14 @@ const proposalDelay = ({
   return Math.max(0, Math.max(nextFromCanonicalBlock, nextFromLocalAttempt) - now);
 };
 
+const enqueueTransaction = async (transaction, ops) => {
+  const hash = await transaction.hash();
+  if (!await ops.hasInPool(hash) && !await ops.hasInStore(hash)) {
+    await ops.putToPool(hash, transaction.encoded);
+  }
+  ops.addPendingNonce(transaction.decoded.from, transaction.decoded.nonce);
+  return hash;
+};
 const compareTransactionNonces = (left, right) => {
   const leftNonce = BigInt(left ?? 0);
   const rightNonce = BigInt(right ?? 0);
@@ -2627,9 +2640,7 @@ class Chain extends VersionControl {
     };
     // ─────────────────────────────────────────────────────────────────────────
     this.#addTransaction = async (message) => {
-      const transaction = new TransactionMessage(message);
-      const hash = await transaction.hash();
-      this.addPendingNonce(transaction.decoded.from, transaction.decoded.nonce);
+      const hash = await this.#sendTransaction(message);
       debug(`added ${hash}`);
     };
     this.#init();
@@ -2704,12 +2715,7 @@ class Chain extends VersionControl {
     return signConsensusMessage(addresses.validators, type, message, identity);
   }
   async #verifyConsensusMessage(type, message) {
-    return verifyConsensusMessage(
-      addresses.validators,
-      type,
-      message,
-      globalThis.peernet?.network || "leofcoin"
-    );
+    return verifyConsensusMessage(addresses.validators, type, message, globalThis.peernet?.network || "leofcoin");
   }
   async #getConsensusValidators(nextBlockIndex2) {
     const localBlock = await this.lastBlock;
@@ -2793,7 +2799,10 @@ class Chain extends VersionControl {
     const adaptivePolicy = supportsMonetaryPolicy(blockMessage.decoded.protocolVersion);
     if (adaptivePolicy) await validateBlockResourceLimits(transactions);
     const policy = await this.#monetaryPolicy(blockMessage.decoded.protocolVersion);
-    const calculatedFees = feesEnabled ? (await Promise.all(transactions.map((transaction) => calculateFee(transaction.decoded)))).reduce((total, fee) => total + BigInt(fee), 0n) : 0n;
+    const calculatedFees = feesEnabled ? (await Promise.all(transactions.map((transaction) => calculateFee(transaction.decoded)))).reduce(
+      (total, fee) => total + BigInt(fee),
+      0n
+    ) : 0n;
     const feeEntries = feesEnabled ? await Promise.all(
       transactions.map(async (transaction) => ({
         fee: BigInt(await calculateFee(transaction.decoded)),
@@ -2802,7 +2811,11 @@ class Chain extends VersionControl {
     ) : [];
     const validatorAddresses = blockMessage.decoded.validators.map(({ address }) => address);
     const validatorFees = feesEnabled ? aggregateValidatorFees(feeEntries, validatorAddresses, policy.burnBasisPoints) : new Map(validatorAddresses.map((address) => [address, 0n]));
-    const subsidyRewards = adaptivePolicy ? distributeAmount(policy.subsidy, validatorAddresses, Number(blockMessage.decoded.index) % validatorAddresses.length) : new Map(validatorAddresses.map((address) => [address, policy.subsidy / BigInt(validatorAddresses.length)]));
+    const subsidyRewards = adaptivePolicy ? distributeAmount(
+      policy.subsidy,
+      validatorAddresses,
+      Number(blockMessage.decoded.index) % validatorAddresses.length
+    ) : new Map(validatorAddresses.map((address) => [address, policy.subsidy / BigInt(validatorAddresses.length)]));
     validateBlockEconomics(blockMessage.decoded, calculatedFees, validatorFees, subsidyRewards, policy.subsidy);
     if (feesEnabled) {
       const feesBySender = /* @__PURE__ */ new Map();
@@ -2814,7 +2827,9 @@ class Chain extends VersionControl {
         [...feesBySender].map(async ([sender, required]) => {
           const balance = BigInt(await this.balanceOf(sender) || 0n);
           if (balance < required) {
-            throw new Error(`insufficient balance for transaction fees from ${sender}: need ${required}, got ${balance}`);
+            throw new Error(
+              `insufficient balance for transaction fees from ${sender}: need ${required}, got ${balance}`
+            );
           }
         })
       );
@@ -2822,10 +2837,9 @@ class Chain extends VersionControl {
     return transactions;
   }
   async #assertFeeBurnSupported(protocolVersion) {
-    const creator = await this.staticCall(addresses.nativeToken, "creator");
     const [canBurn, canMint] = await Promise.all([
-      this.staticCall(addresses.nativeToken, "hasRole", [creator, "BURN"]),
-      this.staticCall(addresses.nativeToken, "hasRole", [creator, "MINT"])
+      this.staticCall(addresses.nativeToken, "hasRole", [MONETARY_POLICY_AUTHORITY, "BURN"]),
+      this.staticCall(addresses.nativeToken, "hasRole", [MONETARY_POLICY_AUTHORITY, "MINT"])
     ]);
     if (!canBurn || supportsMonetaryPolicy(protocolVersion) && !canMint) {
       throw new Error("native token genesis does not support protocol monetary policy");
@@ -3287,12 +3301,24 @@ class Chain extends VersionControl {
   async #versionHandler() {
     return new globalThis.peernet.protos["peernet-response"]({ response: this.version });
   }
-  async #executeTransaction({ hash, from, to, method, params, nonce, feePayments = { payments: [], burned: 0n } }) {
+  async #executeTransaction({
+    hash,
+    from,
+    to,
+    method,
+    params,
+    nonce,
+    executionTimestamp,
+    feePayments = { payments: [], burned: 0n }
+  }) {
     try {
       if (feePayments.payments.length > 0 || feePayments.burned > 0n) {
         await this.machine.collectFee(from, feePayments.payments, feePayments.burned);
       }
-      let result = await this.machine.execute(to, method, params, from);
+      let result = await this.machine.execute(to, method, params, from, {
+        seed: hash,
+        timestamp: Number(executionTimestamp)
+      });
       globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: "fulfilled", hash });
       return result || "no state change";
     } catch (error) {
@@ -3367,12 +3393,19 @@ class Chain extends VersionControl {
       this.removePendingNonce(transaction.decoded.from, transaction.decoded.nonce);
       const transactionHash = await transaction.hash();
       const validatorAddresses = blockMessage.decoded.validators.map(({ address }) => address);
-      const feeDistribution = supportsTransactionFees(blockMessage.decoded.protocolVersion) ? distributeTransactionFee(BigInt(await calculateFee(transaction.decoded)), transactionHash, validatorAddresses, monetaryPolicy.burnBasisPoints) : { payments: [], burned: 0n };
-      await this.#handleTransaction(transaction, [], void 0, feeDistribution);
+      const feeDistribution = supportsTransactionFees(blockMessage.decoded.protocolVersion) ? distributeTransactionFee(
+        BigInt(await calculateFee(transaction.decoded)),
+        transactionHash,
+        validatorAddresses,
+        monetaryPolicy.burnBasisPoints
+      ) : { payments: [], burned: 0n };
+      await this.#handleTransaction(transaction, [], blockMessage.decoded, feeDistribution);
     }
     if (supportsMonetaryPolicy(blockMessage.decoded.protocolVersion) && monetaryPolicy.subsidy > 0n) {
       const validators = blockMessage.decoded.validators.map(({ address }) => address);
-      await this.machine.settleRewards([...distributeAmount(monetaryPolicy.subsidy, validators, blockIndex % validators.length)]);
+      await this.machine.settleRewards([
+        ...distributeAmount(monetaryPolicy.subsidy, validators, blockIndex % validators.length)
+      ]);
     }
     try {
       promises = await Promise.allSettled(promises);
@@ -3442,7 +3475,12 @@ class Chain extends VersionControl {
       return;
     }
     try {
-      const result = await this.#executeTransaction({ ...transaction.decoded, hash, feePayments });
+      const result = await this.#executeTransaction({
+        ...transaction.decoded,
+        hash,
+        executionTimestamp: block?.timestamp ?? transaction.decoded.timestamp,
+        feePayments
+      });
       if (block) {
         block.transactions.push(hash);
         block.fees = block.fees += await calculateFee(transaction.decoded);
@@ -3502,7 +3540,8 @@ class Chain extends VersionControl {
         await globalThis.transactionPoolStore.delete(hash);
         continue;
       }
-      if (block.transactions.length >= MAX_BLOCK_TRANSACTIONS || blockTransactionBytes + transactionBytes > MAX_BLOCK_TRANSACTION_BYTES) break;
+      if (block.transactions.length >= MAX_BLOCK_TRANSACTIONS || blockTransactionBytes + transactionBytes > MAX_BLOCK_TRANSACTION_BYTES)
+        break;
       await this.validateTransactionSignature(transaction);
       block.transactions.push(hash);
       blockTransactionBytes += transactionBytes;
@@ -3592,18 +3631,23 @@ class Chain extends VersionControl {
   async #sendTransaction(transaction) {
     transaction = await new TransactionMessage(transaction.encoded || transaction);
     await this.validateTransactionSignature(transaction);
-    const hash = await transaction.hash();
+    let hash;
     try {
-      const has = await globalThis.transactionPoolStore.has(hash);
-      if (!has && !await transactionStore.has(hash)) {
-        await globalThis.transactionPoolStore.put(hash, transaction.encoded);
-      }
+      hash = await enqueueTransaction(transaction, {
+        putToPool: (txHash, data) => globalThis.transactionPoolStore.put(txHash, data),
+        hasInPool: (txHash) => globalThis.transactionPoolStore.has(txHash),
+        hasInStore: (txHash) => globalThis.transactionStore.has(txHash),
+        addPendingNonce: (address, nonce) => this.addPendingNonce(address, nonce)
+      });
       if (this.#participating && !this.#runningEpoch) this.#runEpoch();
+      return hash;
     } catch (e) {
-      try {
-        globalThis.peernet.publish("invalid-transaction", hash);
-      } catch (publishError) {
-        debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
+      if (hash) {
+        try {
+          globalThis.peernet.publish("invalid-transaction", hash);
+        } catch (publishError) {
+          debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
+        }
       }
       throw new Error("invalid transaction");
     }
@@ -3616,7 +3660,7 @@ class Chain extends VersionControl {
   async sendTransaction(transaction) {
     const transactionMessage = await new TransactionMessage({ ...transaction });
     const event = await super.sendTransaction(transactionMessage);
-    this.#sendTransaction(transactionMessage.encoded);
+    await this.#sendTransaction(transactionMessage.encoded);
     try {
       globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
     } catch (publishError) {

package/exports/{constants-D6gWzJZg.js → constants-CMYKv-Rt.js}

@@ -1,6 +1,6 @@
 import networks from '@leofcoin/networks';
 
-const PROTOCOL_VERSION = "0.2.0";
+const PROTOCOL_VERSION = "0.3.0";
 const REACHED_ONE_ZERO_ZERO = false;
 const DEFAULT_NODE_OPTIONS = {
   autoStart: false,

package/exports/node.js

@@ -1,6 +1,6 @@
 import Peernet from '@leofcoin/peernet';
 import nodeConfig from '@leofcoin/lib/node-config';
-import { D as DEFAULT_NODE_OPTIONS } from './constants-D6gWzJZg.js';
+import { D as DEFAULT_NODE_OPTIONS } from './constants-CMYKv-Rt.js';
 import '@leofcoin/networks';
 
 class Node {

package/exports/quorum-S_qdgiAY.js

@@ -0,0 +1,8 @@
+const quorumThreshold = (validatorCount) => {
+  if (!Number.isSafeInteger(validatorCount) || validatorCount < 1) {
+    throw new Error("validator count must be a positive safe integer");
+  }
+  return Math.floor(2 * validatorCount / 3) + 1;
+};
+
+export { quorumThreshold as q };

package/exports/workers/block-worker.js

@@ -1,4 +1,4 @@
-import { E as EasyWorker, F as FormatInterface, p as proto$3, i as index$3, a as index$2, b as proto$2 } from './worker-CZqErLI7-BxofVJAn.js';
+import { E as EasyWorker, F as FormatInterface, p as proto$3, i as index$3, a as index$2, b as proto$2 } from './worker-DMCj1e6z-CTYVa2yX.js';
 
 class ValidatorMessage extends FormatInterface {
     get messageName() {