@leofcoin/chain 1.10.8 → 1.10.10

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, 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);
     });
   }
@@ -896,7 +891,7 @@ class Machine {
    * @param {Array} parameters
    * @returns Promise<message>
    */
-  async execute(contract, method, parameters) {
+  async execute(contract, method, parameters, sender) {
     try {
       if (contract === contractFactory && method === "registerContract") {
         if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`);
@@ -937,11 +932,18 @@ ${error.message}`);
           to: contract,
           contract,
           method,
-          params: parameters
+          params: parameters,
+          sender
         }
       });
     });
   }
+  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();
@@ -1785,9 +1787,20 @@ class State extends Contract {
   #loadBlockTransactions;
   #getLastTransactions;
   // todo throw error
-  async #_executeTransaction(transaction) {
+  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints) {
     try {
-      await this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params);
+      const hash = await transaction.hash();
+      if (feesEnabled) {
+        const fee = BigInt(await calculateFee(transaction.decoded));
+        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
+      );
     } catch (error) {
       console.log(error);
       await globalThis.transactionPoolStore.delete(await transaction.hash());
@@ -1816,23 +1829,34 @@ class State extends Contract {
         try {
           debug$1(`loading block: ${Number(block.index)} ${block.hash}`);
           let transactions = await this.#loadBlockTransactions(block.transactions || []);
+          const validators = block.validators.map(({ address }) => address);
           debug$1(`loading transactions: ${transactions.length} for block ${block.index}`);
-          let priority = [];
           for (const transaction of transactions) {
             const hash = await transaction.hash();
-            if (transaction.decoded.priority) priority.push(transaction);
             if (poolTransactionKeys.has(hash)) await globalThis.transactionPoolStore.delete(hash);
           }
-          if (priority.length > 0) {
-            debug$1(`executing ${priority.length} priority transactions for block ${block.index}`);
-            priority = priority.sort((a, b) => a.nonce - b.nonce);
-            for (const transaction of priority) {
-              await this.#_executeTransaction(transaction);
-            }
-          }
-          transactions = transactions.filter((transaction) => !transaction.decoded.priority);
+          transactions = transactions.sort((a, b) => {
+            if (a.decoded.priority !== b.decoded.priority) return a.decoded.priority ? -1 : 1;
+            const left = BigInt(a.decoded.nonce);
+            const right = BigInt(b.decoded.nonce);
+            return left < right ? -1 : left > right ? 1 : 0;
+          });
           debug$1(`executing ${transactions.length} transactions for block ${block.index}`);
-          await Promise.all(transactions.map((transaction) => this.#_executeTransaction(transaction)));
+          const feesEnabled = supportsTransactionFees(block.protocolVersion);
+          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;
@@ -2276,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();
@@ -2286,19 +2309,18 @@ const validateCanonicalValidatorSet = (blockIndex, expectedValidators, validator
     );
   }
 };
-const validateBlockEconomics = (block, calculatedFees) => {
+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 expectedReward = calculatedFees / validatorCount + BLOCK_REWARD / validatorCount;
   for (const validator of block.validators) {
+    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}`
@@ -2766,10 +2788,57 @@ class Chain extends VersionControl {
         return transaction;
       })
     );
-    const calculatedFees = (await Promise.all(transactions.map((transaction) => calculateFee(transaction.decoded)))).reduce((total, fee) => total + BigInt(fee), 0n);
-    validateBlockEconomics(blockMessage.decoded, calculatedFees);
+    const feesEnabled = supportsTransactionFees(blockMessage.decoded.protocolVersion);
+    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)),
+        transactionHash: await transaction.hash()
+      }))
+    ) : [];
+    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)]));
+    validateBlockEconomics(blockMessage.decoded, calculatedFees, validatorFees, subsidyRewards, policy.subsidy);
+    if (feesEnabled) {
+      const feesBySender = /* @__PURE__ */ new Map();
+      for (let index = 0; index < transactions.length; index += 1) {
+        const sender = transactions[index].decoded.from;
+        feesBySender.set(sender, (feesBySender.get(sender) || 0n) + feeEntries[index].fee);
+      }
+      await Promise.all(
+        [...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}`);
+          }
+        })
+      );
+    }
     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"])
+    ]);
+    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;
@@ -3218,9 +3287,12 @@ class Chain extends VersionControl {
   async #versionHandler() {
     return new globalThis.peernet.protos["peernet-response"]({ response: this.version });
   }
-  async #executeTransaction({ hash, from, to, method, params, nonce }) {
+  async #executeTransaction({ hash, from, to, method, params, nonce, feePayments = { payments: [], burned: 0n } }) {
     try {
-      let result = await this.machine.execute(to, method, params);
+      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);
       globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: "fulfilled", hash });
       return result || "no state change";
     } catch (error) {
@@ -3289,10 +3361,18 @@ 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);
-      await this.#handleTransaction(transaction, []);
+      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);
+    }
+    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);
@@ -3349,7 +3429,7 @@ class Chain extends VersionControl {
     if (await this.hasTransactionToHandle() && !this.#runningEpoch && this.#participating) await this.#runEpoch();
     return true;
   }
-  async #handleTransaction(transaction, latestTransactions, block) {
+  async #handleTransaction(transaction, latestTransactions, block, feePayments = { payments: [], burned: 0n }) {
     await this.validateTransactionSignature(transaction);
     const hash = await transaction.hash();
     const doubleTransactions = [];
@@ -3362,7 +3442,7 @@ class Chain extends VersionControl {
       return;
     }
     try {
-      const result = await this.#executeTransaction({ ...transaction.decoded, hash });
+      const result = await this.#executeTransaction({ ...transaction.decoded, hash, feePayments });
       if (block) {
         block.transactions.push(hash);
         block.fees = block.fees += await calculateFee(transaction.decoded);
@@ -3393,7 +3473,7 @@ class Chain extends VersionControl {
       fees: BigInt(0),
       timestamp,
       previousHash: "",
-      reward: BLOCK_REWARD,
+      reward: 0n,
       index: 0,
       producer: "",
       producerProof: "",
@@ -3415,10 +3495,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);
-      block.fees += BigInt(await calculateFee(transaction.decoded));
+      blockTransactionBytes += transactionBytes;
+      if (supportsTransactionFees(this.version)) block.fees += BigInt(await calculateFee(transaction.decoded));
       await globalThis.peernet.put(hash, transaction.encoded, "transaction");
     }
     if (block.transactions.length === 0) return;
@@ -3428,9 +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(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, 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: block.fees / BigInt(sortedValidators.length) + block.reward / BigInt(sortedValidators.length)
+      reward: (validatorFees.get(validatorAddress) || 0n) + (subsidyRewards.get(validatorAddress) || 0n)
     }));
     try {
       block.producer = globalThis.peernet.selectedAccount || "";
@@ -3555,7 +3654,7 @@ class Chain extends VersionControl {
    * @returns
    */
   internalCall(sender, contract, method, parameters) {
-    return this.machine.execute(contract, method, parameters);
+    return this.machine.execute(contract, method, parameters, sender);
   }
   /**
    *
@@ -3565,7 +3664,7 @@ class Chain extends VersionControl {
    * @returns
    */
   call(contract, method, parameters) {
-    return this.machine.execute(contract, method, parameters);
+    return this.machine.execute(contract, method, parameters, globalThis.peernet.selectedAccount);
   }
   staticCall(contract, method, parameters) {
     return this.machine.get(contract, method, parameters);