@leofcoin/chain 1.10.9 → 1.10.11

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

@@ -2,15 +2,16 @@ import { createDebugger } from '@vandeurenglenn/debug';
 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 } from '@leofcoin/addresses';
-import { createTransactionHash, calculateFee, createContractMessage, signTransaction, distributeTransactionFee, supportsTransactionFees, aggregateValidatorFees, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
+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, 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;
@@ -78,19 +79,14 @@ class Transaction extends Protocol {
     return new Promise(async (resolve, reject) => {
       let size = 0;
       const _transactions = [];
-      const MAX_BLOCK_TX_BYTES = 786432;
-      await Promise.all(
-        transactions.map(async (tx) => {
-          tx = await new TransactionMessage(tx);
-          const newSize = size + tx.encoded.length;
-          if (newSize <= MAX_BLOCK_TX_BYTES) {
-            size = newSize;
-            _transactions.push({ ...tx.decoded, hash: await tx.hash() });
-          } else {
-            resolve(_transactions);
-          }
-        })
-      );
+      for (const rawTransaction of transactions) {
+        const tx = await new TransactionMessage(rawTransaction);
+        if (tx.encoded.length > MAX_TRANSACTION_BYTES) continue;
+        const newSize = size + tx.encoded.length;
+        if (newSize > MAX_BLOCK_TRANSACTION_BYTES || _transactions.length >= MAX_BLOCK_TRANSACTIONS) break;
+        size = newSize;
+        _transactions.push({ ...tx.decoded, hash: await tx.hash() });
+      }
       return resolve(_transactions);
     });
   }
@@ -896,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]}`);
@@ -938,7 +934,10 @@ ${error.message}`);
           contract,
           method,
           params: parameters,
-          sender
+          sender,
+          executionSeed: execution?.seed,
+          executionTimestamp: execution?.timestamp,
+          executionRandomness: execution?.randomness
         }
       });
     });
@@ -946,6 +945,9 @@ ${error.message}`);
   collectFee(from, payments, burned) {
     return this.#askWorker("collectFee", { from, payments, burned });
   }
+  settleRewards(rewards) {
+    return this.#askWorker("settleRewards", { rewards });
+  }
   get(contract, method, parameters) {
     return new Promise((resolve, reject) => {
       const id = randombytes(20).toString();
@@ -1447,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}`);
@@ -1789,19 +1792,20 @@ class State extends Contract {
   #loadBlockTransactions;
   #getLastTransactions;
   // todo throw error
-  async #_executeTransaction(transaction, validators, feesEnabled) {
+  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints, blockTimestamp) {
     try {
       const hash = await transaction.hash();
       if (feesEnabled) {
         const fee = BigInt(await calculateFee(transaction.decoded));
-        const { payments, burned } = distributeTransactionFee(fee, hash, validators);
+        const { payments, burned } = distributeTransactionFee(fee, hash, validators, burnBasisPoints);
         await this.#machine.collectFee(transaction.decoded.from, payments, burned);
       }
       await this.#machine.execute(
         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);
@@ -1845,7 +1849,26 @@ class State extends Contract {
           });
           debug$1(`executing ${transactions.length} transactions for block ${block.index}`);
           const feesEnabled = supportsTransactionFees(block.protocolVersion);
-          for (const transaction of transactions) await this.#_executeTransaction(transaction, validators, feesEnabled);
+          const monetaryPolicyEnabled = supportsMonetaryPolicy(block.protocolVersion);
+          if (monetaryPolicyEnabled) await validateBlockResourceLimits(transactions);
+          const policy = monetaryPolicyEnabled ? calculateMonetaryPolicy(
+            BigInt(await this.#machine.get(nativeToken, "totalSupply")),
+            BigInt(await this.#machine.get(nativeToken, "targetSupply"))
+          ) : { subsidy: 0n, burnBasisPoints: 1000n };
+          for (const transaction of transactions) {
+            await this.#_executeTransaction(
+              transaction,
+              validators,
+              feesEnabled,
+              policy.burnBasisPoints,
+              block.timestamp
+            );
+          }
+          if (monetaryPolicyEnabled && policy.subsidy > 0n) {
+            await this.#machine.settleRewards([
+              ...distributeAmount(policy.subsidy, validators, Number(block.index) % validators.length)
+            ]);
+          }
           this.#blocks[block.index].loaded = true;
           debug$1(`executed transactions for block ${block.index}`);
           if (Number(block.index) === 0) this.#loaded = true;
