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

package/dest/key_store/node_keystore_adapter.js

@@ -0,0 +1,316 @@
+import { KeystoreManager, loadKeystoreFile } from '@aztec/node-keystore';
+import { InvalidValidatorPrivateKeyError } from '@aztec/stdlib/validators';
+import { privateKeyToAccount } from 'viem/accounts';
+export class NodeKeystoreAdapter {
+    keystoreManager;
+    // Per-validator cache (lazy)
+    validators = new Map();
+    addressIndex = new Map();
+    constructor(keystoreManager){
+        this.keystoreManager = keystoreManager;
+    }
+    /**
+   * Create an adapter from a keystore JSON file on disk.
+   * @param keystoreFilePath Absolute or relative path to a keystore JSON file
+   * @returns A configured NodeKeystoreAdapter instance
+   * @throws Error when the file fails schema validation or cannot be read
+   */ static fromKeystoreFile(keystoreFilePath) {
+        const keystoreConfig = loadKeystoreFile(keystoreFilePath);
+        return NodeKeystoreAdapter.fromKeystoreConfig(keystoreConfig);
+    }
+    /**
+   * Create an adapter from an in-memory keystore-like object.
+   * Validates resolved duplicate attester addresses across validators and sources.
+   * @param keystoreConfig Parsed config object (typically result of loadKeystoreFile)
+   * @returns A configured NodeKeystoreAdapter instance
+   * @throws Error when resolved duplicate attester addresses are detected
+   */ static fromKeystoreConfig(keystoreConfig) {
+        const keystoreManager = new KeystoreManager(keystoreConfig);
+        // Validate resolved attester addresses (covers JSON V3 and mnemonic duplicates across validators)
+        keystoreManager.validateResolvedUniqueAttesterAddresses();
+        return new NodeKeystoreAdapter(keystoreManager);
+    }
+    /**
+   * Build an adapter directly from a list of validator private keys.
+   * Each key becomes a separate validator using the same key for attester and publisher,
+   * coinbase defaults to the derived EOA address, and feeRecipient is a 32-byte padded address.
+   * Note: Fee recipient is a temporary placeholder, replace with actual fee recipient when implemented.
+   */ static fromPrivateKeys(privateKeys) {
+        // Minimal validation: 0x + 64 hex
+        const isPk = (s)=>/^0x[0-9a-fA-F]{64}$/.test(s);
+        for (const pk of privateKeys){
+            if (!isPk(pk)) {
+                throw new InvalidValidatorPrivateKeyError();
+            }
+        }
+        const validators = privateKeys.map((pk)=>{
+            const account = privateKeyToAccount(pk);
+            const ethAddress = account.address;
+            // TODO: Temporary fee recipient, replace with actual fee recipient when implemented
+            const feeRecipient = `0x${ethAddress.slice(2).padStart(64, '0')}`;
+            return {
+                attester: pk,
+                publisher: pk,
+                coinbase: ethAddress,
+                feeRecipient
+            };
+        });
+        const cfg = {
+            schemaVersion: 1,
+            validators
+        };
+        return NodeKeystoreAdapter.fromKeystoreConfig(cfg);
+    }
+    /**
+   * Build an adapter for a Web3Signer setup by providing the signer URL and the EOA addresses.
+   * Each address becomes a separate validator; attester and publisher point to the same remote signer entry.
+   * Note: Fee recipient is a temporary placeholder, replace with actual fee recipient when implemented.
+   */ static fromWeb3Signer(web3SignerUrl, addresses) {
+        const validators = addresses.map((address)=>{
+            const ethAddress = address.toString();
+            // TODO: Temporary fee recipient, replace with actual fee recipient when implemented
+            const feeRecipient = `0x${ethAddress.slice(2).padStart(64, '0')}`;
+            return {
+                attester: {
+                    address: ethAddress,
+                    remoteSignerUrl: web3SignerUrl
+                },
+                publisher: {
+                    address: ethAddress,
+                    remoteSignerUrl: web3SignerUrl
+                },
+                coinbase: ethAddress,
+                feeRecipient
+            };
+        });
+        const cfg = {
+            schemaVersion: 1,
+            validators
+        };
+        return NodeKeystoreAdapter.fromKeystoreConfig(cfg);
+    }
+    static fromKeyStoreManager(manager) {
+        return new NodeKeystoreAdapter(manager);
+    }
+    /**
+   * Normalize address keys to lowercase hex strings for map/set usage.
+   */ static key(addr) {
+        return typeof addr === 'string' ? addr.toLowerCase() : addr.toString().toLowerCase();
+    }
+    /**
+   * Ensure per-validator signer cache exists; build it by creating
+   * attester/publisher signers and populating indices when missing.
+   * @param validatorIndex Index of the validator in the keystore
+   * @returns The cached validator entry
+   */ ensureValidator(validatorIndex) {
+        const cached = this.validators.get(validatorIndex);
+        if (cached) {
+            return cached;
+        }
+        const attesters = this.keystoreManager.createAttesterSigners(validatorIndex);
+        const publishers = this.keystoreManager.createPublisherSigners(validatorIndex);
+        // Build 'all' + indices
+        const byAddress = new Map();
+        const attesterSet = new Set();
+        for (const s of attesters){
+            const k = NodeKeystoreAdapter.key(s.address);
+            byAddress.set(k, s);
+            attesterSet.add(k);
+        }
+        for (const s of publishers){
+            const k = NodeKeystoreAdapter.key(s.address);
+            if (!byAddress.has(k)) {
+                byAddress.set(k, s);
+            }
+        }
+        const all = Array.from(byAddress.values());
+        // Populate global index
+        for (const [k, signer] of byAddress.entries()){
+            this.addressIndex.set(k, {
+                signer,
+                validatorIndex
+            });
+        }
+        const built = {
+            attesters,
+            publishers,
+            all,
+            byAddress,
+            attesterSet
+        };
+        this.validators.set(validatorIndex, built);
+        return built;
+    }
+    /**
+   * Iterate all validator indices in the keystore manager.
+   */ *validatorIndices() {
+        const n = this.keystoreManager.getValidatorCount();
+        for(let i = 0; i < n; i++){
+            yield i;
+        }
+    }
+    /**
+   * Find the validator index that contains the given attester address.
+   * @param attesterAddress Address to locate
+   * @returns Validator index
+   * @throws Error when no validator contains the attester
+   */ findValidatorIndexForAttester(attesterAddress) {
+        const key = NodeKeystoreAdapter.key(attesterAddress);
+        // Fast path: if we’ve already cached any validator that includes this as attester
+        for (const i of this.validatorIndices()){
+            const v = this.ensureValidator(i);
+            if (v.attesterSet.has(key)) {
+                return i;
+            }
+        }
+        throw new Error(`Attester address ${attesterAddress.toString()} not found in any validator configuration`);
+    }
+    /**
+   * Get attester address by flat index across all validators' attester sets.
+   * @param index Zero-based flat index across all attesters
+   * @returns EthAddress for the indexed attester
+   * @throws Error when index is out of bounds
+   */ getAddress(index) {
+        const all = this.getAddresses();
+        if (index < 0 || index >= all.length) {
+            throw new Error(`Index ${index} is out of bounds (0..${all.length - 1}).`);
+        }
+        return all[index];
+    }
+    /**
+   * Get all attester addresses across validators (legacy-compatible view).
+   */ getAddresses() {
+        const out = [];
+        for (const i of this.validatorIndices()){
+            const v = this.ensureValidator(i);
+            // attester addresses only for backward compatibility
+            for (const s of v.attesters){
+                out.push(s.address);
+            }
+        }
+        return out;
+    }
+    /**
+   * Sign typed data with all attester signers across validators.
+   * @param typedData EIP-712 typed data
+   * @returns Array of signatures in validator order, flattened
+   */ async signTypedData(typedData) {
+        const jobs = [];
+        for (const i of this.validatorIndices()){
+            const v = this.ensureValidator(i);
+            for (const s of v.attesters){
+                jobs.push(this.keystoreManager.signTypedData(s, typedData));
+            }
+        }
+        return await Promise.all(jobs);
+    }
+    /**
+   * Sign a message with all attester signers across validators.
+   * @param message 32-byte message (already hashed/padded as needed)
+   * @returns Array of signatures in validator order, flattened
+   */ async signMessage(message) {
+        const jobs = [];
+        for (const i of this.validatorIndices()){
+            const v = this.ensureValidator(i);
+            for (const s of v.attesters){
+                jobs.push(this.keystoreManager.signMessage(s, message));
+            }
+        }
+        return await Promise.all(jobs);
+    }
+    /**
+   * Sign typed data with a signer identified by address (any role).
+   * Hydrates caches on-demand when the address is first seen.
+   * @param address Address to sign with
+   * @param typedData EIP-712 typed data
+   * @returns Signature from the signer matching the address
+   * @throws Error when no signer exists for the address
+   */ async signTypedDataWithAddress(address, typedData) {
+        const entry = this.addressIndex.get(NodeKeystoreAdapter.key(address));
+        if (entry) {
+            return await this.keystoreManager.signTypedData(entry.signer, typedData);
+        }
+        // If not in global index yet, lazily hydrate all validators once and retry
+        for (const i of this.validatorIndices()){
+            this.ensureValidator(i);
+        }
+        const second = this.addressIndex.get(NodeKeystoreAdapter.key(address));
+        if (second) {
+            return await this.keystoreManager.signTypedData(second.signer, typedData);
+        }
+        throw new Error(`No signer found for address ${address.toString()}`);
+    }
+    /**
+   * Sign a message with a signer identified by address (any role).
+   * Hydrates caches on-demand when the address is first seen.
+   * @param address Address to sign with
+   * @param message 32-byte message
+   * @returns Signature from the signer matching the address
+   * @throws Error when no signer exists for the address
+   */ async signMessageWithAddress(address, message) {
+        const entry = this.addressIndex.get(NodeKeystoreAdapter.key(address));
+        if (entry) {
+            return await this.keystoreManager.signMessage(entry.signer, message);
+        }
+        for (const i of this.validatorIndices()){
+            this.ensureValidator(i);
+        }
+        const second = this.addressIndex.get(NodeKeystoreAdapter.key(address));
+        if (second) {
+            return await this.keystoreManager.signMessage(second.signer, message);
+        }
+        throw new Error(`No signer found for address ${address.toString()}`);
+    }
+    /**
+   * Get all attester addresses across validators (alias of getAddresses).
+   */ getAttesterAddresses() {
+        return this.getAddresses();
+    }
+    /**
+   * Get the effective coinbase address for the validator that contains the given attester.
+   * @param attesterAddress Address of an attester belonging to the validator
+   * @returns Coinbase EthAddress
+   */ getCoinbaseAddress(attesterAddress) {
+        const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
+        return this.keystoreManager.getCoinbaseAddress(validatorIndex, attesterAddress);
+    }
+    /**
+   * Get the publisher addresses for the validator that contains the given attester.
+   * @param attesterAddress Address of an attester belonging to the validator
+   * @returns Array of publisher addresses
+   */ getPublisherAddresses(attesterAddress) {
+        const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
+        const v = this.ensureValidator(validatorIndex);
+        return v.publishers.map((s)=>s.address);
+    }
+    getAttestorForPublisher(publisherAddress) {
+        const attestorAddresses = this.getAttesterAddresses();
+        for (const attestor of attestorAddresses){
+            const publishers = this.getPublisherAddresses(attestor);
+            const found = publishers.some((publisher)=>publisher.equals(publisherAddress));
+            if (found) {
+                return attestor;
+            }
+        }
+        // Could not find an attestor for this publisher
+        throw new Error(`Failed to find attestor for publisher ${publisherAddress.toString()}`);
+    }
+    /**
+   * Get the fee recipient for the validator that contains the given attester.
+   * @param attesterAddress Address of an attester belonging to the validator
+   * @returns Fee recipient as AztecAddress
+   */ getFeeRecipient(attesterAddress) {
+        const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
+        return this.keystoreManager.getFeeRecipient(validatorIndex);
+    }
+    /**
+   * Get the effective remote signer configuration for the attester.
+   * Precedence: account-level override > validator-level override > file-level default.
+   * Returns undefined for local signers (private key / JSON-V3 / mnemonic).
+   * @param attesterAddress Address of an attester belonging to the validator
+   * @returns Effective remote signer configuration or undefined
+   */ getRemoteSignerConfig(attesterAddress) {
+        const validatorIndex = this.findValidatorIndexForAttester(attesterAddress);
+        return this.keystoreManager.getEffectiveRemoteSignerConfig(validatorIndex, attesterAddress);
+    }
+}

