@instadapp/fluid-sui-read-sdk 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,9 +1,9 @@
 import { t as __exportAll } from "./chunk-15K8U1wQ.mjs";
-import { deriveDynamicFieldID, deriveObjectID, normalizeStructTag, normalizeSuiAddress, normalizeSuiObjectId, parseStructTag, toHex } from "@mysten/sui/utils";
+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 { ObjectError } from "@mysten/sui/client";
 import { Transaction } from "@mysten/sui/transactions";
 
 //#region src/config.ts
@@ -11,6 +11,8 @@ 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",
@@ -41,6 +43,7 @@ const STAGING = {
 		oracle: same("0xc1e7632c9847370a0f00298defa15d42fcb0e3191cad3bee8451cab5ce144814"),
 		vaults: same("0x08a3f6777d66c82ded41f5c02f902be34407005b2e53649b4e4da0bb63ef6f20")
 	},
+	mathVariant: "pre-audit",
 	objects: {
 		liquidityRegistry: "0x2b712ae7c38f4b4a09498565a4df8184bda875506b9f65ba8f64cf5662731ccc",
 		lendingRegistry: "0xc4f71cb64e6c01216f18fbea012176aa2f3a0a747347c914627cbb5aa0e569d2",
@@ -52,8 +55,7 @@ const STAGING = {
 		oracleAuth: "0x6133bd13291e1d04526c69957b27cf0a9d7422059873ad00e3e34ff1b1ba07d9",
 		vaultAdmin: "0x72ef539f4827cd055e38a3c2385a313831652fe4bde650a5d099dfdb95fc98d3"
 	},
-	oracleVariant: "v2",
-	oracleV2: {
+	oracle: {
 		redstoneAdapter: "0x22794c3a37c5320e5acb6b9cdba6e256bc08867e9de8afd2a4b5d8ea7061fea3",
 		redstonePackage: "0xfa84e5620fda505bbeb9178316a555e1db36f8932dee44210dd88a6464a76ef6",
 		pythPriceInfoObjects: { "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744": "0x89b2add829cb6fcd017153fff428bc9faec4d06d643ecfc435af5b55a9e987f0" },
@@ -65,47 +67,15 @@ const STAGING = {
 	graphqlUrl: "https://graphql.mainnet.sui.io/graphql"
 };
 /**
-* SUPERSEDED. 2026-09-18 deployment: interim admin oracle (`view::quote`, vault 1 on
-* 0xf36d0d95…651f) + the vaults package built on it. Objects still exist on chain; kept only to
-* read historical state.
-*/
-const STAGING_LEGACY = {
-	network: "mainnet",
-	packages: {
-		...COMMON_IDS,
-		oracle: same("0xebe2409c7ea9636f0e446797515cbee2ab809d898b06d99179d9eda59e1e42d5"),
-		vaults: same("0xf0f5a9c105384d5b79e212a9c9d3adfa5d030ef4c0cf9e22fa48674f9ad3652a")
-	},
-	objects: {
-		liquidityRegistry: "0x2b712ae7c38f4b4a09498565a4df8184bda875506b9f65ba8f64cf5662731ccc",
-		lendingRegistry: "0xc4f71cb64e6c01216f18fbea012176aa2f3a0a747347c914627cbb5aa0e569d2",
-		oracleRegistry: "0xe645573b6923398b4fbe952fe7e4aa4acc312b0a1c74c7d7417f812613f3173a",
-		vaultRegistry: "0xef8792ea0c069b7bd8e5c86291180135ff391ce5d5bdfaf205aeee593a486f24",
-		liquidityAuth: "0x85b19be86131a7a4b378c1b78e8e9b765a30c8c770de0645bfe0e1cb4da5ddb5",
-		lendingAuth: "0xc145f5f8aae7d72bf56a2ba82708976c057367160857146beedfa0b5409a5702",
-		vaultAdmin: "0x3ab15bc5037f34fcc5b763e4af4c83f2166811444859616d3ffe5049ef808dd1"
-	},
-	oracleVariant: "admin",
-	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;
-/** Default built-in network. Points at the current staging deployment until production ships. */
-const DEFAULT_NETWORK = "staging";
-const CONFIGS = {
-	staging: STAGING,
-	mainnet: STAGING,
-	"staging-legacy": STAGING_LEGACY
-};
+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", oracleV2 })`.
-* The record has no RedStone package or Pyth feed map, so `oracleV2` comes from the caller.
+* `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) {
@@ -145,16 +115,18 @@ function configFromDeployment(rec, opts) {
 			oracleAuth: obj("oracle", "auth", false),
 			vaultAdmin: obj("vaults", "admin", false)
 		},
-		oracleVariant: "v2",
-		oracleV2: opts.oracleV2,
+		oracle: opts.oracle,
 		tokens: opts.tokens ?? TOKENS,
 		rpcUrls: opts.rpcUrls,
-		graphqlUrl: opts.graphqlUrl
+		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) => ({
@@ -187,7 +159,18 @@ const RATE_OUTPUT_DECIMALS = 100000000000000000n;
 const EXCHANGE_PRICE_SCALE_FACTOR = 1000000000000000000n;
 /** Lending return precision (1e14 = 1e12 * 100). */
 const RETURN_PERCENT_PRECISION = 100000000000000n;
-/** Lending max rewards rate (50% in 1e12). */
+/**
+* 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");
@@ -206,8 +189,94 @@ 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,
@@ -222,19 +291,42 @@ var NeedsDiscoveryError = class extends Error {
 		this.name = "NeedsDiscoveryError";
 	}
 };
-function makeContext(client, config, derive, now, discovery = "state") {
+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: now ?? nowSeconds,
+		now,
 		discovery,
-		allows: (l) => RANK[discovery] >= RANK[l]
+		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(" | "));
@@ -268,12 +360,10 @@ 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);
-	if (clients.length === 1) return Object.assign(clients[0], {
-		endpoints: labels,
-		preferred: () => labels[0]
-	});
 	const timeoutMs = opts.timeoutMs ?? 15e3;
-	const rounds = opts.rounds ?? 2;
+	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;
@@ -286,6 +376,7 @@ function createFailoverClient(endpoints, opts) {
 				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)}`);
@@ -312,6 +403,151 @@ function createFailoverClient(endpoints, opts) {
 	} });
 }
 
