@leofcoin/chain 1.10.9 → 1.10.10

package/exports/browser/chain.js

@@ -1058,9 +1058,17 @@ const nameServiceMessage = bytecodes.nameService;
 const validatorsMessage = bytecodes.validators;
 const TRANSACTION_FEE_BYTES = 1024n;
 const TRANSACTION_FEE_UNIT = 10n;
-const FEE_BURN_BASIS_POINTS = 1000n;
+const MAX_TRANSACTION_BYTES = 32 * 1024;
+const MAX_BLOCK_TRANSACTION_BYTES = 128 * 1024;
+const MAX_BLOCK_TRANSACTIONS = 256;
+BigInt(MAX_TRANSACTION_BYTES) / TRANSACTION_FEE_BYTES * TRANSACTION_FEE_UNIT;
 const FEE_BASIS_POINTS = 10000n;
 const FEE_PROTOCOL_VERSION = "1.10.9";
+const MONETARY_POLICY_PROTOCOL_VERSION = "1.10.10";
+const BLOCKS_PER_YEAR = 5256000n;
+const ANNUAL_ISSUANCE_BASIS_POINTS = 200n;
+const SUPPLY_FLOOR_BASIS_POINTS = 9500n;
+const MONETARY_FEE_BURN_BASIS_POINTS = 1000n;
 const parseProtocolVersion = (version) => {
   const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
@@ -1076,19 +1084,61 @@ const supportsTransactionFees = (version) => {
   }
   return true;
 };
+const supportsMonetaryPolicy = (version) => {
+  const actual = parseProtocolVersion(version);
+  const required = parseProtocolVersion(MONETARY_POLICY_PROTOCOL_VERSION);
+  if (!actual)
+    return false;
+  for (let index = 0; index < required.length; index += 1) {
+    if (actual[index] !== required[index])
+      return actual[index] > required[index];
+  }
+  return true;
+};
+const calculateMonetaryPolicy = (totalSupply, targetSupply) => {
+  if (totalSupply < 0n || targetSupply <= 0n)
+    throw new Error("invalid monetary policy supply");
+  const floorSupply = targetSupply * SUPPLY_FLOOR_BASIS_POINTS / FEE_BASIS_POINTS;
+  if (totalSupply < floorSupply) {
+    const annualIssuance = targetSupply * ANNUAL_ISSUANCE_BASIS_POINTS / FEE_BASIS_POINTS;
+    const scheduled = annualIssuance / BLOCKS_PER_YEAR || 1n;
+    return { subsidy: scheduled < floorSupply - totalSupply ? scheduled : floorSupply - totalSupply, burnBasisPoints: 0n, floorSupply };
+  }
+  return {
+    subsidy: 0n,
+    burnBasisPoints: totalSupply >= targetSupply ? MONETARY_FEE_BURN_BASIS_POINTS : 0n,
+    floorSupply
+  };
+};
+const distributeAmount = (amount, addresses, rotation = 0) => {
+  const canonical = [...new Set(addresses)].sort();
+  if (canonical.length === 0)
+    throw new Error("cannot distribute without validators");
+  const count = BigInt(canonical.length);
+  const base = amount / count;
+  const remainder = Number(amount % count);
+  const result = new Map(canonical.map((address) => [address, base]));
+  for (let index = 0; index < remainder; index += 1) {
+    const address = canonical[(rotation + index) % canonical.length];
+    result.set(address, result.get(address) + 1n);
+  }
+  return result;
+};
 const feeRotationIndex = (transactionHash, validatorCount) => {
   let value = 0n;
   for (const character of transactionHash)
     value = (value * 31n + BigInt(character.charCodeAt(0))) % 4294967291n;
   return Number(value % BigInt(validatorCount));
 };
