@sig-net/midnight 0.24.0-rc.2 → 0.24.0-rc.3

package/dist/signet-requests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signet-requests.d.ts","sourceRoot":"","sources":["../src/signet-requests.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,WAAW,EAGjB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAGvE,YAAY,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAMnE;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,SAAS,CAAY,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB,sFAAsF;aACtF,QAAQ,EAAE,CAAC;IACX;;;;OAIG;aACH,QAAQ,EAAE,CAAC;CACH,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAChC,4BAA4B;aAC5B,KAAK,EAAE,CAAC;IACR,0EAA0E;aAC1E,QAAQ,EAAE,CAAC;CACH,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB,sCAAsC;aACtC,MAAM,EAAE,CAAC;IACT,0EAA0E;aAC1E,QAAQ,EAAE,CAAC;CACH,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB,CAAC,QAAQ,GAAG,gBAAgB;IAC5D,+EAA+E;IAC/E,MAAM,EAAE,eAAe,CAAC;IACxB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,IAAI,EAAE,UAAU,CAAC;IACjB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,EAAE,QAAQ,CAAC;IACnB,8HAA8H;IAC9H,aAAa,EAAE,UAAU,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB,CAAC,QAAQ,GAAG,gBAAgB;IACjE,+EAA+E;IAC/E,MAAM,EAAE,eAAe,CAAC;IACxB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,IAAI,EAAE,UAAU,CAAC;IACjB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,MAAM,EAAE,UAAU,CAAC;IACnB,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,EAAE,QAAQ,CAAC;IACnB,8HAA8H;IAC9H,aAAa,EAAE,UAAU,CAAC;IAC1B,6FAA6F;IAC7F,2BAA2B,EAAE,UAAU,CAAC;IACxC,mFAAmF;IACnF,0BAA0B,EAAE,UAAU,CAAC;CACxC;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EACtD,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,GAC9B,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAU1C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAC3D,QAAQ,EAAE,WAAW,CAAC,QAAQ,CAAC,EAC/B,wBAAwB,EAAE,MAAM,EAChC,uBAAuB,EAAE,MAAM,GAC9B,WAAW,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAc/C;AAED;;;;GAIG;AACH,MAAM,WAAW,+BAAgC,SAAQ,QAAQ,CAC/D;IAAC,SAAS;IAAE,sBAAsB;CAAC,CACpC;IACC,wDAAwD;IACxD,OAAO,IAAI,OAAO,CAAC;IACnB,gDAAgD;IAChD,IAAI,IAAI,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IACtC;;;;OAIG;IACH,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,sBAAsB,CAAC;CACtD;AAED,OAAO,CAAC,MAAM,iBAAiB,EAAE,OAAO,MAAM,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAClC,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;CACpC,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,2BAA2B,GAAG,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,YAAY,CAE/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAM7D;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,YAAY,GAAG,SAAS,CAE1D;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,QAAQ,CAAC,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC,GACzD,2BAA2B,CAM7B"}
+{"version":3,"file":"signet-requests.d.ts","sourceRoot":"","sources":["../src/signet-requests.ts"],"names":[],"mappings":"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"}

package/dist/signet-requests.js

@@ -91,30 +91,22 @@ const TX_PARAM_TYPE = new CompactTypeEnum(1, 1);
 const MPC_SIGNATURE_ALGORITHM = new CompactTypeEnum(1, 1);
 const MPC_DESTINATION = new CompactTypeEnum(1, 1);
 /**
- * Descriptor of {@link RequestIdPreimage} over ANY tx-params decomposition:
- * the TS analogue of Compact's generic `RequestIdPreimage`, what
- * `calculateRequestId` (signet-request-id.ts) hashes. Field order is the
- * Compact struct's, a subsequence of {@link signBidirectionalEventDescriptorWith}'s.
- *
- * @param txParams - Descriptor of the tx-params decomposition, already at
- *   its capacity instantiation.
- * @returns The preimage descriptor.
+ * Descriptor of {@link RequestIdPreimage}: what {@link calculateRequestId}
+ * hashes, in Compact declaration order.
  */
