@aztec/node-keystore 2.0.0-nightly.20250816

package/dest/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWvB,CAAC;AAEL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dest/schemas.js

@@ -0,0 +1,83 @@
+/**
+ * Zod schemas for keystore validation using Aztec's validation functions
+ */ import { EthAddress } from '@aztec/foundation/eth-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { z } from 'zod';
+// Use Aztec's validation functions but return string types to match our TypeScript interfaces
+const ethAddressSchema = z.string().refine(EthAddress.isAddress, 'Invalid Ethereum address');
+const ethPrivateKeySchema = z.string().regex(/^0x[0-9a-fA-F]{64}$/, 'Invalid private key (must be 32 bytes with 0x prefix)');
+const aztecAddressSchema = z.string().refine(AztecAddress.isAddress, 'Invalid Aztec address');
+const urlSchema = z.string().url('Invalid URL');
+// Remote signer config schema
+const remoteSignerConfigSchema = z.union([
+    urlSchema,
+    z.object({
+        remoteSignerUrl: urlSchema,
+        certPath: z.string().optional(),
+        certPass: z.string().optional()
+    })
+]);
+// Remote signer account schema
+const remoteSignerAccountSchema = z.union([
+    ethAddressSchema,
+    z.object({
+        address: ethAddressSchema,
+        remoteSignerUrl: urlSchema.optional(),
+        certPath: z.string().optional(),
+        certPass: z.string().optional()
+    })
+]);
+// JSON V3 keystore schema
+const jsonKeyFileV3Schema = z.object({
+    path: z.string(),
+    password: z.string().optional()
+});
+// Mnemonic config schema
+const mnemonicConfigSchema = z.object({
+    mnemonic: z.string().min(1, 'Mnemonic cannot be empty'),
+    addressIndex: z.number().int().min(0).optional(),
+    accountIndex: z.number().int().min(0).optional(),
+    addressCount: z.number().int().min(1).optional(),
+    accountCount: z.number().int().min(1).optional()
+});
+// EthAccount schema
+const ethAccountSchema = z.union([
+    ethPrivateKeySchema,
+    remoteSignerAccountSchema,
+    jsonKeyFileV3Schema
+]);
+// EthAccounts schema
+const ethAccountsSchema = z.union([
+    ethAccountSchema,
+    z.array(ethAccountSchema),
+    mnemonicConfigSchema
+]);
+// Prover keystore schema
+const proverKeyStoreSchema = z.union([
+    ethAccountSchema,
+    z.object({
+        id: ethAddressSchema,
+        publisher: z.array(ethAccountsSchema)
+    })
+]);
+// Validator keystore schema
+const validatorKeyStoreSchema = z.object({
+    attester: ethAccountsSchema,
+    coinbase: ethAddressSchema.optional(),
+    publisher: ethAccountsSchema.optional(),
+    feeRecipient: aztecAddressSchema,
+    remoteSigner: remoteSignerConfigSchema.optional()
+});
+// Main keystore schema
+export const keystoreSchema = z.object({
+    schemaVersion: z.literal(1),
+    validators: z.array(validatorKeyStoreSchema).optional(),
+    slasher: ethAccountsSchema.optional(),
+    remoteSigner: remoteSignerConfigSchema.optional(),
+    prover: proverKeyStoreSchema.optional()
+}).refine((data)=>data.validators || data.prover, {
+    message: 'Keystore must have at least validators or prover configuration',
+    path: [
+        'root'
+    ]
+});

