@leofcoin/chain 1.10.7 → 1.10.9

package/exports/browser/chain.js

@@ -1056,6 +1056,61 @@ const contractFactoryMessage = bytecodes.contractFactory;
 const nativeTokenMessage = bytecodes.nativeToken;
 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 FEE_BASIS_POINTS = 10000n;
+const FEE_PROTOCOL_VERSION = "1.10.9";
+const parseProtocolVersion = (version) => {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
+};
+const supportsTransactionFees = (version) => {
+  const actual = parseProtocolVersion(version);
+  const required = parseProtocolVersion(FEE_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 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 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;
+  const validatorPool = fee - burned;
+  const count = BigInt(canonicalValidators.length);
+  const base = validatorPool / count;
+  const remainder = Number(validatorPool % count);
+  const start = feeRotationIndex(transactionHash, canonicalValidators.length);
+  const validatorFees = new Map(canonicalValidators.map((validator) => [validator, base]));
+  for (let index = 0; index < remainder; index += 1) {
+    const validator = canonicalValidators[(start + index) % canonicalValidators.length];
+    validatorFees.set(validator, validatorFees.get(validator) + 1n);
+  }
+  const payments = [...validatorFees.entries()].filter(([, amount]) => amount > 0n).map(([to, amount]) => ({ to, amount }));
+  return { burned, validatorFees, payments };
+};
+const aggregateValidatorFees = (fees, validatorAddresses) => {
+  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);
+    for (const [validator, amount] of validatorFees)
+      totals.set(validator, totals.get(validator) + amount);
+  }
+  return totals;
+};
 const createContractMessage = async (creator, contract, constructorParameters = []) => {
   return new ContractMessage({
     creator,
@@ -1064,11 +1119,10 @@ const createContractMessage = async (creator, contract, constructorParameters =
   });
 };
 const calculateFee = async (transaction, format = false) => {
-  if (transaction.to === validators$2)
-    return 0;
   transaction = await new TransactionMessage(transaction);
-  let fee = toBigInt(String(transaction.encoded.length));
-  fee /= 1073741824n;
+  const encodedBytes = BigInt(transaction.encoded.length);
+  const units = (encodedBytes + TRANSACTION_FEE_BYTES - 1n) / TRANSACTION_FEE_BYTES;
+  const fee = units * TRANSACTION_FEE_UNIT;
   return format ? formatUnits(fee.toString()) : fee;
 };
 const createTransactionHash = async (transaction) => {
@@ -8801,7 +8855,7 @@ class Machine {
    * @param {Array} parameters
    * @returns Promise<message>
    */
-  async execute(contract, method, parameters) {
+  async execute(contract, method, parameters, sender) {
     try {
       if (contract === contractFactory$2 && method === "registerContract") {
         if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`);
@@ -8842,11 +8896,15 @@ ${error.message}`);
           to: contract,
           contract,
           method,
-          params: parameters
+          params: parameters,
+          sender
         }
       });
     });
   }
