@aztec/cli 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/cmds/validator_keys/shared.js

@@ -0,0 +1,271 @@
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { computeBn254G1PublicKeyCompressed, deriveBlsPrivateKey } from '@aztec/foundation/crypto';
+import { createBn254Keystore } from '@aztec/foundation/crypto/bls/bn254_keystore';
+import { Wallet } from '@ethersproject/wallet';
+import { constants as fsConstants, mkdirSync } from 'fs';
+import { access, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { dirname, isAbsolute, join } from 'path';
+import { mnemonicToAccount } from 'viem/accounts';
+export function withValidatorIndex(path, index) {
+    const parts = path.split('/');
+    if (parts.length >= 4 && parts[0] === 'm' && parts[1] === '12381' && parts[2] === '3600') {
+        parts[3] = String(index);
+        return parts.join('/');
+    }
+    return path;
+}
+/**
+ * Compute a compressed BN254 G1 public key from a private key.
+ * @param privateKeyHex - Private key as 0x-prefixed hex string
+ * @returns Compressed G1 point (32 bytes with sign bit in MSB)
+ */ export async function computeBlsPublicKeyCompressed(privateKeyHex) {
+    return await computeBn254G1PublicKeyCompressed(privateKeyHex);
+}
+export function deriveEthAttester(mnemonic, baseAccountIndex, addressIndex, remoteSigner) {
+    const acct = mnemonicToAccount(mnemonic, {
+        accountIndex: baseAccountIndex,
+        addressIndex
+    });
+    return remoteSigner ? {
+        address: acct.address,
+        remoteSignerUrl: remoteSigner
+    } : '0x' + Buffer.from(acct.getHdKey().privateKey).toString('hex');
+}
+export async function buildValidatorEntries(input) {
+    const { validatorCount, publisherCount = 0, accountIndex, baseAddressIndex, mnemonic, ikm, blsPath, blsOnly, feeRecipient, coinbase, remoteSigner, fundingAccount } = input;
+    const defaultBlsPath = 'm/12381/3600/0/0/0';
+    const summaries = [];
+    const validators = await Promise.all(Array.from({
+        length: validatorCount
+    }, async (_unused, i)=>{
+        const addressIndex = baseAddressIndex + i;
+        const basePath = blsPath ?? defaultBlsPath;
+        const perValidatorPath = withValidatorIndex(basePath, addressIndex);
+        const blsPrivKey = blsOnly || ikm || mnemonic ? deriveBlsPrivateKey(mnemonic, ikm, perValidatorPath) : undefined;
+        const blsPubCompressed = blsPrivKey ? await computeBlsPublicKeyCompressed(blsPrivKey) : undefined;
+        if (blsOnly) {
+            const attester = {
+                bls: blsPrivKey
+            };
+            summaries.push({
+                attesterBls: blsPubCompressed
+            });
+            return {
+                attester,
+                feeRecipient
+            };
+        }
+        const ethAttester = deriveEthAttester(mnemonic, accountIndex, addressIndex, remoteSigner);
+        const attester = blsPrivKey ? {
+            eth: ethAttester,
+            bls: blsPrivKey
+        } : ethAttester;
+        let publisherField;
+        const publisherAddresses = [];
+        if (publisherCount > 0) {
+            const publishersBaseIndex = baseAddressIndex + validatorCount + i * publisherCount;
+            const publisherAccounts = Array.from({
+                length: publisherCount
+            }, (_unused2, j)=>{
+                const publisherAddressIndex = publishersBaseIndex + j;
+                const pubAcct = mnemonicToAccount(mnemonic, {
+                    accountIndex,
+                    addressIndex: publisherAddressIndex
+                });
+                publisherAddresses.push(pubAcct.address);
+                return remoteSigner ? {
+                    address: pubAcct.address,
+                    remoteSignerUrl: remoteSigner
+                } : '0x' + Buffer.from(pubAcct.getHdKey().privateKey).toString('hex');
+            });
+            publisherField = publisherCount === 1 ? publisherAccounts[0] : publisherAccounts;
+        }
+        const acct = mnemonicToAccount(mnemonic, {
+            accountIndex,
+            addressIndex
+        });
+        const attesterEthAddress = acct.address;
+        summaries.push({
+            attesterEth: attesterEthAddress,
+            attesterBls: blsPubCompressed,
+            publisherEth: publisherAddresses.length > 0 ? publisherAddresses : undefined
+        });
+        return {
+            attester,
+            ...publisherField !== undefined ? {
+                publisher: publisherField
+            } : {},
+            feeRecipient,
+            coinbase,
+            fundingAccount
+        };
+    }));
+    return {
+        validators,
+        summaries
+    };
+}
+export async function resolveKeystoreOutputPath(dataDir, file) {
+    const defaultDataDir = join(homedir(), '.aztec', 'keystore');
+    const resolvedDir = dataDir && dataDir.length > 0 ? dataDir : defaultDataDir;
+    let outputPath;
+    if (file && file.length > 0) {
+        outputPath = isAbsolute(file) ? file : join(resolvedDir, file);
+    } else {
+        let index = 1;
+        while(true){
+            const candidate = join(resolvedDir, `key${index}.json`);
+            try {
+                await access(candidate, fsConstants.F_OK);
+                index += 1;
+            } catch  {
+                outputPath = candidate;
+                break;
+            }
+        }
+    }
+    return {
+        resolvedDir,
+        outputPath: outputPath
+    };
+}
+export async function writeKeystoreFile(path, keystore) {
+    mkdirSync(dirname(path), {
+        recursive: true
+    });
+    await writeFile(path, JSON.stringify(keystore, null, 2), {
+        encoding: 'utf-8'
+    });
+}
+export function logValidatorSummaries(log, summaries) {
+    const lines = [];
+    for(let i = 0; i < summaries.length; i++){
+        const v = summaries[i];
+        lines.push(`acc${i + 1}:`);
+        lines.push(`  attester:`);
+        if (v.attesterEth) {
+            lines.push(`    eth: ${v.attesterEth}`);
+        }
+        if (v.attesterBls) {
+            lines.push(`    bls: ${v.attesterBls}`);
+        }
+        if (v.publisherEth && v.publisherEth.length > 0) {
+            lines.push(`  publisher:`);
+            for (const addr of v.publisherEth){
+                lines.push(`    - ${addr}`);
+            }
+        }
+    }
+    if (lines.length > 0) {
+        log(lines.join('\n'));
+    }
+}
+export function maybePrintJson(log, jsonFlag, obj) {
+    if (jsonFlag) {
+        log(prettyPrintJSON(obj));
+    }
+}
+/**
+ * Writes a BN254 keystore file for a BN254 BLS private key.
+ * Returns the absolute path to the written file.
+ *
+ * @param outDir - Directory to write the keystore file to
+ * @param fileNameBase - Base name for the keystore file (will be sanitized)
+ * @param password - Password for encrypting the private key
+ * @param privateKeyHex - Private key as 0x-prefixed hex string (32 bytes)
+ * @param pubkeyHex - Public key as hex string
+ * @param derivationPath - BIP-44 style derivation path
+ * @returns Absolute path to the written keystore file
+ */ export async function writeBn254BlsKeystore(outDir, fileNameBase, password, privateKeyHex, pubkeyHex, derivationPath) {
+    mkdirSync(outDir, {
+        recursive: true
+    });
+    const keystore = createBn254Keystore(password, privateKeyHex, pubkeyHex, derivationPath);
+    const safeBase = fileNameBase.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const outPath = join(outDir, `keystore-${safeBase}.json`);
+    await writeFile(outPath, JSON.stringify(keystore, null, 2), {
+        encoding: 'utf-8'
+    });
+    return outPath;
+}
+/** Replace plaintext BLS keys in validators with { path, password } pointing to BN254 keystore files. */ export async function writeBlsBn254ToFile(validators, options) {
+    for(let i = 0; i < validators.length; i++){
+        const v = validators[i];
+        if (!v || typeof v !== 'object' || !('attester' in v)) {
+            continue;
+        }
+        const att = v.attester;
+        // Shapes: { bls: <hex> } or { eth: <ethAccount>, bls?: <hex> } or plain EthAccount
+        const blsKey = typeof att === 'object' && 'bls' in att ? att.bls : undefined;
+        if (!blsKey || typeof blsKey !== 'string') {
+            continue;
+        }
+        const pub = await computeBlsPublicKeyCompressed(blsKey);
+        const path = 'm/12381/3600/0/0/0';
+        const fileBase = `${String(i + 1)}_${pub.slice(2, 18)}`;
+        const keystorePath = await writeBn254BlsKeystore(options.outDir, fileBase, options.password, blsKey, pub, path);
+        if (typeof att === 'object') {
+            att.bls = {
+                path: keystorePath,
+                password: options.password
+            };
+        }
+    }
+}
+/** Writes an Ethereum JSON V3 keystore using ethers, returns absolute path */ export async function writeEthJsonV3Keystore(outDir, fileNameBase, password, privateKeyHex) {
+    const safeBase = fileNameBase.replace(/[^a-zA-Z0-9_-]/g, '_');
+    mkdirSync(outDir, {
+        recursive: true
+    });
+    const wallet = new Wallet(privateKeyHex);
+    const json = await wallet.encrypt(password);
+    const outPath = join(outDir, `keystore-eth-${safeBase}.json`);
+    await writeFile(outPath, json, {
+        encoding: 'utf-8'
+    });
+    return outPath;
+}
+/** Replace plaintext ETH keys in validators with { path, password } pointing to JSON V3 files. */ export async function writeEthJsonV3ToFile(validators, options) {
+    const maybeEncryptEth = async (account, label)=>{
+        if (typeof account === 'string' && account.startsWith('0x') && account.length === 66) {
+            const fileBase = `${label}_${account.slice(2, 10)}`;
+            const p = await writeEthJsonV3Keystore(options.outDir, fileBase, options.password, account);
+            return {
+                path: p,
+                password: options.password
+            };
+        }
+        return account;
+    };
+    for(let i = 0; i < validators.length; i++){
+        const v = validators[i];
+        if (!v || typeof v !== 'object') {
+            continue;
+        }
+        // attester may be string (eth), object with eth, or remote signer
+        const att = v.attester;
+        if (typeof att === 'string') {
+            v.attester = await maybeEncryptEth(att, `attester_${i + 1}`);
+        } else if (att && typeof att === 'object' && 'eth' in att) {
+            att.eth = await maybeEncryptEth(att.eth, `attester_${i + 1}`);
+        }
+        // publisher can be single or array
+        if ('publisher' in v) {
+            const pub = v.publisher;
+            if (Array.isArray(pub)) {
+                const out = [];
+                for(let j = 0; j < pub.length; j++){
+                    out.push(await maybeEncryptEth(pub[j], `publisher_${i + 1}_${j + 1}`));
+                }
+                v.publisher = out;
+            } else if (pub !== undefined) {
+                v.publisher = await maybeEncryptEth(pub, `publisher_${i + 1}`);
+            }
+        }
+        // Optional fundingAccount within validator
+        if ('fundingAccount' in v) {
+            v.fundingAccount = await maybeEncryptEth(v.fundingAccount, `funding_${i + 1}`);
+        }
+    }
+}

package/dest/config/cached_fetch.d.ts

@@ -0,0 +1,18 @@
+export interface CachedFetchOptions {
+    /** Cache duration in milliseconds */
+    cacheDurationMs: number;
+    /** The cache file */
+    cacheFile?: string;
+}
+/**
+ * Fetches data from a URL with file-based caching support.
+ * This utility can be used by both remote config and bootnodes fetching.
+ *
+ * @param url - The URL to fetch from
+ * @param networkName - Network name for cache directory structure
+ * @param options - Caching and error handling options
+ * @param cacheDir - Optional cache directory (defaults to no caching)
+ * @returns The fetched and parsed JSON data, or undefined if fetch fails and throwOnError is false
+ */
+export declare function cachedFetch<T = any>(url: string, options: CachedFetchOptions, fetch?: typeof globalThis.fetch, log?: import("@aztec/aztec.js/log").Logger): Promise<T | undefined>;
+//# sourceMappingURL=cached_fetch.d.ts.map

package/dest/config/cached_fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cached_fetch.d.ts","sourceRoot":"","sources":["../../src/config/cached_fetch.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,EAC3B,KAAK,0BAAmB,EACxB,GAAG,uCAA+B,GACjC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAuCxB"}

package/dest/config/cached_fetch.js

@@ -0,0 +1,54 @@
+import { createLogger } from '@aztec/aztec.js/log';
+import { mkdir, readFile, stat, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+/**
+ * Fetches data from a URL with file-based caching support.
+ * This utility can be used by both remote config and bootnodes fetching.
+ *
+ * @param url - The URL to fetch from
+ * @param networkName - Network name for cache directory structure
+ * @param options - Caching and error handling options
+ * @param cacheDir - Optional cache directory (defaults to no caching)
+ * @returns The fetched and parsed JSON data, or undefined if fetch fails and throwOnError is false
+ */ export async function cachedFetch(url, options, fetch = globalThis.fetch, log = createLogger('cached_fetch')) {
+    const { cacheDurationMs, cacheFile } = options;
+    // Try to read from cache first
+    try {
+        if (cacheFile) {
+            const info = await stat(cacheFile);
+            if (info.mtimeMs + cacheDurationMs > Date.now()) {
+                const cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
+                return cachedData;
+            }
+        }
+    } catch  {
+        log.trace('Failed to read data from cache');
+    }
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
+            return undefined;
+        }
+        const data = await response.json();
+        try {
+            if (cacheFile) {
+                await mkdir(dirname(cacheFile), {
+                    recursive: true
+                });
+                await writeFile(cacheFile, JSON.stringify(data), 'utf-8');
+            }
+        } catch (err) {
+            log.warn('Failed to cache data on disk: ' + cacheFile, {
+                cacheFile,
+                err
+            });
+        }
+        return data;
+    } catch (err) {
+        log.warn(`Failed to fetch from ${url}`, {
+            err
+        });
+        return undefined;
+    }
+}

