@agoric/orchestration 0.1.1-dev-827f812.0.827f812 → 0.1.1-dev-dbd6917.0.dbd6917

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-827f812.0.827f812",
+  "version": "0.1.1-dev-dbd6917.0.dbd6917",
   "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-827f812.0.827f812",
-    "@agoric/cosmic-proto": "0.4.1-dev-827f812.0.827f812",
-    "@agoric/ertp": "0.16.3-dev-827f812.0.827f812",
-    "@agoric/internal": "0.3.3-dev-827f812.0.827f812",
-    "@agoric/network": "0.1.1-dev-827f812.0.827f812",
-    "@agoric/notifier": "0.6.3-dev-827f812.0.827f812",
-    "@agoric/store": "0.9.3-dev-827f812.0.827f812",
-    "@agoric/time": "0.3.3-dev-827f812.0.827f812",
-    "@agoric/vat-data": "0.5.3-dev-827f812.0.827f812",
-    "@agoric/vow": "0.1.1-dev-827f812.0.827f812",
-    "@agoric/zoe": "0.26.3-dev-827f812.0.827f812",
-    "@agoric/zone": "0.2.3-dev-827f812.0.827f812",
+    "@agoric/async-flow": "0.1.1-dev-dbd6917.0.dbd6917",
+    "@agoric/cosmic-proto": "0.4.1-dev-dbd6917.0.dbd6917",
+    "@agoric/ertp": "0.16.3-dev-dbd6917.0.dbd6917",
+    "@agoric/internal": "0.3.3-dev-dbd6917.0.dbd6917",
+    "@agoric/network": "0.1.1-dev-dbd6917.0.dbd6917",
+    "@agoric/notifier": "0.6.3-dev-dbd6917.0.dbd6917",
+    "@agoric/store": "0.9.3-dev-dbd6917.0.dbd6917",
+    "@agoric/time": "0.3.3-dev-dbd6917.0.dbd6917",
+    "@agoric/vat-data": "0.5.3-dev-dbd6917.0.dbd6917",
+    "@agoric/vow": "0.1.1-dev-dbd6917.0.dbd6917",
+    "@agoric/zoe": "0.26.3-dev-dbd6917.0.dbd6917",
+    "@agoric/zone": "0.2.3-dev-dbd6917.0.dbd6917",
     "@cosmjs/encoding": "^0.36.0",
     "@endo/base64": "^1.1.1",
     "@endo/common": "^1.4.0",
@@ -61,9 +61,9 @@
     "bs58": "^6.0.0"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-827f812.0.827f812",
-    "@agoric/vats": "0.15.2-dev-827f812.0.827f812",
-    "@agoric/xsnap": "0.14.3-dev-827f812.0.827f812",
+    "@agoric/swingset-liveslots": "0.10.3-dev-dbd6917.0.dbd6917",
+    "@agoric/vats": "0.15.2-dev-dbd6917.0.dbd6917",
+    "@agoric/xsnap": "0.14.3-dev-dbd6917.0.dbd6917",
     "@chain-registry/client": "^1.53.194",
     "@cosmjs/amino": "^0.36.0",
     "@cosmjs/proto-signing": "^0.36.0",
@@ -100,5 +100,5 @@
   "typeCoverage": {
     "atLeast": 96.68
   },
-  "gitHead": "827f81218d5ef867dc728af19600eb5c9ad72fcc"
+  "gitHead": "dbd69178a10fc0c096d38f920c54bcf8e38d083c"
 }

package/src/typeGuards.d.ts

