chore: kip9 version remove & test-11 payload active (#210)

packages/coin-kaspa/src/lib/consensus/config/constants/perf.ts

@@ -2,7 +2,7 @@
 export const DEFAULT_REINDEX_DEPTH: bigint = 100n;
 
 /** The default slack interval used by the reachability algorithm to encounter for blocks out of the selected chain. */
-export const DEFAULT_REINDEX_SLACK: bigint = 1n << 12n;
+export const DEFAULT_REINDEX_SLACK: bigint = 1n << 14n;
 
 const BASELINE_HEADER_DATA_CACHE_SIZE: bigint = 10000n;
 const BASELINE_BLOCK_DATA_CACHE_SIZE: bigint = 200n;

packages/coin-kaspa/src/lib/consensus/config/network-params.ts

@@ -1,5 +1,4 @@
 import { NetworkId, NetworkType } from '../network';
-import { Kip9Version } from '../kip';
 
 /**
  * Class representing network parameters.
@@ -8,28 +7,24 @@ class NetworkParams {
   coinbaseTransactionMaturityPeriodDaa: bigint;
   coinbaseTransactionStasisPeriodDaa: bigint;
   userTransactionMaturityPeriodDaa: bigint;
-  kip9Version: Kip9Version;
   additionalCompoundTransactionMass: bigint;
 
   /**
    * Creates an instance of NetworkParams.
    * @param {bigint} coinbaseTransactionMaturityPeriodDaa - The maturity period for coinbase transactions.
    * @param {bigint} coinbaseTransactionStasisPeriodDaa - The stasis period for coinbase transactions.
    * @param {bigint} userTransactionMaturityPeriodDaa - The maturity period for user transactions.
-   * @param {Kip9Version} kip9Version - The KIP-9 version.
    * @param {bigint} additionalCompoundTransactionMass - The additional compound transaction mass.
    */
   constructor(
     coinbaseTransactionMaturityPeriodDaa: bigint,
     coinbaseTransactionStasisPeriodDaa: bigint,
     userTransactionMaturityPeriodDaa: bigint,
-    kip9Version: Kip9Version,
     additionalCompoundTransactionMass: bigint
   ) {
     this.coinbaseTransactionMaturityPeriodDaa = coinbaseTransactionMaturityPeriodDaa;
     this.coinbaseTransactionStasisPeriodDaa = coinbaseTransactionStasisPeriodDaa;
     this.userTransactionMaturityPeriodDaa = userTransactionMaturityPeriodDaa;
-    this.kip9Version = kip9Version;
     this.additionalCompoundTransactionMass = additionalCompoundTransactionMass;
   }
 
@@ -66,27 +61,27 @@ class NetworkParams {
  * Mainnet network parameters.
  * @type {NetworkParams}
  */
-const MAINNET_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, Kip9Version.Beta, 100n);
+const MAINNET_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, 100n);
 /**
  * Testnet10 network parameters.
  * @type {NetworkParams}
  */
-const TESTNET10_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, Kip9Version.Beta, 100n);
+const TESTNET10_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, 100n);
 /**
  * Testnet11 network parameters.
  * @type {NetworkParams}
  */
-const TESTNET11_NETWORK_PARAMS = new NetworkParams(1000n, 500n, 100n, Kip9Version.Alpha, 100n);
+const TESTNET11_NETWORK_PARAMS = new NetworkParams(1000n, 500n, 100n, 100n);
 /**
  * Simnet network parameters.
  * @type {NetworkParams}
  */
-const SIMNET_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, Kip9Version.Alpha, 0n);
+const SIMNET_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, 0n);
 /**
  * Devnet network parameters.
  * @type {NetworkParams}
  */