package/dest/signer.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Signer Interface and Implementations
+ *
+ * Common interface for different signing backends (local, remote, encrypted)
+ */
+import { Buffer32 } from '@aztec/foundation/buffer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import type { TypedDataDefinition } from 'viem';
+import type { EthRemoteSignerConfig } from './types.js';
+/**
+ * Error thrown for remote signer HTTP or JSON-RPC failures
+ */
+export declare class SignerError extends Error {
+    method: 'eth_sign' | 'eth_signTypedData_v4';
+    url: string;
+    statusCode?: number | undefined;
+    errorCode?: number | undefined;
+    constructor(message: string, method: 'eth_sign' | 'eth_signTypedData_v4', url: string, statusCode?: number | undefined, errorCode?: number | undefined);
+}
+/**
+ * Common interface for all signer implementations
+ */
+/**
+ * Abstraction for signing operations used by the node keystore.
+ */
+export interface Signer {
+    /** The Ethereum address for this signer */
+    readonly address: EthAddress;
+    /** Sign a message using eth_sign (with Ethereum message prefix) */
+    signMessage(message: Buffer32): Promise<Signature>;
+    /** Sign typed data using EIP-712 */
+    signTypedData(typedData: TypedDataDefinition): Promise<Signature>;
+}
+/**
+ * Local signer using in-memory private key
+ */
+/**
+ * Local signer that holds an in-memory Secp256k1 private key.
+ */
+export declare class LocalSigner implements Signer {
+    private readonly signer;
+    constructor(privateKey: Buffer32);
+    get address(): EthAddress;
+    signMessage(message: Buffer32): Promise<Signature>;
+    signTypedData(typedData: TypedDataDefinition): Promise<Signature>;
+}
+/**
+ * Remote signer using Web3Signer HTTP API
+ */
+/**
+ * Remote signer that proxies signing operations to a Web3Signer-compatible HTTP endpoint.
+ */
+export declare class RemoteSigner implements Signer {
+    readonly address: EthAddress;
+    private readonly config;
+    constructor(address: EthAddress, config: EthRemoteSignerConfig);
+    /**
+     * Sign a message using eth_sign via remote JSON-RPC.
+     */
+    signMessage(message: Buffer32): Promise<Signature>;
+    /**
+     * Sign typed data using eth_signTypedData_v4 via remote JSON-RPC.
+     */
+    signTypedData(typedData: TypedDataDefinition): Promise<Signature>;
+    /**
+     * Make a JSON-RPC sign request using eth_sign
+     */
+    /**
+     * Make a JSON-RPC eth_sign request.
+     */
+    private makeJsonRpcSignRequest;
+    /**
+     * Make a JSON-RPC sign typed data request using eth_signTypedData_v4
+     */
+    /**
+     * Make a JSON-RPC eth_signTypedData_v4 request.
+     */
+    private makeJsonRpcSignTypedDataRequest;
+    /**
+     * Resolve the effective remote signer URL from config.
+     */
+    private getSignerUrl;
+}
+//# sourceMappingURL=signer.d.ts.map

package/dest/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../src/signer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAE5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAGhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAG3B,MAAM,EAAE,UAAU,GAAG,sBAAsB;IAC3C,GAAG,EAAE,MAAM;IACX,UAAU,CAAC,EAAE,MAAM;IACnB,SAAS,CAAC,EAAE,MAAM;gBAJzB,OAAO,EAAE,MAAM,EACR,MAAM,EAAE,UAAU,GAAG,sBAAsB,EAC3C,GAAG,EAAE,MAAM,EACX,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,SAAS,CAAC,EAAE,MAAM,YAAA;CAK5B;AAED;;GAEG;AACH;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAE7B,mEAAmE;IACnE,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAEnD,oCAAoC;IACpC,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACnE;AAED;;GAEG;AACH;;GAEG;AACH,qBAAa,WAAY,YAAW,MAAM;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;gBAE7B,UAAU,EAAE,QAAQ;IAIhC,IAAI,OAAO,IAAI,UAAU,CAExB;IAED,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IAIlD,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC;CAIlE;AAED;;GAEG;AACH;;GAEG;AACH,qBAAa,YAAa,YAAW,MAAM;aAEvB,OAAO,EAAE,UAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADP,OAAO,EAAE,UAAU,EAClB,MAAM,EAAE,qBAAqB;IAGhD;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IAIxD;;OAEG;IACG,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC;IAIvE;;OAEG;IACH;;OAEG;YACW,sBAAsB;IAoDpC;;OAEG;IACH;;OAEG;YACW,+BAA+B;IAoD7C;;OAEG;IACH,OAAO,CAAC,YAAY;CAMrB"}

package/dest/signer.js

