@agoric/orchestration 0.1.1-dev-94f7dd3.0.94f7dd3 → 0.1.1-dev-0cd653b.0.0cd653b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-94f7dd3.0.94f7dd3",
+  "version": "0.1.1-dev-0cd653b.0.0cd653b",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -35,18 +35,18 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/async-flow": "0.1.1-dev-94f7dd3.0.94f7dd3",
-    "@agoric/cosmic-proto": "0.4.1-dev-94f7dd3.0.94f7dd3",
-    "@agoric/ertp": "0.16.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/internal": "0.3.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/network": "0.1.1-dev-94f7dd3.0.94f7dd3",
-    "@agoric/notifier": "0.6.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/store": "0.9.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/time": "0.3.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/vat-data": "0.5.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/vow": "0.1.1-dev-94f7dd3.0.94f7dd3",
-    "@agoric/zoe": "0.26.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/zone": "0.2.3-dev-94f7dd3.0.94f7dd3",
+    "@agoric/async-flow": "0.1.1-dev-0cd653b.0.0cd653b",
+    "@agoric/cosmic-proto": "0.4.1-dev-0cd653b.0.0cd653b",
+    "@agoric/ertp": "0.16.3-dev-0cd653b.0.0cd653b",
+    "@agoric/internal": "0.3.3-dev-0cd653b.0.0cd653b",
+    "@agoric/network": "0.1.1-dev-0cd653b.0.0cd653b",
+    "@agoric/notifier": "0.6.3-dev-0cd653b.0.0cd653b",
+    "@agoric/store": "0.9.3-dev-0cd653b.0.0cd653b",
+    "@agoric/time": "0.3.3-dev-0cd653b.0.0cd653b",
+    "@agoric/vat-data": "0.5.3-dev-0cd653b.0.0cd653b",
+    "@agoric/vow": "0.1.1-dev-0cd653b.0.0cd653b",
+    "@agoric/zoe": "0.26.3-dev-0cd653b.0.0cd653b",
+    "@agoric/zone": "0.2.3-dev-0cd653b.0.0cd653b",
     "@cosmjs/encoding": "^0.36.0",
     "@endo/base64": "^1.1.1",
     "@endo/common": "^1.4.0",
@@ -61,8 +61,8 @@
     "bs58": "^6.0.0"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-94f7dd3.0.94f7dd3",
-    "@agoric/vats": "0.15.2-dev-94f7dd3.0.94f7dd3",
+    "@agoric/swingset-liveslots": "0.10.3-dev-0cd653b.0.0cd653b",
+    "@agoric/vats": "0.15.2-dev-0cd653b.0.0cd653b",
     "@chain-registry/client": "^1.53.194",
     "@cosmjs/amino": "^0.36.0",
     "@cosmjs/proto-signing": "^0.36.0",
@@ -98,5 +98,5 @@
   "typeCoverage": {
     "atLeast": 96.68
   },
-  "gitHead": "94f7dd333365233251880bd61ef8c803433ecf4d"
+  "gitHead": "0cd653b11224a7bf48e42d387532844b4c6e091f"
 }

package/src/utils/abitype.d.ts

@@ -1,6 +1,67 @@
-import type { TypedDataType, TypedData } from 'abitype';
+import type { AbiParameterToPrimitiveType, TypedDataType, TypedData } from 'abitype';
+import type { Simplify } from '@agoric/internal';
 export type TypedDataParameter<TN extends string = string, TT extends string = TypedDataType | keyof TypedData | `${keyof TypedData}[${string | ''}]`> = {
     name: TN;
     type: TT;
+    /**
+     * Repo-local extension, not part of the EIP-712 spec: marks this field as
+     * not required to be present on every instance of the struct in a given
+     * message. Must be resolved by `normalizeEIP712Data` (dropped, or stripped
+     * to a plain required field) before the type record is used by any real
+     * EIP-712 tooling (e.g. viem's `hashStruct`/`validateTypedData`), which
+     * doesn't understand it.
+     */
+    optional?: boolean;
 };
