@crewhaus/tool-token 0.7.0

package/README.md

@@ -0,0 +1,172 @@
+# @crewhaus/tool-token
+
+Which token is this, and how much of it is there.
+
+| Tool | Answers |
+|---|---|
+| `TokenResolve` | which address does this symbol actually mean — and is there more than one |
+| `Erc20Balance` | how much of this token does this account hold, scaled by the contract's own decimals |
+| `Erc721TokenInfo` | who owns this NFT, what standard is it really, and what does its URI say |
+
+## Ambiguity is a refusal, not a best guess
+
+A symbol is not an identifier. Nothing stops a second contract from calling
+itself USDC with six decimals and a convincing name, reputable token lists
+routinely carry different addresses for the same ticker, and a harness that
+sends funds to the first match of a symbol is the accident this package exists
+to prevent.
+
+So `TokenResolve` never returns a most-likely. When a query could mean more
+than one address it returns **every** candidate with `resolved: false`, each
+flagged with what is wrong with it — no code at the address, a total supply of
+zero, a symbol the contract does not agree with, a ticker only one list has
+ever heard of. Choosing between two contracts that both say "USDC" is a
+decision with a wrong answer that costs money, and a string match is not
+entitled to make it.
+
+`Erc20Balance` will not take a symbol at all. It takes a contract address, and
+says so when handed anything else. There is no path through this package that
+reads a balance from a ticker nobody resolved.
+
+### Homoglyphs widen the set; they never pick a different address
+
+"USDC" and "USD**С**" — the second with a Cyrillic С — land on the same
+comparison key, so an impostor a literal match would have missed becomes an
+*ambiguity you have to look at*. The fold is deliberately small: the common
+Latin/Cyrillic/Greek lookalikes, invisible formatting characters, and two digit
+shapes. It is not UTS-39, and a symbol that survives it is not thereby safe.
+
+That looseness is affordable because of the direction it is used in. Folding
+only ever **adds** candidates, and a wider set can only move the answer towards
+a refusal — it can never resolve a query to a different address. A query that
+is *itself* confusable is the one case widening cannot help with, so that is
+refused outright, before anything is read.
+
+This is exactly the property ENS normalisation does not have, and why
+`EnsResolve` is **not** in this package: there, a fold that is wrong by one
+codepoint resolves a name to the wrong address and sends funds there. That
+needs the real UTS-46 table (`@adraffy/ens-normalize`), not a hand-rolled one,
+and it is parked pending that dependency decision rather than shipped
+half-done.
+
+## Decimals come from the contract, never from a default
+
+`decimals()` reverting is reported as **unknown**. It is not 18. Every balance
+still comes back as exact base units; what is withheld is the decimal form,
+because scaling by a number nobody supplied is how a six-decimal transfer
+becomes a trillion-fold one.
+
+Every quantity here is a `bigint` or a decimal string, end to end. A `uint256`
+does not fit in a double, and eighteen digits of precision silently become
+fifteen. The scaling itself is `@crewhaus/tool-onchain`'s, not a second
+implementation — as is EIP-55, so there is one checksum in this repository and
+it is the one checked against the EIP's own vectors.
+
+### Tokens that predate the standard still work
+
+- `symbol()` and `name()` returning a **`bytes32`** — MKR and other 2017-era
+  contracts, deployed before the ABI settled — are decoded, and the answer says
+  the encoding was `bytes32` rather than pretending it was a string.
+- A call that returns **nothing** is reported as `absent`. `""` and "we could
+  not read it" are different facts, and showing the first where the second
+  belongs puts a blank where a warning goes.
+- Bytes that are not valid UTF-8 come back as `undecodable` with the raw hex,
+  never as a row of replacement characters.
+- An address with **no code** is refused. Every call to it answers `0x`, which
+  decodes as a zero balance for everyone and an empty symbol — it is somebody's
+  wallet, or a typo.
+
+## NFT metadata is read only where it costs no trust
+
+`tokenURI()` returns a string chosen by whoever deployed the contract. Fetching
+it because a contract said so is a server-side request forgery with extra
+steps. So:
+
+| URI | What happens |
+|---|---|
+| `data:` | decoded in-process — many NFTs are entirely on-chain |
+| `ipfs://` | rewritten onto a gateway **you** named, and re-checked to still be inside it |
+| `https://` | fetched only from a host **you** allow-listed |
+| `http://`, `ar://`, anything else | skipped, with the reason in the answer |
+
+The answer lists what was read and what was skipped, both. The document itself
+is third-party content: it is byte-capped, digested, and reported rather than
+merged into the tool's own fields, and the URLs *inside* it (`image`,
+`animation_url`, …) are listed and never followed — an image URL is the same
+untrusted string one level deeper.
+
+Two ERC corners it gets right: the `{id}` placeholder is substituted with the
+**64-hex-digit, zero-padded, lowercase** form the spec requires (the decimal id
+returns a 404 or somebody else's metadata), and ERC-1155 has no `ownerOf`, so
+ownership is answered as `balanceOf(owner, id)` or reported as unanswerable —
+never as a `null` that reads like "nobody owns it". A `balanceOf` that reverts
+is unanswerable in the same way, with the revert reason, rather than a null
+that reads like "this account holds none". A contract that claims to
+support the invalid interface id `0xffffffff` says yes to everything, so its
+other ERC-165 answers are discounted and the standard is inferred from what
+actually replied.
+
+## One block, not a hundred
+
+Reads are batched through Multicall3 by default, because a hundred balances
+read one at a time are a hundred balances from up to a hundred different
+blocks. `getBlockNumber()` rides along in the same batch, so the answer says
+which block it is a snapshot of, and native balances go through Multicall3's
+own `getEthBalance` to stay in that snapshot. `batch: false` reads them
+one at a time for chains with no Multicall3 deployment, and says in the answer
+that the result is not a snapshot.
+
+A sub-call inside that batch is a contract call like any other, and one that
+does not answer is **not a zero**. A `getEthBalance` that came back empty —
+an aggregator without the helper, a sub-call out of gas — is reported as
+`raw: null` with the reason, never as `0`, because "this wallet is empty" is a
+sentence a gas check acts on. The same holds for a batch whose
+`getBlockNumber()` did not answer: the calls still share one `eth_call`, but
+the answer says it cannot be pinned to a block rather than leaving the field
+quietly null.
+
+## Nothing here signs or sends
+
+No schema in this package has a field a private key could be passed to, and no
+code path composes or submits a transaction. The JSON-RPC methods it can emit
+are exactly three — `eth_call`, `eth_getBalance`, `eth_getCode` — refused at a
+single gate if anything else is asked for. Both halves are asserted by a test,
+not promised by this paragraph.
+
+## No dialling code at all
+
+There is no RPC client and no HTTP client in this package. Both boundaries are
+injected:
+
+```ts
+import { _setChainReader, chainReaderFromAdapters, _setMetadataFetch } from "@crewhaus/tool-token";
+
+_setChainReader(chainReaderFromAdapters((chainId) => adapters.get(chainId)));
+_setMetadataFetch(async ({ url, maxBytes, signal }) => /* your redirect + SSRF policy */);
+```
+
+Which means the test suite cannot reach the network even by accident — there is
+nothing under the seam to reach it with. Every test drives recorded answers,
+and the Multicall3 stub does a real ABI round trip through `tool-onchain`'s
+codec rather than a hand-written fake of one.
+
+## What it refuses
+
+A tool that cannot say no is not finished. These say no, with the reason:
+
+- a symbol that means more than one address — `ambiguous-symbol`, with all of them
+- a query whose own characters are confusable — `confusable-query`, before any read
+- a symbol with no list to resolve it against — `no-lists`
+- an address that is on none of the supplied lists — `unlisted` (opt out with `policy: "allow-unlisted"`)
+- an address whose EIP-55 checksum does not hold — `invalid-address`
+- the zero address — whether it was pasted as the query or carried by a list
+- an address with no contract at it
+- a token list entry whose `address` field is not an address — `invalid-list-address`
+- a contract whose decimals disagree with the list's — `decimals-mismatch`
+- more candidates than it was allowed to confirm — `too-many-candidates`
+- a symbol where `Erc20Balance` wants an address, pointing at `TokenResolve`
+- an `ipfs://` URI that resolves outside the gateway it was given
+- an `https://` metadata host nobody allow-listed, and any `http://` URI
+- a metadata document over the byte cap — refused rather than parsed as a prefix
+- a Multicall3 address that answers with something other than results
+- a block tag that is not one, and a token id that is not a `uint256`

package/dist/fixtures.d.ts

@@ -0,0 +1,117 @@
+import type { ChainRead, ChainReader } from "./lib/chain";
+/** A 32-byte word from an unsigned integer. */
+export declare const word: (value: bigint) => string;
+export declare const encodeUint: (value: bigint) => string;
+export declare const encodeAddress: (address: string) => string;
+export declare const encodeBool: (value: boolean) => string;
+/** A dynamic `string` return: offset, length, then the bytes, padded. */
+export declare function encodeString(text: string): string;
+/** The pre-standard `bytes32` symbol: the text, left-aligned, NUL-padded. */
+export declare function encodeBytes32String(text: string): string;
+/** `Error(string)` revert data — the selector is the one Solidity emits. */
+export declare function revertWith(message: string): Promise<string>;
+/** What one contract answers for one call. A revert is an answer, not a throw. */
+export type CallAnswer = {
+    readonly ok: boolean;
+    readonly data: string;
+};
+export declare const answers: (data: string) => CallAnswer;
+export declare const reverts: (revertData: string) => CallAnswer;
+/** What a contract without that function returns: nothing at all. */
+export declare const NOTHING: CallAnswer;
+export type ContractHandler = (selector: string, args: string) => CallAnswer;
+export declare const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+export declare const IMPOSTOR_USDC = "0x1111111111111111111111111111111111111111";
+export declare const CYRILLIC_USDC = "0x2222222222222222222222222222222222222222";
+export declare const MKR = "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2";
+export declare const BROKEN = "0x3333333333333333333333333333333333333333";
+export declare const NOT_A_CONTRACT = "0x4444444444444444444444444444444444444444";
+export declare const APE_NFT = "0x5555555555555555555555555555555555555555";
+export declare const GAME_1155 = "0x6666666666666666666666666666666666666666";
+export declare const ONCHAIN_NFT = "0x7777777777777777777777777777777777777777";
+export declare const LIAR_165 = "0x8888888888888888888888888888888888888888";
+export declare const ALICE = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+export declare const BOB = "0x388C818CA8B9251b393131C08a736A67ccB19297";
+export declare const SPENDER = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45";
+/** A plain ERC-20 whose metadata is all well-formed strings. */
+export declare function erc20(opts: {
+    decimals: bigint;
+    symbol: string;
+    name: string;
+    totalSupply: bigint;
+    balances?: Record<string, bigint>;
+    allowances?: Record<string, bigint>;
+    bytes32Metadata?: boolean;
+}): ContractHandler;
+/** An ERC-721 that declares itself properly through ERC-165. */
+export declare function erc721(opts: {
+    name: string;
+    symbol: string;
+    owners: Record<string, string>;
+    tokenUris: Record<string, string>;
+    missingTokenRevert: string;
+    interfaceIds?: ReadonlyArray<string>;
+    answersEverything?: boolean;
+}): ContractHandler;
+/** An ERC-1155, which has no ownerOf and whose uri carries the {id} template. */
+export declare function erc1155(opts: {
+    uriTemplate: string;
+    balances: Record<string, bigint>;
+    interfaceIds?: ReadonlyArray<string>;
+}): ContractHandler;
+export type ChainStub = {
+    readonly reader: ChainReader;
+    /** Every read that left the package, in order, for assertions about what was asked. */
+    readonly reads: ChainRead[];
+};
+export declare function chainStub(opts: {
+    readonly contracts: Record<string, ContractHandler>;
+    readonly nativeBalances?: Record<string, bigint>;
+    readonly code?: Record<string, string>;
+    readonly blockNumber?: bigint;
+    readonly multicall3Address?: string;
+    /** Answer the batch call itself with this instead, to test an unusable answer. */
+    readonly brokenBatchAnswer?: string;
+    /**
+     * A Multicall3-shaped contract that implements `aggregate3` and nothing
+     * else, so `getEthBalance` and `getBlockNumber` reach its fallback and
+     * answer with no data. Real: `multicall3Address` is a caller-supplied
+     * address, and an aggregator that is not the canonical deployment has no
+     * obligation to carry the helpers.
+     */
+    readonly withoutMulticallHelpers?: boolean;
+}): ChainStub;
+export declare const UNISWAP_LIST: {
+    id: string;
+    name: string;
+    tokens: {
+        chainId: number;
+        address: string;
+        symbol: string;
+        name: string;
+        decimals: number;
+    }[];
+};
+/** A second reputable list that happens to carry a different address for USDC. */
+export declare const RIVAL_LIST: {
+    id: string;
+    name: string;
+    tokens: {
+        chainId: number;
+        address: string;
+        symbol: string;
+        name: string;
+        decimals: number;
+    }[];
+};
+/** The Cyrillic \u0421 impostor. It is not the same string, and it looks identical. */
+export declare const CYRILLIC_LIST: {
+    id: string;
+    tokens: {
+        chainId: number;
+        address: string;
+        symbol: string;
+        name: string;
+        decimals: number;
+    }[];
+};

package/dist/fixtures.js

@@ -0,0 +1,222 @@
+/**
+ * Recorded chain answers, and a reader stub that serves them.
+ *
+ * Every test in this package drives `_setChainReader` with one of these. None
+ * of them opens a socket, because there is nothing under the seam to open one
+ * with — a suite that reached a public RPC endpoint would fail on a CI runner
+ * with no egress and flake on somebody else's rate limit.
+ *
+ * The tokens here are the ones that break naive readers, and they are
+ * modelled on real contracts rather than invented:
+ *
+ *   - a six-decimal stablecoin, the ordinary case;
+ *   - a `bytes32` symbol, which is what MKR and other 2017-era tokens return
+ *     because the ABI was not settled when they deployed;
+ *   - a token whose `decimals()` reverts, which must come back as unknown and
+ *     never as 18;
+ *   - two impostors claiming a listed ticker, one of them with a Cyrillic \u0421;
+ *   - an address with no code at all.
+ *
+ * The Multicall3 stub does a real ABI round trip through `tool-onchain`'s
+ * codec rather than a hand-written fake of one: it decodes the batch this
+ * package encoded and encodes the `(bool,bytes)[]` the package decodes. A
+ * fixture that faked the encoding would pass against a broken encoder.
+ */
+import { MULTICALL3_ADDRESS, abiDecode, abiEncodeCall } from "@crewhaus/tool-onchain";
+import { SELECTOR } from "./lib/erc";
+// ─── encoding helpers ───────────────────────────────────────────────────────
+const hexBody = (value) => value.replace(/^0x/, "");
+/** A 32-byte word from an unsigned integer. */
+export const word = (value) => value.toString(16).padStart(64, "0");
+export const encodeUint = (value) => `0x${word(value)}`;
+export const encodeAddress = (address) => `0x${hexBody(address).toLowerCase().padStart(64, "0")}`;
+export const encodeBool = (value) => encodeUint(value ? 1n : 0n);
+/** A dynamic `string` return: offset, length, then the bytes, padded. */
+export function encodeString(text) {
+    const bytes = new TextEncoder().encode(text);
+    let data = "";
+    for (const b of bytes)
+        data += b.toString(16).padStart(2, "0");
+    const padded = data.padEnd(Math.ceil(bytes.length / 32) * 64, "0");
+    return `0x${word(32n)}${word(BigInt(bytes.length))}${padded}`;
+}
+/** The pre-standard `bytes32` symbol: the text, left-aligned, NUL-padded. */
+export function encodeBytes32String(text) {
+    const bytes = new TextEncoder().encode(text);
+    if (bytes.length > 32)
+        throw new Error(`"${text}" does not fit in a bytes32`);
+    let data = "";
+    for (const b of bytes)
+        data += b.toString(16).padStart(2, "0");
+    return `0x${data.padEnd(64, "0")}`;
+}
+const strip = (call) => `0x${call.slice(10)}`;
+async function encodeCall(signature, args) {
+    const out = await abiEncodeCall.execute({ signature, args });
+    if (typeof out !== "string")
+        throw new Error("AbiEncodeCall did not return a string");
+    return JSON.parse(out).data;
+}
+/** `Error(string)` revert data — the selector is the one Solidity emits. */
+export async function revertWith(message) {
+    return encodeCall("Error(string)", [message]);
+}
+export const answers = (data) => ({ ok: true, data });
+export const reverts = (revertData) => ({ ok: false, data: revertData });
+/** What a contract without that function returns: nothing at all. */
+export const NOTHING = { ok: true, data: "0x" };
+export const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+export const IMPOSTOR_USDC = "0x1111111111111111111111111111111111111111";
+export const CYRILLIC_USDC = "0x2222222222222222222222222222222222222222";
+export const MKR = "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2";
+export const BROKEN = "0x3333333333333333333333333333333333333333";
+export const NOT_A_CONTRACT = "0x4444444444444444444444444444444444444444";
+export const APE_NFT = "0x5555555555555555555555555555555555555555";
+export const GAME_1155 = "0x6666666666666666666666666666666666666666";
+export const ONCHAIN_NFT = "0x7777777777777777777777777777777777777777";
+export const LIAR_165 = "0x8888888888888888888888888888888888888888";
+export const ALICE = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+export const BOB = "0x388C818CA8B9251b393131C08a736A67ccB19297";
+export const SPENDER = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45";
+const addressArg = (args, index = 0) => `0x${args.slice(index * 64 + 24, index * 64 + 64)}`.toLowerCase();
+const uintArg = (args, index = 0) => BigInt(`0x${args.slice(index * 64, index * 64 + 64) || "0"}`);
+/** A plain ERC-20 whose metadata is all well-formed strings. */
+export function erc20(opts) {
+    const text = opts.bytes32Metadata ? encodeBytes32String : encodeString;
+    return (selector, args) => {
+        switch (selector) {
+            case SELECTOR.decimals:
+                return answers(encodeUint(opts.decimals));
+            case SELECTOR.symbol:
+                return answers(text(opts.symbol));
+            case SELECTOR.name:
+                return answers(text(opts.name));
+            case SELECTOR.totalSupply:
+                return answers(encodeUint(opts.totalSupply));
+            case SELECTOR.balanceOf:
+                return answers(encodeUint(opts.balances?.[addressArg(args)] ?? 0n));
+            case SELECTOR.allowance:
+                return answers(encodeUint(opts.allowances?.[`${addressArg(args, 0)}:${addressArg(args, 1)}`] ?? 0n));
+            default:
+                return NOTHING;
+        }
+    };
+}
+/** An ERC-721 that declares itself properly through ERC-165. */
+export function erc721(opts) {
+    const supported = new Set(opts.interfaceIds ?? ["01ffc9a7", "80ac58cd", "5b5e139f"]);
+    return (selector, args) => {
+        if (selector === SELECTOR.supportsInterface) {
+            const id = args.slice(0, 8).toLowerCase();
+            return answers(encodeBool(opts.answersEverything === true || supported.has(id)));
+        }
+        if (selector === SELECTOR.name)
+            return answers(encodeString(opts.name));
+        if (selector === SELECTOR.symbol)
+            return answers(encodeString(opts.symbol));
+        if (selector === SELECTOR.ownerOf) {
+            const owner = opts.owners[uintArg(args).toString()];
+            return owner === undefined ? reverts(opts.missingTokenRevert) : answers(encodeAddress(owner));
+        }
+        if (selector === SELECTOR.tokenURI) {
+            const uri = opts.tokenUris[uintArg(args).toString()];
+            return uri === undefined ? reverts(opts.missingTokenRevert) : answers(encodeString(uri));
+        }
+        return NOTHING;
+    };
+}
+/** An ERC-1155, which has no ownerOf and whose uri carries the {id} template. */
+export function erc1155(opts) {
+    const supported = new Set(opts.interfaceIds ?? ["01ffc9a7", "d9b67a26", "0e89341c"]);
+    return (selector, args) => {
+        if (selector === SELECTOR.supportsInterface) {
+            return answers(encodeBool(supported.has(args.slice(0, 8).toLowerCase())));
+        }
+        if (selector === SELECTOR.uri)
+            return answers(encodeString(opts.uriTemplate));
+        if (selector === SELECTOR.balanceOf1155) {
+            return answers(encodeUint(opts.balances[`${addressArg(args, 0)}:${uintArg(args, 1)}`] ?? 0n));
+        }
+        return NOTHING;
+    };
+}
+export function chainStub(opts) {
+    const reads = [];
+    const multicall = (opts.multicall3Address ?? MULTICALL3_ADDRESS).toLowerCase();
+    const handlerFor = (address) => opts.contracts[address.toLowerCase()];
+    const dispatch = (target, data) => {
+        const selector = data.slice(0, 10).toLowerCase();
+        const args = data.slice(10);
+        if (target.toLowerCase() === multicall) {
+            if (opts.withoutMulticallHelpers === true)
+                return NOTHING;
+            if (selector === SELECTOR.getBlockNumber)
+                return answers(encodeUint(opts.blockNumber ?? 0n));
+            if (selector === SELECTOR.getEthBalance) {
+                return answers(encodeUint(opts.nativeBalances?.[addressArg(args)] ?? 0n));
+            }
+            return NOTHING;
+        }
+        const handler = handlerFor(target);
+        // An address with no code answers every call with nothing. That is the
+        // whole point of the NOT_A_CONTRACT fixture.
+        return handler === undefined ? NOTHING : handler(selector, args);
+    };
+    const reader = async (read) => {
+        reads.push(read);
+        if (read.method === "eth_getCode") {
+            const address = String(read.params[0]).toLowerCase();
+            if (opts.code?.[address] !== undefined)
+                return opts.code[address];
+            return handlerFor(address) === undefined ? "0x" : "0x60806040";
+        }
+        if (read.method === "eth_getBalance") {
+            return encodeUint(opts.nativeBalances?.[String(read.params[0]).toLowerCase()] ?? 0n);
+        }
+        const call = read.params[0];
+        if (call.to.toLowerCase() !== multicall || !call.data.startsWith("0x82ad56cb")) {
+            const answer = dispatch(call.to, call.data);
+            // An unbatched eth_call cannot return a revert as data: the node errors.
+            if (!answer.ok)
+                throw new Error(`execution reverted (${answer.data})`);
+            return answer.data;
+        }
+        if (opts.brokenBatchAnswer !== undefined)
+            return opts.brokenBatchAnswer;
+        const decoded = await abiDecode.execute({
+            data: strip(call.data),
+            types: ["(address,bool,bytes)[]"],
+        });
+        if (typeof decoded !== "string")
+            throw new Error("AbiDecode did not return a string");
+        const [batch] = JSON.parse(decoded).values;
+        const results = batch.map(([to, , callData]) => {
+            const answer = dispatch(to, callData);
+            return [answer.ok, answer.data];
+        });
+        return strip(await encodeCall("f((bool,bytes)[])", [results]));
+    };
+    return { reader, reads };
+}
+// ─── token lists ────────────────────────────────────────────────────────────
+export const UNISWAP_LIST = {
+    id: "uniswap-default",
+    name: "Uniswap Labs Default",
+    tokens: [
+        { chainId: 1, address: USDC, symbol: "USDC", name: "USD Coin", decimals: 6 },
+        { chainId: 1, address: MKR, symbol: "MKR", name: "Maker", decimals: 18 },
+    ],
+};
+/** A second reputable list that happens to carry a different address for USDC. */
+export const RIVAL_LIST = {
+    id: "rival-list",
+    name: "Somebody Else's List",
+    tokens: [{ chainId: 1, address: IMPOSTOR_USDC, symbol: "USDC", name: "USD Coin", decimals: 6 }],
+};
+/** The Cyrillic \u0421 impostor. It is not the same string, and it looks identical. */
+export const CYRILLIC_LIST = {
+    id: "shady-list",
+    tokens: [
+        { chainId: 1, address: CYRILLIC_USDC, symbol: "USD\u0421", name: "USD Coin", decimals: 6 },
+    ],
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { RegisteredTool } from "@crewhaus/tool-catalog";
+export { type ChainRead, type ChainReadMethod, type ChainReader, READ_METHODS, TokenError, _setChainReader, chainReaderFromAdapters, hasChainReader, } from "./lib/chain";
+export { type MetadataFetch, type MetadataResponse, type UriPlan, DEFAULT_MAX_METADATA_BYTES, _setMetadataFetch, planUri, } from "./lib/uri";
+export { type Candidate, type TokenList, type TokenListEntry, confusableSkeleton, findCandidates, textConcerns, } from "./lib/lists";
+export declare const tokenResolve: RegisteredTool;
+export declare const erc20Balance: RegisteredTool;
+export declare const erc721TokenInfo: RegisteredTool;
+/** Every tool this package registers, in the order a catalog should list them. */
+export declare const TOKEN_TOOLS: ReadonlyArray<RegisteredTool>;