@sig-net/midnight 0.15.0 → 0.17.0

package/src/Signet.compact

@@ -6,9 +6,10 @@
 //  Terms:
 //    - client contract(s): contracts on the Midnight blockchain that integrate with the Signet Distributed MPC
 //                       to execute arbitrary transactions on foreign blockchains.
-//    - Signet singleton: a single contract on the Midnight blockchain holding the Signet registry for transaction
-//                        signature requests and responses, as well as signed attestations of transactions executed
-//                        on foreign blockchains (the execution outputs themselves travel off chain).
+//    - Signet singleton: a single contract on the Midnight blockchain through which clients notify the MPC of
+//                        signature requests, and through which the MPC posts back signatures and signed attestations
+//                        of foreign executions. Each post is emitted as a contract event (the execution
+//                        outputs themselves travel off chain).
 //
 //  Usage:
 //   // Import this module at the start of a contract (resolved through node_modules via COMPACT_PATH):
@@ -28,28 +29,34 @@
 //  - SignBidirectionalEventNotification: Notification delivered by client contracts via cross contract call to Signet singleton
 //                                        (via SignetSigner interface) to notify the MPC of a SignBidirectionalEvent.
 //  - SignatureRespondedEvent: Counterpart to SignBidirectionalEvent containing MPC generated signature requested by a SignBidirectionalEvent.
-//                             Posted by MPC back to Signet singleton for clients to extract to build a signed transaction.
+//                             Posted by the MPC through the Signet singleton, which emits it as a contract
+//                             event. Clients extract it to build a signed transaction.
 //  - RespondBidirectionalEvent: Attestation of a transaction executed on a foreign blockchain: the MPC's ECDSA
 //                               signature over the attestation digest of the request id and serialised output
 //                               (see calculateSignetAttestationDigest), signed with the MPC's RESPONSE key for
 //                               the requesting contract: the key derived from the client contract's address +
 //                               the fixed path "midnight response key". Both the digest and the output itself
-//                               travel off chain. Posted by MPC back to Signet singleton for clients to extract,
-//                               verify (see verifyRespondBidirectionalEvent) and deliver back to the client
-//                               contract.
+//                               travel off chain. Posted by the MPC through the Signet singleton, which
+//                               emits it as a contract event. Clients extract it, verify it (see
+//                               verifyRespondBidirectionalEvent) and deliver it back to the client contract.
 //
 // These key types are best understood within the sign bidirectional flow that they enable:
-// 1. Client contract stores a SignBidirectionalEvent in a SignBidirectionalEventMap its own ledger
-//    (against the calculated RequestId) and requests a signature from the MPC by registering a
-//    SignBidirectionalEventNotification in the Signet singleton contract's registry
-//    (via cross contract call against the SignetSigner interface).
-// 2. MPC polls the Signet singleton contract's registry for the SignBidirectionalEventNotification,
-//    using it to read the SignBidirectionalEvent signature request from the client's ledger. It generates the
-//    signature and and posts a SignatureRespondedEvent (the requested signature) to the Signet singleton contract.
-// 3. Client polls the Signet singleton contract SignatureRespondedEventMap for the signature by RequestId,
-//    verifies the posted SignatureRespondedEvent and broadcasts txn to destination chain.
-// 4. MPC observes txn execution on destination chain, posts a RespondBidirectionalEvent
-//    attestation to the central Signet contract, and the client polls it by RequestId.
+// 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
+//    against the SignetSigner interface. The Signet singleton emits the
+//    SignBidirectionalEventNotification as a contract event, the RequestId disclosed beside it.
+// 2. MPC polls the Signet singleton contract's events for SignBidirectionalEventNotifications and uses
+//    each one to look the declared SignBidirectionalEvent signature request up in the named client's own ledger.
+//    It generates the signature and posts a SignatureRespondedEvent (the requested signature) through
+//    the Signet singleton, which emits it as a contract event.
+// 3. Client polls the Signet singleton contract's SignatureRespondedEvent events. Each event carries
+//    the request id it answers beside the signature. The id is unauthenticated routing data: the client
+//    reads its own request's posts by id, verifies each candidate, and takes the first one whose
+//    signature recovers to its derived key. Then it broadcasts the signed txn to the destination chain.
+// 4. MPC observes txn execution on destination chain and posts a RespondBidirectionalEvent attestation
+//    through the central Signet contract, which emits it as a contract event beside the request id.
+//    The client polls its request's posts and takes the first one that verifies over the request id
+//    and output.
 //    The client recovers the execution output itself off chain (for EVM: the mined
 //    call's return data via debug_traceTransaction, also served by the fakenet
 //    responder's /responses/{requestId} helper API) and hands output plus attestation
