@leofcoin/lib 1.3.8 → 1.3.9

package/exports/index.d.ts

@@ -26,15 +26,30 @@ export declare const nameServiceMessage: string;
 export declare const validatorsMessage: string;
 export declare const TRANSACTION_FEE_BYTES = 1024n;
 export declare const TRANSACTION_FEE_UNIT = 10n;
-export declare const FEE_BURN_BASIS_POINTS = 1000n;
+export declare const MAX_TRANSACTION_BYTES: number;
+export declare const MAX_BLOCK_TRANSACTION_BYTES: number;
+export declare const MAX_BLOCK_TRANSACTIONS = 256;
+export declare const MAX_TRANSACTION_FEE: bigint;
 export declare const FEE_BASIS_POINTS = 10000n;
 export declare const FEE_PROTOCOL_VERSION = "1.10.9";
+export declare const MONETARY_POLICY_PROTOCOL_VERSION = "1.10.10";
+export declare const BLOCKS_PER_YEAR = 5256000n;
+export declare const ANNUAL_ISSUANCE_BASIS_POINTS = 200n;
+export declare const SUPPLY_FLOOR_BASIS_POINTS = 9500n;
+export declare const MONETARY_FEE_BURN_BASIS_POINTS = 1000n;
 export declare const supportsTransactionFees: (version: string) => boolean;
+export declare const supportsMonetaryPolicy: (version: string) => boolean;
+export declare const calculateMonetaryPolicy: (totalSupply: bigint, targetSupply: bigint) => {
+    subsidy: bigint;
+    burnBasisPoints: bigint;
+    floorSupply: bigint;
+};
+export declare const distributeAmount: (amount: bigint, addresses: string[], rotation?: number) => Map<string, bigint>;
 export type FeePayment = {
     to: string;
     amount: bigint;
 };
-export declare const distributeTransactionFee: (fee: bigint, transactionHash: string, validatorAddresses: string[]) => {
+export declare const distributeTransactionFee: (fee: bigint, transactionHash: string, validatorAddresses: string[], burnBasisPoints?: bigint) => {
     burned: bigint;
     validatorFees: Map<string, bigint>;
     payments: FeePayment[];
@@ -42,9 +57,11 @@ export declare const distributeTransactionFee: (fee: bigint, transactionHash: st
 export declare const aggregateValidatorFees: (fees: Array<{
     fee: bigint;
     transactionHash: string;
-}>, validatorAddresses: string[]) => Map<string, bigint>;
+}>, validatorAddresses: string[], burnBasisPoints?: bigint) => Map<string, bigint>;
 export declare const createContractMessage: (creator: any, contract: any, constructorParameters?: never[]) => Promise<ContractMessage>;
 export declare const calculateFee: (transaction: any, format?: boolean) => Promise<string | bigint>;
+export declare const validateTransactionResourceLimits: (transaction: any) => Promise<number>;
+export declare const validateBlockResourceLimits: (transactions: any) => Promise<number>;
 export declare const calculateTransactionFee: (transaction: any) => Promise<string | bigint>;
 export declare const calculateReward: (validators: any, fees: any) => [];
 export declare const createTransactionHash: (transaction: rawTransaction | TransactionMessage | RawTransactionMessage) => Promise<Uint8Array>;

package/exports/index.js

@@ -21,9 +21,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;
+const MAX_TRANSACTION_FEE = (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;
@@ -39,19 +47,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;
@@ -67,10 +117,10 @@ const distributeTransactionFee = (fee, transactionHash, validatorAddresses) => {
         .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);
     }
@@ -90,6 +140,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 calculateTransactionFee = (transaction) => {
     transaction = new TransactionMessage(transaction);
     return calculateFee(transaction);
@@ -144,4 +214,4 @@ const prepareContractTransactionAndSign = async (owner, contract, constructorPar
     return signTransaction(transaction, wallet);
 };
 
-export { FEE_BASIS_POINTS, FEE_BURN_BASIS_POINTS, FEE_PROTOCOL_VERSION, TRANSACTION_FEE_BYTES, TRANSACTION_FEE_UNIT, aggregateValidatorFees, calculateFee, calculateReward, calculateTransactionFee, contractFactoryMessage, createContractMessage, createTransactionHash, distributeTransactionFee, nameServiceMessage, nativeTokenMessage, prepareContractTransaction, prepareContractTransactionAndSign, signTransaction, supportsTransactionFees, validatorsMessage };
+export { ANNUAL_ISSUANCE_BASIS_POINTS, BLOCKS_PER_YEAR, FEE_BASIS_POINTS, FEE_PROTOCOL_VERSION, MAX_BLOCK_TRANSACTIONS, MAX_BLOCK_TRANSACTION_BYTES, MAX_TRANSACTION_BYTES, MAX_TRANSACTION_FEE, MONETARY_FEE_BURN_BASIS_POINTS, MONETARY_POLICY_PROTOCOL_VERSION, SUPPLY_FLOOR_BASIS_POINTS, TRANSACTION_FEE_BYTES, TRANSACTION_FEE_UNIT, aggregateValidatorFees, calculateFee, calculateMonetaryPolicy, calculateReward, calculateTransactionFee, contractFactoryMessage, createContractMessage, createTransactionHash, distributeAmount, distributeTransactionFee, nameServiceMessage, nativeTokenMessage, prepareContractTransaction, prepareContractTransactionAndSign, signTransaction, supportsMonetaryPolicy, supportsTransactionFees, validateBlockResourceLimits, validateTransactionResourceLimits, validatorsMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/lib",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "description": "",
   "type": "module",
   "typings": "./exports/typings/index.d.ts",