@sig-net/midnight 0.24.0-rc.6 → 0.24.0-rc.9

package/dist/abi-serde.js

@@ -1,60 +1,4 @@
-// The two schema-driven conversions every Signet participant performs on the
-// respond path, named after the protocol fields that drive them, and the
-// MPC's rule composing them for an executed EVM transaction:
-//
-//   EVM call result --deserializeEvmOutput--> decoded values
-//                        (outputDeserializationSchema)
-//   decoded values --serializeRespondOutput--> RespondBidirectionalEvent bytes
-//                        (respondSerializationSchema)
-//   callTracer top frame --evmTraceOutputFromCallFrame--> the trace
-//   executed EVM transaction --executedEvmRespondOutput--> attested bytes
-//                        (both schemas, isEvmContractCall, the trace)
-//
-// Run by fakenet and the real MPC after the destination-chain transaction
-// confirms, and by Signet clients to independently recompute the respond
-// bytes the MPC attested or to display a decoded result. A client
-// recomputing an attestation calls executedEvmRespondOutput: the MPC decodes
-// and re-packs a contract call's return data, and synthesises the output
-// of a plain transfer or a void call from the respond schema alone.
-//
-// The respond output is UNBOUNDED: this module never pads or clamps it. Any
-// fixed event-field width is the caller's concern. Schemas are the ABI-style
-// JSON carried on chain (NUL-padded fixed-width bytes). Every function
-// accepts the schema in any form: already-parsed fields, a JSON string, or
-// the raw on-chain bytes. An EMPTY output schema (an unset all-NUL field, a
-// blank string, or `[]`) decodes to no values. A respond schema must be
-// non-empty, and its declared capacities are bounded
-// ({@link MAX_RESPOND_PACKED_BYTES}): schemas are requester-authored
-// on-chain data, so the responder never honours a schema demanding a giant
-// allocation.
-//
-// Decode-side type grammar is left FULLY to the ABI library (ethers): this
-// module checks only the schema's shape. Respond-side types are restricted
-// to the Compact-carrier vocabulary below, strictly enforced.
-//
-// The respond byte layout is Compact's builtin serialize<T, N> /
-// deserialize<T, N> (via @sig-net/midnight-serde, pinned against compiled
-// circuits), so a consumer contract reads the payload with ONE
-// deserialize<T, N> call. Per-type mapping (Compact struct field on the
-// right):
-//   bool            1 byte                    Boolean
-//   uint8..uint248  bits / 8 bytes LE         Uint<bits>
-//     (whole-byte widths only: multiples of 8, others are rejected)
-//   uint256, field  32 bytes LE, below Fr     Field
-//   address         32 bytes LE (numeric)     Field
-//   bytes1..bytes32 N raw bytes               Bytes<N>
-//   string, bytes   8-byte LE length + payload zero-padded to maxBytes
-//                                             struct { len: Uint<64>; data: Bytes<maxBytes>; }
-//   T[]             8-byte LE count + maxItems elements at T's width
-//                                             struct { len: Uint<64>; items: Vector<maxItems, T>; }
-//   intN            rejected: Compact has no signed integers
-//
-// RANGE TRAP: uint256, address and field all map to Compact `Field`, whose
-// values must lie strictly below the BLS12-381 Fr modulus (just under
-// 2^255). An EVM uint256 at or above Fr cannot be respond-serialised, and
-// `serializeRespondOutput` throws at respond time. Schema authors who need
-// the full 256-bit range carry the value as bytes32.
-import { compactSerialize, compactSerializedSize, } from "@sig-net/midnight-serde";
+import { compactSerialize } from "@sig-net/midnight-serde";
 import { ethers } from "ethers";
 // ---------------------------------------------------------------------------
 // 1. EVM call result -> decoded values  (outputDeserializationSchema)
@@ -64,10 +8,10 @@ import { ethers } from "ethers";
  * into named values, driven by the request's outputDeserializationSchema.
  * The decode-side counterpart of {@link serializeRespondOutput}. Type
  * validation is FULLY delegated to ethers: this function checks the schema's
- * shape only. An empty schema decodes to an empty object. The MPC never
- * decodes under an empty schema: {@link executedEvmRespondOutput} carries
- * its rule for that case. Returns a plain object (never an ethers
- * `Result`), so it survives JSON round-trips and structural comparison.
+ * shape only, so it decodes ABI types the respond side refuses. An empty
+ * schema decodes to an empty object. Returns a plain object (never an
+ * ethers `Result`), so it survives JSON round-trips and structural
+ * comparison.
  *
  * @param schema - The outputDeserializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
  * @param callResult - The ABI-encoded return data (hex string or bytes).