@@ -2261,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);
@@ -2289,7 +2305,6 @@ const validateChainLink = (localTip, incoming) => {
   return "append";
 };
 
-const BLOCK_REWARD = 150n;
 const validateCanonicalValidatorSet = (blockIndex, expectedValidators, validators) => {
   const actualValidators = validators.map(({ address }) => address);
   const canonicalExpected = [...new Set(expectedValidators)].sort();
@@ -2299,20 +2314,18 @@ const validateCanonicalValidatorSet = (blockIndex, expectedValidators, validator
     );
   }
 };
-const validateBlockEconomics = (block, calculatedFees, validatorFees = /* @__PURE__ */ new Map()) => {
+const validateBlockEconomics = (block, calculatedFees, validatorFees = /* @__PURE__ */ new Map(), subsidyRewards = /* @__PURE__ */ new Map(), expectedSubsidy = [...subsidyRewards.values()].reduce((sum, reward) => sum + reward, 0n)) => {
   if (block.validators.length === 0) {
     throw new Error(`Block ${block.index} cannot distribute rewards without validators`);
   }
-  if (block.reward !== BLOCK_REWARD) {
-    throw new Error(`Block ${block.index} has invalid base reward: expected ${BLOCK_REWARD}, got ${block.reward}`);
+  if (block.reward !== expectedSubsidy) {
+    throw new Error(`Block ${block.index} has invalid base reward: expected ${expectedSubsidy}, got ${block.reward}`);
   }
   if (block.fees !== calculatedFees) {
     throw new Error(`Block ${block.index} has invalid fees: expected ${calculatedFees}, got ${block.fees}`);
   }
-  const validatorCount = BigInt(block.validators.length);
-  const baseReward = BLOCK_REWARD / validatorCount;
   for (const validator of block.validators) {
-    const expectedReward = baseReward + (validatorFees.get(validator.address) || 0n);
+    const expectedReward = (subsidyRewards.get(validator.address) || 0n) + (validatorFees.get(validator.address) || 0n);
     if (validator.reward !== expectedReward) {
       throw new Error(
         `Block ${block.index} has an invalid reward for validator ${validator.address}: expected ${expectedReward}, got ${validator.reward}`
@@ -2369,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);
@@ -2619,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();
@@ -2696,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;
@@ -2781,8 +2795,14 @@ class Chain extends VersionControl {
       })
     );
     const feesEnabled = supportsTransactionFees(blockMessage.decoded.protocolVersion);
-    if (feesEnabled) await this.#assertFeeBurnSupported();
-    const calculatedFees = feesEnabled ? (await Promise.all(transactions.map((transaction) => calculateFee(transaction.decoded)))).reduce((total, fee) => total + BigInt(fee), 0n) : 0n;
+    if (feesEnabled) await this.#assertFeeBurnSupported(blockMessage.decoded.protocolVersion);
+    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 feeEntries = feesEnabled ? await Promise.all(
       transactions.map(async (transaction) => ({
         fee: BigInt(await calculateFee(transaction.decoded)),
@@ -2790,8 +2810,13 @@ class Chain extends VersionControl {
       }))
     ) : [];
     const validatorAddresses = blockMessage.decoded.validators.map(({ address }) => address);
-    const validatorFees = feesEnabled ? aggregateValidatorFees(feeEntries, validatorAddresses) : new Map(validatorAddresses.map((address) => [address, 0n]));
-    validateBlockEconomics(blockMessage.decoded, calculatedFees, validatorFees);
+    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)]));
+    validateBlockEconomics(blockMessage.decoded, calculatedFees, validatorFees, subsidyRewards, policy.subsidy);
     if (feesEnabled) {
       const feesBySender = /* @__PURE__ */ new Map();
       for (let index = 0; index < transactions.length; index += 1) {
@@ -2802,20 +2827,32 @@ 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}`
+            );
           }
         })
       );
     }
     return transactions;
   }
-  async #assertFeeBurnSupported() {
-    const creator = await this.staticCall(addresses.nativeToken, "creator");
-    const canBurn = await this.staticCall(addresses.nativeToken, "hasRole", [creator, "BURN"]);
-    if (!canBurn) {
-      throw new Error("native token genesis does not support protocol fee burning");
+  async #assertFeeBurnSupported(protocolVersion) {
+    const [canBurn, canMint] = await Promise.all([
+      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");
     }
   }
+  async #monetaryPolicy(protocolVersion) {
+    if (!supportsMonetaryPolicy(protocolVersion)) return { subsidy: 150n, burnBasisPoints: 1000n, floorSupply: 0n };
+    const [totalSupply, targetSupply] = await Promise.all([
+      this.staticCall(addresses.nativeToken, "totalSupply"),
+      this.staticCall(addresses.nativeToken, "targetSupply")
+    ]);
+    return calculateMonetaryPolicy(BigInt(totalSupply), BigInt(targetSupply));
+  }
   /** Check if the next block will cross an epoch boundary (block-based timing) */
   #isEpochBoundary(blockHeight) {
     return (blockHeight + 1) % this.#epochLength === 0;
@@ -3264,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) {
@@ -3338,13 +3387,25 @@ class Chain extends VersionControl {
       if (nonceDiff !== 0) return nonceDiff;
       return 0;
     });
+    const monetaryPolicy = await this.#monetaryPolicy(blockMessage.decoded.protocolVersion);
     for (const transaction of allTransactions) {
       if (!contracts.includes(transaction.decoded.to)) contracts.push(transaction.decoded.to);
       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) : { 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)
+      ]);
     }
     try {
       promises = await Promise.allSettled(promises);
@@ -3414,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);
@@ -3445,7 +3511,7 @@ class Chain extends VersionControl {
       fees: BigInt(0),
       timestamp,
       previousHash: "",
-      reward: BLOCK_REWARD,
+      reward: 0n,
       index: 0,
       producer: "",
       producerProof: "",
@@ -3467,9 +3533,18 @@ class Chain extends VersionControl {
       if (nonceDiff !== 0) return nonceDiff;
       return 0;
     });
+    let blockTransactionBytes = 0;
     for (const { transaction, hash } of allTransactions) {
+      const transactionBytes = transaction.encoded.length;
+      if (transactionBytes > MAX_TRANSACTION_BYTES) {
+        await globalThis.transactionPoolStore.delete(hash);
+        continue;
+      }
+      if (block.transactions.length >= MAX_BLOCK_TRANSACTIONS || blockTransactionBytes + transactionBytes > MAX_BLOCK_TRANSACTION_BYTES)
+        break;
       await this.validateTransactionSignature(transaction);
       block.transactions.push(hash);
+      blockTransactionBytes += transactionBytes;
       if (supportsTransactionFees(this.version)) block.fees += BigInt(await calculateFee(transaction.decoded));
       await globalThis.peernet.put(hash, transaction.encoded, "transaction");
     }
@@ -3480,17 +3555,20 @@ class Chain extends VersionControl {
     const canonicalValidators = await this.staticCall(addresses.validators, "validators");
     const sortedValidators = [...canonicalValidators].sort();
     if (sortedValidators.length === 0) throw new Error("cannot produce a block without validators");
-    if (supportsTransactionFees(this.version)) await this.#assertFeeBurnSupported();
+    if (supportsTransactionFees(this.version)) await this.#assertFeeBurnSupported(this.version);
+    const monetaryPolicy = await this.#monetaryPolicy(this.version);
+    block.reward = monetaryPolicy.subsidy;
     const feeEntries = supportsTransactionFees(this.version) ? await Promise.all(
       allTransactions.map(async ({ transaction, hash }) => ({
         fee: BigInt(await calculateFee(transaction.decoded)),
         transactionHash: hash
       }))
     ) : [];
-    const validatorFees = supportsTransactionFees(this.version) ? aggregateValidatorFees(feeEntries, sortedValidators) : new Map(sortedValidators.map((address) => [address, 0n]));
+    const validatorFees = supportsTransactionFees(this.version) ? aggregateValidatorFees(feeEntries, sortedValidators, monetaryPolicy.burnBasisPoints) : new Map(sortedValidators.map((address) => [address, 0n]));
+    const subsidyRewards = supportsMonetaryPolicy(this.version) ? distributeAmount(monetaryPolicy.subsidy, sortedValidators, Number(block.index) % sortedValidators.length) : new Map(sortedValidators.map((address) => [address, monetaryPolicy.subsidy / BigInt(sortedValidators.length)]));
     block.validators = sortedValidators.map((validatorAddress) => ({
       address: validatorAddress,
-      reward: (validatorFees.get(validatorAddress) || 0n) + block.reward / BigInt(sortedValidators.length)
+      reward: (validatorFees.get(validatorAddress) || 0n) + (subsidyRewards.get(validatorAddress) || 0n)
     }));
     try {
       block.producer = globalThis.peernet.selectedAccount || "";
@@ -3553,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");
     }
@@ -3577,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() {