@@ -224,12 +224,36 @@ export const ForwardOptsShape: CastedPattern<NonNullable<IBCMsgTransferOptions["
  * @internal
  */
 export const IBCTransferOptionsShape: CastedPattern<IBCMsgTransferOptions>;
+export namespace EIP712TypeEntryShape {
+    let name: import("@endo/patterns").MatcherOf<"string", string>;
+    let type: import("@endo/patterns").MatcherOf<"string", string>;
+}
+/**
+ * EIP-712 struct type definitions, keyed by type name. The `EIP712Domain` type
+ * is not required; a consumer that requires it can combine this with e.g.
+ * `M.splitRecord({ EIP712Domain: M.any() }, {}, M.any())` using `M.and`.
+ */
+export const EIP712TypesShape: import("@endo/patterns").MatcherOf<"recordOf", [import("@endo/patterns").MatcherOf<"string", string>, import("@endo/patterns").MatcherOf<"arrayOf", {
+    name: import("@endo/patterns").MatcherOf<"string", string>;
+    type: import("@endo/patterns").MatcherOf<"string", string>;
+}>]>;
+/**
+ * An EIP-712 domain, with only standard fields, all optional. An integer
+ * `chainId` may be in any form accepted for EIP-712 integers.
+ */
+export const EIP712DomainShape: import("@endo/patterns").MatcherOf<"splitRecord", [{}, {
+    name: import("@endo/patterns").MatcherOf<"string", string>;
+    version: import("@endo/patterns").MatcherOf<"string", string>;
+    chainId: import("@endo/patterns").MatcherOf<"or", [import("@endo/patterns").MatcherOf<"string", string>, import("@endo/patterns").MatcherOf<"number", number>, import("@endo/patterns").MatcherOf<"bigint", bigint>]>;
+    verifyingContract: import("@endo/patterns").MatcherOf<"string", string>;
+    salt: import("@endo/patterns").MatcherOf<"string", string>;
+}, {}]>;
 export namespace SignedEIP712DataShape {
-    let domain: import("@endo/patterns").MatcherOf<"recordOf", any>;
-    let types: import("@endo/patterns").MatcherOf<"recordOf", any>;
-    let primaryType: import("@endo/patterns").MatcherOf<"string", string>;
-    let message: import("@endo/patterns").MatcherOf<"recordOf", any>;
-    let signature: import("@endo/patterns").MatcherOf<"or", [import("@endo/patterns").MatcherOf<"string", string>, import("@endo/patterns").MatcherOf<"recordOf", any>]>;
+    export { EIP712DomainShape as domain };
+    export { EIP712TypesShape as types };
+    export let primaryType: import("@endo/patterns").MatcherOf<"string", string>;
+    export let message: import("@endo/patterns").MatcherOf<"recordOf", [import("@endo/patterns").MatcherOf<"string", string>, import("@endo/patterns").MatcherOf<"any", any>]>;
+    export let signature: import("@endo/patterns").MatcherOf<"or", [import("@endo/patterns").MatcherOf<"string", string>, import("@endo/patterns").MatcherOf<"recordOf", any>]>;
 }
 import type { Caip10Record } from './types.js';
 import type { CastedPattern } from '@endo/patterns';

package/src/typeGuards.d.ts.map

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

package/src/typeGuards.js

@@ -379,10 +379,48 @@ export const IBCTransferOptionsShape = M.and(
   CosmosActionOptionsShape,
 );
 
+/**
+ * An entry of an EIP-712 struct type definition: a field name and its type.
+ * Nothing else is allowed, notably not the repo-local `optional` marker, which
+ * belongs in schema definitions only, never in typed data.
+ */
+export const EIP712TypeEntryShape = { name: M.string(), type: M.string() };
+harden(EIP712TypeEntryShape);
+
+/**
+ * EIP-712 struct type definitions, keyed by type name. The `EIP712Domain` type
+ * is not required; a consumer that requires it can combine this with e.g.
+ * `M.splitRecord({ EIP712Domain: M.any() }, {}, M.any())` using `M.and`.
+ */
+export const EIP712TypesShape = M.recordOf(
+  M.string(),
+  M.arrayOf(EIP712TypeEntryShape),
+);
+harden(EIP712TypesShape);
+
+/**
+ * An EIP-712 domain, with only standard fields, all optional. An integer
+ * `chainId` may be in any form accepted for EIP-712 integers.
+ */
+export const EIP712DomainShape = M.splitRecord(
+  {},
+  {
+    name: M.string(),
+    version: M.string(),
+    chainId: M.or(M.string(), M.number(), M.bigint()),
+    verifyingContract: M.string(),
+    salt: M.string(),
+  },
+  {},
+);
+harden(EIP712DomainShape);
+
 /**
  * The fields of signed EIP-712 typed data, e.g. as relayed on behalf of its
- * signer. Only the envelope is described: the typed data itself, and its
- * signature, need to be validated separately.
+ * signer. Only the structure is described: the values themselves (whose
+ * types depend on the typed data's `types`, and can't be described by a
+ * recursive pattern), identifiers, and the signature need to be validated
+ * separately, e.g. by `normalizeAndValidateEIP712Data`.
  *
  * The signature may be in any passable form accepted by viem (see
  * `WithSignature`): hex encoded, or structured (`{ r, s, v }` or
@@ -391,10 +429,10 @@ export const IBCTransferOptionsShape = M.and(
  * As a record of shapes, it can also be extended with other fields.
  */
 export const SignedEIP712DataShape = {
-  domain: M.record(),
-  types: M.record(),
+  domain: EIP712DomainShape,
+  types: EIP712TypesShape,
   primaryType: M.string(),
-  message: M.record(),
+  message: M.recordOf(M.string(), M.any()),
   signature: M.or(M.string(), M.record()),
 };
 harden(SignedEIP712DataShape);

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

@@ -87,11 +87,29 @@ export type NormalizeAndValidateEIP712DataResult = {
     message: Record<string, unknown>;
     types: TypesRecord;
 };
+/**
+ * Make a `RegExp` of the grammar of string-encoded EIP-712 `(u)int<M>` values
+ * accepted by {@link parseEIP712Integer}: unsigned hex, or decimal with an
+ * optional sign. Such strings are also bounded in length by
+ * {@link EIP712_INTEGER_STRING_MAX_LENGTH}.
+ *
+ * For consumers that need to describe the grammar (e.g. in an API schema); to
+ * validate a value, prefer {@link parseEIP712Integer}. Each call returns a new
+ * instance, since a `RegExp` is mutable.
+ */
+export declare const makeEIP712IntegerStringRegExp: () => RegExp;
+/**
+ * The maximum length of a string-encoded EIP-712 integer accepted by
+ * {@link parseEIP712Integer}. Bounds the work `BigInt` parsing of an
+ * untrusted string can do. Generous for any in-range 256-bit value (at most
+ * 78 decimal or 64 hex digits), leaving room for some leading zeros in hex.
+ */
+export declare const EIP712_INTEGER_STRING_MAX_LENGTH = 100;
 /**
  * Parses an integer given in one of the JS representations accepted for an
  * EIP-712 `(u)int<M>` value: a `bigint`, a safe integer `number`, or a
  * string of unsigned hex (`0x...`) or optionally signed decimal digits (see
- * `INTEGER_STRING_REGEX`). Returns `undefined` for anything else, including
+ * {@link makeEIP712IntegerStringRegExp}). Returns `undefined` for anything else, including
  * non-integer and unsafe-integer numbers (which have likely already lost
  * precision; ethers.js rejects them too). Does not check the value's range
  * for any particular type: see {@link normalizeEIP712Primitive} for that.

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

@@ -1 +1 @@
-{"version":3,"file":"eip712-normalize.d.ts","sourceRoot":"","sources":["eip712-normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;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;IACzC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,OAAO,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,WAAW,CAAC;CACpB,CAAC;AAsIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAc5D,CAAC;AAeF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,wBAAwB,GACnC,WAAW,MAAM,EACjB,OAAO,OAAO,KACb,OAgFF,CAAC;AAwLF,eAAO,MAAM,8BAA8B,GACzC,OAAO,mCAAmC,EAC1C,UAAS,qCAA0C,KAClD,oCA+EF,CAAC"}
+{"version":3,"file":"eip712-normalize.d.ts","sourceRoot":"","sources":["eip712-normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;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;IACzC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,OAAO,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,KAAK,EAAE,WAAW,CAAC;CACpB,CAAC;AA4CF;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,QAAO,MACf,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,MAAM,CAAC;AAwFpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAc5D,CAAC;AAeF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,wBAAwB,GACnC,WAAW,MAAM,EACjB,OAAO,OAAO,KACb,OAgFF,CAAC;AAwLF,eAAO,MAAM,8BAA8B,GACzC,OAAO,mCAAmC,EAC1C,UAAS,qCAA0C,KAClD,oCA+EF,CAAC"}

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

@@ -133,10 +133,27 @@ const HEX_REGEX = /^0x[0-9a-fA-F]*$/u;
 // which has no distinct meaning (`0` and `+0` are fine). Hex may have
 // leading zeros, as fixed-width hex commonly does.
 const INTEGER_STRING_REGEX = /^(?:\+?0|[-+]?[1-9][0-9]*|0x[0-9a-fA-F]+)$/u;
-// Bounds the work `BigInt` parsing of an untrusted string can do. Generous
-// for any in-range 256-bit value (at most 78 decimal or 64 hex digits),
-// leaving room for some leading zeros in hex.
-const MAX_INTEGER_STRING_LENGTH = 100;
+
+/**
+ * Make a `RegExp` of the grammar of string-encoded EIP-712 `(u)int<M>` values
+ * accepted by {@link parseEIP712Integer}: unsigned hex, or decimal with an
+ * optional sign. Such strings are also bounded in length by
+ * {@link EIP712_INTEGER_STRING_MAX_LENGTH}.
+ *
+ * For consumers that need to describe the grammar (e.g. in an API schema); to
+ * validate a value, prefer {@link parseEIP712Integer}. Each call returns a new
+ * instance, since a `RegExp` is mutable.
+ */
+export const makeEIP712IntegerStringRegExp = ()         =>
+  new RegExp(INTEGER_STRING_REGEX);
+
+/**
+ * The maximum length of a string-encoded EIP-712 integer accepted by
+ * {@link parseEIP712Integer}. Bounds the work `BigInt` parsing of an
+ * untrusted string can do. Generous for any in-range 256-bit value (at most
+ * 78 decimal or 64 hex digits), leaving room for some leading zeros in hex.
+ */
+export const EIP712_INTEGER_STRING_MAX_LENGTH = 100;
 // abitype types `(u)int<M>` values as `number` for `M <= 48`, else `bigint`.
 const MAX_NUMBER_INTEGER_BITS = 48;
 
@@ -228,7 +245,7 @@ const describeValue = (value         )         => {
  * Parses an integer given in one of the JS representations accepted for an
  * EIP-712 `(u)int<M>` value: a `bigint`, a safe integer `number`, or a
  * string of unsigned hex (`0x...`) or optionally signed decimal digits (see
- * `INTEGER_STRING_REGEX`). Returns `undefined` for anything else, including
+ * {@link makeEIP712IntegerStringRegExp}). Returns `undefined` for anything else, including
  * non-integer and unsafe-integer numbers (which have likely already lost
  * precision; ethers.js rejects them too). Does not check the value's range
  * for any particular type: see {@link normalizeEIP712Primitive} for that.
@@ -242,7 +259,7 @@ export const parseEIP712Integer = (value         )                     => {
   }
   if (
     typeof value !== 'string' ||
-    value.length > MAX_INTEGER_STRING_LENGTH ||
+    value.length > EIP712_INTEGER_STRING_MAX_LENGTH ||
     !INTEGER_STRING_REGEX.test(value)
   ) {
     return undefined;