@instadapp/fluid-sui-read-sdk 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,3541 @@
+import { t as __exportAll } from "./chunk-15K8U1wQ.mjs";
+import { deriveDynamicFieldID, deriveObjectID, fromBase64, normalizeStructTag, normalizeSuiAddress, normalizeSuiObjectId, parseStructTag, toHex } from "@mysten/sui/utils";
+import { ObjectError } from "@mysten/sui/client";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+
+//#region src/config.ts
+const same = (id) => ({
+	packageId: id,
+	originalId: id
+});
+/** Liquidity packages known to run the pre-audit-fix maths (deployed bytecode checked 2026-10-26). */
+const PRE_AUDIT_LIQUIDITY = new Set([normalizeSuiObjectId("0xd0f7e9baf5bb8c13444fc7abc562103b7632acea5f290ed7ab6bbe6f2191febb")]);
+const TOKENS = [
+	"0x2::sui::SUI",
+	"0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+	"0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI"
+];
+const COMMON_IDS = {
+	library: same("0xc3715ec6e2efe31fce7096f93e5986fb57e32ea4d252618563ba0c7ded59565c"),
+	liquidity: same("0xd0f7e9baf5bb8c13444fc7abc562103b7632acea5f290ed7ab6bbe6f2191febb"),
+	lending: same("0x00207c696eaa1b80e6e001cb0739dff0a554b5561265008d33ca9b071fd1d202")
+};
+/**
+* STAGING deployment on Sui mainnet (staging deployment gist, 2026-09-30). NOT a final production
+* deployment: ids change at the production launch. Build
+* your own config from a deployment record with `configFromDeployment`.
+*
+* Fluid Sui staging-on-mainnet: library / liquidity / lending
+* from 2026-09-18; oracle (RedStone main + Pyth guard) and vaults redeployed 2026-09-30.
+* Vault 1 = VaultMarket<SUI, USDC> 0x3ba55ebc…72b8 on oracle nonce 1 (0x1a690d20…b279).
+* Vault 2 = VaultMarket<SUI, USDSUI> 0x5120…0efa. fTokens: fUSDC, fUSDSUI.
+* Ids match the write SDK (fluid-packages-sui deployments/mainnet.json @ 06828ff, 2026-10-01) and
+* the live staging deployment (re-read on chain 2026-10-10). Alias: network "staging".
+*/
+const STAGING = {
+	network: "mainnet",
+	packages: {
+		...COMMON_IDS,
+		lendingRewards: same("0x3a54319b9983e52db29b13bec9952713186cbb1910d223e0358f9cf58af9e199"),
+		oracle: same("0xc1e7632c9847370a0f00298defa15d42fcb0e3191cad3bee8451cab5ce144814"),
+		vaults: same("0x08a3f6777d66c82ded41f5c02f902be34407005b2e53649b4e4da0bb63ef6f20")
+	},
+	mathVariant: "pre-audit",
+	objects: {
+		liquidityRegistry: "0x2b712ae7c38f4b4a09498565a4df8184bda875506b9f65ba8f64cf5662731ccc",
+		lendingRegistry: "0xc4f71cb64e6c01216f18fbea012176aa2f3a0a747347c914627cbb5aa0e569d2",
+		oracleRegistry: "0x3e431dbb50af805875f60f5207aa2515604a2da9eb91ade21e11cc5a5e30b1bf",
+		vaultRegistry: "0x429c416e9c42a96b1c0004bd9b756055636824ec4c08e1500403c7b11da8c8cb",
+		liquidityAuth: "0x85b19be86131a7a4b378c1b78e8e9b765a30c8c770de0645bfe0e1cb4da5ddb5",
+		lendingAuth: "0xc145f5f8aae7d72bf56a2ba82708976c057367160857146beedfa0b5409a5702",
+		rewardsAuth: "0x1da732261bfacdcee28be5ac5fd68917b2fdcaff295a7f1128c0a86d912b44b2",
+		oracleAuth: "0x6133bd13291e1d04526c69957b27cf0a9d7422059873ad00e3e34ff1b1ba07d9",
+		vaultAdmin: "0x72ef539f4827cd055e38a3c2385a313831652fe4bde650a5d099dfdb95fc98d3"
+	},
+	oracle: {
+		redstoneAdapter: "0x22794c3a37c5320e5acb6b9cdba6e256bc08867e9de8afd2a4b5d8ea7061fea3",
+		redstonePackage: "0xfa84e5620fda505bbeb9178316a555e1db36f8932dee44210dd88a6464a76ef6",
+		pythPriceInfoObjects: { "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744": "0x89b2add829cb6fcd017153fff428bc9faec4d06d643ecfc435af5b55a9e987f0" },
+		pythStateId: "0x03719fae774ddab3cfcaa53bbc046f0cbe21410019b6280811bf3f9f4b05839d",
+		wormholeStateId: "0xdbca52b9fb4f712e25f61f974586d93ac541bcf8389564f0323bb07215168b5c"
+	},
+	tokens: TOKENS,
+	rpcUrls: ["https://fullnode.mainnet.sui.io:443"],
+	graphqlUrl: "https://graphql.mainnet.sui.io/graphql"
+};
+/**
+* @deprecated Misleading name kept for compatibility: this is the STAGING deployment
+* (`STAGING`), not production. Use `STAGING` / network "staging".
+*/
+const MAINNET = STAGING;
+const CONFIGS = { staging: STAGING };
+/**
+* Build a read config from a deployment record instead of the built-in ids, e.g.
+* `configFromDeployment(JSON.parse(readFileSync(path, "utf8")), { network: "mainnet", oracle })`.
+* The record has no RedStone package or Pyth feed map, so `oracle` comes from the caller.
+* Throws once, listing every required field the record is missing.
+*/
+function configFromDeployment(rec, opts) {
+	const missing = [];
+	const ids = (k) => {
+		const p = rec.packages[k];
+		if (!p?.packageId) missing.push(`packages.${k}.packageId`);
+		return {
+			packageId: p?.packageId ?? "",
+			originalId: p?.originalId ?? p?.packageId ?? ""
+		};
+	};
+	const obj = (k, name, required = true) => {
+		const v = rec.packages[k]?.objects?.[name];
+		if (!v && required) missing.push(`packages.${k}.objects.${name}`);
+		return v;
+	};
+	const rw = rec.packages.lending_rewards;
+	const config = {
+		network: opts.network,
+		packages: {
+			library: ids("library"),
+			liquidity: ids("liquidity"),
+			lending: ids("lending"),
+			...rw ? { lendingRewards: ids("lending_rewards") } : {},
+			oracle: ids("oracle"),
+			vaults: ids("vaults")
+		},
+		objects: {
+			liquidityRegistry: obj("liquidity", "registry"),
+			lendingRegistry: obj("lending", "registry"),
+			oracleRegistry: obj("oracle", "registry"),
+			vaultRegistry: obj("vaults", "registry"),
+			liquidityAuth: obj("liquidity", "auth", false),
+			lendingAuth: obj("lending", "auth", false),
+			rewardsAuth: rw?.objects?.rewardsAuth,
+			oracleAuth: obj("oracle", "auth", false),
+			vaultAdmin: obj("vaults", "admin", false)
+		},
+		oracle: opts.oracle,
+		tokens: opts.tokens ?? TOKENS,
+		rpcUrls: opts.rpcUrls,
+		graphqlUrl: opts.graphqlUrl,
+		mathVariant: opts.mathVariant ?? (PRE_AUDIT_LIQUIDITY.has(normalizeSuiObjectId(ids("liquidity").packageId)) ? "pre-audit" : "audited")
+	};
+	if (missing.length) throw new Error(`deployment record is missing ${missing.length} required field(s): ${missing.join(", ")}. Package ids alone are not enough; the registry object ids are needed too (see "Deployment record shape" in the README).`);
+	return config;
+}
+function resolveConfig(networkOrConfig) {
+	if (networkOrConfig === void 0 || networkOrConfig === null || networkOrConfig === "") throw new Error("Fluid network required: pass { network: \"staging\" } (the live staging-on-mainnet deployment) or a production config from configFromDeployment(...). There is no default.");
+	if (networkOrConfig === "mainnet") throw new Error("No built-in Fluid production deployment yet. \"mainnet\" used to alias the STAGING deployment; pass { network: \"staging\" } for that, or build the production config with configFromDeployment(...) once it ships.");
+	const cfg = typeof networkOrConfig === "string" ? CONFIGS[networkOrConfig] : networkOrConfig;
+	if (!cfg) throw new Error(`no built-in Fluid config for network "${String(networkOrConfig)}"`);
+	const n = (p) => ({
+		packageId: normalizeSuiObjectId(p.packageId),
+		originalId: normalizeSuiObjectId(p.originalId)
+	});
+	return {
+		...cfg,
+		packages: {
+			library: n(cfg.packages.library),
+			liquidity: n(cfg.packages.liquidity),
+			lending: n(cfg.packages.lending),
+			...cfg.packages.lendingRewards ? { lendingRewards: n(cfg.packages.lendingRewards) } : {},
+			oracle: n(cfg.packages.oracle),
+			vaults: n(cfg.packages.vaults)
+		}
+	};
+}
+
+//#endregion
+//#region src/math/core.ts
+/** Integer helpers that mirror `fluid_library::math` (all bigint, floor unless named ceil). */
+const FOUR_DECIMALS = 10000n;
+const SECONDS_PER_YEAR = 31536000n;
+/** Liquidity / vault / lending exchange-price precision (1e12). */
+const EXCHANGE_PRICES_PRECISION = 1000000000000n;
+/** `exchange_price_rate_output_decimals` in liquidity (1e17). */
+const RATE_OUTPUT_DECIMALS = 100000000000000000n;
+/** Vault exchange-price scale factor (1e18). */
+const EXCHANGE_PRICE_SCALE_FACTOR = 1000000000000000000n;
+/** Lending return precision (1e14 = 1e12 * 100). */
+const RETURN_PERCENT_PRECISION = 100000000000000n;
+/**
+* The two raw on-chain rate scales differ, which is why every rate FIELD the SDK returns is bps
+* (1e4 = 100% per year, floored):
+* - liquidity supply rate (`reserve::calculate_exchange_prices`): 1e12 = 100%  -> SUPPLY_RATE_PRECISION
+* - lending rewards rate (`rewards`, `lending_calcs`): 1e14 = 100%             -> RETURN_PERCENT_PRECISION
+*/
+const SUPPLY_RATE_PRECISION = 1000000000000n;
+/** Raw liquidity supply rate (1e12 = 100%) -> bps, floored. */
+const supplyRateToBps = (raw) => raw / (SUPPLY_RATE_PRECISION / FOUR_DECIMALS);
+/** Raw lending rewards rate (1e14 = 100%) -> bps, floored. */
+const rewardsRateToBps = (raw) => raw / (RETURN_PERCENT_PRECISION / FOUR_DECIMALS);
+/** Lending max rewards rate: 50% at RETURN_PERCENT_PRECISION (1e14 = 100%). */
+const MAX_REWARDS_RATE = 50000000000000n;
+function mulDiv(a, b, c) {
+	if (c === 0n) throw new RangeError("mulDiv: division by zero");
+	return a * b / c;
+}
+function divCeil(a, b) {
+	if (b === 0n) throw new RangeError("divCeil: division by zero");
+	const q = a / b;
+	return a % b === 0n ? q : q + 1n;
+}
+function mulDivCeil(a, b, c) {
+	return divCeil(a * b, c);
+}
+const max = (a, b) => a > b ? a : b;
+const min = (a, b) => a < b ? a : b;
+/** Current unix time in seconds (the default `now` for time-dependent reads). */
+const nowSeconds = () => BigInt(Math.floor(Date.now() / 1e3));
+
+//#endregion
+//#region src/objects.ts
+/** `getObjects` accepts at most 50 ids per call. */
+const BATCH = 50;
+/** Batched fetch. Missing/deleted ids come back as `null` in input order; other errors throw. */
+async function fetchObjects(client, ids) {
+	const out = [];
+	const chunks = [];
+	for (let i = 0; i < ids.length; i += BATCH) chunks.push(ids.slice(i, i + BATCH));
+	const pages = await Promise.all(chunks.map((c) => client.core.getObjects({
+		objectIds: c,
+		include: { content: true }
+	})));
+	for (const { objects } of pages) for (const o of objects) {
+		if (o instanceof Error) {
+			if (o instanceof ObjectError && (o.reason === "notFound" || o.reason === "deleted")) {
+				out.push(null);
+				continue;
+			}
+			throw o;
+		}
+		out.push({
+			objectId: o.objectId,
+			type: o.type,
+			content: o.content,
+			owner: o.owner
+		});
+	}
+	return out;
+}
+var ObjectNotFoundError = class extends Error {
+	constructor(objectId, what) {
+		super(`${what} not found: ${objectId}`);
+		this.objectId = objectId;
+		this.what = what;
+		this.name = "ObjectNotFoundError";
+	}
+};
+async function fetchObject(client, id, what) {
+	const [o] = await fetchObjects(client, [id]);
+	if (!o) throw new ObjectNotFoundError(id, what);
+	return o;
+}
+/** Every dynamic-field id under a parent (Table), paginated. */
+async function listDynamicFieldIds(client, parentId) {
+	const ids = [];
+	let cursor = null;
+	do {
+		const page = await client.core.listDynamicFields({
+			parentId,
+			cursor,
+			limit: 50
+		});
+		for (const f of page.dynamicFields) ids.push(f.fieldId);
+		cursor = page.hasNextPage ? page.cursor : null;
+	} while (cursor !== null);
+	return ids;
+}
+/** Owner address (or parent object id) from a core-API owner union. */
+function ownerAddress(owner) {
+	if (!owner || typeof owner !== "object") return null;
+	const o = owner;
+	for (const k of [
+		"AddressOwner",
+		"ObjectOwner",
+		"ConsensusAddressOwner"
+	]) {
+		const v = o[k];
+		if (typeof v === "string") return v;
+		if (v && typeof v === "object" && typeof v.owner === "string") return v.owner;
+	}
+	if (o.$kind === "Shared") return null;
+	return null;
+}
+
+//#endregion
+//#region src/context.ts
+/** The shared `0x2::clock::Clock` object. */
+const CLOCK_ID = "0x0000000000000000000000000000000000000000000000000000000000000006";
+/**
+* Chain time in seconds from the on-chain `Clock` (0x6) as the fullnode last saw it, i.e. the
+* timestamp of its latest executed checkpoint. Same value a Move call would read via
+* `units::from_clock(clock)` (ms / 1000, floored).
+*/
+async function chainNowSeconds(client) {
+	const o = await fetchObject(client, CLOCK_ID, "Clock");
+	return new DataView(o.content.buffer, o.content.byteOffset + 32, 8).getBigUint64(0, true) / 1000n;
+}
+const RANK = {
+	state: 0,
+	fullnode: 1,
+	indexer: 2
+};
+var NeedsDiscoveryError = class extends Error {
+	constructor(what, needed, onchainFix) {
+		super(`${what} cannot be resolved from object state alone. Pass { discovery: "${needed}" } to allow it, or make it pure on-chain: ${onchainFix}`);
+		this.what = what;
+		this.needed = needed;
+		this.onchainFix = onchainFix;
+		this.name = "NeedsDiscoveryError";
+	}
+};
+function makeContext(client, config, derive, clock = "chain", discovery = "state") {
+	const now = clock === "chain" ? () => chainNowSeconds(client) : clock === "local" ? async () => nowSeconds() : async () => clock();
+	const metaCache = /* @__PURE__ */ new Map();
+	const coinMetadata = (coinType) => {
+		let p = metaCache.get(coinType);
+		if (!p) {
+			p = client.core.getCoinMetadata({ coinType }).then(({ coinMetadata: m }) => m ? {
+				name: m.name,
+				symbol: m.symbol,
+				decimals: m.decimals
+			} : null);
+			p.catch(() => metaCache.delete(coinType));
+			metaCache.set(coinType, p);
+		}
+		return p;
+	};
+	return {
+		client,
+		config,
+		derive,
+		now,
+		discovery,
+		allows: (l) => RANK[discovery] >= RANK[l],
+		math: config.mathVariant ?? "audited",
+		coinMetadata
+	};
+}
+
+//#endregion
+//#region src/transport.ts
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Wait before pass `pass` (1-based, pass >= 2): exponential, capped, +/-25% jitter. */
+function backoffDelay(pass, base, cap) {
+	const d = Math.min(cap, base * 2 ** (pass - 2));
+	return Math.round(d * (.75 + Math.random() * .5));
+}
+var AllEndpointsFailedError = class extends Error {
+	constructor(method, errors) {
+		super(`all ${errors.length} RPC attempts failed for core.${method}: ` + errors.map((e) => `${e.endpoint}: ${e.error instanceof Error ? e.error.message : String(e.error)}`).join(" | "));
+		this.method = method;
+		this.errors = errors;
+		this.name = "AllEndpointsFailedError";
+	}
+};
+function clientForEndpoint(endpoint, network) {
+	if (endpoint.startsWith("jsonrpc+")) return new SuiJsonRpcClient({
+		url: endpoint.slice(8),
+		network
+	});
+	return new SuiGrpcClient({
+		network,
+		baseUrl: endpoint
+	});
+}
+function withTimeout(p, ms, what) {
+	let t;
+	return Promise.race([p.finally(() => clearTimeout(t)), new Promise((_, rej) => {
+		t = setTimeout(() => rej(/* @__PURE__ */ new Error(`${what} timed out after ${ms}ms`)), ms);
+	})]);
+}
+/**
+* One `ClientWithCoreApi` over many endpoints. Accepts endpoint strings or ready clients
+* (label = index). Synchronous core members (e.g. `resolveTransactionPlugin`) come from the
+* currently preferred endpoint.
+*/
+function createFailoverClient(endpoints, opts) {
+	if (endpoints.length === 0) throw new Error("createFailoverClient: at least one endpoint required");
+	const labels = endpoints.map((e, i) => typeof e === "string" ? e : `client#${i}`);
+	const clients = endpoints.map((e) => typeof e === "string" ? clientForEndpoint(e, opts.network) : e);
+	const timeoutMs = opts.timeoutMs ?? 15e3;
+	const rounds = opts.rounds ?? 3;
+	const backoffMs = opts.backoffMs ?? 250;
+	const maxBackoffMs = opts.maxBackoffMs ?? 4e3;
+	let preferred = 0;
+	const core = new Proxy({}, { get(_t, prop) {
+		const first = clients[preferred].core;
+		const member = first[prop];
+		if (typeof member !== "function") return member;
+		return (...args) => {
+			const res = member.apply(first, args);
+			if (!(res instanceof Promise)) return res;
+			return (async () => {
+				const errors = [];
+				for (let attempt = 0; attempt < clients.length * rounds; attempt++) {
+					const i = (preferred + attempt) % clients.length;
+					if (attempt > 0 && attempt % clients.length === 0) await sleep(backoffDelay(attempt / clients.length + 1, backoffMs, maxBackoffMs));
+					const c = clients[i].core;
+					try {
+						const out = await withTimeout(attempt === 0 ? res : c[prop].apply(c, args), timeoutMs, `${labels[i]} core.${String(prop)}`);
+						preferred = i;
+						return out;
+					} catch (error) {
+						errors.push({
+							endpoint: labels[i],
+							error
+						});
+					}
+				}
+				throw new AllEndpointsFailedError(String(prop), errors);
+			})();
+		};
+	} });
+	return new Proxy(clients[0], { get(_t, prop) {
+		if (prop === "core") return core;
+		if (prop === "endpoints") return labels;
+		if (prop === "preferred") return () => labels[preferred];
+		const c = clients[preferred];
+		const v = c[prop];
+		return typeof v === "function" ? v.bind(c) : v;
+	} });
+}
+
+//#endregion
+//#region src/graphql.ts
+/** Minimal Sui GraphQL client (fetch), with the same retry + backoff policy as the RPC failover. */
+var GraphQLError = class extends Error {
+	constructor(message, errors) {
+		super(message);
+		this.errors = errors;
+		this.name = "GraphQLError";
+	}
+};
+/**
+* POST one query. Network errors, timeouts, HTTP 429/5xx are retried with backoff; a GraphQL
+* `errors` payload (bad query, unknown object) is NOT retried.
+*/
+async function graphqlQuery(url, query, variables = {}, opts = {}) {
+	const rounds = opts.rounds ?? 3;
+	const timeoutMs = opts.timeoutMs ?? 15e3;
+	let last;
+	for (let pass = 1; pass <= rounds; pass++) {
+		if (pass > 1) await new Promise((r) => setTimeout(r, backoffDelay(pass, opts.backoffMs ?? 250, opts.maxBackoffMs ?? 4e3)));
+		let res;
+		try {
+			res = await fetch(url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					query,
+					variables
+				}),
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+		} catch (e) {
+			last = e;
+			continue;
+		}
+		if (res.status === 429 || res.status >= 500) {
+			last = new GraphQLError(`GraphQL HTTP ${res.status}`);
+			continue;
+		}
+		const body = await res.json();
+		if (body.errors?.length) throw new GraphQLError(`GraphQL: ${body.errors.map((e) => e.message).join("; ")}`, body.errors);
+		if (!body.data) throw new GraphQLError(`GraphQL HTTP ${res.status}: no data`);
+		return body.data;
+	}
+	throw last instanceof Error ? last : new GraphQLError(String(last));
+}
+
+//#endregion
+//#region src/checkpoint.ts
+var CheckpointReadError = class extends Error {
+	constructor(method, checkpoint) {
+		super(`core.${method} is not available for historical reads (checkpoint ${checkpoint}); only object state is`);
+		this.name = "CheckpointReadError";
+	}
+};
+/** GraphQL `multiGetObjects` takes at most 50 keys per query. */
+const KEYS_PER_QUERY = 50;
+const OBJECT_FIELDS = `address version digest
+  owner { __typename ... on AddressOwner { address { address } } ... on ObjectOwner { address { address } }
+          ... on Shared { initialSharedVersion } ... on ConsensusAddressOwner { startVersion address { address } } }
+  asMoveObject { contents { type { repr } bcs } }`;
+function coreOwner(o) {
+	switch (o?.__typename) {
+		case "AddressOwner": return {
+			$kind: "AddressOwner",
+			AddressOwner: o.address.address
+		};
+		case "ObjectOwner": return {
+			$kind: "ObjectOwner",
+			ObjectOwner: o.address.address
+		};
+		case "Shared": return {
+			$kind: "Shared",
+			Shared: { initialSharedVersion: String(o.initialSharedVersion) }
+		};
+		case "Immutable": return {
+			$kind: "Immutable",
+			Immutable: true
+		};
+		case "ConsensusAddressOwner": return {
+			$kind: "ConsensusAddressOwner",
+			ConsensusAddressOwner: {
+				startVersion: String(o.startVersion),
+				owner: o.address.address
+			}
+		};
+		default: return { $kind: "Unknown" };
+	}
+}
+/** Timestamp of `checkpoint` in unix seconds (floored, as `units::from_clock` reads it). */
+async function checkpointTimestampSeconds(url, checkpoint, opts) {
+	const d = await graphqlQuery(url, `query($c: UInt53!) { checkpoint(sequenceNumber: $c) { timestamp } }`, { c: Number(checkpoint) }, opts);
+	if (!d.checkpoint) throw new Error(`checkpoint ${checkpoint} not found on ${url}`);
+	return BigInt(Math.floor(Date.parse(d.checkpoint.timestamp) / 1e3));
+}
+/** Latest checkpoint the GraphQL service has indexed. */
+async function latestCheckpoint(url, opts) {
+	const d = await graphqlQuery(url, `{ checkpoint { sequenceNumber } }`, {}, opts);
+	return BigInt(d.checkpoint.sequenceNumber);
+}
+/**
+* A core client pinned to `checkpoint`: `getObjects` via GraphQL at that checkpoint,
+* `getCoinMetadata` from `live` (immutable data), every other core read throws.
+*/
+function checkpointClient(url, checkpoint, live, opts) {
+	const getObjects = async ({ objectIds }) => {
+		const objects = [];
+		for (let i = 0; i < objectIds.length; i += KEYS_PER_QUERY) {
+			const ids = objectIds.slice(i, i + KEYS_PER_QUERY);
+			(await graphqlQuery(url, `query($k: [ObjectKey!]!) { multiGetObjects(keys: $k) { ${OBJECT_FIELDS} } }`, { k: ids.map((address) => ({
+				address,
+				atCheckpoint: Number(checkpoint)
+			})) }, opts)).multiGetObjects.forEach((o, j) => {
+				if (!o?.asMoveObject) {
+					objects.push(new ObjectError("notFound", `object ${ids[j]} not found at checkpoint ${checkpoint}`, {
+						reason: "notFound",
+						objectId: ids[j]
+					}));
+					return;
+				}
+				objects.push({
+					objectId: o.address,
+					version: String(o.version),
+					digest: o.digest ?? "",
+					type: o.asMoveObject.contents.type.repr,
+					owner: coreOwner(o.owner),
+					content: fromBase64(o.asMoveObject.contents.bcs)
+				});
+			});
+		}
+		return { objects };
+	};
+	return {
+		core: new Proxy({}, { get(_t, prop) {
+			if (prop === "getObjects") return getObjects;
+			if (prop === "getCoinMetadata") return live.core.getCoinMetadata.bind(live.core);
+			if (typeof prop === "symbol" || prop === "then") return void 0;
+			return () => {
+				throw new CheckpointReadError(String(prop), checkpoint);
+			};
+		} }),
+		checkpoint
+	};
+}
+
+//#endregion
+//#region src/bcs.ts
+/**
+* BCS layouts of every Fluid object the reader decodes, transcribed from the DEPLOYED
+* packages (`sui_getNormalizedMoveModulesByPackage`, mainnet v1, 2026-09-30) — not from
+* source, so a source-only change cannot silently break decoding.
+* Single-field wrappers (UID, ID, TimestampS, DurationS, Balance, Supply) encode as their field.
+*/
+var bcs_exports = /* @__PURE__ */ __exportAll({
+	Branch: () => Branch,
+	BranchStatus: () => BranchStatus,
+	CapRecord: () => CapRecord,
+	Field: () => Field,
+	Holder: () => Holder,
+	LendingRegistry: () => LendingRegistry,
+	LendingState: () => LendingState,
+	LiquidityRegistry: () => LiquidityRegistry,
+	MoveTick: () => MoveTick,
+	OracleObject: () => OracleObject,
+	OracleRegistry: () => OracleRegistry,
+	OracleSource: () => OracleSource,
+	OracleSourceType: () => OracleSourceType,
+	PauseFlags: () => PauseFlags,
+	Position: () => Position,
+	PositionIndex: () => PositionIndex$1,
+	PositionIndexEntry: () => PositionIndexEntry,
+	PositionIndexField: () => PositionIndexField,
+	PriceQuote: () => PriceQuote,
+	PythPriceInfoObject: () => PythPriceInfoObject,
+	RateDataV1Params: () => RateDataV1Params,
+	RateDataV2Params: () => RateDataV2Params,
+	RateMagnifier: () => RateMagnifier,
+	RewardsSchedule: () => RewardsSchedule,
+	RiskConfig: () => RiskConfig,
+	Table: () => Table,
+	TickIdLiquidation: () => TickIdLiquidation,
+	TickIdLiquidationKey: () => TickIdLiquidationKey,
+	TokenReserve: () => TokenReserve,
+	TypeName: () => TypeName,
+	UnitKey: () => UnitKey,
+	UserBorrowConfig: () => UserBorrowConfig,
+	UserBorrowPosition: () => UserBorrowPosition,
+	UserSupplyConfig: () => UserSupplyConfig,
+	UserSupplyPosition: () => UserSupplyPosition,
+	VaultMarket: () => VaultMarket,
+	VaultRegistry: () => VaultRegistry,
+	VaultTick: () => VaultTick,
+	bcsId: () => bcsId,
+	bcsU16: () => bcsU16,
+	bcsU256: () => bcsU256,
+	bcsU64: () => bcsU64
+});
+const Address = bcs.Address;
+const U64 = bcs.u64();
+const U128 = bcs.u128();
+const TypeName = bcs.struct("TypeName", { name: bcs.string() });
+const MoveTick = bcs.struct("Tick", {
+	mag: bcs.u32(),
+	neg: bcs.bool()
+});
+const Table = bcs.struct("Table", {
+	id: Address,
+	size: U64
+});
+const PauseFlags = bcs.struct("PauseFlags", {
+	supply: bcs.bool(),
+	borrow: bcs.bool(),
+	payback: bcs.bool(),
+	withdraw: bcs.bool()
+});
+const Holder = bcs.enum("Holder", {
+	Object: Address,
+	Type: TypeName
+});
+const LiquidityRegistry = bcs.struct("Registry", {
+	id: Address,
+	version: U64,
+	pause: PauseFlags,
+	revenue_collector: Address,
+	active_caps: Table
+});
+const TokenReserve = bcs.struct("TokenReserve", {
+	id: Address,
+	pause: PauseFlags,
+	vault: U64,
+	borrow_rate: U64,
+	fee: U64,
+	last_utilization: U64,
+	last_update_timestamp: U64,
+	supply_exchange_price: U64,
+	borrow_exchange_price: U64,
+	max_utilization: U64,
+	total_supply_with_interest: U64,
+	total_supply_interest_free: U64,
+	total_borrow_with_interest: U64,
+	total_borrow_interest_free: U64,
+	rate_data_version: bcs.u8(),
+	supply_positions: Table,
+	borrow_positions: Table
+});
+const UserSupplyConfig = bcs.struct("UserSupplyConfig", {
+	mode: bcs.u8(),
+	expand_percent: U64,
+	expand_duration: U64,
+	base_withdrawal_limit: U64
+});
+const UserBorrowConfig = bcs.struct("UserBorrowConfig", {
+	mode: bcs.u8(),
+	expand_percent: U64,
+	expand_duration: U64,
+	base_debt_ceiling: U64,
+	max_debt_ceiling: U64
+});
+const UserSupplyPosition = bcs.struct("UserSupplyPosition", {
+	config: bcs.option(UserSupplyConfig),
+	paused_supply: bcs.bool(),
+	paused_withdraw: bcs.bool(),
+	amount: U64,
+	withdrawal_limit: U64,
+	last_update: U64,
+	decay_amount: U64,
+	decay_duration: U64
+});
+const UserBorrowPosition = bcs.struct("UserBorrowPosition", {
+	config: bcs.option(UserBorrowConfig),
+	paused_borrow: bcs.bool(),
+	paused_payback: bcs.bool(),
+	amount: U64,
+	debt_ceiling: U64,
+	last_update: U64
+});
+const RateDataV1Params = bcs.struct("RateDataV1Params", {
+	kink: U64,
+	rate_at_utilization_zero: U64,
+	rate_at_utilization_kink: U64,
+	rate_at_utilization_max: U64
+});
+const RateDataV2Params = bcs.struct("RateDataV2Params", {
+	kink1: U64,
+	kink2: U64,
+	rate_at_utilization_zero: U64,
+	rate_at_utilization_kink1: U64,
+	rate_at_utilization_kink2: U64,
+	rate_at_utilization_max: U64
+});
+const CapRecord = bcs.struct("CapRecord", {
+	token: TypeName,
+	holder: Holder
+});
+const LendingState = bcs.struct("LendingState", {
+	id: Address,
+	supply: U64,
+	reserve_id: Address,
+	rewards_writer: bcs.option(Address),
+	token_exchange_price: U64,
+	liquidity_exchange_price: U64,
+	last_update_s: U64
+});
+const RewardsSchedule = bcs.struct("RewardsSchedule", {
+	start_tvl: U64,
+	start_s: U64,
+	end_s: U64,
+	yearly_reward: U64,
+	next_start_s: U64,
+	next_end_s: U64,
+	next_yearly_reward: U64
+});
+const LendingRegistry = bcs.struct("LendingRegistry", {
+	id: Address,
+	version: U64
+});
+const RiskConfig = bcs.struct("RiskConfig", {
+	collateral_factor: bcs.u16(),
+	liquidation_threshold: bcs.u16(),
+	liquidation_max_limit: bcs.u16(),
+	withdraw_gap: bcs.u16(),
+	liquidation_penalty: bcs.u16(),
+	borrow_fee: bcs.u8()
+});
+const RateMagnifier = bcs.struct("RateMagnifier", {
+	magnitude: bcs.u16(),
+	negative: bcs.bool()
+});
+const VaultMarket = bcs.struct("VaultMarket", {
+	id: Address,
+	vault_id: U64,
+	risk: RiskConfig,
+	supply_rate_magnifier: RateMagnifier,
+	borrow_rate_magnifier: RateMagnifier,
+	vault_type: bcs.u8(),
+	oracle: Address,
+	liquidity_program: Address,
+	col_decimals: bcs.u8(),
+	debt_decimals: bcs.u8(),
+	branch_liquidated: bcs.bool(),
+	topmost_tick: MoveTick,
+	current_branch_id: U64,
+	total_branch_id: U64,
+	total_supply: U64,
+	total_borrow: U64,
+	absorbed_debt_amount: U128,
+	absorbed_col_amount: U128,
+	absorbed_dust_debt: U64,
+	liquidity_supply_exchange_price: U64,
+	liquidity_borrow_exchange_price: U64,
+	vault_supply_exchange_price: U64,
+	vault_borrow_exchange_price: U64,
+	last_update_timestamp: U64,
+	ticks: Table,
+	branches: Table,
+	liq_snaps: Table,
+	tick_bitmap: Table
+});
+const VaultTick = bcs.struct("Tick", {
+	is_liquidated: bcs.bool(),
+	total_ids: bcs.u32(),
+	raw_debt: U64,
+	is_fully_liquidated: bcs.bool(),
+	liquidation_branch_id: U64,
+	debt_factor: U64
+});
+const TickIdLiquidation = bcs.struct("TickIdLiquidation", {
+	is_fully_liquidated: bcs.bool(),
+	liquidation_branch_id: U64,
+	debt_factor: U64
+});
+const TickIdLiquidationKey = bcs.struct("TickIdLiquidationKey", {
+	tick: MoveTick,
+	tick_map: bcs.u32()
+});
+const BranchStatus = bcs.enum("BranchStatus", {
+	NotLiquidated: null,
+	Liquidated: null,
+	Merged: null,
+	Closed: null
+});
+const Branch = bcs.struct("Branch", {
+	status: BranchStatus,
+	minima_tick: MoveTick,
+	minima_tick_partials: bcs.u32(),
+	debt_liquidity: U64,
+	debt_factor: U64,
+	connected_branch_id: U64,
+	connected_minima_tick: MoveTick
+});
+const Position = bcs.struct("Position", {
+	id: Address,
+	vault_id: Address,
+	position_mint: Address,
+	is_supply_only_position: bcs.bool(),
+	tick: MoveTick,
+	tick_id: bcs.u32(),
+	supply_amount: U64,
+	dust_debt_amount: U64
+});
+const VaultRegistry = bcs.struct("VaultRegistry", {
+	id: Address,
+	next_vault_id: U64,
+	version: U64
+});
+const OracleRegistry = bcs.struct("OracleRegistry", {
+	id: Address,
+	version: U64,
+	total_oracles: U64
+});
+const OracleSourceType = bcs.enum("SourceType", {
+	Redstone: bcs.struct("Redstone", { adapter_id: Address }),
+	Pyth: null
+});
+const OracleSource = bcs.struct("Source", {
+	feed_id: bcs.vector(bcs.u8()),
+	invert: bcs.bool(),
+	source_type: OracleSourceType
+});
+/** `fluid_oracle::oracle::Oracle` derived from the registry by nonce. */
+const OracleObject = bcs.struct("Oracle", {
+	id: Address,
+	nonce: bcs.u16(),
+	main: OracleSource,
+	guard: bcs.option(OracleSource)
+});
+/** `view::PriceQuote`: each rate is optional (operate-only / liquidate-only quotes). */
+const PriceQuote = bcs.struct("PriceQuote", {
+	oracle_id: Address,
+	rate_liquidate: bcs.option(U128),
+	rate_operate: bcs.option(U128)
+});
+const PythI64 = bcs.struct("I64", {
+	negative: bcs.bool(),
+	magnitude: U64
+});
+const PythPrice = bcs.struct("Price", {
+	price: PythI64,
+	conf: U64,
+	expo: PythI64,
+	timestamp: U64
+});
+/** `pyth::price_info::PriceInfoObject`. */
+const PythPriceInfoObject = bcs.struct("PriceInfoObject", {
+	id: Address,
+	price_info: bcs.struct("PriceInfo", {
+		attestation_time: U64,
+		arrival_time: U64,
+		price_feed: bcs.struct("PriceFeed", {
+			price_identifier: bcs.struct("PriceIdentifier", { bytes: bcs.vector(bcs.u8()) }),
+			price: PythPrice,
+			ema_price: PythPrice
+		})
+	})
+});
+/** `0x2::dynamic_field::Field<K, V>` wrapper. */
+function Field(name, value) {
+	return bcs.struct("Field", {
+		id: Address,
+		name,
+		value
+	});
+}
+const bcsU64 = bcs.u64();
+const bcsU16 = bcs.u16();
+const bcsU256 = bcs.u256();
+const bcsId = bcs.Address;
+/** Unit key struct (`RateDataKey`, `RewardsKey`, ...): BCS `dummy_field: bool`. */
+const UnitKey = bcs.bool();
+/** Proposed `fluid_vaults::position_index::PositionIndex` (docs/onchain-position-index.md). */
+const PositionIndex$1 = bcs.struct("PositionIndex", {
+	next_position_id: U64,
+	caps: Table,
+	ordinals: Table
+});
+const PositionIndexField = Field(UnitKey, PositionIndex$1);
+/** `caps: Table<u64, ID>` entry: ordinal -> PositionOwnerCap id. */
+const PositionIndexEntry = Field(U64, Address);
+
+//#endregion
+//#region src/math/tick.ts
+var tick_exports = /* @__PURE__ */ __exportAll({
+	COLD_TICK: () => COLD_TICK,
+	MAX_MASK_DEBT_FACTOR: () => MAX_MASK_DEBT_FACTOR,
+	MAX_TICK: () => MAX_TICK,
+	MIN_TICK: () => MIN_TICK,
+	SHIFT: () => SHIFT,
+	TICK_SPACING: () => TICK_SPACING,
+	X30: () => X30,
+	ZERO_TICK_SCALED_RATIO: () => ZERO_TICK_SCALED_RATIO,
+	getRatioAtTick: () => getRatioAtTick,
+	mulBigNumber: () => mulBigNumber,
+	mulDivNormal: () => mulDivNormal,
+	tickFromMove: () => tickFromMove,
+	tickToMove: () => tickToMove
+});
+/** Port of `fluid_library::tick_math` + `fluid_library::big_number` (the parts a reader needs). */
+const MAX_TICK = 16383;
+const MIN_TICK = -16383;
+/** `tick_math::cold_tick()` = { mag: 2^31, neg: true }: "no tick" (supply-only / fully liquidated). */
+const COLD_TICK = -2147483648;
+const TICK_SPACING = 10015n;
+const ZERO_TICK_SCALED_RATIO = 281474976710656n;
+const SHIFT = 48n;
+const X30 = 1073741823n;
+const MAX_U128 = (1n << 128n) - 1n;
+const FACTORS = [
+	18419115400608638658n,
+	18391528108445969703n,
+	18336477419114433396n,
+	18226869890870665593n,
+	18009616477100071088n,
+	17582847377087825313n,
+	16759408633341240198n,
+	15226414841393184936n,
+	12568272644527235157n,
+	8563108841104354677n,
+	3975055583337633975n,
+	856577552520149366n,
+	39775317560084773n,
+	85764505686420n
+];
+/** Move `Tick { mag, neg }` → signed number. */
+function tickFromMove(t) {
+	return t.neg ? -t.mag : t.mag;
+}
+/** Signed number → Move `Tick { mag, neg }` (zero is `neg: false`). */
+function tickToMove(tick) {
+	return tick < 0 ? {
+		mag: -tick,
+		neg: true
+	} : {
+		mag: tick,
+		neg: false
+	};
+}
+/** ratioX48 = 1.0015^tick * 2^48, bit-exact with `tick_math::get_ratio_at_tick`. */
+function getRatioAtTick(tick) {
+	const abs$1 = Math.abs(tick);
+	if (abs$1 > MAX_TICK) throw new RangeError(`tick ${tick} out of bounds`);
+	let factor = 1n << 64n;
+	if (abs$1 & 1) factor = FACTORS[0];
+	for (let i = 1; i < FACTORS.length; i++) if (abs$1 & 1 << i) factor = factor * FACTORS[i] >> 64n;
+	let precision = 0n;
+	if (tick >= 0) {
+		factor = MAX_U128 / factor;
+		if (factor % 65536n !== 0n) precision = 1n;
+	}
+	return (factor >> 16n) + precision;
+}
+const EXPONENT_SIZE = 15n;
+const EXPONENT_MAX = 32767n;
+const DECIMALS_DEBT_FACTOR = 16384n;
+const MAX_MASK_DEBT_FACTOR = 1125899906842623n;
+const COEFFICIENT_SIZE = 35n;
+const TWO_POWER_69_MINUS_1 = 590295810358705651711n;
+function msb(x) {
+	return x === 0n ? 0n : BigInt(x.toString(2).length);
+}
+/** `big_number::mul_big_number`. */
+function mulBigNumber(a, b) {
+	const c = (a >> EXPONENT_SIZE) * (b >> EXPONENT_SIZE);
+	const overflowLen = c > TWO_POWER_69_MINUS_1 ? COEFFICIENT_SIZE : COEFFICIENT_SIZE - 1n;
+	const adjusted = c >> overflowLen;
+	const resExp = (a & EXPONENT_MAX) + (b & EXPONENT_MAX) + overflowLen;
+	if (resExp < DECIMALS_DEBT_FACTOR) throw new RangeError("mulBigNumber: exponent underflow");
+	const finalExp = resExp - DECIMALS_DEBT_FACTOR;
+	if (finalExp > EXPONENT_MAX) return MAX_MASK_DEBT_FACTOR;
+	return adjusted << EXPONENT_SIZE | finalExp;
+}
+/** `big_number::mul_div_normal`: normal * bn1 / bn2. */
+function mulDivNormal(normal, bn1, bn2) {
+	if (bn1 === 0n || bn2 === 0n) return 0n;
+	const e1 = bn1 & EXPONENT_MAX;
+	const e2 = bn2 & EXPONENT_MAX;
+	if (e2 < e1) throw new RangeError("mulDivNormal: exponent order");
+	const net = e2 - e1;
+	if (net >= 129n) return 0n;
+	const c1 = bn1 >> EXPONENT_SIZE;
+	const c2 = bn2 >> EXPONENT_SIZE;
+	if (net > 128n - msb(c2)) return 0n;
+	const denominator = c2 << net;
+	if (denominator === 0n) throw new RangeError("mulDivNormal: division by zero");
+	return normal * c1 / denominator;
+}
+
+//#endregion
+//#region src/derive.ts
+/** Offline object ids (the Sui equivalent of Solana PDAs). */
+const UNIT = UnitKey.serialize(false).toBytes();
+function createDerive(cfg) {
+	const { packages: p, objects: o } = cfg;
+	const liq = p.liquidity.originalId;
+	const lend = p.lending.originalId;
+	const vaults = p.vaults.originalId;
+	const lib = p.library.originalId;
+	return {
+		tokenReserveId: (coinType) => deriveObjectID(o.liquidityRegistry, `${liq}::keys::ReserveKey<${normalizeStructTag(coinType)}>`, UNIT),
+		lendingStateId: (coinType) => deriveObjectID(o.lendingRegistry, `${lend}::keys::LendingStateKey<${normalizeStructTag(coinType)}>`, UNIT),
+		vaultMarketId: (vaultId) => deriveObjectID(o.vaultRegistry, `${vaults}::keys::VaultKey`, bcs.u64().serialize(BigInt(vaultId)).toBytes()),
+		positionId: (vaultMarketId, capId) => deriveObjectID(normalizeSuiAddress(vaultMarketId), `${vaults}::keys::PositionKey`, bcs.Address.serialize(capId).toBytes()),
+		holderKeyType: `${liq}::keys::Holder`,
+		holderEntryId: (tableId, holderObjectId) => deriveDynamicFieldID(tableId, `${liq}::keys::Holder`, Holder.serialize({ Object: holderObjectId }).toBytes()),
+		rateDataId: (reserveId) => deriveDynamicFieldID(reserveId, `${liq}::keys::RateDataKey`, UNIT),
+		rewardsId: (lendingStateId) => deriveDynamicFieldID(lendingStateId, `${lend}::keys::RewardsKey`, UNIT),
+		tickEntryId: (ticksTableId, tick) => deriveDynamicFieldID(ticksTableId, `${lib}::tick_math::Tick`, MoveTick.serialize(tickToMove(tick)).toBytes()),
+		branchEntryId: (branchesTableId, branchId) => deriveDynamicFieldID(branchesTableId, "u64", bcs.u64().serialize(BigInt(branchId)).toBytes()),
+		liqSnapEntryId: (snapsTableId, tick, tickId) => deriveDynamicFieldID(snapsTableId, `${vaults}::tick::TickIdLiquidationKey`, TickIdLiquidationKey.serialize({
+			tick: tickToMove(tick),
+			tick_map: tickId
+		}).toBytes()),
+		bitmapWordId: (bitmapTableId, word) => deriveDynamicFieldID(bitmapTableId, "u16", bcs.u16().serialize(word).toBytes()),
+		positionIndexKeyType: cfg.positionIndexKeyType ?? `${vaults}::position_index::PositionIndexKey`,
+		positionIndexId: (vaultMarketId) => deriveDynamicFieldID(normalizeSuiAddress(vaultMarketId), cfg.positionIndexKeyType ?? `${vaults}::position_index::PositionIndexKey`, UNIT),
+		positionIndexEntryId: (capsTableId, n) => deriveDynamicFieldID(capsTableId, "u64", bcs.u64().serialize(BigInt(n)).toBytes()),
+		oracleId: (nonce) => deriveObjectID(o.oracleRegistry, `${p.oracle.originalId}::keys::OracleKey`, bcs.u16().serialize(nonce).toBytes()),
+		fTokenType: (coinType) => `${lend}::lending_state::FToken<${normalizeStructTag(coinType)}>`,
+		positionCapType: `${vaults}::position::PositionOwnerCap`
+	};
+}
+
+//#endregion
+//#region src/math/liquidity.ts
+/** Liquidity-layer maths. Exchange prices + revenue are bit-exact ports of
+*  `fluid_liquidity::reserve` / `liquidity_calcs`; the user/overall shaping follows
+*  `@jup-ag/lend-read` so consumers get identical field semantics. */
+var liquidity_exports = /* @__PURE__ */ __exportAll({
+	calcBorrowLimitBeforeOperate: () => calcBorrowLimitBeforeOperate,
+	calcRevenue: () => calcRevenue,
+	calcWithdrawalLimitBeforeOperate: () => calcWithdrawalLimitBeforeOperate,
+	calculateExchangePrice: () => calculateExchangePrice,
+	emptyUserBorrowData: () => emptyUserBorrowData,
+	emptyUserSupplyData: () => emptyUserSupplyData,
+	processOverallTokenData: () => processOverallTokenData,
+	processUserBorrowData: () => processUserBorrowData,
+	processUserSupplyData: () => processUserSupplyData,
+	supplyRateAt: () => supplyRateAt,
+	supplyRateRaw: () => supplyRateRaw,
+	totalAmountsOf: () => totalAmountsOf,
+	totalBorrowNormal: () => totalBorrowNormal,
+	totalSupplyNormal: () => totalSupplyNormal
+});
+function withInterestVsFreeRatio(withInterest, interestFree) {
+	if (withInterest > interestFree) return interestFree * FOUR_DECIMALS / withInterest;
+	if (withInterest < interestFree) return withInterest * FOUR_DECIMALS / interestFree;
+	return withInterest > 0n ? FOUR_DECIMALS : 0n;
+}
+/**
+* Supply rate the reserve credits for a period starting from these exchange prices, at
+* `SUPPLY_RATE_PRECISION` (1e12 = 100% per year): exactly `borrow_rate * ratio_supply_yield * (1e4 - fee)`
+* from `reserve::calculate_exchange_prices` (interest-free ratios on both sides, fee applied).
+* `borrowEpForRatio` is the borrow exchange price the contract normalises the borrow ratio with.
+*/
+function supplyRateRaw(r, supplyExchangePrice, borrowEpForRatio, variant) {
+	if (r.borrowRate === 0n || r.totalBorrowWithInterest === 0n || r.totalSupplyWithInterest === 0n) return 0n;
+	const supplyWithInterestNormal = divCeil(r.totalSupplyWithInterest * supplyExchangePrice, EXCHANGE_PRICES_PRECISION);
+	const supplyRatio = withInterestVsFreeRatio(supplyWithInterestNormal, r.totalSupplyInterestFree);
+	let ratioSupplyYield;
+	if (supplyWithInterestNormal < r.totalSupplyInterestFree) {
+		if (supplyRatio === 0n) return 0n;
+		const inverted = variant === "audited" ? mulDiv(r.totalSupplyInterestFree, RATE_OUTPUT_DECIMALS, supplyWithInterestNormal) : RATE_OUTPUT_DECIMALS * FOUR_DECIMALS / supplyRatio;
+		ratioSupplyYield = r.lastUtilization * (RATE_OUTPUT_DECIMALS + inverted) / FOUR_DECIMALS;
+	} else ratioSupplyYield = r.lastUtilization * RATE_OUTPUT_DECIMALS * (FOUR_DECIMALS + supplyRatio) / (FOUR_DECIMALS * FOUR_DECIMALS);
+	const borrowWithInterestNormal = r.totalBorrowWithInterest * borrowEpForRatio / EXCHANGE_PRICES_PRECISION;
+	let borrowRatio = withInterestVsFreeRatio(borrowWithInterestNormal, r.totalBorrowInterestFree);
+	borrowRatio = borrowWithInterestNormal < r.totalBorrowInterestFree ? borrowRatio * RATE_OUTPUT_DECIMALS / (FOUR_DECIMALS + borrowRatio) : RATE_OUTPUT_DECIMALS - borrowRatio * RATE_OUTPUT_DECIMALS / (FOUR_DECIMALS + borrowRatio);
+	ratioSupplyYield = mulDiv(ratioSupplyYield, borrowRatio, RATE_OUTPUT_DECIMALS);
+	ratioSupplyYield = ratioSupplyYield * FOUR_DECIMALS / RATE_OUTPUT_DECIMALS;
+	return r.borrowRate * ratioSupplyYield * (FOUR_DECIMALS - r.fee);
+}
+/** `reserve::calculate_exchange_prices(now)`. */
+function calculateExchangePrice(r, now, variant = "audited") {
+	let supplyExchangePrice = r.supplyExchangePrice;
+	let borrowExchangePrice = r.borrowExchangePrice;
+	if (supplyExchangePrice === 0n || borrowExchangePrice === 0n) throw new RangeError("exchange price zero (reserve never initialised)");
+	const elapsed = now > r.lastUpdateTimestamp ? now - r.lastUpdateTimestamp : 0n;
+	if (elapsed === 0n || r.borrowRate === 0n || r.totalBorrowWithInterest === 0n) return {
+		supplyExchangePrice,
+		borrowExchangePrice
+	};
+	const borrowBefore = borrowExchangePrice;
+	borrowExchangePrice += divCeil(borrowExchangePrice * r.borrowRate * elapsed, SECONDS_PER_YEAR * FOUR_DECIMALS);
+	const rate = supplyRateRaw(r, supplyExchangePrice, variant === "audited" ? borrowBefore : borrowExchangePrice, variant);
+	supplyExchangePrice += supplyExchangePrice * rate * elapsed / (SECONDS_PER_YEAR * FOUR_DECIMALS) / (FOUR_DECIMALS * FOUR_DECIMALS);
+	return {
+		supplyExchangePrice,
+		borrowExchangePrice
+	};
+}
+/**
+* Instantaneous liquidity supply rate at `now` (1e12 = 100%): the rate the contract would credit
+* for the period starting at `now`, i.e. `supplyRateRaw` on both exchange prices accrued to `now`.
+*/
+function supplyRateAt(r, now, variant = "audited") {
+	const ep = calculateExchangePrice(r, now, variant);
+	return supplyRateRaw(r, ep.supplyExchangePrice, ep.borrowExchangePrice, variant);
+}
+/** `liquidity_calcs::get_total_supply` (floor). */
+const totalSupplyNormal = (r, supplyEp) => r.totalSupplyInterestFree + r.totalSupplyWithInterest * supplyEp / EXCHANGE_PRICES_PRECISION;
+/** `liquidity_calcs::get_total_borrow` (floor). */
+const totalBorrowNormal = (r, borrowEp) => r.totalBorrowInterestFree + r.totalBorrowWithInterest * borrowEp / EXCHANGE_PRICES_PRECISION;
+/** `reserve::calc_revenue` (supply side ceiled, saturating at 0). */
+function calcRevenue(r, supplyEp, borrowEp) {
+	const totalSupply = r.totalSupplyInterestFree + divCeil(r.totalSupplyWithInterest * supplyEp, EXCHANGE_PRICES_PRECISION);
+	if (totalSupply === 0n) return r.vaultBalance;
+	const revenueAmount = r.vaultBalance + totalBorrowNormal(r, borrowEp);
+	return revenueAmount > totalSupply ? revenueAmount - totalSupply : 0n;
+}
+function totalAmountsOf(r) {
+	return {
+		supplyRawInterest: r.totalSupplyWithInterest,
+		supplyInterestFree: r.totalSupplyInterestFree,
+		borrowRawInterest: r.totalBorrowWithInterest,
+		borrowInterestFree: r.totalBorrowInterestFree,
+		totalClaimAmount: 0n
+	};
+}
+/**
+* Same shape as the Solana reader's `processOverallTokenData`. `supplyRate` (bps) is the exact
+* on-chain supply rate at `now` (`supplyRateAt`, floored to bps), not the Solana approximation.
+*/
+function processOverallTokenData(r, rateData, now, variant = "audited") {
+	const { supplyExchangePrice, borrowExchangePrice } = calculateExchangePrice(r, now, variant);
+	const supplyRate = supplyRateToBps(supplyRateRaw(r, supplyExchangePrice, borrowExchangePrice, variant));
+	return {
+		rateData,
+		supplyExchangePrice,
+		borrowExchangePrice,
+		borrowRate: r.borrowRate,
+		fee: r.fee,
+		lastStoredUtilization: r.lastUtilization,
+		lastUpdateTimestamp: r.lastUpdateTimestamp,
+		maxUtilization: r.maxUtilization,
+		supplyRawInterest: r.totalSupplyWithInterest,
+		supplyInterestFree: r.totalSupplyInterestFree,
+		borrowRawInterest: r.totalBorrowWithInterest,
+		borrowInterestFree: r.totalBorrowInterestFree,
+		totalSupply: totalSupplyNormal(r, supplyExchangePrice),
+		totalBorrow: totalBorrowNormal(r, borrowExchangePrice),
+		revenue: calcRevenue(r, supplyExchangePrice, borrowExchangePrice),
+		supplyRate
+	};
+}
+/** `liquidity_calcs::calc_withdrawal_limit_before_operate`. */
+function calcWithdrawalLimitBeforeOperate(userAmount, lastLimit, expandPercent, expandDuration, lastUpdate, now) {
+	if (lastLimit === 0n) return 0n;
+	const maxWithdrawable = userAmount * expandPercent / FOUR_DECIMALS;
+	const elapsed = now > lastUpdate ? now - lastUpdate : 0n;
+	const withdrawableAmount = expandDuration === 0n ? maxWithdrawable : mulDiv(maxWithdrawable, elapsed, expandDuration);
+	let limit = lastLimit > withdrawableAmount ? lastLimit - withdrawableAmount : 0n;
+	const minLimit = userAmount - maxWithdrawable;
+	if (minLimit > limit) limit = minLimit;
+	return limit;
+}
+/** `liquidity_calcs::calc_borrow_limit_before_operate`. */
+function calcBorrowLimitBeforeOperate(userAmount, lastLimit, expandPercent, expandDuration, baseLimit, maxLimit, lastUpdate, now) {
+	const maxExpansion = userAmount * expandPercent / FOUR_DECIMALS;
+	const maxExpanded = userAmount + maxExpansion;
+	if (maxExpanded < baseLimit) return baseLimit;
+	if (expandDuration === 0n) return baseLimit;
+	let limit = mulDiv(maxExpansion, now > lastUpdate ? now - lastUpdate : 0n, expandDuration) + lastLimit;
+	if (limit > maxExpanded) limit = maxExpanded;
+	if (limit > maxLimit) return maxLimit;
+	return limit;
+}
+const toNormal = (raw, ep) => raw * ep / EXCHANGE_PRICES_PRECISION;
+function emptyUserSupplyData() {
+	return {
+		modeWithInterest: false,
+		supply: 0n,
+		withdrawalLimit: 0n,
+		lastUpdateTimestamp: 0n,
+		expandPercent: 0n,
+		expandDuration: 0n,
+		baseWithdrawalLimit: 0n,
+		withdrawableUntilLimit: 0n,
+		withdrawable: 0n,
+		decayAmount: 0n,
+		decayEndTimestamp: 0n
+	};
+}
+function emptyUserBorrowData() {
+	return {
+		modeWithInterest: false,
+		borrow: 0n,
+		borrowLimit: 0n,
+		lastUpdateTimestamp: 0n,
+		expandPercent: 0n,
+		expandDuration: 0n,
+		baseBorrowLimit: 0n,
+		maxBorrowLimit: 0n,
+		borrowLimitUtilization: 0n,
+		borrowableUntilLimit: 0n,
+		borrowable: 0n
+	};
+}
+/** Solana `processUserSupplyData`, with Sui's decay fields. */
+function processUserSupplyData(acc, overall, liquidityBalance, now) {
+	const d = emptyUserSupplyData();
+	if (!acc) return d;
+	d.modeWithInterest = acc.modeWithInterest;
+	d.supply = acc.amount;
+	d.withdrawalLimit = calcWithdrawalLimitBeforeOperate(acc.amount, acc.withdrawalLimit, acc.expandPercent, acc.expandDuration, acc.lastUpdateTimestamp, now);
+	d.lastUpdateTimestamp = acc.lastUpdateTimestamp;
+	d.expandPercent = acc.expandPercent;
+	d.expandDuration = acc.expandDuration;
+	d.baseWithdrawalLimit = acc.baseWithdrawalLimit;
+	let decay = acc.decayAmount;
+	let decayEnd = now;
+	if (decay > 0n && acc.decayDuration > 0n) {
+		const elapsed = now > acc.lastUpdateTimestamp ? now - acc.lastUpdateTimestamp : 0n;
+		if (elapsed < acc.decayDuration) {
+			decay -= decay * elapsed / acc.decayDuration;
+			decayEnd = acc.lastUpdateTimestamp + acc.decayDuration;
+		} else decay = 0n;
+	}
+	d.decayAmount = decay;
+	d.decayEndTimestamp = decayEnd;
+	if (d.modeWithInterest) {
+		const ep = overall.supplyExchangePrice;
+		d.supply = toNormal(d.supply, ep);
+		d.withdrawalLimit = toNormal(d.withdrawalLimit, ep);
+		d.baseWithdrawalLimit = toNormal(d.baseWithdrawalLimit, ep);
+		d.decayAmount = toNormal(d.decayAmount, ep);
+	}
+	d.withdrawableUntilLimit = d.supply > d.withdrawalLimit ? d.supply - d.withdrawalLimit : 0n;
+	if (d.withdrawalLimit === 0n) d.withdrawalLimit = d.supply;
+	d.withdrawable = liquidityBalance > d.withdrawableUntilLimit ? d.withdrawableUntilLimit : liquidityBalance;
+	return d;
+}
+/** Solana `processUserBorrowData`. */
+function processUserBorrowData(acc, overall, liquidityBalance, now) {
+	const d = emptyUserBorrowData();
+	if (!acc) return d;
+	d.modeWithInterest = acc.modeWithInterest;
+	d.borrow = acc.amount;
+	d.borrowLimit = calcBorrowLimitBeforeOperate(acc.amount, acc.borrowLimit, acc.expandPercent, acc.expandDuration, acc.baseBorrowLimit, acc.maxBorrowLimit, acc.lastUpdateTimestamp, now);
+	d.lastUpdateTimestamp = acc.lastUpdateTimestamp;
+	d.expandPercent = acc.expandPercent;
+	d.expandDuration = acc.expandDuration;
+	d.baseBorrowLimit = acc.baseBorrowLimit;
+	d.maxBorrowLimit = acc.maxBorrowLimit;
+	if (d.modeWithInterest) {
+		const ep = overall.borrowExchangePrice;
+		d.borrow = toNormal(d.borrow, ep);
+		d.borrowLimit = toNormal(d.borrowLimit, ep);
+		d.baseBorrowLimit = toNormal(d.baseBorrowLimit, ep);
+		d.maxBorrowLimit = toNormal(d.maxBorrowLimit, ep);
+	}
+	d.borrowLimitUtilization = overall.maxUtilization * overall.totalSupply / FOUR_DECIMALS;
+	const untilUtil = d.borrowLimitUtilization > overall.totalBorrow ? d.borrowLimitUtilization - overall.totalBorrow : 0n;
+	const untilLimit = d.borrowLimit > d.borrow ? d.borrowLimit - d.borrow : 0n;
+	d.borrowableUntilLimit = untilLimit > untilUtil ? untilUtil : untilLimit;
+	d.borrowable = liquidityBalance > d.borrowableUntilLimit ? d.borrowableUntilLimit : liquidityBalance;
+	return d;
+}
+
+//#endregion
+//#region src/math/lending.ts
+/** Lending (fToken) maths: bit-exact ports of `fluid_lending::accounting`, `lending_calcs`
+*  and `rewards::get_rate_segments`. */
+var lending_exports = /* @__PURE__ */ __exportAll({
+	accruedTokenExchangePrice: () => accruedTokenExchangePrice,
+	currentRewardsRate: () => currentRewardsRate,
+	previews: () => previews,
+	rateSegments: () => rateSegments,
+	rewardsRateFor: () => rewardsRateFor,
+	rewardsTvl: () => rewardsTvl,
+	toAssets: () => toAssets,
+	toShares: () => toShares
+});
+const toShares = (assets, ep, roundUp) => roundUp ? mulDivCeil(assets, EXCHANGE_PRICES_PRECISION, ep) : mulDiv(assets, EXCHANGE_PRICES_PRECISION, ep);
+const toAssets = (shares, ep, roundUp) => roundUp ? mulDivCeil(shares, ep, EXCHANGE_PRICES_PRECISION) : mulDiv(shares, ep, EXCHANGE_PRICES_PRECISION);
+/** `lending_calcs::calc_rewards_rate` via `rewards::rate_for`. */
+function rewardsRateFor(yearlyReward, totalAssets, startTvl) {
+	if (totalAssets < startTvl || totalAssets === 0n) return 0n;
+	const rate = mulDiv(yearlyReward, RETURN_PERCENT_PRECISION, totalAssets);
+	return rate > MAX_REWARDS_RATE ? MAX_REWARDS_RATE : rate;
+}
+/** `rewards::get_rate_segments`. */
+function rateSegments(s, totalAssets, fromS, nowS) {
+	const out = [];
+	const push = (rate, from, to) => {
+		if (to > from && rate > 0n) out.push({
+			rate,
+			fromS: from,
+			toS: to
+		});
+	};
+	push(rewardsRateFor(s.yearlyReward, totalAssets, s.startTvl), maxB(fromS, s.startS), minB(nowS, s.endS));
+	push(rewardsRateFor(s.nextYearlyReward, totalAssets, s.startTvl), maxB(fromS, s.nextStartS), minB(nowS, s.nextEndS));
+	return out;
+}
+const maxB = (a, b) => a > b ? a : b;
+const minB = (a, b) => a < b ? a : b;
+/**
+* TVL the contract prices rewards on: total shares at the STORED (pre-accrual) token exchange
+* price, as `accounting::accrued_token_exchange_price` does. Rounded up on "audited" packages
+* (742ea21+), floored on the 09-18 "pre-audit" packages.
+*/
+const rewardsTvl = (state, variant = "audited") => toAssets(state.totalShares, state.tokenExchangePrice, variant === "audited");
+/**
+* Current rewards rate (raw, RETURN_PERCENT_PRECISION: 1e14 = 100%) at `now`, from the active schedule segment, priced on
+* the pre-accrual TVL (`rewardsTvl`) exactly as the contract prices the segment it will credit.
+* Windows are [start, end): the rate is live from `startS` and gone at `endS`.
+*/
+function currentRewardsRate(state, now, variant = "audited") {
+	if (!state.rewards) return 0n;
+	const tvl = rewardsTvl(state, variant);
+	const s = state.rewards;
+	if (now >= s.startS && now < s.endS) return rewardsRateFor(s.yearlyReward, tvl, s.startTvl);
+	if (now >= s.nextStartS && now < s.nextEndS) return rewardsRateFor(s.nextYearlyReward, tvl, s.startTvl);
+	return 0n;
+}
+/** `accounting::accrued_token_exchange_price`. */
+function accruedTokenExchangePrice(state, newLiquidityExchangePrice, nowS, variant = "audited") {
+	const oldLiq = state.liquidityExchangePrice;
+	const oldToken = state.tokenExchangePrice;
+	if (newLiquidityExchangePrice < oldLiq) throw new RangeError("liquidity exchange price went backwards");
+	let totalReturn = mulDiv(newLiquidityExchangePrice - oldLiq, RETURN_PERCENT_PRECISION, oldLiq);
+	if (state.rewards) {
+		const tvl = rewardsTvl(state, variant);
+		for (const seg of rateSegments(state.rewards, tvl, state.lastUpdateS, nowS)) totalReturn += mulDiv(seg.rate, seg.toS - seg.fromS, SECONDS_PER_YEAR);
+	}
+	return oldToken + mulDiv(oldToken, totalReturn, RETURN_PERCENT_PRECISION);
+}
+/** `accounting::preview_*` given the reserve's current liquidity (supply) exchange price. */
+function previews(state, liquidityExchangePrice, nowS, assets, shares, variant = "audited") {
+	const tokenEp = accruedTokenExchangePrice(state, liquidityExchangePrice, nowS, variant);
+	return {
+		tokenExchangePrice: tokenEp,
+		previewDeposit: toShares(toAssets(toShares(assets, liquidityExchangePrice, false), liquidityExchangePrice, false), tokenEp, false),
+		previewMint: toAssets(shares, tokenEp, true),
+		previewWithdraw: toShares(assets, tokenEp, true),
+		previewRedeem: toAssets(shares, tokenEp, false)
+	};
+}
+
+//#endregion
+//#region src/view.ts
+/** Any address works as the simulated sender; nothing is executed. */
+const VIEW_SENDER = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ViewCallError = class extends Error {
+	constructor(message, details) {
+		super(message);
+		this.details = details;
+		this.name = "ViewCallError";
+	}
+};
+/**
+* Build a PTB with `build`, simulate it, and return every command's return values as raw BCS.
+* `results[i][j]` = return value j of command i.
+*/
+async function simulateView(client, build) {
+	const tx = new Transaction();
+	tx.setSender(VIEW_SENDER);
+	build(tx);
+	const res = await client.core.simulateTransaction({
+		transaction: tx,
+		include: {
+			effects: true,
+			commandResults: true
+		},
+		checksEnabled: false
+	});
+	if (res.$kind !== "Transaction") {
+		const status = res.FailedTransaction?.effects?.status;
+		throw new ViewCallError(`view call failed: ${JSON.stringify(status)}`, status);
+	}
+	return (res.commandResults ?? []).map((c) => c.returnValues.map((v) => v.bcs));
+}
+
+//#endregion
+//#region src/lending.ts
+/** Lending resolver: mirrors `@jup-ag/lend-read` `Lending`. Sui's share token is
+*  `Coin<FToken<T>>`; Solana `jlToken` names survive only as `@deprecated` aliases of the `fToken` ones. */
+const RewardsField = Field(UnitKey, RewardsSchedule);
+var Lending = class {
+	constructor(ctx, liquidity) {
+		this.ctx = ctx;
+		this.liquidity = liquidity;
+	}
+	/** Object ids `loadLendings` reads: every LendingState, then every rewards field. */
+	lendingObjectIds(tokens) {
+		const ids = tokens.map((t) => this.ctx.derive.lendingStateId(normalizeStructTag(t)));
+		return [...ids, ...ids.map((id) => this.ctx.derive.rewardsId(id))];
+	}
+	/** LendingStates (+ rewards fields) for `tokens`; `null` where no pool exists. */
+	async loadLendings(tokens) {
+		return this.lendingsFromObjects(tokens, await fetchObjects(this.ctx.client, this.lendingObjectIds(tokens)));
+	}
+	lendingsFromObjects(tokens, objs) {
+		const norm = tokens.map((t) => normalizeStructTag(t));
+		const ids = norm.map((t) => this.ctx.derive.lendingStateId(t));
+		return norm.map((token, i) => {
+			const o = objs[i];
+			if (!o) return null;
+			const raw = LendingState.parse(o.content);
+			const rf = objs[ids.length + i];
+			const rw = rf ? RewardsField.parse(rf.content).value : null;
+			return {
+				token,
+				id: ids[i],
+				raw,
+				snapshot: {
+					totalShares: BigInt(raw.supply),
+					liquidityExchangePrice: BigInt(raw.liquidity_exchange_price),
+					tokenExchangePrice: BigInt(raw.token_exchange_price),
+					lastUpdateS: BigInt(raw.last_update_s),
+					rewards: rw && {
+						startTvl: BigInt(rw.start_tvl),
+						startS: BigInt(rw.start_s),
+						endS: BigInt(rw.end_s),
+						yearlyReward: BigInt(rw.yearly_reward),
+						nextStartS: BigInt(rw.next_start_s),
+						nextEndS: BigInt(rw.next_end_s),
+						nextYearlyReward: BigInt(rw.next_yearly_reward)
+					}
+				}
+			};
+		});
+	}
+	/**
+	* Everything a pool read needs in ONE `getObjects` batch (LendingState, rewards field,
+	* TokenReserve, rate data per token; 50 ids per request, chunks in parallel), plus the chain
+	* clock in parallel. With `withEntries`, a second batch reads each pool's liquidity supply entry.
+	*/
+	async loadPools(tokens, withEntries = false) {
+		const norm = tokens.map((t) => normalizeStructTag(t));
+		const lIds = this.lendingObjectIds(norm);
+		const [objs, now] = await Promise.all([fetchObjects(this.ctx.client, [...lIds, ...this.liquidity.reserveObjectIds(norm)]), this.ctx.now()]);
+		const lendings = this.lendingsFromObjects(norm, objs.slice(0, lIds.length));
+		const reserves = this.liquidity.reservesFromObjects(norm, objs.slice(lIds.length));
+		const pools = norm.map((token, i) => {
+			const lending = lendings[i];
+			if (!lending) throw new Error(`no LendingState for ${token}`);
+			return {
+				lending,
+				reserve: reserves[i],
+				supplyEntry: null
+			};
+		});
+		if (withEntries) {
+			const entries = await this.liquidity.loadUserEntries(pools.map((p) => ({
+				holder: p.lending.id,
+				reserve: p.reserve
+			})));
+			pools.forEach((p, i) => p.supplyEntry = entries[i].supply);
+		}
+		return {
+			pools,
+			now
+		};
+	}
+	async loadOne(token) {
+		const { pools, now } = await this.loadPools([token]);
+		return {
+			...pools[0],
+			now
+		};
+	}
+	async getAllLendings() {
+		const tokens = await this.liquidity.listedTokens();
+		const recs = (await this.loadLendings(tokens)).filter((r) => r !== null);
+		const metas = await Promise.all(recs.map((r) => this.ctx.coinMetadata(r.token)));
+		return recs.map((r, i) => ({
+			id: r.id,
+			mint: r.token,
+			fTokenMint: this.ctx.derive.fTokenType(r.token),
+			decimals: metas[i]?.decimals ?? 0,
+			totalShares: r.snapshot.totalShares,
+			liquidityExchangePrice: r.snapshot.liquidityExchangePrice,
+			tokenExchangePrice: r.snapshot.tokenExchangePrice,
+			lastUpdateTimestamp: r.snapshot.lastUpdateS,
+			tokenReservesLiquidity: r.raw.reserve_id,
+			rewardsWriter: r.raw.rewards_writer ?? null
+		}));
+	}
+	/** Underlying coin types that have a lending pool. */
+	async getAllFTokens() {
+		return (await this.getAllLendings()).map((l) => l.mint);
+	}
+	/** @deprecated Solana name; use `getAllFTokens`. */
+	getAllJlTokens = () => this.getAllFTokens();
+	/** Token exchange price accrued to now (`accounting::calculate_new_token_exchange_price`). */
+	async getExchangePrice(token) {
+		const { lending, reserve, now } = await this.loadOne(token);
+		const liqEp = calculateExchangePrice(reserve.snapshot, now, this.ctx.math).supplyExchangePrice;
+		return accruedTokenExchangePrice(lending.snapshot, liqEp, now, this.ctx.math);
+	}
+	async getPreviews(token, assets, shares) {
+		const { lending, reserve, now } = await this.loadOne(token);
+		const liqEp = calculateExchangePrice(reserve.snapshot, now, this.ctx.math).supplyExchangePrice;
+		const p = previews(lending.snapshot, liqEp, now, assets, shares, this.ctx.math);
+		return {
+			previewDeposit: p.previewDeposit,
+			previewMint: p.previewMint,
+			previewWithdraw: p.previewWithdraw,
+			previewRedeem: p.previewRedeem
+		};
+	}
+	detailsFromRecords(lending, reserve, supplyEntry, meta, now) {
+		const { userSupplyData, overallTokenData } = this.liquidity.supplyDataFromRecords(reserve, supplyEntry, now);
+		const tokenEp = accruedTokenExchangePrice(lending.snapshot, overallTokenData.supplyExchangePrice, now, this.ctx.math);
+		const totalAssets = toAssets(lending.snapshot.totalShares, tokenEp, false);
+		const one = 10n ** BigInt(meta.decimals);
+		const supplyRate = supplyRateToBps(supplyRateRaw(reserve.snapshot, overallTokenData.supplyExchangePrice, overallTokenData.borrowExchangePrice, this.ctx.math));
+		const rewardsRate = rewardsRateToBps(currentRewardsRate(lending.snapshot, now, this.ctx.math));
+		return {
+			tokenAddress: this.ctx.derive.fTokenType(lending.token),
+			lendingStateId: lending.id,
+			name: meta.name,
+			symbol: meta.symbol,
+			decimals: meta.decimals,
+			underlyingAddress: lending.token,
+			totalAssets,
+			totalSupply: lending.snapshot.totalShares,
+			conversionRateToShares: toShares(one, tokenEp, false),
+			conversionRateToAssets: toAssets(one, tokenEp, false),
+			rewardsRate,
+			supplyRate,
+			totalRate: supplyRate + rewardsRate,
+			rebalanceDifference: userSupplyData.supply - totalAssets,
+			userSupplyData
+		};
+	}
+	/** fToken name/symbol/decimals (cached; falls back to the underlying's metadata). */
+	async fTokenMeta(token) {
+		const [f, under] = await Promise.all([this.ctx.coinMetadata(this.ctx.derive.fTokenType(token)).catch(() => null), this.ctx.coinMetadata(token)]);
+		return {
+			name: f?.name ?? `Fluid ${under?.name ?? ""}`.trim(),
+			symbol: f?.symbol ?? `f${under?.symbol ?? ""}`,
+			decimals: f?.decimals ?? under?.decimals ?? 0
+		};
+	}
+	async getFTokenDetails(token) {
+		return (await this.getFTokensDetails([token]))[0];
+	}
+	/** Details for many fTokens: 2 batched object reads + the clock, metadata cached. */
+	async getFTokensDetails(tokens) {
+		return (await this.detailsWithPrices(tokens)).map((d) => d.details);
+	}
+	async detailsWithPrices(tokens) {
+		const [{ pools, now }, metas] = await Promise.all([this.loadPools(tokens, true), Promise.all(tokens.map((t) => this.fTokenMeta(normalizeStructTag(t))))]);
+		return pools.map((p, i) => {
+			const details = this.detailsFromRecords(p.lending, p.reserve, p.supplyEntry, metas[i], now);
+			const liqEp = calculateExchangePrice(p.reserve.snapshot, now, this.ctx.math).supplyExchangePrice;
+			return {
+				details,
+				tokenEp: accruedTokenExchangePrice(p.lending.snapshot, liqEp, now, this.ctx.math)
+			};
+		});
+	}
+	/** @deprecated Solana name; use `getFTokenDetails`. */
+	getJlTokenDetails = (token) => this.getFTokenDetails(token);
+	async getAllFTokenDetails() {
+		return this.getFTokensDetails(await this.listedLendingTokens());
+	}
+	/** Underlying coin types that have a lending pool (pure state: one batched existence read). */
+	async listedLendingTokens() {
+		const tokens = await this.liquidity.listedTokens();
+		const ids = tokens.map((t) => this.ctx.derive.lendingStateId(normalizeStructTag(t)));
+		const objs = await fetchObjects(this.ctx.client, ids);
+		return tokens.map((t) => normalizeStructTag(t)).filter((_, i) => objs[i] !== null);
+	}
+	/** @deprecated Solana name; use `getAllFTokenDetails`. */
+	getAllJlTokenDetails = () => this.getAllFTokenDetails();
+	async getFTokenInternalData(token) {
+		const { pools, now } = await this.loadPools([token], true);
+		const { lending, reserve, supplyEntry } = pools[0];
+		const entry = { supply: supplyEntry };
+		const { userSupplyData } = this.liquidity.supplyDataFromRecords(reserve, entry.supply, now);
+		const liqEp = calculateExchangePrice(reserve.snapshot, now, this.ctx.math).supplyExchangePrice;
+		return {
+			liquidity: reserve.id,
+			lendingFactory: this.ctx.config.objects.lendingRegistry,
+			lendingRewardsRateModel: lending.raw.rewards_writer ?? null,
+			liquidityBalance: userSupplyData.supply,
+			liquidityExchangePrice: liqEp,
+			tokenExchangePrice: accruedTokenExchangePrice(lending.snapshot, liqEp, now, this.ctx.math)
+		};
+	}
+	/** @deprecated Solana name; use `getFTokenInternalData`. */
+	getJlTokenInternalData = (token) => this.getFTokenInternalData(token);
+	/**
+	* Generic lending state per fToken (identity, accrued + stored exchange prices, TVL, rates in
+	* bps, rewards schedule) for `tokens` (underlying coin types), or every listed pool when
+	* omitted. One batched `getObjects` for all pools + the on-chain Clock; metadata cached.
+	*/
+	async getLendingStateData(tokens) {
+		const list = (tokens ?? await this.listedLendingTokens()).map((t) => normalizeStructTag(t));
+		const [{ pools, now }, metas] = await Promise.all([this.loadPools(list), Promise.all(list.map((t) => this.fTokenMeta(t)))]);
+		return pools.map(({ lending, reserve }, i) => this.stateDataFrom(lending, reserve, metas[i].decimals, now));
+	}
+	/** Pure: `LendingStateData` from loaded records at `now`. */
+	stateDataFrom(lending, reserve, decimals, now) {
+		const m = this.ctx.math;
+		const liq = calculateExchangePrice(reserve.snapshot, now, m);
+		const tokenEp = accruedTokenExchangePrice(lending.snapshot, liq.supplyExchangePrice, now, m);
+		const supplyRate = supplyRateToBps(supplyRateRaw(reserve.snapshot, liq.supplyExchangePrice, liq.borrowExchangePrice, m));
+		const rewardsRate = rewardsRateToBps(currentRewardsRate(lending.snapshot, now, m));
+		return {
+			fTokenType: this.ctx.derive.fTokenType(lending.token),
+			asset: lending.token,
+			decimals,
+			lendingStateId: lending.id,
+			timestamp: now,
+			tokenExchangePrice: tokenEp,
+			liquidityExchangePrice: liq.supplyExchangePrice,
+			storedTokenExchangePrice: lending.snapshot.tokenExchangePrice,
+			storedLiquidityExchangePrice: lending.snapshot.liquidityExchangePrice,
+			lastUpdateS: lending.snapshot.lastUpdateS,
+			liquidityLastUpdateS: reserve.snapshot.lastUpdateTimestamp,
+			totalShares: lending.snapshot.totalShares,
+			totalAssets: toAssets(lending.snapshot.totalShares, tokenEp, false),
+			supplyRate,
+			rewardsRate,
+			totalRate: supplyRate + rewardsRate,
+			rewards: lending.snapshot.rewards ? { ...lending.snapshot.rewards } : null
+		};
+	}
+	/**
+	* Wallet holders of `Coin<FToken<T>>` for `token` (underlying coin type), via the GraphQL
+	* indexer (`config.graphqlUrl`; needs `discovery: "indexer"`). Lists every Coin<FToken<T>>
+	* object by type and keeps the ones with an ADDRESS owner (AddressOwner or
+	* ConsensusAddressOwner), aggregated by owner, all pages at one checkpoint (consistent cursors).
+	*
+	* LIMITS (documented, by design): coins owned by other objects, shared/immutable coins and
+	* wrapped `Balance<FToken<T>>` (inside other protocols' objects) are NOT attributed to a wallet;
+	* nor are address balances (funds credited to an address without a coin object), since they are
+	* not objects and cannot be enumerated by type. `totalSupply` is returned so a caller can
+	* compare it with the sum of the wallets. With `verify` (default true) each wallet is cross-checked against
+	* fullnode `getBalance` (coinBalance + addressBalance), `concurrency` at a time (default 8).
+	*/
+	async getFTokenHolders(token, opts = {}) {
+		if (!this.ctx.allows("indexer")) throw new NeedsDiscoveryError("fToken holder list", "indexer", "no on-chain holder registry exists (fToken coins are owned objects); only an indexer can list them by type");
+		const url = this.ctx.config.graphqlUrl;
+		if (!url) throw new Error("config.graphqlUrl not set (needed for the holder list)");
+		const asset = normalizeStructTag(token);
+		const fTokenType = this.ctx.derive.fTokenType(asset);
+		const stateId = this.ctx.derive.lendingStateId(asset);
+		const coinType = `0x2::coin::Coin<${fTokenType}>`;
+		const NODES = `pageInfo { hasNextPage endCursor }
+      nodes { owner { __typename ... on AddressOwner { address { address } } ... on ConsensusAddressOwner { address { address } } ... on ObjectOwner { address { address } } }
+              asMoveObject { contents { json } } }`;
+		const first = `query($t: String!, $s: SuiAddress!, $n: Int!) {
+      checkpoint { sequenceNumber }
+      state: object(address: $s) { asMoveObject { contents { json } } }
+      objects(first: $n, filter: { type: $t }) { ${NODES} } }`;
+		const next = `query($t: String!, $n: Int!, $a: String) { objects(first: $n, after: $a, filter: { type: $t }) { ${NODES} } }`;
+		const n = opts.pageSize ?? 50;
+		const byOwner = /* @__PURE__ */ new Map();
+		let page = await graphqlQuery(url, first, {
+			t: coinType,
+			s: stateId,
+			n
+		});
+		const checkpoint = BigInt(page.checkpoint.sequenceNumber);
+		const supplyJson = page.state?.asMoveObject?.contents.json.supply;
+		if (supplyJson === void 0) throw new Error(`no LendingState ${stateId} for ${asset}`);
+		for (;;) {
+			for (const node of page.objects.nodes) {
+				const bal = BigInt(node.asMoveObject?.contents.json.balance ?? 0);
+				const kind = node.owner?.__typename;
+				if ((kind === "AddressOwner" || kind === "ConsensusAddressOwner") && node.owner?.address) {
+					const k = normalizeSuiAddress(node.owner.address.address);
+					const e = byOwner.get(k) ?? {
+						balance: 0n,
+						coins: 0
+					};
+					e.balance += bal;
+					e.coins += 1;
+					byOwner.set(k, e);
+				}
+			}
+			if (!page.objects.pageInfo.hasNextPage) break;
+			page = await graphqlQuery(url, next, {
+				t: coinType,
+				n,
+				a: page.objects.pageInfo.endCursor
+			});
+		}
+		const holders = [...byOwner.entries()].map(([owner, e]) => ({
+			owner,
+			balance: e.balance,
+			coins: e.coins
+		})).sort((a, b) => a.balance === b.balance ? 0 : a.balance > b.balance ? -1 : 1);
+		if (opts.verify !== false) {
+			const limit = Math.max(1, opts.concurrency ?? 8);
+			let i = 0;
+			const worker = async () => {
+				while (i < holders.length) {
+					const h = holders[i++];
+					const { balance: b } = await this.ctx.client.core.getBalance({
+						owner: h.owner,
+						coinType: fTokenType
+					});
+					h.rpc = {
+						balance: BigInt(b.balance),
+						coinBalance: BigInt(b.coinBalance ?? b.balance),
+						addressBalance: BigInt(b.addressBalance ?? 0)
+					};
+					h.agrees = h.rpc.coinBalance === h.balance && h.rpc.addressBalance === 0n;
+				}
+			};
+			await Promise.all(Array.from({ length: Math.min(limit, holders.length) }, worker));
+		}
+		return {
+			fTokenType,
+			asset,
+			checkpoint,
+			holders,
+			countedTotal: holders.reduce((a, h) => a + h.balance, 0n),
+			totalSupply: BigInt(typeof supplyJson === "object" ? supplyJson.value : supplyJson)
+		};
+	}
+	/** `[rewards writer cap id, current rewards rate in bps]`. */
+	async getFTokenRewards(token) {
+		const { lending, now } = await this.loadOne(token);
+		return [lending.raw.rewards_writer ?? null, rewardsRateToBps(currentRewardsRate(lending.snapshot, now, this.ctx.math))];
+	}
+	/** @deprecated Solana name; use `getFTokenRewards`. */
+	getJlTokenRewards = (token) => this.getFTokenRewards(token);
+	async getFTokenRewardsRateModelConfig(token) {
+		const { lending } = await this.loadOne(token);
+		const r = lending.snapshot.rewards;
+		if (!r) return null;
+		return {
+			duration: r.endS - r.startS,
+			startTime: r.startS,
+			endTime: r.endS,
+			startTvl: r.startTvl,
+			maxRate: rewardsRateToBps(MAX_REWARDS_RATE),
+			rewardAmount: r.yearlyReward,
+			nextStartTime: r.nextStartS,
+			nextEndTime: r.nextEndS,
+			nextRewardAmount: r.nextYearlyReward
+		};
+	}
+	/** @deprecated Solana name; use `getFTokenRewardsRateModelConfig`. */
+	getJlTokenRewardsRateModelConfig = (token) => this.getFTokenRewardsRateModelConfig(token);
+	async getUserPosition(token, user) {
+		const [ep, shares, under] = await Promise.all([
+			this.getExchangePrice(token),
+			this.ctx.client.core.getBalance({
+				owner: user,
+				coinType: this.ctx.derive.fTokenType(token)
+			}),
+			this.ctx.client.core.getBalance({
+				owner: user,
+				coinType: normalizeStructTag(token)
+			})
+		]);
+		const s = BigInt(shares.balance.balance);
+		return {
+			fTokenShares: s,
+			underlyingAssets: toAssets(s, ep, false),
+			underlyingBalance: BigInt(under.balance.balance)
+		};
+	}
+	async getUserPositions(user) {
+		const tokens = await this.listedLendingTokens();
+		const details = await this.detailsWithPrices(tokens);
+		const balances = await Promise.all(tokens.flatMap((t) => [this.ctx.client.core.getBalance({
+			owner: user,
+			coinType: this.ctx.derive.fTokenType(t)
+		}), this.ctx.client.core.getBalance({
+			owner: user,
+			coinType: t
+		})]));
+		return details.map(({ details: d, tokenEp }, i) => {
+			const shares = BigInt(balances[2 * i].balance.balance);
+			return {
+				fTokenDetails: d,
+				userPosition: {
+					fTokenShares: shares,
+					underlyingAssets: toAssets(shares, tokenEp, false),
+					underlyingBalance: BigInt(balances[2 * i + 1].balance.balance)
+				}
+			};
+		});
+	}
+	/** `lending::auth::is_admin(&Auth, addr)` via simulation. */
+	async isLendingAdmin(addr) {
+		return this.authView("is_admin", addr);
+	}
+	/** `lending::auth::has_role(&Auth, addr)` (any role) via simulation. */
+	async isLendingAuth(addr) {
+		return this.authView("has_role", addr);
+	}
+	async authView(fn, addr) {
+		const auth = this.ctx.config.objects.lendingAuth;
+		if (!auth) throw new Error("config.objects.lendingAuth not set");
+		const pkg = this.ctx.config.packages.lending.packageId;
+		return (await simulateView(this.ctx.client, (tx) => {
+			tx.moveCall({
+				target: `${pkg}::auth::${fn}`,
+				arguments: [tx.object(auth), tx.pure.address(addr)]
+			});
+		}))[0][0][0] === 1;
+	}
+};
+
+//#endregion
+//#region src/liquidity.ts
+/** Liquidity resolver: mirrors `@jup-ag/lend-read` `Liquidity`. `user` = a Holder object id
+*  (a VaultMarket id or a LendingState id); `token` = a coin type. */
+const SupplyField = Field(Holder, UserSupplyPosition);
+const BorrowField = Field(Holder, UserBorrowPosition);
+const RateV1Field = Field(UnitKey, RateDataV1Params);
+const RateV2Field = Field(UnitKey, RateDataV2Params);
+const CapField = Field(bcsId, CapRecord);
+const typeNameToCoinType = (name) => normalizeStructTag(name.startsWith("0x") ? name : `0x${name}`);
+function snapshotOf(r) {
+	return {
+		supplyExchangePrice: BigInt(r.supply_exchange_price),
+		borrowExchangePrice: BigInt(r.borrow_exchange_price),
+		borrowRate: BigInt(r.borrow_rate),
+		fee: BigInt(r.fee),
+		lastUtilization: BigInt(r.last_utilization),
+		lastUpdateTimestamp: BigInt(r.last_update_timestamp),
+		maxUtilization: BigInt(r.max_utilization),
+		totalSupplyWithInterest: BigInt(r.total_supply_with_interest),
+		totalSupplyInterestFree: BigInt(r.total_supply_interest_free),
+		totalBorrowWithInterest: BigInt(r.total_borrow_with_interest),
+		totalBorrowInterestFree: BigInt(r.total_borrow_interest_free),
+		vaultBalance: BigInt(r.vault)
+	};
+}
+function rateDataOf(token, version, field) {
+	const v1 = {
+		token,
+		rateAtUtilizationZero: 0n,
+		kink: 0n,
+		rateAtUtilizationKink: 0n,
+		rateAtUtilizationMax: 0n
+	};
+	const v2 = {
+		token,
+		rateAtUtilizationZero: 0n,
+		kink1: 0n,
+		rateAtUtilizationKink1: 0n,
+		kink2: 0n,
+		rateAtUtilizationKink2: 0n,
+		rateAtUtilizationMax: 0n
+	};
+	if (field && version === 1) {
+		const p = RateV1Field.parse(field.content).value;
+		Object.assign(v1, {
+			rateAtUtilizationZero: BigInt(p.rate_at_utilization_zero),
+			kink: BigInt(p.kink),
+			rateAtUtilizationKink: BigInt(p.rate_at_utilization_kink),
+			rateAtUtilizationMax: BigInt(p.rate_at_utilization_max)
+		});
+	} else if (field && version === 2) {
+		const p = RateV2Field.parse(field.content).value;
+		Object.assign(v2, {
+			rateAtUtilizationZero: BigInt(p.rate_at_utilization_zero),
+			kink1: BigInt(p.kink1),
+			rateAtUtilizationKink1: BigInt(p.rate_at_utilization_kink1),
+			kink2: BigInt(p.kink2),
+			rateAtUtilizationKink2: BigInt(p.rate_at_utilization_kink2),
+			rateAtUtilizationMax: BigInt(p.rate_at_utilization_max)
+		});
+	}
+	return {
+		token,
+		version,
+		rateDataV1: v1,
+		rateDataV2: v2
+	};
+}
+function supplyAccountOf(user, token, o) {
+	if (!o) return null;
+	const p = SupplyField.parse(o.content).value;
+	return {
+		user,
+		mint: token,
+		amount: BigInt(p.amount),
+		withdrawalLimit: BigInt(p.withdrawal_limit),
+		baseWithdrawalLimit: BigInt(p.config?.base_withdrawal_limit ?? 0),
+		lastUpdateTimestamp: BigInt(p.last_update),
+		expandPercent: BigInt(p.config?.expand_percent ?? 0),
+		expandDuration: BigInt(p.config?.expand_duration ?? 0),
+		modeWithInterest: p.config ? p.config.mode === 1 : false,
+		decayAmount: BigInt(p.decay_amount),
+		decayDuration: BigInt(p.decay_duration),
+		configured: p.config !== null,
+		pausedSupply: p.paused_supply,
+		pausedWithdraw: p.paused_withdraw
+	};
+}
+function borrowAccountOf(user, token, o) {
+	if (!o) return null;
+	const p = BorrowField.parse(o.content).value;
+	return {
+		user,
+		mint: token,
+		amount: BigInt(p.amount),
+		borrowLimit: BigInt(p.debt_ceiling),
+		baseBorrowLimit: BigInt(p.config?.base_debt_ceiling ?? 0),
+		maxBorrowLimit: BigInt(p.config?.max_debt_ceiling ?? 0),
+		lastUpdateTimestamp: BigInt(p.last_update),
+		expandPercent: BigInt(p.config?.expand_percent ?? 0),
+		expandDuration: BigInt(p.config?.expand_duration ?? 0),
+		modeWithInterest: p.config ? p.config.mode === 1 : false,
+		configured: p.config !== null,
+		pausedBorrow: p.paused_borrow,
+		pausedPayback: p.paused_payback
+	};
+}
+var Liquidity = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	/** Object ids `loadReserves` reads: every reserve, then every reserve's rate-data field. */
+	reserveObjectIds(tokens) {
+		const ids = tokens.map((t) => this.ctx.derive.tokenReserveId(normalizeStructTag(t)));
+		return [...ids, ...ids.map((id) => this.ctx.derive.rateDataId(id))];
+	}
+	/** Parse objects fetched for `reserveObjectIds(tokens)` (same order). */
+	reservesFromObjects(tokens, objs) {
+		const norm = tokens.map((t) => normalizeStructTag(t));
+		const ids = norm.map((t) => this.ctx.derive.tokenReserveId(t));
+		return norm.map((token, i) => {
+			const o = objs[i];
+			if (!o) throw new Error(`no TokenReserve for ${token} (${ids[i]})`);
+			const raw = TokenReserve.parse(o.content);
+			return {
+				token,
+				id: ids[i],
+				raw,
+				snapshot: snapshotOf(raw),
+				rateData: rateDataOf(token, raw.rate_data_version, objs[ids.length + i] ?? null)
+			};
+		});
+	}
+	/** Reserves + their rate-data fields in one batched `getObjects`. */
+	async loadReserves(tokens) {
+		return this.reservesFromObjects(tokens, await fetchObjects(this.ctx.client, this.reserveObjectIds(tokens)));
+	}
+	async loadReserve(token) {
+		return (await this.loadReserves([token]))[0];
+	}
+	/** Supply/borrow Table entries of `holders` on `reserves` (one batched round trip). */
+	async loadUserEntries(pairs) {
+		const d = this.ctx.derive;
+		const ids = pairs.flatMap(({ holder, reserve }) => [d.holderEntryId(reserve.raw.supply_positions.id, holder), d.holderEntryId(reserve.raw.borrow_positions.id, holder)]);
+		const objs = await fetchObjects(this.ctx.client, ids);
+		return pairs.map(({ holder, reserve }, i) => ({
+			supply: supplyAccountOf(holder, reserve.token, objs[2 * i] ?? null),
+			borrow: borrowAccountOf(holder, reserve.token, objs[2 * i + 1] ?? null)
+		}));
+	}
+	async getLiquidityAccount() {
+		const o = await fetchObject(this.ctx.client, this.ctx.config.objects.liquidityRegistry, "liquidity Registry");
+		const r = LiquidityRegistry.parse(o.content);
+		return {
+			id: r.id,
+			version: BigInt(r.version),
+			revenueCollector: r.revenue_collector,
+			status: r.pause,
+			activeCapsTableId: r.active_caps.id,
+			activeCapsCount: BigInt(r.active_caps.size)
+		};
+	}
+	async getRevenueCollector() {
+		return (await this.getLiquidityAccount()).revenueCollector;
+	}
+	/**
+	* Protocol holders discoverable from object state alone: every VaultMarket (ids 1..total from
+	* `VaultRegistry.next_vault_id`, derived) and every LendingState of a candidate token
+	* (derived). Pure state, no list query.
+	*/
+	async discoverProtocolHolders(seedTokens = this.ctx.config.tokens ?? []) {
+		const cfg = this.ctx.config;
+		const reg = VaultRegistry.parse((await fetchObject(this.ctx.client, cfg.objects.vaultRegistry, "VaultRegistry")).content);
+		const n = Number(reg.next_vault_id) - 1;
+		const vaultIds = Array.from({ length: n }, (_, i) => this.ctx.derive.vaultMarketId(i + 1));
+		const vaultObjs = await fetchObjects(this.ctx.client, vaultIds);
+		const vm = cfg.packages.vaults.originalId;
+		const UNIT$1 = UnitKey.serialize(false).toBytes();
+		const capFieldIds = vaultIds.flatMap((id) => [deriveDynamicFieldID(id, `${vm}::vault_market::ColCapKey`, UNIT$1), deriveDynamicFieldID(id, `${vm}::vault_market::DebtCapKey`, UNIT$1)]);
+		const capFields = await fetchObjects(this.ctx.client, capFieldIds);
+		const vaults = vaultObjs.flatMap((o, i) => {
+			if (!o) return [];
+			const [col, debt] = parseStructTag(o.type).typeParams;
+			return [{
+				vaultId: i + 1,
+				id: o.objectId,
+				collateralType: normalizeStructTag(col),
+				debtType: normalizeStructTag(debt),
+				capCount: (capFields[2 * i] ? 1 : 0) + (capFields[2 * i + 1] ? 1 : 0)
+			}];
+		});
+		const tokens = [...new Set([...seedTokens.map((t) => normalizeStructTag(t)), ...vaults.flatMap((v) => [v.collateralType, v.debtType])])];
+		const lendIds = tokens.map((t) => this.ctx.derive.lendingStateId(t));
+		const lendObjs = await fetchObjects(this.ctx.client, lendIds);
+		return {
+			vaults,
+			lendings: tokens.flatMap((token, i) => lendObjs[i] ? [{
+				token,
+				id: lendIds[i]
+			}] : [])
+		};
+	}
+	/**
+	* Token discovery from object state alone (default, no indexer, no list query):
+	* seed tokens (`config.tokens`) ∪ collateral/debt types of every VaultMarket, kept if their
+	* `TokenReserve` exists (derived id). Coverage check: every liquidity user cap is counted in
+	* `Registry.active_caps.size`; caps held by known holders (2 per vault, 1 per LendingState)
+	* are subtracted, and `untrackedCaps > 0` means some other holder exists that state alone
+	* cannot name (a token listed only by a non-Fluid integrator, or a test holder).
+	*/
+	async discoverTokens() {
+		const [acc, holders] = await Promise.all([this.getLiquidityAccount(), this.discoverProtocolHolders()]);
+		const candidates = [...new Set([...(this.ctx.config.tokens ?? []).map((t) => normalizeStructTag(t)), ...holders.vaults.flatMap((v) => [v.collateralType, v.debtType])])];
+		const reserves = await fetchObjects(this.ctx.client, candidates.map((t) => this.ctx.derive.tokenReserveId(t)));
+		const tokens = new Set(candidates.filter((_, i) => reserves[i] !== null));
+		const known = holders.vaults.reduce((s, v) => s + v.capCount, 0) + holders.lendings.length;
+		const activeCaps = Number(acc.activeCapsCount);
+		let untrackedCaps = Math.max(0, activeCaps - known);
+		let source = "state";
+		if (untrackedCaps > 0 && this.ctx.allows("fullnode")) {
+			const ids = await listDynamicFieldIds(this.ctx.client, acc.activeCapsTableId);
+			for (const o of await fetchObjects(this.ctx.client, ids)) if (o) tokens.add(typeNameToCoinType(CapField.parse(o.content).value.token.name));
+			untrackedCaps = 0;
+			source = "state+fullnode-index";
+		}
+		return {
+			tokens: [...tokens].sort(),
+			activeCaps,
+			untrackedCaps,
+			source
+		};
+	}
+	/** Listed tokens (see `discoverTokens`; pure state by default). */
+	async listedTokens() {
+		return (await this.discoverTokens()).tokens;
+	}
+	async getExchangePricesAndConfig(token) {
+		const { snapshot: s } = await this.loadReserve(token);
+		return {
+			supplyExchangePrice: s.supplyExchangePrice,
+			borrowExchangePrice: s.borrowExchangePrice,
+			borrowRate: s.borrowRate,
+			fee: s.fee,
+			lastStoredUtilization: s.lastUtilization,
+			lastUpdateTimestamp: s.lastUpdateTimestamp,
+			maxUtilization: s.maxUtilization
+		};
+	}
+	/** Pure: accrue a reserve snapshot to `now` (unix seconds; use `await ctx.now()` for chain time). */
+	calculateExchangePrice(snapshot, now) {
+		return calculateExchangePrice(snapshot, now, this.ctx.math);
+	}
+	async getRateConfig(token) {
+		const { rateData: r } = await this.loadReserve(token);
+		if (r.version === 1) return {
+			mint: r.token,
+			version: 1,
+			...pick(r.rateDataV1, [
+				"rateAtUtilizationZero",
+				"kink",
+				"rateAtUtilizationKink",
+				"rateAtUtilizationMax"
+			])
+		};
+		if (r.version === 2) return {
+			mint: r.token,
+			version: 2,
+			...pick(r.rateDataV2, [
+				"rateAtUtilizationZero",
+				"kink1",
+				"rateAtUtilizationKink1",
+				"kink2",
+				"rateAtUtilizationKink2",
+				"rateAtUtilizationMax"
+			])
+		};
+		return null;
+	}
+	async getTotalAmounts(token) {
+		return totalAmountsOf((await this.loadReserve(token)).snapshot);
+	}
+	async getConfigs2(token) {
+		return { maxUtilization: (await this.loadReserve(token)).snapshot.maxUtilization };
+	}
+	async getRevenue(token) {
+		const [{ snapshot }, now] = await Promise.all([this.loadReserve(token), this.ctx.now()]);
+		const ep = calculateExchangePrice(snapshot, now, this.ctx.math);
+		return calcRevenue(snapshot, ep.supplyExchangePrice, ep.borrowExchangePrice);
+	}
+	async getTokenRateData(token) {
+		return (await this.loadReserve(token)).rateData;
+	}
+	async getTokensRateData(tokens) {
+		return (await this.loadReserves(tokens)).map((r) => r.rateData);
+	}
+	overallFromRecord(r, now) {
+		return processOverallTokenData(r.snapshot, r.rateData, now, this.ctx.math);
+	}
+	async getOverallTokenData(token) {
+		const [r, now] = await Promise.all([this.loadReserve(token), this.ctx.now()]);
+		return this.overallFromRecord(r, now);
+	}
+	async getOverallTokensData(tokens) {
+		const [rs, now] = await Promise.all([this.loadReserves(tokens), this.ctx.now()]);
+		return rs.map((r) => this.overallFromRecord(r, now));
+	}
+	async getAllOverallTokensData() {
+		return this.getOverallTokensData(await this.listedTokens());
+	}
+	/** Raw supply position of a holder, or `0n` when none exists (Solana returns BN 0). */
+	async getUserSupply(user, token) {
+		const reserve = await this.loadReserve(token);
+		const [e] = await this.loadUserEntries([{
+			holder: user,
+			reserve
+		}]);
+		return e.supply ?? 0n;
+	}
+	async getUserBorrow(user, token) {
+		const reserve = await this.loadReserve(token);
+		const [e] = await this.loadUserEntries([{
+			holder: user,
+			reserve
+		}]);
+		return e.borrow ?? 0n;
+	}
+	supplyDataFromRecords(reserve, acc, now) {
+		const overallTokenData = this.overallFromRecord(reserve, now);
+		return {
+			userSupplyData: processUserSupplyData(acc, overallTokenData, reserve.snapshot.vaultBalance, now),
+			overallTokenData
+		};
+	}
+	borrowDataFromRecords(reserve, acc, now) {
+		const overallTokenData = this.overallFromRecord(reserve, now);
+		return {
+			userBorrowData: processUserBorrowData(acc, overallTokenData, reserve.snapshot.vaultBalance, now),
+			overallTokenData
+		};
+	}
+	async getUserSupplyData(user, token) {
+		const [reserve, now] = await Promise.all([this.loadReserve(token), this.ctx.now()]);
+		const [e] = await this.loadUserEntries([{
+			holder: user,
+			reserve
+		}]);
+		return this.supplyDataFromRecords(reserve, e.supply, now);
+	}
+	async getUserBorrowData(user, token) {
+		const [reserve, now] = await Promise.all([this.loadReserve(token), this.ctx.now()]);
+		const [e] = await this.loadUserEntries([{
+			holder: user,
+			reserve
+		}]);
+		return this.borrowDataFromRecords(reserve, e.borrow, now);
+	}
+	async getUserMultipleSupplyData(user, tokens) {
+		const [reserves, now] = await Promise.all([this.loadReserves(tokens), this.ctx.now()]);
+		const entries = await this.loadUserEntries(reserves.map((reserve) => ({
+			holder: user,
+			reserve
+		})));
+		const out = reserves.map((r, i) => this.supplyDataFromRecords(r, entries[i].supply, now));
+		return {
+			userSuppliesData: out.map((o) => o.userSupplyData),
+			overallTokensData: out.map((o) => o.overallTokenData)
+		};
+	}
+	async getUserMultipleBorrowData(user, tokens) {
+		const [reserves, now] = await Promise.all([this.loadReserves(tokens), this.ctx.now()]);
+		const entries = await this.loadUserEntries(reserves.map((reserve) => ({
+			holder: user,
+			reserve
+		})));
+		const out = reserves.map((r, i) => this.borrowDataFromRecords(r, entries[i].borrow, now));
+		return {
+			userBorrowingsData: out.map((o) => o.userBorrowData),
+			overallTokensData: out.map((o) => o.overallTokenData)
+		};
+	}
+	async getUserMultipleBorrowSupplyData(user, supplyTokens, borrowTokens) {
+		const [s, b] = await Promise.all([this.getUserMultipleSupplyData(user, supplyTokens), this.getUserMultipleBorrowData(user, borrowTokens)]);
+		return {
+			userSuppliesData: s.userSuppliesData,
+			overallSupplyTokensData: s.overallTokensData,
+			userBorrowingsData: b.userBorrowingsData,
+			overallBorrowTokensData: b.overallTokensData
+		};
+	}
+	/**
+	* Every supply/borrow position on every listed reserve, grouped by holder.
+	*
+	* Default ("state"): holders = every VaultMarket + LendingState (derived), entries read by
+	* derived Table-entry id. `untracked` = `Table.size` minus entries found, per reserve: rows of
+	* holders that object state cannot name (non-Fluid integrators). With `discovery: "fullnode"`
+	* the tables are listed and `untracked` is always empty.
+	*/
+	async getAllUserPositionsDetailed() {
+		const reserves = await this.loadReserves(await this.listedTokens());
+		if (this.ctx.allows("fullnode")) return {
+			positions: await this.listAllUserPositions(reserves),
+			untracked: [],
+			source: "fullnode-index"
+		};
+		const holders = await this.discoverProtocolHolders(reserves.map((r) => r.token));
+		const holderIds = [...holders.vaults.map((v) => v.id), ...holders.lendings.map((l) => l.id)];
+		const pairs = reserves.flatMap((reserve) => holderIds.map((holder) => ({
+			holder,
+			reserve
+		})));
+		const entries = await this.loadUserEntries(pairs);
+		const byUser = /* @__PURE__ */ new Map();
+		const found = /* @__PURE__ */ new Map();
+		entries.forEach((e, i) => {
+			const { holder, reserve } = pairs[i];
+			const f = found.get(reserve.token) ?? {
+				s: 0,
+				b: 0
+			};
+			found.set(reserve.token, f);
+			if (!e.supply && !e.borrow) return;
+			let u = byUser.get(holder);
+			if (!u) byUser.set(holder, u = {
+				user: holder,
+				supply: {},
+				borrow: {}
+			});
+			if (e.supply) u.supply[reserve.token] = e.supply, f.s++;
+			if (e.borrow) u.borrow[reserve.token] = e.borrow, f.b++;
+		});
+		const untracked = reserves.map((r) => ({
+			token: r.token,
+			supply: Number(r.raw.supply_positions.size) - (found.get(r.token)?.s ?? 0),
+			borrow: Number(r.raw.borrow_positions.size) - (found.get(r.token)?.b ?? 0)
+		})).filter((u) => u.supply > 0 || u.borrow > 0);
+		return {
+			positions: [...byUser.values()],
+			untracked,
+			source: "state"
+		};
+	}
+	/** Positions only (see `getAllUserPositionsDetailed`). */
+	async getAllUserPositions() {
+		return (await this.getAllUserPositionsDetailed()).positions;
+	}
+	/** Fullnode-index tier: lists every Table entry. */
+	async listAllUserPositions(reserves) {
+		const byUser = /* @__PURE__ */ new Map();
+		const get = (u) => {
+			let e = byUser.get(u);
+			if (!e) byUser.set(u, e = {
+				user: u,
+				supply: {},
+				borrow: {}
+			});
+			return e;
+		};
+		for (const r of reserves) {
+			const [sIds, bIds] = await Promise.all([listDynamicFieldIds(this.ctx.client, r.raw.supply_positions.id), listDynamicFieldIds(this.ctx.client, r.raw.borrow_positions.id)]);
+			(await fetchObjects(this.ctx.client, [...sIds, ...bIds])).forEach((o, i) => {
+				if (!o) return;
+				const isSupply = i < sIds.length;
+				const f = (isSupply ? SupplyField : BorrowField).parse(o.content);
+				const user = f.name.$kind === "Object" ? f.name.Object : typeNameToCoinType(f.name.Type.name);
+				if (isSupply) get(user).supply[r.token] = supplyAccountOf(user, r.token, o);
+				else get(user).borrow[r.token] = borrowAccountOf(user, r.token, o);
+			});
+		}
+		return [...byUser.values()];
+	}
+};
+function pick(o, keys) {
+	const out = {};
+	for (const k of keys) out[k] = o[k];
+	return out;
+}
+
+//#endregion
+//#region src/oracle.ts
+/**
+* Oracle reads.
+*
+* v2 (mainnet since 2026-09-30): `fluid_oracle::oracle::Oracle { nonce, main: Source, guard: Option<Source> }`.
+* A Source is a RedStone feed (on a pinned PriceAdapter) or a Pyth feed (PriceInfoObject). Vaults
+* consume `view::get_exchange_rate_operate` / `get_exchange_rate_liquidate`:
+*   - operate   = min(main, guard); either route stale (>600s) / invalid aborts the quote.
+*   - liquidate = min of the routes still usable at the looser bound (7200s); both dead aborts.
+* `getOraclePrice` simulates both views exactly as a vault would call them (nothing sent), and
+* returns `null` for a side whose view aborts, with the abort in `operateError` / `liquidateError`.
+* `getOracleRoutes` reads each route on its own (RedStone via the adapter's view, Pyth by decoding
+* the PriceInfoObject) so callers see which route set the price and whether the guard is live.
+*/
+/** Oracle rates are debt-per-collateral in the vault's internal 1e9 space, scaled by 1e15. */
+const ORACLE_RATE_PRECISION = 1000000000000000n;
+/** Mirrors `fluid_oracle::constants` of the deployed v2 package. */
+const ORACLE_LIMITS = {
+	rateOutputDecimals: 15,
+	maxAgeOperateS: 600n,
+	maxAgeLiquidateS: 7200n,
+	maxPythArrivalLagS: 60n,
+	confidenceScaleOperate: 50n,
+	confidenceScaleLiquidate: 25n,
+	maxPythExponent: 12n,
+	redstoneDecimals: 8,
+	maxInvertibleRate: 10n ** 24n
+};
+const hex = (b) => `0x${toHex(Uint8Array.from(b))}`;
+function toSource(s) {
+	const st = s.source_type;
+	return {
+		feedId: hex(s.feed_id),
+		invert: s.invert,
+		provider: "Redstone" in st && st.Redstone ? "redstone" : "pyth",
+		..."Redstone" in st && st.Redstone ? { adapterId: normalizeSuiObjectId(st.Redstone.adapter_id) } : {}
+	};
+}
+/** `rate::scale_and_invert`: raw provider price with `decimals` → 1e15 rate, optionally inverted. */
+function scaleAndInvert(raw, decimals, invert) {
+	const out = ORACLE_LIMITS.rateOutputDecimals;
+	let rate = decimals > out ? raw / 10n ** BigInt(decimals - out) : raw * 10n ** BigInt(out - decimals);
+	if (rate > 0n && invert) rate = rate > ORACLE_LIMITS.maxInvertibleRate ? 0n : ORACLE_RATE_PRECISION * ORACLE_RATE_PRECISION / rate;
+	return rate;
+}
+function abortText(e) {
+	if (e instanceof ViewCallError) {
+		const s = JSON.stringify(e.details ?? e.message);
+		const code = /abort[^0-9]*(\d+)/i.exec(s)?.[1] ?? /"abortCode":"?(\d+)/.exec(s)?.[1];
+		return code ? `abort ${code}` : s.slice(0, 200);
+	}
+	return e instanceof Error ? e.message : String(e);
+}
+var Oracle = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	get providers() {
+		const c = this.ctx.config.oracle;
+		if (!c) throw new Error("config has no oracle (config.oracle)");
+		return c;
+	}
+	/** v2 oracle object: nonce + main / guard routes. */
+	async getOracle(oracleId) {
+		const id = normalizeSuiObjectId(oracleId);
+		const o = OracleObject.parse((await fetchObject(this.ctx.client, id, "Oracle")).content);
+		return {
+			id,
+			nonce: o.nonce,
+			main: toSource(o.main),
+			guard: o.guard ? toSource(o.guard) : null
+		};
+	}
+	/** Provider objects the v2 views take for this oracle. */
+	providerArgs(o) {
+		const cfg = this.providers;
+		const adapter = [o.main, o.guard].find((s) => s?.provider === "redstone")?.adapterId ?? cfg.redstoneAdapter;
+		const pythFeed = [o.main, o.guard].find((s) => s?.provider === "pyth")?.feedId;
+		const byFeed = Object.fromEntries(Object.entries(cfg.pythPriceInfoObjects).map(([k, v]) => [k.toLowerCase(), v]));
+		const pythInfo = pythFeed ? byFeed[pythFeed.toLowerCase()] : Object.values(cfg.pythPriceInfoObjects)[0];
+		if (!pythInfo) throw new Error(`no Pyth PriceInfoObject configured for feed ${pythFeed ?? "(any)"} (config.oracle.pythPriceInfoObjects)`);
+		return {
+			adapter: normalizeSuiObjectId(adapter),
+			pythInfo: normalizeSuiObjectId(pythInfo)
+		};
+	}
+	async quote(o, fn) {
+		const pkg = this.ctx.config.packages.oracle.packageId;
+		const { adapter, pythInfo } = this.providerArgs(o);
+		const res = await simulateView(this.ctx.client, (tx) => {
+			tx.moveCall({
+				target: `${pkg}::view::${fn}`,
+				arguments: [
+					tx.object(o.id),
+					tx.object(adapter),
+					tx.object(pythInfo),
+					tx.object.clock()
+				]
+			});
+		});
+		const q = PriceQuote.parse(res[0][0]);
+		const r = fn === "get_exchange_rate_operate" ? q.rate_operate : q.rate_liquidate;
+		if (r == null) throw new Error(`${fn} returned no rate`);
+		return BigInt(r);
+	}
+	/** Price exactly as vaults see it. v2: operate and liquidate simulated separately (one can abort alone). */
+	async getOraclePrice(oracleId) {
+		const id = normalizeSuiObjectId(oracleId);
+		const o = await this.getOracle(id);
+		const [op, liq] = await Promise.allSettled([this.quote(o, "get_exchange_rate_operate"), this.quote(o, "get_exchange_rate_liquidate")]);
+		return {
+			oracle: id,
+			operate: op.status === "fulfilled" ? op.value : null,
+			liquidate: liq.status === "fulfilled" ? liq.value : null,
+			...op.status === "rejected" ? { operateError: abortText(op.reason) } : {},
+			...liq.status === "rejected" ? { liquidateError: abortText(liq.reason) } : {}
+		};
+	}
+	/**
+	* Each v2 route read on its own, at the chain's clock: raw price, 1e15 rate, age, and whether it
+	* passes the operate / liquidate checks (`*_core::reading_error`, mirrored off-chain).
+	* Operate price = min over routes; liquidate = min over routes usable for liquidate.
+	*/
+	async getOracleRoutes(oracleId) {
+		const o = await this.getOracle(oracleId);
+		const cfg = this.providers;
+		const { pythInfo } = this.providerArgs(o);
+		const redstone = [o.main, o.guard].filter((s) => s?.provider === "redstone");
+		const res = await simulateView(this.ctx.client, (tx) => {
+			tx.moveCall({
+				target: "0x2::clock::timestamp_ms",
+				arguments: [tx.object.clock()]
+			});
+			for (const s of redstone) {
+				const feed = tx.pure.vector("u8", Array.from(Buffer.from(s.feedId.slice(2), "hex")));
+				tx.moveCall({
+					target: `${cfg.redstonePackage}::price_adapter::price_and_timestamp`,
+					arguments: [tx.object(s.adapterId), feed]
+				});
+				const feed2 = tx.pure.vector("u8", Array.from(Buffer.from(s.feedId.slice(2), "hex")));
+				tx.moveCall({
+					target: `${cfg.redstonePackage}::price_adapter::get_price_feed_write_timestamp`,
+					arguments: [tx.object(s.adapterId), feed2]
+				});
+			}
+		});
+		const nowMs = BigInt(bcs.u64().parse(res[0][0]));
+		const pyth = o.main.provider === "pyth" || o.guard?.provider === "pyth" ? PythPriceInfoObject.parse((await fetchObject(this.ctx.client, pythInfo, "PriceInfoObject")).content) : null;
+		let rsIdx = 0;
+		const route = (s) => {
+			const L = ORACLE_LIMITS;
+			if (s.provider === "redstone") {
+				const k = 1 + 2 * rsIdx++;
+				const value = BigInt(bcs.u256().parse(res[k][0]));
+				const dataTs = BigInt(bcs.u64().parse(res[k][1]));
+				const wts = bcs.option(bcs.u64()).parse(res[k + 1][0]);
+				const writeTs = wts == null ? dataTs : BigInt(wts);
+				const publishedMs = dataTs < writeTs ? dataTs : writeTs;
+				const ageS = nowMs >= publishedMs ? (nowMs - publishedMs) / 1000n : -1n;
+				const bad = value === 0n || value > 2n ** 64n - 1n;
+				const fresh = (max$1) => nowMs >= publishedMs && nowMs - publishedMs <= max$1 * 1000n;
+				return {
+					...s,
+					rawPrice: value,
+					decimals: L.redstoneDecimals,
+					rate: bad ? 0n : scaleAndInvert(value, L.redstoneDecimals, s.invert),
+					publishedMs,
+					ageS,
+					usableOperate: !bad && fresh(L.maxAgeOperateS),
+					usableLiquidate: !bad && fresh(L.maxAgeLiquidateS)
+				};
+			}
+			const info = pyth.price_info;
+			const feed = hex(info.price_feed.price_identifier.bytes);
+			if (feed.toLowerCase() !== s.feedId.toLowerCase()) throw new Error(`Pyth PriceInfoObject ${pythInfo} is feed ${feed}, oracle wants ${s.feedId}`);
+			const p = info.price_feed.price;
+			const mag = BigInt(p.price.magnitude);
+			const expoNeg = p.expo.negative;
+			const expo = BigInt(p.expo.magnitude);
+			const conf = BigInt(p.conf);
+			const publishedS = BigInt(p.timestamp);
+			const arrivalS = BigInt(info.arrival_time);
+			const nowS = nowMs / 1000n;
+			const decimals = expoNeg ? Number(expo) : 0;
+			const valid = !p.price.negative && mag > 0n && (expoNeg ? expo <= L.maxPythExponent : expo === 0n) && arrivalS <= publishedS + L.maxPythArrivalLagS;
+			const ok = (maxAge, confScale) => valid && nowS >= publishedS && nowS - publishedS <= maxAge && conf * confScale <= mag;
+			return {
+				...s,
+				rawPrice: mag,
+				decimals,
+				rate: valid ? scaleAndInvert(mag, decimals, s.invert) : 0n,
+				publishedMs: publishedS * 1000n,
+				ageS: nowS >= publishedS ? nowS - publishedS : -1n,
+				confidence: conf,
+				usableOperate: ok(L.maxAgeOperateS, L.confidenceScaleOperate),
+				usableLiquidate: ok(L.maxAgeLiquidateS, L.confidenceScaleLiquidate)
+			};
+		};
+		return {
+			oracle: o,
+			nowMs,
+			main: route(o.main),
+			guard: o.guard ? route(o.guard) : null
+		};
+	}
+	/** Human price (collateral priced in debt units) from a raw 1e15 rate. */
+	static toNumber(rate) {
+		return Number(rate) / Number(ORACLE_RATE_PRECISION);
+	}
+};
+
+//#endregion
+//#region src/math/vault.ts
+/** Vault maths: bit-exact ports of `fluid_vaults::exchange_price`, `position::get_position_info`
+*  and `operate_utils::fetch_latest_position`. */
+var vault_exports = /* @__PURE__ */ __exportAll({
+	BRANCH_STATUS: () => BRANCH_STATUS,
+	currentPositionState: () => currentPositionState,
+	fetchLatestPosition: () => fetchLatestPosition,
+	loadVaultExchangePrices: () => loadVaultExchangePrices,
+	minimumDebt: () => minimumDebt,
+	needsLiquidationSettle: () => needsLiquidationSettle,
+	positionInfo: () => positionInfo,
+	rawToNormal: () => rawToNormal,
+	unscale: () => unscale
+});
+const BRANCH_STATUS = {
+	NotLiquidated: 0,
+	Liquidated: 1,
+	Merged: 2,
+	Closed: 3
+};
+function rateChange(oldPrice, timeDiff, magnitude) {
+	return oldPrice * timeDiff * magnitude / FOUR_DECIMALS / SECONDS_PER_YEAR;
+}
+/** `exchange_price::load_exchange_prices` → `(vaultSupplyExPrice, vaultBorrowExPrice)`. */
+function loadVaultExchangePrices(p) {
+	if (p.liqSupplyExPrice < p.oldLiqSupplyExPrice || p.liqBorrowExPrice < p.oldLiqBorrowExPrice) throw new RangeError("liquidity exchange price went backwards");
+	const S = EXCHANGE_PRICE_SCALE_FACTOR;
+	let supply = mulDiv(p.vaultSupplyExPrice, mulDiv(p.liqSupplyExPrice, S, p.oldLiqSupplyExPrice), S);
+	if (p.supplyRateMagnifier !== 0n) {
+		const ch = rateChange(p.vaultSupplyExPrice, p.timeDiff, abs(p.supplyRateMagnifier));
+		supply = p.supplyRateMagnifier < 0n ? supply - ch : supply + ch;
+	}
+	let borrow = mulDivCeil(p.vaultBorrowExPrice, mulDiv(p.liqBorrowExPrice, S, p.oldLiqBorrowExPrice), S);
+	if (p.borrowRateMagnifier !== 0n) {
+		const ch = rateChange(p.vaultBorrowExPrice, p.timeDiff, abs(p.borrowRateMagnifier));
+		borrow = p.borrowRateMagnifier < 0n ? borrow - ch : borrow + ch;
+	}
+	return {
+		vaultSupplyExchangePrice: supply,
+		vaultBorrowExchangePrice: borrow
+	};
+}
+const abs = (x) => x < 0n ? -x : x;
+/** `position::get_position_info`: (colRaw, dustDebtRaw, debtRaw, tick, tickId). Debt is rounded up. */
+function positionInfo(pos) {
+	const colRaw = pos.supplyAmount;
+	const dustDebtRaw = pos.dustDebtAmount;
+	const tick = pos.isSupplyOnlyPosition ? COLD_TICK : pos.tick;
+	const tickId = pos.isSupplyOnlyPosition ? 0 : pos.tickId;
+	return {
+		colRaw,
+		dustDebtRaw,
+		debtRaw: tick > COLD_TICK ? (getRatioAtTick(tick) * (colRaw + 1n) >> SHIFT) + 1n : 0n,
+		tick,
+		tickId
+	};
+}
+/**
+* `operate_utils::fetch_latest_position`: the position's debt/col after liquidations, as
+* `operate` would settle it. `debtRaw` is the position's pre-liquidation raw debt.
+*/
+function fetchLatestPosition(debtRaw, tickId, l) {
+	let isFullyLiquidated;
+	let branchId;
+	let connectionFactor;
+	if (l.tick.totalIds === tickId) {
+		isFullyLiquidated = l.tick.isFullyLiquidated;
+		branchId = l.tick.liquidationBranchId;
+		connectionFactor = l.tick.debtFactor;
+	} else {
+		if (!l.snap) throw new Error(`missing liquidation snapshot for tick id ${tickId}`);
+		isFullyLiquidated = l.snap.isFullyLiquidated;
+		branchId = l.snap.liquidationBranchId;
+		connectionFactor = l.snap.debtFactor;
+	}
+	if (isFullyLiquidated) return {
+		tick: COLD_TICK,
+		colRaw: 0n,
+		debtRaw: 0n,
+		branchId
+	};
+	let factor = connectionFactor;
+	let branch = l.branch(branchId);
+	while (branch.status === BRANCH_STATUS.Merged) {
+		factor = mulBigNumber(factor, branch.debtFactor);
+		if (factor === MAX_MASK_DEBT_FACTOR) break;
+		branchId = branch.connectedBranchId;
+		branch = l.branch(branchId);
+	}
+	if (branch.status === BRANCH_STATUS.Closed || factor === MAX_MASK_DEBT_FACTOR) return {
+		tick: COLD_TICK,
+		colRaw: 0n,
+		debtRaw: 0n,
+		branchId
+	};
+	let posDebt = mulDivNormal(debtRaw, branch.debtFactor, factor);
+	posDebt = posDebt > debtRaw / 100n ? mulDiv(posDebt, FOUR_DECIMALS - 1n, FOUR_DECIMALS) : 0n;
+	if (posDebt === 0n) return {
+		tick: COLD_TICK,
+		colRaw: 0n,
+		debtRaw: 0n,
+		branchId
+	};
+	const tick = branch.minimaTick;
+	const ratioAtTick = getRatioAtTick(tick);
+	const ratioOneLess = mulDiv(ratioAtTick, FOUR_DECIMALS, TICK_SPACING);
+	const finalRatio = ratioOneLess + mulDiv(ratioAtTick - ratioOneLess, BigInt(branch.minimaTickPartials), X30);
+	return {
+		tick,
+		colRaw: mulDiv(posDebt, ZERO_TICK_SCALED_RATIO, finalRatio),
+		debtRaw: posDebt,
+		branchId
+	};
+}
+/** Whether `operate` would run `fetch_latest_position` for this position. */
+const needsLiquidationSettle = (tick, tickId) => tick.isLiquidated || tick.totalIds > tickId;
+/** Current raw state of a position (Solana `getCurrentPositionState`). */
+function currentPositionState(pos, lookups, debtDecimals = 9) {
+	const info = positionInfo(pos);
+	if (pos.isSupplyOnlyPosition || info.tick === COLD_TICK) return {
+		tick: COLD_TICK,
+		tickId: 0,
+		colRaw: info.colRaw,
+		debtRaw: 0n,
+		dustDebtRaw: 0n,
+		finalAmount: info.colRaw,
+		isSupplyOnlyPosition: pos.isSupplyOnlyPosition,
+		userLiquidationStatus: false,
+		postLiquidationBranchId: 0
+	};
+	let { colRaw, debtRaw, tick } = info;
+	let dustDebtRaw = info.dustDebtRaw;
+	let liquidated = false;
+	let branchId = 0;
+	if (lookups && needsLiquidationSettle(lookups.tick, info.tickId)) {
+		liquidated = true;
+		const latest = fetchLatestPosition(debtRaw, info.tickId, lookups);
+		colRaw = latest.colRaw;
+		debtRaw = latest.debtRaw;
+		tick = latest.tick;
+		branchId = latest.branchId;
+		if (debtRaw < dustDebtRaw || debtRaw < 2n * minimumDebt(debtDecimals)) {
+			debtRaw = 0n;
+			colRaw = 0n;
+			dustDebtRaw = 0n;
+			tick = COLD_TICK;
+		}
+	}
+	const netDebt = debtRaw > dustDebtRaw ? debtRaw - dustDebtRaw : 0n;
+	return {
+		tick,
+		tickId: info.tickId,
+		colRaw,
+		debtRaw,
+		dustDebtRaw,
+		finalAmount: netDebt > 0n ? colRaw : 0n,
+		isSupplyOnlyPosition: false,
+		userLiquidationStatus: liquidated,
+		postLiquidationBranchId: branchId
+	};
+}
+/** raw (internal 1e9 space) → normal (still internal space) through a vault exchange price. */
+const rawToNormal = (raw, exPrice) => raw * exPrice / EXCHANGE_PRICES_PRECISION;
+/** `constants::get_minimum_debt(decimals)` in the internal 1e9 space. */
+const minimumDebt = (decimals) => (decimals >= 4 ? 1000n : 10n) * 10n ** BigInt(9 - decimals);
+/** Internal 1e9 space → token units (`constants::unscale_amounts`, floor). */
+const unscale = (amount, decimals) => amount / 10n ** BigInt(9 - decimals);
+
+//#endregion
+//#region src/positionIndex.ts
+/**
+* Per-vault position enumeration + counts on Sui.
+*
+* A `Position` is a derived object keyed by its (random) `PositionOwnerCap` id, and the deployed
+* `VaultMarket` carries no counter or list. So, unlike EVM (`totalPositions` = 32 bits of
+* `vaultVariables`, +1 per mint) and Solana (`next_position_id` in vault state), the deployed
+* Sui package gives NO way to enumerate positions from object state alone.
+*
+* Resolution order (the first one available under the client's `discovery` level wins):
+*
+* 1. "state"    - proposed on-chain `PositionIndex` dynamic field on the VaultMarket
+*                 (docs/onchain-position-index.md): counter + `Table<u64, ID>` of cap ids, all
+*                 read by DERIVED id. Pure state, no list query. Used automatically once shipped.
+* 2. "fullnode" - `listDynamicFields(vaultMarket)`: every position claims a
+*                 `0x2::derived_object::Claimed(position_id)` field on its VaultMarket, and the
+*                 claim is never removed (even after close/delete), so the claim set = every
+*                 position ever opened (EVM `totalPositions` semantics). Served by the fullnode
+*                 itself, same endpoints/failover as object reads.
+* 3. "indexer"  - GraphQL event scan (`LogPositionOpened` / `LogClosePosition`).
+*
+* In every tier, "open" is decided by object existence (close deletes the Position).
+* Under "state" with no on-chain index, `counts` throws `NeedsDiscoveryError`.
+*/
+const POSITION_INDEX_FIX = "add the PositionIndex dynamic field (next_position_id + Table<u64, ID> of cap ids, written in user::init_position) plus `vault_market::total_positions` / `next_position_id` getters, see docs/onchain-position-index.md";
+const CLAIMED = "0x0000000000000000000000000000000000000000000000000000000000000002::derived_object::Claimed";
+const QUERY = `query($t:String!,$a:String,$n:Int){events(filter:{type:$t},first:$n,after:$a){pageInfo{hasNextPage endCursor}nodes{sequenceNumber transaction{digest} contents{json}}}}`;
+var PositionIndex = class {
+	streams = /* @__PURE__ */ new Map();
+	inflight = /* @__PURE__ */ new Map();
+	constructor(ctx, opts = {}) {
+		this.ctx = ctx;
+		this.opts = opts;
+	}
+	/**
+	* Reads the proposed on-chain index by derived ids. `null` when the vault has no index yet.
+	* Returns ordinal -> cap id for every position ever opened, and the stored counter.
+	*/
+	async readOnchainIndex(vaultMarketId) {
+		const d = this.ctx.derive;
+		const [field] = await fetchObjects(this.ctx.client, [d.positionIndexId(vaultMarketId)]);
+		if (!field) return null;
+		const idx = PositionIndexField.parse(field.content).value;
+		const next = Number(idx.next_position_id);
+		const ordinals = Array.from({ length: Math.max(0, next - 1) }, (_, i) => i + 1);
+		return {
+			nextPositionId: next,
+			capIds: (await fetchObjects(this.ctx.client, ordinals.map((n) => d.positionIndexEntryId(idx.caps.id, n)))).map((e, i) => {
+				if (!e) throw new Error(`position index entry ${ordinals[i]} missing in ${idx.caps.id}`);
+				return normalizeSuiObjectId(PositionIndexEntry.parse(e.content).value);
+			})
+		};
+	}
+	/** Every position id ever claimed on `vaultMarketId` (`derived_object::Claimed` fields). */
+	async claimedIds(vaultMarketId) {
+		const ids = [];
+		let cursor = null;
+		do {
+			const page = await this.ctx.client.core.listDynamicFields({
+				parentId: vaultMarketId,
+				cursor,
+				limit: 50
+			});
+			for (const f of page.dynamicFields) {
+				const name = f.name;
+				if (normalizeClaimed(name.type) !== CLAIMED) continue;
+				ids.push(normalizeSuiObjectId("0x" + Buffer.from(name.bcs).toString("hex")));
+			}
+			cursor = page.hasNextPage ? page.cursor : null;
+		} while (cursor !== null);
+		return ids;
+	}
+	async counts(vaultId, vaultMarketId) {
+		const onchain = await this.readOnchainIndex(vaultMarketId);
+		if (onchain) {
+			const positionIds = onchain.capIds.map((cap) => this.ctx.derive.positionId(vaultMarketId, cap));
+			return this.finish(vaultId, positionIds, onchain.nextPositionId, "state");
+		}
+		if (this.ctx.allows("fullnode")) {
+			const claimed = await this.claimedIds(vaultMarketId);
+			return this.finish(vaultId, claimed, claimed.length + 1, "fullnode-index");
+		}
+		if (this.ctx.allows("indexer")) {
+			const [opened, closed] = await Promise.all([this.openedIds(vaultMarketId), this.closedIds(vaultId)]);
+			return {
+				...await this.finish(vaultId, opened.filter((id) => !closed.has(id)), opened.length + 1, "events+objects"),
+				totalPositions: opened.length
+			};
+		}
+		throw new NeedsDiscoveryError(`positions of vault ${vaultId}`, "fullnode", POSITION_INDEX_FIX);
+	}
+	async finish(vaultId, everOpened, next, source) {
+		const objs = await fetchObjects(this.ctx.client, everOpened);
+		const openPositionIds = everOpened.filter((_, i) => objs[i] !== null);
+		return {
+			vaultId,
+			totalPositions: everOpened.length,
+			openPositions: openPositionIds.length,
+			nextPositionId: next,
+			openPositionIds,
+			source
+		};
+	}
+	/** Lowest discovery level `counts` would need right now for this vault. */
+	async requiredLevel(vaultMarketId) {
+		return await this.readOnchainIndex(vaultMarketId) ? "state" : "fullnode";
+	}
+	get url() {
+		const u = this.opts.graphqlUrl ?? this.ctx.config.graphqlUrl;
+		if (!u) throw new Error("graphqlUrl required for event scans (config.graphqlUrl or PositionIndex opts)");
+		return u;
+	}
+	type(name) {
+		return `${this.ctx.config.packages.vaults.originalId}::events::${name}`;
+	}
+	async post(body) {
+		const f = this.opts.fetchImpl ?? fetch;
+		const retries = this.opts.retries ?? 4;
+		const base = this.opts.backoffMs ?? 400;
+		let last;
+		for (let attempt = 0; attempt <= retries; attempt++) try {
+			const res = await f(this.url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(body)
+			});
+			if (res.status === 429 || res.status >= 500) throw new Error(`graphql ${res.status}`);
+			if (!res.ok) throw Object.assign(/* @__PURE__ */ new Error(`graphql ${res.status}`), { fatal: true });
+			const j = await res.json();
+			if (!j.data) throw new Error(`graphql error: ${JSON.stringify(j.errors)}`);
+			return j.data;
+		} catch (e) {
+			last = e;
+			if (e.fatal || attempt === retries) break;
+			await new Promise((r) => setTimeout(r, base * 2 ** attempt));
+		}
+		throw last;
+	}
+	/** All events of `type`, resuming from the last cursor. Concurrent callers share one scan. */
+	sync(type) {
+		const running = this.inflight.get(type);
+		if (running) return running;
+		const p = (async () => {
+			const s = this.streams.get(type) ?? {
+				cursor: null,
+				seen: /* @__PURE__ */ new Set(),
+				events: []
+			};
+			this.streams.set(type, s);
+			for (;;) {
+				const page = (await this.post({
+					query: QUERY,
+					variables: {
+						t: type,
+						a: s.cursor,
+						n: this.opts.pageSize ?? 50
+					}
+				})).events;
+				for (const n of page.nodes) {
+					const key = `${n.transaction?.digest ?? "?"}:${n.sequenceNumber}`;
+					if (s.seen.has(key)) continue;
+					s.seen.add(key);
+					s.events.push({
+						key,
+						json: n.contents.json
+					});
+				}
+				if (page.pageInfo.endCursor) s.cursor = page.pageInfo.endCursor;
+				if (!page.pageInfo.hasNextPage) return s.events;
+			}
+		})().finally(() => this.inflight.delete(type));
+		this.inflight.set(type, p);
+		return p;
+	}
+	/** Every position id ever opened in `vaultMarketId` (event order, deduped). Indexer tier. */
+	async openedIds(vaultMarketId) {
+		const vm = normalizeSuiObjectId(vaultMarketId);
+		const ids = /* @__PURE__ */ new Set();
+		for (const e of await this.sync(this.type("LogPositionOpened"))) if (normalizeSuiObjectId(String(e.json.vault)) === vm) ids.add(normalizeSuiObjectId(String(e.json.position)));
+		return [...ids];
+	}
+	/** Position ids with a `LogClosePosition` for numeric `vaultId`. Indexer tier. */
+	async closedIds(vaultId) {
+		const out = /* @__PURE__ */ new Set();
+		for (const e of await this.sync(this.type("LogClosePosition"))) if (Number(e.json.vault_id) === vaultId) out.add(normalizeSuiObjectId(String(e.json.position_id)));
+		return out;
+	}
+	/** Drop cached cursors (forces a full rescan next call). */
+	reset() {
+		this.streams.clear();
+	}
+};
+function normalizeClaimed(t) {
+	return /^0x0*2::derived_object::Claimed$/.exec(t) ? CLAIMED : t;
+}
+
+//#endregion
+//#region src/vault.ts
+/**
+* Vault resolver: mirrors `@jup-ag/lend-read` `Vault`.
+* Units: like Solana, vault amounts (position supply/borrow, vault totals, absorbed) are in the
+* vault's internal 1e9 space (`constants::scale_amounts`); liquidity-side amounts
+* (`totalSupplyLiquidityOrDex`, limits) are in token units. Use `unscale()` to convert.
+*/
+const TickField = Field(MoveTick, VaultTick);
+const BranchField = Field(bcsU64, Branch);
+const SnapField = Field(TickIdLiquidationKey, TickIdLiquidation);
+const BitmapField = Field(bcsU16, bcsU256);
+const magnifier = (m) => m.negative ? -BigInt(m.magnitude) : BigInt(m.magnitude);
+const BRANCH_STATUS_INDEX = {
+	NotLiquidated: 0,
+	Liquidated: 1,
+	Merged: 2,
+	Closed: 3
+};
+function decodeTick(o) {
+	const t = TickField.parse(o.content).value;
+	return {
+		isLiquidated: t.is_liquidated,
+		totalIds: t.total_ids,
+		rawDebt: BigInt(t.raw_debt),
+		isFullyLiquidated: t.is_fully_liquidated,
+		liquidationBranchId: Number(t.liquidation_branch_id),
+		debtFactor: BigInt(t.debt_factor)
+	};
+}
+function decodeBranch(o) {
+	const f = BranchField.parse(o.content);
+	const b = f.value;
+	return {
+		branchId: Number(f.name),
+		status: BRANCH_STATUS_INDEX[b.status.$kind],
+		minimaTick: tickFromMove(b.minima_tick),
+		minimaTickPartials: b.minima_tick_partials,
+		debtLiquidity: BigInt(b.debt_liquidity),
+		debtFactor: BigInt(b.debt_factor),
+		connectedBranchId: Number(b.connected_branch_id),
+		connectedMinimaTick: tickFromMove(b.connected_minima_tick)
+	};
+}
+function decodePosition(o, vaultId) {
+	const p = Position.parse(o.content);
+	return {
+		vaultId,
+		positionId: p.id,
+		vault: p.vault_id,
+		positionMint: p.position_mint,
+		isSupplyOnlyPosition: p.is_supply_only_position,
+		tick: tickFromMove(p.tick),
+		tickId: p.tick_id,
+		supplyAmount: BigInt(p.supply_amount),
+		dustDebtAmount: BigInt(p.dust_debt_amount)
+	};
+}
+var Vault = class {
+	/** Derived per-vault position counts (no counter exists on-chain on Sui). */
+	positions;
+	constructor(ctx, liquidity, oracle) {
+		this.ctx = ctx;
+		this.liquidity = liquidity;
+		this.oracle = oracle;
+		this.positions = new PositionIndex(ctx);
+	}
+	/**
+	* totalPositions (ever opened, EVM parity), openPositions (object exists now), nextPositionId
+	* (stored counter once the on-chain index ships, else totalPositions + 1). Pure state when the
+	* vault has the on-chain index; otherwise needs `discovery: "fullnode"` (derived_object claims)
+	* or "indexer" (events), and throws `NeedsDiscoveryError` under the default "state".
+	*/
+	async getVaultPositionCounts(vaultId) {
+		return this.positions.counts(vaultId, this.ctx.derive.vaultMarketId(vaultId));
+	}
+	/** Counts for state fills: never lets an event-endpoint outage break a vault read (-1 then). */
+	async countsOrNull(vaults, want) {
+		if (want === false) return vaults.map(() => null);
+		return Promise.all(vaults.map((v) => this.positions.counts(v.vaultId, v.id).catch(() => null)));
+	}
+	async getTotalVaults() {
+		const o = await fetchObject(this.ctx.client, this.ctx.config.objects.vaultRegistry, "VaultRegistry");
+		return Number(VaultRegistry.parse(o.content).next_vault_id) - 1;
+	}
+	async loadVaults(vaultIds) {
+		const ids = vaultIds.map((v) => this.ctx.derive.vaultMarketId(v));
+		return (await fetchObjects(this.ctx.client, ids)).map((o, i) => {
+			if (!o) throw new Error(`vault ${vaultIds[i]} not found (${ids[i]})`);
+			const [col, debt] = parseStructTag(o.type).typeParams;
+			return {
+				vaultId: vaultIds[i],
+				id: o.objectId,
+				collateralType: normalizeStructTag(col),
+				debtType: normalizeStructTag(debt),
+				raw: VaultMarket.parse(o.content)
+			};
+		});
+	}
+	async loadVault(vaultId) {
+		return (await this.loadVaults([vaultId]))[0];
+	}
+	configFromRecord(v) {
+		const r = v.raw;
+		return {
+			vaultId: v.vaultId,
+			vault: v.id,
+			supplyRateMagnifier: Number(magnifier(r.supply_rate_magnifier)),
+			borrowRateMagnifier: Number(magnifier(r.borrow_rate_magnifier)),
+			collateralFactor: r.risk.collateral_factor,
+			liquidationThreshold: r.risk.liquidation_threshold,
+			liquidationMaxLimit: r.risk.liquidation_max_limit,
+			withdrawGap: r.risk.withdraw_gap,
+			liquidationPenalty: r.risk.liquidation_penalty,
+			borrowFee: r.risk.borrow_fee,
+			oracle: r.oracle,
+			liquidityProgram: r.liquidity_program,
+			oracleProgram: this.ctx.config.packages.oracle.packageId,
+			supplyToken: v.collateralType,
+			borrowToken: v.debtType,
+			vaultType: r.vault_type,
+			collateralDecimals: r.col_decimals,
+			debtDecimals: r.debt_decimals
+		};
+	}
+	async getVaultConfig(vaultId) {
+		return this.configFromRecord(await this.loadVault(vaultId));
+	}
+	async batchGetTicks(vaultId, ticks) {
+		const v = await this.loadVault(vaultId);
+		return this.ticksOf(v, ticks);
+	}
+	async ticksOf(v, ticks) {
+		return (await fetchObjects(this.ctx.client, ticks.map((t) => this.ctx.derive.tickEntryId(v.raw.ticks.id, t)))).map((o) => o ? decodeTick(o) : null);
+	}
+	async getTick({ vaultId, tick }) {
+		return (await this.batchGetTicks(vaultId, [tick]))[0];
+	}
+	async batchGetBranches(vaultId, branchIds) {
+		return this.branchesOf(await this.loadVault(vaultId), branchIds);
+	}
+	async branchesOf(v, branchIds) {
+		return (await fetchObjects(this.ctx.client, branchIds.map((b) => this.ctx.derive.branchEntryId(v.raw.branches.id, b)))).map((o) => o ? decodeBranch(o) : null);
+	}
+	async getBranch({ vaultId, branchId }) {
+		return (await this.batchGetBranches(vaultId, [branchId]))[0];
+	}
+	/** Branches 1..total_branch_id. */
+	async getAllBranches(vaultId) {
+		const v = await this.loadVault(vaultId);
+		const n = Number(v.raw.total_branch_id);
+		const ids = Array.from({ length: n }, (_, i) => i + 1);
+		return (await this.branchesOf(v, ids)).filter((b) => b !== null);
+	}
+	async getTickIdLiquidation({ vaultId, tick, tickId }) {
+		const v = await this.loadVault(vaultId);
+		const [o] = await fetchObjects(this.ctx.client, [this.ctx.derive.liqSnapEntryId(v.raw.liq_snaps.id, tick, tickId)]);
+		if (!o) return null;
+		const s = SnapField.parse(o.content).value;
+		return {
+			isFullyLiquidated: s.is_fully_liquidated,
+			liquidationBranchId: Number(s.liquidation_branch_id),
+			debtFactor: BigInt(s.debt_factor)
+		};
+	}
+	/** Raw `tick_bitmap` words (u256) for `words`; missing words = 0. */
+	async getTickHasDebtArray(vaultId, words) {
+		const v = await this.loadVault(vaultId);
+		const objs = await fetchObjects(this.ctx.client, words.map((w) => this.ctx.derive.bitmapWordId(v.raw.tick_bitmap.id, w)));
+		return words.map((word, i) => ({
+			word,
+			bitmap: objs[i] ? BigInt(BitmapField.parse(objs[i].content).value) : 0n
+		}));
+	}
+	stateFromRecord(v, branch, counts = null) {
+		const r = v.raw;
+		let currentBranchState;
+		if (branch) currentBranchState = {
+			status: branch.status,
+			minimaTick: branch.minimaTick,
+			debtFactor: branch.debtFactor,
+			partials: BigInt(branch.minimaTickPartials),
+			debtLiquidity: branch.debtLiquidity,
+			baseBranchId: branch.connectedBranchId,
+			baseBranchMinima: branch.connectedMinimaTick
+		};
+		return {
+			topTick: tickFromMove(r.topmost_tick),
+			currentBranch: Number(r.current_branch_id),
+			totalBranch: Number(r.total_branch_id),
+			totalSupply: BigInt(r.total_supply),
+			totalBorrow: BigInt(r.total_borrow),
+			totalPositions: counts?.totalPositions ?? -1,
+			currentBranchState,
+			branchLiquidated: r.branch_liquidated,
+			absorbedDebtAmount: BigInt(r.absorbed_debt_amount),
+			absorbedColAmount: BigInt(r.absorbed_col_amount),
+			absorbedDustDebt: BigInt(r.absorbed_dust_debt),
+			liquiditySupplyExchangePrice: BigInt(r.liquidity_supply_exchange_price),
+			liquidityBorrowExchangePrice: BigInt(r.liquidity_borrow_exchange_price),
+			vaultSupplyExchangePrice: BigInt(r.vault_supply_exchange_price),
+			vaultBorrowExchangePrice: BigInt(r.vault_borrow_exchange_price),
+			nextPositionId: counts?.nextPositionId ?? -1,
+			lastUpdateTimestamp: BigInt(r.last_update_timestamp)
+		};
+	}
+	async getVaultState(vaultId, opts = {}) {
+		const v = await this.loadVault(vaultId);
+		const [[branch], [counts]] = await Promise.all([this.branchesOf(v, [Number(v.raw.current_branch_id)]), this.countsOrNull([v], opts.positionCounts)]);
+		return this.stateFromRecord(v, branch ?? null, counts ?? null);
+	}
+	/** `user::get_exchange_prices`: (liqSupply, liqBorrow, vaultSupply, vaultBorrow) accrued to `now`. */
+	exchangePricesFromRecords(v, colReserve, debtReserve, now) {
+		const r = v.raw;
+		const liqSupply = calculateExchangePrice(colReserve.snapshot, now, this.ctx.math).supplyExchangePrice;
+		const liqBorrow = calculateExchangePrice(debtReserve.snapshot, now, this.ctx.math).borrowExchangePrice;
+		const last = BigInt(r.last_update_timestamp);
+		const vp = loadVaultExchangePrices({
+			vaultSupplyExPrice: BigInt(r.vault_supply_exchange_price),
+			vaultBorrowExPrice: BigInt(r.vault_borrow_exchange_price),
+			oldLiqSupplyExPrice: BigInt(r.liquidity_supply_exchange_price),
+			oldLiqBorrowExPrice: BigInt(r.liquidity_borrow_exchange_price),
+			liqSupplyExPrice: liqSupply,
+			liqBorrowExPrice: liqBorrow,
+			timeDiff: now > last ? now - last : 0n,
+			supplyRateMagnifier: magnifier(r.supply_rate_magnifier),
+			borrowRateMagnifier: magnifier(r.borrow_rate_magnifier)
+		});
+		return {
+			liquiditySupplyExchangePrice: liqSupply,
+			liquidityBorrowExchangePrice: liqBorrow,
+			vaultSupplyExchangePrice: vp.vaultSupplyExchangePrice,
+			vaultBorrowExchangePrice: vp.vaultBorrowExchangePrice
+		};
+	}
+	/** Full vault view. `withOracle` (default true) adds the oracle price via one simulation. */
+	async getVaultEntireData(vaultId, opts = {}) {
+		return (await this.entireDataFor([await this.loadVault(vaultId)], opts))[0];
+	}
+	async getVaultEntireDataV2(vaultId, opts = {}) {
+		return this.toV2(await this.getVaultEntireData(vaultId, opts));
+	}
+	async getAllVaults(opts = {}) {
+		const n = await this.getTotalVaults();
+		if (n <= 0) return [];
+		const recs = await this.loadVaults(Array.from({ length: n }, (_, i) => i + 1));
+		return this.entireDataFor(recs, opts);
+	}
+	async getAllVaultsV2(opts = {}) {
+		return (await this.getAllVaults(opts)).map((v) => this.toV2(v));
+	}
+	getVaultByVaultId = (vaultId) => this.getVaultEntireData(vaultId);
+	toV2(d) {
+		return {
+			...d,
+			vaultId: d.constantViews.vaultId,
+			vaultType: d.constantViews.vaultType,
+			supplyDex: null,
+			borrowDex: null,
+			supplyDexPosition: null,
+			borrowDexPosition: null
+		};
+	}
+	async entireDataFor(vaults, opts) {
+		const nowP = this.ctx.now();
+		const tokens = [...new Set(vaults.flatMap((v) => [v.collateralType, v.debtType]))];
+		const reserves = new Map((await this.liquidity.loadReserves(tokens)).map((r) => [r.token, r]));
+		const pairs = vaults.flatMap((v) => [{
+			holder: v.id,
+			reserve: reserves.get(v.collateralType)
+		}, {
+			holder: v.id,
+			reserve: reserves.get(v.debtType)
+		}]);
+		const [entries, branches, prices, counts] = await Promise.all([
+			this.liquidity.loadUserEntries(pairs),
+			fetchObjects(this.ctx.client, vaults.map((v) => this.ctx.derive.branchEntryId(v.raw.branches.id, v.raw.current_branch_id))),
+			opts.withOracle === false ? Promise.resolve(vaults.map(() => null)) : Promise.all(vaults.map((v) => this.oracle.getOraclePrice(v.raw.oracle).catch(() => null))),
+			this.countsOrNull(vaults, opts.positionCounts)
+		]);
+		const now = await nowP;
+		return vaults.map((v, i) => {
+			const col = reserves.get(v.collateralType);
+			const debt = reserves.get(v.debtType);
+			const sup = this.liquidity.supplyDataFromRecords(col, entries[2 * i].supply, now);
+			const bor = this.liquidity.borrowDataFromRecords(debt, entries[2 * i + 1].borrow, now);
+			const ep = this.exchangePricesFromRecords(v, col, debt, now);
+			const cfg = this.configFromRecord(v);
+			const state = this.stateFromRecord(v, branches[i] ? decodeBranch(branches[i]) : null, counts[i] ?? null);
+			const price = prices[i];
+			const supMag = BigInt(cfg.supplyRateMagnifier);
+			const borMag = BigInt(cfg.borrowRateMagnifier);
+			const exchangePricesAndRates = {
+				lastStoredLiquiditySupplyExchangePrice: state.liquiditySupplyExchangePrice,
+				lastStoredLiquidityBorrowExchangePrice: state.liquidityBorrowExchangePrice,
+				lastStoredVaultSupplyExchangePrice: state.vaultSupplyExchangePrice,
+				lastStoredVaultBorrowExchangePrice: state.vaultBorrowExchangePrice,
+				...ep,
+				supplyRateLiquidity: sup.overallTokenData.supplyRate,
+				borrowRateLiquidity: bor.overallTokenData.borrowRate,
+				supplyRateVault: sup.overallTokenData.supplyRate + supMag,
+				borrowRateVault: bor.overallTokenData.borrowRate + borMag,
+				rewardsOrFeeRateSupply: supMag,
+				rewardsOrFeeRateBorrow: borMag
+			};
+			const limits = {
+				withdrawLimit: 0n,
+				withdrawableUntilLimit: 0n,
+				withdrawable: 0n,
+				borrowLimit: 0n,
+				borrowLimitUtilization: 0n,
+				borrowableUntilLimit: 0n,
+				borrowable: 0n,
+				minimumBorrowing: rawToNormal(minimumDebt(cfg.debtDecimals), ep.vaultBorrowExchangePrice)
+			};
+			const us = sup.userSupplyData;
+			if (us.supply > 0n) {
+				limits.withdrawLimit = us.withdrawalLimit;
+				const gap = us.supply * BigInt(cfg.withdrawGap) / 1000n;
+				limits.withdrawableUntilLimit = us.withdrawableUntilLimit > gap ? (us.withdrawableUntilLimit - gap) * 999999n / 1000000n : 0n;
+				limits.withdrawable = col.snapshot.vaultBalance < limits.withdrawableUntilLimit ? col.snapshot.vaultBalance : limits.withdrawableUntilLimit;
+			}
+			const ub = bor.userBorrowData;
+			if (ub.borrow > 0n) {
+				limits.borrowLimit = ub.borrowLimit;
+				limits.borrowLimitUtilization = ub.borrowLimitUtilization;
+				limits.borrowableUntilLimit = ub.borrowableUntilLimit * 999999n / 1000000n;
+				limits.borrowable = debt.snapshot.vaultBalance < limits.borrowableUntilLimit ? debt.snapshot.vaultBalance : limits.borrowableUntilLimit;
+			}
+			return {
+				vault: v.id,
+				isSmartCol: false,
+				isSmartDebt: false,
+				constantViews: {
+					liquidity: v.raw.liquidity_program,
+					supply: col.id,
+					borrow: debt.id,
+					supplyToken: v.collateralType,
+					borrowToken: v.debtType,
+					vaultId: v.vaultId,
+					vaultType: v.raw.vault_type
+				},
+				configs: {
+					supplyRateMagnifier: supMag,
+					borrowRateMagnifier: borMag,
+					collateralFactor: BigInt(cfg.collateralFactor),
+					liquidationThreshold: BigInt(cfg.liquidationThreshold),
+					liquidationMaxLimit: BigInt(cfg.liquidationMaxLimit),
+					withdrawalGap: BigInt(cfg.withdrawGap),
+					liquidationPenalty: BigInt(cfg.liquidationPenalty),
+					borrowFee: BigInt(cfg.borrowFee),
+					oracle: cfg.oracle,
+					...price?.operate != null ? { oraclePriceOperate: price.operate } : {},
+					...price?.liquidate != null ? { oraclePriceLiquidate: price.liquidate } : {},
+					lastUpdateTimestamp: state.lastUpdateTimestamp
+				},
+				exchangePricesAndRates,
+				limitsAndAvailability: limits,
+				liquidityUserSupplyData: us,
+				liquidityUserBorrowData: ub,
+				vaultState: state,
+				totalSupplyAndBorrow: {
+					totalSupplyVault: rawToNormal(state.totalSupply, ep.vaultSupplyExchangePrice),
+					totalBorrowVault: rawToNormal(state.totalBorrow, ep.vaultBorrowExchangePrice),
+					totalSupplyLiquidityOrDex: us.supply,
+					totalBorrowLiquidityOrDex: ub.borrow,
+					absorbedSupply: rawToNormal(state.absorbedColAmount, ep.vaultSupplyExchangePrice),
+					absorbedBorrow: rawToNormal(state.absorbedDebtAmount, ep.vaultBorrowExchangePrice)
+				}
+			};
+		});
+	}
+	/** Raw Position object. `vaultId` is resolved from the position's VaultMarket if omitted. */
+	async getUserPosition({ positionId, vaultId }) {
+		const [o] = await fetchObjects(this.ctx.client, [normalizeSuiObjectId(positionId)]);
+		if (!o) return null;
+		const p = decodePosition(o, vaultId ?? 0);
+		if (vaultId === void 0) p.vaultId = await this.vaultIdOf(p.vault);
+		return p;
+	}
+	async batchGetUserPositions(positionIds) {
+		const out = (await fetchObjects(this.ctx.client, positionIds.map((p) => normalizeSuiObjectId(p)))).map((o) => o ? decodePosition(o, 0) : null);
+		const vaultIds = /* @__PURE__ */ new Map();
+		for (const p of out) if (p && !vaultIds.has(p.vault)) vaultIds.set(p.vault, await this.vaultIdOf(p.vault));
+		for (const p of out) if (p) p.vaultId = vaultIds.get(p.vault);
+		return out;
+	}
+	async vaultIdOf(vaultMarketId) {
+		const o = await fetchObject(this.ctx.client, vaultMarketId, "VaultMarket");
+		return Number(VaultMarket.parse(o.content).vault_id);
+	}
+	/** Everything `fetch_latest_position` needs for one position (tick, snapshot, branch chain). */
+	async liquidationLookups(v, pos) {
+		if (pos.isSupplyOnlyPosition || pos.tick === COLD_TICK) return null;
+		const [tick] = await this.ticksOf(v, [pos.tick]);
+		if (!tick) throw new Error(`tick ${pos.tick} missing in vault ${v.vaultId}`);
+		if (!needsLiquidationSettle(tick, pos.tickId)) return {
+			tick,
+			branch: () => {
+				throw new Error("unused");
+			}
+		};
+		let snap = null;
+		if (tick.totalIds !== pos.tickId) {
+			const [o] = await fetchObjects(this.ctx.client, [this.ctx.derive.liqSnapEntryId(v.raw.liq_snaps.id, pos.tick, pos.tickId)]);
+			if (o) {
+				const s = SnapField.parse(o.content).value;
+				snap = {
+					isFullyLiquidated: s.is_fully_liquidated,
+					liquidationBranchId: Number(s.liquidation_branch_id),
+					debtFactor: BigInt(s.debt_factor)
+				};
+			}
+		}
+		const n = Number(v.raw.total_branch_id);
+		const all = await this.branchesOf(v, Array.from({ length: n }, (_, i) => i + 1));
+		const byId = new Map(all.filter((b) => b !== null).map((b) => [b.branchId, b]));
+		return {
+			tick,
+			snap,
+			branch: (id) => {
+				const b = byId.get(id);
+				if (!b) throw new Error(`branch ${id} missing in vault ${v.vaultId}`);
+				return b;
+			}
+		};
+	}
+	/** Solana `getCurrentPositionState`: raw col/debt after any liquidation, as operate would settle it. */
+	async getCurrentPositionState({ vaultId, position }) {
+		const v = await this.loadVault(vaultId);
+		return currentPositionState(position, await this.liquidationLookups(v, position), v.raw.debt_decimals);
+	}
+	async getFinalPosition({ vaultId, positionId }) {
+		const position = await this.getUserPosition({
+			vaultId,
+			positionId
+		});
+		if (!position) throw new Error(`position ${positionId} not found`);
+		return this.getCurrentPositionState({
+			vaultId,
+			position
+		});
+	}
+	/** Owner of a PositionOwnerCap (Solana `getNftOwner`). */
+	async getPositionOwner(capId) {
+		const [o] = await fetchObjects(this.ctx.client, [normalizeSuiObjectId(capId)]);
+		return o ? ownerAddress(o.owner) : null;
+	}
+	getNftOwner = (capId) => this.getPositionOwner(capId);
+	/** Solana `buildNftPositionFromPositionAccount` semantics, on a fetched vault context. */
+	async buildNftPosition(pos, v, vault, owner) {
+		const ep = vault.exchangePricesAndRates;
+		const out = {
+			nftId: pos.positionId,
+			owner: owner !== void 0 ? owner : await this.getPositionOwner(pos.positionMint),
+			capId: pos.positionMint,
+			isSupplyPosition: pos.isSupplyOnlyPosition,
+			supply: pos.supplyAmount,
+			beforeSupply: pos.supplyAmount,
+			dustBorrow: pos.dustDebtAmount,
+			beforeDustBorrow: pos.dustDebtAmount,
+			tick: pos.tick,
+			tickId: pos.tickId,
+			borrow: 0n,
+			beforeBorrow: 0n,
+			isLiquidated: false
+		};
+		if (!out.isSupplyPosition && pos.tick !== COLD_TICK) {
+			out.borrow = getRatioAtTick(pos.tick) * out.supply >> SHIFT;
+			out.beforeBorrow = out.borrow - out.dustBorrow;
+			const lookups = await this.liquidationLookups(v, pos);
+			if (lookups && needsLiquidationSettle(lookups.tick, pos.tickId)) {
+				out.isLiquidated = true;
+				const cur = currentPositionState(pos, lookups, v.raw.debt_decimals);
+				out.tick = cur.tick;
+				out.supply = cur.colRaw;
+				out.borrow = cur.debtRaw;
+				out.dustBorrow = cur.dustDebtRaw;
+			}
+			if (out.borrow > out.dustBorrow) out.borrow -= out.dustBorrow;
+			else {
+				out.borrow = 0n;
+				out.dustBorrow = 0n;
+			}
+		}
+		out.beforeSupply = rawToNormal(out.beforeSupply, ep.vaultSupplyExchangePrice);
+		out.beforeBorrow = rawToNormal(out.beforeBorrow, ep.vaultBorrowExchangePrice);
+		out.beforeDustBorrow = rawToNormal(out.beforeDustBorrow, ep.vaultBorrowExchangePrice);
+		out.supply = rawToNormal(out.supply, ep.vaultSupplyExchangePrice);
+		out.borrow = rawToNormal(out.borrow, ep.vaultBorrowExchangePrice);
+		out.dustBorrow = rawToNormal(out.dustBorrow, ep.vaultBorrowExchangePrice);
+		return out;
+	}
+	/** Solana `getPositionByVaultId(vaultId, nftId)`; Sui takes the Position object id. */
+	async getPositionByVaultId(vaultId, positionId) {
+		const pos = await this.getUserPosition({
+			vaultId,
+			positionId
+		});
+		if (!pos) throw new Error(`position ${positionId} not found`);
+		const v = await this.loadVault(vaultId);
+		if (normalizeSuiObjectId(pos.vault) !== v.id) throw new Error(`position ${positionId} is not in vault ${vaultId}`);
+		const vault = (await this.entireDataFor([v], {}))[0];
+		return {
+			...await this.buildNftPosition(pos, v, vault),
+			vault
+		};
+	}
+	async getPositionByVaultIdV2(vaultId, positionId) {
+		const p = await this.getPositionByVaultId(vaultId, positionId);
+		return {
+			...p,
+			vault: this.toV2(p.vault)
+		};
+	}
+	/**
+	* Every position whose PositionOwnerCap `user` owns, across all vaults.
+	*
+	* Pure state when every vault has the on-chain position index: all cap ids come from the
+	* index, their owners from the cap objects themselves. Otherwise needs `discovery: "fullnode"`
+	* (`listOwnedObjects`). If the caller already knows the cap ids (a wallet does), use
+	* `getUserPositionsByCapIds`, which is always pure state.
+	*/
+	async getAllUserPositions(user) {
+		const owner = normalizeSuiObjectId(user);
+		const n = await this.getTotalVaults();
+		const markets = Array.from({ length: n }, (_, i) => this.ctx.derive.vaultMarketId(i + 1));
+		const indexes = await Promise.all(markets.map((m) => this.positions.readOnchainIndex(m)));
+		let capIds = [];
+		if (indexes.every((x) => x !== null)) {
+			const all = indexes.flatMap((x) => x.capIds);
+			const caps = await fetchObjects(this.ctx.client, all);
+			capIds = all.filter((_, i) => caps[i] && ownerAddress(caps[i].owner) === owner);
+		} else if (this.ctx.allows("fullnode")) {
+			let cursor = null;
+			do {
+				const page = await this.ctx.client.core.listOwnedObjects({
+					owner: user,
+					type: this.ctx.derive.positionCapType,
+					cursor
+				});
+				capIds.push(...page.objects.map((o) => o.objectId));
+				cursor = page.hasNextPage ? page.cursor : null;
+			} while (cursor !== null);
+		} else throw new NeedsDiscoveryError(`positions owned by ${user}`, "fullnode", POSITION_INDEX_FIX);
+		return this.getUserPositionsByCapIds(capIds, owner);
+	}
+	/** Positions for known PositionOwnerCap ids (pure state: derived position ids only). */
+	async getUserPositionsByCapIds(capIds, user) {
+		if (capIds.length === 0) return [];
+		const n = await this.getTotalVaults();
+		const vaults = await this.loadVaults(Array.from({ length: n }, (_, i) => i + 1));
+		const candidates = capIds.flatMap((capId) => vaults.map((v) => ({
+			v,
+			id: this.ctx.derive.positionId(v.id, capId)
+		})));
+		const found = await fetchObjects(this.ctx.client, candidates.map((c) => c.id));
+		const hits = candidates.flatMap((c, i) => found[i] ? [{
+			v: c.v,
+			pos: decodePosition(found[i], c.v.vaultId)
+		}] : []);
+		const entire = /* @__PURE__ */ new Map();
+		for (const vd of await this.entireDataFor([...new Map(hits.map((h) => [h.v.id, h.v])).values()], {})) entire.set(vd.vault, vd);
+		return Promise.all(hits.map(async ({ v, pos }) => ({
+			...await this.buildNftPosition(pos, v, entire.get(v.id), user === void 0 ? void 0 : normalizeSuiObjectId(user)),
+			vault: entire.get(v.id)
+		})));
+	}
+	getAllUserPositionsV2 = async (user) => (await this.getAllUserPositions(user)).map((p) => ({
+		...p,
+		vault: this.toV2(p.vault)
+	}));
+	/** Open Position ids in a vault: opened events, minus closes, verified by object existence. */
+	async getAllPositionIdsForVault(vaultId) {
+		return (await this.getVaultPositionCounts(vaultId)).openPositionIds;
+	}
+	/** All open positions of a vault with `riskRatio` = debt / (col × liquidate price), 1e4 scale. */
+	async getAllPositionsWithRiskRatio(vaultId) {
+		const ids = await this.getAllPositionIdsForVault(vaultId);
+		const v = await this.loadVault(vaultId);
+		const vault = (await this.entireDataFor([v], {}))[0];
+		const price = vault.configs.oraclePriceLiquidate ?? 0n;
+		const positions = (await this.batchGetUserPositions(ids)).filter((p) => p !== null);
+		return Promise.all(positions.map(async (pos) => {
+			const nft = await this.buildNftPosition({
+				...pos,
+				vaultId
+			}, v, vault);
+			const colValue = nft.supply * price;
+			const riskRatio = colValue === 0n ? 0n : nft.borrow * ORACLE_RATE_PRECISION * FOUR_DECIMALS / colValue;
+			return {
+				...nft,
+				vaultId,
+				riskRatio
+			};
+		}));
+	}
+	/** Oracle price of a vault's oracle (as vaults consume it). */
+	async getOraclePrice(vaultId) {
+		const v = await this.loadVault(vaultId);
+		return this.oracle.getOraclePrice(v.raw.oracle);
+	}
+	/** Raw vault-internal 1e9 amounts → token units (`constants::unscale_amounts`). */
+	static unscale(amount, decimals) {
+		return amount / 10n ** BigInt(9 - decimals);
+	}
+};
+
+//#endregion
+//#region src/client.ts
+const DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
+/**
+* Unified reader, same shape as `@jup-ag/lend-read`'s `Client`:
+* `client.liquidity`, `client.lending`, `client.vault` (+ `client.oracle`, Sui-only).
+*
+* @example
+* const client = new Client(undefined, { network: "staging" });  // staging deployment, Sui mainnet gRPC
+* const client = new Client("https://my-fullnode:443", { network: prodConfig });
+* const client = new Client(existingSuiGrpcClient, { network: "staging" });
+* const vault = await client.vault.getVaultEntireData(1);
+*/
+var Client = class Client {
+	liquidity;
+	lending;
+	vault;
+	oracle;
+	context;
+	constructor(rpc, opts) {
+		const config = resolveConfig(opts?.network);
+		this.context = makeContext(createFailoverClient(rpc === void 0 ? config.rpcUrls ?? [DEFAULT_RPC_URL] : typeof rpc === "string" ? [rpc] : Array.isArray(rpc) ? rpc : [rpc], {
+			network: config.network,
+			timeoutMs: opts.timeoutMs,
+			...opts.retry
+		}), config, createDerive(config), opts.now, opts.discovery ?? "state");
+		this.liquidity = new Liquidity(this.context);
+		this.oracle = new Oracle(this.context);
+		this.lending = new Lending(this.context, this.liquidity);
+		this.vault = new Vault(this.context, this.liquidity, this.oracle);
+	}
+	/**
+	* The same reader pinned to a past `checkpoint`: every object read comes from the GraphQL service
+	* (`config.graphqlUrl`) at that checkpoint and the clock is the checkpoint's timestamp, so
+	* `lending.getLendingStateData()`, rates, reserves and vault state are what the chain held then.
+	* Move views / oracle quotes / balances are not available historically (`CheckpointReadError`).
+	* Needs `discovery: "indexer"` (it is a GraphQL read).
+	*
+	* @example
+	* const past = await client.atCheckpoint(330_000_000);
+	* const state = await past.lending.getLendingStateData();
+	*/
+	async atCheckpoint(checkpoint) {
+		if (!this.context.allows("indexer")) throw new NeedsDiscoveryError("state at a past checkpoint", "indexer", "fullnodes serve only live object versions; historical object versions come from the GraphQL indexer");
+		const url = this.context.config.graphqlUrl;
+		if (!url) throw new Error("config.graphqlUrl not set (needed for checkpoint reads)");
+		const cp = BigInt(checkpoint);
+		const ts = await checkpointTimestampSeconds(url, cp);
+		return new Client(checkpointClient(url, cp, this.context.client), {
+			network: this.context.config,
+			now: () => ts,
+			discovery: "state",
+			retry: { rounds: 1 }
+		});
+	}
+};
+/**
+* `$extend` form, same pattern as the write SDK's `fluid()`:
+* `const c = new SuiGrpcClient({...}).$extend(fluidRead());  c.fluidRead.vault...`
+*/
+function fluidRead(opts) {
+	return {
+		name: "fluidRead",
+		register: (client) => new Client(client, opts)
+	};
+}
+
+//#endregion
+export { AllEndpointsFailedError, CONFIGS, CheckpointReadError, Client, DEFAULT_RPC_URL, EXCHANGE_PRICES_PRECISION, EXCHANGE_PRICE_SCALE_FACTOR, FOUR_DECIMALS, GraphQLError, Lending, Liquidity, MAINNET, MAX_REWARDS_RATE, NeedsDiscoveryError, ORACLE_LIMITS, ORACLE_RATE_PRECISION, ObjectNotFoundError, Oracle, POSITION_INDEX_FIX, PositionIndex, RATE_OUTPUT_DECIMALS, RETURN_PERCENT_PRECISION, SECONDS_PER_YEAR, STAGING, SUPPLY_RATE_PRECISION, Vault, ViewCallError, backoffDelay, bcs_exports as bcsTypes, checkpointClient, checkpointTimestampSeconds, clientForEndpoint, configFromDeployment, createDerive, createFailoverClient, divCeil, fluidRead, graphqlQuery, latestCheckpoint, lending_exports as lendingMath, liquidity_exports as liquidityMath, max, min, mulDiv, mulDivCeil, nowSeconds, resolveConfig, rewardsRateToBps, scaleAndInvert, simulateView, supplyRateToBps, tick_exports as tickMath, vault_exports as vaultMath };