package/dest/key_store/web3signer_key_store.d.ts

@@ -0,0 +1,67 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import type { TypedDataDefinition } from 'viem';
+import type { ValidatorKeyStore } from './interface.js';
+/**
+ * Web3Signer Key Store
+ *
+ * An implementation of the Key store using Web3Signer remote signing service.
+ * This implementation uses the Web3Signer JSON-RPC API for secp256k1 signatures.
+ */
+export declare class Web3SignerKeyStore implements ValidatorKeyStore {
+    private addresses;
+    private baseUrl;
+    constructor(addresses: EthAddress[], baseUrl: string);
+    /**
+     * Get the address of a signer by index
+     *
+     * @param index - The index of the signer
+     * @returns the address
+     */
+    getAddress(index: number): EthAddress;
+    /**
+     * Get all addresses
+     *
+     * @returns all addresses
+     */
+    getAddresses(): EthAddress[];
+    /**
+     * Sign EIP-712 typed data with all keystore addresses
+     * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+     * @return signatures
+     */
+    signTypedData(typedData: TypedDataDefinition): Promise<Signature[]>;
+    /**
+     * Sign EIP-712 typed data with a specific address
+     * @param address - The address of the signer to use
+     * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+     * @returns signature for the specified address
+     * @throws Error if the address is not found in the keystore or signing fails
+     */
+    signTypedDataWithAddress(address: EthAddress, typedData: TypedDataDefinition): Promise<Signature>;
+    /**
+     * Sign a message with all keystore addresses using EIP-191 prefix
+     *
+     * @param message - The message to sign
+     * @return signatures
+     */
+    signMessage(message: Buffer32): Promise<Signature[]>;
+    /**
+     * Sign a message with a specific address using EIP-191 prefix
+     * @param address - The address of the signer to use
+     * @param message - The message to sign
+     * @returns signature for the specified address
+     * @throws Error if the address is not found in the keystore or signing fails
+     */
+    signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature>;
+    /**
+     * Make a JSON-RPC sign request to Web3Signer using eth_sign
+     * @param address - The Ethereum address to sign with
+     * @param data - The data to sign
+     * @returns The signature
+     */
+    private makeJsonRpcSignRequest;
+    private makeJsonRpcSignTypedDataRequest;
+}
+//# sourceMappingURL=web3signer_key_store.d.ts.map

