@sig-net/midnight 0.0.1

package/src/epsilon-derivation.ts

@@ -0,0 +1,62 @@
+// 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: string,
+  contractAddress: string,
+  path: string,
+  chainId: string = MIDNIGHT_TESTNET_CHAIN_ID,
+): string {
+  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)}`);
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+// 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.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";

package/src/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/src/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/src/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>;