+  collectFee(from, payments, burned) {
+    return this.#askWorker("collectFee", { from, payments, burned });
+  }
   get(contract, method, parameters) {
     return new Promise((resolve, reject) => {
       const id = randombytes(20).toString();
@@ -9690,9 +9748,20 @@ class State extends Contract {
   #loadBlockTransactions;
   #getLastTransactions;
   // todo throw error
-  async #_executeTransaction(transaction) {
+  async #_executeTransaction(transaction, validators, feesEnabled) {
     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);
+        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());
@@ -9721,23 +9790,21 @@ 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);
+          for (const transaction of transactions) await this.#_executeTransaction(transaction, validators, feesEnabled);
           this.#blocks[block.index].loaded = true;
           debug$1(`executed transactions for block ${block.index}`);
           if (Number(block.index) === 0) this.#loaded = true;
@@ -10181,6 +10248,47 @@ 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();
+  if (actualValidators.length !== canonicalExpected.length || actualValidators.some((address, index) => address !== canonicalExpected[index])) {
+    throw new Error(
+      `Block ${blockIndex} validator set mismatch: expected ${canonicalExpected.join(",")}, got ${actualValidators.join(",")}`
+    );
+  }
+};
+const validateBlockEconomics = (block, calculatedFees, validatorFees = /* @__PURE__ */ new Map()) => {
+  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.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);
+    if (validator.reward !== expectedReward) {
+      throw new Error(
+        `Block ${block.index} has an invalid reward for validator ${validator.address}: expected ${expectedReward}, got ${validator.reward}`
+      );
+    }
+  }
+};
+
+const resolveTransactionReference = async (expectedHash, transactionData) => {
+  const transaction = transactionData instanceof TransactionMessage ? transactionData : new TransactionMessage(transactionData);
+  const actualHash = await transaction.hash();
+  if (actualHash !== expectedHash) {
+    throw new Error(`Transaction hash mismatch: expected ${expectedHash}, got ${actualHash}`);
+  }
+  return transaction;
+};
+
 const consensusSignableData = (validatorsAddress, type, message) => ({
   from: String(message.from),
   to: validatorsAddress,
@@ -10348,8 +10456,23 @@ class Chain extends VersionControl {
             debug(`[consensus] Block hash mismatch in proposal: expected ${blockHash}, got ${actualHash}`);
             return;
           }
+          if (BigInt(blockMessage.decoded.index) !== index) {
+            debug(`[consensus] Proposal height ${index} does not match block height ${blockMessage.decoded.index}`);
+            return;
+          }
+          if (blockMessage.decoded.producer !== from) {
+            debug(`[consensus] Proposal sender ${from} does not match block producer ${blockMessage.decoded.producer}`);
+            return;
+          }
+          validateChainLink(localBlock, {
+            index: Number(blockMessage.decoded.index),
+            hash: actualHash,
+            previousHash: String(blockMessage.decoded.previousHash)
+          });
+          await this.#validateBlockValidators(blockMessage);
+          await this.#resolveBlockTransactions(blockMessage);
         } catch (e) {
-          debug(`[consensus] Cannot fetch proposed block ${blockHash}:`, e?.message);
+          debug(`[consensus] Invalid proposed block ${blockHash}:`, e?.message);
           return;
         }
         this.#consensusRound = Number(round);
@@ -10604,14 +10727,52 @@ class Chain extends VersionControl {
     if (new Set(validatorAddresses).size !== validatorAddresses.length) {
       throw new Error(`Block ${blockMessage.decoded.index} validators contain duplicates`);
     }
-    const validatorCount = BigInt(validators.length);
-    const expectedReward = blockMessage.decoded.fees / validatorCount + blockMessage.decoded.reward / validatorCount;
-    for (const validator of validators) {
-      if (validator.reward !== expectedReward) {
-        throw new Error(
-          `Block ${blockMessage.decoded.index} has an invalid reward for validator ${validator.address}: expected ${expectedReward}, got ${validator.reward}`
-        );
+    const expectedValidators = await this.staticCall(addresses.validators, "validators");
+    validateCanonicalValidatorSet(blockMessage.decoded.index, expectedValidators, validators);
+  }
+  async #resolveBlockTransactions(blockMessage) {
+    const transactions = await Promise.all(
+      blockMessage.decoded.transactions.map(async (expectedHash) => {
+        const data = await globalThis.peernet.get(expectedHash, "transaction");
+        const transaction = await resolveTransactionReference(expectedHash, data);
+        await this.validateTransactionSignature(transaction);
+        return transaction;
+      })
+    );
+    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;
+    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) : new Map(validatorAddresses.map((address) => [address, 0n]));
+    validateBlockEconomics(blockMessage.decoded, calculatedFees, validatorFees);
+    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() {
+    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");
     }
   }
   /** Check if the next block will cross an epoch boundary (block-based timing) */
@@ -11062,9 +11223,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) {
@@ -11111,13 +11275,7 @@ class Chain extends VersionControl {
     }
     console.log(`[chain] \u2705 Block data integrity verified: ${hash}`);
     await this.#validateBlockValidators(blockMessage);
-    const transactions = await Promise.all(
-      blockMessage.decoded.transactions.map(async (hash2) => {
-        const data = await peernet.get(hash2, "transaction");
-        return new TransactionMessage(data);
-      })
-    );
-    await Promise.all(transactions.map((transaction) => this.validateTransactionSignature(transaction)));
+    const transactions = await this.#resolveBlockTransactions(blockMessage);
     await Promise.all(
       blockMessage.decoded.transactions.map(async (transactionHash) => {
         if (await transactionPoolStore.has(transactionHash)) await transactionPoolStore.delete(transactionHash);
@@ -11142,7 +11300,10 @@ class Chain extends VersionControl {
     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) : { payments: [], burned: 0n };
+      await this.#handleTransaction(transaction, [], void 0, feeDistribution);
     }
     try {
       promises = await Promise.allSettled(promises);
@@ -11199,7 +11360,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 = [];
@@ -11212,7 +11373,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);
@@ -11243,7 +11404,7 @@ class Chain extends VersionControl {
       fees: BigInt(0),
       timestamp,
       previousHash: "",
-      reward: BigInt(150),
+      reward: BLOCK_REWARD,
       index: 0,
       producer: "",
       producerProof: "",
@@ -11268,7 +11429,7 @@ class Chain extends VersionControl {
     for (const { transaction, hash } of allTransactions) {
       await this.validateTransactionSignature(transaction);
       block.transactions.push(hash);
-      block.fees += BigInt(await calculateFee(transaction.decoded));
+      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;
@@ -11278,9 +11439,17 @@ 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();
+    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]));
     block.validators = sortedValidators.map((validatorAddress) => ({
       address: validatorAddress,
-      reward: block.fees / BigInt(sortedValidators.length) + block.reward / BigInt(sortedValidators.length)
+      reward: (validatorFees.get(validatorAddress) || 0n) + block.reward / BigInt(sortedValidators.length)
     }));
     try {
       block.producer = globalThis.peernet.selectedAccount || "";
@@ -11405,7 +11574,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);
   }
   /**
    *
@@ -11415,7 +11584,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);