package/dest/key_store/web3signer_key_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web3signer_key_store.d.ts","sourceRoot":"","sources":["../../src/key_store/web3signer_key_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAE5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,iBAAiB;IAExD,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;gBADP,SAAS,EAAE,UAAU,EAAE,EACvB,OAAO,EAAE,MAAM;IAGzB;;;;;OAKG;IACI,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAO5C;;;;OAIG;IACI,YAAY,IAAI,UAAU,EAAE;IAInC;;;;OAIG;IACI,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAI1E;;;;;;OAMG;IACU,wBAAwB,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC;IAQ9G;;;;;OAKG;IACI,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAI3D;;;;;;OAMG;IACU,sBAAsB,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IAO/F;;;;;OAKG;YACW,sBAAsB;YAiDtB,+BAA+B;CA6C9C"}

package/dest/key_store/web3signer_key_store.js

@@ -0,0 +1,152 @@
+import { normalizeSignature } from '@aztec/foundation/crypto';
+import { Signature } from '@aztec/foundation/eth-signature';
+/**
+ * Web3Signer Key Store
+ *
+ * An implementation of the Key store using Web3Signer remote signing service.
+ * This implementation uses the Web3Signer JSON-RPC API for secp256k1 signatures.
+ */ export class Web3SignerKeyStore {
+    addresses;
+    baseUrl;
+    constructor(addresses, baseUrl){
+        this.addresses = addresses;
+        this.baseUrl = baseUrl;
+    }
+    /**
+   * Get the address of a signer by index
+   *
+   * @param index - The index of the signer
+   * @returns the address
+   */ getAddress(index) {
+        if (index >= this.addresses.length) {
+            throw new Error(`Index ${index} is out of bounds.`);
+        }
+        return this.addresses[index];
+    }
+    /**
+   * Get all addresses
+   *
+   * @returns all addresses
+   */ getAddresses() {
+        return this.addresses;
+    }
+    /**
+   * Sign EIP-712 typed data with all keystore addresses
+   * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+   * @return signatures
+   */ signTypedData(typedData) {
+        return Promise.all(this.addresses.map((address)=>this.makeJsonRpcSignTypedDataRequest(address, typedData)));
+    }
+    /**
+   * Sign EIP-712 typed data with a specific address
+   * @param address - The address of the signer to use
+   * @param typedData - The complete EIP-712 typed data structure (domain, types, primaryType, message)
+   * @returns signature for the specified address
+   * @throws Error if the address is not found in the keystore or signing fails
+   */ async signTypedDataWithAddress(address, typedData) {
+        if (!this.addresses.some((addr)=>addr.equals(address))) {
+            throw new Error(`Address ${address.toString()} not found in keystore`);
+        }
+        return await this.makeJsonRpcSignTypedDataRequest(address, typedData);
+    }
+    /**
+   * Sign a message with all keystore addresses using EIP-191 prefix
+   *
+   * @param message - The message to sign
+   * @return signatures
+   */ signMessage(message) {
+        return Promise.all(this.addresses.map((address)=>this.makeJsonRpcSignRequest(address, message)));
+    }
+    /**
+   * Sign a message with a specific address using EIP-191 prefix
+   * @param address - The address of the signer to use
+   * @param message - The message to sign
+   * @returns signature for the specified address
+   * @throws Error if the address is not found in the keystore or signing fails
+   */ async signMessageWithAddress(address, message) {
+        if (!this.addresses.some((addr)=>addr.equals(address))) {
+            throw new Error(`Address ${address.toString()} not found in keystore`);
+        }
+        return await this.makeJsonRpcSignRequest(address, message);
+    }
+    /**
+   * Make a JSON-RPC sign request to Web3Signer using eth_sign
+   * @param address - The Ethereum address to sign with
+   * @param data - The data to sign
+   * @returns The signature
+   */ async makeJsonRpcSignRequest(address, data) {
+        const url = this.baseUrl;
+        // Use JSON-RPC eth_sign method which automatically applies Ethereum message prefixing
+        const body = {
+            jsonrpc: '2.0',
+            method: 'eth_sign',
+            params: [
+                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 Error(`Web3Signer request failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const result = await response.json();
+        // Handle JSON-RPC response format
+        if (result.error) {
+            throw new Error(`Web3Signer JSON-RPC error: ${result.error.code} - ${result.error.message}`);
+        }
+        if (!result.result) {
+            throw new Error('Invalid response from Web3Signer: no result found');
+        }
+        let signatureHex = result.result;
+        // Ensure the signature has the 0x prefix
+        if (!signatureHex.startsWith('0x')) {
+            signatureHex = '0x' + signatureHex;
+        }
+        // Parse the signature from the hex string
+        return normalizeSignature(Signature.fromString(signatureHex));
+    }
+    async makeJsonRpcSignTypedDataRequest(address, typedData) {
+        const url = this.baseUrl;
+        const body = {
+            jsonrpc: '2.0',
+            method: 'eth_signTypedData',
+            params: [
+                address.toString(),
+                JSON.stringify(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 Error(`Web3Signer request failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const result = await response.json();
+        if (result.error) {
+            throw new Error(`Web3Signer JSON-RPC error: ${result.error.code} - ${result.error.message}`);
+        }
+        if (!result.result) {
+            throw new Error('Invalid response from Web3Signer: no result found');
+        }
+        let signatureHex = result.result;
+        // Ensure the signature has the 0x prefix
+        if (!signatureHex.startsWith('0x')) {
+            signatureHex = '0x' + signatureHex;
+        }
+        return normalizeSignature(Signature.fromString(signatureHex));
+    }
+}

package/dest/metrics.d.ts

@@ -1,11 +1,18 @@
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 export declare class ValidatorMetrics {
-    private reExecutionTime;
     private failedReexecutionCounter;
+    private successfulAttestationsCount;
+    private failedAttestationsBadProposalCount;
+    private failedAttestationsNodeIssueCount;
+    private reexMana;
+    private reexTx;
+    private reexDuration;
     constructor(telemetryClient: TelemetryClient);
-    reExecutionTimer(): () => void;
-    recordReExecutionTime(time: number): void;
-    recordFailedReexecution(proposal: BlockProposal): Promise<void>;
+    recordReex(time: number, txs: number, mManaTotal: number): void;
+    recordFailedReexecution(proposal: BlockProposal): void;
+    incSuccessfulAttestations(num: number): void;
+    incFailedAttestationsBadProposal(num: number, reason: string, inCommittee: boolean): void;
+    incFailedAttestationsNodeIssue(num: number, reason: string, inCommittee: boolean): void;
 }
 //# sourceMappingURL=metrics.d.ts.map

package/dest/metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAIL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,wBAAwB,CAAgB;gBAEpC,eAAe,EAAE,eAAe;IAgBrC,gBAAgB,IAAI,MAAM,IAAI;IAQ9B,qBAAqB,CAAC,IAAI,EAAE,MAAM;IAI5B,uBAAuB,CAAC,QAAQ,EAAE,aAAa;CAO7D"}
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAIL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,wBAAwB,CAAgB;IAChD,OAAO,CAAC,2BAA2B,CAAgB;IACnD,OAAO,CAAC,kCAAkC,CAAgB;IAC1D,OAAO,CAAC,gCAAgC,CAAgB;IAExD,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,YAAY,CAAY;gBAEpB,eAAe,EAAE,eAAe;IAiDrC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAMxD,uBAAuB,CAAC,QAAQ,EAAE,aAAa;IAQ/C,yBAAyB,CAAC,GAAG,EAAE,MAAM;IAIrC,gCAAgC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO;IAOlF,8BAA8B,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO;CAMxF"}

package/dest/metrics.js

@@ -1,7 +1,12 @@
 import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
 export class ValidatorMetrics {
-    reExecutionTime;
     failedReexecutionCounter;
+    successfulAttestationsCount;
+    failedAttestationsBadProposalCount;
+    failedAttestationsNodeIssueCount;
+    reexMana;
+    reexTx;
+    reexDuration;
     constructor(telemetryClient){
         const meter = telemetryClient.getMeter('Validator');
         this.failedReexecutionCounter = meter.createUpDownCounter(Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT, {
@@ -9,27 +14,59 @@ export class ValidatorMetrics {
             unit: 'count',
             valueType: ValueType.INT
         });
-        this.reExecutionTime = meter.createGauge(Metrics.VALIDATOR_RE_EXECUTION_TIME, {
+        this.successfulAttestationsCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_SUCCESS_COUNT, {
+            description: 'The number of successful attestations',
+            valueType: ValueType.INT
+        });
+        this.failedAttestationsBadProposalCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_FAILED_BAD_PROPOSAL_COUNT, {
+            description: 'The number of failed attestations due to invalid block proposals',
+            valueType: ValueType.INT
+        });
+        this.failedAttestationsNodeIssueCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_FAILED_NODE_ISSUE_COUNT, {
+            description: 'The number of failed attestations due to node issues (timeout, missing data, etc.)',
+            valueType: ValueType.INT
+        });
+        this.reexMana = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_MANA, {
+            description: 'The mana consumed by blocks',
+            valueType: ValueType.DOUBLE,
+            unit: 'Mmana'
+        });
+        this.reexTx = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_TX_COUNT, {
+            description: 'The number of txs in a block proposal',
+            valueType: ValueType.INT,
+            unit: 'tx'
+        });
+        this.reexDuration = meter.createGauge(Metrics.VALIDATOR_RE_EXECUTION_TIME, {
             description: 'The time taken to re-execute a transaction',
             unit: 'ms',
-            valueType: ValueType.DOUBLE
+            valueType: ValueType.INT
         });
     }
-    reExecutionTimer() {
-        const start = performance.now();
-        return ()=>{
-            const end = performance.now();
-            this.recordReExecutionTime(end - start);
-        };
-    }
-    recordReExecutionTime(time) {
-        this.reExecutionTime.record(time);
+    recordReex(time, txs, mManaTotal) {
+        this.reexDuration.record(Math.ceil(time));
+        this.reexTx.record(txs);
+        this.reexMana.record(mManaTotal);
     }
-    async recordFailedReexecution(proposal) {
+    recordFailedReexecution(proposal) {
+        const proposer = proposal.getSender();
         this.failedReexecutionCounter.add(1, {
             [Attributes.STATUS]: 'failed',
-            [Attributes.BLOCK_NUMBER]: proposal.payload.header.globalVariables.blockNumber.toString(),
-            [Attributes.BLOCK_PROPOSER]: (await proposal.getSender())?.toString()
+            [Attributes.BLOCK_PROPOSER]: proposer?.toString() ?? 'unknown'
+        });
+    }
+    incSuccessfulAttestations(num) {
+        this.successfulAttestationsCount.add(num);
+    }
+    incFailedAttestationsBadProposal(num, reason, inCommittee) {
+        this.failedAttestationsBadProposalCount.add(num, {
+            [Attributes.ERROR_TYPE]: reason,
+            [Attributes.IS_COMMITTEE_MEMBER]: inCommittee
+        });
+    }
+    incFailedAttestationsNodeIssue(num, reason, inCommittee) {
+        this.failedAttestationsNodeIssueCount.add(num, {
+            [Attributes.ERROR_TYPE]: reason,
+            [Attributes.IS_COMMITTEE_MEMBER]: inCommittee
         });
     }
 }