-export function requestIdPreimageDescriptorWith(txParams) {
-    return compactStructDescriptor({
-        sender: CONTRACT_ADDRESS,
-        keyVersion: UINT_8,
-        path: BYTES_32,
-        algo: MPC_SIGNATURE_ALGORITHM,
-        txParamType: TX_PARAM_TYPE,
-        txParams,
-        executionDest: BYTES_32,
-    });
-}
+export const requestIdPreimageDescriptor = compactStructDescriptor({
+    keyVersion: UINT_8,
+    sender: CONTRACT_ADDRESS,
+    path: BYTES_32,
+    algo: MPC_SIGNATURE_ALGORITHM,
+    txParamType: TX_PARAM_TYPE,
+    txParamsDigest: BYTES_32,
+    executionDest: BYTES_32,
+});
 /**
  * Descriptor of {@link SignBidirectionalEvent} over ANY tx-params
  * decomposition: the TS analogue of Compact's generic
- * `SignBidirectionalEvent`. Each decomposition wraps this with its own
+ * `SignBidirectionalEventV1`. Each decomposition wraps this with its own
  * capacity-parameterised convenience (see `signBidirectionalEventDescriptor`
  * in signet-evtype2tx-requests.ts for the EVM Type-2 one).
  *
@@ -128,15 +120,15 @@ export function requestIdPreimageDescriptorWith(txParams) {
  */
 export function signBidirectionalEventDescriptorWith(txParams, lenOutputDeserialization, lenRespondSerialization) {
     return compactStructDescriptor({
-        sender: CONTRACT_ADDRESS,
         keyVersion: UINT_8,
+        sender: CONTRACT_ADDRESS,
         path: BYTES_32,
         algo: MPC_SIGNATURE_ALGORITHM,
-        signatureDest: MPC_DESTINATION,
-        params: BYTES_64,
         txParamType: TX_PARAM_TYPE,
         txParams,
         executionDest: BYTES_32,
+        signatureDest: MPC_DESTINATION,
+        params: BYTES_64,
         outputDeserializationSchema: new CompactTypeBytes(lenOutputDeserialization),
         respondSerializationSchema: new CompactTypeBytes(lenRespondSerialization),
     });

package/dist/signet-requests.js.map

@@ -1 +1 @@
-{"version":3,"file":"signet-requests.js","sourceRoot":"","sources":["../src/signet-requests.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"signet-requests.js","sourceRoot":"","sources":["../src/signet-requests.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sig-net/midnight",
-  "version": "0.24.0-rc.2",
+  "version": "0.24.0-rc.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/sig-net/midnight-integration",
@@ -49,7 +49,7 @@
     "@midnight-ntwrk/compact-runtime": "0.18.0-rc.1",
     "@midnight-ntwrk/midnight-js-types": "5.0.0-beta.6",
     "@noble/curves": "^2.2.0",
-    "@sig-net/midnight-serde": "^0.24.0-rc.2",
+    "@sig-net/midnight-serde": "^0.24.0-rc.3",
     "ethers": "^6.17.0"
   },
   "devDependencies": {

package/src/Signet.compact

@@ -18,17 +18,23 @@
 //   import "@sig-net/midnight/src/Signet";
 //
 //  Key types at a glance (each declaration below carries the full contract):
-//  - SignBidirectionalEvent: a client contract's structured request for a signature on a transaction.
-//  - RequestId: 32-byte id of a request, the transientHash of its RequestIdPreimage (the record
-//    minus the serialisation schemas).
-//  - SignBidirectionalEventMap: the RequestId -> SignBidirectionalEvent map a client contract
+//  - SignBidirectionalEventV1: a client contract's structured request for a signature on a transaction.
+//  - RequestId: 32-byte id of a request, the transientHash of its RequestIdPreimageV1 (the fields
+//    that name one execution: key, sender, path, a digest of the transaction and its destination).
+//  - SignBidirectionalEventMapV1: the RequestId -> SignBidirectionalEventV1 map a client contract
 //    declares in its own ledger for the MPC to read requests from.
 //  - SignetSigner: the contract interface client contracts call to notify the Signet singleton.
-//  - SignBidirectionalEventNotification: the versioned notification delivered through that call.
-//  - SignatureRespondedEvent: the MPC's posted signature answering a request.
-//  - RespondBidirectionalEvent: the MPC's posted attestation that the foreign chain executed the
+//  - SignBidirectionalEventNotification: the notification delivered through that call, versioned by
+//    the version byte it carries.
+//  - SignatureRespondedEventV1: the MPC's posted signature answering a request.
+//  - RespondBidirectionalEventV1: the MPC's posted attestation that the foreign chain executed the
 //    signed transaction.
 //
+//  The V1 suffix marks the wire and hash-domain artefacts of protocol version 1 (the structs the
+//  ledger stores and the singleton emits, and the circuits that hash or verify them). Vocabulary
+//  shared across versions (RequestId, OutputKind, Signature, the enums, the transaction parameter
+//  structs, which TxParamType tags) and the version-tagged notification carry no suffix.
+//
 // These key types are best understood within the sign bidirectional flow that they enable:
 // 1. Client contract stores a SignBidirectionalEvent in a SignBidirectionalEventMap in its own ledger
 //    (against the calculated RequestId) and requests a signature from the MPC via a cross contract call
@@ -67,10 +73,8 @@ module Signet {
   //
   // KEY: texual order of the fields in this structure must remain fixed as is as their order
   //      is relied upon for consistent hashing and decoding from ledger state.
-  export struct SignBidirectionalEvent<TxParams, #LenOutputDeserialization, #LenRespondSerialization> {
-    // Address of the client contract that stores and notifies of this SignBidirectionalEvent.
-    // Set with kernel.self().
-    sender: ContractAddress;
+  export struct SignBidirectionalEventV1<TxParams, #LenOutputDeserialization, #LenRespondSerialization> {
+    // ---- RequestIdPreimageV1 fields: hashed into the request id, in this order ----
 
     // MPC Key Derivation Parameters.
     // Every key the MPC signs with is scoped by the requesting contract:
@@ -83,13 +87,13 @@ module Signet {
     // CRITICAL: the MPC renders the path as hex::encode(path) for key derivation (lowercase hex
     // of the full 32 bytes, no trimming, no 0x prefix). The sender is always part
     // of the derivation, so no contract can reach another contract's derived keys.
-    keyVersion: Uint<8>;      // MPC root-key version to derive from. Currently 1.
-    path: Bytes<32>;          // Key derivation path: 32 opaque bytes, client contract's choice.
+    keyVersion: Uint<8>;        // MPC root-key version to derive from. Currently 1.
+    sender: ContractAddress;    // Address of the client contract that stores and notifies of this
+                                // request. Set with kernel.self().
+    path: Bytes<32>;            // Key derivation path: 32 opaque bytes, client contract's choice.
 
     // MPC Parameters.
     algo: MPCSignatureAlgorithm;    // Signature algorithm scheme, e.g. ecdsa
-    signatureDest: MPCDestination;  // Destination field reserved for future use. Set to unused.
-    params: Bytes<64>;              // Extra MPC parameters reserved for future use. Zero-fill.
 
     // Specific destination chain Transaction parameters.
     txParamType: TxParamType;  // Off-chain tag indicating what type txParams is set to.
@@ -99,6 +103,11 @@ module Signet {
                                // (mainnet, Sepolia or a local anvil) uses ethereumCaip2Id():
                                // the network itself is txParams' chainId.
 
+    // ---- Protocol-only fields: outside the request id ----
+
+    signatureDest: MPCDestination;  // Destination field reserved for future use. Set to unused.
+    params: Bytes<64>;              // Extra MPC parameters reserved for future use. Zero-fill.
+
     // Serialisation Schemas.
     // outputDeserializationSchema tells the MPC how to deserialise the destination chain's
     // execution output (destination chain -> MPC). respondSerializationSchema tells the MPC
@@ -131,36 +140,37 @@ module Signet {
     reserved, // Reserved for future use. Exists to keep enum >= 2 (proof server bug).
   }
 
-  // Construction helper for the canonical Signet SignBidirectionalEvent.
-  export pure circuit constructSignBidirectionalEvent<TxParams, #LenOutputDeserialization, #LenRespondSerialization>(
-    sender: ContractAddress,
+  // Construction helper for the canonical Signet SignBidirectionalEventV1.
+  export pure circuit constructSignBidirectionalEventV1<TxParams, #LenOutputDeserialization, #LenRespondSerialization>(
     keyVersion: Uint<8>,
+    sender: ContractAddress,
     path: Bytes<32>,
     algo: MPCSignatureAlgorithm,
-    signatureDest: MPCDestination,
-    params: Bytes<64>,
     txParamType: TxParamType,
     txParams: TxParams,
     executionDest: Bytes<32>,
+    signatureDest: MPCDestination,
+    params: Bytes<64>,
     outputDeserializationSchema: Bytes<LenOutputDeserialization>,
     respondSerializationSchema: Bytes<LenRespondSerialization>,
-  ): SignBidirectionalEvent<TxParams, LenOutputDeserialization, LenRespondSerialization> {
+  ): SignBidirectionalEventV1<TxParams, LenOutputDeserialization, LenRespondSerialization> {
     assert(keyVersion >= 1, "keyVersion must be >= 1");
     // The protocol reserves the "midnight response key" path for the MPC's
-    // attestation key of this contract (see RespondBidirectionalEvent), and the
+    // attestation key of this contract (see RespondBidirectionalEventV1), and the
     // MPC refuses a request that names it.
     assert(path != pad(32, "midnight response key"), "path is reserved for the MPC response key");
 
-    return SignBidirectionalEvent<TxParams, LenOutputDeserialization, LenRespondSerialization> {
-      sender,
+    // Shorthand struct fields bind positionally: this list follows the declaration order.
+    return SignBidirectionalEventV1<TxParams, LenOutputDeserialization, LenRespondSerialization> {
       keyVersion,
+      sender,
       path,
       algo,
-      signatureDest,
-      params,
       txParamType,
       txParams,
       executionDest,
+      signatureDest,
+      params,
       outputDeserializationSchema,
       respondSerializationSchema,
     };
@@ -169,25 +179,27 @@ module Signet {
   // ---- SignBidirectionalEvent RequestId --------------------------------------------------------------
 
   // 32 byte chain agnostic nominal id of a SignBidirectionalEvent, calculated as the
-  // transientHash of its RequestIdPreimage (see calculateRequestId).
+  // transientHash of its RequestIdPreimageV1 (see calculateRequestIdV1).
   export new type RequestId = Bytes<32>;
 
-  // The fields of a SignBidirectionalEvent that name one execution: the requesting contract,
-  // the signing key (version, path, algorithm), the transaction and its execution destination.
-  // The serialisation schemas and the reserved MPC parameters (signatureDest, params) stay
-  // out, so two requests for one transaction cannot both be outstanding whatever schemas
-  // they declare, and the id does not depend on the schemas' declared widths either.
+  // The fields of a SignBidirectionalEventV1 that name one execution: the signing key
+  // (keyVersion, path, algo), the requesting contract, the transaction and its execution
+  // destination. Fields the execution does not depend on (the serialisation schemas and
+  // the reserved MPC parameters signatureDest and params) stay out. The transaction
+  // enters as a digest computed per TxParamType over its USED entries only
+  // (calculateEvmType2TxParamsDigestV1 for evmType2), so one execution has one id
+  // whatever capacities the requester compiled with and whatever sits in unused slots.
   //
-  // KEY: the field order follows SignBidirectionalEvent's and is relied upon for consistent
-  //      hashing. The TS twin (requestIdPreimageDescriptorWith in signet-requests.ts)
-  //      mirrors it field by field.
-  export struct RequestIdPreimage<TxParams> {
-    sender: ContractAddress;
+  // KEY: the field order follows SignBidirectionalEventV1's and is relied upon for consistent
+  //      hashing. The TS twin (requestIdPreimageDescriptor in signet-requests.ts) mirrors it
+  //      field by field.
+  export struct RequestIdPreimageV1 {
     keyVersion: Uint<8>;
+    sender: ContractAddress;
     path: Bytes<32>;
     algo: MPCSignatureAlgorithm;
     txParamType: TxParamType;
-    txParams: TxParams;
+    txParamsDigest: Bytes<32>;
     executionDest: Bytes<32>;
   }
 
@@ -201,21 +213,10 @@ module Signet {
   //  - byte 31 is always zero. upgradeFromTransient writes the field element's 31
   //    little-endian bytes into bytes 0..30, so an id carries ~248 bits of entropy.
   //  - a Bytes<N> field packs into ceil(N/31) field elements, so trailing zero bytes
-  //    within a chunk do not change the hash. Widths here are fixed at compile time
-  //    and every id commits to its sender, so requests cannot collide in practice.
-  export pure circuit calculateRequestId<TxParams, #LenOutputDeserialization, #LenRespondSerialization>(
-    request: SignBidirectionalEvent<TxParams, LenOutputDeserialization, LenRespondSerialization>
-  ): RequestId {
-    const preimage = RequestIdPreimage<TxParams> {
-      sender: request.sender,
-      keyVersion: request.keyVersion,
-      path: request.path,
-      algo: request.algo,
-      txParamType: request.txParamType,
-      txParams: request.txParams,
-      executionDest: request.executionDest,
-    };
-    return upgradeFromTransient(transientHash<RequestIdPreimage<TxParams>>(preimage)) as RequestId;
+  //    within a chunk do not change the hash. Every id commits to its sender, so
+  //    requests cannot collide in practice.
+  export pure circuit calculateRequestIdV1(preimage: RequestIdPreimageV1): RequestId {
+    return upgradeFromTransient(transientHash<RequestIdPreimageV1>(preimage)) as RequestId;
   }
 
   // ---- Client Contract: SignBidirectionalEvent Map ---------------------------------------------------
@@ -224,7 +225,7 @@ module Signet {
   // in their ledger. Client contract tells MPC field location of this map when making a cross
   // contract call, via SignetSigner, to the Signet singleton. The MPC looks here to find
   // SignBidirectionalEvents.
-  export new type SignBidirectionalEventMap<TxParams, #LenOutputDeserialization, #LenRespondSerialization> = Map<RequestId, SignBidirectionalEvent<TxParams, LenOutputDeserialization, LenRespondSerialization>>;
+  export new type SignBidirectionalEventMapV1<TxParams, #LenOutputDeserialization, #LenRespondSerialization> = Map<RequestId, SignBidirectionalEventV1<TxParams, LenOutputDeserialization, LenRespondSerialization>>;
 
   // ---- Cross Contract SignBidirectionalEventNotification ---------------------------------------------
 
@@ -233,7 +234,7 @@ module Signet {
   export contract SignetSigner {
     // Called by client contracts to notify the MPC of a SignBidirectionalEvent.
     circuit signBidirectional(
-      // Canonical id of the SignBidirectionalEvent (calculate with calculateRequestId).
+      // Canonical id of the SignBidirectionalEvent (calculateEvmType2RequestIdV1 for evmType2).
       // Disclosed in the emitted notification event: the MPC looks this id up in the
       // caller's own request map.
       requestId: RequestId,
@@ -256,7 +257,7 @@ module Signet {
   // Construction helper for the V1 SignBidirectionalEventNotification.
   //
   // The payload is a pointer for the MPC: the contract that holds the
-  // SignBidirectionalEventMap (callerAddress) and the position of that map in
+  // SignBidirectionalEventMapV1 (callerAddress) and the position of that map in
   // the contract's raw ledger state tree (requestsPathDepth + requestsPath).
   //
   // Read the path from your contract's compiled artifacts, never derive it by
@@ -272,7 +273,7 @@ module Signet {
     // Number of meaningful entries in requestsPath: 1 for a flat (15 or fewer
     // field) contract, one more per chunk level after that (max 4).
     requestsPathDepth: Uint<8>,
-    // Resolved ledger-tree path of the caller's SignBidirectionalEventMap, from
+    // Resolved ledger-tree path of the caller's SignBidirectionalEventMapV1, from
     // its contract-info.json "index". Entries at and beyond requestsPathDepth
     // are zero.
     requestsPath: Vector<4, Uint<8>>
@@ -309,7 +310,7 @@ module Signet {
   // Counterpart to SignBidirectionalEvent: the MPC generated signature a request asked for.
   // Posted by the MPC through the Signet singleton for clients to extract and build a
   // signed transaction from.
-  export struct SignatureRespondedEvent {
+  export struct SignatureRespondedEventV1 {
     // The request this signature answers. Routing data: the singleton emits it
     // unverified, and a reader proves the signature against the request's own key.
     requestId: RequestId;
@@ -329,10 +330,10 @@ module Signet {
   //  mpcResponseKey = f(mpcRootKey[keyVersion], caip2ChainId, sender, "midnight response key")
   //
   // The output travels off chain and the digest is recomputed at verification
-  // time (verifyRespondBidirectionalEvent). The signature is the ONLY thing that
+  // time (verifyRespondBidirectionalEventV1). The signature is the ONLY thing that
   // distinguishes a genuine post from garbage: the singleton emits every post
   // unverified.
-  export struct RespondBidirectionalEvent {
+  export struct RespondBidirectionalEventV1 {
     // The request this attestation answers. Signed into the digest: a verified
     // post settles exactly the request it names, so a client consumes this id
     // and never one taken from elsewhere.
@@ -347,7 +348,7 @@ module Signet {
     // or unviable execution), so a client holding no output yet knows which
     // width to settle at.
     serializedOutputLength: Uint<64>;
-    // The attestation digest the signature is over (calculateSignetAttestationDigest),
+    // The attestation digest the signature is over (calculateSignetAttestationDigestV1),
     // so a reader holding no output can check the signature. The verifying
     // circuit recomputes it from the output and never reads this copy.
     digest: Bytes<32>;
@@ -370,8 +371,8 @@ module Signet {
   // transaction the attestation describes, in the destination chain's own
   // numbering (a slot on Solana).
   // Off-chain code uses the TypeScript twin:
-  //    import { calculateSignetAttestationDigest } from "@sig-net/midnight";
-  export pure circuit calculateSignetAttestationDigest<#serializedOutputLength>(
+  //    import { calculateSignetAttestationDigest } from "@sig-net/midnight/testing";
+  export pure circuit calculateSignetAttestationDigestV1<#serializedOutputLength>(
     requestId: RequestId,
     blockHeight: Uint<64>,
     outputKind: OutputKind,
@@ -397,12 +398,12 @@ module Signet {
   // that reduces to 0 mod the curve order aborts the
   // circuit rather than returning false, so sift candidate posts off chain
   // first (verifyRespondBidirectionalSignature).
-  export pure circuit verifyRespondBidirectionalEvent<#serializedOutputLength>(
+  export pure circuit verifyRespondBidirectionalEventV1<#serializedOutputLength>(
     serializedOutput: Bytes<serializedOutputLength>,
-    respondBidirectionalEvent: RespondBidirectionalEvent,
+    respondBidirectionalEvent: RespondBidirectionalEventV1,
     mpcResponseKey: Secp256k1Point
   ): Boolean {
-    const digest = calculateSignetAttestationDigest<serializedOutputLength>(
+    const digest = calculateSignetAttestationDigestV1<serializedOutputLength>(
       respondBidirectionalEvent.requestId,
       respondBidirectionalEvent.blockHeight,
       respondBidirectionalEvent.outputKind,
@@ -439,10 +440,11 @@ module Signet {
   //
   // Every variable-length part is a compile-time CAPACITY (a generic size
   // parameter the requesting contract fixes) plus a runtime count of how many
-  // leading slots are real. Unused capacity is hashed as part of the record
-  // (zero-fill) but never reaches the assembled transaction. Field order is
-  // the canonical EIP-1559 RLP order and the request-id hash order: part of
-  // the wire contract, each count directly before the slot it bounds.
+  // leading slots are real. Unused capacity sits in the ledger record but
+  // reaches neither the request id (calculateEvmType2TxParamsDigestV1 walks
+  // the used slots only) nor the assembled transaction. Field order is the
+  // canonical EIP-1559 RLP order and the digest order: part of the wire
+  // contract, each count directly before the slot it bounds.
   //
   // KEY: texual order of the fields in this structure must remain fixed as is as their order
   //      is relied upon for consistent hashing and decoding from ledger state.
@@ -464,7 +466,7 @@ module Signet {
   // raw 32-byte values, copied verbatim into the RLP encoding.
   //
   // KEY: texual order of the fields in this structure must remain fixed as is as their order
-  //      is relied upon for consistent hashing and decoding from ledger state.  
+  //      is relied upon for consistent hashing and decoding from ledger state.
   export struct EvmAccessListEntry<#maxStorageKeys> {
     address: Bytes<20>;
     storageKeyCount: Uint<8>; // how many leading storageKeys are real
@@ -479,13 +481,120 @@ module Signet {
   // canonical ABI words for common types.
   //
   // KEY: texual order of the fields in this structure must remain fixed as is as their order
-  //      is relied upon for consistent hashing and decoding from ledger state.  
+  //      is relied upon for consistent hashing and decoding from ledger state.
   export struct EvmCalldata<#maxWords> {
     selector: Bytes<4>;  // the literal first 4 calldata bytes
     noWords: Uint<16>;   // No. of used words in the words list
     words: Vector<maxWords, Bytes<32>>; // canonical ABI words (big-endian)
   }
 
+  // Digest of an EvmType2TxParams over the bytes that reach the signed transaction:
+  // the scalar fields, then the calldata words, access-list entries and storage keys
+  // up to their declared counts, each count hashed beside its entries so the encoding
+  // commits to its length. Slots past a count are skipped, and an absent calldata
+  // contributes only its absence, so one transaction has one digest whatever
+  // capacities the requester compiled its struct with and whatever bytes sit in
+  // unused slots. The counts must fit their capacities. Off-chain code uses the
+  // TypeScript twin calculateEvmType2TxParamsDigest in @sig-net/midnight.
+  //
+  // The slot walks are folds carrying the slot index and a running hash: a `for`
+  // over `0..n` has no index type at n = 0, and a zero capacity is the common case.
+  export pure circuit calculateEvmType2TxParamsDigestV1<#maxCalldataWords, #maxAccessListEntries, #maxStorageKeysPerEntry>(
+    txParams: EvmType2TxParams<maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry>
+  ): Bytes<32> {
+    // An absent calldata contributes is_some = false, a zero selector and a zero word count.
+    const calldata = txParams.calldata;
+    const noWords = calldata.is_some ? calldata.value.noWords : 0 as Uint<16>;
+    const selector = calldata.is_some ? calldata.value.selector : default<Bytes<4>>;
+
+    assert(noWords <= maxCalldataWords, "calldata noWords exceeds capacity");
+    assert(txParams.accessListEntryCount <= maxAccessListEntries, "accessListEntryCount exceeds capacity");
+
+    // For every used access-list entry, confirm its storageKeyCount fits
+    // maxStorageKeysPerEntry. A Compact loop needs a compile-time bound, so the walk
+    // is a fold over every slot carrying [slot index, all fit so far], and the index
+    // picks out the used entries.
+    const keyCountsFit = fold(
+      (acc: [Uint<8>, Boolean], entry: EvmAccessListEntry<maxStorageKeysPerEntry>): [Uint<8>, Boolean] =>
+        [(acc[0] + 1) as Uint<8>, acc[1] && (acc[0] >= txParams.accessListEntryCount || entry.storageKeyCount <= maxStorageKeysPerEntry)],
+      [0 as Uint<8>, true],
+      txParams.accessList
+    );
+    assert(keyCountsFit[1], "a used entry's storageKeyCount exceeds capacity");
+
+    // The scalar fields and the counts, hashed as one field-aligned tuple.
+    const head = transientHash<[Uint<64>, Uint<64>, Uint<128>, Uint<128>, Uint<64>, Bytes<20>, Uint<128>, Boolean, Bytes<4>, Uint<16>, Uint<8>]>([
+      txParams.chainId,
+      txParams.nonce,
+      txParams.maxPriorityFeePerGas,
+      txParams.maxFeePerGas,
+      txParams.gasLimit,
+      txParams.to,
+      txParams.value,
+      calldata.is_some,
+      selector,
+      noWords,
+      txParams.accessListEntryCount
+    ]);
+
+    // The calldata words below noWords, chained onto the head one word at a time.
+    // calldata.value is read whether or not the calldata is present: with noWords
+    // at zero every step passes the head through.
+    const wordsScan = fold(
+      (acc: [Uint<16>, Field], word: Bytes<32>): [Uint<16>, Field] =>
+        [(acc[0] + 1) as Uint<16>, acc[0] < noWords ? transientHash<[Field, Bytes<32>]>([acc[1], word]) : acc[1]],
+      [0 as Uint<16>, head],
+      calldata.value.words
+    );
+
+    // The access-list entries below accessListEntryCount, each chained on as its
+    // address, its key count and a digest of its storage keys below that count
+    // (the inner fold, started from a zero Field).
+    const listScan = fold(
+      (acc: [Uint<8>, Field], entry: EvmAccessListEntry<maxStorageKeysPerEntry>): [Uint<8>, Field] =>
+        [
+          (acc[0] + 1) as Uint<8>,
+          acc[0] < txParams.accessListEntryCount
+            ? transientHash<[Field, Bytes<20>, Uint<8>, Field]>([
+                acc[1],
+                entry.address,
+                entry.storageKeyCount,
+                fold(
+                  (keyAcc: [Uint<8>, Field], key: Bytes<32>): [Uint<8>, Field] =>
+                    [(keyAcc[0] + 1) as Uint<8>, keyAcc[0] < entry.storageKeyCount ? transientHash<[Field, Bytes<32>]>([keyAcc[1], key]) : keyAcc[1]],
+                  [0 as Uint<8>, 0 as Field],
+                  entry.storageKeys
+                )[1]
+              ])
+            : acc[1]
+        ],
+      [0 as Uint<8>, wordsScan[1]],
+      txParams.accessList
+    );
+
+    // The running hash is a Field. upgradeFromTransient writes it out as Bytes<32>.
+    return upgradeFromTransient(listScan[1]);
+  }
+
+  // The request id of an EVM type-2 request: its preimage with the transaction digested
+  // by calculateEvmType2TxParamsDigestV1. Off-chain code uses the TypeScript twin:
+  //    import { calculateRequestId } from "@sig-net/midnight";
+  export pure circuit calculateEvmType2RequestIdV1<#maxCalldataWords, #maxAccessListEntries, #maxStorageKeysPerEntry, #LenOutputDeserialization, #LenRespondSerialization>(
+    request: SignBidirectionalEventV1<EvmType2TxParams<maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry>, LenOutputDeserialization, LenRespondSerialization>
+  ): RequestId {
+    assert(request.txParamType == TxParamType.evmType2, "txParamType must tag txParams as evmType2");
+    const preimage = RequestIdPreimageV1 {
+      keyVersion: request.keyVersion,
+      sender: request.sender,
+      path: request.path,
+      algo: request.algo,
+      txParamType: request.txParamType,
+      txParamsDigest: calculateEvmType2TxParamsDigestV1<maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry>(request.txParams),
+      executionDest: request.executionDest,
+    };
+    return calculateRequestIdV1(preimage);
+  }
+
   // ---- ABI Calldata Word Construction Utilities ------------------------------------------------------
   // Canonical ABI word builders and readers. Words MUST be stored in canonical
   // ABI form (big-endian, per the ABI spec). These utilities help construct