package/dest/config/chain_l2_config.d.ts

@@ -0,0 +1,39 @@
+import { type L1ContractsConfig } from '@aztec/ethereum';
+import type { NetworkNames } from '@aztec/foundation/config';
+import type { SharedNodeConfig } from '@aztec/node-lib/config';
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+export type L2ChainConfig = L1ContractsConfig & Omit<SlasherConfig, 'slashValidatorsNever' | 'slashValidatorsAlways'> & {
+    l1ChainId: number;
+    testAccounts: boolean;
+    sponsoredFPC: boolean;
+    p2pEnabled: boolean;
+    p2pBootstrapNodes: string[];
+    seqMinTxsPerBlock: number;
+    seqMaxTxsPerBlock: number;
+    realProofs: boolean;
+    snapshotsUrls: string[];
+    autoUpdate: SharedNodeConfig['autoUpdate'];
+    autoUpdateUrl?: string;
+    maxTxPoolSize: number;
+    publicIncludeMetrics?: string[];
+    publicMetricsCollectorUrl?: string;
+    publicMetricsCollectFrom?: string[];
+    skipArchiverInitialSync?: boolean;
+    blobAllowEmptySources?: boolean;
+    dbMapSizeKb: number;
+    archiverStoreMapSizeKb: number;
+    noteHashTreeMapSizeKb: number;
+    nullifierTreeMapSizeKb: number;
+    publicDataTreeMapSizeKb: number;
+    sentinelEnabled: boolean;
+    disableTransactions: boolean;
+};
+export declare const stagingIgnitionL2ChainConfig: L2ChainConfig;
+export declare const stagingPublicL2ChainConfig: L2ChainConfig;
+export declare const nextNetL2ChainConfig: L2ChainConfig;
+export declare const testnetL2ChainConfig: L2ChainConfig;
+export declare const mainnetL2ChainConfig: L2ChainConfig;
+export declare const devnetL2ChainConfig: L2ChainConfig;
+export declare function getL2ChainConfig(networkName: NetworkNames): L2ChainConfig | undefined;
+export declare function enrichEnvironmentWithChainConfig(networkName: NetworkNames): void;
+//# sourceMappingURL=chain_l2_config.d.ts.map

package/dest/config/chain_l2_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/config/chain_l2_config.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAYrE,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAC3C,IAAI,CAAC,aAAa,EAAE,sBAAsB,GAAG,uBAAuB,CAAC,GAAG;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;IACpC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAIhC,WAAW,EAAE,MAAM,CAAC;IACpB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,uBAAuB,EAAE,MAAM,CAAC;IAGhC,eAAe,EAAE,OAAO,CAAC;IACzB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AA+CJ,eAAO,MAAM,4BAA4B,EAAE,aA8E1C,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,aAmDxC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,aAmDlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,aAqFlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,aAkFlC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,aAmDjC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,GAAG,SAAS,CAgBrF;AAMD,wBAAgB,gCAAgC,CAAC,WAAW,EAAE,YAAY,QAoGzE"}