@crewhaus/tool-onchain 0.7.0 → 0.8.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+CrewHaus Factory
+Copyright 2026 Max Meier
+
+This product includes software developed by Max Meier
+(operating as StudioMax — https://studiomax.io) and contributors.
+
+The CrewHaus name and logo are trademarks of Max Meier. See
+https://github.com/crewhaus/factory/blob/main/TRADEMARK.md for the
+use-of-marks policy.

package/README.md

@@ -66,6 +66,27 @@ nothing on a chain. So:
   percentage, because a percentage invites a decimal and a decimal invites a
   float.
 
+- **Data that decodes to far more than itself.** Return data comes from
+  whoever deployed the contract, and nothing in the ABI format stops two
+  offsets pointing at the same bytes: a few kilobytes whose heads all share
+  one tail decode to millions of values. `AbiDecode` (and every package that
+  decodes through it) refuses data that decodes to more than four times its
+  own size — no encoder writes such data — and checks an array's length
+  against the bytes that follow it before building anything. It also counts
+  the values it produces, tuples and arrays included, and stops at what the
+  data could hold for those types if each word were read once. An empty
+  tuple `()` is refused as a type to decode: no Solidity type is one, and it
+  reads no bytes, so a type string full of them multiplied every word of
+  data on its own. Type strings are capped at 8,192 characters and 32 levels
+  of nesting.
+
+- **An address re-typed between two calls.** `AbiEncodeCall` and
+  `TypedDataHash` (message fields and `verifyingContract` alike) check every
+  address they encode the way `AddressCheck` does: 0x and 40 hex characters,
+  and a mixed-case address must pass its EIP-55 checksum. All-lowercase and
+  all-uppercase hex carry no checksum and are accepted, as ethers and viem
+  accept them.
+
 An address with no checksum is reported as valid **and** as unverifiable,
 rather than letting `valid: true` be read as "no typo". A position with no
 debt has no health factor rather than an infinite one — `Infinity` would read
@@ -105,7 +126,11 @@ same as all of them, so every entry point takes it as an argument.
 - **It does not sign or hold keys.**
 - **It does not know what a contract does.** `AbiDecode` decodes the types
   you name; naming the wrong ones produces confident nonsense, which is why
-  data that ends early is an error rather than a short answer.
+  data that ends early is an error rather than a short answer. So is a word
+  that is not the encoding of its type — a `uint8` holding 256, an `address`
+  or `bytes4` with non-zero padding, an `int8` that is not sign-extended —
+  which is how Solidity's own decoder treats it, and what reading a
+  `uint256` slot as a `uint8` looks like.
 - **It does not fetch an ABI.** Signatures come from the caller.
 - **It does not price anything.** `DefiMath` computes against a reference you
   supply; where that reference came from is your problem.

package/dist/index.d.ts

@@ -4,7 +4,18 @@ import type { RegisteredTool } from "@crewhaus/tool-catalog";
  * registers no tool of its own: a batch read is only useful to something that
  * can dial a chain, and nothing in this package dials anything.
  */
-export { AGGREGATE3_RETURN_TYPE, AGGREGATE3_SELECTOR, AGGREGATE3_SIGNATURE, type Aggregate3Request, type Aggregate3Result, type Call3, ERROR_STRING_SELECTOR, MULTICALL3_ADDRESS, PANIC_REASONS, PANIC_SELECTOR, type RevertKind, type RevertReason, decodeAggregate3, decodeRevertData, encodeAggregate3, } from "./lib/multicall";
+export { AGGREGATE3_RETURN_TYPE, AGGREGATE3_SELECTOR, AGGREGATE3_SIGNATURE, type Aggregate3Request, type Aggregate3Result, type Call3, ERROR_STRING_SELECTOR, MULTICALL3_ADDRESS, PANIC_REASONS, PANIC_SELECTOR, type RevertKind, type RevertReason, decodeAggregate3, decodeRevertData, encodeAggregate3, parseMulticallMap, } from "./lib/multicall";
+/**
+ * The canonical form of a function signature, and its four-byte selector —
+ * the pair that tells two overloads of one name apart. `uint` is `uint256`
+ * here, as it is in the hash; a malformed signature throws, naming what is
+ * wrong. Library code for a package that builds tools from an ABI
+ * (`@crewhaus/tool-contract-gateway`); like everything here, it dials nothing.
+ */
+export declare function canonicalFunction(signature: string): {
+    readonly signature: string;
+    readonly selector: string;
+};
 export declare const abiEncodeCall: RegisteredTool;
 export declare const abiDecode: RegisteredTool;
 export declare const functionSelector: RegisteredTool;

package/dist/index.js

@@ -19,7 +19,7 @@
 import { buildTool } from "@crewhaus/tool-builder";
 import { keccak256Hex } from "@crewhaus/tool-encode";
 import { z } from "zod";
-import { decodeData, encodeCall, parseSignature, selectorOf } from "./lib/abi";
+import { canonicalSignature, decodeData, encodeCall, parseSignature, selectorOf, } from "./lib/abi";
 import { formatUnits, parseUnits, validateAddress } from "./lib/address";
 import { healthFactorBps, maximumIn, minimumOut, priceImpactBps, rescaleDecimals, shareBps, } from "./lib/defi";
 import { personalSignHash, typedDataDigest } from "./lib/typed";
@@ -28,7 +28,19 @@ import { personalSignHash, typedDataDigest } from "./lib/typed";
  * registers no tool of its own: a batch read is only useful to something that
  * can dial a chain, and nothing in this package dials anything.
  */
-export { AGGREGATE3_RETURN_TYPE, AGGREGATE3_SELECTOR, AGGREGATE3_SIGNATURE, ERROR_STRING_SELECTOR, MULTICALL3_ADDRESS, PANIC_REASONS, PANIC_SELECTOR, decodeAggregate3, decodeRevertData, encodeAggregate3, } from "./lib/multicall";
+export { AGGREGATE3_RETURN_TYPE, AGGREGATE3_SELECTOR, AGGREGATE3_SIGNATURE, ERROR_STRING_SELECTOR, MULTICALL3_ADDRESS, PANIC_REASONS, PANIC_SELECTOR, decodeAggregate3, decodeRevertData, encodeAggregate3, parseMulticallMap, } from "./lib/multicall";
+/**
+ * The canonical form of a function signature, and its four-byte selector —
+ * the pair that tells two overloads of one name apart. `uint` is `uint256`
+ * here, as it is in the hash; a malformed signature throws, naming what is
+ * wrong. Library code for a package that builds tools from an ABI
+ * (`@crewhaus/tool-contract-gateway`); like everything here, it dials nothing.
+ */
+export function canonicalFunction(signature) {
+    const { name, types } = parseSignature(signature);
+    const canonical = canonicalSignature(name, types);
+    return { signature: canonical, selector: `0x${selectorOf(canonical)}` };
+}
 const json = (value) => JSON.stringify(value);
 const LIMITS = { args: 256, types: 64, hexChars: 2_000_000 };
 /** Accepts a bigint-safe integer: a decimal or hex string, or a safe number. */
@@ -77,7 +89,7 @@ export const abiEncodeCall = buildTool({
 });
 export const abiDecode = buildTool({
     name: "AbiDecode",
-    description: "Decode ABI-encoded hex — an eth_call result, a log's data, a transaction's arguments, revert data — into named, typed values. Use it to read a contract's answer without a model squinting at 32-byte words. Integers come back as decimal STRINGS so a uint256 survives JSON intact; addresses come back lowercase and hex-prefixed. Data that ends early is an error rather than a plausible short answer.",
+    description: "Decode ABI-encoded hex — an eth_call result, a log's data, a transaction's arguments, revert data — into named, typed values. Use it to read a contract's answer without a model squinting at 32-byte words. Integers come back as decimal STRINGS so a uint256 survives JSON intact; addresses come back lowercase and hex-prefixed. Data that ends early is an error rather than a plausible short answer, and so is a word that no encoder writes for its type — a uint8 holding 256, an address or bytes4 with non-zero padding, an int8 that is not sign-extended — because that is what naming the wrong types looks like.",
     inputSchema: z.object({
         data: z.string().max(LIMITS.hexChars).describe("0x hex, without a function selector"),
         types: z.array(z.string()).min(1).max(LIMITS.types).describe('e.g. ["uint256", "address"]'),

package/dist/lib/abi.d.ts

@@ -11,7 +11,27 @@ export type AbiType = {
     /** Canonical form, which is what the selector is computed over. */
     readonly canonical: string;
 };
+/**
+ * The longest type string, and the deepest nesting of arrays and tuples,
+ * this parses. Each level rescans the text beneath it, so an unbounded one
+ * costs time in the square of its length; real ABI types are a few hundred
+ * characters and a handful of levels deep.
+ */
+export declare const MAX_TYPE_CHARS = 8192;
+export declare const MAX_TYPE_DEPTH = 32;
 export declare function parseType(raw: string): AbiType;
+/**
+ * Hex to bytes, strictly: an odd number of digits or a non-hex character is
+ * refused, never truncated or skipped. The one hex decoder the coder and the
+ * EIP-712 hasher share, so they cannot disagree about what a value is.
+ */
+export declare function hexToBytes(raw: string, what: string): Uint8Array;
+/**
+ * A `bytes` or `bytesN` value: a hex string. A number is refused rather than
+ * read as its decimal digits reinterpreted as hex, which is how 4660 would
+ * become 0x4660.
+ */
+export declare function bytesArg(value: unknown, what: string): Uint8Array;
 /** Head/tail encoding for a list of types, which is what a tuple is. */
 export declare function encodeTuple(types: ReadonlyArray<AbiType>, values: ReadonlyArray<AbiValue>, what?: string): Uint8Array;
 /** The canonical signature a selector is hashed over. */
@@ -25,5 +45,34 @@ export declare function parseSignature(signature: string): {
 export declare function encodeCall(signature: string, args: ReadonlyArray<AbiValue>): string;
 /** Decoded values use strings for integers, so a uint256 survives JSON. */
 export type Decoded = string | boolean | Decoded[];
+/**
+ * How far a decode may inflate its input.
+ *
+ * An ABI encoding points at its dynamic values with offsets, and nothing in
+ * the format stops two offsets pointing at the same bytes. No encoder writes
+ * that — the compilers, ethers and viem each write every tail once — but a
+ * hostile contract or a crafted blob can: n heads sharing one tail decode it
+ * n times, at every level of nesting, so a few kilobytes decode to millions
+ * of values, and one call pins a core and fills the heap.
+ *
+ * So a decode is metered twice:
+ *
+ * - Every word read and every word of string or bytes payload costs one
+ *   unit, and a decode may spend {@link MAX_INFLATION} units per word of
+ *   input (and at least {@link BUDGET_FLOOR}). An honest encoding reads each
+ *   word about once and never comes near the limit.
+ * - Every value decoded — a tuple and an array included, not only the words
+ *   in them — is counted, and a decode may produce at most `1 + n` values
+ *   per word of input, where `n` is how deeply the types nest. A value either
+ *   reads a word of its own or is a tuple or an array holding at least one
+ *   value, so an encoding that reads each word once never produces more.
+ *   Without this count a type string could multiply its data on its own:
+ *   `((),(),…,uint256)[]` read one word per item and returned thousands of
+ *   values for it.
+ *
+ * An empty tuple `()` is refused outright: no Solidity type is one, and it
+ * decodes from no bytes at all, so nothing in the data could back it.
+ */
+export declare const MAX_INFLATION = 4;
 export declare function decodeTuple(types: ReadonlyArray<AbiType>, data: Uint8Array, base?: number, what?: string): Decoded[];
 export declare function decodeData(typeList: ReadonlyArray<string>, hex: string): Decoded[];

package/dist/lib/abi.js

@@ -13,6 +13,7 @@
  * ether.
  */
 import { keccak256, toHex } from "@crewhaus/tool-encode";
+import { checkedAddress } from "./address";
 const WORD = 32;
 const INT_RE = /^(u?int)(\d*)$/;
 const BYTES_RE = /^bytes(\d*)$/;
@@ -37,18 +38,41 @@ function splitTop(text) {
         parts.push(current.trim());
     return parts;
 }
+/**
+ * The longest type string, and the deepest nesting of arrays and tuples,
+ * this parses. Each level rescans the text beneath it, so an unbounded one
+ * costs time in the square of its length; real ABI types are a few hundred
+ * characters and a handful of levels deep.
+ */
+export const MAX_TYPE_CHARS = 8192;
+export const MAX_TYPE_DEPTH = 32;
 export function parseType(raw) {
+    if (raw.length > MAX_TYPE_CHARS) {
+        throw new Error(`a type of ${raw.length} characters is longer than the ${MAX_TYPE_CHARS} this reads`);
+    }
+    return parseTypeAt(raw, 0);
+}
+function parseTypeAt(raw, depth) {
     const text = raw.trim();
     if (text === "")
         throw new Error("an empty string is not an ABI type");
+    if (depth > MAX_TYPE_DEPTH) {
+        throw new Error(`the type nests arrays and tuples more than ${MAX_TYPE_DEPTH} levels deep`);
+    }
     // Array suffix, innermost last: `uint256[2][]` is a dynamic array of
     // fixed-length-2 arrays, so the LAST suffix is the outer type.
     const arrayMatch = /^(.*)\[(\d*)\]$/.exec(text);
     if (arrayMatch) {
-        const child = parseType(arrayMatch[1]);
+        const child = parseTypeAt(arrayMatch[1], depth + 1);
         const length = arrayMatch[2] === "" ? -1 : Number.parseInt(arrayMatch[2], 10);
         if (length === 0)
             throw new Error(`"${text}" has a zero-length array, which cannot hold a value`);
+        // A fixed length is laid out inline, so its size must be a number this
+        // can count in: a type string is not a reason to believe in 2^64 items.
+        if (length !== -1 &&
+            !Number.isSafeInteger(length * (child.dynamic ? WORD : staticSize(child)))) {
+            throw new Error(`"${text}" is a fixed array too large to lay out`);
+        }
         return {
             base: "array",
             bits: 0,
@@ -60,7 +84,7 @@ export function parseType(raw) {
         };
     }
     if (text.startsWith("(") && text.endsWith(")")) {
-        const components = splitTop(text.slice(1, -1)).map(parseType);
+        const components = splitTop(text.slice(1, -1)).map((c) => parseTypeAt(c, depth + 1));
         return {
             base: "tuple",
             bits: 0,
@@ -150,7 +174,12 @@ export function parseType(raw) {
     }
     throw new Error(`"${text}" is not an ABI type this understands`);
 }
-function hexToBytes(raw, what) {
+/**
+ * Hex to bytes, strictly: an odd number of digits or a non-hex character is
+ * refused, never truncated or skipped. The one hex decoder the coder and the
+ * EIP-712 hasher share, so they cannot disagree about what a value is.
+ */
+export function hexToBytes(raw, what) {
     const text = raw.startsWith("0x") || raw.startsWith("0X") ? raw.slice(2) : raw;
     if (text.length % 2 !== 0)
         throw new Error(`${what} has an odd number of hex digits`);
@@ -161,6 +190,17 @@ function hexToBytes(raw, what) {
         out[i] = Number.parseInt(text.slice(i * 2, i * 2 + 2), 16);
     return out;
 }
+/**
+ * A `bytes` or `bytesN` value: a hex string. A number is refused rather than
+ * read as its decimal digits reinterpreted as hex, which is how 4660 would
+ * become 0x4660.
+ */
+export function bytesArg(value, what) {
+    if (typeof value !== "string") {
+        throw new Error(`${what}: bytes are a 0x hex string, not a ${typeof value}`);
+    }
+    return hexToBytes(value, what);
+}
 /** Two's complement into a 32-byte word, big-endian. */
 function wordFromBigInt(value, signed, bits, what) {
     const limit = 1n << BigInt(bits);
@@ -255,18 +295,16 @@ function encodeValue(type, value, what) {
         return type.dynamic ? { head: none, tail: body } : { head: body, tail: none };
     }
     if (type.base === "string" || type.base === "bytes") {
-        const bytes = type.base === "string"
-            ? new TextEncoder().encode(String(value))
-            : hexToBytes(String(value), what);
+        const bytes = type.base === "string" ? new TextEncoder().encode(String(value)) : bytesArg(value, what);
         return {
             head: none,
             tail: concat([wordFromBigInt(BigInt(bytes.length), false, 256, what), padRight(bytes)]),
         };
     }
     if (type.base === "address") {
-        const bytes = hexToBytes(String(value), what);
-        if (bytes.length !== 20)
-            throw new Error(`${what}: an address is 20 bytes, got ${bytes.length}`);
+        // Shape AND checksum: a mixed-case address that fails EIP-55 has a wrong
+        // character in it, and encoding it anyway sends to that wrong address.
+        const bytes = hexToBytes(checkedAddress(value, what), what);
         const word = new Uint8Array(WORD);
         word.set(bytes, 12);
         return { head: word, tail: none };
@@ -277,7 +315,7 @@ function encodeValue(type, value, what) {
         return { head: wordFromBigInt(value ? 1n : 0n, false, 8, what), tail: none };
     }
     if (type.base === "bytesN") {
-        const bytes = hexToBytes(String(value), what);
+        const bytes = bytesArg(value, what);
         const size = type.bits / 8;
         if (bytes.length !== size)
             throw new Error(`${what}: bytes${size} needs ${size} bytes, got ${bytes.length}`);
@@ -324,6 +362,9 @@ export function selectorOf(signature) {
 }
 /** Split `transfer(address,uint256)` into its name and parsed argument types. */
 export function parseSignature(signature) {
+    if (signature.length > MAX_TYPE_CHARS) {
+        throw new Error(`a signature of ${signature.length} characters is longer than the ${MAX_TYPE_CHARS} this reads`);
+    }
     const open = signature.indexOf("(");
     if (open === -1 || !signature.trim().endsWith(")")) {
         throw new Error(`"${signature}" is not a function signature — expected name(type,type)`);
@@ -343,78 +384,208 @@ export function encodeCall(signature, args) {
     const canonical = canonicalSignature(name, types);
     return `0x${selectorOf(canonical)}${toHex(encodeTuple(types, args))}`;
 }
-function wordAt(data, offset, what) {
+/**
+ * How far a decode may inflate its input.
+ *
+ * An ABI encoding points at its dynamic values with offsets, and nothing in
+ * the format stops two offsets pointing at the same bytes. No encoder writes
+ * that — the compilers, ethers and viem each write every tail once — but a
+ * hostile contract or a crafted blob can: n heads sharing one tail decode it
+ * n times, at every level of nesting, so a few kilobytes decode to millions
+ * of values, and one call pins a core and fills the heap.
+ *
+ * So a decode is metered twice:
+ *
+ * - Every word read and every word of string or bytes payload costs one
+ *   unit, and a decode may spend {@link MAX_INFLATION} units per word of
+ *   input (and at least {@link BUDGET_FLOOR}). An honest encoding reads each
+ *   word about once and never comes near the limit.
+ * - Every value decoded — a tuple and an array included, not only the words
+ *   in them — is counted, and a decode may produce at most `1 + n` values
+ *   per word of input, where `n` is how deeply the types nest. A value either
+ *   reads a word of its own or is a tuple or an array holding at least one
+ *   value, so an encoding that reads each word once never produces more.
+ *   Without this count a type string could multiply its data on its own:
+ *   `((),(),…,uint256)[]` read one word per item and returned thousands of
+ *   values for it.
+ *
+ * An empty tuple `()` is refused outright: no Solidity type is one, and it
+ * decodes from no bytes at all, so nothing in the data could back it.
+ */
+export const MAX_INFLATION = 4;
+const BUDGET_FLOOR = 1024;
+/** How many tuples and arrays deep a type goes: 0 for a word, 1 for `uint256[]`. */
+function nesting(type) {
+    if (type.base === "array")
+        return 1 + nesting(type.child);
+    if (type.base === "tuple") {
+        return 1 + type.components.reduce((deepest, c) => Math.max(deepest, nesting(c)), 0);
+    }
+    return 0;
+}
+function budgetFor(data, types) {
+    const words = Math.ceil(data.length / WORD);
+    const perWord = 1 + types.reduce((deepest, t) => Math.max(deepest, nesting(t)), 0);
+    const maxValues = Math.max(BUDGET_FLOOR, words * perWord);
+    return {
+        remaining: Math.max(BUDGET_FLOOR, words * MAX_INFLATION),
+        values: maxValues,
+        maxValues,
+    };
+}
+function charge(budget, units, what) {
+    budget.remaining -= units;
+    if (budget.remaining < 0) {
+        throw new Error(`${what}: the data decodes to more than ${MAX_INFLATION} times its own size — its offsets point at the same bytes again and again, which no ABI encoder writes. Refusing to inflate it.`);
+    }
+}
+/** One decoded value, counted against the decode's value budget. */
+function chargeValue(budget, what) {
+    budget.values -= 1;
+    if (budget.values < 0) {
+        throw new Error(`${what}: the data decodes to more than ${budget.maxValues} values, more than its size can hold for these types when each word is read once — its offsets point at the same bytes again and again, or the types multiply it. Refusing to inflate it.`);
+    }
+}
+function wordAt(data, offset, what, budget) {
     if (offset + WORD > data.length) {
         throw new Error(`${what}: the data ends before offset ${offset}, so it is truncated or mistyped`);
     }
+    charge(budget, 1, what);
     return data.subarray(offset, offset + WORD);
 }
-function bigIntFromWord(word, signed, bits) {
+/** A word read as an unsigned 256-bit integer: an offset, a length, or a value to check. */
+function uintFromWord(word) {
     let value = 0n;
     for (const byte of word)
         value = (value << 8n) | BigInt(byte);
-    if (!signed)
-        return value;
-    const limit = 1n << BigInt(bits);
-    const half = limit >> 1n;
-    const truncated = value & (limit - 1n);
-    return truncated >= half ? truncated - limit : truncated;
+    return value;
+}
+/** How many bytes one element of this type takes where its parent lays it out. */
+function headSize(type) {
+    return type.dynamic ? WORD : staticSize(type);
+}
+/**
+ * Decode `count` elements of one type laid out from `start` — an array's
+ * items. The data must be able to hold them BEFORE anything is decoded or
+ * allocated: a length is a claim the data makes about itself, and a fixed
+ * length is a claim the caller's type string makes.
+ */
+function decodeRepeated(count, child, data, start, what, budget) {
+    const each = headSize(child);
+    // A zero-size element (an empty tuple) takes no bytes, so no length the
+    // data claims for it is backed by anything.
+    if (each === 0 && count > 0) {
+        throw new Error(`${what}: an array of ${child.canonical} holds nothing the data can back`);
+    }
+    const need = count * each;
+    if (!Number.isSafeInteger(need) || start + need > data.length) {
+        throw new Error(`${what}: claims ${count} items, more than the data could hold`);
+    }
+    return decodeSequence(count, () => child, data, start, what, budget);
 }
-function decodeValue(type, data, offset, what) {
+function decodeValue(type, data, offset, what, budget) {
+    chargeValue(budget, what);
     if (type.base === "array") {
         const child = type.child;
         if (type.arrayLength === -1) {
-            const length = Number(bigIntFromWord(wordAt(data, offset, what), false, 256));
-            if (length * WORD > data.length) {
-                throw new Error(`${what}: claims ${length} items, more than the data could hold`);
-            }
-            return decodeTuple(new Array(length).fill(child), data, offset + WORD, what);
+            const length = Number(uintFromWord(wordAt(data, offset, what, budget)));
+            return decodeRepeated(length, child, data, offset + WORD, what, budget);
         }
-        return decodeTuple(new Array(type.arrayLength).fill(child), data, offset, what);
+        return decodeRepeated(type.arrayLength, child, data, offset, what, budget);
+    }
+    if (type.base === "tuple") {
+        const components = type.components;
+        if (components.length === 0) {
+            throw new Error(`${what}: () is an empty tuple — no Solidity type is one, and it decodes from no bytes, so nothing in the data can back it`);
+        }
+        return decodeSequence(components.length, (i) => components[i], data, offset, what, budget);
     }
-    if (type.base === "tuple")
-        return decodeTuple(type.components, data, offset, what);
     if (type.base === "string" || type.base === "bytes") {
-        const length = Number(bigIntFromWord(wordAt(data, offset, what), false, 256));
+        const length = Number(uintFromWord(wordAt(data, offset, what, budget)));
         const start = offset + WORD;
         if (start + length > data.length) {
             throw new Error(`${what}: declares ${length} bytes, past the end of the data`);
         }
+        charge(budget, Math.ceil(length / WORD), what);
         const bytes = data.subarray(start, start + length);
         return type.base === "string" ? new TextDecoder().decode(bytes) : `0x${toHex(bytes)}`;
     }
-    const word = wordAt(data, offset, what);
-    if (type.base === "address")
+    return decodeStaticWord(type, wordAt(data, offset, what, budget), what);
+}
+/** True when every byte in the slice is zero. */
+function allZero(bytes) {
+    return bytes.every((b) => b === 0);
+}
+/**
+ * One static word, read as its type — and refused unless it is the ONE word
+ * an encoder writes for a value of that type.
+ *
+ * A 32-byte word holds more than an address, a uint8 or a bytes4 can, and the
+ * ABI says what the rest must be: zero padding, or a sign extension. Solidity's
+ * decoder reverts on a word that breaks that; reading it anyway returns a value
+ * the named type cannot hold — a uint8 of 2^256−1, an "address" read from the
+ * low bytes of a balance — which is what naming the wrong types looks like,
+ * and a plausible answer to a question nobody asked. So it is an error, as a
+ * bool word of 2 always was.
+ */
+function decodeStaticWord(type, word, what) {
+    const value = uintFromWord(word);
+    if (type.base === "address") {
+        if (!allZero(word.subarray(0, 12))) {
+            throw new Error(`${what}: an address word has non-zero upper bytes (0x${toHex(word.subarray(0, 12))}), so it is not an address — the data is mistyped or was not ABI-encoded`);
+        }
         return `0x${toHex(word.subarray(12))}`;
+    }
     if (type.base === "bool") {
-        const value = bigIntFromWord(word, false, 256);
         if (value > 1n)
             throw new Error(`${what}: a bool word holds ${value}, which is neither true nor false`);
         return value === 1n;
     }
-    if (type.base === "bytesN")
-        return `0x${toHex(word.subarray(0, type.bits / 8))}`;
-    return bigIntFromWord(word, type.base === "int", type.bits).toString();
+    if (type.base === "bytesN") {
+        const size = type.bits / 8;
+        if (!allZero(word.subarray(size))) {
+            throw new Error(`${what}: a bytes${size} word has non-zero padding after its ${size} bytes — the data is mistyped or was not ABI-encoded`);
+        }
+        return `0x${toHex(word.subarray(0, size))}`;
+    }
+    if (type.base === "int") {
+        const signed = BigInt.asIntN(type.bits, value);
+        // A canonical intN word is the sign extension of its low N bits: every
+        // bit above them equals the sign bit.
+        if (BigInt.asUintN(256, signed) !== value) {
+            throw new Error(`${what}: the word is not a sign-extended int${type.bits} — its upper bits are neither all zero nor all one — so the data is mistyped or was not ABI-encoded`);
+        }
+        return signed.toString();
+    }
+    if (value >> BigInt(type.bits) !== 0n) {
+        throw new Error(`${what}: a uint${type.bits} word holds ${value}, which does not fit in ${type.bits} bits — the data is mistyped or was not ABI-encoded`);
+    }
+    return value.toString();
 }
-export function decodeTuple(types, data, base = 0, what = "value") {
+/** Head/tail decoding of `count` values laid out from `base`: a tuple, or an array's items. */
+function decodeSequence(count, typeAt, data, base, what, budget) {
     const out = [];
     let head = base;
-    for (const [i, type] of types.entries()) {
+    for (let i = 0; i < count; i++) {
+        const type = typeAt(i);
         const label = `${what}[${i}]`;
         if (type.dynamic) {
-            const offset = Number(bigIntFromWord(wordAt(data, head, label), false, 256));
+            const offset = Number(uintFromWord(wordAt(data, head, label, budget)));
             // An offset is relative to the start of the enclosing tuple. Treating
             // it as absolute reads the wrong bytes and usually still "works".
-            out.push(decodeValue(type, data, base + offset, label));
+            out.push(decodeValue(type, data, base + offset, label, budget));
             head += WORD;
         }
         else {
-            out.push(decodeValue(type, data, head, label));
+            out.push(decodeValue(type, data, head, label, budget));
             head += staticSize(type);
         }
     }
     return out;
 }
+export function decodeTuple(types, data, base = 0, what = "value") {
+    return decodeSequence(types.length, (i) => types[i], data, base, what, budgetFor(data, types));
+}
 /** How many bytes a static type occupies in a head. */
 function staticSize(type) {
     if (type.base === "tuple")

package/dist/lib/address.d.ts

@@ -11,6 +11,24 @@ export type AddressResult = {
 /** Apply the EIP-55 case checksum to a lowercase address. */
 export declare function toChecksumAddress(lowercase: string): string;
 export declare function validateAddress(raw: string): AddressResult;
+/**
+ * An address a coder may put into calldata or a digest: 0x and 40 hex
+ * characters, whose EIP-55 checksum holds when it carries one. Returns the
+ * checksummed form; throws the reason otherwise.
+ *
+ * Every path that writes an address goes through this, not only
+ * `AddressCheck`: the encoder is the last point where a re-typed character
+ * can still be caught, and ethers and viem refuse the same input.
+ */
+export declare function checkedAddress(raw: unknown, what: string): string;
+/**
+ * Whether `text` is an optional `-`, digits, an optional `.` and digits: what
+ * `/^-?\d*\.?\d*$/.test(text)` answered, in one pass. That pattern gave
+ * every digit back to the second run in turn when the text did not end where
+ * it should, so a long run of digits before a stray character was quadratic
+ * in its length, and the amount is the model's.
+ */
+export declare function isDecimalText(text: string): boolean;
 /**
  * Parse a decimal amount into base units, exactly.
  *

package/dist/lib/address.js

@@ -31,9 +31,11 @@ export function validateAddress(raw) {
             valid: false,
             checksummed: "",
             hadChecksum: false,
-            reason: /^0x/i.test(text)
-                ? `an address is 0x followed by 40 hex characters; this has ${body.length}`
-                : "an address starts with 0x",
+            reason: text.startsWith("0X")
+                ? "an address starts with a lowercase 0x; this starts with 0X"
+                : text.startsWith("0x")
+                    ? `an address is 0x followed by 40 hex characters; this has ${body.length}`
+                    : "an address starts with 0x",
         };
     }
     const checksummed = toChecksumAddress(body);
@@ -59,6 +61,44 @@ export function validateAddress(raw) {
             : "this address carries no EIP-55 checksum, so only its shape was checked; a typo in an all-lowercase address cannot be detected",
     };
 }
+/**
+ * An address a coder may put into calldata or a digest: 0x and 40 hex
+ * characters, whose EIP-55 checksum holds when it carries one. Returns the
+ * checksummed form; throws the reason otherwise.
+ *
+ * Every path that writes an address goes through this, not only
+ * `AddressCheck`: the encoder is the last point where a re-typed character
+ * can still be caught, and ethers and viem refuse the same input.
+ */
+export function checkedAddress(raw, what) {
+    if (typeof raw !== "string")
+        throw new Error(`${what}: an address is a 0x hex string`);
+    const result = validateAddress(raw);
+    if (!result.valid)
+        throw new Error(`${what}: ${result.reason}`);
+    return result.checksummed;
+}
+/**
+ * Whether `text` is an optional `-`, digits, an optional `.` and digits: what
+ * `/^-?\d*\.?\d*$/.test(text)` answered, in one pass. That pattern gave
+ * every digit back to the second run in turn when the text did not end where
+ * it should, so a long run of digits before a stray character was quadratic
+ * in its length, and the amount is the model's.
+ */
+export function isDecimalText(text) {
+    const digit = (i) => {
+        const c = text.charCodeAt(i);
+        return c >= 0x30 && c <= 0x39;
+    };
+    let i = text.charCodeAt(0) === 0x2d ? 1 : 0;
+    while (i < text.length && digit(i))
+        i++;
+    if (text.charCodeAt(i) === 0x2e)
+        i++;
+    while (i < text.length && digit(i))
+        i++;
+    return i === text.length;
+}
 /**
  * Parse a decimal amount into base units, exactly.
  *
@@ -67,7 +107,7 @@ export function validateAddress(raw) {
  */
 export function parseUnits(amount, decimals) {
     const text = amount.trim();
-    if (!/^-?\d*\.?\d*$/.test(text) || text === "" || text === "." || text === "-") {
+    if (!isDecimalText(text) || text === "" || text === "." || text === "-") {
         throw new Error(`"${amount}" is not a decimal amount`);
     }
     const negative = text.startsWith("-");

package/dist/lib/multicall.d.ts

@@ -7,6 +7,15 @@
  * Every entry point here takes the address as an argument.
  */
 export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+/**
+ * An operator's own Multicall3 deployments, from a tool_config block:
+ * `{ "<chainId>": "0x…" }`, for a chain where the deterministic deploy is not
+ * at {@link MULTICALL3_ADDRESS}. Every value must be an address whose
+ * checksum holds — an aggregator answers every read in a batch, so a typo
+ * here is every answer wrong. Returns chain id → EIP-55 address; `undefined`
+ * is an empty map.
+ */
+export declare function parseMulticallMap(input: unknown, what: string): ReadonlyMap<string, string>;
 /** The canonical signature, which is what the selector is hashed over. */
 export declare const AGGREGATE3_SIGNATURE = "aggregate3((address,bool,bytes)[])";
 /** `0x82ad56cb` — the four bytes a block explorer shows for a Multicall3 batch. */

package/dist/lib/multicall.js

@@ -27,7 +27,7 @@
  * or submits a transaction.
  */
 import { decodeData, encodeCall } from "./abi";
-import { validateAddress } from "./address";
+import { checkedAddress } from "./address";
 /**
  * Where Multicall3 is deployed on most chains, via a deterministic deploy.
  *
@@ -37,6 +37,26 @@ import { validateAddress } from "./address";
  * Every entry point here takes the address as an argument.
  */
 export const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+/**
+ * An operator's own Multicall3 deployments, from a tool_config block:
+ * `{ "<chainId>": "0x…" }`, for a chain where the deterministic deploy is not
+ * at {@link MULTICALL3_ADDRESS}. Every value must be an address whose
+ * checksum holds — an aggregator answers every read in a batch, so a typo
+ * here is every answer wrong. Returns chain id → EIP-55 address; `undefined`
+ * is an empty map.
+ */
+export function parseMulticallMap(input, what) {
+    const out = new Map();
+    if (input === undefined)
+        return out;
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        throw new Error(`${what} must map a chain id to its Multicall3 address, for example { "324": "0xF9cda624FBC7e059355ce98a31693d299FACd963" }`);
+    }
+    for (const [chainId, address] of Object.entries(input)) {
+        out.set(chainId.trim(), checkedAddress(address, `${what}["${chainId}"]`));
+    }
+    return out;
+}
 /** The canonical signature, which is what the selector is hashed over. */
 export const AGGREGATE3_SIGNATURE = "aggregate3((address,bool,bytes)[])";
 /** `0x82ad56cb` — the four bytes a block explorer shows for a Multicall3 batch. */
@@ -63,12 +83,6 @@ export const PANIC_REASONS = Object.freeze({
     "0x41": "too much memory was allocated, or an array was created too large",
     "0x51": "a zero-initialised variable of internal function type was called",
 });
-function checkedAddress(raw, what) {
-    const result = validateAddress(raw);
-    if (!result.valid)
-        throw new Error(`${what}: ${result.reason}`);
-    return result.checksummed;
-}
 function checkedBytes(raw, what) {
     const text = raw.trim();
     // An odd number of hex digits is a truncated paste, and the ABI coder would

package/dist/lib/typed.d.ts

@@ -10,7 +10,7 @@ export type TypedTypes = Readonly<Record<string, ReadonlyArray<TypedField>>>;
  */
 export declare function encodeType(primary: string, types: TypedTypes): string;
 export declare function typeHash(primary: string, types: TypedTypes): Uint8Array;
-export declare function hashStruct(primary: string, data: Record<string, unknown>, types: TypedTypes): Uint8Array;
+export declare function hashStruct(primary: string, data: unknown, types: TypedTypes): Uint8Array;
 export type Domain = {
     readonly name?: string;
     readonly version?: string;

package/dist/lib/typed.js

@@ -11,7 +11,7 @@
  * was actually shown, compared against the one the dapp asked for.
  */
 import { keccak256, toHex } from "@crewhaus/tool-encode";
-import { encodeTuple, parseType } from "./abi";
+import { MAX_TYPE_DEPTH, bytesArg, encodeTuple, parseType, } from "./abi";
 const encoder = new TextEncoder();
 const hash = (bytes) => keccak256(bytes);
 const concat = (parts) => {
@@ -23,21 +23,62 @@ const concat = (parts) => {
     }
     return out;
 };
+const OPEN_BRACKET = 0x5b;
+const CLOSE_BRACKET = 0x5d;
+const isDigit = (code) => code >= 0x30 && code <= 0x39;
+/**
+ * The outermost array suffix of `type` — `Foo[2][]` is `Foo[2]` with a
+ * dynamic suffix — or `undefined` when it has none. Read from the end, one
+ * character at a time: the regex this replaces backtracked in the square of
+ * the type's length, and a type string is the caller's.
+ */
+function outerArraySuffix(type) {
+    if (type.charCodeAt(type.length - 1) !== CLOSE_BRACKET)
+        return undefined;
+    let i = type.length - 2;
+    while (i >= 0 && isDigit(type.charCodeAt(i)))
+        i--;
+    if (i < 0 || type.charCodeAt(i) !== OPEN_BRACKET)
+        return undefined;
+    return { inner: type.slice(0, i), length: type.slice(i + 1, -1) };
+}
+/** `type` without its array suffixes, and how many it had, in one pass. */
+function withoutArraySuffixes(type) {
+    let base = type;
+    let depth = 0;
+    for (let suffix = outerArraySuffix(base); suffix !== undefined;) {
+        base = suffix.inner;
+        depth++;
+        suffix = outerArraySuffix(base);
+    }
+    return { base, depth };
+}
 /** The struct types `primary` refers to, transitively. */
 function referencedTypes(primary, types, seen = new Set()) {
     if (seen.has(primary))
         return seen;
-    const fields = types[primary];
+    const fields = structFields(types, primary);
     if (!fields)
         return seen;
     seen.add(primary);
     for (const field of fields) {
-        const base = field.type.replace(/(\[\d*\])+$/, "");
-        if (types[base])
+        const { base } = withoutArraySuffixes(field.type);
+        if (structFields(types, base))
             referencedTypes(base, types, seen);
     }
     return seen;
 }
+/**
+ * The fields of the struct `name`, when `types` DEFINES it — an own property.
+ *
+ * A plain lookup walks the prototype chain, so a type named `constructor` or
+ * `toString` "exists" in every types object: a field of that type was then
+ * hashed as a struct whose field list is a function, instead of being refused
+ * as a type nobody defined.
+ */
+function structFields(types, name) {
+    return Object.hasOwn(types, name) ? types[name] : undefined;
+}
 /**
  * `encodeType`: the primary struct first, then every referenced struct in
  * alphabetical order. The order is part of the standard — a different order
@@ -47,7 +88,7 @@ export function encodeType(primary, types) {
     const referenced = [...referencedTypes(primary, types)].filter((t) => t !== primary).sort();
     return [primary, ...referenced]
         .map((name) => {
-        const fields = types[name];
+        const fields = structFields(types, name);
         if (!fields)
             throw new Error(`the type "${name}" is referenced but not defined`);
         return `${name}(${fields.map((f) => `${f.type} ${f.name}`).join(",")})`;
@@ -57,56 +98,119 @@ export function encodeType(primary, types) {
 export function typeHash(primary, types) {
     return hash(encoder.encode(encodeType(primary, types)));
 }
+function cachedTypeHash(ctx, primary) {
+    let known = ctx.typeHashes.get(primary);
+    if (known === undefined) {
+        known = typeHash(primary, ctx.types);
+        ctx.typeHashes.set(primary, known);
+    }
+    return known;
+}
+/** A caller's text in a refusal, cut to a length a message can carry. */
+function clip(text) {
+    return text.length <= 80 ? text : `${text.slice(0, 80)}… (${text.length} characters)`;
+}
+/**
+ * Every struct `primary` reaches, checked before anything is hashed: each
+ * field's type must be a struct `types` defines (with array suffixes, at
+ * most as many as an ABI type may nest) or an ABI type the coder parses.
+ * Checked on use alone, a struct referenced but never instantiated (in an
+ * empty array) went into the encoded type unexamined, and the digest came
+ * back "ok" over a type string no wallet would accept.
+ */
+function checkTypes(primary, types) {
+    if (!structFields(types, primary))
+        throw new Error(`the type "${clip(primary)}" is not defined`);
+    for (const name of referencedTypes(primary, types)) {
+        for (const field of structFields(types, name) ?? []) {
+            const what = `${clip(name)}.${clip(field.name)}`;
+            const { base, depth } = withoutArraySuffixes(field.type);
+            if (structFields(types, base)) {
+                if (depth > MAX_TYPE_DEPTH) {
+                    throw new Error(`${what}: "${clip(field.type)}" nests arrays more than ${MAX_TYPE_DEPTH} levels deep`);
+                }
+                continue;
+            }
+            try {
+                parseType(field.type);
+            }
+            catch (err) {
+                throw new Error(`${what}: "${clip(field.type)}" is neither a struct defined in types nor an ABI type (${err.message})`);
+            }
+        }
+    }
+}
 /** One field, as the 32 bytes it contributes to a struct's encoding. */
-function encodeField(type, value, types, what) {
-    const arrayMatch = /^(.*)\[(\d*)\]$/.exec(type);
-    if (arrayMatch) {
+function encodeField(ctx, type, value, what) {
+    const types = ctx.types;
+    const array = outerArraySuffix(type);
+    if (array) {
         if (!Array.isArray(value))
             throw new Error(`${what}: expected an array`);
-        const inner = arrayMatch[1];
-        const expected = arrayMatch[2];
-        if (expected !== undefined &&
-            expected !== "" &&
-            value.length !== Number.parseInt(expected, 10)) {
+        const expected = array.length;
+        if (expected !== "" && value.length !== Number.parseInt(expected, 10)) {
             throw new Error(`${what}: expected ${expected} items, got ${value.length}`);
         }
         // An array contributes the hash of its members' encodings.
-        return hash(concat(value.map((item, i) => encodeField(inner, item, types, `${what}[${i}]`))));
+        return hash(concat(value.map((item, i) => encodeField(ctx, array.inner, item, `${what}[${i}]`))));
     }
-    if (types[type])
-        return hashStruct(type, value, types);
-    if (type === "string")
-        return hash(encoder.encode(String(value)));
-    if (type === "bytes") {
-        const text = String(value).replace(/^0x/i, "");
-        if (!/^[0-9a-fA-F]*$/.test(text))
-            throw new Error(`${what}: bytes must be hex`);
-        const bytes = new Uint8Array(text.length / 2);
-        for (let i = 0; i < bytes.length; i++) {
-            bytes[i] = Number.parseInt(text.slice(i * 2, i * 2 + 2), 16);
+    if (structFields(types, type))
+        return structHash(ctx, type, value);
+    if (type === "string") {
+        // A number or a boolean reads as the text it prints as. An object does
+        // not: String({}) is "[object Object]", a value nobody was shown.
+        if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+            throw new Error(`${what}: a string field takes text, not ${describeValue(value)}`);
         }
-        return hash(bytes);
+        return hash(encoder.encode(String(value)));
     }
+    // The coder's own strict decoder: an odd digit count is refused rather
+    // than its last nibble dropped, which made 0xabc hash as 0xab.
+    if (type === "bytes")
+        return hash(bytesArg(value, what));
     // Everything else must be an atomic ABI type. When it is not, the likely
     // mistake is a struct named in a field and left out of `types`, so say
     // both possibilities rather than only "not an ABI type".
+    let parsed;
     try {
-        return encodeTuple([parseType(type)], [value], what);
+        parsed = parseType(type);
     }
     catch (err) {
         throw new Error(`${what}: "${type}" is neither a struct defined in types nor an ABI type (${err.message})`);
     }
+    // Outside the try: a value the type refuses — an address whose checksum
+    // fails — is the value's problem, not an unknown type's.
+    return encodeTuple([parsed], [value], what);
+}
+/** What a value is, for a refusal: "an array", "null", "a number". */
+function describeValue(value) {
+    if (value === null || value === undefined)
+        return String(value);
+    if (Array.isArray(value))
+        return "an array";
+    return typeof value === "object" ? "an object" : `a ${typeof value}`;
 }
 export function hashStruct(primary, data, types) {
-    const fields = types[primary];
+    return structHash({ types, typeHashes: new Map() }, primary, data);
+}
+function structHash(ctx, primary, data) {
+    const fields = structFields(ctx.types, primary);
     if (!fields)
         throw new Error(`the type "${primary}" is not defined`);
-    const parts = [typeHash(primary, types)];
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+        throw new Error(`"${primary}" expects an object for its fields, got ${describeValue(data)}`);
+    }
+    const record = data;
+    const parts = [cachedTypeHash(ctx, primary)];
     for (const field of fields) {
-        if (!(field.name in data)) {
+        // An OWN field. `in` also sees what every object inherits, so a message
+        // missing "toString" was hashed over the source text of
+        // Object.prototype.toString — a digest of a value nobody was shown —
+        // instead of being refused like any other missing field.
+        if (!Object.hasOwn(record, field.name)) {
             throw new Error(`"${primary}" requires the field "${field.name}", which the message does not have`);
         }
-        parts.push(encodeField(field.type, data[field.name], types, `${primary}.${field.name}`));
+        parts.push(encodeField(ctx, field.type, record[field.name], `${primary}.${field.name}`));
     }
     return hash(concat(parts));
 }
@@ -137,13 +241,15 @@ export function typedDataDigest(domain, types, primaryType, message) {
     // defined by the standard and must not take part in encodeType.
     const withoutDomain = Object.fromEntries(Object.entries(types).filter(([name]) => name !== "EIP712Domain"));
     const separator = domainSeparator(domain);
-    const structHash = hashStruct(primaryType, message, withoutDomain);
-    const digest = hash(concat([new Uint8Array([0x19, 0x01]), separator, structHash]));
+    checkTypes(primaryType, withoutDomain);
+    const ctx = { types: withoutDomain, typeHashes: new Map() };
+    const messageHash = structHash(ctx, primaryType, message);
+    const digest = hash(concat([new Uint8Array([0x19, 0x01]), separator, messageHash]));
     return {
         digest: `0x${toHex(digest)}`,
         domainSeparator: `0x${toHex(separator)}`,
-        messageHash: `0x${toHex(structHash)}`,
-        typeHash: `0x${toHex(typeHash(primaryType, withoutDomain))}`,
+        messageHash: `0x${toHex(messageHash)}`,
+        typeHash: `0x${toHex(cachedTypeHash(ctx, primaryType))}`,
         encodedType: encodeType(primaryType, withoutDomain),
         primaryType,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/tool-onchain",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "type": "module",
   "description": "Deterministic onchain tools: ABI encoding and decoding, EIP-55 address checksums, EIP-712 and EIP-191 hashing, unit conversion and fixed-point DeFi maths",
   "main": "dist/index.js",
@@ -8,17 +8,18 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.7.0",
-    "@crewhaus/tool-builder": "0.7.0",
-    "@crewhaus/tool-catalog": "0.7.0",
-    "@crewhaus/tool-encode": "0.7.0",
+    "@crewhaus/errors": "0.8.1",
+    "@crewhaus/tool-builder": "0.8.1",
+    "@crewhaus/tool-catalog": "0.8.1",
+    "@crewhaus/tool-encode": "0.8.1",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -42,5 +43,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"],
+  "engines": {
+    "bun": ">=1.3.14"
+  }
 }