@sig-net/midnight-contract 0.0.2 → 0.0.4

package/README.md

@@ -0,0 +1,27 @@
+# @sig-net/midnight-contract
+
+The central [Sig Network](https://sig.network) signet contract on the [Midnight blockchain](https://midnight.network): the singleton that exposes the MPC's [sign bidirectional flow](https://docs.sig.network/architecture/sign-bidirectional) to other Midnight contracts. The MPC posts back to it and clients poll it:
+
+- **Signature responses**: an unauthenticated counted log; callers verify the signatures off-chain or in their own circuits.
+- **Remote execution responses**: Schnorr attestations by the MPC's Jubjub key, verified in-circuit at post time.
+- **Request-notification registry**: how the MPC discovers new signature requests.
+
+## What is in it
+
+- The curated export surface (package root): the generated contract module (`Contract`, the `ledger` state decoder, `pureCircuits`), the handwritten witnesses, and the platform-agnostic contract surface (circuit ids and the provider type).
+- The `./managed/*` subpath export: the compiled contract assets (compiler output, `zkir/`, prover/verifier `keys/`) so runtimes can fetch them as files. The published package always carries the proving keys.
+
+Consumers import the package root; the `./managed/*` paths exist only for runtimes that load zk assets.
+
+## Install
+
+```sh
+npm install @sig-net/midnight-contract
+```
+
+## Related packages
+
+- [`@sig-net/midnight-contract-deploy`](https://www.npmjs.com/package/@sig-net/midnight-contract-deploy): deploys this contract (constructor argument: the MPC attestation key).
+- [`@sig-net/midnight`](https://www.npmjs.com/package/@sig-net/midnight): the client-agnostic protocol library for reading this contract's state and verifying responses.
+
+Developed in [sig-net/midnight-integration](https://github.com/sig-net/midnight-integration); example applications live in [sig-net/midnight-examples](https://github.com/sig-net/midnight-examples).

package/dist/managed/compiler/contract-info.json

@@ -1,7 +1,7 @@
 {
   "compiler-version": "0.33.0",
   "language-version": "0.25.0",
-  "runtime-version": "0.18.0-rc.0",
+  "runtime-version": "0.18.0-rc.1",
   "circuits": [
     {
       "name": "notifyBidirectionalSignatureRequest",

package/dist/managed/compiler/contract-manifest.json

@@ -2,13 +2,13 @@
   "manifest-version": "1",
   "compiler-version": "0.33.0",
   "language-version": "0.25.0",
-  "runtime-version": "0.18.0-rc.0",
+  "runtime-version": "0.18.0-rc.1",
   "compiler": {
     "type": "directory",
     "contract-info.json": {
       "type": "file",
       "size": 8633,
-      "hash": "6c9b7bfed4149ef2b9adb72c039a32c881f385f437640fe3dff7b7ba2f4768c1"
+      "hash": "72d03046b056dd7fb01af5b97b9992b95d952cef1fbbc7a600d5d5ea29c361c5"
     }
   },
   "contract": {
@@ -20,13 +20,13 @@
     },
     "index.js": {
       "type": "file",
-      "size": 84531,
-      "hash": "8ae44bde9e25000d76e25a663cda7b1cedc7bdf4e5978cac096f9ae7a5525397"
+      "size": 84363,
+      "hash": "45747bcf588a8fb96a9413ca532e578f6e9023c9198f7c97ad25e3f2de31790d"
     },
     "index.js.map": {
       "type": "file",
-      "size": 3258,
-      "hash": "40d1f39539d07d1e011d8dac46bd89b0de547ea4307e7489bc8ac5b9e4d80581"
+      "size": 3251,
+      "hash": "8d82e5ba5aced9fc8dc821154cc513a3064e4f8bf40228fcebf157fbcb884996"
     }
   },
   "zkir": {

package/dist/managed/contract/index.js

@@ -1,5 +1,5 @@
 import * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
-__compactRuntime.checkRuntimeVersion('0.18.0-rc.0');
+__compactRuntime.checkRuntimeVersion('0.18.0-rc.1');
 
 const _descriptor_0 = new __compactRuntime.CompactTypeBytes(32);
 
@@ -498,30 +498,30 @@ export class Contract {
                                               __compactRuntime.convertBigintToBytes(32,
                                                                                     outputLen_0,
                                                                                     'Signet.compact line 369 char 7')]);
-    return [__compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                  16,
-                                                  ((e, i) => e.slice(i, i+16))(rid_0,
-                                                                               Number(0n)),
-                                                  'Field',
-                                                  'Signet.compact line 372 char 7'),
-            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                  16,
-                                                  ((e, i) => e.slice(i, i+16))(rid_0,
-                                                                               Number(16n)),
-                                                  'Field',
-                                                  'Signet.compact line 373 char 7'),
-            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                  16,
-                                                  ((e, i) => e.slice(i, i+16))(outHash_0,
-                                                                               Number(0n)),
-                                                  'Field',
-                                                  'Signet.compact line 374 char 7'),
-            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                  16,
-                                                  ((e, i) => e.slice(i, i+16))(outHash_0,
-                                                                               Number(16n)),
-                                                  'Field',
-                                                  'Signet.compact line 375 char 7')];
+    return [__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                16,
+                                                ((e, i) => e.slice(i, i+16))(rid_0,
+                                                                             Number(0n)),
+                                                'Field',
+                                                'Signet.compact line 372 char 7'),
+            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                16,
+                                                ((e, i) => e.slice(i, i+16))(rid_0,
+                                                                             Number(16n)),
+                                                'Field',
+                                                'Signet.compact line 373 char 7'),
+            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                16,
+                                                ((e, i) => e.slice(i, i+16))(outHash_0,
+                                                                             Number(0n)),
+                                                'Field',
+                                                'Signet.compact line 374 char 7'),
+            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                16,
+                                                ((e, i) => e.slice(i, i+16))(outHash_0,
+                                                                             Number(16n)),
+                                                'Field',
+                                                'Signet.compact line 375 char 7')];
   }
   async _notifyBidirectionalSignatureRequest_0(context,
                                                partialProofData,
@@ -712,15 +712,8 @@ export class Contract {
     }
   }
   _equal_0(x0, y0) {
-    {
-      let x1 = x0.x;
-      let y1 = y0.x;
-      if (x1 !== y1) { return false; }
-    }
-    {
-      let x1 = x0.y;
-      let y1 = y0.y;
-      if (x1 !== y1) { return false; }
+    if (x0.x != y0.x || x0.y != y0.y) {
+      return false;
     }
     return true;
   }

package/dist/managed/contract/index.js.map

@@ -4,5 +4,5 @@
   "sourceRoot": "../../../",
   "sources": ["src/signet-contract.compact", "compiler/standard-library.compact", "compiler/zkir-v3-library.compact", "../../node_modules/@sig-net/midnight/src/Signet.compact"],
   "names": [],
-  "mappings": "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"
+  "mappings": "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"
 }

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@sig-net/midnight-contract",
-  "version": "0.0.2",
+  "version": "0.0.4",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sig-net/midnight-integration",
+    "directory": "packages/signet-contract"
+  },
   "type": "module",
   "description": "The central signet Compact contract on Midnight: the MPC posts signature responses (unauthenticated counted log, verified off-chain) and remote execution responses (Schnorr attestations, verified in-circuit at post time) here; clients poll it. src/index.ts is the curated export surface.",
   "exports": {
@@ -11,9 +16,7 @@
     "./managed/*": "./dist/managed/*"
   },
   "files": [
-    "dist",
-    "src",
-    "!src/managed"
+    "dist"
   ],
   "scripts": {
     "compile": "COMPACT_PATH=../../node_modules compact compile --skip-zk src/signet-contract.compact src/managed",
@@ -35,11 +38,11 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/compact-runtime": "0.18.0-rc.0",
-    "@midnight-ntwrk/midnight-js": "5.0.0-beta.3"
+    "@midnight-ntwrk/compact-runtime": "0.18.0-rc.1",
+    "@midnight-ntwrk/midnight-js": "5.0.0-beta.4"
   },
   "devDependencies": {
-    "@sig-net/midnight": "^0.0.2",
+    "@sig-net/midnight": "^0.0.4",
     "@types/node": "^26.1.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9"

package/src/contract-surface.ts

@@ -1,40 +0,0 @@
-// The contract's platform-agnostic client surface: the circuit-id union, the
-// private-state store key, and the provider-set TYPE. Deliberately nothing
-// runnable — no wallet flavor, no zk-config source, no state store, no proof
-// provider. Composing a live midnight-js provider set is CONSUMER territory
-// (it differs per environment: Node fs vs browser fetch, LevelDB vs
-// IndexedDB, WalletFacade vs a connector API), so each consumer declares its
-// own — see this monorepo's signet-contract-deploy package for the Node
-// operator composition, and the fakenet response server for a consumer's.
-
-import type { MidnightProviders } from "@midnight-ntwrk/midnight-js/types";
-
-import { Contract } from "./managed/contract/index.js";
-import { type SignetContractPrivateState } from "./witnesses.ts";
-
-/** The contract's provable circuit ids, straight from the generated contract. */
-export type SignetContractCircuitId = keyof InstanceType<typeof Contract>["provableCircuits"] & string;
-
-/**
- * Literal of the private-state storage key. Just a string, but a single-value
- * union so the providers/`findDeployedContract` pairing is enforced by the
- * type system.
- */
-export type SignetContractPrivateStateId = "signet-contract";
-
-/**
- * Key under which midnight-js persists this contract's private state locally
- * (in whatever private-state store the consumer's provider set uses).
- * Distinct per contract so two clients don't share an entry.
- */
-export const SIGNET_CONTRACT_PRIVATE_STATE_ID: SignetContractPrivateStateId = "signet-contract";
-
-/** The full midnight-js provider set, typed to the signet contract. */
-export type SignetContractProviders = MidnightProviders<
-  // PCK: the union of the contract's provable circuit names.
-  SignetContractCircuitId,
-  // PSI: the private-state storage key literal.
-  SignetContractPrivateStateId,
-  // PS: the shape of the contract's (empty) private state object.
-  SignetContractPrivateState
->;

package/src/index.ts

@@ -1,9 +0,0 @@
-// Curated export surface — this IS the "sdk" face of the package.
-// Everything the compiler emitted, the handwritten witnesses, and the
-// platform-agnostic contract surface (ids + provider TYPE). Environment
-// bindings (zk-config source, state store, wallet adapter) deliberately
-// live with each consumer, not here.
-
-export * from "./managed/contract/index.js";
-export * from "./witnesses.ts";
-export * from "./contract-surface.ts";

package/src/signet-contract.compact

@@ -1,128 +0,0 @@
-pragma language_version >= 0.25;
-
-import CompactStandardLibrary;
-
-// Shared signet library: request/response structs, request-id hashing,
-// path<->identity binding, and the attestation message. See the module header
-// in Signet.compact and https://docs.sig.network/ for the protocol.
-import "@sig-net/midnight/src/Signet";
-
-// The CENTRAL signet contract: clients register their signature-request
-// notifications here, the MPC delivers all its responses here, and both sides
-// poll it — there is deliberately no push/websocket channel. Ledger layout per
-// "Signet Contract Ledger Layout" in Signet.compact, so pollers need only this
-// contract's address.
-export ledger signatureResponseCounterIndex: SignatureResponseCounterIndex;
-
-export ledger signatureResponseIndex: SignatureResponseIndex;
-
-export ledger respondBidirectionalIndex: RespondBidirectionalIndex;
-
-// The MPC attestation key, pinned at deploy time: postRespondBidirectional
-// accepts only responses signed by this key.
-export sealed ledger mpcPubKeyHash: Bytes<32>;
-
-// The notification registry (field 4): clients register "a request was stored
-// in MY ledger at THIS index field" pointers here; the MPC polls by
-// enumerating the map. Append-only, idempotent overwrite, no removal.
-export ledger signBidirectionalNotificationIndex: SignBidirectionalNotificationIndex;
-
-constructor(mpcPk: JubjubPoint) {
-    mpcPubKeyHash = disclose(persistentHash<JubjubPoint>(mpcPk));
-}
-
-// notifyBidirectionalSignatureRequest should be called (cross-contract) by
-// clients after (or within) a transaction that writes a
-// SignBidirectionalRequest to their canonical SignBidirectionalRequestIndex
-// state map. Registers the notification in the registry the MPC polls; a
-// repeat call for the same request id overwrites idempotently. Unauthenticated
-// by design: the notification is a pointer, and the MPC trusts only what it
-// reads back from the named caller's own ledger.
-export circuit notifyBidirectionalSignatureRequest(
-    requestId: RequestId,
-    notification: SignBidirectionalNotification
-): [] {
-    signBidirectionalNotificationIndex.insert(
-        disclose(requestId),
-        disclose(notification),
-    );
-}
-
-// postSignatureResponse appends a signature response for requestId.
-// Unauthenticated by NECESSITY (secp256k1 ECDSA cannot be verified
-// in-circuit): anyone may post, and nothing is ever overwritten — each post
-// lands under the next (requestId, count) key. Callers poll the log by
-// request id and verify the posted signatures off-chain to pick out the
-// genuine one.
-export circuit postSignatureResponse(requestId: RequestId, signatureResponse: SignatureResponse): [] {
-    // Everything stored here is public by construction.
-    const disclosedRequestId = disclose(requestId);
-
-    // Ensure the request's counter exists (a fresh Counter reads 0).
-    if (!signatureResponseCounterIndex.member(disclosedRequestId)) {
-        signatureResponseCounterIndex.insertDefault(disclosedRequestId);
-    }
-
-    // Posts so far == this post's 0-based count. Read ONCE into a local so
-    // the stored key and the counter update cannot disagree.
-    const count = signatureResponseCounterIndex.lookup(disclosedRequestId).read();
-    signatureResponseCounterIndex.lookup(disclosedRequestId).increment(1);
-
-    // Store the response under (requestId, count).
-    signatureResponseIndex.insert(
-        SignetResponseKey{
-            requestId: disclosedRequestId,
-            count: count,
-        },
-        disclose(signatureResponse),
-    );
-}
-
-// postRespondBidirectional records the MPC's attestation of requestId's
-// remote execution. Anyone may POST, but nothing unauthentic can LAND: the
-// Schnorr signature over (requestId, hash(serializedOutput, outputLen)) is
-// verified in-circuit against the sealed MPC key, so the stored record is
-// authentic by construction and one slot per request suffices — clients read
-// it without re-verifying.
-export circuit postRespondBidirectional(
-    requestId: RequestId,
-    respondBidirectional: RespondBidirectional
-): [] {
-    // Everything stored here is public by construction.
-    const disclosedRequestId = disclose(requestId);
-    const disclosedResponse = disclose(respondBidirectional);
-
-    // Only the pinned MPC key may attest.
-    assert(
-        persistentHash<JubjubPoint>(disclosedResponse.pk) == mpcPubKeyHash,
-        "unauthorized: attestation pk is not the MPC key"
-    );
-
-    // The attestation must sign THIS request and THIS output.
-    assert(
-        jubjubSchnorrVerify<4>(
-            signetAttestationMessage(
-                disclosedRequestId,
-                disclosedResponse.serializedOutput,
-                disclosedResponse.outputLen
-            ),
-            JubjubSchnorrSignature {
-                announcement: disclosedResponse.announcement,
-                response: disclosedResponse.response,
-            },
-            disclosedResponse.pk
-        ),
-        "Invalid attestation signature"
-    );
-
-    // First valid write wins. A re-post is a no-op, never an overwrite —
-    // Schnorr is randomized, so even the MPC re-signing the same output
-    // yields bytewise-different records; asserting equality would misfire.
-    // The no-op leaves the single authenticated slot untouched. Clients poll
-    // the index by request id; no off-chain verification follows — the
-    // in-circuit checks above already authenticated the stored record.
-    if (respondBidirectionalIndex.member(disclosedRequestId)) {
-        return [];
-    }
-    respondBidirectionalIndex.insert(disclosedRequestId, disclosedResponse);
-}

package/src/witnesses.ts

@@ -1,22 +0,0 @@
-// The signet contract has no witnesses: Schnorr verification is
-// CompactStandardLibrary's `jubjubSchnorrVerify` (fully in-circuit), and
-// there is no private state — posting carries no caller secrets.
-
-import type { Witnesses } from "./managed/contract/index.js";
-
-/** Private state carried through signet-contract circuit calls: none. */
-export type SignetContractPrivateState = Record<string, never>;
-
-/**
- * Build the contract's (empty) private state.
- *
- * @returns A fresh, empty private state.
- */
-export const createSignetContractPrivateState =
-  (): SignetContractPrivateState => ({});
-
-/**
- * Witness implementations, typed against the generated `Witnesses` shape:
- * the contract declares none.
- */
-export const witnesses: Witnesses<SignetContractPrivateState> = {};