+/**
+ * Depth-agnostic replacement for abitype's `TypedDataToPrimitiveTypes`,
+ * which has no notion of this repo's `optional` field marker at all -- every
+ * field of every struct it touches infers as required. Given the full
+ * type-graph record `TD` and the name `K` of the struct to convert, this
+ * recursively derives the same TS type abitype would for that struct, but
+ * applies `optional` at every struct it encounters, however deeply nested
+ * (directly, through another struct field, or through an array element
+ * type).
+ *
+ * Values for plain Solidity primitive fields (and arrays of them) are still
+ * computed via abitype's own `AbiParameterToPrimitiveType` -- only the
+ * struct/array *graph walk* is reimplemented here, to weave in `optional`.
+ * Unlike abitype's version, this has no self/circular-reference detection:
+ * none of this repo's type graphs are self-referencing, so it wasn't worth
+ * reproducing.
+ */
+export type TypedDataToStructType<TD extends Record<string, readonly TypedDataParameter[]>, K extends keyof TD & string> = StructToType<TD, TD[K]>;
+type StructToType<TD extends Record<string, readonly TypedDataParameter[]>, Fields extends readonly TypedDataParameter[]> = Simplify<{
+    [F in Exclude<Fields[number], {
+        optional: true;
+    }> as F['name']]: FieldToType<TD, F['type']>;
+} & {
+    [F in Extract<Fields[number], {
+        optional: true;
+    }> as F['name']]?: FieldToType<TD, F['type']>;
+}>;
+/**
+ * `Foo[3]` / `Foo[]` -> `{elem: 'Foo'; size: '3' | ''}`; non-array ->
+ * `undefined`, NOT `never` -- `never` is a subtype of everything, so
+ * `ParseArrayType<T> extends {elem: ...; size: ...}` would then vacuously
+ * match every non-array `T` too (mirrors abitype's own `undefined` fallback
+ * in `MaybeExtractArrayParameterType`, for the same reason).
+ */
+type ParseArrayType<T extends string> = T extends `${infer Elem}[${infer Size}]` ? {
+    elem: Elem;
+    size: Size;
+} : undefined;
+/** Mirrors abitype's own (unexported) `Tuple` helper. */
+type FixedLengthTuple<T, N extends number, Acc extends unknown[] = []> = Acc['length'] extends N ? Acc : FixedLengthTuple<T, N, [T, ...Acc]>;
+type FieldToType<TD extends Record<string, readonly TypedDataParameter[]>, FieldType extends string> = ParseArrayType<FieldType> extends {
+    elem: infer Elem extends string;
+    size: infer Size extends string;
+} ? Elem extends keyof TD & string ? Size extends `${infer N extends number}` ? FixedLengthTuple<StructToType<TD, TD[Elem]>, N> : readonly StructToType<TD, TD[Elem]>[] : AbiParameterToPrimitiveType<{
+    name: string;
+    type: FieldType;
+}> : FieldType extends keyof TD & string ? StructToType<TD, TD[FieldType]> : AbiParameterToPrimitiveType<{
+    name: string;
+    type: FieldType;
+}>;
+export {};
 //# sourceMappingURL=abitype.d.ts.map

package/src/utils/abitype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abitype.d.ts","sourceRoot":"","sources":["abitype.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGxD,MAAM,MAAM,kBAAkB,CAC5B,EAAE,SAAS,MAAM,GAAG,MAAM,EAC1B,EAAE,SAAS,MAAM,GACb,aAAa,GACb,MAAM,SAAS,GACf,GAAG,MAAM,SAAS,IAAI,MAAM,GAAG,EAAE,GAAG,IACtC;IACF,IAAI,EAAE,EAAE,CAAC;IACT,IAAI,EAAE,EAAE,CAAC;CACV,CAAC"}
+{"version":3,"file":"abitype.d.ts","sourceRoot":"","sources":["abitype.ts"],"names":[],"mappings":"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"}

package/src/utils/abitype.js

@@ -1,4 +1,9 @@
-                                                        
+             
+                              
+                
+            
+                 
+                                                 
 
 // Redefine abitype's TypedDataParameter to make it generic
                                
@@ -10,4 +15,87 @@
      
            
            
+     
+                                                                            
+                                                                          
+                                                                             
+                                                                          
+                                                                          
+                           
+     
+                     
   
+
+/**
+ * Depth-agnostic replacement for abitype's `TypedDataToPrimitiveTypes`,
+ * which has no notion of this repo's `optional` field marker at all -- every
+ * field of every struct it touches infers as required. Given the full
+ * type-graph record `TD` and the name `K` of the struct to convert, this
+ * recursively derives the same TS type abitype would for that struct, but
+ * applies `optional` at every struct it encounters, however deeply nested
+ * (directly, through another struct field, or through an array element
+ * type).
+ *
+ * Values for plain Solidity primitive fields (and arrays of them) are still
+ * computed via abitype's own `AbiParameterToPrimitiveType` -- only the
+ * struct/array *graph walk* is reimplemented here, to weave in `optional`.
+ * Unlike abitype's version, this has no self/circular-reference detection:
+ * none of this repo's type graphs are self-referencing, so it wasn't worth
+ * reproducing.
+ */
+                                  
+                                                           
+                              
+                            
+
+                  
+                                                           
+                                               
+             
+   
+                  
+                     
+                        
+                                                
+       
+                  
+                     
+                        
+                                                 
+   
+  
+
+/**
+ * `Foo[3]` / `Foo[]` -> `{elem: 'Foo'; size: '3' | ''}`; non-array ->
+ * `undefined`, NOT `never` -- `never` is a subtype of everything, so
+ * `ParseArrayType<T> extends {elem: ...; size: ...}` would then vacuously
+ * match every non-array `T` too (mirrors abitype's own `undefined` fallback
+ * in `MaybeExtractArrayParameterType`, for the same reason).
+ */
+                                                                                
+                              
+              
+
+/** Mirrors abitype's own (unexported) `Tuple` helper. */
+                      
+    
+                   
+                             
+                                                                        
+
+                 
+                                                           
+                           
+   
+                                     
+                                    
+                                    
+   
+                                    
+                                                
+                                                         
+                                               
+                                                                      
+                                         
+                                       
+                                                                       

