@sig-net/midnight 0.0.1

package/README.md

@@ -0,0 +1,20 @@
+# @sig-net/midnight
+
+THE point of the repo: the Midnight-side sig-net integration. Midnight is not
+yet a signet.js chain — this package is the seed of that future adapter.
+
+Where signet.js already covers something (e.g. EVM tx preparation, address
+derivation), import it rather than re-implement. Only what is Midnight-specific
+belongs here.
+
+Planned modules (ported from the old repo's `boilerplate/contract-cli/src/signet/`):
+
+- `request-id.ts` — signet request-id computation
+- `calldata-builder.ts` — EVM calldata construction
+- `tx-builder.ts` — EIP-1559 transaction building
+- `codec.ts` — byte/hex codecs
+- `constants.ts`
+- `schnorr.ts` — Jubjub response verification (Midnight-specific, not in signet.js)
+- `state-reader.ts` — read pending requests/responses from the Midnight indexer
+- `signet-request-response-reader.ts` — read/poll the signet contract for results
+  (replaces the old websocket subscription — purged, no fallback)

package/dist/constants.d.ts

@@ -0,0 +1,62 @@
+/** Width of `SignBidirectionalRequest.caip2Id` (`Bytes<32>`). */
+export declare const CAIP2_ID_BYTES = 32;
+/** Width of `SignBidirectionalRequest.algo` (`Bytes<32>`). */
+export declare const ALGO_BYTES = 32;
+/** Width of `SignBidirectionalRequest.dest` (`Bytes<32>`). */
+export declare const DEST_BYTES = 32;
+/** Width of `SignBidirectionalRequest.params` (`Bytes<64>`). */
+export declare const MPC_PARAMS_BYTES = 64;
+/** Width of `SignBidirectionalRequest.outputDeserializationSchema` (`Bytes<128>`). */
+export declare const OUTPUT_DESERIALIZATION_SCHEMA_BYTES = 128;
+/** Width of `SignBidirectionalRequest.respondSerializationSchema` (`Bytes<128>`). */
+export declare const RESPOND_SERIALIZATION_SCHEMA_BYTES = 128;
+/** Width of `EVMCalldata.selector` (`Bytes<4>`) — the literal first 4 calldata bytes. */
+export declare const SELECTOR_BYTES = 4;
+/** Width of `RespondBidirectional.serializedOutput` (`Bytes<128>`). */
+export declare const SERIALIZED_OUTPUT_BYTES = 128;
+/**
+ * The MPC's error sentinel: `serializedOutput` beginning with these four
+ * bytes marks a failed/absent remote execution (mirrors the sig-net MPC's
+ * MAGIC_ERROR_PREFIX).
+ */
+export declare const MPC_ERROR_SENTINEL: Uint8Array<ArrayBuffer>;
+/**
+ * Whether an attestation's serialized output reports a successful remote
+ * execution: the first byte is 1 — the little-endian encoding of the
+ * ABI-decoded success flag, matching the circuits'
+ * `serializedOutput as Field == 1` check.
+ *
+ * @param serializedOutput - The attestation's serialized output.
+ * @returns `true` when the remote call succeeded.
+ */
+export declare function executionSucceeded(serializedOutput: Uint8Array): boolean;
+/**
+ * Whether an attestation's serialized output is the MPC's error sentinel
+ * (see {@link MPC_ERROR_SENTINEL}) rather than a call result.
+ *
+ * @param serializedOutput - The attestation's serialized output.
+ * @returns `true` when the MPC reported an execution error.
+ */
+export declare function isExecutionError(serializedOutput: Uint8Array): boolean;
+/** Signature algorithm the MPC uses for EVM chains (`algo` field value). */
+export declare const SIGNET_ALGO_ECDSA = "ecdsa";
+/** Destination chain family for EVM requests (`dest` field value). */
+export declare const SIGNET_DEST_ETHEREUM = "ethereum";
+/**
+ * Default MPC key version (`keyVersion` field value). Version 0 is the
+ * unsupported legacy format — the canonical MPC (and
+ * `constructSignBidirectionalRequest`) requires `keyVersion >= 1`.
+ */
+export declare const SIGNET_DEFAULT_KEY_VERSION = 1n;
+/**
+ * Encode text as zero-padded ASCII bytes — the Compact `pad(N, "text")`
+ * convention every string-ish field of the request structs uses (consumers
+ * NUL-trim on decode).
+ *
+ * @param text - The ASCII text to encode.
+ * @param length - The fixed field width in bytes.
+ * @returns `text`'s bytes followed by zero padding to exactly `length`.
+ * @throws If the encoded text does not fit in `length` bytes.
+ */
+export declare function asciiPadded(text: string, length: number): Uint8Array;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAUA,iEAAiE;AACjE,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC,8DAA8D;AAC9D,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B,8DAA8D;AAC9D,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B,gEAAgE;AAChE,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC,sFAAsF;AACtF,eAAO,MAAM,mCAAmC,MAAM,CAAC;AAEvD,qFAAqF;AACrF,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD,yFAAyF;AACzF,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,yBAA2C,CAAC;AAE3E;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,UAAU,GAAG,OAAO,CAExE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,gBAAgB,EAAE,UAAU,GAAG,OAAO,CAEtE;AAED,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,UAAU,CAAC;AAEzC,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAQpE"}

package/dist/constants.js

@@ -0,0 +1,83 @@
+// MPC routing constants + the padded-ASCII codec for the signet request
+// structs. Field widths mirror Signet.compact (the wire format —
+// keep in lockstep); the string constants are the values the MPC network
+// routes on. Ported from the MVP's contract-cli signet/constants.ts, adapted
+// to the refactor's zero-padded convention (Compact `pad(N, "text")`) — the
+// MVP's 2-byte length-prefixed codec is gone with the old layout.
+//
+// The routing constants belong in github.com/sig-net/signet.js — kept here
+// until upstreamed.
+/** Width of `SignBidirectionalRequest.caip2Id` (`Bytes<32>`). */
+export const CAIP2_ID_BYTES = 32;
+/** Width of `SignBidirectionalRequest.algo` (`Bytes<32>`). */
+export const ALGO_BYTES = 32;
+/** Width of `SignBidirectionalRequest.dest` (`Bytes<32>`). */
+export const DEST_BYTES = 32;
+/** Width of `SignBidirectionalRequest.params` (`Bytes<64>`). */
+export const MPC_PARAMS_BYTES = 64;
+/** Width of `SignBidirectionalRequest.outputDeserializationSchema` (`Bytes<128>`). */
+export const OUTPUT_DESERIALIZATION_SCHEMA_BYTES = 128;
+/** Width of `SignBidirectionalRequest.respondSerializationSchema` (`Bytes<128>`). */
+export const RESPOND_SERIALIZATION_SCHEMA_BYTES = 128;
+/** Width of `EVMCalldata.selector` (`Bytes<4>`) — the literal first 4 calldata bytes. */
+export const SELECTOR_BYTES = 4;
+/** Width of `RespondBidirectional.serializedOutput` (`Bytes<128>`). */
+export const SERIALIZED_OUTPUT_BYTES = 128;
+/**
+ * The MPC's error sentinel: `serializedOutput` beginning with these four
+ * bytes marks a failed/absent remote execution (mirrors the sig-net MPC's
+ * MAGIC_ERROR_PREFIX).
+ */
+export const MPC_ERROR_SENTINEL = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+/**
+ * Whether an attestation's serialized output reports a successful remote
+ * execution: the first byte is 1 — the little-endian encoding of the
+ * ABI-decoded success flag, matching the circuits'
+ * `serializedOutput as Field == 1` check.
+ *
+ * @param serializedOutput - The attestation's serialized output.
+ * @returns `true` when the remote call succeeded.
+ */
+export function executionSucceeded(serializedOutput) {
+    return serializedOutput[0] === 1;
+}
+/**
+ * Whether an attestation's serialized output is the MPC's error sentinel
+ * (see {@link MPC_ERROR_SENTINEL}) rather than a call result.
+ *
+ * @param serializedOutput - The attestation's serialized output.
+ * @returns `true` when the MPC reported an execution error.
+ */
+export function isExecutionError(serializedOutput) {
+    return MPC_ERROR_SENTINEL.every((byte, index) => serializedOutput[index] === byte);
+}
+/** Signature algorithm the MPC uses for EVM chains (`algo` field value). */
+export const SIGNET_ALGO_ECDSA = "ecdsa";
+/** Destination chain family for EVM requests (`dest` field value). */
+export const SIGNET_DEST_ETHEREUM = "ethereum";
+/**
+ * Default MPC key version (`keyVersion` field value). Version 0 is the
+ * unsupported legacy format — the canonical MPC (and
+ * `constructSignBidirectionalRequest`) requires `keyVersion >= 1`.
+ */
+export const SIGNET_DEFAULT_KEY_VERSION = 1n;
+/**
+ * Encode text as zero-padded ASCII bytes — the Compact `pad(N, "text")`
+ * convention every string-ish field of the request structs uses (consumers
+ * NUL-trim on decode).
+ *
+ * @param text - The ASCII text to encode.
+ * @param length - The fixed field width in bytes.
+ * @returns `text`'s bytes followed by zero padding to exactly `length`.
+ * @throws If the encoded text does not fit in `length` bytes.
+ */
+export function asciiPadded(text, length) {
+    const encoded = new TextEncoder().encode(text);
+    if (encoded.length > length) {
+        throw new Error(`"${text}" is ${encoded.length} bytes — does not fit the ${length}-byte field`);
+    }
+    const out = new Uint8Array(length);
+    out.set(encoded);
+    return out;
+}
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,iEAAiE;AACjE,yEAAyE;AACzE,6EAA6E;AAC7E,4EAA4E;AAC5E,kEAAkE;AAClE,EAAE;AACF,2EAA2E;AAC3E,oBAAoB;AAEpB,iEAAiE;AACjE,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC;AAEjC,8DAA8D;AAC9D,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAE7B,8DAA8D;AAC9D,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAE7B,gEAAgE;AAChE,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAEnC,sFAAsF;AACtF,MAAM,CAAC,MAAM,mCAAmC,GAAG,GAAG,CAAC;AAEvD,qFAAqF;AACrF,MAAM,CAAC,MAAM,kCAAkC,GAAG,GAAG,CAAC;AAEtD,yFAAyF;AACzF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC;AAEhC,uEAAuE;AACvE,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAE3E;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,gBAA4B;IAC7D,OAAO,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,gBAA4B;IAC3D,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;AACrF,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAEzC,sEAAsE;AACtE,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;AAE/C;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,MAAc;IACtD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC/C,IAAI,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,IAAI,IAAI,QAAQ,OAAO,CAAC,MAAM,6BAA6B,MAAM,aAAa,CAAC,CAAC;IAClG,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACnC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACjB,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/epsilon-derivation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Domain prefix of the sig-net v1.0.0 epsilon derivation scheme, as used by
+ * the live response server. The full derivation string is
+ * `<prefix>,<chainId>,<requester>,<path>` (comma-separated).
+ */
+export declare const EPSILON_DERIVATION_PREFIX = "sig.network v1.0.0 epsilon derivation";
+/**
+ * CAIP-2 chain id under which the MPC derives keys for requests originating
+ * from Midnight contracts.
+ */
+export declare const MIDNIGHT_TESTNET_CHAIN_ID = "midnight:testnet";
+/**
+ * Derive the EVM address the MPC network signs from for a given Midnight
+ * contract and derivation path, using the sig-net v1.0.0 epsilon scheme:
+ * `epsilon = keccak256("<prefix>,<chainId>,<contractAddress>,<path>")` and
+ * `derivedPubKey = mpcRootPubKey + epsilon * G` on secp256k1.
+ *
+ * The MPC treats `path` as an opaque string: the vault's own account uses the
+ * literal path `"vault"`, a user's account uses the lowercase hex of their
+ * identity commitment.
+ *
+ * @param mpcSecp256k1PubkeyHex - The MPC root secp256k1 public key as 0x-hex
+ *   (compressed or uncompressed; normalized internally).
+ * @param contractAddress - The Midnight contract address the request
+ *   originates from (the "requester" in the derivation string).
+ * @param path - The derivation path string (e.g. `"vault"` or a commitment
+ *   hex).
+ * @param chainId - CAIP-2 chain id component of the derivation string.
+ * @returns The derived EVM address as a 0x-prefixed EIP-55 checksummed string.
+ */
+export declare function deriveEvmAddress(mpcSecp256k1PubkeyHex: string, contractAddress: string, path: string, chainId?: string): string;
+//# sourceMappingURL=epsilon-derivation.d.ts.map

package/dist/epsilon-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epsilon-derivation.d.ts","sourceRoot":"","sources":["../src/epsilon-derivation.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,0CAA0C,CAAC;AAEjF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,qBAAqB,EAAE,MAAM,EAC7B,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,MAAkC,GAC1C,MAAM,CASR"}

package/dist/epsilon-derivation.js

@@ -0,0 +1,54 @@
+// Epsilon key derivation: contract address + path -> derived EVM account.
+//
+// This belongs in github.com/sig-net/signet.js — kept here until upstreamed.
+// It is NOT imported from signet.js because signet.js's `deriveChildPublicKey`
+// implements the v2.0.0 COLON-separated epsilon format
+// (`sig.network v2.0.0 epsilon derivation:<chainId>:<requester>:<path>`),
+// which is incompatible with the live sig-net response server's v1.0.0
+// COMMA-separated format (see solana-signet-program
+// clients/response-server/src/modules/CryptoUtils.ts). The two schemes hash
+// different strings and therefore derive different accounts; this module
+// matches the server.
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { computeAddress, keccak256, SigningKey, toUtf8Bytes } from "ethers";
+/**
+ * Domain prefix of the sig-net v1.0.0 epsilon derivation scheme, as used by
+ * the live response server. The full derivation string is
+ * `<prefix>,<chainId>,<requester>,<path>` (comma-separated).
+ */
+export const EPSILON_DERIVATION_PREFIX = "sig.network v1.0.0 epsilon derivation";
+/**
+ * CAIP-2 chain id under which the MPC derives keys for requests originating
+ * from Midnight contracts.
+ */
+export const MIDNIGHT_TESTNET_CHAIN_ID = "midnight:testnet";
+/**
+ * Derive the EVM address the MPC network signs from for a given Midnight
+ * contract and derivation path, using the sig-net v1.0.0 epsilon scheme:
+ * `epsilon = keccak256("<prefix>,<chainId>,<contractAddress>,<path>")` and
+ * `derivedPubKey = mpcRootPubKey + epsilon * G` on secp256k1.
+ *
+ * The MPC treats `path` as an opaque string: the vault's own account uses the
+ * literal path `"vault"`, a user's account uses the lowercase hex of their
+ * identity commitment.
+ *
+ * @param mpcSecp256k1PubkeyHex - The MPC root secp256k1 public key as 0x-hex
+ *   (compressed or uncompressed; normalized internally).
+ * @param contractAddress - The Midnight contract address the request
+ *   originates from (the "requester" in the derivation string).
+ * @param path - The derivation path string (e.g. `"vault"` or a commitment
+ *   hex).
+ * @param chainId - CAIP-2 chain id component of the derivation string.
+ * @returns The derived EVM address as a 0x-prefixed EIP-55 checksummed string.
+ */
+export function deriveEvmAddress(mpcSecp256k1PubkeyHex, contractAddress, path, chainId = MIDNIGHT_TESTNET_CHAIN_ID) {
+    const fullPath = `${EPSILON_DERIVATION_PREFIX},${chainId},${contractAddress},${path}`;
+    // Reduce mod n before multiplying: noble throws on scalars >= n, whereas the
+    // server's scalar arithmetic reduces implicitly.
+    const epsilon = BigInt(keccak256(toUtf8Bytes(fullPath))) % secp256k1.Point.Fn.ORDER;
+    const rootPubKeyHex = SigningKey.computePublicKey(mpcSecp256k1PubkeyHex, false);
+    const rootPoint = secp256k1.Point.fromHex(rootPubKeyHex.slice(2));
+    const derivedPoint = epsilon === 0n ? rootPoint : rootPoint.add(secp256k1.Point.BASE.multiply(epsilon));
+    return computeAddress(`0x${derivedPoint.toHex(false)}`);
+}
+//# sourceMappingURL=epsilon-derivation.js.map

package/dist/epsilon-derivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"epsilon-derivation.js","sourceRoot":"","sources":["../src/epsilon-derivation.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,uDAAuD;AACvD,0EAA0E;AAC1E,uEAAuE;AACvE,oDAAoD;AACpD,4EAA4E;AAC5E,yEAAyE;AACzE,sBAAsB;AAEtB,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE5E;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,uCAAuC,CAAC;AAEjF;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,kBAAkB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,qBAA6B,EAC7B,eAAuB,EACvB,IAAY,EACZ,UAAkB,yBAAyB;IAE3C,MAAM,QAAQ,GAAG,GAAG,yBAAyB,IAAI,OAAO,IAAI,eAAe,IAAI,IAAI,EAAE,CAAC;IACtF,6EAA6E;IAC7E,iDAAiD;IACjD,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC;IACpF,MAAM,aAAa,GAAG,UAAU,CAAC,gBAAgB,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC;IAChF,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,MAAM,YAAY,GAAG,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;IACxG,OAAO,cAAc,CAAC,KAAK,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAC1D,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./signet-requests.ts";
+export * from "./signature-state-reading.ts";
+export * from "./signature-requests-state-reader.ts";
+export * from "./signet-contract-state-reader.ts";
+export * from "./signature-response-verification.ts";
+export * from "./signet-request-response-reader.ts";
+export * from "./signet-events.ts";
+export * from "./signet-event-observer.ts";
+export * from "./signet-request-resolver.ts";
+export * from "./signet-request-feed.ts";
+export * from "./signet-response-feed.ts";
+export * from "./constants.ts";
+export * from "./epsilon-derivation.ts";
+export * from "./schnorr.ts";
+/**
+ * Compiled pure circuits of Signet.compact (run `yarn compile` first): the
+ * executable reference implementation of the client-agnostic circuits —
+ * path<->identity checks, the attestation message, and the Schnorr challenge.
+ * Off-chain code MUST use these instead of re-porting the algorithms — they
+ * are the same compiled logic the contracts prove. The generic request
+ * circuits cannot be compiled here (type-parameterized): request construction
+ * is contract-only, and request-id hashing has a documented-deviation TS twin
+ * (`calculateRequestId` in signet-requests.ts).
+ */
+export { pureCircuits, type PureCircuits } from "./managed/contract/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAE7B;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+// Midnight-side sig-net integration. See README.md for the module plan:
+// request-id, calldata-builder, tx-builder, codec, constants, schnorr,
+// state-reader, response-poller — ported bit by bit from the old repo's
+// boilerplate/contract-cli/src/signet/.
+export * from "./signet-requests.js";
+export * from "./signature-state-reading.js";
+export * from "./signature-requests-state-reader.js";
+export * from "./signet-contract-state-reader.js";
+export * from "./signature-response-verification.js";
+export * from "./signet-request-response-reader.js";
+export * from "./signet-events.js";
+export * from "./signet-event-observer.js";
+export * from "./signet-request-resolver.js";
+export * from "./signet-request-feed.js";
+export * from "./signet-response-feed.js";
+export * from "./constants.js";
+export * from "./epsilon-derivation.js";
+export * from "./schnorr.js";
+/**
+ * Compiled pure circuits of Signet.compact (run `yarn compile` first): the
+ * executable reference implementation of the client-agnostic circuits —
+ * path<->identity checks, the attestation message, and the Schnorr challenge.
+ * Off-chain code MUST use these instead of re-porting the algorithms — they
+ * are the same compiled logic the contracts prove. The generic request
+ * circuits cannot be compiled here (type-parameterized): request construction
+ * is contract-only, and request-id hashing has a documented-deviation TS twin
+ * (`calculateRequestId` in signet-requests.ts).
+ */
+export { pureCircuits } from "./managed/contract/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,uEAAuE;AACvE,wEAAwE;AACxE,wCAAwC;AAExC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAE7B;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC"}

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

@@ -0,0 +1,165 @@
+{
+  "compiler-version": "0.33.0",
+  "language-version": "0.25.0",
+  "runtime-version": "0.18.0-rc.0",
+  "circuits": [
+    {
+      "name": "evmAddressAbiValue",
+      "pure": true,
+      "proof": false,
+      "arguments": [
+        {
+          "name": "addr",
+          "type": {
+            "type-name": "Bytes",
+            "length": 20
+          }
+        }
+      ],
+      "result-type": {
+        "type-name": "Field"
+      }
+    },
+    {
+      "name": "signetAttestationMessage",
+      "pure": true,
+      "proof": false,
+      "arguments": [
+        {
+          "name": "requestId",
+          "type": {
+            "type-name": "Alias",
+            "name": "RequestId",
+            "type": {
+              "type-name": "Bytes",
+              "length": 32
+            }
+          }
+        },
+        {
+          "name": "serializedOutput",
+          "type": {
+            "type-name": "Bytes",
+            "length": 128
+          }
+        },
+        {
+          "name": "outputLen",
+          "type": {
+            "type-name": "Uint",
+            "maxval": 255
+          }
+        }
+      ],
+      "result-type": {
+        "type-name": "Vector",
+        "length": 4,
+        "type": {
+          "type-name": "Field"
+        }
+      }
+    },
+    {
+      "name": "assertHexOf",
+      "pure": true,
+      "proof": false,
+      "arguments": [
+        {
+          "name": "commitment",
+          "type": {
+            "type-name": "Bytes",
+            "length": 32
+          }
+        },
+        {
+          "name": "hexStr",
+          "type": {
+            "type-name": "Bytes",
+            "length": 64
+          }
+        }
+      ],
+      "result-type": {
+        "type-name": "Tuple",
+        "types": [
+        ]
+      }
+    },
+    {
+      "name": "assertPathCommitment",
+      "pure": true,
+      "proof": false,
+      "arguments": [
+        {
+          "name": "commitment",
+          "type": {
+            "type-name": "Bytes",
+            "length": 32
+          }
+        },
+        {
+          "name": "path",
+          "type": {
+            "type-name": "Bytes",
+            "length": 256
+          }
+        }
+      ],
+      "result-type": {
+        "type-name": "Tuple",
+        "types": [
+        ]
+      }
+    },
+    {
+      "name": "schnorrChallenge",
+      "pure": true,
+      "proof": false,
+      "arguments": [
+        {
+          "name": "ann_x",
+          "type": {
+            "type-name": "Field"
+          }
+        },
+        {
+          "name": "ann_y",
+          "type": {
+            "type-name": "Field"
+          }
+        },
+        {
+          "name": "pk_x",
+          "type": {
+            "type-name": "Field"
+          }
+        },
+        {
+          "name": "pk_y",
+          "type": {
+            "type-name": "Field"
+          }
+        },
+        {
+          "name": "msg",
+          "type": {
+            "type-name": "Vector",
+            "length": 4,
+            "type": {
+              "type-name": "Field"
+            }
+          }
+        }
+      ],
+      "result-type": {
+        "type-name": "Field"
+      }
+    }
+  ],
+  "witnesses": [
+  ],
+  "contracts": [
+  ],
+  "ledger": [
+  ]
+}

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

@@ -0,0 +1,32 @@
+{
+  "manifest-version": "1",
+  "compiler-version": "0.33.0",
+  "language-version": "0.25.0",
+  "runtime-version": "0.18.0-rc.0",
+  "compiler": {
+    "type": "directory",
+    "contract-info.json": {
+      "type": "file",
+      "size": 3135,
+      "hash": "9d2395e0039bbce65bda3e89eaa3832b8cc9e9b00ed39a40ed0f69bf599d96be"
+    }
+  },
+  "contract": {
+    "type": "directory",
+    "index.d.ts": {
+      "type": "file",
+      "size": 2665,
+      "hash": "88892cc8a7682b384a9cbce21339f382916a978777853f81350e55f9510e223c"
+    },
+    "index.js": {
+      "type": "file",
+      "size": 39675,
+      "hash": "6de3c60def5fa9eff08b822b79070f3005ec94972d09b90fbdef95d6443e61b3"
+    },
+    "index.js.map": {
+      "type": "file",
+      "size": 2850,
+      "hash": "ce08afea972941a9da6f6291389381be8ae956f5477b5281d3cbc0ba749fe196"
+    }
+  }
+}

package/dist/managed/contract/index.d.ts

@@ -0,0 +1,65 @@
+import type * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
+
+export type Witnesses<PS> = {
+}
+
+export type ImpureCircuits<PS> = {
+}
+
+export type ProvableCircuits<PS> = {
+}
+
+export type PureCircuits = {
+  evmAddressAbiValue(addr_0: Uint8Array): bigint;
+  signetAttestationMessage(requestId_0: Uint8Array,
+                           serializedOutput_0: Uint8Array,
+                           outputLen_0: bigint): bigint[];
+  assertHexOf(commitment_0: Uint8Array, hexStr_0: Uint8Array): [];
+  assertPathCommitment(commitment_0: Uint8Array, path_0: Uint8Array): [];
+  schnorrChallenge(ann_x_0: bigint,
+                   ann_y_0: bigint,
+                   pk_x_0: bigint,
+                   pk_y_0: bigint,
+                   msg_0: bigint[]): bigint;
+}
+
+export type Circuits<PS> = {
+  evmAddressAbiValue(context: __compactRuntime.CircuitContext<PS>,
+                     addr_0: Uint8Array): Promise<__compactRuntime.CircuitResults<PS, bigint>>;
+  signetAttestationMessage(context: __compactRuntime.CircuitContext<PS>,
+                           requestId_0: Uint8Array,
+                           serializedOutput_0: Uint8Array,
+                           outputLen_0: bigint): Promise<__compactRuntime.CircuitResults<PS, bigint[]>>;
+  assertHexOf(context: __compactRuntime.CircuitContext<PS>,
+              commitment_0: Uint8Array,
+              hexStr_0: Uint8Array): Promise<__compactRuntime.CircuitResults<PS, []>>;
+  assertPathCommitment(context: __compactRuntime.CircuitContext<PS>,
+                       commitment_0: Uint8Array,
+                       path_0: Uint8Array): Promise<__compactRuntime.CircuitResults<PS, []>>;
+  schnorrChallenge(context: __compactRuntime.CircuitContext<PS>,
+                   ann_x_0: bigint,
+                   ann_y_0: bigint,
+                   pk_x_0: bigint,
+                   pk_y_0: bigint,
+                   msg_0: bigint[]): Promise<__compactRuntime.CircuitResults<PS, bigint>>;
+}
+
+export type Ledger = {
+}
+
+export type ContractReferenceLocations = any;
+
+export declare const contractReferenceLocations : ContractReferenceLocations;
+
+export declare class Contract<PS = any, W extends Witnesses<PS> = Witnesses<PS>> {
+  witnesses: W;
+  circuits: Circuits<PS>;
+  impureCircuits: ImpureCircuits<PS>;
+  provableCircuits: ProvableCircuits<PS>;
+  constructor(witnesses: W);
+  initialState(context: __compactRuntime.ConstructorContext<PS>): Promise<__compactRuntime.ConstructorResult<PS>>;
+}
+
+export declare function ledger(state: __compactRuntime.StateValue | __compactRuntime.ChargedState): Ledger;
+export declare const pureCircuits: PureCircuits;
+export declare const expectedVk: Record<string, string>;