@sig-net/midnight 0.0.1

package/dist/signet-requests.d.ts

@@ -0,0 +1,363 @@
+import { type CompactType } from "@midnight-ntwrk/compact-runtime";
+import { Signature, Transaction } from "ethers";
+import type { SignatureResponse } from "./signet-contract-state-reader.ts";
+/**
+ * 32-byte signet request id (Compact: `new type RequestId = Bytes<32>`).
+ * Chain-agnostic: downstream consumers treat it as an opaque key. Ids are
+ * minted by `calculateRequestId` in Signet.compact — the domain-separated
+ * hash of the full {@link SignBidirectionalRequest} record.
+ */
+export type RequestId = Uint8Array;
+/**
+ * Which transaction-param decomposition a request carries (Compact:
+ * `enum TxParamType`), as the generated code represents enums: a `number`
+ * holding the 0-based variant index. Exported as a `const` object (not a TS
+ * `enum`) so the values stay structurally `number`.
+ */
+export declare const TxParamType: {
+    /** {@link EVMType2TxParams}: an EIP-1559 EVM transaction. */
+    readonly evmType2: 0;
+    /**
+     * Never emitted — mirrors the Compact-side padding variant that keeps the
+     * enum at >= 2 variants (a 1-variant enum is a zero-byte value the proof
+     * server cannot parse inside persistentHash preimages).
+     */
+    readonly reserved: 1;
+};
+/**
+ * Compact's standard-library `Maybe<T>` as the compiler generates it: a
+ * plain struct. Even when `is_some` is false, `value` carries a full
+ * default-valued `T` (so vector capacities remain inferable).
+ */
+export interface Maybe<T> {
+    is_some: boolean;
+    value: T;
+}
+/**
+ * ABI calldata as a 4-byte selector + 32-byte word slots (Compact:
+ * `EVMCalldata<#maxWords>`). Each word is a little-endian field embed (what the
+ * contract's `x as Field as Bytes<32>` cast produces); the MPC re-encodes the
+ * leading {@link noWords} of them big-endian to form the calldata body —
+ * `data = selector || BE(words[0..noWords])`, see {@link assembleCalldata}.
+ */
+export interface EVMCalldata {
+    /** The literal first 4 calldata bytes (big-endian, as broadcast). */
+    selector: Uint8Array;
+    /** How many leading {@link words} are real (Compact `noWords: Uint<16>`). */
+    noWords: bigint;
+    /** 32-byte word slots; capacity is the contract's `#maxWords` (vault: 2). */
+    words: Uint8Array[];
+}
+/**
+ * One EIP-2930 access-list entry (Compact:
+ * `EVMAccessListEntry<#maxStorageKeys>`).
+ */
+export interface EVMAccessListEntry {
+    /** The pre-declared contract address, 20 display-order bytes. */
+    address: Uint8Array;
+    /** How many leading {@link storageKeys} are real. */
+    storageKeyCount: bigint;
+    /** Raw 32-byte storage keys, copied verbatim into the transaction. */
+    storageKeys: Uint8Array[];
+}
+/**
+ * The EVM transaction to be signed, decomposed into typed fields (Compact:
+ * `EVMType2TxParams<#maxCalldataWords, #maxAccessListEntries,
+ * #maxStorageKeysPerEntry>`; EIP-1559 — https://eips.ethereum.org/EIPS/eip-1559).
+ * Compact `Bytes<N>` fields arrive as N-byte `Uint8Array`s, `Uint<N>` as
+ * `bigint`. Vector capacities are each contract's compile-time throttle;
+ * the runtime counts say how many leading slots are real.
+ */
+export interface EVMType2TxParams {
+    /** Call target (e.g. the ERC20 contract), 20 bytes. */
+    to: Uint8Array;
+    /** EVM chain id (also expressed in {@link SignBidirectionalRequest.caip2Id}). */
+    chainId: bigint;
+    /** Account nonce of the MPC-derived sender address. */
+    nonce: bigint;
+    /** Gas ceiling for the call. */
+    gasLimit: bigint;
+    /** Max total fee per gas, wei. */
+    maxFeePerGas: bigint;
+    /** Max priority fee per gas, wei. */
+    maxPriorityFeePerGas: bigint;
+    /** ETH sent with the call, wei. */
+    value: bigint;
+    /** How many leading {@link accessList} entries are real. */
+    accessListEntryCount: bigint;
+    /** EIP-2930 access list slots (capacity = contract's throttle). */
+    accessList: EVMAccessListEntry[];
+    /** Call data; `is_some: false` means a plain ETH transfer (`0x` data). */
+    calldata: Maybe<EVMCalldata>;
+}
+/**
+ * Canonical signet request record (Compact:
+ * `SignBidirectionalRequest<TxParams>`), stored per {@link RequestId} in a
+ * requesting contract's index (ledger field 0). Mirrors the MPC's
+ * SignBidirectionalRequest with the transaction decomposed. The TS twin fixes
+ * the type parameter at {@link EVMType2TxParams} — the only decomposition
+ * so far; new tx kinds add a union here alongside their Compact struct.
+ */
+export interface SignBidirectionalRequest {
+    /** Contract-local nonce captured when the request was created. */
+    requestNonce: bigint;
+    /** A {@link TxParamType} value tagging the txParams decomposition. */
+    txParamType: number;
+    /** The transaction decomposition. */
+    txParams: EVMType2TxParams;
+    /** Target chain in CAIP-2 form (https://chainagnostic.org/CAIPs/caip-2), zero-padded; 32 bytes. */
+    caip2Id: Uint8Array;
+    /** MPC root-key version to derive from (>= 1; version 0 is the unsupported legacy format). */
+    keyVersion: bigint;
+    /** Key-derivation path: canonical lowercase hex of the caller's identity commitment, zero-padded; 256 bytes. */
+    path: Uint8Array;
+    /** Signature scheme, zero-padded ASCII, e.g. "ecdsa"; 32 bytes. */
+    algo: Uint8Array;
+    /** Response destination, zero-padded ASCII, e.g. "ethereum"; 32 bytes. */
+    dest: Uint8Array;
+    /** Scheme-specific extras, opaque; 64 bytes. */
+    params: Uint8Array;
+    /** MPC output_deserialization_schema (destination chain -> MPC); 128 bytes. */
+    outputDeserializationSchema: Uint8Array;
+    /** MPC respond_serialization_schema (MPC -> source chain); 128 bytes. */
+    respondSerializationSchema: Uint8Array;
+}
+/**
+ * Descriptor of {@link EVMCalldata} at one word capacity — the TS analogue
+ * of instantiating Compact's `EVMCalldata<#maxWords>`.
+ *
+ * @param maxWords - The contract's calldata word capacity (the vault uses 2).
+ * @returns The calldata descriptor.
+ */
+export declare function evmCalldataDescriptor(maxWords: number): CompactType<EVMCalldata>;
+/**
+ * Descriptor of {@link EVMAccessListEntry} at one storage-key capacity
+ * (Compact: `EVMAccessListEntry<#maxStorageKeys>`).
+ *
+ * @param maxStorageKeys - Storage-key capacity per entry.
+ * @returns The entry descriptor.
+ */
+export declare function evmAccessListEntryDescriptor(maxStorageKeys: number): CompactType<EVMAccessListEntry>;
+/**
+ * Descriptor of {@link EVMType2TxParams} at one capacity instantiation —
+ * the TS analogue of Compact's `EVMType2TxParams<#maxCalldataWords,
+ * #maxAccessListEntries, #maxStorageKeysPerEntry>`.
+ *
+ * @param maxCalldataWords - Calldata word capacity.
+ * @param maxAccessListEntries - Access-list entry capacity.
+ * @param maxStorageKeysPerEntry - Storage-key capacity per entry.
+ * @returns The tx-params descriptor.
+ */
+export declare function evmType2TxParamsDescriptor(maxCalldataWords: number, maxAccessListEntries: number, maxStorageKeysPerEntry: number): CompactType<EVMType2TxParams>;
+/**
+ * Descriptor of {@link SignBidirectionalRequest} at one capacity instantiation.
+ *
+ * @param maxCalldataWords - Calldata word capacity.
+ * @param maxAccessListEntries - Access-list entry capacity.
+ * @param maxStorageKeysPerEntry - Storage-key capacity per entry.
+ * @returns The request record descriptor.
+ */
+export declare function signBidirectionalRequestDescriptor(maxCalldataWords: number, maxAccessListEntries: number, maxStorageKeysPerEntry: number): CompactType<SignBidirectionalRequest>;
+/**
+ * Canonical id of a signet request: the domain-separated persistent hash of
+ * the entire request record. TS twin of Signet.compact's `calculateRequestId`
+ * circuit (see the deviation note atop this section), generic over the
+ * capacity instantiation via the record's own array lengths — pass the
+ * record exactly as the ledger stores it, unused slots included.
+ *
+ * @param request - The full request record (contract-shaped, all slots).
+ * @returns The 32-byte request id — the record's ledger map key.
+ */
+export declare function calculateRequestId(request: SignBidirectionalRequest): RequestId;
+/**
+ * The 32-byte value of a numeric ABI word: the little-endian field embed of
+ * the number, exactly what Compact's `x as Field as Bytes<32>` cast produces
+ * in-circuit. Use when building words off-chain (UIs, expected-record
+ * builders, tests).
+ *
+ * @param value - The word's numeric value (e.g. an amount).
+ * @returns The 32-byte LE embed to store in an {@link EVMCalldata} word.
+ */
+export declare function numericAbiWordValue(value: bigint): Uint8Array;
+/**
+ * The 32-byte staticArg word value for an EVM address: the BIG-ENDIAN
+ * numeric reading of its 20 display-order bytes, LE-embedded. TS mirror of
+ * Signet.compact's `evmAddressAbiValue` circuit (+ `as Bytes<32>`); see the
+ * warning there — embedding the display-order bytes directly would come out
+ * byte-reversed in the assembled calldata.
+ *
+ * @param address - The 20-byte address in display order.
+ * @returns The 32-byte word value to store in an {@link EVMCalldata} word.
+ */
+export declare function evmAddressAbiWord(address: Uint8Array): Uint8Array;
+/**
+ * Re-assemble the raw calldata a request's words describe:
+ * `data = selector || BE(words[0..noWords])`. Each word is a little-endian
+ * field embed (the contract's `x as Field as Bytes<32>` cast); the leading
+ * `noWords` are re-encoded big-endian into 32-byte ABI words and any remaining
+ * capacity slots are dropped. This is THE implementation of the MPC re-assembly
+ * documented on `EVMCalldata` in Signet.compact.
+ *
+ * @param calldata - The request's calldata field.
+ * @returns Hex calldata for the transaction (`"0x"` when absent).
+ */
+export declare function assembleCalldata(calldata: Maybe<EVMCalldata>): string;
+/**
+ * Rebuild the unsigned EIP-1559 transaction a request record describes,
+ * byte-identical to the one the MPC assembles and signs: calldata from the
+ * tagged words (see {@link assembleCalldata}), the count-trimmed access
+ * list, and the stored envelope fields. This is the canonical
+ * request→transaction transform; response-side verification
+ * (`signature-response-verification.ts`) and the signed-transaction builder
+ * below both go through it, so the transaction a client broadcasts is
+ * provably the one the MPC put its signature over.
+ *
+ * @param event - The on-ledger request record.
+ * @returns The unsigned ethers transaction (`unsignedHash` is the digest the
+ *   MPC signs).
+ * @throws Error if a calldata word carries an unknown kind.
+ */
+export declare function signBidirectionalRequestToUnsignedEVMTransaction(event: SignBidirectionalRequest): Transaction;
+/**
+ * Decode a response signature record (as posted to the signet contract's
+ * signature response log — the canonical MPC `Signature { big_r, s,
+ * recovery_id }` shape) into an ethers {@link Signature}: `r` is `bigR`'s x
+ * coordinate, `v` the legacy parity derived from the recovery id.
+ *
+ * @param response - The posted signature record.
+ * @returns The ethers signature.
+ * @throws Error if the recovery id is not 0 or 1.
+ */
+export declare function signatureResponseToSignature(response: SignatureResponse): Signature;
+/**
+ * Encode an ECDSA signature as the response record posted to the signet
+ * contract — the inverse of {@link signatureResponseToSignature},
+ * for MPC-side posters (the fakenet signer, tests). The canonical record
+ * carries `bigR` as a full affine point but an `r || s || v` signature only
+ * has R.x and the parity of R.y, so R.y is recovered by decompressing the
+ * point on the curve (y² = x³ + 7 over the secp256k1 base field).
+ *
+ * The parameter is structural (the r/s/yParity subset of an ethers
+ * {@link Signature}) so signatures from ANY ethers instance qualify — posters
+ * living in other repos resolve their own ethers install, and nominal class
+ * typing would reject it.
+ *
+ * @param signature - The signature to encode (`r`/`s` as 0x hex, `yParity` 0 or 1).
+ * @returns The response record, ready to post.
+ * @throws Error if `r` is not the x coordinate of a curve point.
+ */
+export declare function signatureToSignatureResponse(signature: Pick<Signature, "r" | "s" | "yParity">): SignatureResponse;
+/**
+ * Assemble the broadcast-ready signed EIP-1559 transaction for a request from
+ * its MPC signature response: rebuild the exact unsigned transaction the MPC
+ * signed (see {@link signBidirectionalRequestToUnsignedEVMTransaction}) and
+ * attach the signature. Does NOT check that the signature recovers to the
+ * requester's derived address — the response log is unauthenticated, so
+ * verify first with `verifySignatureResponse`.
+ *
+ * @param event - The on-ledger request record.
+ * @param response - The posted signature record answering it.
+ * @returns The signed ethers transaction; `serialized` is the raw payload for
+ *   `eth_sendRawTransaction`, `hash` its on-chain hash, `from` the recovered
+ *   sender.
+ * @throws Error if the request record is malformed (see
+ *   {@link signBidirectionalRequestToUnsignedEVMTransaction}) or the response
+ *   is not a decodable signature.
+ */
+export declare function signBidirectionalRequestToSignedEVMTransaction(event: SignBidirectionalRequest, response: SignatureResponse): Transaction;
+/**
+ * The generated ledger shape of `Map<RequestId, SignBidirectionalRequest>`:
+ * what a contract's `ledger(state).signetRequestsIndex` provides. Structural,
+ * so any contract exposing the index satisfies it.
+ */
+export interface SignBidirectionalRequestLedgerIndex extends Iterable<[RequestId, SignBidirectionalRequest]> {
+    /** @returns `true` when the index holds no requests. */
+    isEmpty(): boolean;
+    /** @returns Number of requests in the index. */
+    size(): bigint;
+    /**
+     * @param requestId - 32-byte request id to probe.
+     * @returns `true` when the index holds an entry for `requestId`.
+     */
+    member(requestId: RequestId): boolean;
+    /**
+     * @param requestId - 32-byte request id to fetch.
+     * @returns The stored request record; throws when absent — guard with
+     *   {@link member} first.
+     */
+    lookup(requestId: RequestId): SignBidirectionalRequest;
+}
+declare const requestIdHexBrand: unique symbol;
+/**
+ * 64-char lowercase hex rendering of a {@link RequestId} — THE
+ * representation of a request id everywhere in TypeScript. Raw
+ * {@link RequestId} bytes appear only at the Compact boundary (state
+ * readers, compiled-circuit calls); the moment an id crosses that boundary it
+ * becomes this type. Branded (the TS analogue of Compact's `new type`) so an
+ * arbitrary string cannot pose as a request id: mint one with
+ * {@link requestIdHex} (from ledger bytes) or {@link parseRequestIdHex}
+ * (from user input), and go back to bytes with {@link requestIdBytes}.
+ */
+export type RequestIdHex = string & {
+    readonly [requestIdHexBrand]: true;
+};
+/** Plain-JS index parsed out of the ledger, keyed by hex request id. */
+export type SignBidirectionalRequestIndex = Map<RequestIdHex, SignBidirectionalRequest>;
+/**
+ * Render bytes as a lowercase hex string, no `0x` prefix.
+ *
+ * @param bytes - The bytes to render.
+ * @returns Lowercase hex, two chars per byte.
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Render a request id in its canonical TS form (see
+ * {@link RequestIdHex}) — also usable as a JS `Map` key, which raw
+ * `Uint8Array` ids are not (they compare by reference).
+ *
+ * @param requestId - 32-byte request id.
+ * @returns The branded 64-char lowercase hex string, no `0x` prefix.
+ */
+export declare function requestIdHex(requestId: RequestId): RequestIdHex;
+/**
+ * Validate and normalize an untrusted string (CLI argument, config value)
+ * into a {@link RequestIdHex}: an optional `0x` prefix is stripped and
+ * the digits lowercased before validation.
+ *
+ * @param value - The candidate request id string.
+ * @returns The branded, normalized request id hex.
+ * @throws Error if the value is not 64 hex chars after normalization.
+ */
+export declare function parseRequestIdHex(value: string): RequestIdHex;
+/**
+ * Decode a request id back to its 32 raw bytes for the Compact boundary
+ * (compiled-circuit calls, ledger lookups).
+ *
+ * @param id - The request id in canonical hex form.
+ * @returns The 32-byte request id.
+ */
+export declare function requestIdBytes(id: RequestIdHex): RequestId;
+/** Byte width of the path field (Compact `Bytes<256>`). */
+export declare const PATH_BYTES = 256;
+/**
+ * Build the canonical MPC derivation path for an identity commitment: the
+ * lowercase hex of the commitment as ASCII, zero-padded to {@link PATH_BYTES}
+ * — exactly what the contract's `assertPathCommitment` accepts. Use this to
+ * populate {@link SignBidirectionalRequest.path} when constructing requests.
+ *
+ * @param commitment - 32-byte identity commitment.
+ * @returns The 256-byte path field value.
+ */
+export declare function signetPathOfCommitment(commitment: Uint8Array): Uint8Array;
+/**
+ * Parse the on-ledger request map into a plain-JS index keyed by hex
+ * request id.
+ *
+ * @param ledgerIndex - Iterable of `[requestId, request]` entries — e.g. a
+ *   contract's `ledger(state).signetRequestsIndex` (any
+ *   {@link SignBidirectionalRequestLedgerIndex}).
+ * @returns A new `Map` from {@link requestIdHex} key to request record.
+ */
+export declare function toSignBidirectionalRequestIndex(ledgerIndex: Iterable<[RequestId, SignBidirectionalRequest]>): SignBidirectionalRequestIndex;
+export {};
+//# sourceMappingURL=signet-requests.d.ts.map

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

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