package/src/utils/permit2/signatureTransfer.d.ts

@@ -10,23 +10,22 @@
  *
  * Some stylistic changes have also been made to conform to our code style.
  */
-import type { TypedDataToPrimitiveTypes } from 'abitype';
 import type { Address, TypedData, TypedDataDefinition } from 'viem';
-import type { TypedDataParameter } from '../abitype.js';
+import type { TypedDataParameter, TypedDataToStructType } from '../abitype.js';
 export declare const PERMIT2_DOMAIN_NAME = "Permit2";
 interface WitnessDefinition<T extends TypedData = TypedData, TD extends TypedDataParameter<string, Extract<keyof T, string>> = TypedDataParameter<'witness', Extract<keyof T, string>>> {
     witnessField: TD;
     witnessTypes: T;
 }
 export interface Witness<T extends TypedData = TypedData, TD extends TypedDataParameter<string, Extract<keyof T, string>> = TypedDataParameter<'witness', Extract<keyof T, string>>> extends WitnessDefinition<T, TD> {
-    witness: TypedDataToPrimitiveTypes<T>[TD['type']];
+    witness: TypedDataToStructType<T, TD['type']>;
 }
 /**
  * Helper to help caller check that the `data` matches the inferred witness types
  *
  * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-4.html#the-noinfer-utility-type}
  */