@@ -58,7 +65,8 @@
 // Read more:
 //   - For full integration examples (such as an ERC20 cross chain vault example) see
 //     the Midnight Examples repository at: https://github.com/sig-net/midnight-examples.
-//   - Signet docs (chain signatures, key derivation): https://docs.sig.network
+//   - The sign bidirectional flow and key derivation: this package's README
+//     ("Sign bidirectional flow", "Derived keys").
 //   - Compact language reference (modules, types):
 //     https://docs.midnight.network/compact/reference/compact-reference
 
@@ -79,11 +87,15 @@ module Signet {
 
     // MPC Key Derivation Parameters.
     // Every key the MPC signs with is scoped by the requesting contract:
-    //   derivedSigningKey = f(mpcRootKey[keyVersion], sender, path)
-    // The path is 32 opaque bytes of the client contract's choosing (e.g a fixed literal
-    // for a contract-owned account or a hash of a caller's secret for per-user
-    // accounts): no format is enforced. The sender is always part of the
-    // derivation, so no contract can reach another contract's derived keys.
+    //   derivedSigningKey = f(mpcRootKey[keyVersion], caip2ChainId, sender, hex::encode(path))
+    // where caip2ChainId is the CAIP-2 id of the ORIGINATING chain (the Midnight
+    // variant for requests made from Midnight contracts), not this record's target
+    // caip2Id. The path is 32 opaque bytes of the client contract's choosing (e.g a
+    // fixed literal for a contract-owned account or a hash of a caller's secret for
+    // per-user accounts): no format is enforced, any 32 bytes are valid. CRITICAL:
+    // the MPC renders the path as hex::encode(path) before deriving (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. Set to 1.
     path: Bytes<32>;          // Key derivation path: 32 opaque bytes, client contract's choice.
 
@@ -199,11 +211,13 @@ module Signet {
     // Called by client contracts to notify the MPC of a SignBidirectionalEvent.
     circuit signBidirectional(
       // Canonical id of the SignBidirectionalEvent (calculate with calculateRequestId).
+      // Disclosed in the emitted notification event: the MPC looks this id up in the
+      // caller's own request map.
       requestId: RequestId,
       // Versioned notification of the SignBidirectionalEvent
       // (construct with constructSignBidirectionalEventNotificationV1).
       notification: SignBidirectionalEventNotification
-    ): SignetMapKey;
+    ): [];
   }
 
   // Notification delivered by client contracts via cross contract call to Signet singleton
