@aztec/cli 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/cmds/validator_keys/shared.js

@@ -0,0 +1,274 @@
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { deriveBlsPrivateKey } from '@aztec/foundation/crypto/bls';
+import { createBn254Keystore } from '@aztec/foundation/crypto/bls/bn254_keystore';
+import { computeBn254G1PublicKeyCompressed } from '@aztec/foundation/crypto/bn254';
+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';
+import { defaultBlsPath } from './utils.js';
+export function withValidatorIndex(path, accountIndex = 0, addressIndex = 0) {
+    // NOTE: The legacy BLS CLI is to allow users who generated keys in 2.1.4 to be able to use the same command
+    // to re-generate their keys. In 2.1.5 we switched how we append addresses to the path so this is to maintain backwards compatibility.
+    const useLegacyBlsCli = [
+        'true',
+        '1',
+        'yes',
+        'y'
+    ].includes(process.env.LEGACY_BLS_CLI ?? '');
+    const defaultBlsPathParts = defaultBlsPath.split('/');
+    const parts = path.split('/');
+    if (parts.length == defaultBlsPathParts.length && parts.every((part, index)=>part === defaultBlsPathParts[index])) {
+        if (useLegacyBlsCli) {
+            // In 2.1.4, we were using address-index in parts[3] and did NOT use account-index, check lines 32 & 84
+            // https://github.com/AztecProtocol/aztec-packages/blob/v2.1.4/yarn-project/cli/src/cmds/validator_keys/shared.ts
+            parts[3] = String(addressIndex);
+        } else {
+            parts[3] = String(accountIndex);
+            parts[5] = String(addressIndex);
+        }
+        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, publishers, accountIndex, baseAddressIndex, mnemonic, ikm, blsPath, feeRecipient, coinbase, remoteSigner } = input;
+    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, accountIndex, addressIndex);
+        const blsPrivKey = ikm || mnemonic ? deriveBlsPrivateKey(mnemonic, ikm, perValidatorPath) : undefined;
+        const blsPubCompressed = blsPrivKey ? await computeBlsPublicKeyCompressed(blsPrivKey) : undefined;
+        const ethAttester = deriveEthAttester(mnemonic, accountIndex, addressIndex, remoteSigner);
+        const attester = blsPrivKey ? {
+            eth: ethAttester,
+            bls: blsPrivKey
+        } : ethAttester;
+        let publisherField;
+        const publisherAddresses = [];
+        if (publishers && publishers.length > 0) {
+            publisherAddresses.push(...publishers);
+            publisherField = publishers.length === 1 ? publishers[0] : publishers;
+        } else 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: coinbase ?? attesterEthAddress
+        };
+    }));
+    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 = options.blsPath ?? defaultBlsPath;
+        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}`);
+            }
+        }
+    }
+}

package/dest/cmds/validator_keys/staker.d.ts

@@ -0,0 +1,38 @@
+import { GSEContract } from '@aztec/ethereum/contracts';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+import type { AttesterAccounts } from '@aztec/node-keystore/types';
+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;
+    };
+};
+/**
+ * Process AttesterAccounts (which can be a single attester, array, or mnemonic)
+ */
+export declare function processAttesterAccounts(attesterAccounts: AttesterAccounts, gse: GSEContract, password?: string): Promise<StakerOutput[]>;
+/**
+ * Main staker command function
+ */
+export declare function generateStakerJson(options: StakerOptions, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Rha2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy92YWxpZGF0b3Jfa2V5cy9zdGFrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBSXhELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sS0FBSyxFQUVWLGdCQUFnQixFQUtqQixNQUFNLDRCQUE0QixDQUFDO0FBUXBDLE1BQU0sTUFBTSxhQUFhLEdBQUc7SUFDMUIsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLFFBQVEsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNsQixNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDaEIsVUFBVSxFQUFFLFVBQVUsQ0FBQztJQUN2QixTQUFTLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDcEIsU0FBUyxFQUFFLE1BQU0sQ0FBQztDQUNuQixDQUFDO0FBRUYsTUFBTSxNQUFNLFlBQVksR0FBRztJQUN6QixRQUFRLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLFdBQVcsRUFBRTtRQUNYLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDVixDQUFDLEVBQUUsTUFBTSxDQUFDO0tBQ1gsQ0FBQztJQUNGLFdBQVcsRUFBRTtRQUNYLEVBQUUsRUFBRSxNQUFNLENBQUM7UUFDWCxFQUFFLEVBQUUsTUFBTSxDQUFDO1FBQ1gsRUFBRSxFQUFFLE1BQU0sQ0FBQztRQUNYLEVBQUUsRUFBRSxNQUFNLENBQUM7S0FDWixDQUFDO0lBQ0YsaUJBQWlCLEVBQUU7UUFDakIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztRQUNWLENBQUMsRUFBRSxNQUFNLENBQUM7S0FDWCxDQUFDO0NBQ0gsQ0FBQztBQTJLRjs7R0FFRztBQUNILHdCQUFzQix1QkFBdUIsQ0FDM0MsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQ2xDLEdBQUcsRUFBRSxXQUFXLEVBQ2hCLFFBQVEsQ0FBQyxFQUFFLE1BQU0sR0FDaEIsT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBcUJ6QjtBQUVEOztHQUVHO0FBQ0gsd0JBQXNCLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxhQUFhLEVBQUUsR0FBRyxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBK0MxRiJ9

package/dest/cmds/validator_keys/staker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staker.d.ts","sourceRoot":"","sources":["../../../src/cmds/validator_keys/staker.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAIxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,KAAK,EAEV,gBAAgB,EAKjB,MAAM,4BAA4B,CAAC;AAQpC,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE;QACX,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;KACX,CAAC;IACF,WAAW,EAAE;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;KACZ,CAAC;IACF,iBAAiB,EAAE;QACjB,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;KACX,CAAC;CACH,CAAC;AA2KF;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,EAAE,WAAW,EAChB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAqBzB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CA+C1F"}

package/dest/cmds/validator_keys/staker.js

@@ -0,0 +1,210 @@
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { GSEContract } from '@aztec/ethereum/contracts';
+import { decryptBn254Keystore } from '@aztec/foundation/crypto/bls/bn254_keystore';
+import { computeBn254G1PublicKey, computeBn254G2PublicKey } from '@aztec/foundation/crypto/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { loadKeystoreFile } from '@aztec/node-keystore/loader';
+import { Wallet } from '@ethersproject/wallet';
+import { readFileSync, writeFileSync } from 'fs';
+import { basename, dirname, join } from 'path';
+import { createPublicClient, fallback, http } from 'viem';
+import { privateKeyToAddress } from 'viem/accounts';
+/**
+ * Check if an object is a MnemonicConfig
+ */ function isMnemonicConfig(obj) {
+    return typeof obj === 'object' && obj !== null && 'mnemonic' in obj;
+}
+/**
+ * Check if a value is an encrypted keystore file config
+ */ function isEncryptedKeyFileConfig(value) {
+    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) {
+    return typeof bls === 'string' && bls.startsWith('0x');
+}
+/**
+ * Check if an EthAccount is a private key string (66 chars: 0x + 64 hex)
+ */ function isEthPrivateKey(eth) {
+    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) {
+    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, password) {
+    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, password) {
+    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;
+    }
+    return undefined;
+}
+/**
+ * Extract Ethereum address from an EthAccount (or private key)
+ */ async function getEthAddress(eth, password) {
+    // Case 1: It's a private key string - derive the address
+    if (isEthPrivateKey(eth)) {
+        return privateKeyToAddress(eth);
+    }
+    // Case 2: It's just an address string directly (EthRemoteSignerAccount can be just EthAddress)
+    if (isEthAddress(eth)) {
+        return eth;
+    }
+    // Case 3: It's an object with an address property (remote signer config)
+    if (typeof eth === 'object' && eth !== null && 'address' in eth) {
+        return eth.address;
+    }
+    // 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);
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Extract BLS private key and Ethereum address from an AttesterAccount
+ */ async function extractAttesterInfo(attester, password) {
+    // 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, password)
+    };
+}
+/**
+ * Process a single attester entry and output staking JSON
+ */ async function processAttester(attester, gse, password) {
+    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, gse, password) {
+    // Skip mnemonic configs
+    if (isMnemonicConfig(attesterAccounts)) {
+        return [];
+    }
+    // Handle array of attesters
+    if (Array.isArray(attesterAccounts)) {
+        const results = [];
+        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, log) {
+    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 = [];
+    // L1 client for proof of possession
+    const chain = createEthereumChain(l1RpcUrls, l1ChainId);
+    const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map((url)=>http(url, {
+                batch: false
+            })))
+    });
+    const gse = new GSEContract(publicClient, gseAddress);
+    const keystoreBaseName = basename(from, '.json');
+    const outputDir = output ? output : dirname(from);
+    for(let i = 0; i < keystore.validators.length; i++){
+        const validator = keystore.validators[i];
+        const outputs = await processAttesterAccounts(validator.attester, gse, password);
+        for(let j = 0; j < outputs.length; j++){
+            allOutputs.push(outputs[j]);
+        }
+    }
+    if (allOutputs.length === 0) {
+        log('No attesters with BLS keys found (skipping mnemonics and encrypted keystores without password)');
+        return;
+    }
+    // Write a single JSON file with all staker outputs
+    const stakerOutputPath = join(outputDir, `${keystoreBaseName}_staker_output.json`);
+    writeFileSync(stakerOutputPath, prettyPrintJSON(allOutputs), 'utf-8');
+    log(`Wrote staker output for ${allOutputs.length} validator(s) to ${stakerOutputPath}`);
+}

package/dest/cmds/validator_keys/utils.d.ts

@@ -0,0 +1,25 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+export declare const defaultBlsPath = "m/12381/3600/0/0/0";
+export declare function validateBlsPathOptions(options: {
+    count?: number;
+    publisherCount?: number;
+    accountIndex?: number;
+    addressIndex?: number;
+    blsPath?: string;
+    ikm?: string;
+}): void;
+export declare function validateStakerOutputOptions(options: {
+    stakerOutput?: boolean;
+    gseAddress?: EthAddress;
+    l1RpcUrls?: string[];
+    l1ChainId?: number;
+}): void;
+export declare function validateRemoteSignerOptions(options: {
+    remoteSigner?: string;
+    mnemonic?: string;
+}): void;
+export declare function validatePublisherOptions(options: {
+    publishers?: string[];
+    publisherCount?: number;
+}): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL3ZhbGlkYXRvcl9rZXlzL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBSWhFLGVBQU8sTUFBTSxjQUFjLHVCQUF1QixDQUFDO0FBRW5ELHdCQUFnQixzQkFBc0IsQ0FBQyxPQUFPLEVBQUU7SUFDOUMsS0FBSyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2YsY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3hCLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN0QixZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLEdBQUcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNkLFFBV0E7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsT0FBTyxFQUFFO0lBQ25ELFlBQVksQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUN2QixVQUFVLENBQUMsRUFBRSxVQUFVLENBQUM7SUFDeEIsU0FBUyxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDckIsU0FBUyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ3BCLFFBZUE7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsT0FBTyxFQUFFO0lBQUUsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQUMsUUFBUSxDQUFDLEVBQUUsTUFBTSxDQUFBO0NBQUUsUUFNaEc7QUFFRCx3QkFBZ0Isd0JBQXdCLENBQUMsT0FBTyxFQUFFO0lBQUUsVUFBVSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFBQyxjQUFjLENBQUMsRUFBRSxNQUFNLENBQUE7Q0FBRSxRQXdCbkcifQ==

package/dest/cmds/validator_keys/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/cmds/validator_keys/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAIhE,eAAO,MAAM,cAAc,uBAAuB,CAAC;AAEnD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,QAWA;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,QAeA;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,QAMhG;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,QAwBnG"}

package/dest/cmds/validator_keys/utils.js

@@ -0,0 +1,52 @@
+import { ethPrivateKeySchema } from '@aztec/node-keystore/schemas';
+export const defaultBlsPath = 'm/12381/3600/0/0/0';
+export function validateBlsPathOptions(options) {
+    if (options.blsPath && options.blsPath !== defaultBlsPath) {
+        if (options.count && options.count !== 1 || options.publisherCount && options.publisherCount > 0 || options.accountIndex && options.accountIndex !== 0 || options.addressIndex && options.addressIndex !== 0) {
+            throw new Error('--bls-path cannot be used with --count, --publisher-count, --account-index, or --address-index');
+        }
+    }
+}
+export function validateStakerOutputOptions(options) {
+    if (!options.stakerOutput) {
+        return;
+    }
+    // Required options for staker output
+    if (!options.gseAddress) {
+        throw new Error('--gse-address is required when using --staker-output');
+    }
+    if (!options.l1RpcUrls || options.l1RpcUrls.length === 0) {
+        throw new Error('--l1-rpc-urls is required when using --staker-output');
+    }
+    if (options.l1ChainId === undefined) {
+        throw new Error('--l1-chain-id is required when using --staker-output');
+    }
+}
+export function validateRemoteSignerOptions(options) {
+    if (options.remoteSigner && !options.mnemonic) {
+        throw new Error('Using --remote-signer requires a deterministic key source. Provide --mnemonic to derive keys, or omit --remote-signer to write new private keys to keystore.');
+    }
+}
+export function validatePublisherOptions(options) {
+    if (options.publisherCount && options.publisherCount > 0 && options.publishers && options.publishers.length > 0) {
+        throw new Error('--publishers and --publisher-count cannot be used together');
+    }
+    if (options.publishers && options.publishers.length > 0) {
+        // Normalize each private key by adding 0x prefix if missing
+        const normalizedKeys = [];
+        for (const key of options.publishers){
+            let privateKey = key.trim();
+            if (!privateKey.startsWith('0x')) {
+                privateKey = '0x' + privateKey;
+            }
+            try {
+                ethPrivateKeySchema.parse(privateKey);
+                normalizedKeys.push(privateKey);
+            } catch (error) {
+                throw new Error(`Invalid publisher private key: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Update the options with the normalized keys
+        options.publishers = normalizedKeys;
+    }
+}

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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkX2ZldGNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NhY2hlZF9mZXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLHFDQUFxQztJQUNyQyxlQUFlLEVBQUUsTUFBTSxDQUFDO0lBQ3hCLHFCQUFxQjtJQUNyQixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDcEI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsV0FBVyxDQUFDLENBQUMsR0FBRyxHQUFHLEVBQ3ZDLEdBQUcsRUFBRSxNQUFNLEVBQ1gsT0FBTyxFQUFFLGtCQUFrQixFQUMzQixLQUFLLDBCQUFtQixFQUN4QixHQUFHLHVDQUErQixHQUNqQyxPQUFPLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQXVDeEIifQ==

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"}