@aztec/stdlib 5.0.0-nightly.20260707 → 5.0.0-nightly.20260708

package/dest/logs/shared_secret_derivation.d.ts

@@ -3,8 +3,14 @@ import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { PublicKey } from '../keys/public_key.js';
 /**
- * Derives an app-siloed ECDH shared secret from keys: ECDHs `S = secretKey * publicKey`, then app-silos it via
- * {@link appSiloEcdhSharedSecretPoint}.
+ * Derives the raw ECDH shared secret point `S = secretKey * publicKey`.
+ *
+ * @throws If the publicKey is zero.
+ */
+export declare function deriveEcdhSharedSecretPoint(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point>;
+/**
+ * Derives an app-siloed ECDH shared secret from keys: ECDHs `S = secretKey * publicKey` via
+ * {@link deriveEcdhSharedSecretPoint}, then app-silos it via {@link appSiloEcdhSharedSecretPoint}.
  *
  * @param secretKey - The secret key used to derive shared secret.
  * @param publicKey - The public key used to derive shared secret.
@@ -22,4 +28,4 @@ export declare function appSiloEcdhSharedSecret(secretKey: GrumpkinScalar, publi
  * @param app - The contract address to silo to.
  */
 export declare function appSiloEcdhSharedSecretPoint(point: Point, app: AztecAddress): Promise<Fr>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkX3NlY3JldF9kZXJpdmF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbG9ncy9zaGFyZWRfc2VjcmV0X2Rlcml2YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLEtBQUssRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBRS9FLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXZEOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQix1QkFBdUIsQ0FDM0MsU0FBUyxFQUFFLGNBQWMsRUFDekIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsZUFBZSxFQUFFLFlBQVksR0FDNUIsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQVFiO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFnQiw0QkFBNEIsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUV6RiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkX3NlY3JldF9kZXJpdmF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbG9ncy9zaGFyZWRfc2VjcmV0X2Rlcml2YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLEtBQUssRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBRS9FLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXZEOzs7O0dBSUc7QUFDSCx3QkFBZ0IsMkJBQTJCLENBQUMsU0FBUyxFQUFFLGNBQWMsRUFBRSxTQUFTLEVBQUUsU0FBUyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FPM0c7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsdUJBQXVCLENBQzNDLFNBQVMsRUFBRSxjQUFjLEVBQ3pCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGVBQWUsRUFBRSxZQUFZLEdBQzVCLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FHYjtBQUVEOzs7Ozs7O0dBT0c7QUFDSCx3QkFBZ0IsNEJBQTRCLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FFekYifQ==

package/dest/logs/shared_secret_derivation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared_secret_derivation.d.ts","sourceRoot":"","sources":["../../src/logs/shared_secret_derivation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,EAAE,CAAC,CAQb;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAEzF"}
+{"version":3,"file":"shared_secret_derivation.d.ts","sourceRoot":"","sources":["../../src/logs/shared_secret_derivation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAO3G;AAED;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,EAAE,CAAC,CAGb;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAEzF"}

package/dest/logs/shared_secret_derivation.js

@@ -2,8 +2,18 @@ import { DomainSeparator } from '@aztec/constants';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 /**
- * Derives an app-siloed ECDH shared secret from keys: ECDHs `S = secretKey * publicKey`, then app-silos it via
- * {@link appSiloEcdhSharedSecretPoint}.
+ * Derives the raw ECDH shared secret point `S = secretKey * publicKey`.
+ *
+ * @throws If the publicKey is zero.
+ */ export function deriveEcdhSharedSecretPoint(secretKey, publicKey) {
+    if (publicKey.isZero()) {
+        throw new Error(`Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`);
+    }
+    return Grumpkin.mul(publicKey, secretKey);
+}
+/**
+ * Derives an app-siloed ECDH shared secret from keys: ECDHs `S = secretKey * publicKey` via
+ * {@link deriveEcdhSharedSecretPoint}, then app-silos it via {@link appSiloEcdhSharedSecretPoint}.
  *
  * @param secretKey - The secret key used to derive shared secret.
  * @param publicKey - The public key used to derive shared secret.
@@ -11,10 +21,7 @@ import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
  * @returns The app-siloed shared secret as a Field.
  * @throws If the publicKey is zero.
  */ export async function appSiloEcdhSharedSecret(secretKey, publicKey, contractAddress) {
-    if (publicKey.isZero()) {
-        throw new Error(`Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`);
-    }
-    const rawSharedSecret = await Grumpkin.mul(publicKey, secretKey);
+    const rawSharedSecret = await deriveEcdhSharedSecretPoint(secretKey, publicKey);
     return appSiloEcdhSharedSecretPoint(rawSharedSecret, contractAddress);
 }
 /**

package/dest/p2p/signature_utils.d.ts

@@ -28,6 +28,15 @@ export declare function hasValidSignatureContext(signable: Signable, expected: C
 export declare function getCoordinationSignatureTypedDataForPayloadHash(payloadHash: Buffer32, type: CoordinationSignatureType, context: CoordinationSignatureContext): TypedDataDefinition;
 export declare function getCoordinationSignatureTypedData(signable: Signable): TypedDataDefinition;
 export declare function getHashedSignaturePayloadTypedData(signable: Signable): Buffer32;
+/**
+ * Recovers the sender of a gossiped coordination message. Deliberately lenient (allowYParityAsV): a
+ * signature whose recovery byte is in yParity form (v ∈ {0, 1}) still resolves to its sender, so the P2P
+ * layer can attribute and accept it and then canonicalize on ingress (CheckpointAttestation.
+ * withNormalizedSignature, A-1351) before it reaches the L1 bundle. This is intentionally looser than
+ * on-chain checkpoint validation (getAttestationInfoFromPayload), which recovers strictly to mirror L1's
+ * ECDSA.recover — do not unify the two. These proposal/attestation signatures are P2P-only and never reach
+ * L1 verbatim, so leniency here cannot leak a non-canonical byte onto L1.
+ */
 export declare function recoverCoordinationSigner(signable: Signable, signature: Signature): EthAddress | undefined;
 export declare function getHashedSignaturePayload(s: Signable): Buffer32;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmF0dXJlX3V0aWxzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcDJwL3NpZ25hdHVyZV91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFHcEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUVuRixPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBaUIsTUFBTSxNQUFNLENBQUM7QUFHL0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFbEQsTUFBTSxNQUFNLHlCQUF5QixHQUNqQyxlQUFlLEdBQ2Ysb0JBQW9CLEdBQ3BCLHVCQUF1QixHQUN2Qix3QkFBd0IsR0FDeEIsV0FBVyxDQUFDO0FBRWhCLE1BQU0sTUFBTSw0QkFBNEIsR0FBRztJQUN6QyxPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLGFBQWEsRUFBRSxVQUFVLENBQUM7Q0FDM0IsQ0FBQztBQUVGLGVBQU8sTUFBTSxvQ0FBb0MsRUFBRSw0QkFHbEQsQ0FBQztBQUVGLGVBQU8sTUFBTSxrQ0FBa0MsRUFBRSxNQUFNLENBQUMsNEJBQTRCLENBR2xGLENBQUM7QUFFSCxNQUFNLFdBQVcsUUFBUTtJQUN2QixRQUFRLENBQUMsV0FBVyxFQUFFLHlCQUF5QixDQUFDO0lBQ2hELFFBQVEsQ0FBQyxnQkFBZ0IsRUFBRSw0QkFBNEIsQ0FBQztJQUN4RCxnQkFBZ0IsSUFBSSxNQUFNLENBQUM7Q0FDNUI7QUFFRCx3QkFBZ0Isa0NBQWtDLENBQ2hELENBQUMsRUFBRSw0QkFBNEIsRUFDL0IsQ0FBQyxFQUFFLDRCQUE0QixHQUM5QixPQUFPLENBRVQ7QUFFRCx3QkFBZ0IscUNBQXFDLENBQUMsR0FBRyxFQUFFLDRCQUE0QixHQUFHLE1BQU0sQ0FFL0Y7QUFFRCx3QkFBZ0IsZ0NBQWdDLENBQUMsTUFBTSxFQUFFLFlBQVksR0FBRyw0QkFBNEIsQ0FJbkc7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQWdCLHdCQUF3QixDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLDRCQUE0QixHQUFHLE9BQU8sQ0FFNUc7QUFxQkQsd0JBQWdCLCtDQUErQyxDQUM3RCxXQUFXLEVBQUUsUUFBUSxFQUNyQixJQUFJLEVBQUUseUJBQXlCLEVBQy9CLE9BQU8sRUFBRSw0QkFBNEIsR0FDcEMsbUJBQW1CLENBY3JCO0FBRUQsd0JBQWdCLGlDQUFpQyxDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsbUJBQW1CLENBR3pGO0FBRUQsd0JBQWdCLGtDQUFrQyxDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsUUFBUSxDQUUvRTtBQUVELHdCQUFnQix5QkFBeUIsQ0FBQyxRQUFRLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxTQUFTLEdBQUcsVUFBVSxHQUFHLFNBQVMsQ0FHMUc7QUFFRCx3QkFBZ0IseUJBQXlCLENBQUMsQ0FBQyxFQUFFLFFBQVEsR0FBRyxRQUFRLENBRS9EIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmF0dXJlX3V0aWxzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcDJwL3NpZ25hdHVyZV91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFHcEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUVuRixPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBaUIsTUFBTSxNQUFNLENBQUM7QUFHL0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFbEQsTUFBTSxNQUFNLHlCQUF5QixHQUNqQyxlQUFlLEdBQ2Ysb0JBQW9CLEdBQ3BCLHVCQUF1QixHQUN2Qix3QkFBd0IsR0FDeEIsV0FBVyxDQUFDO0FBRWhCLE1BQU0sTUFBTSw0QkFBNEIsR0FBRztJQUN6QyxPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLGFBQWEsRUFBRSxVQUFVLENBQUM7Q0FDM0IsQ0FBQztBQUVGLGVBQU8sTUFBTSxvQ0FBb0MsRUFBRSw0QkFHbEQsQ0FBQztBQUVGLGVBQU8sTUFBTSxrQ0FBa0MsRUFBRSxNQUFNLENBQUMsNEJBQTRCLENBR2xGLENBQUM7QUFFSCxNQUFNLFdBQVcsUUFBUTtJQUN2QixRQUFRLENBQUMsV0FBVyxFQUFFLHlCQUF5QixDQUFDO0lBQ2hELFFBQVEsQ0FBQyxnQkFBZ0IsRUFBRSw0QkFBNEIsQ0FBQztJQUN4RCxnQkFBZ0IsSUFBSSxNQUFNLENBQUM7Q0FDNUI7QUFFRCx3QkFBZ0Isa0NBQWtDLENBQ2hELENBQUMsRUFBRSw0QkFBNEIsRUFDL0IsQ0FBQyxFQUFFLDRCQUE0QixHQUM5QixPQUFPLENBRVQ7QUFFRCx3QkFBZ0IscUNBQXFDLENBQUMsR0FBRyxFQUFFLDRCQUE0QixHQUFHLE1BQU0sQ0FFL0Y7QUFFRCx3QkFBZ0IsZ0NBQWdDLENBQUMsTUFBTSxFQUFFLFlBQVksR0FBRyw0QkFBNEIsQ0FJbkc7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQWdCLHdCQUF3QixDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLDRCQUE0QixHQUFHLE9BQU8sQ0FFNUc7QUFxQkQsd0JBQWdCLCtDQUErQyxDQUM3RCxXQUFXLEVBQUUsUUFBUSxFQUNyQixJQUFJLEVBQUUseUJBQXlCLEVBQy9CLE9BQU8sRUFBRSw0QkFBNEIsR0FDcEMsbUJBQW1CLENBY3JCO0FBRUQsd0JBQWdCLGlDQUFpQyxDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsbUJBQW1CLENBR3pGO0FBRUQsd0JBQWdCLGtDQUFrQyxDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsUUFBUSxDQUUvRTtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQWdCLHlCQUF5QixDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFNBQVMsR0FBRyxVQUFVLEdBQUcsU0FBUyxDQUcxRztBQUVELHdCQUFnQix5QkFBeUIsQ0FBQyxDQUFDLEVBQUUsUUFBUSxHQUFHLFFBQVEsQ0FFL0QifQ==

package/dest/p2p/signature_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signature_utils.d.ts","sourceRoot":"","sources":["../../src/p2p/signature_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAEnF,OAAO,EAAE,KAAK,mBAAmB,EAAiB,MAAM,MAAM,CAAC;AAG/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,MAAM,MAAM,yBAAyB,GACjC,eAAe,GACf,oBAAoB,GACpB,uBAAuB,GACvB,wBAAwB,GACxB,WAAW,CAAC;AAEhB,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,4BAGlD,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,4BAA4B,CAGlF,CAAC;AAEH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAC;IAChD,QAAQ,CAAC,gBAAgB,EAAE,4BAA4B,CAAC;IACxD,gBAAgB,IAAI,MAAM,CAAC;CAC5B;AAED,wBAAgB,kCAAkC,CAChD,CAAC,EAAE,4BAA4B,EAC/B,CAAC,EAAE,4BAA4B,GAC9B,OAAO,CAET;AAED,wBAAgB,qCAAqC,CAAC,GAAG,EAAE,4BAA4B,GAAG,MAAM,CAE/F;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,YAAY,GAAG,4BAA4B,CAInG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,4BAA4B,GAAG,OAAO,CAE5G;AAqBD,wBAAgB,+CAA+C,CAC7D,WAAW,EAAE,QAAQ,EACrB,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,4BAA4B,GACpC,mBAAmB,CAcrB;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,CAGzF;AAED,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAE/E;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAG1G;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAE/D"}
+{"version":3,"file":"signature_utils.d.ts","sourceRoot":"","sources":["../../src/p2p/signature_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAEnF,OAAO,EAAE,KAAK,mBAAmB,EAAiB,MAAM,MAAM,CAAC;AAG/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,MAAM,MAAM,yBAAyB,GACjC,eAAe,GACf,oBAAoB,GACpB,uBAAuB,GACvB,wBAAwB,GACxB,WAAW,CAAC;AAEhB,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,4BAGlD,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,4BAA4B,CAGlF,CAAC;AAEH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAC;IAChD,QAAQ,CAAC,gBAAgB,EAAE,4BAA4B,CAAC;IACxD,gBAAgB,IAAI,MAAM,CAAC;CAC5B;AAED,wBAAgB,kCAAkC,CAChD,CAAC,EAAE,4BAA4B,EAC/B,CAAC,EAAE,4BAA4B,GAC9B,OAAO,CAET;AAED,wBAAgB,qCAAqC,CAAC,GAAG,EAAE,4BAA4B,GAAG,MAAM,CAE/F;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,YAAY,GAAG,4BAA4B,CAInG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,4BAA4B,GAAG,OAAO,CAE5G;AAqBD,wBAAgB,+CAA+C,CAC7D,WAAW,EAAE,QAAQ,EACrB,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,4BAA4B,GACpC,mBAAmB,CAcrB;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,CAGzF;AAED,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAE/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAG1G;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAE/D"}

package/dest/p2p/signature_utils.js

@@ -112,7 +112,15 @@ export function getCoordinationSignatureTypedData(signable) {
 export function getHashedSignaturePayloadTypedData(signable) {
     return Buffer32.fromString(hashTypedData(getCoordinationSignatureTypedData(signable)));
 }
-export function recoverCoordinationSigner(signable, signature) {
+/**
+ * Recovers the sender of a gossiped coordination message. Deliberately lenient (allowYParityAsV): a
+ * signature whose recovery byte is in yParity form (v ∈ {0, 1}) still resolves to its sender, so the P2P
+ * layer can attribute and accept it and then canonicalize on ingress (CheckpointAttestation.
+ * withNormalizedSignature, A-1351) before it reaches the L1 bundle. This is intentionally looser than
+ * on-chain checkpoint validation (getAttestationInfoFromPayload), which recovers strictly to mirror L1's
+ * ECDSA.recover — do not unify the two. These proposal/attestation signatures are P2P-only and never reach
+ * L1 verbatim, so leniency here cannot leak a non-canonical byte onto L1.
+ */ export function recoverCoordinationSigner(signable, signature) {
     const digest = getHashedSignaturePayloadTypedData(signable);
     return tryRecoverAddress(digest, signature, {
         allowYParityAsV: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "5.0.0-nightly.20260707",
+  "version": "5.0.0-nightly.20260708",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -92,13 +92,13 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "5.0.0-nightly.20260707",
-    "@aztec/blob-lib": "5.0.0-nightly.20260707",
-    "@aztec/constants": "5.0.0-nightly.20260707",
-    "@aztec/ethereum": "5.0.0-nightly.20260707",
-    "@aztec/foundation": "5.0.0-nightly.20260707",
-    "@aztec/l1-artifacts": "5.0.0-nightly.20260707",
-    "@aztec/noir-noirc_abi": "5.0.0-nightly.20260707",
+    "@aztec/bb.js": "5.0.0-nightly.20260708",
+    "@aztec/blob-lib": "5.0.0-nightly.20260708",
+    "@aztec/constants": "5.0.0-nightly.20260708",
+    "@aztec/ethereum": "5.0.0-nightly.20260708",
+    "@aztec/foundation": "5.0.0-nightly.20260708",
+    "@aztec/l1-artifacts": "5.0.0-nightly.20260708",
+    "@aztec/noir-noirc_abi": "5.0.0-nightly.20260708",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.15.1",
     "json-stringify-deterministic": "1.0.12",

package/src/block/attestation_info.ts

@@ -60,9 +60,14 @@ export function getAttestationInfoFromPayload(
       return { address: attestation.address, status: 'provided-as-address' as const };
     }
 
-    // Try to recover address from signature
+    // Try to recover address from signature. Recover with default opts (no allowYParityAsV): a slot
+    // whose recovery byte is in yParity form (v ∈ {0, 1}) is judged invalid here, matching L1 proving
+    // (ValidatorSelectionLib.verifyAttestations → ECDSA.recover only accepts v ∈ {27, 28}). A malicious
+    // proposer that lands such a slot cannot have it silently treated as valid off-chain; it is routed to
+    // invalid-attestation and invalidated. The gossip receipt path (recoverCoordinationSigner) stays
+    // lenient with allowYParityAsV; A-1351 normalizes on pool ingress and before the L1 bundle.
     try {
-      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature, { allowYParityAsV: true });
+      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature);
       return { address: recoveredAddress, status: 'recovered-from-signature' as const };
     } catch {
       // Signature present but recovery failed

package/src/block/l2_block_source.ts

@@ -63,8 +63,18 @@ export type CheckpointQuery =
   | { slot: SlotNumber }
   | { tag: 'checkpointed' | 'proven' | 'finalized' };
 
-/** Query a range of confirmed checkpoints by start/limit or by epoch. */
-export type CheckpointsQuery = { from: CheckpointNumber; limit: number } | { epoch: EpochNumber };
+/**
+ * Query a range of confirmed checkpoints by start/limit, by slot anchor, or by epoch.
+ *
+ * The `fromSlot` variant walks the slot index: it returns up to `limit` checkpoints anchored at
+ * `fromSlot`, ordered nearest-first. With `reverse` it takes the checkpoints at or before the slot
+ * (descending); otherwise the checkpoints at or after it (ascending). Use `limit: 1, reverse: true`
+ * to find the latest checkpoint at or before a slot in a single range scan.
+ */
+export type CheckpointsQuery =
+  | { from: CheckpointNumber; limit: number }
+  | { fromSlot: SlotNumber; limit: number; reverse?: boolean }
+  | { epoch: EpochNumber };
 
 /**
  * Lookup a proposed (archiver-internal, not-yet-L1-confirmed) checkpoint.
@@ -81,6 +91,7 @@ export const CheckpointQuerySchema: z.ZodType<CheckpointQuery, unknown> = z.unio
 
 export const CheckpointsQuerySchema: z.ZodType<CheckpointsQuery, unknown> = z.union([
   z.object({ from: CheckpointNumberSchema, limit: z.number().int().min(1) }).strict(),
+  z.object({ fromSlot: SlotNumberSchema, limit: z.number().int().min(1), reverse: z.boolean().optional() }).strict(),
   z.object({ epoch: EpochNumberSchema }).strict(),
 ]);
 

package/src/block/proposal/attestations_and_signers.ts

@@ -1,5 +1,5 @@
 import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
-import { hexToBuffer } from '@aztec/foundation/string';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
@@ -157,3 +157,45 @@ export class MaliciousCommitteeAttestationsAndSigners extends CommitteeAttestati
     return this.signers;
   }
 }
+
+/**
+ * Malicious extension of CommitteeAttestationsAndSigners that rewrites every non-proposer signature slot's
+ * recovery byte to yParity form (v ∈ {0, 1}) in the packed output, after the honest `packAttestations` has
+ * already canonicalized it to v ∈ {27, 28}. Models a malicious selected proposer that hand-crafts
+ * `propose()` calldata L1 accepts but no honest node can byte-replay: each rewritten signature still
+ * recovers to the same member (r, s and the recovery parity are preserved), the bitmap bits stay set, and
+ * `getSigners()` stays consistent, so `propose()` does not revert `SignersSizeMismatch` -- yet the
+ * checkpoint can never be proven (`ECDSA.recover` rejects v ∉ {27, 28}). The proposer's own slot is left
+ * canonical so L1 `verifyProposer` (which recovers that slot) still accepts the checkpoint. For testing only.
+ */
+export class MaliciousYParityCommitteeAttestationsAndSigners extends CommitteeAttestationsAndSigners {
+  constructor(
+    attestations: CommitteeAttestation[],
+    /** Committee index of the proposer's own slot, left canonical so `propose()` passes `verifyProposer`. */
+    private proposerIndex: number,
+    signatureContext: CoordinationSignatureContext,
+  ) {
+    super(attestations, signatureContext);
+  }
+
+  override getPackedAttestations(): ViemCommitteeAttestations {
+    const packed = super.getPackedAttestations();
+    const data = hexToBuffer(packed.signaturesOrAddresses);
+
+    // Walk the packed byte-vector and rewrite every non-proposer signed slot's v-byte to yParity form. A
+    // signed slot occupies 65 bytes (v, r, s); an empty slot occupies 20 bytes (address only).
+    let offset = 0;
+    for (let i = 0; i < this.attestations.length; i++) {
+      const isSigned = !this.attestations[i].signature.isEmpty();
+      if (isSigned && i !== this.proposerIndex) {
+        // `packAttestations` canonicalized v to 27/28; rewrite back to the equivalent yParity byte (0/1),
+        // preserving the recovery parity so the signature still recovers to the same member.
+        const v = data[offset];
+        data[offset] = v >= 27 ? v - 27 : v;
+      }
+      offset += isSigned ? 65 : 20;
+    }
+
+    return { signatureIndices: packed.signatureIndices, signaturesOrAddresses: bufferToHex(data) };
+  }
+}

package/src/block/validate_block_result.ts

@@ -1,7 +1,9 @@
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
@@ -30,6 +32,14 @@ export type ValidateCheckpointNegativeResult =
       attestors: EthAddress[];
       /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
+      /**
+       * The exact packed `CommitteeAttestations` tuple as posted to L1 calldata, carried verbatim so the
+       * invalidation evidence is byte-faithful to the stored `attestationsHash`. A repack via
+       * `packAttestations` is not a round-trip inverse of `fromPacked`, so it would diverge from the hash
+       * and revert `invalidateBadAttestation`/`invalidateInsufficientAttestations`. Always populated on the
+       * calldata validation path, the only production source of invalidation evidence.
+       */
+      verbatimAttestations: ViemCommitteeAttestations;
       /** Reason for the checkpoint being invalid: not enough attestations were posted */
       reason: 'insufficient-attestations';
     }
@@ -47,6 +57,12 @@ export type ValidateCheckpointNegativeResult =
       attestors: EthAddress[];
       /** Committee attestations for this checkpoint as they were posted to L1 */
       attestations: CommitteeAttestation[];
+      /**
+       * The exact packed `CommitteeAttestations` tuple as posted to L1 calldata, carried verbatim so the
+       * invalidation evidence is byte-faithful to the stored `attestationsHash`. See the same field on the
+       * insufficient-attestations variant for why a repack cannot be used.
+       */
+      verbatimAttestations: ViemCommitteeAttestations;
       /** Reason for the checkpoint being invalid: an invalid attestation was posted */
       reason: 'invalid-attestation';
       /** Index in the attestations array of the invalid attestation posted */
@@ -56,6 +72,12 @@ export type ValidateCheckpointNegativeResult =
 /** Result type for validating checkpoint attestations */
 export type ValidateCheckpointResult = { valid: true } | ValidateCheckpointNegativeResult;
 
+/** Zod schema for the raw packed `CommitteeAttestations` viem tuple (two 0x-prefixed hex strings). */
+const ViemCommitteeAttestationsSchema: ZodFor<ViemCommitteeAttestations> = z.object({
+  signatureIndices: schemas.HexStringWith0x,
+  signaturesOrAddresses: schemas.HexStringWith0x,
+});
+
 export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> = z.union([
   z.object({ valid: z.literal(true) }),
   z.object({
@@ -66,6 +88,7 @@ export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> =
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
+    verbatimAttestations: ViemCommitteeAttestationsSchema,
     reason: z.literal('insufficient-attestations'),
   }),
   z.object({
@@ -76,6 +99,7 @@ export const ValidateCheckpointResultSchema: ZodFor<ValidateCheckpointResult> =
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
+    verbatimAttestations: ViemCommitteeAttestationsSchema,
     reason: z.literal('invalid-attestation'),
     invalidIndex: z.number(),
   }),
@@ -87,6 +111,8 @@ export function serializeValidateCheckpointResult(result: ValidateCheckpointResu
   }
 
   const checkpointBuffer = serializeCheckpointInfo(result.checkpoint);
+  const signatureIndices = hexToBuffer(result.verbatimAttestations.signatureIndices);
+  const signaturesOrAddresses = hexToBuffer(result.verbatimAttestations.signaturesOrAddresses);
   return serializeToBuffer(
     result.valid,
     result.reason,
@@ -101,6 +127,10 @@ export function serializeValidateCheckpointResult(result: ValidateCheckpointResu
     result.attestations.length,
     result.attestations,
     result.reason === 'invalid-attestation' ? result.invalidIndex : 0,
+    signatureIndices.length,
+    signatureIndices,
+    signaturesOrAddresses.length,
+    signaturesOrAddresses,
   );
 }
 
@@ -118,10 +148,26 @@ export function deserializeValidateCheckpointResult(bufferOrReader: Buffer | Buf
   const attestors = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
   const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
   const invalidIndex = reader.readNumber();
+  const verbatimAttestations: ViemCommitteeAttestations = {
+    signatureIndices: bufferToHex(reader.readBuffer()),
+    signaturesOrAddresses: bufferToHex(reader.readBuffer()),
+  };
+
   if (reason === 'insufficient-attestations') {
-    return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations };
+    return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations, verbatimAttestations };
   } else if (reason === 'invalid-attestation') {
-    return { valid, reason, checkpoint, committee, epoch, seed, attestors, invalidIndex, attestations };
+    return {
+      valid,
+      reason,
+      checkpoint,
+      committee,
+      epoch,
+      seed,
+      attestors,
+      invalidIndex,
+      attestations,
+      verbatimAttestations,
+    };
   } else {
     const _: never = reason;
     throw new Error(`Unknown reason: ${reason}`);

package/src/config/network-consensus-config.ts

@@ -1,4 +1,4 @@
-import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { type L1ContractsConfig, l1ContractsConfigMappings, validateSlotDurations } from '@aztec/ethereum/config';
 import { type EnvVar, pickConfigMappings } from '@aztec/foundation/config';
 
 import type { SequencerConfig } from '../interfaces/configs.js';
@@ -156,21 +156,10 @@ export function validateNetworkConsensusConfig(config: NetworkConsensusConfig):
     return errors;
   }
 
-  if (config.ethereumSlotDuration <= 0) {
-    errors.push(`ethereumSlotDuration must be positive (got ${config.ethereumSlotDuration})`);
-  }
+  errors.push(...validateSlotDurations(config));
   if (config.blockDurationMs <= 0) {
     errors.push(`blockDurationMs must be positive (got ${config.blockDurationMs})`);
   }
-  if (config.aztecSlotDuration <= 0) {
-    errors.push(`aztecSlotDuration must be positive (got ${config.aztecSlotDuration})`);
-  }
-  if (config.ethereumSlotDuration > 0 && config.aztecSlotDuration % config.ethereumSlotDuration !== 0) {
-    errors.push(
-      `aztecSlotDuration (${config.aztecSlotDuration}s) must be a multiple of ethereumSlotDuration ` +
-        `(${config.ethereumSlotDuration}s)`,
-    );
-  }
   if (config.blockDurationMs / 1000 > config.aztecSlotDuration) {
     errors.push(
       `blockDurationMs (${config.blockDurationMs}ms) exceeds aztecSlotDuration (${config.aztecSlotDuration}s)`,

package/src/database-version/version_manager.ts

@@ -6,11 +6,20 @@ import { join } from 'path';
 
 import { DatabaseVersion } from './database_version.js';
 
-export type DatabaseVersionManagerFs = Pick<typeof fs, 'readFile' | 'writeFile' | 'rm' | 'mkdir'>;
+export type DatabaseVersionManagerFs = Pick<typeof fs, 'readFile' | 'rm' | 'mkdir' | 'rename' | 'open'>;
 
 export const DATABASE_VERSION_FILE_NAME = 'db_version';
 export type SchemaVersionMismatchPolicy = 'reset' | 'throw';
 
+/**
+ * How to react when the version file exists but cannot be read (permissions, IO error, truncation).
+ * `'reset'` (default) treats the store as unversioned and lets the reset path run — safe for stores
+ * where an empty state is legitimate. `'throw'` refuses to open, leaving data untouched — required
+ * for protection stores (e.g. signing protection) that must never be silently wiped by a transient
+ * filesystem error. A genuinely missing file (ENOENT) is a first boot and is never affected by this.
+ */
+export type VersionFileReadFailurePolicy = 'reset' | 'throw';
+
 export type DatabaseVersionManagerOptions<T> = {
   schemaVersion: number;
   rollupAddress: EthAddress;
@@ -18,6 +27,7 @@ export type DatabaseVersionManagerOptions<T> = {
   onOpen: (dataDir: string) => Promise<T>;
   onUpgrade?: (dataDir: string, currentVersion: number, latestVersion: number) => Promise<void>;
   schemaVersionMismatchPolicy?: SchemaVersionMismatchPolicy;
+  versionFileReadFailurePolicy?: VersionFileReadFailurePolicy;
   fileSystem?: DatabaseVersionManagerFs;
   log?: Logger;
 };
@@ -37,6 +47,7 @@ export class DatabaseVersionManager<T> {
   private onOpen: (dataDir: string) => Promise<T>;
   private onUpgrade?: (dataDir: string, currentVersion: number, latestVersion: number) => Promise<void>;
   private schemaVersionMismatchPolicy: SchemaVersionMismatchPolicy;
+  private versionFileReadFailurePolicy: VersionFileReadFailurePolicy;
   private fileSystem: DatabaseVersionManagerFs;
   private log: Logger;
 
@@ -47,8 +58,11 @@ export class DatabaseVersionManager<T> {
    * @param rollupAddress - The rollup contract address
    * @param dataDirectory - The directory where version information will be stored
    * @param onOpen - A callback to the open the database at the given location
-   * @param onUpgrade - An optional callback to upgrade the database before opening. If not provided it will reset the database
+   * @param onUpgrade - An optional callback to upgrade the database before opening. If not provided it will reset the
+   *   database. Must be idempotent: since the version marker is written only after a successful open, a crash after
+   *   onUpgrade but before the marker is written re-runs onUpgrade on the next start.
    * @param schemaVersionMismatchPolicy - Whether schema mismatches should reset data or throw
+   * @param versionFileReadFailurePolicy - Whether an unreadable (non-missing) version file should reset data or throw
    * @param fileSystem - An interface to access the filesystem
    * @param log - Optional custom logger
    * @param options - Configuration options
@@ -60,6 +74,7 @@ export class DatabaseVersionManager<T> {
     onOpen,
     onUpgrade,
     schemaVersionMismatchPolicy = 'reset',
+    versionFileReadFailurePolicy = 'reset',
     fileSystem = fs,
     log = createLogger(`foundation:version-manager`),
   }: DatabaseVersionManagerOptions<T>) {
@@ -74,13 +89,40 @@ export class DatabaseVersionManager<T> {
     this.onOpen = onOpen;
     this.onUpgrade = onUpgrade;
     this.schemaVersionMismatchPolicy = schemaVersionMismatchPolicy;
+    this.versionFileReadFailurePolicy = versionFileReadFailurePolicy;
     this.fileSystem = fileSystem;
     this.log = log;
   }
 
   static async writeVersion(version: DatabaseVersion, dataDir: string, fileSystem: DatabaseVersionManagerFs = fs) {
     await fileSystem.mkdir(dataDir, { recursive: true });
-    return fileSystem.writeFile(join(dataDir, DatabaseVersionManager.VERSION_FILE), version.toBuffer());
+    const finalPath = join(dataDir, DatabaseVersionManager.VERSION_FILE);
+    const tmpPath = `${finalPath}.tmp`;
+
+    // Atomic durable write: fill a temp file, fsync it, then rename it into place. The marker only
+    // becomes visible under its final name once its bytes are durably on disk, so a crash mid-write
+    // can never leave a "valid" version file sitting over an empty or partially-populated data dir.
+    const handle = await fileSystem.open(tmpPath, 'w');
+    try {
+      await handle.writeFile(version.toBuffer());
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await fileSystem.rename(tmpPath, finalPath);
+
+    // Best-effort fsync of the containing directory so the rename itself survives a crash. Not all
+    // filesystems support directory fsync, so a failure here is non-fatal.
+    try {
+      const dirHandle = await fileSystem.open(dataDir, 'r');
+      try {
+        await dirHandle.sync();
+      } finally {
+        await dirHandle.close();
+      }
+    } catch {
+      // directory fsync is best-effort
+    }
   }
 
   /**
@@ -105,6 +147,17 @@ export class DatabaseVersionManager<T> {
         storedVersion = DatabaseVersion.empty();
         // only turn off these logs if the data dir didn't exist before
         shouldLogDataReset = false;
+      } else if (this.versionFileReadFailurePolicy === 'throw') {
+        // The version file exists but could not be read/parsed (permissions, IO error, truncation).
+        // Treating this as "unversioned" would reset the data directory, silently wiping a store that
+        // must fail closed. Refuse to open instead, leaving the data untouched for the operator.
+        const code = (err as Error & { code?: string })?.code;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Failed to read database version file at ${this.versionFile} (${code ?? 'unknown error'}: ${message}). ` +
+            `Refusing to open the database; data was NOT reset. Resolve the underlying filesystem error and retry.`,
+          { cause: err },
+        );
       } else {
         this.log.warn(`Failed to read stored version information: ${err}. Defaulting to empty version`);
         storedVersion = DatabaseVersion.empty();
@@ -159,10 +212,47 @@ export class DatabaseVersionManager<T> {
       await this.resetDataDirectory();
     }
 
-    // Write the current version to disk
-    await this.writeVersion();
+    // Open the database first, then record the version marker. Writing the marker only after a
+    // successful open makes it a post-commit record: if the process crashes between the reset and a
+    // durable open, no marker is left behind, so the next startup re-runs the reset instead of
+    // trusting a marker that sits over empty or partially-initialized data.
+    const instance = await this.onOpen(this.dataDirectory);
 
-    return [await this.onOpen(this.dataDirectory), needsReset];
+    // Only (re)write the marker when it would actually change — first boot, reset, or upgrade. On a
+    // normal boot it already matches, so skipping avoids an unnecessary fsync (and the directory
+    // write permission the temp-file+rename needs) and, more importantly, any window where a
+    // marker-write failure would orphan the database we just opened.
+    if (!storedVersion.equals(this.currentVersion)) {
+      try {
+        await this.writeVersion();
+      } catch (err) {
+        // The database opened but recording the marker failed; close the freshly opened instance so
+        // we do not leak its file handles / locks before propagating the failure.
+        await this.closeQuietly(instance);
+        throw err;
+      }
+    }
+
+    return [instance, needsReset];
+  }
+
+  /**
+   * Best-effort close of a just-opened database instance, used to avoid leaking handles/locks when a
+   * post-open step fails. Swallows close errors so the original failure is the one that propagates.
+   */
+  private async closeQuietly(instance: T): Promise<void> {
+    const closable = instance as
+      | { close?: () => Promise<void> | void; [Symbol.asyncDispose]?: () => Promise<void> }
+      | undefined;
+    const dispose = closable?.close ?? closable?.[Symbol.asyncDispose];
+    if (typeof dispose !== 'function') {
+      return;
+    }
+    try {
+      await dispose.call(closable);
+    } catch (err) {
+      this.log.warn(`Failed to close database after version-write failure: ${err}`);
+    }
   }
 
   /**

package/src/ha-signing/config.ts

@@ -25,8 +25,20 @@ export type BaseSignerConfig = {
   nodeId: string;
   /** How long to wait between polls when a duty is being signed (ms) */
   pollingIntervalMs: number;
-  /** Maximum time to wait for a duty being signed to complete (ms) */
-  signingTimeoutMs: number;
+  /**
+   * How long (ms) to wait for a peer node's in-progress signing before giving up and treating the
+   * duty as already handled. This is the cross-node wait/poll timeout, distinct from
+   * signerCallTimeoutMs (the hard upper bound on this node's own signer call).
+   */
+  peerSigningTimeoutMs: number;
+  /**
+   * Hard upper bound (ms) on a single signer call made by this node. If the (possibly remote)
+   * signer does not return within this time, the call is aborted, the duty lock is released, and
+   * signing fails so it can be safely retried. The effective value is clamped to
+   * maxStuckDutiesAgeMs / 2 at construction, so a slow signer's lock is always released before
+   * stuck-duty cleanup could reclaim it. Defaults to 30_000 when unset.
+   */
+  signerCallTimeoutMs?: number;
   /** Maximum age of a stuck duty in ms (defaults to 2x hardcoded Aztec slot duration if not set) */
   maxStuckDutiesAgeMs?: number;
   /** Optional: clean up old duties after this many hours (disabled if not set) */
@@ -44,11 +56,16 @@ export const baseSignerConfigMappings: ConfigMappingsType<BaseSignerConfig> = {
     description: 'The number of ms to wait between polls when a duty is being signed',
     ...numberConfigHelper(100),
   },
-  signingTimeoutMs: {
+  peerSigningTimeoutMs: {
     env: 'VALIDATOR_HA_SIGNING_TIMEOUT_MS',
-    description: 'The maximum time to wait for a duty being signed to complete',
+    description: "How long to wait for a peer node's in-progress signing before giving up",
     ...numberConfigHelper(3_000),
   },
+  signerCallTimeoutMs: {
+    env: 'VALIDATOR_SIGNER_CALL_TIMEOUT_MS',
+    description: 'Hard upper bound in ms on a single signer call before it is aborted (default 30000)',
+    ...numberConfigHelper(30_000),
+  },
   maxStuckDutiesAgeMs: {
     env: 'VALIDATOR_HA_MAX_STUCK_DUTIES_AGE_MS',
     description: 'The maximum age of a stuck duty in ms (defaults to 2x Aztec slot duration)',
@@ -65,7 +82,8 @@ export const baseSignerConfigMappings: ConfigMappingsType<BaseSignerConfig> = {
 export const BaseSignerConfigSchema = z.object({
   nodeId: z.string(),
   pollingIntervalMs: z.number().min(0),
-  signingTimeoutMs: z.number().min(0),
+  peerSigningTimeoutMs: z.number().min(0),
+  signerCallTimeoutMs: z.number().min(0).optional(),
   maxStuckDutiesAgeMs: z.number().min(0).optional(),
   cleanupOldDutiesAfterHours: z.number().min(0).optional(),
   ...pickL1ContractAddressesSchema('rollupAddress'),