@@ -310,8 +324,10 @@ module Signet {
   //  signature = signSECP256k1(mpcResponseKey, attestationDigest)
   //
   // Where the MPC response key is a per-client-contract key derived using the same derivation function
-  // as request signing keys, with the path set to the fixed "midnight response key":
-  //  mpcResponseKey = f(mpcRootKey[keyVersion], sender, "midnight response key")
+  // as request signing keys, with the path set to the fixed "midnight response key" (a protocol
+  // string that enters the derivation verbatim, unlike a request's 32 path bytes which are
+  // hex-encoded first):
+  //  mpcResponseKey = f(mpcRootKey[keyVersion], caip2ChainId, sender, "midnight response key")
   //
   // Storage & Verification:
   // The execution output is of variable size, so it travels off chain, and the digest
@@ -319,19 +335,12 @@ module Signet {
   // the attestation digest and verifies the signature in-circuit via
   // verifyRespondBidirectionalEvent against its derived MPC response key. The signature
   // is the ONLY thing that distinguishes a genuine post from garbage: the Signet
-  // singleton is an unauthenticated log and stores every post unverified.
+  // singleton is an unauthenticated log and emits every post unverified.
   export struct RespondBidirectionalEvent {
     // The MPC's ECDSA signature over the attestation digest.
     signature: Signature;
   }
 
-  // SignetMapKey used to locate SignBidirectionalEventNotifications, SignatureRespondedEvent and
-  // RespondBidirectionalEvents in Signet singleton contract storage.
-  export struct SignetMapKey {
-    count: Uint<64>;
-    requestId: RequestId;
-  };
-
   // Calculates the 32-byte attestation digest for a remote execution output:
   //    attestationDigest = keccak256(requestId + serializedOutput)
   //
@@ -371,7 +380,7 @@ module Signet {
   // signatures, and one that is not simply fails to verify.
   //
   // Note: Client contracts must run this check before consuming outputs, as the Signet
-  // singleton stores responses unverified.
+  // singleton emits responses unverified.
   export pure circuit verifyRespondBidirectionalEvent<#serializedOutputLength>(
     requestId: RequestId,
     serializedOutput: Bytes<serializedOutputLength>,

package/dist/signet-contract-state-reader.d.ts

@@ -1,247 +0,0 @@
-import { type CompactType } from "@midnight-ntwrk/compact-runtime";
-import { type RequestId, type RequestIdHex } from "./signet-requests.ts";
-import { type RawContractState } from "./signature-state-reading.ts";
-/** Signet contract layout: the notification counter map is ledger field 0. */
-export declare const SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_COUNTER_MAP_FIELD = 0;
-/** Signet contract layout: the notification map is ledger field 1. */
-export declare const SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_MAP_FIELD = 1;
-/** Signet contract layout: the `respond` counter map is ledger field 2. */
-export declare const RESPOND_COUNTER_MAP_FIELD = 2;
-/** Signet contract layout: the `respond` post log is ledger field 3. */
-export declare const RESPOND_MAP_FIELD = 3;
-/** Signet contract layout: the respond-bidirectional counter map is ledger field 4. */
-export declare const RESPOND_BIDIRECTIONAL_COUNTER_MAP_FIELD = 4;
-/** Signet contract layout: the respond-bidirectional map is ledger field 5. */
-export declare const RESPOND_BIDIRECTIONAL_MAP_FIELD = 5;
-/**
- * A curve point in affine coordinates (Compact `AffinePoint`), SEC1
- * big-endian, the same shape the sig-net EVM and Solana signer contracts
- * expose.
- */
-export interface AffinePoint {
-    /** The x coordinate, 32 big-endian bytes. */
-    x: Uint8Array;
-    /** The y coordinate, 32 big-endian bytes. */
-    y: Uint8Array;
-}
-/**
- * The MPC's canonical ECDSA signature as both respond events store it
- * (Compact `Signature`, matching the MPC's own
- * `Signature { big_r, s, recovery_id }` and the EVM/Solana signer
- * contracts): `bigR` the full nonce point so consumers never decompress,
- * `s` big-endian, `recoveryId` the parity of R.y. Stored UNVERIFIED like
- * everything else on the singleton. Convert with
- * `ecdsaSignatureToMpcSignature` / `mpcSignatureToEcdsaSignature`.
- */
-export interface MpcSignature {
-    /** The signature's nonce point R. */
-    bigR: AffinePoint;
-    /** Signature scalar s, 32 big-endian bytes. */
-    s: Uint8Array;
-    /** Recovery id (parity of R.y): 0 or 1. */
-    recoveryId: bigint;
-}
-/**
- * The MPC's signature over the requested EVM transaction (Compact
- * `SignatureRespondedEvent`): decode to an ethers signature with
- * `signatureRespondedEventToSignature`. The request id it answers lives in
- * the map key.
- */
-export interface SignatureRespondedEvent {
-    /** The requested signature over the transaction the request describes. */
-    signature: MpcSignature;
-}
-/**
- * Hand-composed descriptor for {@link SignatureRespondedEvent}: the single
- * {@link MpcSignature} field, matching the Compact struct.
- */
-export declare const signatureRespondedEventType: CompactType<SignatureRespondedEvent>;
-/**
- * The MPC's respond-bidirectional attestation of a request's remote EVM
- * execution (Compact `RespondBidirectionalEvent`): the ECDSA signature over
- * the attestation digest `keccak256(requestId || serializedOutput)`. Both the
- * digest and the output travel off chain: readers fetch the output, recompute
- * the digest (`calculateSignetAttestationDigest`) and verify the signature
- * over it. Stored UNVERIFIED by the signet contract, so that signature check
- * against the expected MPC response key is the only thing separating a
- * genuine post from garbage (in-circuit via
- * `verifyRespondBidirectionalEvent`, off chain via
- * {@link verifyRespondBidirectionalSignature}).
- */
-export interface RespondBidirectionalEvent {
-    /** ECDSA signature over the attestation digest. */
-    signature: MpcSignature;
-}
-/**
- * Composite key of one posted entry in the signet contract's maps (Compact
- * `SignetMapKey`): the request id it belongs to plus the post's 0-based
- * count. Field order (count first, then request id) mirrors the Compact
- * struct.
- */
-export interface SignetMapKey {
-    /** 0-based position of this post among the entries for {@link requestId}. */
-    count: bigint;
-    /** 32-byte id of the request this entry belongs to. */
-    requestId: RequestId;
-}
-/**
- * Hand-composed descriptor for {@link SignetMapKey}, the map key of every
- * posted-entry map in the signet contract. Field order (count, then
- * requestId) must match the Compact struct.
- */
-export declare const signetMapKeyType: CompactType<SignetMapKey>;
-/**
- * Hand-composed descriptor for {@link RespondBidirectionalEvent}: the single
- * {@link MpcSignature} field, matching the Compact struct.
- */
-export declare const respondBidirectionalEventType: CompactType<RespondBidirectionalEvent>;
-/**
- * Raw twin of the Compact `SignBidirectionalEventNotification` struct as
- * stored on-ledger: the version tag plus the still-packed 128-byte payload.
- * Decode the payload with {@link decodeSignBidirectionalNotification}.
- */
-export interface SignBidirectionalNotificationRecord {
-    /** Payload layout tag (Compact `Uint<8>`): 1 = the V1 layout. */
-    version: bigint;
-    /** The packed payload bytes, exactly as the registering circuit built them. */
-    payload: Uint8Array;
-}
-/**
- * Hand-composed descriptor for {@link SignBidirectionalNotificationRecord}.
- * Field order (version, payload) must match the Compact struct.
- */
-export declare const signBidirectionalNotificationType: CompactType<SignBidirectionalNotificationRecord>;
-/**
- * A decoded V1 notification from the signet contract's registry: the flat
- * pointer a client registered to tell the MPC a request was stored, and
- * WHERE to read the authenticated copy. The request id is NOT in the payload:
- * it lives in the registry map key the record was stored under. Never trusted
- * on its own: the resolver authenticates by reading the request back from
- * {@link callerAddress}'s own ledger (see signet-request-resolver.ts).
- */
-export interface SignBidirectionalNotification {
-    /** Payload layout tag: this decoder only produces version 1. */
-    version: number;
-    /**
-     * Address of the contract whose request map holds the request, rendered
-     * as lowercase hex, no `0x` prefix: directly usable as a
-     * `queryContractState` argument. The MPC reads the request from THIS
-     * contract's authenticated state. The field itself confers no authority.
-     */
-    callerAddress: string;
-    /**
-     * Resolved ledger-tree path of the `SignBidirectionalEventMap` in
-     * {@link callerAddress}, as compactc records it in that contract's
-     * `contract-info.json` (`"index"`): `[4]` for a flat contract's field 4,
-     * `[1, 14]` once chunking applies. The reader follows it node for node
-     * (see {@link signetFieldNodeByPath}) and never assumes a layout.
-     */
-    requestsPath: number[];
-}
-/**
- * Unpack a stored {@link SignBidirectionalNotificationRecord}'s payload by
- * the fixed V1 offsets: the decode twin of the compiled
- * `constructSignBidirectionalEventNotificationV1` circuit (byte plumbing
- * only: the pack↔decode lockstep is pinned by the state-reader unit test that
- * round-trips through the real circuit). V1 layout:
- * callerAddress (32) ++ requestsPathDepth (1) ++ requestsPath (4) ++ zero
- * padding (91), where only the first `requestsPathDepth` path bytes are
- * meaningful.
- *
- * Fails closed on an unrecognised `version`: a future payload layout adds a
- * branch here rather than silently misinterpreting bytes under the V1 offsets.
- *
- * @param record - The raw on-ledger record.
- * @returns The decoded notification, its `requestsPath` trimmed to the
- *   declared depth.
- * @throws Error if the record's `version` is not one this decoder understands,
- *   or its `requestsPathDepth` is zero or exceeds {@link MAX_LEDGER_PATH_DEPTH}.
- */
-export declare function decodeSignBidirectionalNotification(record: SignBidirectionalNotificationRecord): SignBidirectionalNotification;
-/**
- * Plain-JS notification registry parsed out of the ledger: hex request id
- * (from the `SignetMapKey` the notification was stored under) to the raw
- * stored record. Re-notifies append under higher counts. This index keeps
- * the FIRST post (count 0) per request id, the record the original submit
- * registered. Decode each record with
- * {@link decodeSignBidirectionalNotification}.
- */
-export type SignBidirectionalNotificationIndex = Map<RequestIdHex, SignBidirectionalNotificationRecord>;
-/**
- * Plain-JS counter map parsed out of the ledger: hex request id (see
- * {@link requestIdHex}) to the number of entries posted for that request.
- * Entries in the corresponding map exist for counts `0 .. value - 1`.
- */
-export type SignetCounterIndex = Map<RequestIdHex, bigint>;
-/**
- * Plain-JS signature response log parsed out of the ledger, keyed by
- * {@link signetMapEntryKey} (`"<hexRequestId>:<count>"`) so the composite
- * Compact key survives as a usable JS `Map` key.
- */
-export type SignatureResponseIndex = Map<string, SignatureRespondedEvent>;
-/**
- * Plain-JS respond-bidirectional log parsed out of the ledger, keyed by
- * {@link signetMapEntryKey} (`"<hexRequestId>:<count>"`).
- */
-export type RespondBidirectionalIndex = Map<string, RespondBidirectionalEvent>;
-/**
- * Build the flattened JS map key for a `(requestId, count)` pair: the
- * composite Compact {@link SignetMapKey} as a string so it works as a JS
- * `Map` key.
- *
- * @param id - The request id the entry belongs to, in canonical hex form.
- * @param count - 0-based post count within that request.
- * @returns `"<hexRequestId>:<count>"`.
- */
-export declare function signetMapEntryKey(id: RequestIdHex, count: bigint): string;
-/**
- * Read ONLY the notification registry (ledger field
- * {@link SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_MAP_FIELD}) out of raw signet
- * contract state: the poll-loop primitive of {@link SignetRequestFeed},
- * which cycles frequently and has no use for the response fields. One record
- * per request id (the count-0 post, see
- * {@link SignBidirectionalNotificationIndex}).
- *
- * @param raw - Raw contract state, e.g. `queryContractState(address).data`
- *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
- * @returns The registry, keyed by the hex request id of each entry's map key.
- * @throws Error if the field is missing or is not a Map.
- */
-export declare function readSignBidirectionalNotificationIndexFromState(raw: RawContractState): SignBidirectionalNotificationIndex;
-/**
- * The decoded ledger fields of the signet contract: the three
- * (counter map, entry map) pairs, namely notifications (fields 0/1), signature
- * responses (fields 2/3), respond-bidirectional responses (fields 4/5).
- * Together they give a poller everything the contract ever records about a
- * request. All entries are UNAUTHENTICATED: verify before trusting.
- */
-export interface SignetContractLedger {
-    /** Notification post counts per request id (ledger field 0). */
-    signBidirectionalEventNotificationCounterMap: SignetCounterIndex;
-    /**
-     * The notification registry (ledger field 1), one record per request id
-     * (count-0 post).
-     */
-    signBidirectionalEventNotificationMap: SignBidirectionalNotificationIndex;
-    /** `respond` post counts per request id (ledger field 2). */
-    respondCounterMap: SignetCounterIndex;
-    /** The `respond` post log (ledger field 3), keyed by {@link signetMapEntryKey}. */
-    respondMap: SignatureResponseIndex;
-    /** Respond-bidirectional post counts per request id (ledger field 4). */
-    respondBidirectionalCounterMap: SignetCounterIndex;
-    /** The respond-bidirectional log (ledger field 5), keyed by {@link signetMapEntryKey}. */
-    respondBidirectionalMap: RespondBidirectionalIndex;
-}
-/**
- * MPC-/client-style read: parse the signet contract's ledger fields out of
- * raw contract state by field position alone, with no compiled contract and
- * no generated `ledger()`, only the declaration-order layout and the
- * canonical descriptors above.
- *
- * @param raw - Raw contract state, e.g. `queryContractState(address).data`
- *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
- * @returns The decoded {@link SignetContractLedger}.
- * @throws Error if a field is missing or has the wrong state-value shape.
- */
-export declare function readSignetContractLedgerFromState(raw: RawContractState): SignetContractLedger;
-//# sourceMappingURL=signet-contract-state-reader.d.ts.map

package/dist/signet-contract-state-reader.d.ts.map

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