-const DEVNET_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, Kip9Version.Beta, 0n);
+const DEVNET_NETWORK_PARAMS = new NetworkParams(100n, 50n, 10n, 0n);
 
 export {
   NetworkParams,

packages/coin-kaspa/src/lib/consensus/config/params.ts

@@ -48,6 +48,8 @@ class Params {
   skipProofOfWork: boolean;
   maxBlockLevel: number;
   pruningProofM: bigint;
+
+  /// Activation rules for when to enable using the payload field in transactions
   payloadActivation: ForkActivation;
 
   /**
@@ -424,11 +426,13 @@ const TESTNET11_PARAMS: Params = {
 
   storageMassParameter: STORAGE_MASS_PARAMETER,
   storageMassActivation: ForkActivation.always(),
-  kip10Activation: ForkActivation.never(),
+
+  // Roughly at Dec 3, 2024 1800 UTC
+  kip10Activation: new ForkActivation(287238000),
+  payloadActivation: new ForkActivation(287238000),
 
   skipProofOfWork: false,
-  maxBlockLevel: 250,
-  payloadActivation: ForkActivation.never()
+  maxBlockLevel: 250
 };
 
 const SIMNET_PARAMS: Params = {

packages/coin-kaspa/src/lib/consensus/index.ts

@@ -2,4 +2,3 @@ export * from './network';
 export * from './subnetwork-id';
 export * from './script-public-key';
 export * from './config';
-export * from './kip';

packages/coin-kaspa/src/lib/tx/generator/genrator.ts

@@ -1,7 +1,7 @@
 import { MAXIMUM_STANDARD_TRANSACTION_MASS, UNACCEPTED_DAA_SCORE } from '../../tx/constants';
 import { UnsignedTxMassCalculator } from '../../tx/mass/unsigned-tx-mass-calc';
 import { Address, AddressPrefixHelper } from '../../address';
-import { Kip9Version, NetworkId, NetworkParams, Params, ScriptPublicKey, SUBNETWORK_ID_NATIVE } from '../../consensus';
+import { NetworkId, NetworkParams, Params, ScriptPublicKey, SUBNETWORK_ID_NATIVE } from '../../consensus';
 import {
   Data,
   DataKind,
@@ -120,7 +120,7 @@ class Generator {
 
     this.networkId = networkId;
     this.networkParams = NetworkParams.from(networkId);
-    this.massCalculator = new UnsignedTxMassCalculator(Params.fromNetworkId(networkId), this.networkParams);
+    this.massCalculator = new UnsignedTxMassCalculator(Params.fromNetworkId(networkId));
     this.sigOpCount = sigOpCount;
     this.minimumSignatures = minimumSignatures;
     this.changeAddress = changeAddress;
@@ -681,10 +681,7 @@ class Generator {
             calc.calcStorageMassOutputHarmonicSingle(changeValue) + this.finalTransactionOutputsHarmonic;
           const storageMassWithChange = this.calcStorageMass(data, outputHarmonicWithChange);
 
-          if (
-            storageMassWithChange === 0n ||
-            (this.networkParams.kip9Version === Kip9Version.Beta && storageMassWithChange < computeMassWithChange)
-          ) {
+          if (storageMassWithChange === 0n || storageMassWithChange < computeMassWithChange) {
             return 0n;
           } else {
             const storageMassNoChange = this.calcStorageMass(data, this.finalTransactionOutputsHarmonic);

packages/coin-kaspa/src/lib/tx/mass/signed-tx-mass-calc.ts

@@ -1,7 +1,6 @@
 import { Transaction, IVerifiableTransaction } from '../';
 import { TransactionCalculator, StorageMassCalculator } from './';
 import { validateU64 } from '../../validator';
-import { Kip9Version } from '../../consensus';
 
 /**
  * SignedTxMassCalculator class for calculating signed transaction mass.
@@ -78,15 +77,13 @@ class SignedTxMassCalculator {
    * 2. At least one input (unless coinbase)
    * Otherwise this function should never fail.
    * @param {IVerifiableTransaction} tx - The transaction to calculate the storage mass for.
-   * @param {Kip9Version} version - The KIP9 version to use for the calculation.
    * @returns {bigint | undefined} The storage mass of the transaction, or undefined if it cannot be calculated.
    */
-  calcTxStorageMass(tx: IVerifiableTransaction, version: Kip9Version): bigint | undefined {
+  calcTxStorageMass(tx: IVerifiableTransaction): bigint | undefined {
     return StorageMassCalculator.calcStorageMass(
       tx.isCoinbase(),
       tx.populatedInputs().map(([, entry]) => entry.amount),
       tx.outputs().map((out) => out.value),
-      version,
       this.storageMassParameter
     );
   }
@@ -95,19 +92,13 @@ class SignedTxMassCalculator {
    * Calculates the overall mass of this transaction, combining both compute and storage masses.
    * The combination strategy depends on the version passed.
    * @param {IVerifiableTransaction} tx - The transaction to calculate the overall mass for.
-   * @param {Kip9Version} version - The KIP9 version to use for the calculation.
    * @returns {bigint | undefined} The overall mass of the transaction, or undefined if it cannot be calculated.
    */
-  calcTxOverallMass(tx: IVerifiableTransaction, version: Kip9Version): bigint | undefined {
-    const storageMass = this.calcTxStorageMass(tx, version);
+  calcTxOverallMass(tx: IVerifiableTransaction): bigint | undefined {
+    const storageMass = this.calcTxStorageMass(tx);
     const computeMass = this.calcTxComputeMass(tx.tx());
 
-    switch (version) {
-      case Kip9Version.Alpha:
-        return storageMass !== undefined ? storageMass + computeMass : undefined;
-      case Kip9Version.Beta:
-        return storageMass !== undefined ? (storageMass > computeMass ? storageMass : computeMass) : undefined;
-    }
+    return storageMass !== undefined ? (storageMass > computeMass ? storageMass : computeMass) : undefined;
   }
 }
 

packages/coin-kaspa/src/lib/tx/mass/storage-mass-calc.ts

@@ -1,5 +1,3 @@
-import { Kip9Version } from '../../consensus';
-
 class StorageMassCalculator {
   /**
    * Calculates the storage mass for the provided input and output values.
@@ -10,15 +8,13 @@ class StorageMassCalculator {
    * @param {boolean} isCoinbase - Whether the transaction is a coinbase transaction.
    * @param {Iterable<number>} inputValues - The input values of the transaction.
    * @param {Iterable<number>} outputValues - The output values of the transaction.
-   * @param {Kip9Version} version - The KIP9 version to use for the calculation.
    * @param {number} storageMassParameter - The storage mass parameter to use for the calculation.
    * @returns {number | undefined} The storage mass of the transaction, or undefined if it cannot be calculated.
    */
   static calcStorageMass(
     isCoinbase: boolean,
     inputValues: Iterable<bigint>,
     outputValues: Iterable<bigint>,
-    version: Kip9Version,
     storageMassParameter: bigint
   ): bigint | undefined {
     if (isCoinbase) {
@@ -32,7 +28,7 @@ class StorageMassCalculator {
       .map((out) => storageMassParameter / out)
       .reduce((total, current) => total + current, 0n);
 
-    if (version === Kip9Version.Beta && (outsLen === 1n || insLen === 1n || (outsLen === 2n && insLen === 2n))) {
+    if (outsLen === 1n || insLen === 1n || (outsLen === 2n && insLen === 2n)) {
       const harmonicIns = Array.from(inputValues)
         .map((value) => storageMassParameter / value)
         .reduce((total, current) => total + current, 0n);

packages/coin-kaspa/src/lib/tx/mass/unsigned-tx-mass-calc.ts

@@ -8,7 +8,7 @@ import {
 } from '../';
 import { StorageMassCalculator } from './storage-mass-calc';
 import { STANDARD_OUTPUT_SIZE_PLUS_INPUT_SIZE_3X, TransactionCalculator } from './tx-calc';
-import { Kip9Version, NetworkParams, Params } from '../../consensus';
+import { Params } from '../../consensus';
 
 /**
  * Class to calculate the mass of unsigned transactions.
@@ -18,19 +18,16 @@ class UnsignedTxMassCalculator {
   massPerScriptPubKeyByte: bigint;
   massPerSigOp: bigint;
   storageMassParameter: bigint;
-  kip9Version: Kip9Version;
 
   /**
    * Constructor for UnsignedTxMassCalculator.
    * @param consensusParams - Consensus parameters.
-   * @param networkParams - Network parameters.
    */
-  constructor(consensusParams: Params, networkParams: NetworkParams) {
+  constructor(consensusParams: Params) {
     this.massPerTxByte = consensusParams.massPerTxByte;
     this.massPerScriptPubKeyByte = consensusParams.massPerScriptPubKeyByte;
     this.massPerSigOp = consensusParams.massPerSigOp;
     this.storageMassParameter = consensusParams.storageMassParameter;
-    this.kip9Version = networkParams.kip9Version;
   }
 
   /**
@@ -174,12 +171,7 @@ class UnsignedTxMassCalculator {
    * @returns The combined mass.
    */
   combineMass(computeMass: bigint, storageMass: bigint): bigint {
-    switch (this.kip9Version) {
-      case Kip9Version.Alpha:
-        return computeMass + storageMass;
-      case Kip9Version.Beta:
-        return computeMass > storageMass ? computeMass : storageMass;
-    }
+    return computeMass > storageMass ? computeMass : storageMass;
   }
 
   /**
@@ -210,7 +202,6 @@ class UnsignedTxMassCalculator {
       false,
       inputs.map((entry) => entry.amount),
       outputs.map((out) => out.value),
-      this.kip9Version,
       this.storageMassParameter
     );
   }