@aztec/cli 3.0.0-nightly.20251111 → 3.0.0-nightly.20251113

package/src/cmds/validator_keys/staker.ts

@@ -0,0 +1,298 @@
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { GSEContract, createEthereumChain } from '@aztec/ethereum';
+import { computeBn254G1PublicKey, computeBn254G2PublicKey } from '@aztec/foundation/crypto';
+import { decryptBn254Keystore } from '@aztec/foundation/crypto/bls/bn254_keystore';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+import { loadKeystoreFile } from '@aztec/node-keystore/loader';
+import type {
+  AttesterAccount,
+  AttesterAccounts,
+  BLSAccount,
+  EncryptedKeyFileConfig,
+  EthAccount,
+  MnemonicConfig,
+} from '@aztec/node-keystore/types';
+
+import { Wallet } from '@ethersproject/wallet';
+import { readFileSync, writeFileSync } from 'fs';
+import { createPublicClient, fallback, http } from 'viem';
+import { privateKeyToAddress } from 'viem/accounts';
+
+export type StakerOptions = {
+  from: string;
+  password?: string;
+  output?: string;
+  gseAddress: EthAddress;
+  l1RpcUrls: string[];
+  l1ChainId: number;
+};
+
+export type StakerOutput = {
+  attester: string;
+  publicKeyG1: {
+    x: string;
+    y: string;
+  };
+  publicKeyG2: {
+    x0: string;
+    x1: string;
+    y0: string;
+    y1: string;
+  };
+  proofOfPossession: {
+    x: string;
+    y: string;
+  };
+};
+
+/**
+ * Check if an object is a MnemonicConfig
+ */
+function isMnemonicConfig(obj: unknown): obj is MnemonicConfig {
+  return typeof obj === 'object' && obj !== null && 'mnemonic' in obj;
+}
+
+/**
+ * Check if a value is an encrypted keystore file config
+ */
+function isEncryptedKeyFileConfig(value: unknown): value is EncryptedKeyFileConfig {
+  return typeof value === 'object' && value !== null && 'path' in value;
+}
+
+/**
+ * Check if a BLSAccount is a private key string (not an encrypted keystore file)
+ */
+function isBlsPrivateKey(bls: unknown): bls is string {
+  return typeof bls === 'string' && bls.startsWith('0x');
+}
+
+/**
+ * Check if an EthAccount is a private key string (66 chars: 0x + 64 hex)
+ */
+function isEthPrivateKey(eth: unknown): eth is string {
+  return typeof eth === 'string' && eth.startsWith('0x') && eth.length === 66;
+}
+
+/**
+ * Check if a string is an Ethereum address (42 chars: 0x + 40 hex)
+ */
+function isEthAddress(value: unknown): value is string {
+  return typeof value === 'string' && /^0x[0-9a-fA-F]{40}$/.test(value);
+}
+
+/**
+ * Decrypt a BLS private key from an encrypted keystore file
+ */
+function decryptBlsKey(bls: BLSAccount, password?: string): string | undefined {
+  if (isBlsPrivateKey(bls)) {
+    return bls;
+  }
+
+  if (isEncryptedKeyFileConfig(bls)) {
+    if (!password && !bls.password) {
+      return undefined; // Can't decrypt without password
+    }
+    const pwd = password ?? bls.password!;
+    return decryptBn254Keystore(bls.path, pwd);
+  }
+
+  return undefined;
+}
+
+/**
+ * Decrypt an Ethereum private key from an encrypted keystore file
+ */
+async function decryptEthKey(eth: EthAccount, password?: string): Promise<string | undefined> {
+  if (isEthPrivateKey(eth)) {
+    return eth;
+  }
+
+  if (isEncryptedKeyFileConfig(eth)) {
+    if (!password && !eth.password) {
+      return undefined; // Can't decrypt without password
+    }
+    const pwd = password ?? eth.password!;
+    const json = readFileSync(eth.path, 'utf-8');
+    const wallet = await Wallet.fromEncryptedJson(json, pwd);
+    return wallet.privateKey as string;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extract Ethereum address from an EthAccount (or private key)
+ */
+async function getEthAddress(eth: EthAccount | string, password?: string): Promise<EthAddress | undefined> {
+  // Case 1: It's a private key string - derive the address
+  if (isEthPrivateKey(eth)) {
+    return privateKeyToAddress(eth as `0x${string}`) as unknown as EthAddress;
+  }
+
+  // Case 2: It's just an address string directly (EthRemoteSignerAccount can be just EthAddress)
+  if (isEthAddress(eth)) {
+    return eth as unknown as EthAddress;
+  }
+
+  // Case 3: It's an object with an address property (remote signer config)
+  if (typeof eth === 'object' && eth !== null && 'address' in eth) {
+    return (eth as any).address as EthAddress;
+  }
+
+  // Case 4: It's an encrypted keystore file - decrypt and derive address
+  if (isEncryptedKeyFileConfig(eth)) {
+    const privateKey = await decryptEthKey(eth, password);
+    if (privateKey) {
+      return privateKeyToAddress(privateKey as `0x${string}`) as unknown as EthAddress;
+    }
+    return undefined;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extract BLS private key and Ethereum address from an AttesterAccount
+ */
+async function extractAttesterInfo(
+  attester: AttesterAccount,
+  password?: string,
+): Promise<{ blsPrivateKey?: string; ethAddress?: EthAddress }> {
+  // Case 1: attester is { eth: EthAccount, bls?: BLSAccount }
+  if (typeof attester === 'object' && attester !== null && 'eth' in attester) {
+    const ethAddress = await getEthAddress(attester.eth, password);
+    const blsPrivateKey = attester.bls ? decryptBlsKey(attester.bls, password) : undefined;
+    return { blsPrivateKey, ethAddress };
+  }
+
+  // Case 2: attester is just an EthAccount directly (no BLS key)
+  return {
+    blsPrivateKey: undefined,
+    ethAddress: await getEthAddress(attester as EthAccount, password),
+  };
+}
+
+/**
+ * Process a single attester entry and output staking JSON
+ */
+async function processAttester(
+  attester: AttesterAccount,
+  gse: GSEContract,
+  password?: string,
+): Promise<StakerOutput | undefined> {
+  const { blsPrivateKey, ethAddress } = await extractAttesterInfo(attester, password);
+
+  // Skip if no BLS private key or no Ethereum address
+  if (!blsPrivateKey || !ethAddress) {
+    return undefined;
+  }
+
+  // Derive G1 and G2 public keys
+  const g1PublicKey = await computeBn254G1PublicKey(blsPrivateKey);
+  const g2PublicKey = await computeBn254G2PublicKey(blsPrivateKey);
+
+  // Generate proof of possession
+  const bn254SecretKeyFieldElement = Fr.fromString(blsPrivateKey);
+  const registrationTuple = await gse.makeRegistrationTuple(bn254SecretKeyFieldElement.toBigInt());
+
+  return {
+    attester: String(ethAddress),
+    publicKeyG1: {
+      x: '0x' + g1PublicKey.x.toString(16).padStart(64, '0'),
+      y: '0x' + g1PublicKey.y.toString(16).padStart(64, '0'),
+    },
+    publicKeyG2: {
+      x0: '0x' + g2PublicKey.x.c0.toString(16).padStart(64, '0'),
+      x1: '0x' + g2PublicKey.x.c1.toString(16).padStart(64, '0'),
+      y0: '0x' + g2PublicKey.y.c0.toString(16).padStart(64, '0'),
+      y1: '0x' + g2PublicKey.y.c1.toString(16).padStart(64, '0'),
+    },
+    proofOfPossession: {
+      x: '0x' + registrationTuple.proofOfPossession.x.toString(16),
+      y: '0x' + registrationTuple.proofOfPossession.y.toString(16),
+    },
+  };
+}
+
+/**
+ * Process AttesterAccounts (which can be a single attester, array, or mnemonic)
+ */
+export async function processAttesterAccounts(
+  attesterAccounts: AttesterAccounts,
+  gse: GSEContract,
+  password?: string,
+): Promise<StakerOutput[]> {
+  // Skip mnemonic configs
+  if (isMnemonicConfig(attesterAccounts)) {
+    return [];
+  }
+
+  // Handle array of attesters
+  if (Array.isArray(attesterAccounts)) {
+    const results: StakerOutput[] = [];
+    for (const attester of attesterAccounts) {
+      const result = await processAttester(attester, gse, password);
+      if (result) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+
+  // Handle single attester
+  const result = await processAttester(attesterAccounts, gse, password);
+  return result ? [result] : [];
+}
+
+/**
+ * Main staker command function
+ */
+export async function generateStakerJson(options: StakerOptions, log: LogFn): Promise<void> {
+  const { from, password, gseAddress, l1RpcUrls, l1ChainId, output } = options;
+
+  // Load the keystore file
+  const keystore = loadKeystoreFile(from);
+
+  if (!gseAddress) {
+    throw new Error('GSE contract address is required');
+  }
+  log(`Calling GSE contract ${gseAddress} on chain ${l1ChainId}, using ${l1RpcUrls.join(', ')} to get staker outputs`);
+
+  if (!keystore.validators || keystore.validators.length === 0) {
+    log('No validators found in keystore');
+    return;
+  }
+
+  const allOutputs: StakerOutput[] = [];
+
+  // L1 client for proof of possession
+  const chain = createEthereumChain(l1RpcUrls, l1ChainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(l1RpcUrls.map(url => http(url))),
+  });
+  const gse = new GSEContract(publicClient, gseAddress);
+
+  // Process each validator
+  for (const validator of keystore.validators) {
+    const outputs = await processAttesterAccounts(validator.attester, gse, password);
+    allOutputs.push(...outputs);
+  }
+
+  if (allOutputs.length === 0) {
+    log('No attesters with BLS keys found (skipping mnemonics and encrypted keystores without password)');
+    return;
+  }
+
+  const jsonOutput = prettyPrintJSON(allOutputs);
+
+  // Write to file if output is specified, otherwise log to stdout
+  if (output) {
+    writeFileSync(output, jsonOutput, 'utf-8');
+    log(`Wrote staking data to ${output}`);
+  } else {
+    log(jsonOutput);
+  }
+}

package/src/config/chain_l2_config.ts

@@ -1,8 +1,9 @@
-import { DefaultL1ContractsConfig, type L1ContractsConfig } from '@aztec/ethereum';
+import { DefaultL1ContractsConfig, type L1ContractsConfig, type L1TxUtilsConfig } from '@aztec/ethereum';
 import type { NetworkNames } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { SharedNodeConfig } from '@aztec/node-lib/config';
-import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { P2PConfig } from '@aztec/p2p';
+import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
 
 import path from 'path';
 
@@ -14,15 +15,15 @@ const SNAPSHOTS_URL = 'https://aztec-labs-snapshots.com';
 const defaultDBMapSizeKb = 128 * 1_024 * 1_024; // 128 GB
 const tbMapSizeKb = 1_024 * 1_024 * 1_024; // 1 TB
 
-export type L2ChainConfig = L1ContractsConfig &
-  Omit<SlasherConfig, 'slashValidatorsNever' | 'slashValidatorsAlways'> & {
+export type L2ChainConfig = Omit<L1ContractsConfig, keyof L1TxUtilsConfig> &
+  Omit<SlasherConfig, 'slashValidatorsNever' | 'slashValidatorsAlways' | 'slashOverridePayload' | 'slashSelfAllowed'> &
+  Pick<P2PConfig, 'bootstrapNodes' | 'p2pEnabled' | 'txPoolDeleteTxsAfterReorg'> &
+  Pick<SequencerConfig, 'minTxsPerBlock' | 'maxTxsPerBlock'> & {
     l1ChainId: number;
     testAccounts: boolean;
     sponsoredFPC: boolean;
-    p2pEnabled: boolean;
-    p2pBootstrapNodes: string[];
-    seqMinTxsPerBlock: number;
-    seqMaxTxsPerBlock: number;
+    minTxsPerBlock: number;
+    maxTxsPerBlock: number;
     realProofs: boolean;
     snapshotsUrls: string[];
     autoUpdate: SharedNodeConfig['autoUpdate'];
@@ -35,9 +36,9 @@ export type L2ChainConfig = L1ContractsConfig &
     skipArchiverInitialSync?: boolean;
     blobAllowEmptySources?: boolean;
 
-    // Setting the dbMapSize provides the default for every DB in the node.
+    // Setting the dataStoreMapSize provides the default for every DB in the node.
     // Then we explicitly override the sizes for the archiver and the larger trees.
-    dbMapSizeKb: number;
+    dataStoreMapSizeKb: number;
     archiverStoreMapSizeKb: number;
     noteHashTreeMapSizeKb: number;
     nullifierTreeMapSizeKb: number;
@@ -86,7 +87,7 @@ const DefaultSlashConfig = {
 } satisfies Partial<L2ChainConfig>;
 
 const DefaultNetworkDBMapSizeConfig = {
-  dbMapSizeKb: defaultDBMapSizeKb,
+  dataStoreMapSizeKb: defaultDBMapSizeKb,
   archiverStoreMapSizeKb: tbMapSizeKb,
   noteHashTreeMapSizeKb: tbMapSizeKb,
   nullifierTreeMapSizeKb: tbMapSizeKb,
@@ -99,9 +100,9 @@ export const stagingIgnitionL2ChainConfig: L2ChainConfig = {
   sponsoredFPC: false,
   disableTransactions: true,
   p2pEnabled: true,
-  p2pBootstrapNodes: [],
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 0,
+  bootstrapNodes: [],
+  minTxsPerBlock: 0,
+  maxTxsPerBlock: 0,
   realProofs: true,
   snapshotsUrls: [`${SNAPSHOTS_URL}/staging-ignition/`],
   autoUpdate: 'config-and-version',
@@ -111,6 +112,8 @@ export const stagingIgnitionL2ChainConfig: L2ChainConfig = {
   publicIncludeMetrics,
   publicMetricsCollectorUrl: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
   publicMetricsCollectFrom: ['sequencer'],
+  txPoolDeleteTxsAfterReorg: false,
+  blobAllowEmptySources: true,
 
   /** How many seconds an L1 slot lasts. */
   ethereumSlotDuration: 12,
@@ -180,9 +183,9 @@ export const stagingPublicL2ChainConfig: L2ChainConfig = {
   sponsoredFPC: true,
   disableTransactions: false,
   p2pEnabled: true,
-  p2pBootstrapNodes: [],
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 20,
+  bootstrapNodes: [],
+  minTxsPerBlock: 0,
+  maxTxsPerBlock: 20,
   realProofs: true,
   snapshotsUrls: [`${SNAPSHOTS_URL}/staging-public/`],
   autoUpdate: 'config-and-version',
@@ -192,6 +195,7 @@ export const stagingPublicL2ChainConfig: L2ChainConfig = {
   publicMetricsCollectorUrl: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
   publicMetricsCollectFrom: ['sequencer'],
   maxTxPoolSize: 100_000_000, // 100MB
+  txPoolDeleteTxsAfterReorg: true,
 
   // Deployment stuff
   /** How many seconds an L1 slot lasts. */
@@ -234,9 +238,9 @@ export const nextNetL2ChainConfig: L2ChainConfig = {
   sponsoredFPC: true,
   p2pEnabled: true,
   disableTransactions: false,
-  p2pBootstrapNodes: [],
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 8,
+  bootstrapNodes: [],
+  minTxsPerBlock: 0,
+  maxTxsPerBlock: 8,
   realProofs: true,
   snapshotsUrls: [],
   autoUpdate: 'config-and-version',
@@ -246,6 +250,7 @@ export const nextNetL2ChainConfig: L2ChainConfig = {
   publicMetricsCollectorUrl: '',
   publicMetricsCollectFrom: [''],
   maxTxPoolSize: 100_000_000, // 100MB
+  txPoolDeleteTxsAfterReorg: false,
 
   // Deployment stuff
   /** How many seconds an L1 slot lasts. */
@@ -288,9 +293,9 @@ export const testnetL2ChainConfig: L2ChainConfig = {
   sponsoredFPC: true,
   p2pEnabled: true,
   disableTransactions: true,
-  p2pBootstrapNodes: [],
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 0,
+  bootstrapNodes: [],
+  minTxsPerBlock: 0,
+  maxTxsPerBlock: 0,
   realProofs: true,
   snapshotsUrls: [`${SNAPSHOTS_URL}/testnet/`],
   autoUpdate: 'config-and-version',
@@ -300,6 +305,7 @@ export const testnetL2ChainConfig: L2ChainConfig = {
   publicIncludeMetrics,
   publicMetricsCollectorUrl: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
   publicMetricsCollectFrom: ['sequencer'],
+  txPoolDeleteTxsAfterReorg: true,
   skipArchiverInitialSync: true,
   blobAllowEmptySources: true,
 
@@ -371,14 +377,16 @@ export const testnetL2ChainConfig: L2ChainConfig = {
 };
 
 export const mainnetL2ChainConfig: L2ChainConfig = {
+  txPoolDeleteTxsAfterReorg: true,
+  disableTransactions: true,
+
   l1ChainId: 1,
   testAccounts: false,
   sponsoredFPC: false,
   p2pEnabled: true,
-  disableTransactions: true,
-  p2pBootstrapNodes: [],
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 0,
+  bootstrapNodes: [],
+  minTxsPerBlock: 0,
+  maxTxsPerBlock: 0,
   realProofs: true,
   snapshotsUrls: [`${SNAPSHOTS_URL}/mainnet/`],
   autoUpdate: 'notify',
@@ -462,9 +470,9 @@ export const devnetL2ChainConfig: L2ChainConfig = {
   sponsoredFPC: true,
   p2pEnabled: true,
   disableTransactions: false,
-  p2pBootstrapNodes: [],
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 8,
+  bootstrapNodes: [],
+  minTxsPerBlock: 0,
+  maxTxsPerBlock: 8,
   realProofs: false,
   snapshotsUrls: [],
   autoUpdate: 'config-and-version',
@@ -474,6 +482,7 @@ export const devnetL2ChainConfig: L2ChainConfig = {
   publicMetricsCollectorUrl: '',
   publicMetricsCollectFrom: [''],
   maxTxPoolSize: 100_000_000, // 100MB
+  txPoolDeleteTxsAfterReorg: true,
 
   // Deployment stuff
   /** How many seconds an L1 slot lasts. */
@@ -532,7 +541,7 @@ function getDefaultDataDir(networkName: NetworkNames): string {
   return path.join(process.env.HOME || '~', '.aztec', networkName, 'data');
 }
 
-export function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
+export function enrichEnvironmentWithChainName(networkName: NetworkNames) {
   if (networkName === 'local') {
     return;
   }
@@ -544,19 +553,24 @@ export function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
     throw new Error(`Unknown network name: ${networkName}`);
   }
 
-  enrichVar('BOOTSTRAP_NODES', config.p2pBootstrapNodes.join(','));
+  enrichEnvironmentWithChainConfig(config);
+}
+
+export function enrichEnvironmentWithChainConfig(config: L2ChainConfig) {
+  enrichVar('BOOTSTRAP_NODES', config.bootstrapNodes.join(','));
   enrichVar('TEST_ACCOUNTS', config.testAccounts.toString());
   enrichVar('SPONSORED_FPC', config.sponsoredFPC.toString());
   enrichVar('P2P_ENABLED', config.p2pEnabled.toString());
   enrichVar('L1_CHAIN_ID', config.l1ChainId.toString());
-  enrichVar('SEQ_MIN_TX_PER_BLOCK', config.seqMinTxsPerBlock.toString());
-  enrichVar('SEQ_MAX_TX_PER_BLOCK', config.seqMaxTxsPerBlock.toString());
+  enrichVar('SEQ_MIN_TX_PER_BLOCK', config.minTxsPerBlock.toString());
+  enrichVar('SEQ_MAX_TX_PER_BLOCK', config.maxTxsPerBlock.toString());
   enrichVar('PROVER_REAL_PROOFS', config.realProofs.toString());
   enrichVar('PXE_PROVER_ENABLED', config.realProofs.toString());
   enrichVar('SYNC_SNAPSHOTS_URLS', config.snapshotsUrls.join(','));
   enrichVar('P2P_MAX_TX_POOL_SIZE', config.maxTxPoolSize.toString());
+  enrichVar('P2P_TX_POOL_DELETE_TXS_AFTER_REORG', config.txPoolDeleteTxsAfterReorg.toString());
 
-  enrichVar('DATA_STORE_MAP_SIZE_KB', config.dbMapSizeKb.toString());
+  enrichVar('DATA_STORE_MAP_SIZE_KB', config.dataStoreMapSizeKb.toString());
   enrichVar('ARCHIVER_STORE_MAP_SIZE_KB', config.archiverStoreMapSizeKb.toString());
   enrichVar('NOTE_HASH_TREE_MAP_SIZE_KB', config.noteHashTreeMapSizeKb.toString());
   enrichVar('NULLIFIER_TREE_MAP_SIZE_KB', config.nullifierTreeMapSizeKb.toString());
@@ -597,6 +611,7 @@ export function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
   enrichVar('AZTEC_SLOT_DURATION', config.aztecSlotDuration.toString());
   enrichVar('AZTEC_EPOCH_DURATION', config.aztecEpochDuration.toString());
   enrichVar('AZTEC_TARGET_COMMITTEE_SIZE', config.aztecTargetCommitteeSize.toString());
+  enrichVar('AZTEC_LAG_IN_EPOCHS', config.lagInEpochs.toString());
   enrichVar('AZTEC_PROOF_SUBMISSION_EPOCHS', config.aztecProofSubmissionEpochs.toString());
   enrichVar('AZTEC_ACTIVATION_THRESHOLD', config.activationThreshold.toString());
   enrichVar('AZTEC_EJECTION_THRESHOLD', config.ejectionThreshold.toString());
@@ -614,6 +629,7 @@ export function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
   enrichVar('AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS', config.slashingExecutionDelayInRounds.toString());
   enrichVar('AZTEC_SLASHING_OFFSET_IN_ROUNDS', config.slashingOffsetInRounds.toString());
   enrichVar('AZTEC_SLASHER_FLAVOR', config.slasherFlavor);
+  enrichVar('AZTEC_SLASHING_DISABLE_DURATION', config.slashingDisableDuration.toString());
   enrichVar('AZTEC_EXIT_DELAY_SECONDS', config.exitDelaySeconds.toString());
   enrichEthAddressVar('AZTEC_SLASHING_VETOER', config.slashingVetoer.toString());
 
@@ -631,6 +647,8 @@ export function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
   enrichVar('SLASH_INVALID_BLOCK_PENALTY', config.slashBroadcastedInvalidBlockPenalty.toString());
   enrichVar('SLASH_OFFENSE_EXPIRATION_ROUNDS', config.slashOffenseExpirationRounds.toString());
   enrichVar('SLASH_MAX_PAYLOAD_SIZE', config.slashMaxPayloadSize.toString());
+  enrichVar('SLASH_GRACE_PERIOD_L2_SLOTS', config.slashGracePeriodL2Slots.toString());
+  enrichVar('SLASH_EXECUTE_ROUNDS_LOOK_BACK', config.slashExecuteRoundsLookBack.toString());
 
   enrichVar('SENTINEL_ENABLED', config.sentinelEnabled.toString());
   enrichVar('TRANSACTIONS_DISABLED', config.disableTransactions.toString());