@@ -86,54 +30,204 @@ export function deserializeEvmOutput(schema, callResult) {
     return output;
 }
 // ---------------------------------------------------------------------------
-// 2. decoded values -> respond bytes  (respondSerializationSchema)
+// 2. decoded values -> respond bytes  (Borsh schema derived from the output schema)
 // ---------------------------------------------------------------------------
 /**
- * Ceiling on a respond schema's total packed byte width. Schemas are
- * requester-authored on-chain data, so unbounded maxBytes/maxItems would let
- * a hostile request demand giant allocations from the responder. A real
- * respond payload must fit its consumer contract's fixed `deserialize<T, N>`
- * width, orders of magnitude below this.
+ * The ABI output types the MPC attests, and what each maps to. The respond
+ * bytes are the Borsh serialisation of a struct with one member per output
+ * field, in schema order, typed by this mapping:
+ *
+ * - {@link EvmOutputTypeKind.Bool}: ABI `bool`, Borsh `bool`, Compact `Boolean` (1 byte).
+ * - {@link EvmOutputTypeKind.Uint256}: ABI `uint256`, Borsh `[u8; 32]`
+ *   holding the value LITTLE-endian, the byte order of every Borsh and
+ *   Compact integer, Compact `Bytes<32>` (32 bytes). A circuit that wants a
+ *   number narrows it with `checkedTruncationU128`, which aborts above
+ *   2^128 - 1. The ABI wire word is big-endian: the MPC reverses it once,
+ *   here, so no circuit has to.
+ * - {@link EvmOutputTypeKind.Address}: ABI `address`, Borsh `[u8; 20]`
+ *   holding the address bytes, Compact `Bytes<20>` (20 bytes).
+ * - {@link EvmOutputTypeKind.FixedBytes}: ABI `bytes1` to `bytes32`, Borsh
+ *   `[u8; N]`, Compact `Bytes<N>` (N bytes).
+ *
+ * Every other ABI type is unsupported: the MPC drops a request whose output
+ * schema names one, and {@link deriveRespondSchema} throws on it.
  */
-export const MAX_RESPOND_PACKED_BYTES = 65536;
+export var EvmOutputTypeKind;
+(function (EvmOutputTypeKind) {
+    EvmOutputTypeKind["Bool"] = "bool";
+    EvmOutputTypeKind["Uint256"] = "uint256";
+    EvmOutputTypeKind["Address"] = "address";
+    EvmOutputTypeKind["FixedBytes"] = "bytesN";
+})(EvmOutputTypeKind || (EvmOutputTypeKind = {}));
+/** The byte width of an ABI word, and of the Borsh array a `uint256` output maps to. */
+const ABI_WORD_BYTES = 32;
+/** The byte width of an EVM address, and of the Borsh array an `address` output maps to. */
+const EVM_ADDRESS_BYTES = 20;
 /**
- * Encode decoded output values into the respond payload, driven by the
- * request's respondSerializationSchema: the bytes a consumer contract reads
- * with `deserialize<T, N>` and the MPC attests. The respond-side counterpart
- * of {@link deserializeEvmOutput}.
+ * Classify an ABI type string into the supported output subset.
  *
- * The result is the PACKED value, unpadded and unbounded: its length follows
- * entirely from the schema, and padding to a fixed container width is the
- * caller's concern. Strict: values are range-checked, dynamic payloads must
- * fit their capacity with no silent truncation, and signed integer types are
- * rejected.
+ * @param type - The ABI type string of an output schema field.
+ * @returns The field's kind and respond byte width, or `undefined` for an unsupported type.
+ */
+function classifyEvmOutputType(type) {
+    if (type === "bool")
+        return { kind: EvmOutputTypeKind.Bool, bytes: 1 };
+    if (type === "uint256")
+        return { kind: EvmOutputTypeKind.Uint256, bytes: ABI_WORD_BYTES };
+    if (type === "address")
+        return { kind: EvmOutputTypeKind.Address, bytes: EVM_ADDRESS_BYTES };
+    const fixedBytes = /^bytes([1-9]|[12][0-9]|3[0-2])$/.exec(type);
+    if (fixedBytes !== null) {
+        return { kind: EvmOutputTypeKind.FixedBytes, bytes: Number(fixedBytes[1]) };
+    }
+    return undefined;
+}
+/**
+ * The fields of an outputDeserializationSchema whose ABI type is outside the
+ * supported subset ({@link EvmOutputTypeKind}). The check itself never
+ * throws on an unsupported type: an empty result means the MPC attests the
+ * request, a non-empty one means it drops it.
  *
- * @param schema - The respondSerializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
- * @param output - Decoded values keyed by field name (from {@link deserializeEvmOutput} or any source using the same forms).
- * @returns The packed respond bytes.
- * @throws {Error} If the schema is empty or malformed, packs to more than
- *   {@link MAX_RESPOND_PACKED_BYTES} bytes, a value falls outside its declared
- *   range, or a dynamic payload exceeds its capacity.
+ * @param schema - The outputDeserializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
+ * @returns The unsupported fields in schema order, empty when every field is supported.
+ * @throws {Error} If the schema is not an array of uniquely named fields (its shape, not its types).
  */