@@ -0,0 +1,148 @@
+/**
+ * Signer Interface and Implementations
+ *
+ * Common interface for different signing backends (local, remote, encrypted)
+ */ import { Buffer32 } from '@aztec/foundation/buffer';
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { hashTypedData } from 'viem';
+/**
+ * Error thrown for remote signer HTTP or JSON-RPC failures
+ */ export class SignerError extends Error {
+    method;
+    url;
+    statusCode;
+    errorCode;
+    constructor(message, method, url, statusCode, errorCode){
+        super(message), this.method = method, this.url = url, this.statusCode = statusCode, this.errorCode = errorCode;
+        this.name = 'SignerError';
+    }
+}
+/**
+ * Local signer using in-memory private key
+ */ /**
+ * Local signer that holds an in-memory Secp256k1 private key.
+ */ export class LocalSigner {
+    signer;
+    constructor(privateKey){
+        this.signer = new Secp256k1Signer(privateKey);
+    }
+    get address() {
+        return this.signer.address;
+    }
+    signMessage(message) {
+        return Promise.resolve(this.signer.signMessage(message));
+    }
+    signTypedData(typedData) {
+        const digest = hashTypedData(typedData);
+        return Promise.resolve(this.signer.sign(Buffer32.fromString(digest)));
+    }
+}
+/**
+ * Remote signer using Web3Signer HTTP API
+ */ /**
+ * Remote signer that proxies signing operations to a Web3Signer-compatible HTTP endpoint.
+ */ export class RemoteSigner {
+    address;
+    config;
+    constructor(address, config){
+        this.address = address;
+        this.config = config;
+    }
+    /**
+   * Sign a message using eth_sign via remote JSON-RPC.
+   */ async signMessage(message) {
+        return await this.makeJsonRpcSignRequest(message);
+    }
+    /**
+   * Sign typed data using eth_signTypedData_v4 via remote JSON-RPC.
+   */ async signTypedData(typedData) {
+        return await this.makeJsonRpcSignTypedDataRequest(typedData);
+    }
+    /**
+   * Make a JSON-RPC sign request using eth_sign
+   */ /**
+   * Make a JSON-RPC eth_sign request.
+   */ async makeJsonRpcSignRequest(data) {
+        const url = this.getSignerUrl();
+        const body = {
+            jsonrpc: '2.0',
+            method: 'eth_sign',
+            params: [
+                this.address.toString(),
+                data.toString()
+            ],
+            id: 1
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new SignerError(`Web3Signer request failed for eth_sign at ${url}: ${response.status} ${response.statusText} - ${errorText}`, 'eth_sign', url, response.status);
+        }
+        const result = await response.json();
+        if (result.error) {
+            throw new SignerError(`Web3Signer JSON-RPC error for eth_sign at ${url}: ${result.error.code} - ${result.error.message}`, 'eth_sign', url, undefined, result.error.code);
+        }
+        if (!result.result) {
+            throw new Error('Invalid response from Web3Signer: no result found');
+        }
+        let signatureHex = result.result;
+        if (!signatureHex.startsWith('0x')) {
+            signatureHex = '0x' + signatureHex;
+        }
+        return Signature.fromString(signatureHex);
+    }
+    /**
+   * Make a JSON-RPC sign typed data request using eth_signTypedData_v4
+   */ /**
+   * Make a JSON-RPC eth_signTypedData_v4 request.
+   */ async makeJsonRpcSignTypedDataRequest(typedData) {
+        const url = this.getSignerUrl();
+        const body = {
+            jsonrpc: '2.0',
+            method: 'eth_signTypedData_v4',
+            params: [
+                this.address.toString(),
+                typedData
+            ],
+            id: 1
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new SignerError(`Web3Signer request failed for eth_signTypedData_v4 at ${url}: ${response.status} ${response.statusText} - ${errorText}`, 'eth_signTypedData_v4', url, response.status);
+        }
+        const result = await response.json();
+        if (result.error) {
+            throw new SignerError(`Web3Signer JSON-RPC error for eth_signTypedData_v4 at ${url}: ${result.error.code} - ${result.error.message}`, 'eth_signTypedData_v4', url, undefined, result.error.code);
+        }
+        if (!result.result) {
+            throw new Error('Invalid response from Web3Signer: no result found');
+        }
+        let signatureHex = result.result;
+        if (!signatureHex.startsWith('0x')) {
+            signatureHex = '0x' + signatureHex;
+        }
+        return Signature.fromString(signatureHex);
+    }
+    /**
+   * Resolve the effective remote signer URL from config.
+   */ getSignerUrl() {
+        if (typeof this.config === 'string') {
+            return this.config;
+        }
+        return this.config.remoteSignerUrl;
+    }
+}