+//#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
 /**
@@ -321,7 +557,6 @@ function createFailoverClient(endpoints, opts) {
 * Single-field wrappers (UID, ID, TimestampS, DurationS, Balance, Supply) encode as their field.
 */
 var bcs_exports = /* @__PURE__ */ __exportAll({
-	AdminOracle: () => AdminOracle,
 	Branch: () => Branch,
 	BranchStatus: () => BranchStatus,
 	CapRecord: () => CapRecord,
@@ -331,17 +566,16 @@ var bcs_exports = /* @__PURE__ */ __exportAll({
 	LendingState: () => LendingState,
 	LiquidityRegistry: () => LiquidityRegistry,
 	MoveTick: () => MoveTick,
+	OracleObject: () => OracleObject,
 	OracleRegistry: () => OracleRegistry,
 	OracleSource: () => OracleSource,
 	OracleSourceType: () => OracleSourceType,
-	OracleV2: () => OracleV2,
 	PauseFlags: () => PauseFlags,
 	Position: () => Position,
 	PositionIndex: () => PositionIndex$1,
 	PositionIndexEntry: () => PositionIndexEntry,
 	PositionIndexField: () => PositionIndexField,
 	PriceQuote: () => PriceQuote,
-	PriceQuoteV2: () => PriceQuoteV2,
 	PythPriceInfoObject: () => PythPriceInfoObject,
 	RateDataV1Params: () => RateDataV1Params,
 	RateDataV2Params: () => RateDataV2Params,
@@ -574,22 +808,11 @@ const VaultRegistry = bcs.struct("VaultRegistry", {
 	next_vault_id: U64,
 	version: U64
 });
-const AdminOracle = bcs.struct("Oracle", {
-	id: Address,
-	name: bcs.string(),
-	rate: U128,
-	version: U64
-});
 const OracleRegistry = bcs.struct("OracleRegistry", {
 	id: Address,
 	version: U64,
 	total_oracles: U64
 });
-const PriceQuote = bcs.struct("PriceQuote", {
-	oracle_id: Address,
-	rate_liquidate: U128,
-	rate_operate: U128
-});
 const OracleSourceType = bcs.enum("SourceType", {
 	Redstone: bcs.struct("Redstone", { adapter_id: Address }),
 	Pyth: null
@@ -599,15 +822,15 @@ const OracleSource = bcs.struct("Source", {
 	invert: bcs.bool(),
 	source_type: OracleSourceType
 });
-/** `fluid_oracle::oracle::Oracle` (v2): derived from the registry by nonce. */
-const OracleV2 = bcs.struct("Oracle", {
+/** `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)
 });
-/** v2 `view::PriceQuote`: each rate is optional (operate-only / liquidate-only quotes). */
-const PriceQuoteV2 = bcs.struct("PriceQuote", {
+/** `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)
@@ -816,6 +1039,8 @@ var liquidity_exports = /* @__PURE__ */ __exportAll({
 	processOverallTokenData: () => processOverallTokenData,
 	processUserBorrowData: () => processUserBorrowData,
 	processUserSupplyData: () => processUserSupplyData,
+	supplyRateAt: () => supplyRateAt,
+	supplyRateRaw: () => supplyRateRaw,
 	totalAmountsOf: () => totalAmountsOf,
 	totalBorrowNormal: () => totalBorrowNormal,
 	totalSupplyNormal: () => totalSupplyNormal
@@ -825,8 +1050,31 @@ function withInterestVsFreeRatio(withInterest, interestFree) {
 	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) {
+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)");
@@ -835,34 +1083,23 @@ function calculateExchangePrice(r, now) {
 		supplyExchangePrice,
 		borrowExchangePrice
 	};
+	const borrowBefore = borrowExchangePrice;
 	borrowExchangePrice += divCeil(borrowExchangePrice * r.borrowRate * elapsed, SECONDS_PER_YEAR * FOUR_DECIMALS);
-	if (r.totalSupplyWithInterest === 0n) return {
-		supplyExchangePrice,
-		borrowExchangePrice
-	};
-	const supplyWithInterestNormal = divCeil(r.totalSupplyWithInterest * supplyExchangePrice, EXCHANGE_PRICES_PRECISION);
-	let supplyRatio = withInterestVsFreeRatio(supplyWithInterestNormal, r.totalSupplyInterestFree);
-	let ratioSupplyYield;
-	if (supplyWithInterestNormal < r.totalSupplyInterestFree) {
-		if (supplyRatio === 0n) return {
-			supplyExchangePrice,
-			borrowExchangePrice
-		};
-		supplyRatio = RATE_OUTPUT_DECIMALS * FOUR_DECIMALS / supplyRatio;
-		ratioSupplyYield = r.lastUtilization * (RATE_OUTPUT_DECIMALS + supplyRatio) / FOUR_DECIMALS;
-	} else ratioSupplyYield = r.lastUtilization * RATE_OUTPUT_DECIMALS * (FOUR_DECIMALS + supplyRatio) / (FOUR_DECIMALS * FOUR_DECIMALS);
-	const borrowWithInterestNormal = r.totalBorrowWithInterest * borrowExchangePrice / 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;
-	const supplyRate = r.borrowRate * ratioSupplyYield * (FOUR_DECIMALS - r.fee);
-	supplyExchangePrice += supplyExchangePrice * supplyRate * elapsed / (SECONDS_PER_YEAR * FOUR_DECIMALS) / (FOUR_DECIMALS * 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). */
@@ -883,15 +1120,13 @@ function totalAmountsOf(r) {
 		totalClaimAmount: 0n
 	};
 }
-/** Same shape/semantics as the Solana reader's `processOverallTokenData`. */
-function processOverallTokenData(r, rateData, now) {
-	const { supplyExchangePrice, borrowExchangePrice } = calculateExchangePrice(r, now);
-	let supplyRate = 0n;
-	if (r.totalSupplyWithInterest !== 0n) {
-		const borrowForRate = r.totalBorrowWithInterest * r.borrowExchangePrice / EXCHANGE_PRICES_PRECISION;
-		const supplyForRate = r.totalSupplyWithInterest * r.supplyExchangePrice / EXCHANGE_PRICES_PRECISION;
-		if (supplyForRate !== 0n) supplyRate = r.borrowRate * (FOUR_DECIMALS - r.fee) * borrowForRate / (supplyForRate * FOUR_DECIMALS);
-	}
+/**
+* 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,
@@ -1035,6 +1270,7 @@ var lending_exports = /* @__PURE__ */ __exportAll({
 	previews: () => previews,
 	rateSegments: () => rateSegments,
 	rewardsRateFor: () => rewardsRateFor,
+	rewardsTvl: () => rewardsTvl,
 	toAssets: () => toAssets,
 	toShares: () => toShares
 });
@@ -1062,30 +1298,40 @@ function rateSegments(s, totalAssets, fromS, nowS) {
 }
 const maxB = (a, b) => a > b ? a : b;
 const minB = (a, b) => a < b ? a : b;
-/** Current rewards rate (1e12 = 100%) at `now`, from the active schedule segment. */
-function currentRewardsRate(state, now) {
+/**
+* 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 = toAssets(state.totalShares, state.tokenExchangePrice, false);
+	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) {
+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 = toAssets(state.totalShares, oldToken, false);
+		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) {
-	const tokenEp = accruedTokenExchangePrice(state, liquidityExchangePrice, nowS);
+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),
@@ -1095,81 +1341,6 @@ function previews(state, liquidityExchangePrice, nowS, assets, shares) {
 	};
 }
 
-//#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/view.ts
 /** Any address works as the simulated sender; nothing is executed. */
@@ -1214,12 +1385,18 @@ var Lending = class {
 		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) {
-		const d = this.ctx.derive;
+		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) => d.lendingStateId(t));
-		const objs = await fetchObjects(this.ctx.client, [...ids, ...ids.map((id) => d.rewardsId(id))]);
+		const ids = norm.map((t) => this.ctx.derive.lendingStateId(t));
 		return norm.map((token, i) => {
 			const o = objs[i];
 			if (!o) return null;
@@ -1248,23 +1425,54 @@ var Lending = class {
 			};
 		});
 	}
+	/**
+	* 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 [[lending], reserve] = await Promise.all([this.loadLendings([token]), this.liquidity.loadReserve(token)]);
-		if (!lending) throw new Error(`no LendingState for ${token}`);
+		const { pools, now } = await this.loadPools([token]);
 		return {
-			lending,
-			reserve
+			...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.client.core.getCoinMetadata({ coinType: r.token })));
+		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].coinMetadata?.decimals ?? 0,
+			decimals: metas[i]?.decimals ?? 0,
 			totalShares: r.snapshot.totalShares,
 			liquidityExchangePrice: r.snapshot.liquidityExchangePrice,
 			tokenExchangePrice: r.snapshot.tokenExchangePrice,
@@ -1281,16 +1489,14 @@ var Lending = class {
 	getAllJlTokens = () => this.getAllFTokens();
 	/** Token exchange price accrued to now (`accounting::calculate_new_token_exchange_price`). */
 	async getExchangePrice(token) {
-		const { lending, reserve } = await this.loadOne(token);
-		const now = this.ctx.now();
-		const liqEp = calculateExchangePrice(reserve.snapshot, now).supplyExchangePrice;
-		return accruedTokenExchangePrice(lending.snapshot, liqEp, now);
+		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 } = await this.loadOne(token);
-		const now = this.ctx.now();
-		const liqEp = calculateExchangePrice(reserve.snapshot, now).supplyExchangePrice;
-		const p = previews(lending.snapshot, liqEp, now, 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,
@@ -1298,11 +1504,13 @@ var Lending = class {
 			previewRedeem: p.previewRedeem
 		};
 	}
-	detailsFromRecords(lending, reserve, supplyEntry, meta, now = this.ctx.now()) {
+	detailsFromRecords(lending, reserve, supplyEntry, meta, now) {
 		const { userSupplyData, overallTokenData } = this.liquidity.supplyDataFromRecords(reserve, supplyEntry, now);
-		const tokenEp = accruedTokenExchangePrice(lending.snapshot, overallTokenData.supplyExchangePrice, 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,
@@ -1314,60 +1522,207 @@ var Lending = class {
 			totalSupply: lending.snapshot.totalShares,
 			conversionRateToShares: toShares(one, tokenEp, false),
 			conversionRateToAssets: toAssets(one, tokenEp, false),
-			rewardsRate: currentRewardsRate(lending.snapshot, now),
-			supplyRate: overallTokenData.supplyRate,
+			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, u] = await Promise.all([this.ctx.client.core.getCoinMetadata({ coinType: this.ctx.derive.fTokenType(token) }).catch(() => ({ coinMetadata: null })), this.ctx.client.core.getCoinMetadata({ coinType: token })]);
-		const under = u.coinMetadata;
+		const [f, under] = await Promise.all([this.ctx.coinMetadata(this.ctx.derive.fTokenType(token)).catch(() => null), this.ctx.coinMetadata(token)]);
 		return {
-			name: f.coinMetadata?.name ?? `Fluid ${under?.name ?? ""}`.trim(),
-			symbol: f.coinMetadata?.symbol ?? `f${under?.symbol ?? ""}`,
-			decimals: f.coinMetadata?.decimals ?? under?.decimals ?? 0
+			name: f?.name ?? `Fluid ${under?.name ?? ""}`.trim(),
+			symbol: f?.symbol ?? `f${under?.symbol ?? ""}`,
+			decimals: f?.decimals ?? under?.decimals ?? 0
 		};
 	}
 	async getFTokenDetails(token) {
-		const { lending, reserve } = await this.loadOne(token);
-		const [[entry], meta] = await Promise.all([this.liquidity.loadUserEntries([{
-			holder: lending.id,
-			reserve
-		}]), this.fTokenMeta(lending.token)]);
-		return this.detailsFromRecords(lending, reserve, entry.supply, meta);
+		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 Promise.all((await this.getAllFTokens()).map((t) => this.getFTokenDetails(t)));
+		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 { lending, reserve } = await this.loadOne(token);
-		const [entry] = await this.liquidity.loadUserEntries([{
-			holder: lending.id,
-			reserve
-		}]);
-		const now = this.ctx.now();
+		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).supplyExchangePrice;
+		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,
-			rebalancer: "",
 			liquidityBalance: userSupplyData.supply,
 			liquidityExchangePrice: liqEp,
-			tokenExchangePrice: accruedTokenExchangePrice(lending.snapshot, liqEp, now)
+			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 } = await this.loadOne(token);
-		return [lending.raw.rewards_writer ?? null, currentRewardsRate(lending.snapshot, this.ctx.now())];
+		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);
@@ -1380,7 +1735,7 @@ var Lending = class {
 			startTime: r.startS,
 			endTime: r.endS,
 			startTvl: r.startTvl,
-			maxRate: 50000000000000n,
+			maxRate: rewardsRateToBps(MAX_REWARDS_RATE),
 			rewardAmount: r.yearlyReward,
 			nextStartTime: r.nextStartS,
 			nextEndTime: r.nextEndS,
@@ -1405,16 +1760,30 @@ var Lending = class {
 		return {
 			fTokenShares: s,
 			underlyingAssets: toAssets(s, ep, false),
-			underlyingBalance: BigInt(under.balance.balance),
-			allowance: 0n
+			underlyingBalance: BigInt(under.balance.balance)
 		};
 	}
 	async getUserPositions(user) {
-		const tokens = await this.getAllFTokens();
-		return Promise.all(tokens.map(async (t) => ({
-			fTokenDetails: await this.getFTokenDetails(t),
-			userPosition: await this.getUserPosition(t, 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) {
@@ -1549,11 +1918,15 @@ var Liquidity = class {
 	constructor(ctx) {
 		this.ctx = ctx;
 	}
-	/** Reserves + their rate-data fields in 2 batched round trips. */
-	async loadReserves(tokens) {
+	/** 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));
-		const objs = await fetchObjects(this.ctx.client, [...ids, ...ids.map((id) => this.ctx.derive.rateDataId(id))]);
 		return norm.map((token, i) => {
 			const o = objs[i];
 			if (!o) throw new Error(`no TokenReserve for ${token} (${ids[i]})`);
@@ -1567,6 +1940,10 @@ var Liquidity = class {
 			};
 		});
 	}
+	/** 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];
 	}
@@ -1678,9 +2055,9 @@ var Liquidity = class {
 			maxUtilization: s.maxUtilization
 		};
 	}
-	/** Pure: accrue a reserve snapshot to `now` (defaults to the context clock). */
+	/** 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.now());
+		return calculateExchangePrice(snapshot, now, this.ctx.math);
 	}
 	async getRateConfig(token) {
 		const { rateData: r } = await this.loadReserve(token);
@@ -1715,8 +2092,8 @@ var Liquidity = class {
 		return { maxUtilization: (await this.loadReserve(token)).snapshot.maxUtilization };
 	}
 	async getRevenue(token) {
-		const { snapshot } = await this.loadReserve(token);
-		const ep = calculateExchangePrice(snapshot, this.ctx.now());
+		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) {
@@ -1725,15 +2102,16 @@ var Liquidity = class {
 	async getTokensRateData(tokens) {
 		return (await this.loadReserves(tokens)).map((r) => r.rateData);
 	}
-	overallFromRecord(r, now = this.ctx.now()) {
-		return processOverallTokenData(r.snapshot, r.rateData, now);
+	overallFromRecord(r, now) {
+		return processOverallTokenData(r.snapshot, r.rateData, now, this.ctx.math);
 	}
 	async getOverallTokenData(token) {
-		return this.overallFromRecord(await this.loadReserve(token));
+		const [r, now] = await Promise.all([this.loadReserve(token), this.ctx.now()]);
+		return this.overallFromRecord(r, now);
 	}
 	async getOverallTokensData(tokens) {
-		const now = this.ctx.now();
-		return (await this.loadReserves(tokens)).map((r) => this.overallFromRecord(r, now));
+		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());
@@ -1755,14 +2133,14 @@ var Liquidity = class {
 		}]);
 		return e.borrow ?? 0n;
 	}
-	supplyDataFromRecords(reserve, acc, now = this.ctx.now()) {
+	supplyDataFromRecords(reserve, acc, now) {
 		const overallTokenData = this.overallFromRecord(reserve, now);
 		return {
 			userSupplyData: processUserSupplyData(acc, overallTokenData, reserve.snapshot.vaultBalance, now),
 			overallTokenData
 		};
 	}
-	borrowDataFromRecords(reserve, acc, now = this.ctx.now()) {
+	borrowDataFromRecords(reserve, acc, now) {
 		const overallTokenData = this.overallFromRecord(reserve, now);
 		return {
 			userBorrowData: processUserBorrowData(acc, overallTokenData, reserve.snapshot.vaultBalance, now),
@@ -1770,28 +2148,27 @@ var Liquidity = class {
 		};
 	}
 	async getUserSupplyData(user, token) {
-		const reserve = await this.loadReserve(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);
+		return this.supplyDataFromRecords(reserve, e.supply, now);
 	}
 	async getUserBorrowData(user, token) {
-		const reserve = await this.loadReserve(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);
+		return this.borrowDataFromRecords(reserve, e.borrow, now);
 	}
 	async getUserMultipleSupplyData(user, tokens) {
-		const reserves = await this.loadReserves(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 now = this.ctx.now();
 		const out = reserves.map((r, i) => this.supplyDataFromRecords(r, entries[i].supply, now));
 		return {
 			userSuppliesData: out.map((o) => o.userSupplyData),
@@ -1799,12 +2176,11 @@ var Liquidity = class {
 		};
 	}
 	async getUserMultipleBorrowData(user, tokens) {
-		const reserves = await this.loadReserves(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 now = this.ctx.now();
 		const out = reserves.map((r, i) => this.borrowDataFromRecords(r, entries[i].borrow, now));
 		return {
 			userBorrowingsData: out.map((o) => o.userBorrowData),
@@ -1922,13 +2298,11 @@ function pick(o, keys) {
 * 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.
-*
-* admin (2026-09-18 preset only): `Oracle { name, rate }`, `view::quote(&Oracle)`.
 */
 /** 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_V2_LIMITS = {
+const ORACLE_LIMITS = {
 	rateOutputDecimals: 15,
 	maxAgeOperateS: 600n,
 	maxAgeLiquidateS: 7200n,
@@ -1951,9 +2325,9 @@ function toSource(s) {
 }
 /** `rate::scale_and_invert`: raw provider price with `decimals` → 1e15 rate, optionally inverted. */
 function scaleAndInvert(raw, decimals, invert) {
-	const out = ORACLE_V2_LIMITS.rateOutputDecimals;
+	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_V2_LIMITS.maxInvertibleRate ? 0n : ORACLE_RATE_PRECISION * ORACLE_RATE_PRECISION / rate;
+	if (rate > 0n && invert) rate = rate > ORACLE_LIMITS.maxInvertibleRate ? 0n : ORACLE_RATE_PRECISION * ORACLE_RATE_PRECISION / rate;
 	return rate;
 }
 function abortText(e) {
@@ -1968,26 +2342,15 @@ var Oracle = class {
 	constructor(ctx) {
 		this.ctx = ctx;
 	}
-	get v2() {
-		const c = this.ctx.config.oracleV2;
-		if (this.ctx.config.oracleVariant !== "v2" || !c) throw new Error("config has no v2 oracle (oracleVariant/oracleV2)");
+	get providers() {
+		const c = this.ctx.config.oracle;
+		if (!c) throw new Error("config has no oracle (config.oracle)");
 		return c;
 	}
-	/** Admin oracle object (2026-09-18 preset). */
-	async getOracle(oracleId) {
-		const id = normalizeSuiObjectId(oracleId);
-		const o = AdminOracle.parse((await fetchObject(this.ctx.client, id, "Oracle")).content);
-		return {
-			id,
-			name: o.name,
-			rate: BigInt(o.rate),
-			version: BigInt(o.version)
-		};
-	}
 	/** v2 oracle object: nonce + main / guard routes. */
-	async getOracleV2(oracleId) {
+	async getOracle(oracleId) {
 		const id = normalizeSuiObjectId(oracleId);
-		const o = OracleV2.parse((await fetchObject(this.ctx.client, id, "Oracle")).content);
+		const o = OracleObject.parse((await fetchObject(this.ctx.client, id, "Oracle")).content);
 		return {
 			id,
 			nonce: o.nonce,
@@ -1997,18 +2360,18 @@ var Oracle = class {
 	}
 	/** Provider objects the v2 views take for this oracle. */
 	providerArgs(o) {
-		const cfg = this.v2;
+		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.oracleV2.pythPriceInfoObjects)`);
+		if (!pythInfo) throw new Error(`no Pyth PriceInfoObject configured for feed ${pythFeed ?? "(any)"} (config.oracle.pythPriceInfoObjects)`);
 		return {
 			adapter: normalizeSuiObjectId(adapter),
 			pythInfo: normalizeSuiObjectId(pythInfo)
 		};
 	}
-	async quoteV2(o, fn) {
+	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) => {
@@ -2022,7 +2385,7 @@ var Oracle = class {
 				]
 			});
 		});
-		const q = PriceQuoteV2.parse(res[0][0]);
+		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);
@@ -2030,29 +2393,12 @@ var Oracle = class {
 	/** Price exactly as vaults see it. v2: operate and liquidate simulated separately (one can abort alone). */
 	async getOraclePrice(oracleId) {
 		const id = normalizeSuiObjectId(oracleId);
-		if (this.ctx.config.oracleVariant === "admin") {
-			const pkg = this.ctx.config.packages.oracle.packageId;
-			const res = await simulateView(this.ctx.client, (tx) => {
-				tx.moveCall({
-					target: `${pkg}::view::quote`,
-					arguments: [tx.object(id)]
-				});
-			});
-			const q = PriceQuote.parse(res[0][0]);
-			return {
-				oracle: q.oracle_id,
-				operate: BigInt(q.rate_operate),
-				liquidate: BigInt(q.rate_liquidate),
-				source: "admin"
-			};
-		}
-		const o = await this.getOracleV2(id);
-		const [op, liq] = await Promise.allSettled([this.quoteV2(o, "get_exchange_rate_operate"), this.quoteV2(o, "get_exchange_rate_liquidate")]);
+		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,
-			source: "v2",
 			...op.status === "rejected" ? { operateError: abortText(op.reason) } : {},
 			...liq.status === "rejected" ? { liquidateError: abortText(liq.reason) } : {}
 		};
@@ -2063,8 +2409,8 @@ var Oracle = class {
 	* Operate price = min over routes; liquidate = min over routes usable for liquidate.
 	*/
 	async getOracleRoutes(oracleId) {
-		const o = await this.getOracleV2(oracleId);
-		const cfg = this.v2;
+		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) => {
@@ -2089,7 +2435,7 @@ var Oracle = class {
 		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_V2_LIMITS;
+			const L = ORACLE_LIMITS;
 			if (s.provider === "redstone") {
 				const k = 1 + 2 * rsIdx++;
 				const value = BigInt(bcs.u256().parse(res[k][0]));
@@ -2632,7 +2978,6 @@ var Vault = class {
 			liquidationPenalty: r.risk.liquidation_penalty,
 			borrowFee: r.risk.borrow_fee,
 			oracle: r.oracle,
-			rebalancer: "",
 			liquidityProgram: r.liquidity_program,
 			oracleProgram: this.ctx.config.packages.oracle.packageId,
 			supplyToken: v.collateralType,
@@ -2729,10 +3074,10 @@ var Vault = class {
 		return this.stateFromRecord(v, branch ?? null, counts ?? null);
 	}
 	/** `user::get_exchange_prices`: (liqSupply, liqBorrow, vaultSupply, vaultBorrow) accrued to `now`. */
-	exchangePricesFromRecords(v, colReserve, debtReserve, now = this.ctx.now()) {
+	exchangePricesFromRecords(v, colReserve, debtReserve, now) {
 		const r = v.raw;
-		const liqSupply = calculateExchangePrice(colReserve.snapshot, now).supplyExchangePrice;
-		const liqBorrow = calculateExchangePrice(debtReserve.snapshot, now).borrowExchangePrice;
+		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),
@@ -2781,7 +3126,7 @@ var Vault = class {
 		};
 	}
 	async entireDataFor(vaults, opts) {
-		const now = this.ctx.now();
+		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) => [{
@@ -2797,6 +3142,7 @@ var Vault = class {
 			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);
@@ -2868,7 +3214,6 @@ var Vault = class {
 					liquidationPenalty: BigInt(cfg.liquidationPenalty),
 					borrowFee: BigInt(cfg.borrowFee),
 					oracle: cfg.oracle,
-					rebalancer: "",
 					...price?.operate != null ? { oraclePriceOperate: price.operate } : {},
 					...price?.liquidate != null ? { oraclePriceLiquidate: price.liquidate } : {},
 					lastUpdateTimestamp: state.lastUpdateTimestamp
@@ -3133,34 +3478,59 @@ const DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
 * `client.liquidity`, `client.lending`, `client.vault` (+ `client.oracle`, Sui-only).
 *
 * @example
-* const client = new Client();                                   // staging deployment, Sui mainnet gRPC
-* const client = new Client("https://my-fullnode:443");
+* 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 {
+var Client = class Client {
 	liquidity;
 	lending;
 	vault;
 	oracle;
 	context;
-	constructor(rpc, opts = {}) {
-		const config = resolveConfig(opts.network ?? DEFAULT_NETWORK);
+	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
+			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 = {}) {
+function fluidRead(opts) {
 	return {
 		name: "fluidRead",
 		register: (client) => new Client(client, opts)
@@ -3168,4 +3538,4 @@ function fluidRead(opts = {}) {
 }
 
 //#endregion
-export { AllEndpointsFailedError, CONFIGS, Client, DEFAULT_NETWORK, DEFAULT_RPC_URL, EXCHANGE_PRICES_PRECISION, EXCHANGE_PRICE_SCALE_FACTOR, FOUR_DECIMALS, Lending, Liquidity, MAINNET, MAX_REWARDS_RATE, NeedsDiscoveryError, ORACLE_RATE_PRECISION, ORACLE_V2_LIMITS, ObjectNotFoundError, Oracle, POSITION_INDEX_FIX, PositionIndex, RATE_OUTPUT_DECIMALS, RETURN_PERCENT_PRECISION, SECONDS_PER_YEAR, STAGING, STAGING_LEGACY, Vault, ViewCallError, bcs_exports as bcsTypes, clientForEndpoint, configFromDeployment, createDerive, createFailoverClient, divCeil, fluidRead, lending_exports as lendingMath, liquidity_exports as liquidityMath, max, min, mulDiv, mulDivCeil, nowSeconds, resolveConfig, scaleAndInvert, simulateView, tick_exports as tickMath, vault_exports as vaultMath };
+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 };