-export function serializeRespondOutput(schema, output) {
-    const fields = normalizeRespondSchema(schema);
-    // Size the descriptor BEFORE any value work: the ceiling check is what
-    // keeps a hostile capacity from ever reaching an allocation.
-    const descriptor = respondSchemaToCompactType(fields);
-    const packedWidth = compactSerializedSize(descriptor);
-    if (packedWidth > MAX_RESPOND_PACKED_BYTES) {
-        throw new Error(`respond schema packs to ${String(packedWidth)} bytes, above the ` +
-            `${String(MAX_RESPOND_PACKED_BYTES)}-byte ceiling`);
+export function unsupportedEvmOutputFields(schema) {
+    return parseSchemaShape(schema).filter((field) => classifyEvmOutputType(field.type) === undefined);
+}
+/**
+ * Parse an output schema and classify every field, refusing the schema as a
+ * whole when any field is unsupported.
+ *
+ * @param schema - The outputDeserializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
+ * @returns The classified fields in schema order.
+ * @throws {Error} If the schema is malformed or names an unsupported ABI type.
+ */
+function classifiedEvmOutputFields(schema) {
+    const fields = parseSchemaShape(schema);
+    const unsupported = fields.filter((field) => classifyEvmOutputType(field.type) === undefined);
+    if (unsupported.length > 0) {
+        throw new Error(`respond output: unsupported ABI output type${unsupported.length > 1 ? "s" : ""} ` +
+            unsupported.map((field) => `'${field.name}' (${field.type})`).join(", ") +
+            ": the MPC attests bool, uint256, address and bytes1 to bytes32 only");
+    }
+    return fields.flatMap((field) => {
+        const classified = classifyEvmOutputType(field.type);
+        return classified === undefined ? [] : [{ ...field, ...classified }];
+    });
+}
+/**
+ * The Borsh schema the respond bytes of an executed call are serialised
+ * with: a struct with one member per output field, in schema order, each
+ * typed by {@link EvmOutputTypeKind}. An empty output schema derives an
+ * empty struct, which serialises to zero bytes.
+ *
+ * @param schema - The outputDeserializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
+ * @returns The derived Borsh struct schema.
+ * @throws {Error} If the schema is malformed or names an unsupported ABI type.
+ */
+export function deriveRespondSchema(schema) {
+    return {
+        struct: Object.fromEntries(classifiedEvmOutputFields(schema).map((field) => [
+            field.name,
+            field.kind === EvmOutputTypeKind.Bool
+                ? "bool"
+                : { array: { type: "u8", len: field.bytes } },
+        ])),
+    };
+}
+/**
+ * The byte width of the respond bytes an output schema derives: the sum of
+ * its fields' widths under {@link EvmOutputTypeKind}, what a settle circuit
+ * declares as its `Bytes<N>` output argument.
+ *
+ * @param schema - The outputDeserializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
+ * @returns The exact serialised width, 0 for an empty schema.
+ * @throws {Error} If the schema is malformed or names an unsupported ABI type.
+ */
+export function respondOutputWidth(schema) {
+    return classifiedEvmOutputFields(schema).reduce((width, field) => width + field.bytes, 0);
+}
+/**
+ * The 32-byte LITTLE-endian encoding of a `uint256` output value, as ethers
+ * decodes it (bigint) or as indexer JSON renders it (a number or a decimal
+ * string). This is the ABI wire word reversed: the Borsh integer byte order,
+ * which a Compact `Uint<128>` reads directly.
+ *
+ * @param value - The decoded value.
+ * @param name - The field name, for the error message.
+ * @returns The value's 32 little-endian bytes.
+ * @throws {RangeError} If the value is not an integer in `0 <= value < 2^256`.
+ */
+function uint256Word(value, name) {
+    if (typeof value !== "bigint" && typeof value !== "number" && typeof value !== "string") {
+        throw new TypeError(`respond output: '${name}' (uint256) expects an integer`);
+    }
+    if (typeof value === "number" && !Number.isSafeInteger(value)) {
+        throw new RangeError(`respond output: '${name}' (uint256) is not a safe integer`);
     }
-    const value = {};
-    for (const field of fields) {
-        const raw = output[field.name];
-        if (raw === undefined) {
+    if (typeof value === "string" && !/^\s*\d+\s*$/.test(value)) {
+        throw new RangeError(`respond output: '${name}' (uint256) is not a decimal integer string`);
+    }
+    const integer = BigInt(value);
+    if (integer < 0n || integer >= 1n << 256n) {
+        throw new RangeError(`respond output: '${name}' (uint256) ${String(integer)} is outside uint256`);
+    }
+    return Array.from(ethers.getBytes(ethers.toBeHex(integer, ABI_WORD_BYTES))).reverse();
+}
+/**
+ * The bytes of an `address` or `bytesN` output value, as ethers decodes it
+ * (a hex string, checksummed for an address) or as bytes. Byte order is the
+ * wire's: these are byte strings, not numbers.
+ *
+ * @param value - The decoded value.
+ * @param field - The field, for the error message.
+ * @returns The value's bytes, length-checked by Borsh against the schema.
+ * @throws {TypeError} If the value is neither a hex string nor bytes.
+ */
+function byteString(value, field) {
+    if (value instanceof Uint8Array)
+        return Array.from(value);
+    if (typeof value === "string")
+        return Array.from(ethers.getBytes(value));
+    throw new TypeError(`respond output: '${field.name}' (${field.type}) expects hex or bytes`);
+}
+/**
+ * Serialise ABI-decoded output into the respond bytes the MPC attests: the
+ * Borsh encoding of {@link deriveRespondSchema}'s struct over the output's
+ * values. A `uint256` is carried whole as 32 little-endian bytes, so no
+ * value is narrowed off chain: a circuit that wants a number narrows the
+ * `Bytes<32>` with `checkedTruncationU128`.
+ *
+ * @param schema - The outputDeserializationSchema: parsed, JSON text, or the raw NUL-padded on-chain bytes.
+ * @param output - The decoded values keyed by field name, as {@link deserializeEvmOutput} returns them.
+ * @returns The unpadded respond bytes, {@link respondOutputWidth} long.
+ * @throws {Error} If the schema is malformed or names an unsupported type, a
+ *   field is missing from `output`, or a value is outside its type.
+ */
+export function serializeRespondOutput(schema, output) {
+    const values = {};
+    for (const field of classifiedEvmOutputFields(schema)) {
+        const value = output[field.name];
+        if (value === undefined)
             throw new Error(`respond output: missing value for '${field.name}'`);
+        switch (field.kind) {
+            case EvmOutputTypeKind.Bool:
+                if (typeof value !== "boolean") {
+                    throw new TypeError(`respond output: '${field.name}' (bool) expects a boolean`);
+                }
+                values[field.name] = value;
+                break;
+            case EvmOutputTypeKind.Uint256:
+                values[field.name] = uint256Word(value, field.name);
+                break;
+            case EvmOutputTypeKind.Address:
+            case EvmOutputTypeKind.FixedBytes:
+                values[field.name] = byteString(value, field);
+                break;
         }
-        value[field.name] = toCompactValue(raw, field);
     }
-    return compactSerialize(descriptor, value);
+    return compactSerialize(deriveRespondSchema(schema), values);
 }
 // ---------------------------------------------------------------------------
 // 3. executed EVM transaction -> attested respond bytes
@@ -170,89 +264,62 @@ export var EvmTraceOutputKind;
     /** The top call frame carries no string `output` field. */
     EvmTraceOutputKind["NoReturnData"] = "NoReturnData";
 })(EvmTraceOutputKind || (EvmTraceOutputKind = {}));
-/** The string default the MPC synthesises for an execution without call output. */
-const NON_FUNCTION_CALL_SUCCESS = "non_function_call_success";
-/**
- * The per-field values the MPC synthesises for an execution without call
- * output (its `default_value_for_kind`): `true` for a bool field,
- * {@link NON_FUNCTION_CALL_SUCCESS} for a string field.
- *
- * @param respondSchema - The respondSerializationSchema.
- * @returns The synthesised values keyed by field name.
- * @throws {Error} If the schema is one {@link serializeRespondOutput}
- *   rejects, or a field is of any other kind.
- */
-function nonFunctionCallDefaults(respondSchema) {
-    const output = {};
-    for (const field of normalizeRespondSchema(respondSchema)) {
-        if (field.type === "bool") {
-            output[field.name] = true;
-        }
-        else if (field.type === "string") {
-            output[field.name] = NON_FUNCTION_CALL_SUCCESS;
-        }
-        else {
-            throw new Error(`respond output: '${field.name}' (${field.type}) has no non-function-call ` +
-                "default: only bool and string fields have one");
-        }
-    }
-    return output;
-}
 /**
- * The exact serialised respond output the MPC attests for an EVM transaction
- * that executed (the payload of an `OutputKind.executed` attestation),
- * mirroring the MPC's `build_serialized_output` under the Midnight respond
- * format:
+ * The exact respond output the MPC attests for an EVM transaction that
+ * executed (the payload of an `OutputKind.executed` attestation), derived
+ * from the request's outputDeserializationSchema alone. The schema and the
+ * execution's return data MUST agree: an empty schema declares that the
+ * execution returns nothing, a non-empty schema that it returns data.
  *
- * - Not a contract call: the output schema and the trace are ignored, and
- *   the respond fields get synthesised defaults (bool `true`, string
- *   `"non_function_call_success"` in its `maxBytes` buffer, any other kind
- *   throws).
- * - A contract call under an EMPTY output schema (a void call): the same
- *   defaults when the trace has no or empty return data, a throw when it
- *   returned data.
- * - A contract call under a non-empty output schema: the return data
- *   decoded by {@link deserializeEvmOutput} and packed by
- *   {@link serializeRespondOutput}, a throw when the trace has no return
- *   data.
+ * - Not a contract call (a plain transfer): there is no return data, so the
+ *   schema must be empty and the output is EMPTY.
+ * - A contract call whose trace carries no return data, or empty return
+ *   data (`0x`): the schema must be empty and the output is EMPTY.
+ * - A contract call that returned data: the schema must be non-empty, and
+ *   the output is the return data decoded by {@link deserializeEvmOutput}
+ *   and serialised by {@link serializeRespondOutput}.
  *
- * A contract call that was not traced always throws. A failed or unviable
- * execution is attested over an empty output instead, which needs no call.
+ * The schema's types are checked on every path, a plain transfer included,
+ * so a request the MPC should have dropped never attests anything. A failed
+ * or unviable execution is attested over an empty output instead, which
+ * needs no call. An empty output under `executed` is therefore ordinary for
+ * an empty schema: its settle circuit verifies at width 0 and must route on
+ * the verified `outputKind`, never on the width.
  *
- * @param schemas - The request's two schemas (a request record satisfies this).
+ * @param schema - The request's outputDeserializationSchema (a request record's field satisfies this).
  * @param isContractCall - Whether the transaction is a contract call, as {@link isEvmContractCall} decides it.
  * @param trace - The transaction's traced return data (`NotTraced` for an untraced plain transfer).
- * @returns The packed respond bytes, unpadded.
+ * @returns The respond bytes, unpadded, empty for an empty schema.
  * @throws {Error} Exactly where the MPC refuses to attest an execution: a
- *   contract call not traced, an empty output schema with return data, a
- *   non-empty output schema with no or undecodable return data, a malformed
- *   output schema on a contract call, a respond field without a synthesised
- *   default, and every {@link serializeRespondOutput} rejection.
+ *   malformed schema or an unsupported output type, a contract call not
+ *   traced, return data under an empty schema, no or empty return data
+ *   under a non-empty schema, return data the schema cannot decode, and
+ *   every {@link serializeRespondOutput} rejection.
  */
-export function executedEvmRespondOutput(schemas, isContractCall, trace) {
-    const { outputDeserializationSchema, respondSerializationSchema } = schemas;
+export function executedEvmRespondOutput(schema, isContractCall, trace) {
+    const expectsOutput = classifiedEvmOutputFields(schema).length > 0;
     if (!isContractCall) {
-        return serializeRespondOutput(respondSerializationSchema, nonFunctionCallDefaults(respondSerializationSchema));
+        if (expectsOutput) {
+            throw new Error("respond output: a plain transfer returns nothing, but the output schema declares return values");
+        }
+        return new Uint8Array(0);
     }
-    const expectsNoOutput = parseSchemaShape(outputDeserializationSchema).length === 0;
-    switch (trace.kind) {
-        case EvmTraceOutputKind.NotTraced:
-            throw new Error("respond output: a contract call's output needs its trace");
-        case EvmTraceOutputKind.NoReturnData:
-            if (!expectsNoOutput) {
-                throw new Error("respond output: the contract call's trace has no return data for a non-empty output schema");
-            }
-            break;
-        case EvmTraceOutputKind.Output:
-            if (!expectsNoOutput) {
-                return serializeRespondOutput(respondSerializationSchema, deserializeEvmOutput(outputDeserializationSchema, trace.returnData));
-            }
-            if (ethers.getBytes(trace.returnData).length > 0) {
-                throw new Error("respond output: the contract call returned data but its output schema declares no return values");
-            }
-            break;
+    if (trace.kind === EvmTraceOutputKind.NotTraced) {
+        throw new Error("respond output: a contract call's output needs its trace");
     }
-    return serializeRespondOutput(respondSerializationSchema, nonFunctionCallDefaults(respondSerializationSchema));
+    const returnData = trace.kind === EvmTraceOutputKind.Output
+        ? ethers.getBytes(trace.returnData)
+        : new Uint8Array(0);
+    if (returnData.length === 0) {
+        if (expectsOutput) {
+            throw new Error("respond output: the contract call returned no data, but the output schema declares return values");
+        }
+        return new Uint8Array(0);
+    }
+    if (!expectsOutput) {
+        throw new Error("respond output: the contract call returned data, but the output schema declares no return values");
+    }
+    return serializeRespondOutput(schema, deserializeEvmOutput(schema, returnData));
 }
 /**
  * Whether a JSON value is an object. A type guard, as `Array.isArray` does
@@ -321,26 +388,6 @@ export function evmTraceOutputFromCallFrame(frame) {
 // Helpers from here down. The exports above are the whole public surface:
 // everything below serves them.
 // ===========================================================================
-// ---------------------------------------------------------------------------
-// Field-kind guards
-// ---------------------------------------------------------------------------
-function isAbiDynamicField(field) {
-    return field.type === "string" || field.type === "bytes";
-}
-function isAbiArrayField(field) {
-    return field.type.endsWith("[]");
-}
-// ---------------------------------------------------------------------------
-// Decode-side value flattening
-// ---------------------------------------------------------------------------
-/**
- * Flatten ethers `Result` arrays into plain arrays, pass scalars through.
- *
- * @param value - A decoded ABI value, possibly a nested `Result`.
- * @param label - Field path, used in error messages.
- * @returns The value with every `Result` replaced by a plain array.
- * @throws {Error} If the value is of a kind the respond side cannot carry.
- */
 function toPlainValue(value, label) {
     if (value instanceof ethers.Result) {
         return value.toArray().map((v, i) => toPlainValue(v, `${label}[${String(i)}]`));
@@ -360,10 +407,6 @@ function toPlainValue(value, label) {
 // ---------------------------------------------------------------------------
 // Schema parsing + validation
 // ---------------------------------------------------------------------------
-const ADDRESS_BOUND = 1n << 160n;
-const MAX_UINT_BITS = 248;
-/** Length-prefix width of the dynamic string/bytes/array convention (Uint<64>). */
-const DYN_LEN_BYTES = 8;
 /**
  * Parse schema text as JSON with the parse failure named. Blank text (an
  * unset all-NUL on-chain schema field) is the empty schema.
@@ -386,10 +429,8 @@ function parseSchemaJson(text) {
 /**
  * Parse a schema in any input form and check its SHAPE only: an array of
  * fields with non-empty, unique names and non-empty type strings. An empty
- * schema is valid here: emptiness policy belongs to the callers
- * ({@link deserializeEvmOutput} decodes nothing, {@link serializeRespondOutput}
- * rejects, {@link executedEvmRespondOutput} synthesises defaults for a
- * contract call without return data).
+ * schema is valid here: {@link deserializeEvmOutput} decodes nothing from
+ * it and {@link executedEvmRespondOutput} attests an empty output.
  *
  * @param schema - The schema as JSON text, packed bytes, or a field array.
  * @returns The schema's fields, names and type strings unvalidated beyond shape.
@@ -407,7 +448,7 @@ function parseSchemaShape(schema) {
         if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
             throw new Error(`schema field ${String(i)} is not an object`);
         }
-        const { name, type, maxBytes, maxItems } = raw;
+        const { name, type } = raw;
         if (typeof name !== "string" || name.length === 0) {
             throw new Error(`schema field ${String(i)} needs a non-empty name`);
         }
@@ -418,36 +459,7 @@ function parseSchemaShape(schema) {
         if (typeof type !== "string" || type.length === 0) {
             throw new Error(`schema: '${name}' needs a type`);
         }
-        return { name, type, maxBytes, maxItems };
-    });
-}
-/**
- * Enforce the respond-side Compact-carrier vocabulary on a shape-checked
- * schema: every type needs a Compact carrier (no signed ints, uint widths of
- * at most 248 bits or exactly 256, bytesN at most 32) and every dynamic field
- * needs its fixed capacity.
- *
- * @param schema - The schema to normalize.
- * @returns The schema with every field proven to have a Compact carrier.
- * @throws {Error} If a type has no carrier or a dynamic field omits its capacity.
- */
-function normalizeRespondSchema(schema) {
-    const fields = parseSchemaShape(schema);
-    if (fields.length === 0) {
-        throw new Error("respond schema is empty: a respond serialization schema needs at least one field");
-    }
-    return fields.map(({ name, type, maxBytes, maxItems }) => {
-        if (type === "string" || type === "bytes") {
-            assertCapacity(maxBytes, `'${name}' (${type}) maxBytes`);
-            return { name, type, maxBytes };
-        }
-        if (type.endsWith("[]")) {
-            classifyFixedType(type.slice(0, -2), name);
-            assertCapacity(maxItems, `'${name}' (${type}) maxItems`);
-            return { name, type: type, maxItems };
-        }
-        classifyFixedType(type, name);
-        return { name, type: type };
+        return { name, type };
     });
 }
 /**
@@ -461,193 +473,4 @@ function schemaText(schema) {
     const nul = raw.indexOf("\0");
     return nul === -1 ? raw : raw.slice(0, nul);
 }
-function assertCapacity(value, label) {
-    if (value === undefined) {
-        throw new Error(`schema: ${label} is required: Compact types are fixed-size`);
-    }
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
-        throw new Error(`schema: ${label} must be a positive integer`);
-    }
-}
-/**
- * Classify a fixed-width respond type into its Compact carrier, validating
- * the respond-side vocabulary in one place: both the schema check
- * ({@link normalizeRespondSchema}) and the descriptor build
- * ({@link respondSchemaToCompactType}) call this, so the grammar cannot
- * drift between them. Respond-side uint widths are restricted to whole-byte
- * widths (multiples of 8 from 8 to 248, packing to bits / 8 bytes), plus
- * uint256 which maps to Field. Throws with the offending field named.
- *
- * @param type - The fixed-width ABI type name.
- * @param fieldName - The field the type belongs to, used in error messages.
- * @returns The Compact descriptor that carries the type.
- * @throws {Error} If the type has no respond-side Compact carrier.
- */
-function classifyFixedType(type, fieldName) {
-    if (type === "bool")
-        return { kind: "boolean" };
-    if (type === "field" || type === "uint256" || type === "address") {
-        return { kind: "field" };
-    }
-    if (/^int\d+$/.test(type)) {
-        throw new Error(`schema: '${fieldName}' (${type}) is unsupported: Compact has no signed integers`);
-    }
-    const uintMatch = /^uint([1-9]\d*)$/.exec(type);
-    if (uintMatch) {
-        const bits = Number(uintMatch[1]);
-        const wholeByteWidth = bits >= 8 && bits <= MAX_UINT_BITS && bits % 8 === 0;
-        if (!wholeByteWidth) {
-            throw new Error(`schema: '${fieldName}' (${type}) has no respond carrier: uint widths ` +
-                `must be multiples of 8 from 8 to ${String(MAX_UINT_BITS)}, or uint256 (maps to Field)`);
-        }
-        return { kind: "uint", bits };
-    }
-    const bytesMatch = /^bytes([1-9]\d*)$/.exec(type);
-    if (bytesMatch) {
-        const n = Number(bytesMatch[1]);
-        if (n < 1 || n > 32) {
-            throw new Error(`schema: '${fieldName}' (${type}) is not a valid bytesN type`);
-        }
-        return { kind: "bytes", length: n };
-    }
-    throw new Error(`schema: '${fieldName}' has unsupported type '${type}'`);
-}
-// ---------------------------------------------------------------------------
-// Schema -> CompactType descriptor + value coercion
-// ---------------------------------------------------------------------------
-function respondSchemaToCompactType(fields) {
-    return {
-        kind: "struct",
-        fields: fields.map((field) => {
-            if (isAbiDynamicField(field)) {
-                return {
-                    name: field.name,
-                    type: {
-                        kind: "struct",
-                        fields: [
-                            { name: "len", type: { kind: "uint", bits: DYN_LEN_BYTES * 8 } },
-                            { name: "data", type: { kind: "bytes", length: field.maxBytes } },
-                        ],
-                    },
-                };
-            }
-            if (isAbiArrayField(field)) {
-                return {
-                    name: field.name,
-                    type: {
-                        kind: "struct",
-                        fields: [
-                            { name: "len", type: { kind: "uint", bits: DYN_LEN_BYTES * 8 } },
-                            {
-                                name: "items",
-                                type: {
-                                    kind: "vector",
-                                    length: field.maxItems,
-                                    element: classifyFixedType(field.type.slice(0, -2), field.name),
-                                },
-                            },
-                        ],
-                    },
-                };
-            }
-            return { name: field.name, type: classifyFixedType(field.type, field.name) };
-        }),
-    };
-}
-function toCompactValue(value, field) {
-    const { name } = field;
-    if (isAbiDynamicField(field)) {
-        const payload = field.type === "string"
-            ? new TextEncoder().encode(asString(value, name))
-            : asBytes(value, name);
-        if (payload.length > field.maxBytes) {
-            throw new Error(`'${name}': payload is ${String(payload.length)} bytes, maxBytes is ${String(field.maxBytes)}`);
-        }
-        const data = new Uint8Array(field.maxBytes);
-        data.set(payload);
-        return { len: BigInt(payload.length), data };
-    }
-    if (isAbiArrayField(field)) {
-        if (!Array.isArray(value)) {
-            throw new Error(`'${name}' (${field.type}) expects an array`);
-        }
-        if (value.length > field.maxItems) {
-            throw new Error(`'${name}': ${String(value.length)} elements, maxItems is ${String(field.maxItems)}`);
-        }
-        const elementType = field.type.slice(0, -2);
-        const items = value.map((element, i) => fixedCompactValue(element, elementType, `${name}[${String(i)}]`));
-        // Unused capacity encodes as zero values of the element type.
-        while (items.length < field.maxItems)
-            items.push(zeroOf(elementType));
-        return { len: BigInt(value.length), items };
-    }
-    return fixedCompactValue(value, field.type, name);
-}
-function fixedCompactValue(value, type, label) {
-    if (type === "bool") {
-        if (typeof value !== "boolean") {
-            throw new Error(`'${label}' (bool) expects a boolean`);
-        }
-        return value;
-    }
-    if (/^bytes\d+$/.test(type)) {
-        const raw = asBytes(value, label);
-        const expected = Number(type.slice(5));
-        if (raw.length !== expected) {
-            throw new Error(`'${label}' (${type}) expects exactly ${String(expected)} bytes, got ${String(raw.length)}`);
-        }
-        return raw;
-    }
-    // Numeric carriers: uintN, uint256/field and address.
-    const n = asBigint(value, label);
-    if (type === "address" && n >= ADDRESS_BOUND) {
-        throw new Error(`'${label}': value ${String(n)} exceeds an address`);
-    }
-    // Uint width and Field modulus bounds are enforced by @sig-net/midnight-serde.
-    return n;
-}
-function zeroOf(type) {
-    if (type === "bool")
-        return false;
-    if (/^bytes\d+$/.test(type))
-        return new Uint8Array(Number(type.slice(5)));
-    return 0n;
-}
-// ---------------------------------------------------------------------------
-// Value-form coercions
-// ---------------------------------------------------------------------------
-function asBigint(value, label) {
-    if (typeof value === "bigint")
-        return value;
-    if (typeof value === "number" && Number.isSafeInteger(value))
-        return BigInt(value);
-    if (typeof value === "string") {
-        try {
-            return BigInt(value);
-        }
-        catch {
-            throw new Error(`'${label}': cannot parse '${value}' as an integer`);
-        }
-    }
-    throw new Error(`'${label}': expected an integer-like value`);
-}
-function asBytes(value, label) {
-    if (value instanceof Uint8Array)
-        return value;
-    if (typeof value === "string") {
-        try {
-            return ethers.getBytes(value);
-        }
-        catch {
-            throw new Error(`'${label}': not a valid 0x hex byte string: "${value}"`);
-        }
-    }
-    throw new Error(`'${label}': expected bytes (Uint8Array or hex string)`);
-}
-function asString(value, label) {
-    if (typeof value !== "string") {
-        throw new Error(`'${label}': expected a string`);
-    }
-    return value;
-}
 //# sourceMappingURL=abi-serde.js.map