-const distributeTransactionFee = (fee, transactionHash, validatorAddresses) => {
+const distributeTransactionFee = (fee, transactionHash, validatorAddresses, burnBasisPoints = 1000n) => {
   const canonicalValidators = [...new Set(validatorAddresses)].sort();
   if (canonicalValidators.length === 0)
     throw new Error("cannot distribute transaction fee without validators");
   if (fee < 0n)
     throw new Error("transaction fee cannot be negative");
-  const burned = fee * FEE_BURN_BASIS_POINTS / FEE_BASIS_POINTS;
+  if (burnBasisPoints < 0n || burnBasisPoints > FEE_BASIS_POINTS)
+    throw new Error("invalid fee burn rate");
+  const burned = fee * burnBasisPoints / FEE_BASIS_POINTS;
   const validatorPool = fee - burned;
   const count = BigInt(canonicalValidators.length);
   const base = validatorPool / count;
@@ -1102,10 +1152,10 @@ const distributeTransactionFee = (fee, transactionHash, validatorAddresses) => {
   const payments = [...validatorFees.entries()].filter(([, amount]) => amount > 0n).map(([to, amount]) => ({ to, amount }));
   return { burned, validatorFees, payments };
 };
-const aggregateValidatorFees = (fees, validatorAddresses) => {
+const aggregateValidatorFees = (fees, validatorAddresses, burnBasisPoints = 1000n) => {
   const totals = new Map([...new Set(validatorAddresses)].sort().map((validator) => [validator, 0n]));
   for (const entry of fees) {
-    const { validatorFees } = distributeTransactionFee(entry.fee, entry.transactionHash, validatorAddresses);
+    const { validatorFees } = distributeTransactionFee(entry.fee, entry.transactionHash, validatorAddresses, burnBasisPoints);
     for (const [validator, amount] of validatorFees)
       totals.set(validator, totals.get(validator) + amount);
   }
@@ -1125,6 +1175,26 @@ const calculateFee = async (transaction, format = false) => {
   const fee = units * TRANSACTION_FEE_UNIT;
   return format ? formatUnits(fee.toString()) : fee;
 };
+const validateTransactionResourceLimits = async (transaction) => {
+  const message = await new TransactionMessage(transaction);
+  const size = message.encoded.length;
+  if (size > MAX_TRANSACTION_BYTES) {
+    throw new Error(`transaction exceeds ${MAX_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+  }
+  return size;
+};
+const validateBlockResourceLimits = async (transactions) => {
+  if (transactions.length > MAX_BLOCK_TRANSACTIONS) {
+    throw new Error(`block exceeds ${MAX_BLOCK_TRANSACTIONS} transaction protocol limit`);
+  }
+  let size = 0;
+  for (const transaction of transactions)
+    size += await validateTransactionResourceLimits(transaction);
+  if (size > MAX_BLOCK_TRANSACTION_BYTES) {
+    throw new Error(`block transactions exceed ${MAX_BLOCK_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+  }
+  return size;
+};
 const createTransactionHash = async (transaction) => {
   const isRawTransactionMessage = transaction instanceof RawTransactionMessage;
   let message;
@@ -7899,19 +7969,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);
     });
   }
@@ -8905,6 +8970,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();
@@ -9748,12 +9816,12 @@ class State extends Contract {
   #loadBlockTransactions;
   #getLastTransactions;
   // todo throw error
-  async #_executeTransaction(transaction, validators, feesEnabled) {
+  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints) {
     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(
@@ -9804,7 +9872,20 @@ 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$2, "totalSupply")),
+            BigInt(await this.#machine.get(nativeToken$2, "targetSupply"))
+          ) : { subsidy: 0n, burnBasisPoints: 1000n };
+          for (const transaction of transactions) {
+            await this.#_executeTransaction(transaction, validators, feesEnabled, policy.burnBasisPoints);
+          }
+          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;
@@ -10248,7 +10329,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();
@@ -10258,20 +10338,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}`
@@ -10740,7 +10818,10 @@ class Chain extends VersionControl {
       })
     );
     const feesEnabled = supportsTransactionFees(blockMessage.decoded.protocolVersion);
-    if (feesEnabled) await this.#assertFeeBurnSupported();
+    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) => ({
@@ -10749,8 +10830,9 @@ 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) {
@@ -10768,13 +10850,24 @@ class Chain extends VersionControl {
     }
     return transactions;
   }
-  async #assertFeeBurnSupported() {
+  async #assertFeeBurnSupported(protocolVersion) {
     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");
+    const [canBurn, canMint] = await Promise.all([
+      this.staticCall(addresses.nativeToken, "hasRole", [creator, "BURN"]),
+      this.staticCall(addresses.nativeToken, "hasRole", [creator, "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;
@@ -11297,14 +11390,19 @@ 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 };
+      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);
     }
+    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);
       const noncesByAddress = {};
@@ -11404,7 +11502,7 @@ class Chain extends VersionControl {
       fees: BigInt(0),
       timestamp,
       previousHash: "",
-      reward: BLOCK_REWARD,
+      reward: 0n,
       index: 0,
       producer: "",
       producerProof: "",
@@ -11426,9 +11524,17 @@ 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");
     }
@@ -11439,17 +11545,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 || "";

package/exports/browser/workers/machine-worker.js

@@ -977,9 +977,17 @@ var bytecodes = {
 
 const TRANSACTION_FEE_BYTES = 1024n;
 const TRANSACTION_FEE_UNIT = 10n;
-const FEE_BURN_BASIS_POINTS = 1000n;
+const MAX_TRANSACTION_BYTES = 32 * 1024;
+const MAX_BLOCK_TRANSACTION_BYTES = 128 * 1024;
+const MAX_BLOCK_TRANSACTIONS = 256;
+(BigInt(MAX_TRANSACTION_BYTES) / TRANSACTION_FEE_BYTES) * TRANSACTION_FEE_UNIT;
 const FEE_BASIS_POINTS = 10000n;
 const FEE_PROTOCOL_VERSION = '1.10.9';
+const MONETARY_POLICY_PROTOCOL_VERSION = '1.10.10';
+const BLOCKS_PER_YEAR = 5256000n;
+const ANNUAL_ISSUANCE_BASIS_POINTS = 200n;
+const SUPPLY_FLOOR_BASIS_POINTS = 9500n;
+const MONETARY_FEE_BURN_BASIS_POINTS = 1000n;
 const parseProtocolVersion = (version) => {
     const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
     return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;
@@ -995,19 +1003,61 @@ const supportsTransactionFees = (version) => {
     }
     return true;
 };
+const supportsMonetaryPolicy = (version) => {
+    const actual = parseProtocolVersion(version);
+    const required = parseProtocolVersion(MONETARY_POLICY_PROTOCOL_VERSION);
+    if (!actual)
+        return false;
+    for (let index = 0; index < required.length; index += 1) {
+        if (actual[index] !== required[index])
+            return actual[index] > required[index];
+    }
+    return true;
+};
+const calculateMonetaryPolicy = (totalSupply, targetSupply) => {
+    if (totalSupply < 0n || targetSupply <= 0n)
+        throw new Error('invalid monetary policy supply');
+    const floorSupply = (targetSupply * SUPPLY_FLOOR_BASIS_POINTS) / FEE_BASIS_POINTS;
+    if (totalSupply < floorSupply) {
+        const annualIssuance = (targetSupply * ANNUAL_ISSUANCE_BASIS_POINTS) / FEE_BASIS_POINTS;
+        const scheduled = annualIssuance / BLOCKS_PER_YEAR || 1n;
+        return { subsidy: scheduled < floorSupply - totalSupply ? scheduled : floorSupply - totalSupply, burnBasisPoints: 0n, floorSupply };
+    }
+    return {
+        subsidy: 0n,
+        burnBasisPoints: totalSupply >= targetSupply ? MONETARY_FEE_BURN_BASIS_POINTS : 0n,
+        floorSupply
+    };
+};
+const distributeAmount = (amount, addresses, rotation = 0) => {
+    const canonical = [...new Set(addresses)].sort();
+    if (canonical.length === 0)
+        throw new Error('cannot distribute without validators');
+    const count = BigInt(canonical.length);
+    const base = amount / count;
+    const remainder = Number(amount % count);
+    const result = new Map(canonical.map((address) => [address, base]));
+    for (let index = 0; index < remainder; index += 1) {
+        const address = canonical[(rotation + index) % canonical.length];
+        result.set(address, result.get(address) + 1n);
+    }
+    return result;
+};
 const feeRotationIndex = (transactionHash, validatorCount) => {
     let value = 0n;
     for (const character of transactionHash)
         value = (value * 31n + BigInt(character.charCodeAt(0))) % 4294967291n;
     return Number(value % BigInt(validatorCount));
 };
-const distributeTransactionFee = (fee, transactionHash, validatorAddresses) => {
+const distributeTransactionFee = (fee, transactionHash, validatorAddresses, burnBasisPoints = 1000n) => {
     const canonicalValidators = [...new Set(validatorAddresses)].sort();
     if (canonicalValidators.length === 0)
         throw new Error('cannot distribute transaction fee without validators');
     if (fee < 0n)
         throw new Error('transaction fee cannot be negative');
-    const burned = (fee * FEE_BURN_BASIS_POINTS) / FEE_BASIS_POINTS;
+    if (burnBasisPoints < 0n || burnBasisPoints > FEE_BASIS_POINTS)
+        throw new Error('invalid fee burn rate');
+    const burned = (fee * burnBasisPoints) / FEE_BASIS_POINTS;
     const validatorPool = fee - burned;
     const count = BigInt(canonicalValidators.length);
     const base = validatorPool / count;
@@ -1030,6 +1080,26 @@ const calculateFee = async (transaction, format = false) => {
     const fee = units * TRANSACTION_FEE_UNIT;
     return format ? formatUnits(fee.toString()) : fee;
 };
+const validateTransactionResourceLimits = async (transaction) => {
+    const message = await new TransactionMessage(transaction);
+    const size = message.encoded.length;
+    if (size > MAX_TRANSACTION_BYTES) {
+        throw new Error(`transaction exceeds ${MAX_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+    }
+    return size;
+};
+const validateBlockResourceLimits = async (transactions) => {
+    if (transactions.length > MAX_BLOCK_TRANSACTIONS) {
+        throw new Error(`block exceeds ${MAX_BLOCK_TRANSACTIONS} transaction protocol limit`);
+    }
+    let size = 0;
+    for (const transaction of transactions)
+        size += await validateTransactionResourceLimits(transaction);
+    if (size > MAX_BLOCK_TRANSACTION_BYTES) {
+        throw new Error(`block transactions exceed ${MAX_BLOCK_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+    }
+    return size;
+};
 
 class LittlePubSub {
     subscribers = new Map();
@@ -1211,7 +1281,7 @@ const runTask = async (id, taskName, input) => {
         });
     }
 };
-const _executeTransaction = async (transaction, validators, feesEnabled) => {
+const _executeTransaction = async (transaction, validators, feesEnabled, burnBasisPoints) => {
     const hash = await new TransactionMessage(transaction).hash();
     if (latestTransactions.includes(hash)) {
         throw new Error(`double transaction found: ${hash}`);
@@ -1223,7 +1293,7 @@ const _executeTransaction = async (transaction, validators, feesEnabled) => {
         globalThis.state = await createState();
         if (feesEnabled) {
             const fee = BigInt(await calculateFee(transaction));
-            const { payments, burned } = distributeTransactionFee(fee, hash, validators);
+            const { payments, burned } = distributeTransactionFee(fee, hash, validators, burnBasisPoints);
             await _.collectFee({ from, payments, burned });
         }
         await _.execute({ contract: to, method, params });
@@ -1327,6 +1397,17 @@ const _ = {
         }
         return total;
     },
+    settleRewards: ({ rewards }) => {
+        globalThis.msg = createMessage(contracts[nativeToken$2].creator, nativeToken$2);
+        let minted = 0n;
+        for (const [validator, rawAmount] of rewards) {
+            const amount = BigInt(rawAmount);
+            if (amount > 0n)
+                contracts[nativeToken$2].mint(validator, amount);
+            minted += amount;
+        }
+        return minted;
+    },
     init: async (message) => {
         let { peerid, fromState, state, info } = message;
         if (info)
@@ -1438,8 +1519,20 @@ const _ = {
                                 return left < right ? -1 : left > right ? 1 : 0;
                             });
                             const feesEnabled = supportsTransactionFees(block.protocolVersion);
-                            for (const transaction of transactions)
-                                await _executeTransaction(transaction, validators, feesEnabled);
+                            const monetaryPolicyEnabled = supportsMonetaryPolicy(block.protocolVersion);
+                            if (monetaryPolicyEnabled)
+                                await validateBlockResourceLimits(transactions);
+                            const policy = monetaryPolicyEnabled
+                                ? calculateMonetaryPolicy(BigInt(contracts[nativeToken$2].totalSupply), BigInt(contracts[nativeToken$2].targetSupply))
+                                : { subsidy: 0n, burnBasisPoints: 1000n };
+                            for (const transaction of transactions) {
+                                await _executeTransaction(transaction, validators, feesEnabled, policy.burnBasisPoints);
+                            }
+                            if (monetaryPolicyEnabled && policy.subsidy > 0n) {
+                                _.settleRewards({
+                                    rewards: [...distributeAmount(policy.subsidy, validators, Number(block.index) % validators.length)]
+                                });
+                            }
                             block.loaded = true;
                             worker.postMessage({
                                 type: 'debug',
@@ -1507,6 +1600,9 @@ worker.onmessage(({ id, type, input }) => {
         case 'collectFee':
             runTask(id, 'collectFee', input);
             break;
+        case 'settleRewards':
+            runTask(id, 'settleRewards', input);
+            break;
         case 'contracts':
             respond(id, contracts);
             break;

package/exports/chain.js

@@ -2,8 +2,8 @@ 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, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
 import MultiWallet from '@leofcoin/multi-wallet';
 import { fromBase58 } from '@vandeurenglenn/typed-array-utils';
 import semver from 'semver';
@@ -78,19 +78,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);
     });
   }
@@ -946,6 +941,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();
@@ -1789,12 +1787,12 @@ class State extends Contract {
   #loadBlockTransactions;
   #getLastTransactions;
   // todo throw error
-  async #_executeTransaction(transaction, validators, feesEnabled) {
+  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints) {
     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(
@@ -1845,7 +1843,20 @@ 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);
+          }
+          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;
@@ -2289,7 +2300,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 +2309,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}`
@@ -2781,7 +2789,10 @@ class Chain extends VersionControl {
       })
     );
     const feesEnabled = supportsTransactionFees(blockMessage.decoded.protocolVersion);
-    if (feesEnabled) await this.#assertFeeBurnSupported();
+    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) => ({
@@ -2790,8 +2801,9 @@ 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) {
@@ -2809,13 +2821,24 @@ class Chain extends VersionControl {
     }
     return transactions;
   }
-  async #assertFeeBurnSupported() {
+  async #assertFeeBurnSupported(protocolVersion) {
     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");
+    const [canBurn, canMint] = await Promise.all([
+      this.staticCall(addresses.nativeToken, "hasRole", [creator, "BURN"]),
+      this.staticCall(addresses.nativeToken, "hasRole", [creator, "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;
@@ -3338,14 +3361,19 @@ 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 };
+      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);
     }
+    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);
       const noncesByAddress = {};
@@ -3445,7 +3473,7 @@ class Chain extends VersionControl {
       fees: BigInt(0),
       timestamp,
       previousHash: "",
-      reward: BLOCK_REWARD,
+      reward: 0n,
       index: 0,
       producer: "",
       producerProof: "",
@@ -3467,9 +3495,17 @@ 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 +3516,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 || "";

package/exports/workers/machine-worker.js

@@ -977,9 +977,17 @@ var bytecodes = {
 
 const TRANSACTION_FEE_BYTES = 1024n;
 const TRANSACTION_FEE_UNIT = 10n;
-const FEE_BURN_BASIS_POINTS = 1000n;
+const MAX_TRANSACTION_BYTES = 32 * 1024;
+const MAX_BLOCK_TRANSACTION_BYTES = 128 * 1024;
+const MAX_BLOCK_TRANSACTIONS = 256;
+(BigInt(MAX_TRANSACTION_BYTES) / TRANSACTION_FEE_BYTES) * TRANSACTION_FEE_UNIT;
 const FEE_BASIS_POINTS = 10000n;
 const FEE_PROTOCOL_VERSION = '1.10.9';
+const MONETARY_POLICY_PROTOCOL_VERSION = '1.10.10';
+const BLOCKS_PER_YEAR = 5256000n;
+const ANNUAL_ISSUANCE_BASIS_POINTS = 200n;
+const SUPPLY_FLOOR_BASIS_POINTS = 9500n;
+const MONETARY_FEE_BURN_BASIS_POINTS = 1000n;
 const parseProtocolVersion = (version) => {
     const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
     return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;
@@ -995,19 +1003,61 @@ const supportsTransactionFees = (version) => {
     }
     return true;
 };
+const supportsMonetaryPolicy = (version) => {
+    const actual = parseProtocolVersion(version);
+    const required = parseProtocolVersion(MONETARY_POLICY_PROTOCOL_VERSION);
+    if (!actual)
+        return false;
+    for (let index = 0; index < required.length; index += 1) {
+        if (actual[index] !== required[index])
+            return actual[index] > required[index];
+    }
+    return true;
+};
+const calculateMonetaryPolicy = (totalSupply, targetSupply) => {
+    if (totalSupply < 0n || targetSupply <= 0n)
+        throw new Error('invalid monetary policy supply');
+    const floorSupply = (targetSupply * SUPPLY_FLOOR_BASIS_POINTS) / FEE_BASIS_POINTS;
+    if (totalSupply < floorSupply) {
+        const annualIssuance = (targetSupply * ANNUAL_ISSUANCE_BASIS_POINTS) / FEE_BASIS_POINTS;
+        const scheduled = annualIssuance / BLOCKS_PER_YEAR || 1n;
+        return { subsidy: scheduled < floorSupply - totalSupply ? scheduled : floorSupply - totalSupply, burnBasisPoints: 0n, floorSupply };
+    }
+    return {
+        subsidy: 0n,
+        burnBasisPoints: totalSupply >= targetSupply ? MONETARY_FEE_BURN_BASIS_POINTS : 0n,
+        floorSupply
+    };
+};
+const distributeAmount = (amount, addresses, rotation = 0) => {
+    const canonical = [...new Set(addresses)].sort();
+    if (canonical.length === 0)
+        throw new Error('cannot distribute without validators');
+    const count = BigInt(canonical.length);
+    const base = amount / count;
+    const remainder = Number(amount % count);
+    const result = new Map(canonical.map((address) => [address, base]));
+    for (let index = 0; index < remainder; index += 1) {
+        const address = canonical[(rotation + index) % canonical.length];
+        result.set(address, result.get(address) + 1n);
+    }
+    return result;
+};
 const feeRotationIndex = (transactionHash, validatorCount) => {
     let value = 0n;
     for (const character of transactionHash)
         value = (value * 31n + BigInt(character.charCodeAt(0))) % 4294967291n;
     return Number(value % BigInt(validatorCount));
 };
-const distributeTransactionFee = (fee, transactionHash, validatorAddresses) => {
+const distributeTransactionFee = (fee, transactionHash, validatorAddresses, burnBasisPoints = 1000n) => {
     const canonicalValidators = [...new Set(validatorAddresses)].sort();
     if (canonicalValidators.length === 0)
         throw new Error('cannot distribute transaction fee without validators');
     if (fee < 0n)
         throw new Error('transaction fee cannot be negative');
-    const burned = (fee * FEE_BURN_BASIS_POINTS) / FEE_BASIS_POINTS;
+    if (burnBasisPoints < 0n || burnBasisPoints > FEE_BASIS_POINTS)
+        throw new Error('invalid fee burn rate');
+    const burned = (fee * burnBasisPoints) / FEE_BASIS_POINTS;
     const validatorPool = fee - burned;
     const count = BigInt(canonicalValidators.length);
     const base = validatorPool / count;
@@ -1030,6 +1080,26 @@ const calculateFee = async (transaction, format = false) => {
     const fee = units * TRANSACTION_FEE_UNIT;
     return format ? formatUnits(fee.toString()) : fee;
 };
+const validateTransactionResourceLimits = async (transaction) => {
+    const message = await new TransactionMessage(transaction);
+    const size = message.encoded.length;
+    if (size > MAX_TRANSACTION_BYTES) {
+        throw new Error(`transaction exceeds ${MAX_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+    }
+    return size;
+};
+const validateBlockResourceLimits = async (transactions) => {
+    if (transactions.length > MAX_BLOCK_TRANSACTIONS) {
+        throw new Error(`block exceeds ${MAX_BLOCK_TRANSACTIONS} transaction protocol limit`);
+    }
+    let size = 0;
+    for (const transaction of transactions)
+        size += await validateTransactionResourceLimits(transaction);
+    if (size > MAX_BLOCK_TRANSACTION_BYTES) {
+        throw new Error(`block transactions exceed ${MAX_BLOCK_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+    }
+    return size;
+};
 
 class LittlePubSub {
     subscribers = new Map();
@@ -1211,7 +1281,7 @@ const runTask = async (id, taskName, input) => {
         });
     }
 };
-const _executeTransaction = async (transaction, validators, feesEnabled) => {
+const _executeTransaction = async (transaction, validators, feesEnabled, burnBasisPoints) => {
     const hash = await new TransactionMessage(transaction).hash();
     if (latestTransactions.includes(hash)) {
         throw new Error(`double transaction found: ${hash}`);
@@ -1223,7 +1293,7 @@ const _executeTransaction = async (transaction, validators, feesEnabled) => {
         globalThis.state = await createState();
         if (feesEnabled) {
             const fee = BigInt(await calculateFee(transaction));
-            const { payments, burned } = distributeTransactionFee(fee, hash, validators);
+            const { payments, burned } = distributeTransactionFee(fee, hash, validators, burnBasisPoints);
             await _.collectFee({ from, payments, burned });
         }
         await _.execute({ contract: to, method, params });
@@ -1327,6 +1397,17 @@ const _ = {
         }
         return total;
     },
+    settleRewards: ({ rewards }) => {
+        globalThis.msg = createMessage(contracts[nativeToken$2].creator, nativeToken$2);
+        let minted = 0n;
+        for (const [validator, rawAmount] of rewards) {
+            const amount = BigInt(rawAmount);
+            if (amount > 0n)
+                contracts[nativeToken$2].mint(validator, amount);
+            minted += amount;
+        }
+        return minted;
+    },
     init: async (message) => {
         let { peerid, fromState, state, info } = message;
         if (info)
@@ -1438,8 +1519,20 @@ const _ = {
                                 return left < right ? -1 : left > right ? 1 : 0;
                             });
                             const feesEnabled = supportsTransactionFees(block.protocolVersion);
-                            for (const transaction of transactions)
-                                await _executeTransaction(transaction, validators, feesEnabled);
+                            const monetaryPolicyEnabled = supportsMonetaryPolicy(block.protocolVersion);
+                            if (monetaryPolicyEnabled)
+                                await validateBlockResourceLimits(transactions);
+                            const policy = monetaryPolicyEnabled
+                                ? calculateMonetaryPolicy(BigInt(contracts[nativeToken$2].totalSupply), BigInt(contracts[nativeToken$2].targetSupply))
+                                : { subsidy: 0n, burnBasisPoints: 1000n };
+                            for (const transaction of transactions) {
+                                await _executeTransaction(transaction, validators, feesEnabled, policy.burnBasisPoints);
+                            }
+                            if (monetaryPolicyEnabled && policy.subsidy > 0n) {
+                                _.settleRewards({
+                                    rewards: [...distributeAmount(policy.subsidy, validators, Number(block.index) % validators.length)]
+                                });
+                            }
                             block.loaded = true;
                             worker.postMessage({
                                 type: 'debug',
@@ -1507,6 +1600,9 @@ worker.onmessage(({ id, type, input }) => {
         case 'collectFee':
             runTask(id, 'collectFee', input);
             break;
+        case 'settleRewards':
+            runTask(id, 'settleRewards', input);
+            break;
         case 'contracts':
             respond(id, contracts);
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.10.9",
+  "version": "1.10.10",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {