@crewhaus/tool-defi 0.7.0 → 0.8.0

package/dist/lib/oracle.js

@@ -1,4 +1,4 @@
-import { MAX_CONTRACT_TEXT_CHARS, SELECTORS, asSigned, callNoArgs, callWithBytes32, decodeString, decodeWords, normalizeAddress, normalizeBytes32, sanitizeContractText, } from "./abi";
+import { MAX_CONTRACT_TEXT_CHARS, SELECTORS, asSigned, asUnsigned, callNoArgs, callWithBytes32, decodeString, decodeWords, isCanonicalInt, normalizeAddress, normalizeBytes32, sanitizeContractText, } from "./abi";
 /**
  * Reading a price feed onchain, and saying what its own freshness signal says.
  *
@@ -198,7 +198,10 @@ export async function readPyth(request, options = {}) {
     // Every member is static, so the struct is four words inline — no offset.
     const [priceWord, confWord, expoWord, publishWord] = decodeWords(data, 4, "getPriceUnsafe(bytes32)");
     const rawPrice = asSigned(priceWord, 64);
-    const confidence = asSigned(confWord, 64);
+    // `conf` is a uint64. Read signed, a confidence from 2^63 up came back
+    // negative, so its ratio to the price was negative and never beyond any
+    // bound — the widest band a feed can state passed as the tightest.
+    const confidence = asUnsigned(confWord, 64);
     // `expo` is an int32 and is almost always NEGATIVE: -8 means the integer is
     // scaled by 1e-8. Read unsigned it is about 4.29e9, and the price comes back
     // as a number with four billion zeros after it.
@@ -210,6 +213,14 @@ export async function readPyth(request, options = {}) {
     const value = fixed(rawPrice, -exponent);
     const confidenceValue = fixed(confidence, -exponent);
     const notes = [];
+    const dirty = [
+        isCanonicalInt(priceWord, 64, true) ? null : "price (int64)",
+        isCanonicalInt(confWord, 64, false) ? null : "conf (uint64)",
+        isCanonicalInt(expoWord, 32, true) ? null : "expo (int32)",
+    ].filter((field) => field !== null);
+    if (dirty.length > 0) {
+        notes.push(`the answer's ${dirty.join(", ")} ${dirty.length === 1 ? "word is" : "words are"} not padded the way the ABI encodes ${dirty.length === 1 ? "that type" : "those types"}, so only the low bits were read — a real Pyth contract does not answer like that, and a different contract answering the same selector does`);
+    }
     let confidenceToPriceBps = 0;
     if (isPositive(value)) {
         confidenceToPriceBps = ratioBps(confidenceValue, value);

package/dist/lib/quotes.js

@@ -109,8 +109,11 @@ async function frankfurterLeg(base, quote, at, options) {
     const url = new URL(`${at ?? "latest"}?from=${base}&to=${quote}`, `${PROVIDER_ORIGINS.frankfurter}/`);
     assertKnownOrigin(url);
     const outcome = await getJson(url.toString(), options);
-    if (!outcome.ok)
-        return { ok: false, reason: `frankfurter: ${outcome.message}` };
+    if (!outcome.ok) {
+        return outcome.kind === "budget"
+            ? { ok: false, reason: `frankfurter was not asked for ${base}/${quote}: ${outcome.message}` }
+            : { ok: false, reason: `frankfurter: ${outcome.message}` };
+    }
     const body = outcome.value;
     if (typeof body !== "object" || body === null) {
         return { ok: false, reason: "frankfurter answered something other than an object" };
@@ -177,6 +180,10 @@ async function coinbaseLeg(base, quote, at, options) {
         return { ok: false, reason: "a pair of one asset with itself is not a quote" };
     }
     const direct = await coinbaseSpot(base, quote, options);
+    if (!direct.ok && direct.notAsked === true) {
+        // Nothing was asked, so nothing is known about what coinbase publishes.
+        return { ok: false, reason: `coinbase was not asked for ${base}-${quote}: ${direct.reason}` };
+    }
     if (direct.ok) {
         return {
             ok: true,
@@ -199,7 +206,9 @@ async function coinbaseLeg(base, quote, at, options) {
     if (!inverse.ok) {
         return {
             ok: false,
-            reason: `coinbase publishes neither ${base}-${quote} (${direct.reason}) nor its inverse`,
+            reason: inverse.notAsked === true
+                ? `coinbase does not publish ${base}-${quote} (${direct.reason}), and its inverse ${quote}-${base} was not asked: ${inverse.reason}`
+                : `coinbase publishes neither ${base}-${quote} (${direct.reason}) nor its inverse`,
         };
     }
     if (!isPositive(inverse.price)) {
@@ -230,8 +239,11 @@ async function coinbaseSpot(base, quote, options) {
     const url = new URL(`/v2/prices/${base}-${quote}/spot`, PROVIDER_ORIGINS.coinbase);
     assertKnownOrigin(url);
     const outcome = await getJson(url.toString(), options);
-    if (!outcome.ok)
-        return { ok: false, reason: outcome.message };
+    if (!outcome.ok) {
+        return outcome.kind === "budget"
+            ? { ok: false, reason: outcome.message, notAsked: true }
+            : { ok: false, reason: outcome.message };
+    }
     const body = outcome.value;
     const data = body?.data;
     if (typeof data !== "object" || data === null) {

package/dist/lib/rpc.d.ts

@@ -96,7 +96,12 @@ export declare const MAX_RESPONSE_BYTES: number;
  */
 export declare const DEFI_RPC_METHODS: ReadonlySet<string>;
 export type TransportFailure = {
-    readonly kind: "transport" | "status" | "rateLimited" | "malformed" | "rpcError" | "refused";
+    /**
+     * `budget`: not sent, because the call's price-provider requests are spent
+     * or this round's share of them is — nothing was asked, so nothing is
+     * known about what the provider publishes.
+     */
+    readonly kind: "transport" | "status" | "rateLimited" | "malformed" | "rpcError" | "refused" | "budget";
     readonly message: string;
     readonly status?: number;
     /** The JSON-RPC error code, when the node answered with one. */
@@ -109,11 +114,52 @@ export type RpcOutcome<T> = {
     readonly ok: false;
 } & TransportFailure);
 export type RpcOptions = {
+    /**
+     * The WHOLE call's signal: a tool opens one deadline per call
+     * ({@link startDeadline}) and hands its signal down, so every request the
+     * call makes shares one budget of time. Once it has aborted, nothing more
+     * is dialled.
+     */
     readonly signal?: AbortSignal;
     readonly timeoutMs?: number;
     /** Only for the refusal message when a method is off the allow-list. */
     readonly chainId?: string;
+    /** The call's price-provider budget and answers, for {@link getJson}. */
+    readonly providers?: ProviderLedger;
 };
+/**
+ * What one tool call may ask the public price providers, and what it already
+ * has.
+ *
+ * `PortfolioValuation` prices up to 256 holdings, and one quote can take up to
+ * fifteen requests (direct, inverted, then crossed through two intermediates).
+ * Unbounded, one call could send thousands of requests to somebody else's
+ * public endpoint — and the same leg (USD/JPY, for every holding crossed
+ * through USD) was fetched again for every holding. The ledger caps the
+ * requests and answers a URL already fetched in this call from its answer.
+ */
+export type ProviderLedger = {
+    readonly limit: number;
+    made: number;
+    /**
+     * How many NEW requests the attempt in progress may still make, when a
+     * caller shares the budget out in rounds (PortfolioValuation: one per
+     * holding per round). Undefined: no per-attempt limit. An answer already
+     * fetched in the call is free — until the attempt is `halted`.
+     */
+    allowance?: number;
+    /**
+     * Set once the attempt in progress has been refused a request: every
+     * later request of that attempt is refused too, cached or not, so a route
+     * it prefers less cannot answer from the cache while a route it prefers
+     * more was not asked.
+     */
+    halted?: boolean;
+    /** How many requests were refused for budget, so a caller can say so. */
+    refused: number;
+    readonly answers: Map<string, Promise<RpcOutcome<unknown>>>;
+};
+export declare function newProviderLedger(limit: number): ProviderLedger;
 /**
  * Issue one JSON-RPC call.
  *
@@ -152,8 +198,15 @@ export declare function ethBlockNumber(endpoint: string, options?: RpcOptions):
 export declare function blockTagOf(blockNumber: bigint | undefined): string;
 export type Deadline = {
     readonly signal: AbortSignal;
+    readonly ms: number;
     cancel(): void;
 };
+/** The abort reason of a deadline that ran out, as opposed to a cancellation. */
+export declare class DeadlineElapsed extends Error {
+    readonly ms: number;
+    readonly name = "DeadlineElapsed";
+    constructor(ms: number);
+}
 /**
  * A deadline that also honours the runtime's own cancellation. Every call
  * opens one and cancels it in a `finally` — a timer left running holds the

package/dist/lib/rpc.js

@@ -24,6 +24,8 @@
  */
 import { assertReadOnlyMethod } from "@crewhaus/chain-adapter-base";
 import { CrewhausError } from "@crewhaus/errors";
+import { parseMulticallMap } from "@crewhaus/tool-onchain";
+import { fetchRaw, readResponseBounded } from "@crewhaus/tool-safety/streams";
 /** A refusal this package chose: a missing endpoint, a bad shape, a write attempt. */
 export class DefiError extends CrewhausError {
     name = "DefiError";
@@ -51,12 +53,17 @@ export function buildDefiConfig(input) {
             throw new DefiError(`rpc["${chainId}"] must be a URL string`);
         endpoints.set(String(chainId), assertEndpoint(url, chainId));
     }
-    const multicall = new Map();
-    for (const [chainId, address] of Object.entries(input.multicall3 ?? {})) {
-        if (typeof address !== "string") {
-            throw new DefiError(`multicall3["${chainId}"] must be an address string`);
-        }
-        multicall.set(String(chainId), address.trim().toLowerCase());
+    // Checked like any address a coder writes: shape, and the EIP-55 checksum
+    // when it carries one. The deployment answers every read in a batch.
+    let multicall;
+    try {
+        multicall = new Map([...parseMulticallMap(input.multicall3, "multicall3")].map(([id, a]) => [
+            id,
+            a.toLowerCase(),
+        ]));
+    }
+    catch (err) {
+        throw new DefiError(err.message);
     }
     const feeds = new Map();
     for (const [name, row] of Object.entries(input.feeds ?? {})) {
@@ -116,6 +123,11 @@ export function _resetDefiConfig() {
  * is looking at the spec, rather than three tool calls into a run.
  */
 function assertEndpoint(raw, chainId) {
+    if (/^\$[A-Z_][A-Z0-9_]*$/.test(raw.trim())) {
+        // A bundle and `crewhaus run` read a `$VAR` value from the environment
+        // before this sees it; one arriving here was handed over unresolved.
+        throw new DefiError(`rpc["${chainId}"] is ${raw.trim()}, an environment reference nothing resolved — a compiled bundle and crewhaus run read it from the environment at start; a direct registerDefiConfig caller passes the URL itself`);
+    }
     let url;
     try {
         url = new URL(raw.trim());
@@ -191,7 +203,14 @@ export function requireEndpoint(config, chainId) {
     }
     return endpoint;
 }
-const realFetch = (req) => globalThis.fetch(req);
+/**
+ * The body is kept RAW (`fetchRaw`, Bun's `decompress: false`): otherwise Bun
+ * inflates a gzip, deflate, br or zstd reply in native code before any
+ * reader sees a byte, so a 260 KB gzip of zeros from an RPC or price
+ * endpoint cost about 1 GB of RSS before the cap fired (C093). `readCapped`
+ * decodes it, under the cap.
+ */
+const realFetch = (req) => fetchRaw(req);
 let defiFetch = realFetch;
 /**
  * Test-only injection point, the convention every networked package here
@@ -232,6 +251,17 @@ export const DEFI_RPC_METHODS = new Set([
     "eth_blockNumber",
     "eth_getBlockByNumber",
 ]);
+export function newProviderLedger(limit) {
+    return { limit, made: 0, refused: 0, answers: new Map() };
+}
+/** Why nothing was dialled: the call's signal had already fired. */
+function notAsked(signal, label, what) {
+    const cancelled = !(signal.reason instanceof DeadlineElapsed);
+    return {
+        kind: "transport",
+        message: `the deadline elapsed before ${label} was asked ${what}: ${cancelled ? "the call was cancelled" : `the call's ${signal.reason.ms}ms were spent`}`,
+    };
+}
 /**
  * Issue one JSON-RPC call.
  *
@@ -249,6 +279,9 @@ export async function rpcCall(endpoint, method, params, options = {}) {
         throw new DefiError(`refusing to issue "${method}" — @crewhaus/tool-defi reads prices and balances, and its method set is ${[...DEFI_RPC_METHODS].sort().join(", ")}`);
     }
     const label = endpointLabel(endpoint);
+    if (options.signal?.aborted === true) {
+        return { ok: false, ...notAsked(options.signal, label, method) };
+    }
     const deadline = startDeadline(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.signal);
     try {
         const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method, params });
@@ -312,14 +345,19 @@ export async function rpcCall(endpoint, method, params, options = {}) {
                 message: withoutEndpoint(`${label} answered ${res.status} ${res.statusText}`.trimEnd(), endpoint),
             };
         }
-        const text = await readCapped(res, MAX_RESPONSE_BYTES);
-        if (text === null) {
+        const read = await readCapped(res, MAX_RESPONSE_BYTES, deadline.signal);
+        if (!read.ok) {
             return {
                 ok: false,
-                kind: "malformed",
-                message: `${label} sent more than ${MAX_RESPONSE_BYTES} bytes for ${method} — refusing to answer from a prefix of it`,
+                kind: read.why === "aborted" ? "transport" : "malformed",
+                message: read.why === "too-large"
+                    ? `${label} sent more than ${MAX_RESPONSE_BYTES} bytes for ${method} — refusing to answer from a prefix of it`
+                    : read.why === "aborted"
+                        ? `the deadline elapsed before ${label} finished answering ${method}`
+                        : `${label} answered ${method} with a body that could not be decoded (${read.why})`,
             };
         }
+        const text = read.text;
         let parsed;
         try {
             parsed = JSON.parse(text);
@@ -376,6 +414,47 @@ export async function rpcCall(endpoint, method, params, options = {}) {
  */
 export async function getJson(url, options = {}) {
     const label = endpointLabel(url);
+    if (options.signal?.aborted === true) {
+        return { ok: false, ...notAsked(options.signal, label, "for a price") };
+    }
+    const ledger = options.providers;
+    if (ledger === undefined)
+        return dialJson(url, label, options);
+    const key = `${options.accept ?? "application/json"} ${url}`;
+    const roundOver = () => {
+        ledger.halted = true;
+        ledger.refused++;
+        return {
+            ok: false,
+            kind: "budget",
+            message: `${label} was not asked: this call's ${ledger.limit} price-provider requests go out one per holding per round, and too few were left for another round of every holding still unpriced — price fewer distinct assets per call`,
+        };
+    };
+    if (ledger.halted === true)
+        return roundOver();
+    const known = ledger.answers.get(key);
+    if (known !== undefined)
+        return known;
+    if (ledger.made >= ledger.limit) {
+        ledger.halted = true;
+        ledger.refused++;
+        return {
+            ok: false,
+            kind: "budget",
+            message: `this call has already sent the ${ledger.limit} price-provider requests it may send, so ${label} was not asked — price fewer distinct assets per call`,
+        };
+    }
+    if (ledger.allowance !== undefined) {
+        if (ledger.allowance <= 0)
+            return roundOver();
+        ledger.allowance--;
+    }
+    ledger.made++;
+    const answer = dialJson(url, label, options);
+    ledger.answers.set(key, answer);
+    return answer;
+}
+async function dialJson(url, label, options) {
     const deadline = startDeadline(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.signal);
     try {
         let res;
@@ -430,14 +509,19 @@ export async function getJson(url, options = {}) {
                 message: withoutEndpoint(`${label} answered ${res.status} ${res.statusText}`.trimEnd(), url),
             };
         }
-        const text = await readCapped(res, MAX_RESPONSE_BYTES);
-        if (text === null) {
+        const read = await readCapped(res, MAX_RESPONSE_BYTES, deadline.signal);
+        if (!read.ok) {
             return {
                 ok: false,
-                kind: "malformed",
-                message: `${label} sent more than ${MAX_RESPONSE_BYTES} bytes`,
+                kind: read.why === "aborted" ? "transport" : "malformed",
+                message: read.why === "too-large"
+                    ? `${label} sent more than ${MAX_RESPONSE_BYTES} bytes`
+                    : read.why === "aborted"
+                        ? `the deadline elapsed before ${label} finished answering`
+                        : `${label} answered with a body that could not be decoded (${read.why})`,
             };
         }
+        const text = read.text;
         try {
             return { ok: true, value: JSON.parse(text) };
         }
@@ -505,52 +589,35 @@ async function discard(res) {
         // already closed — nothing to release
     }
 }
-/** Read a body with a hard byte cap, cancelling the stream once it is passed. */
-async function readCapped(res, maxBytes) {
-    if (res.body === null) {
-        const text = await res.text();
-        return new TextEncoder().encode(text).byteLength > maxBytes ? null : text;
-    }
-    const reader = res.body.getReader();
-    const chunks = [];
-    let total = 0;
-    let over = false;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done || value === undefined)
-                break;
-            if (total + value.byteLength > maxBytes) {
-                over = true;
-                try {
-                    await reader.cancel();
-                }
-                catch {
-                    // already aborting
-                }
-                break;
-            }
-            chunks.push(value);
-            total += value.byteLength;
-        }
-    }
-    finally {
-        try {
-            reader.releaseLock();
-        }
-        catch {
-            // already released
-        }
-    }
-    if (over)
-        return null;
-    const merged = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        merged.set(chunk, offset);
-        offset += chunk.byteLength;
+/**
+ * Read a body with a hard cap on its DECODED size: the body arrives raw (see
+ * `realFetch`), a gzip, deflate, br or zstd body is decoded here in small
+ * steps, and the decoder stops at the cap. A body past it is refused, never
+ * parsed from a prefix.
+ */
+async function readCapped(res, maxBytes, signal) {
+    const read = await readResponseBounded(res, { maxBytes, signal });
+    if (read.ok)
+        return read.truncated ? { ok: false, why: "too-large" } : { ok: true, text: read.text };
+    if (read.code === "aborted" || read.code === "stalled")
+        return { ok: false, why: "aborted" };
+    return {
+        ok: false,
+        why: read.code === "unsupported-encoding"
+            ? "a stack of content-encodings this package cannot decode within its cap"
+            : read.code === "read-error"
+                ? "the connection closed before the body ended"
+                : "it is labelled as compressed but is not",
+    };
+}
+/** The abort reason of a deadline that ran out, as opposed to a cancellation. */
+export class DeadlineElapsed extends Error {
+    ms;
+    name = "DeadlineElapsed";
+    constructor(ms) {
+        super(`deadline of ${ms}ms elapsed`);
+        this.ms = ms;
     }
-    return new TextDecoder("utf-8", { fatal: false }).decode(merged);
 }
 /**
  * A deadline that also honours the runtime's own cancellation. Every call
@@ -559,7 +626,7 @@ async function readCapped(res, maxBytes) {
  */
 export function startDeadline(ms, outer) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(new Error(`deadline of ${ms}ms elapsed`)), ms);
+    const timer = setTimeout(() => controller.abort(new DeadlineElapsed(ms)), ms);
     const onOuter = () => controller.abort(outer?.reason);
     if (outer !== undefined) {
         if (outer.aborted)
@@ -569,6 +636,7 @@ export function startDeadline(ms, outer) {
     }
     return {
         signal: controller.signal,
+        ms,
         cancel: () => {
             clearTimeout(timer);
             outer?.removeEventListener("abort", onOuter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/tool-defi",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "Deterministic valuation: oracle reads, price quotes and portfolio valuation with provenance and an explicit unpriced bucket",
   "main": "dist/index.js",
@@ -8,19 +8,21 @@
   "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/chain-adapter-base": "0.7.0",
-    "@crewhaus/errors": "0.7.0",
-    "@crewhaus/tool-builder": "0.7.0",
-    "@crewhaus/tool-catalog": "0.7.0",
-    "@crewhaus/tool-math": "0.7.0",
-    "@crewhaus/tool-onchain": "0.7.0",
+    "@crewhaus/chain-adapter-base": "0.8.0",
+    "@crewhaus/errors": "0.8.0",
+    "@crewhaus/tool-builder": "0.8.0",
+    "@crewhaus/tool-catalog": "0.8.0",
+    "@crewhaus/tool-math": "0.8.0",
+    "@crewhaus/tool-onchain": "0.8.0",
+    "@crewhaus/tool-safety": "0.8.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -44,5 +46,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"],
+  "engines": {
+    "bun": ">=1.3.14"
+  }
 }

package/dist/fixtures.d.ts

@@ -1,111 +0,0 @@
-import type { DefiFetch } from "./lib/rpc";
-/** ABI-encode a tuple of values, as a contract's return data (no selector). */
-export declare function encodeReturn(types: ReadonlyArray<string>, args: ReadonlyArray<unknown>): Promise<string>;
-/** Mainnet-shaped addresses. Lowercase: this package shape-checks, it does not checksum. */
-export declare const ADDR: Readonly<{
-    wallet: "0x1111111111111111111111111111111111111111";
-    chainlinkEthUsd: "0x5f4ec3df9cbd43714fe2740f5e3616155c5b8419";
-    pyth: "0x4305fb66699c3b2702d4d05cf36551390a4c69c6";
-    aavePool: "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2";
-    comet: "0xc3d688b66703497daa19211eedff47f25384cdc3";
-    vault4626: "0x83f20f44975d03b1b09e64809b757c47f942beea";
-    usdc: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
-    weth: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-    multicall3: "0xca11bde05977b3631167028862be2a173976ca11";
-    spam: "0xdead000000000000000000000000000000000001";
-}>;
-export declare const SELECTOR_TEXT: Readonly<{
-    decimals: "0x313ce567";
-    description: "0x7284e416";
-    latestRoundData: "0xfeaf968c";
-    balanceOf: "0x70a08231";
-    getPriceUnsafe: "0x96834ad3";
-    getUserAccountData: "0xbf92857c";
-    convertToAssets: "0x07a2d13a";
-    asset: "0x38d52e0f";
-    borrowBalanceOf: "0x374c49b4";
-    baseToken: "0xc55dae63";
-    collateralBalanceOf: "0x5c2549ee";
-    isLiquidatable: "0x042e02cf";
-    aggregate3: "0x82ad56cb";
-}>;
-/** A Pyth price id. Any 32 bytes will do; this is the shape, not the value. */
-export declare const ETH_USD_PRICE_ID: string;
-/** A sub-call's answer: return data, or a revert. */
-export type CallAnswer = {
-    readonly data: string;
-} | {
-    readonly revert: string;
-};
-export type ChainState = {
-    blockNumber: bigint;
-    /** `${to}|${calldata}` -> answer. Exact calldata, so a wrong argument misses. */
-    readonly calls: Map<string, CallAnswer>;
-    /** address -> wei. */
-    readonly balances: Map<string, bigint>;
-    /** Where Multicall3 is, when this chain has it. */
-    multicall3?: string;
-};
-export declare function newChain(blockNumber?: bigint): ChainState;
-export declare function route(chain: ChainState, to: string, calldata: string, answer: CallAnswer): void;
-/** `latestRoundData()`, `decimals()` and `description()` for one Chainlink feed. */
-export declare function chainlinkFeed(chain: ChainState, address: string, feed: {
-    roundId: bigint;
-    answer: bigint;
-    startedAt: bigint;
-    updatedAt: bigint;
-    answeredInRound: bigint;
-    decimals: number;
-    description?: string | null;
-}): Promise<void>;
-/** One Pyth price, under `getPriceUnsafe(priceId)`. */
-export declare function pythFeed(chain: ChainState, address: string, priceId: string, price: {
-    price: bigint;
-    confidence: bigint;
-    exponent: number;
-    publishTime: bigint;
-}): Promise<void>;
-/** An ERC-20's `balanceOf(wallet)` and `decimals()`. */
-export declare function erc20(chain: ChainState, token: string, wallet: string, balance: bigint, decimals: number | null): Promise<void>;
-/** Aave v3 `getUserAccountData(account)`. */
-export declare function aaveAccount(chain: ChainState, pool: string, account: string, data: {
-    collateralBase: bigint;
-    debtBase: bigint;
-    availableBorrowsBase: bigint;
-    liquidationThresholdBps: bigint;
-    ltvBps: bigint;
-    healthFactorWad: bigint;
-}): Promise<void>;
-export type Recorded = {
-    method: string;
-    url: string;
-    rpcMethod?: string;
-    body?: unknown;
-};
-export type ServeOptions = {
-    readonly chain?: ChainState;
-    /** Absolute URL -> body, or a status to answer with. */
-    readonly http?: Record<string, unknown | {
-        status: number;
-        headers?: Record<string, string>;
-    }>;
-    /** Called before anything is served, so a test can fail one request. */
-    readonly intercept?: (req: Request) => Response | undefined;
-};
-/**
- * Build the fetch stub. It records every request so a test can assert what was
- * NOT asked for, which is how the "a cross only happens when a direct quote
- * failed" claims are checked.
- */
-export declare function serve(options: ServeOptions): {
-    fetch: DefiFetch;
-    recorded: Recorded[];
-};
-/** Frankfurter's shape. The rate is a bare JSON NUMBER, which is the point. */
-export declare function frankfurter(base: string, quote: string, rate: number, date: string): unknown;
-/** Coinbase's shape. The amount is a STRING, and there is no timestamp anywhere. */
-export declare function coinbaseSpot(base: string, currency: string, amount: string): unknown;
-export declare const FRANKFURTER = "https://api.frankfurter.app";
-export declare const COINBASE = "https://api.coinbase.com";
-export declare const frankfurterUrl: (base: string, quote: string, at?: string) => string;
-export declare const coinbaseUrl: (base: string, quote: string) => string;