package/dest/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Keys and Addresses Configuration Types
+ *
+ * TypeScript definitions based on the specification for validator keystore files.
+ * These types define the JSON structure for configuring validators, provers, and
+ * their associated keys and addresses.
+ */
+/** Parameterized hex string type for specific byte lengths */
+export type Hex<TByteLength extends number> = `0x${string}` & {
+    readonly _length: TByteLength;
+};
+/** A json keystore config points to a local file with the encrypted private key, and may require a password for decrypting it */
+export type EthJsonKeyFileV3Config = {
+    path: string;
+    password?: string;
+};
+/** A private key is a 32-byte 0x-prefixed hex */
+export type EthPrivateKey = Hex<32>;
+/** An address is a 20-byte 0x-prefixed hex */
+export type EthAddressHex = Hex<20>;
+/** An Aztec address is a 32-byte 0x-prefixed hex */
+export type AztecAddressHex = Hex<32>;
+/** URL type for remote signers */
+export type Url = string;
+/**
+ * A remote signer is configured as an URL to connect to, and optionally a client certificate to use for auth
+ */
+export type EthRemoteSignerConfig = Url | {
+    remoteSignerUrl: Url;
+    certPath?: string;
+    certPass?: string;
+};
+/**
+ * A remote signer account config is equal to the remote signer config, but requires an address to be specified.
+ * If only the address is set, then the default remote signer config from the parent config is used.
+ */
+export type EthRemoteSignerAccount = EthAddressHex | {
+    address: EthAddressHex;
+    remoteSignerUrl?: Url;
+    certPath?: string;
+    certPass?: string;
+};
+/** An L1 account is a private key, a remote signer configuration, or a standard json key store file */
+export type EthAccount = EthPrivateKey | EthRemoteSignerAccount | EthJsonKeyFileV3Config;
+/** A mnemonic can be used to define a set of accounts */
+export type EthMnemonicConfig = {
+    mnemonic: string;
+    addressIndex?: number;
+    accountIndex?: number;
+    addressCount?: number;
+    accountCount?: number;
+};
+/** One or more L1 accounts */
+export type EthAccounts = EthAccount | EthAccount[] | EthMnemonicConfig;
+export type ProverKeyStore = {
+    /** Address that identifies the prover. This address will receive the rewards. */
+    id: EthAddressHex;
+    /** One or more EOAs used for sending proof L1 txs. */
+    publisher: EthAccounts[];
+} | EthAccount;
+export type ValidatorKeyStore = {
+    /**
+     * One or more validator attester keys to handle in this configuration block.
+     * An attester address may only appear once across all configuration blocks across all keystore files.
+     */
+    attester: EthAccounts;
+    /**
+     * Coinbase address to use when proposing an L2 block as any of the validators in this configuration block.
+     * Falls back to the attester address if not set.
+     */
+    coinbase?: EthAddressHex;
+    /**
+     * One or more EOAs used for sending block proposal L1 txs for all validators in this configuration block.
+     * Falls back to the attester account if not set.
+     */
+    publisher?: EthAccounts;
+    /**
+     * Fee recipient address to use when proposing an L2 block as any of the validators in this configuration block.
+     */
+    feeRecipient: AztecAddressHex;
+    /**
+     * Default remote signer for all accounts in this block.
+     */
+    remoteSigner?: EthRemoteSignerConfig;
+};
+export type KeyStore = {
+    /** Schema version of this keystore file (initially 1). */
+    schemaVersion: number;
+    /** Validator configurations. */
+    validators?: ValidatorKeyStore[];
+    /** One or more accounts used for creating slash payloads on L1. Does not create slash payloads if not set. */
+    slasher?: EthAccounts;
+    /** Default config for the remote signer for all accounts in this file. */
+    remoteSigner?: EthRemoteSignerConfig;
+    /** Prover configuration. Only one prover configuration is allowed. */
+    prover?: ProverKeyStore;
+};
+//# sourceMappingURL=types.d.ts.map

package/dest/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,GAAG,CAAC,WAAW,SAAS,MAAM,IAAI,KAAK,MAAM,EAAE,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAEhG,iIAAiI;AACjI,MAAM,MAAM,sBAAsB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AAEpC,8CAA8C;AAC9C,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AAEpC,oDAAoD;AACpD,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC;AAEtC,kCAAkC;AAClC,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC;AAEzB;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B,GAAG,GACH;IACE,eAAe,EAAE,GAAG,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEN;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAC9B,aAAa,GACb;IACE,OAAO,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEN,uGAAuG;AACvG,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,sBAAsB,GAAG,sBAAsB,CAAC;AAEzF,yDAAyD;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,8BAA8B;AAC9B,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,UAAU,EAAE,GAAG,iBAAiB,CAAC;AAExE,MAAM,MAAM,cAAc,GACtB;IACE,iFAAiF;IACjF,EAAE,EAAE,aAAa,CAAC;IAClB,sDAAsD;IACtD,SAAS,EAAE,WAAW,EAAE,CAAC;CAC1B,GACD,UAAU,CAAC;AAEf,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,QAAQ,EAAE,WAAW,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB;;OAEG;IACH,YAAY,EAAE,eAAe,CAAC;IAC9B;;OAEG;IACH,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,UAAU,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACjC,8GAA8G;IAC9G,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC,sEAAsE;IACtE,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB,CAAC"}

package/dest/types.js

@@ -0,0 +1,7 @@
+/**
+ * Keys and Addresses Configuration Types
+ *
+ * TypeScript definitions based on the specification for validator keystore files.
+ * These types define the JSON structure for configuring validators, provers, and
+ * their associated keys and addresses.
+ */ /** Parameterized hex string type for specific byte lengths */ export { };

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@aztec/node-keystore",
+  "version": "2.0.0-nightly.20250816",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./types": "./dest/types.js",
+    "./validation": "./dest/validation.js",
+    "./loader": "./dest/loader.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Node Keystore",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/foundation": "2.0.0-nightly.20250816",
+    "@aztec/stdlib": "2.0.0-nightly.20250816",
+    "@ethersproject/wallet": "^5.7.0",
+    "tslib": "^2.4.0",
+    "viem": "2.23.7",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "jest": "^30.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './loader.js';
+export * from './schemas.js';
+export * from './signer.js';
+export * from './keystore_manager.js';