-export declare function makeWitness<T extends TypedData, TD extends TypedDataParameter<string, Extract<keyof T, string>>>(data: NoInfer<TypedDataToPrimitiveTypes<T>[TD['type']]>, types: T, typeParam: TD): Witness<T, TD>;
+export declare function makeWitness<T extends TypedData, TD extends TypedDataParameter<string, Extract<keyof T, string>>>(data: NoInfer<TypedDataToStructType<T, TD['type']>>, types: T, typeParam: TD): Witness<T, TD>;
 export type TokenPermissions = {
     token: Address;
     amount: bigint;

package/src/utils/permit2/signatureTransfer.d.ts.map

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

package/src/utils/permit2/signatureTransfer.js

@@ -11,14 +11,13 @@
  * Some stylistic changes have also been made to conform to our code style.
  */
 
-                                                         
              
           
             
                       
                   
               
-                                                        
+                                                                               
 
 export const PERMIT2_DOMAIN_NAME = 'Permit2';
 
@@ -37,7 +36,7 @@ export const PERMIT2_DOMAIN_NAME = 'Permit2';
                                                                    
                                                             
                                     
-                                                    
+                                                
  
 
 /**
@@ -49,7 +48,7 @@ export function makeWitness(
                       
                                                                   
   
-  data                                                   ,
+  data                                               ,
   types   ,
   typeParam    ,
 )                 {

package/src/utils/permit2/signatureTransferHelpers.d.ts.map

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

package/src/utils/permit2/signatureTransferHelpers.js

@@ -149,7 +149,7 @@ export function validatePermit2Domain(
     throw new Error(`Missing domain in permit2 data`);
   }
 
-  const { chainId, verifyingContract, name } = domain;
+  const { chainId, verifyingContract, name, ...extra } = domain;
   if (name !== PERMIT2_DOMAIN_NAME) {
     throw new Error(`Invalid permit2 domain name: ${name}`);
   }
@@ -170,7 +170,12 @@ export function validatePermit2Domain(
     }
   }
 
-  // XXX: check no extra fields?
+  const extraKeys = Object.keys(extra);
+  if (extraKeys.length) {
+    throw new Error(
+      `Unexpected field(s) in permit2 domain: ${extraKeys.join(', ')}`,
+    );
+  }
 }
 
 /**

package/src/utils/viem-utils/eip712-normalize.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @file Normalizes *and validates* EIP-712 typed data (`{message, types,
+ * primaryType}`) in a single pass:
+ * - `optional` struct fields (see {@link TypedDataParameter}) are resolved
+ *   per-message: dropped from `types` if never present on any instance of
+ *   the struct, otherwise kept with the `optional` marker stripped (treated
+ *   as required from then on).
+ * - struct types never actually encountered while walking `message` from
+ *   `primaryType` are absent from `types`. `EIP712Domain` is always
+ *   preserved if present, since domain values live outside `message`.
+ *
+ * `onExtraField` controls how *excess* data (fields not declared in
+ * `types`, array elements beyond a fixed length) is handled:
+ * - 'drop' (default): silently remove it from `message`.
+ * - 'throw': reject it — use when `types` is the trusted/expected shape
+ *   and `message` is untrusted, to catch data smuggled in outside what's
+ *   declared.
+ * - 'keep': leave `message` untouched (no projection, no removal of excess
+ *   data). Dynamic-length arrays are never truncated in any mode, since
+ *   every element affects the EIP-712 hash.
+ *
+ * Regardless of `onExtraField`, the result is also *validated*, with the
+ * goal that if validation succeeds, hashing the result is guaranteed to
+ * succeed and to hash exactly the values given:
+ * - every declared field must be present. Fixed-length arrays must have at
+ *   least their declared number of elements (too few is missing data, not
+ *   excess, so no mode tolerates it; too many is excess, tolerated only by
+ *   `'keep'`).
+ * - a struct/array field must get an array/object value, and a plain
+ *   Solidity type (`address`, `bool`, `string`, `uint*`/`int*`, `bytes*`)
+ *   must get a value of the specific JS type that implies -- see
+ *   `assertValidPrimitive`.
+ * - primitive leaf values are checked against their type's shape/range,
+ *   recursing correctly through arrays, which real EIP-712 tooling (e.g.
+ *   viem's `validateTypedData`) does not.
+ *
+ * No runtime dependency on `viem`/`abitype`, so this can run on-chain. Two
+ * known exceptions to the validate-implies-hash invariant, both left
+ * unclosed since closing them needs a hashing dependency:
+ * - `address` values are only checked for 20-byte-hex shape, not EIP-55
+ *   checksum. Real hashing lowercases addresses before encoding (so casing
+ *   never affects the hash), but still separately rejects a mixed-case
+ *   value whose checksum doesn't match, as a typo safety net.
+ * - a `Uint8Array` given for a fixed `bytes<M>` field is rejected rather
+ *   than converted to the equivalent hex string.
+ */
+import type { TypedDataParameter } from '../abitype.js';
+type TypesRecord = Record<string, readonly TypedDataParameter[]>;
+export type NormalizeAndValidateEIP712DataInput = {
+    message: Record<string, unknown>;
+    types: TypesRecord;
+    primaryType: string;
+};
+export type NormalizeAndValidateEIP712DataOptions = {
+    /** default 'drop' */
+    onExtraField?: 'drop' | 'throw' | 'keep';
+};
+export type NormalizeAndValidateEIP712DataResult = {
+    message: Record<string, unknown>;
+    types: TypesRecord;
+};
+export declare const normalizeAndValidateEIP712Data: (input: NormalizeAndValidateEIP712DataInput, options?: NormalizeAndValidateEIP712DataOptions) => NormalizeAndValidateEIP712DataResult;
+export {};
+//# sourceMappingURL=eip712-normalize.d.ts.map

package/src/utils/viem-utils/eip712-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eip712-normalize.d.ts","sourceRoot":"","sources":["eip712-normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC,CAAC;AAEjE,MAAM,MAAM,mCAAmC,GAAG;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,WAAW,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qCAAqC,GAAG;IAClD,qBAAqB;IACrB,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,WAAW,CAAC;CACpB,CAAC;AAkYF,eAAO,MAAM,8BAA8B,GACzC,OAAO,mCAAmC,EAC1C,UAAS,qCAA0C,KAClD,oCA+CF,CAAC"}

package/src/utils/viem-utils/eip712-normalize.js

@@ -0,0 +1,501 @@
+/**
+ * @file Normalizes *and validates* EIP-712 typed data (`{message, types,
+ * primaryType}`) in a single pass:
+ * - `optional` struct fields (see {@link TypedDataParameter}) are resolved
+ *   per-message: dropped from `types` if never present on any instance of
+ *   the struct, otherwise kept with the `optional` marker stripped (treated
+ *   as required from then on).
+ * - struct types never actually encountered while walking `message` from
+ *   `primaryType` are absent from `types`. `EIP712Domain` is always
+ *   preserved if present, since domain values live outside `message`.
+ *
+ * `onExtraField` controls how *excess* data (fields not declared in
+ * `types`, array elements beyond a fixed length) is handled:
+ * - 'drop' (default): silently remove it from `message`.
+ * - 'throw': reject it — use when `types` is the trusted/expected shape
+ *   and `message` is untrusted, to catch data smuggled in outside what's
+ *   declared.
+ * - 'keep': leave `message` untouched (no projection, no removal of excess
+ *   data). Dynamic-length arrays are never truncated in any mode, since
+ *   every element affects the EIP-712 hash.
+ *
+ * Regardless of `onExtraField`, the result is also *validated*, with the
+ * goal that if validation succeeds, hashing the result is guaranteed to
+ * succeed and to hash exactly the values given:
+ * - every declared field must be present. Fixed-length arrays must have at
+ *   least their declared number of elements (too few is missing data, not
+ *   excess, so no mode tolerates it; too many is excess, tolerated only by
+ *   `'keep'`).
+ * - a struct/array field must get an array/object value, and a plain
+ *   Solidity type (`address`, `bool`, `string`, `uint*`/`int*`, `bytes*`)
+ *   must get a value of the specific JS type that implies -- see
+ *   `assertValidPrimitive`.
+ * - primitive leaf values are checked against their type's shape/range,
+ *   recursing correctly through arrays, which real EIP-712 tooling (e.g.
+ *   viem's `validateTypedData`) does not.
+ *
+ * No runtime dependency on `viem`/`abitype`, so this can run on-chain. Two
+ * known exceptions to the validate-implies-hash invariant, both left
+ * unclosed since closing them needs a hashing dependency:
+ * - `address` values are only checked for 20-byte-hex shape, not EIP-55
+ *   checksum. Real hashing lowercases addresses before encoding (so casing
+ *   never affects the hash), but still separately rejects a mixed-case
+ *   value whose checksum doesn't match, as a typo safety net.
+ * - a `Uint8Array` given for a fixed `bytes<M>` field is rejected rather
+ *   than converted to the equivalent hex string.
+ */
+                                                        
+
+                                                                 
+
+                                                   
+                                   
+                     
+                      
+  
+
+                                                     
+                       
+                                           
+  
+
+                                                    
+                                   
+                     
+  
+
+const ARRAY_SUFFIX = /\[(\d*)\]$/u;
+
+const splitArrayType = (
+  type        ,
+                                                     ) => {
+  const match = type.match(ARRAY_SUFFIX);
+  if (!match) return { base: type, isArray: false };
+  return {
+    base: type.slice(0, -match[0].length),
+    length: match[1] ? Number(match[1]) : undefined,
+    isArray: true,
+  };
+};
+
+const ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/u;
+// Solidity `(u)int<M>`: (un)signed integer of `M` bits, `0 < M <= 256`,
+// `M % 8 === 0`; bare `uint`/`int` (no explicit width) means 256 bits.
+// Mirrors viem's `integerRegex` (utils/regex.ts) -- duplicated rather than
+// imported so this module has no runtime dependency on `viem`.
+const INTEGER_TYPE_REGEX =
+  /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/u;
+// Solidity `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`; bare `bytes`
+// (no explicit size) is dynamic-length, so has nothing to check here.
+const BYTES_TYPE_REGEX = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/u;
+const HEX_REGEX = /^0x[0-9a-fA-F]*$/u;
+
+const MAX_DESCRIBED_LENGTH = 100;
+
+/**
+ * Slices `str` to at most `MAX_DESCRIBED_LENGTH` characters, appending
+ * `...` if it was cut. Bounds length only -- doesn't escape or annotate;
+ * `truncate` and `describeValue`'s string case each build on this
+ * differently (an appended `(N chars total)` annotation, or JSON escaping,
+ * respectively), so the raw slicing lives in one place.
+ */
+const truncateRaw = (str        )         =>
+  str.length > MAX_DESCRIBED_LENGTH
+    ? `${str.slice(0, MAX_DESCRIBED_LENGTH)}...`
+    : str;
+
+/**
+ * Bounds a string embedded in an error message -- `message` (and, in
+ * 'throw' mode, `types`) can come from an untrusted source, so a field
+ * name, value, or joined list of them could otherwise be arbitrarily large.
+ * Bounds length only, and doesn't escape the result -- see `quoteName` for
+ * a quoted-and-escaped identifier suitable for embedding directly in a
+ * message (manually wrapping this in literal quotes instead is unsafe: an
+ * embedded quote character in `str` would break out of them).
+ */
+const truncate = (str        )         =>
+  str.length > MAX_DESCRIBED_LENGTH
+    ? `${truncateRaw(str)}(${str.length} chars total)`
+    : str;
+
+/**
+ * Quotes and escapes an identifier (a struct/field type or field name) for
+ * embedding in an error message. Escaping via `JSON.stringify` happens
+ * *after* truncating and covers the whole (possibly-annotated) result, so
+ * an embedded quote, backslash, or newline in the identifier can't break
+ * out of the message's own quoting, and the `(N chars total)` annotation
+ * can't itself get chopped off by a later truncation step (there isn't
+ * one).
+ */
+const quoteName = (str        )         => JSON.stringify(truncate(str));
+
+const MAX_DESCRIBED_ITEMS = 10;
+
+/**
+ * Quotes and escapes each name in `names` (see `quoteName`) and joins them
+ * for an error message -- bounding not just each individual name's length
+ * but also, since attacker-controlled data can make the *list itself*
+ * arbitrarily long (e.g. very many extra fields on a struct), the number of
+ * items included. Cuts off whole items rather than slicing the joined
+ * string's raw characters, so the result can never end mid-quote the way
+ * `truncate`-ing an already-joined-and-quoted string could.
+ */
+const quoteNameList = (names                   )         => {
+  const shown = names.slice(0, MAX_DESCRIBED_ITEMS).map(quoteName).join(', ');
+  const omitted = names.length - MAX_DESCRIBED_ITEMS;
+  return omitted > 0 ? `${shown}, and ${omitted} more` : shown;
+};
+
+/**
+ * A short, bounded description of a value for error messages. Only
+ * `string`/`number`/`bigint` can be arbitrarily long themselves; anything
+ * else is described by shape/type rather than rendered.
+ */
+const describeValue = (value         )         => {
+  if (value === null) return 'null';
+  if (typeof value === 'string') {
+    if (value.length > MAX_DESCRIBED_LENGTH) {
+      // The `(N chars total)` annotation goes *outside* the JSON-quoted,
+      // truncated value (unlike `quoteName`), so it reads as metadata about
+      // the value rather than part of it.
+      return `${JSON.stringify(truncateRaw(value))}(${value.length} chars total)`;
+    }
+    return JSON.stringify(value);
+  }
+  // Truncate the digits *before* appending the `n` suffix -- appending
+  // first and truncating the combined string risks slicing the `n` itself
+  // off a long enough value, leaving output that no longer looks like a
+  // bigint.
+  if (typeof value === 'bigint') return `${truncate(`${value}`)}n`;
+  if (typeof value === 'number') return truncate(String(value));
+  if (value instanceof Uint8Array)
+    return `a Uint8Array with ${value.length} byte(s)`;
+  if (Array.isArray(value)) return `an array with ${value.length} element(s)`;
+  return `a ${typeof value}`;
+};
+
+/**
+ * Validates a value declared as a non-struct, non-array EIP-712 type
+ * (`visit` only calls this once it's confirmed `fieldType` is neither).
+ * Requires the specific JS type real hashing needs for each Solidity type,
+ * not just something that happens to coerce -- e.g. a number given for a
+ * `string` field would otherwise hash as the number's own hex encoding,
+ * not the string form, a footgun real EIP-712 tooling doesn't catch either.
+ *
+ * - `address`: string, 20-byte-hex shape (not full EIP-55 checksum -- see
+ *   the module doc comment for why).
+ * - `bool`: JS `boolean`.
+ * - `string`: JS `string`.
+ * - `bytes` (dynamic): hex string *or* `Uint8Array` -- hashed identically
+ *   either way.
+ * - `bytes<M>` (fixed): hex string only, of exactly `M` bytes -- a
+ *   `Uint8Array` does not hash successfully here (see the module doc
+ *   comment).
+ * - `uint<M>`/`int<M>` (bare `uint`/`int` means 256 bits): `number` or
+ *   `bigint`, an integer, in range for the bit width/signedness.
+ * - anything else: not a real Solidity primitive type, so rejected
+ *   unconditionally.
+ */
+const assertValidPrimitive = (fieldType        , value         )       => {
+  const quotedType = quoteName(fieldType);
+
+  if (fieldType === 'address') {
+    if (typeof value !== 'string' || !ADDRESS_REGEX.test(value)) {
+      throw new Error(`Invalid EIP-712 address value: ${describeValue(value)}`);
+    }
+    return;
+  }
+
+  if (fieldType === 'bool') {
+    if (typeof value !== 'boolean') {
+      throw new Error(
+        `Expected a boolean for EIP-712 type "bool", got ${describeValue(value)}`,
+      );
+    }
+    return;
+  }
+
+  if (fieldType === 'string') {
+    if (typeof value !== 'string') {
+      throw new Error(
+        `Expected a string for EIP-712 type "string", got ${describeValue(value)}`,
+      );
+    }
+    return;
+  }
+
+  const integerMatch = fieldType.match(INTEGER_TYPE_REGEX);
+  if (integerMatch) {
+    if (typeof value !== 'number' && typeof value !== 'bigint') {
+      throw new Error(
+        `Expected a number or bigint for EIP-712 type ${quotedType}, got ${describeValue(value)}`,
+      );
+    }
+    if (typeof value === 'number' && !Number.isInteger(value)) {
+      throw new Error(
+        `Expected an integer for EIP-712 type ${quotedType}, got ${describeValue(value)}`,
+      );
+    }
+    const signed = integerMatch[1] === 'int';
+    const bits = integerMatch[2] ? Number(integerMatch[2]) : 256;
+    const bigValue = BigInt(value);
+    const max = signed ? 2n ** BigInt(bits - 1) - 1n : 2n ** BigInt(bits) - 1n;
+    const min = signed ? -max - 1n : 0n;
+    if (bigValue < min || bigValue > max) {
+      throw new Error(
+        `Value ${describeValue(value)} is out of range for EIP-712 type ${quotedType} (expected ${min} to ${max})`,
+      );
+    }
+    return;
+  }
+
+  const bytesMatch = fieldType.match(BYTES_TYPE_REGEX);
+  if (bytesMatch) {
+    // Dynamic `bytes` is hashed directly via `keccak256`, which accepts a
+    // `Uint8Array` interchangeably with a hex string. Fixed `bytes<M>` goes
+    // through the generic Solidity ABI path instead, which requires a hex
+    // string and throws an unrelated error for a `Uint8Array`.
+    if (!bytesMatch[1] && value instanceof Uint8Array) return;
+    if (typeof value !== 'string' || !HEX_REGEX.test(value)) {
+      throw new Error(
+        `Expected a hex string for EIP-712 type ${quotedType}, got ${describeValue(value)}`,
+      );
+    }
+    if (bytesMatch[1]) {
+      const expectedSize = Number(bytesMatch[1]);
+      const actualSize = Math.ceil((value.length - 2) / 2);
+      if (actualSize !== expectedSize) {
+        throw new Error(
+          `Expected EIP-712 type ${quotedType} to be ${expectedSize} bytes, got ${actualSize}: ${describeValue(value)}`,
+        );
+      }
+    }
+    return;
+  }
+
+  throw new Error(`Unrecognized EIP-712 type ${quotedType}`);
+};
+
+/**
+ * A field declared without `optional` starts `required`; one declared
+ * `optional` starts `optional-unseen` and transitions from there as
+ * instances of its struct are visited -- see `visit`.
+ */
+;                                                                  
+
+/**
+ * A struct's fields, keyed by name, tracking each field's {@link
+ * FieldState}. Also doubles as an array-typed field's per-element record
+ * (see `visit`'s `isArray` branch) -- but even then, the keys involved are
+ * always strings: `for...in`/`in` read array indices as strings, never as
+ * `number`.
+ */
+;                                                                     
+
+/** Looks up (and lazily builds) the {@link TypeFields} for a struct type name, or `undefined` for a primitive leaf. */
+;                                                           
+
+/**
+ * Walks `value` against `fieldType` (a struct or array field type string).
+ * One function covers both, since a field's declared type is never an
+ * array of arrays. `getType` hands out the *same* {@link TypeFields}
+ * record for every instance of a given struct type name encountered
+ * anywhere in the message, which is what lets a single walk resolve
+ * `optional` fields and validate required-field presence across
+ * repeated/nested uses of the same type:
+ *
+ * - `optional-unseen` + present => `required` (this instance's presence
+ *   makes the field required everywhere, including instances already
+ *   visited or yet to be visited).
+ * - `optional-unseen` + absent => `optional-seen`.
+ * - `optional-seen` + present => conflict: an earlier instance confirmed
+ *   the field absent, this one sets it. Rejected immediately.
+ * - `optional-seen` + absent => stays `optional-seen`.
+ * - `required` + present => stays `required`.
+ * - `required` + absent => rejected immediately.
+ *
+ * Every mode runs these the same way, `keep` included -- missing data is
+ * missing data regardless of `onExtraField`. `keep` only skips removing or
+ * rejecting *excess* data (extra fields, over-length arrays) and never
+ * touches `message`.
+ */
+const visit = (
+  fieldType        ,
+  value     ,
+  getType         ,
+  onExtraField                           ,
+         ) => {
+  const keep = onExtraField === 'keep';
+  const { base, length: requiredLength, isArray } = splitArrayType(fieldType);
+  // Registers `base` in the output types even if no element ends up visited.
+  const baseType = getType(base);
+
+  if (!isArray && !baseType) {
+    // Not a declared struct or array, so it must be a recognized Solidity
+    // primitive with a matching JS value; also catches an unknown type.
+    assertValidPrimitive(fieldType, value);
+    return value;
+  }
+
+  // A declared struct or array needs an actual object/array value. Split
+  // into two distinct messages (rather than interpolating `isArray` into
+  // one) so each is independently greppable.
+  if (typeof value !== 'object' || value === null) {
+    if (isArray) {
+      throw new Error(
+        `Expected an array for EIP-712 type ${quoteName(fieldType)}, got ${describeValue(value)}`,
+      );
+    } else {
+      throw new Error(
+        `Expected an object for EIP-712 type ${quoteName(fieldType)}, got ${describeValue(value)}`,
+      );
+    }
+  }
+
+  let type            ;
+  let result     ;
+  if (isArray) {
+    const actualLength = value.length;
+    if (typeof actualLength !== 'number' || Number.isNaN(actualLength)) {
+      throw new Error(
+        `Expected an array-like value (with a numeric \`length\`) for EIP-712 type ${quoteName(fieldType)}`,
+      );
+    }
+    if (requiredLength !== undefined) {
+      // Too few is missing data: rejected in every mode, 'keep' included.
+      if (actualLength < requiredLength) {
+        throw new Error(
+          `Array field ${quoteName(fieldType)} has ${actualLength} elements, expected at least ${requiredLength}`,
+        );
+      }
+      // Too many is excess data: only 'throw' rejects it ('drop' truncates
+      // below, 'keep' leaves it alone).
+      if (onExtraField === 'throw' && actualLength > requiredLength) {
+        throw new Error(
+          `Array field ${quoteName(fieldType)} has ${actualLength} elements, expected at most ${requiredLength}`,
+        );
+      }
+    }
+    const length = keep
+      ? actualLength
+      : Math.min(actualLength, requiredLength ?? actualLength);
+    result = keep ? value : new Array(length);
+    type = Array.from({ length }, () => ({
+      state: 'required'         ,
+      type: base,
+    }))                         ;
+  } else {
+    // Guaranteed defined (the `!isArray && !baseType` case already
+    // returned above); this is just for TS's narrowing.
+    if (!baseType) {
+      throw new Error(`Unrecognized EIP-712 type ${quoteName(fieldType)}`);
+    }
+    // Plain object, not null-prototype: this ends up in the returned
+    // `message`, which may need to be Endo-Passable (e.g. across a Zoe/exo
+    // boundary), and a null-prototype object fails that check.
+    result = keep ? value : {};
+    type = baseType;
+  }
+
+  if (onExtraField === 'throw') {
+    const extraKeys = Object.keys(value).filter(key => !(key in type));
+    if (extraKeys.length) {
+      throw new Error(
+        `Unexpected field(s) on EIP-712 type ${quoteName(fieldType)}: ${quoteNameList(extraKeys)}`,
+      );
+    }
+  }
+
+  // `fieldName in obj`, not `hasOwnProperty`: matches how viem itself reads
+  // field values (plain property access resolves the prototype chain).
+  // `type` must be null-prototype or a fresh array-literal record (so
+  // there's no inherited-property risk to guard against here), but this
+  // check protects against future refactorings.
+  if (Object.getPrototypeOf(type) && !Array.isArray(type)) {
+    throw new Error(
+      `EIP-712 type ${quoteName(fieldType)} must be described by a null-prototype object or an array`,
+    );
+  }
+  // eslint-disable-next-line guard-for-in
+  for (const fieldName in type) {
+    const field = type[fieldName];
+    const present = fieldName in value;
+
+    if (present) {
+      if (field.state === 'optional-seen') {
+        throw new Error(
+          `Field ${quoteName(fieldName)} of EIP-712 type ${quoteName(fieldType)} is present here but was missing on another instance of the same type -- it must be consistently present or consistently absent`,
+        );
+      }
+      field.state = 'required';
+    } else if (field.state === 'required') {
+      throw new Error(
+        `Missing required field ${quoteName(fieldName)} for EIP-712 type ${quoteName(fieldType)}`,
+      );
+    } else {
+      field.state = 'optional-seen';
+      continue;
+    }
+
+    const projectedValue = visit(
+      field.type,
+      value[fieldName],
+      getType,
+      onExtraField,
+    );
+    if (!keep) result[fieldName] = projectedValue;
+  }
+  return result;
+};
+
+export const normalizeAndValidateEIP712Data = (
+  input                                     ,
+  options                                        = {},
+                                      ) => {
+  const { message, types, primaryType } = input;
+  const onExtraField = options.onExtraField ?? 'drop';
+
+  if (!(primaryType in types)) {
+    throw new Error(
+      `Unknown EIP-712 primary type ${quoteName(primaryType)} (expected one of ${quoteNameList(Object.keys(types))})`,
+    );
+  }
+
+  // Built lazily as struct types are encountered walking `message`, and
+  // shared across every instance of a given type name -- see `visit`.
+  const resultTypes = new Map                    ();
+  const getType          = typeName => {
+    const cached = resultTypes.get(typeName);
+    if (cached) return cached;
+    const declared = types[typeName];
+    if (!declared) return undefined; // primitive leaf
+    // Null-prototype so `fieldName in type` in `visit` can't collide with
+    // an inherited Object.prototype member (e.g. a field named "toString").
+    const fields             = Object.create(null);
+    for (const field of declared) {
+      fields[field.name] = {
+        state: field.optional ? 'optional-unseen' : 'required',
+        type: field.type,
+      };
+    }
+    resultTypes.set(typeName, fields);
+    return fields;
+  };
+
+  const projectedMessage = visit(
+    primaryType,
+    message,
+    getType,
+    onExtraField,
+  )                           ;
+
+  const outputTypes              = {};
+  for (const [typeName, fields] of resultTypes) {
+    outputTypes[typeName] = Object.entries(fields)
+      .filter(([, field]) => field.state === 'required')
+      .map(([name, field]) => ({ name, type: field.type }));
+  }
+  if ('EIP712Domain' in types) outputTypes.EIP712Domain = types.EIP712Domain;
+
+  return { message: projectedMessage, types: outputTypes };
+};

package/src/utils/viem.d.ts

@@ -8,4 +8,5 @@
  */
 export * from './viem-utils/hashTypedData.js';
 export * from './viem-utils/types.js';
+export * from './viem-utils/eip712-normalize.js';
 //# sourceMappingURL=viem.d.ts.map

package/src/utils/viem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["viem.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["viem.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,kCAAkC,CAAC"}

package/src/utils/viem.js

@@ -9,3 +9,4 @@
 
 export * from './viem-utils/hashTypedData.js';
 export * from './viem-utils/types.js';
+export * from './viem-utils/eip712-normalize.js';