@ember-finance/sdk 2.12.0-ccip.0 → 2.13.0

package/dist/src/placements/adapters/bluefin-spot.js

@@ -0,0 +1,78 @@
+import { coinTypesMatch, toBigInt, typeArguments } from "../sui.js";
+import { createSuiVenueAdapter } from "./factory.js";
+/** Sui wraps a signed tick as `{ bits }`, two's complement in a u32. */
+function tickOf(field) {
+    const bits = Number(field?.bits ?? 0);
+    return bits >= 0x80000000 ? bits - 0x100000000 : bits;
+}
+const Q64 = 2n ** 64n;
+/**
+ * √(1.0001^tick) as a Q64 fixed point.
+ *
+ * Computed in floating point rather than by the usual chain of magic constants.
+ * A double carries ~15 significant digits against Q64's ~19, so the result can
+ * be off by roughly 1e-16 relative — orders of magnitude below the dust these
+ * amounts are displayed to, and far less error-prone than transcribing the
+ * bit-manipulation table.
+ */
+function sqrtRatioAtTick(tick) {
+    return BigInt(Math.floor(Math.pow(1.0001, tick / 2) * Number(Q64)));
+}
+/**
+ * The token amounts a concentrated-liquidity position is currently worth.
+ *
+ * A position holds liquidity over a tick range, not amounts, so what it is
+ * worth depends on where the pool's price sits relative to that range: entirely
+ * in coin A above it, entirely in coin B below it, and split while inside.
+ */
+function positionAmounts(liquidity, sqrtLower, sqrtUpper, sqrtPrice) {
+    if (liquidity === 0n || sqrtLower >= sqrtUpper)
+        return { amountA: 0n, amountB: 0n };
+    const clamped = sqrtPrice < sqrtLower ? sqrtLower : sqrtPrice > sqrtUpper ? sqrtUpper : sqrtPrice;
+    // amountA = L * (√upper - √p) / (√p * √upper)
+    const amountA = clamped >= sqrtUpper
+        ? 0n
+        : (liquidity * (sqrtUpper - clamped) * Q64) / (clamped * sqrtUpper);
+    // amountB = L * (√p - √lower)
+    const amountB = clamped <= sqrtLower ? 0n : (liquidity * (clamped - sqrtLower)) / Q64;
+    return { amountA, amountB };
+}
+export const bluefinSpot = createSuiVenueAdapter({
+    id: "bluefin-spot",
+    async read(ref, account, reader) {
+        // Bluefin spot AMM. A position is an owned `Position` object naming its pool, so
+        // an account's stake in one venue is the sum of the positions it owns there.
+        const pools = await reader.objects([ref.venue]);
+        const pool = pools[ref.venue];
+        if (!pool)
+            throw new Error(`bluefin-spot: pool ${ref.venue} not found on chain`);
+        // Positions come from the same package as the pool, so derive the type
+        // rather than pin a package that moves on every contract upgrade.
+        const positionType = ref.shareToken ?? `${pool.type.split("::")[0]}::position::Position`;
+        const owned = await reader.ownedObjects(account, positionType);
+        const inPool = owned.filter(o => o.json.pool_id === ref.venue);
+        if (inPool.length === 0)
+            return undefined;
+        const [typeA, typeB] = typeArguments(pool.type);
+        const wantsA = coinTypesMatch(typeA, ref.coin);
+        if (!wantsA && !coinTypesMatch(typeB, ref.coin)) {
+            throw new Error(`bluefin-spot: pool ${ref.venue} does not hold ${ref.coin}`);
+        }
+        // A missing field reads as 0, which clamps every position to the lower
+        // tick and returns a plausible but wrong amount. Fail instead.
+        const sqrtPrice = toBigInt(pool.json.current_sqrt_price);
+        if (sqrtPrice === 0n) {
+            throw new Error(`bluefin-spot: pool ${ref.venue} has no current_sqrt_price`);
+        }
+        let total = 0n;
+        for (const position of inPool) {
+            const { amountA, amountB } = positionAmounts(toBigInt(position.json.liquidity), sqrtRatioAtTick(tickOf(position.json.lower_tick)), sqrtRatioAtTick(tickOf(position.json.upper_tick)), sqrtPrice);
+            total += wantsA ? amountA : amountB;
+        }
+        // A position wholly outside the current range holds none of this side.
+        // Reporting zero would render an empty row rather than no row.
+        if (total === 0n)
+            return undefined;
+        return total;
+    }
+});

package/dist/src/placements/adapters/current.d.ts

@@ -0,0 +1 @@
+export declare const current: import("../types.js").ProtocolAdapter;

package/dist/src/placements/adapters/current.js

@@ -0,0 +1,70 @@
+import { coinTypesMatch, decimalToBaseUnits, tableId, toBigInt, typeArguments } from "../sui.js";
+import { createSuiVenueAdapter } from "./factory.js";
+export const current = createSuiVenueAdapter({
+    id: "current",
+    async read(ref, account, reader) {
+        // Current. An account holds an `obligation::ObligationOwnerCap` naming its
+        // obligation, whose cToken balances hang off a dynamic-field table keyed by the
+        // cToken type rather than sitting inline.
+        //
+        // Balances are cTokens, so they convert through the market's reserve — total
+        // supplied over cTokens issued — to the underlying coin.
+        const markets = await reader.objects([ref.venue]);
+        const market = markets[ref.venue];
+        if (!market)
+            throw new Error(`current: market ${ref.venue} not found on chain`);
+        const capType = ref.shareToken ??
+            `${market.type.split("::")[0]}::obligation::ObligationOwnerCap`;
+        const caps = await reader.ownedObjects(account, capType);
+        if (caps.length === 0)
+            return undefined;
+        // The reserve for our coin gives the exchange rate.
+        const reservesId = tableId(market.json.reserves);
+        if (!reservesId)
+            throw new Error(`current: no reserves table on ${ref.venue}`);
+        const reserves = await reader.dynamicFields(reservesId);
+        const reserve = reserves.find(entry => coinTypesMatch(String(entry.name ?? ""), ref.coin));
+        if (!reserve)
+            return undefined;
+        const reserveValue = reserve.value;
+        const supplied = toBigInt(reserveValue.cash) + decimalToBaseUnits(reserveValue.debt);
+        const ctokenSupply = toBigInt(reserveValue.total_supply);
+        if (ctokenSupply === 0n)
+            return undefined;
+        let held = 0n;
+        for (const cap of caps) {
+            // The cap is not parameterised by market, so an account active in
+            // several Current markets owns several. Both the cap and the
+            // obligation name the market; filtering here skips fetching the
+            // obligations that belong to the others.
+            const capMarket = cap.json.market_id;
+            if (capMarket && capMarket !== ref.venue)
+                continue;
+            const obligationId = cap.json.obligation_id;
+            if (!obligationId)
+                continue;
+            const obligations = await reader.objects([obligationId]);
+            const obligation = obligations[obligationId];
+            if (!obligation)
+                continue;
+            if (obligation.json.lending_market_id !== ref.venue)
+                continue;
+            const ctokens = obligation.json.ctokens;
+            const valuesId = tableId(ctokens?.ctoken_values);
+            if (!valuesId)
+                continue;
+            for (const entry of await reader.dynamicFields(valuesId)) {
+                // Keys are `CToken<MarketType, coin>` — the market type comes
+                // first, so the coin is the last type argument, not the first.
+                const args = typeArguments(String(entry.name ?? ""));
+                const wrapped = args[args.length - 1];
+                if (!wrapped || !coinTypesMatch(wrapped, ref.coin))
+                    continue;
+                held += toBigInt(entry.value);
+            }
+        }
+        if (held === 0n)
+            return undefined;
+        return (held * supplied) / ctokenSupply;
+    }
+});

package/dist/src/placements/adapters/evm-protocols.d.ts

@@ -0,0 +1 @@
+export declare const openCover: import("../types.js").ProtocolAdapter;

package/dist/src/placements/adapters/evm-protocols.js

@@ -0,0 +1,8 @@
+import { createEvmVenueAdapter } from "./factory.js";
+// EVM protocols whose position IS the token the account holds, one for one, so
+// the amount is that token's `balanceOf(account)`.
+//
+// Neither Pendle nor Royco qualifies. Pendle's PT/YT/LP are not 1:1 with the
+// receipt coin, and a Royco tranche vault issues 18-decimal shares that convert
+// through its own claims struct. See ./pendle.ts and ./royco.ts.
+export const openCover = createEvmVenueAdapter("opencover");

package/dist/src/placements/adapters/factory.d.ts

@@ -0,0 +1,15 @@
+import { PlacementRef, ProtocolAdapter, ProtocolId, SuiReader } from "../types.js";
+/**
+ * What `account` holds at one venue, in base units of `ref.coin`.
+ *
+ * Return `undefined` when the account has no position there — that is the
+ * common case and not a failure, so it is distinct from throwing.
+ */
+export type SuiAccountReader = (ref: PlacementRef, account: string, reader: SuiReader) => Promise<bigint | undefined>;
+/** A Sui protocol adapter, defined by how one account's position is read. */
+export declare function createSuiVenueAdapter(options: {
+    id: ProtocolId;
+    read: SuiAccountReader;
+}): ProtocolAdapter;
+/** An EVM protocol adapter. */
+export declare function createEvmVenueAdapter(id: ProtocolId): ProtocolAdapter;

package/dist/src/placements/adapters/factory.js

@@ -0,0 +1,62 @@
+import { asContractAddress, encodeBalanceOf, decodeUint256 } from "../evm.js";
+/** A Sui protocol adapter, defined by how one account's position is read. */
+export function createSuiVenueAdapter(options) {
+    return {
+        id: options.id,
+        chain: "sui",
+        // async so a pointer source that throws synchronously still lands in
+        // `failures` rather than rejecting the whole call.
+        async discover(coin, ctx) {
+            return ctx.pointers.placements(options.id, coin);
+        },
+        async read(refs, account, ctx) {
+            if (!ctx.sui)
+                throw new Error("no sui reader configured");
+            const reader = ctx.sui;
+            const readAt = new Date().toISOString();
+            const resolved = await Promise.all(refs.map(async (ref) => {
+                const amount = await options.read(ref, account, reader);
+                if (amount === undefined)
+                    return undefined;
+                return { ...ref, amount: amount.toString(), readAt };
+            }));
+            // A venue the account is not in simply does not appear.
+            return resolved.filter((p) => p !== undefined);
+        }
+    };
+}
+/** An EVM protocol adapter. */
+export function createEvmVenueAdapter(id) {
+    // Every EVM venue in scope hands the account a token to represent its
+    // position — an ERC-4626 vault issues its own address, a Pendle market
+    // issues PT/YT/LP at separate ones — so the position is that token's
+    // `balanceOf(account)` and the adapters need nothing protocol-specific.
+    return {
+        id,
+        chain: "evm",
+        async discover(coin, ctx) {
+            return ctx.pointers.placements(id, coin);
+        },
+        async read(refs, account, ctx) {
+            if (!ctx.evm)
+                throw new Error("no evm reader configured");
+            const reader = ctx.evm;
+            const readAt = new Date().toISOString();
+            const resolved = await Promise.all(refs.map(async (ref) => {
+                const chainId = ref.chain.chainId;
+                if (chainId === undefined) {
+                    throw new Error(`evm placement ${ref.venue} has no chainId`);
+                }
+                // The token the account actually holds, which is the venue
+                // itself only when the venue issues no separate share token.
+                const token = asContractAddress(ref.shareToken ?? ref.venue);
+                const raw = await reader.call(chainId, token, encodeBalanceOf(account), ref.rpcUrl);
+                const amount = decodeUint256(raw);
+                if (amount === 0n)
+                    return undefined;
+                return { ...ref, amount: amount.toString(), readAt };
+            }));
+            return resolved.filter((p) => p !== undefined);
+        }
+    };
+}

package/dist/src/placements/adapters/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./factory.js";
+export { alphalend } from "./alphalend.js";
+export { bluefinSpot } from "./bluefin-spot.js";
+export { current } from "./current.js";
+export { openCover } from "./evm-protocols.js";
+export { royco } from "./royco.js";
+export { navi } from "./navi.js";
+export { createPendleAdapter, pendle } from "./pendle.js";
+export { suilend } from "./suilend.js";
+/**
+ * Registers the adapters that ship with the SDK. Call once at start-up, or
+ * register a subset by hand to keep the surface small.
+ */
+export declare function registerBundledAdapters(): void;

package/dist/src/placements/adapters/index.js

@@ -0,0 +1,25 @@
+import { registerAdapter } from "../registry.js";
+import { alphalend } from "./alphalend.js";
+import { bluefinSpot } from "./bluefin-spot.js";
+import { current } from "./current.js";
+import { openCover } from "./evm-protocols.js";
+import { royco } from "./royco.js";
+import { navi } from "./navi.js";
+import { pendle } from "./pendle.js";
+import { suilend } from "./suilend.js";
+export * from "./factory.js";
+export { alphalend } from "./alphalend.js";
+export { bluefinSpot } from "./bluefin-spot.js";
+export { current } from "./current.js";
+export { openCover } from "./evm-protocols.js";
+export { royco } from "./royco.js";
+export { navi } from "./navi.js";
+export { createPendleAdapter, pendle } from "./pendle.js";
+export { suilend } from "./suilend.js";
+/**
+ * Registers the adapters that ship with the SDK. Call once at start-up, or
+ * register a subset by hand to keep the surface small.
+ */
+export function registerBundledAdapters() {
+    [bluefinSpot, suilend, alphalend, current, navi, pendle, royco, openCover].forEach(registerAdapter);
+}

package/dist/src/placements/adapters/navi.d.ts

@@ -0,0 +1 @@
+export declare const navi: import("../types.js").ProtocolAdapter;

package/dist/src/placements/adapters/navi.js

@@ -0,0 +1,53 @@
+import { bcsAddress, coinTypesMatch, tableId, toBigInt } from "../sui.js";
+import { createSuiVenueAdapter } from "./factory.js";
+/** Navi's fixed-point scale for its supply/borrow indexes. */
+const RAY = 10n ** 27n;
+/** Navi normalises every reserve to 9 decimals, whatever the coin's own are. */
+const NAVI_DECIMALS = 9;
+export const navi = createSuiVenueAdapter({
+    id: "navi",
+    async read(ref, account, reader) {
+        // Navi. A lender's balance lives in the shared `storage::Storage` object, in a
+        // per-reserve table keyed by depositor address, rather than in anything the
+        // account owns — so there is no cap or position object to walk from.
+        //
+        // That table is keyed by address and grows with the depositor count, so it is
+        // addressed by key rather than paged.
+        //
+        // Balances are stored scaled by the reserve's supply index and normalised to 9
+        // decimals, so they convert back through both.
+        const storages = await reader.objects([ref.venue]);
+        const storage = storages[ref.venue];
+        if (!storage)
+            throw new Error(`navi: storage ${ref.venue} not found on chain`);
+        const reservesId = tableId(storage.json.reserves);
+        if (!reservesId)
+            throw new Error(`navi: no reserves table on ${ref.venue}`);
+        // Navi runs several Storage objects and a coin may be listed in more
+        // than one, so only the reserve in this venue counts.
+        const reserves = await reader.dynamicFields(reservesId);
+        const reserve = reserves.find(entry => coinTypesMatch(String(entry.value?.coin_type ?? ""), ref.coin));
+        if (!reserve)
+            return undefined;
+        const value = reserve.value;
+        const supply = value.supply_balance;
+        const userStateId = tableId(supply?.user_state);
+        if (!userStateId)
+            return undefined;
+        const scaled = toBigInt(await reader.dynamicField(userStateId, {
+            type: "address",
+            bcs: bcsAddress(account)
+        }));
+        if (scaled === 0n)
+            return undefined;
+        const index = toBigInt(value.current_supply_index) || RAY;
+        // Balances are held at NAVI_DECIMALS regardless of the coin, so rescale
+        // in whichever direction the coin needs rather than clamping at zero —
+        // clamping silently under-reports a coin with more decimals than navi.
+        const shift = NAVI_DECIMALS - ref.decimals;
+        const amount = (scaled * index) / RAY;
+        return shift >= 0
+            ? amount / 10n ** BigInt(shift)
+            : amount * 10n ** BigInt(-shift);
+    }
+});

package/dist/src/placements/adapters/pendle.d.ts

@@ -0,0 +1,9 @@
+import { ProtocolAdapter } from "../types.js";
+export interface PendleOptions {
+    /** Overrides the public API, for a proxy or a test double. */
+    baseUrl?: string;
+    /** Injection seam for tests; defaults to `fetch`. */
+    load?: (url: string) => Promise<unknown>;
+}
+export declare function createPendleAdapter(options?: PendleOptions): ProtocolAdapter;
+export declare const pendle: ProtocolAdapter;

package/dist/src/placements/adapters/pendle.js

@@ -0,0 +1,108 @@
+const PENDLE_API = "https://api-v2.pendle.finance/core";
+/**
+ * Converts a decimal value to base units without going through a float at the
+ * end, so a large `decimals` does not turn the integer part into garbage.
+ */
+function toBaseUnits(value, decimals) {
+    if (!Number.isFinite(value) || value <= 0)
+        return 0n;
+    const [whole, fraction = ""] = value.toFixed(decimals).split(".");
+    return BigInt(whole + fraction.padEnd(decimals, "0").slice(0, decimals));
+}
+export function createPendleAdapter(options = {}) {
+    // Pendle.
+    //
+    // A Pendle position is not held in the receipt coin: splitting eEARN yields PT
+    // and YT, and providing liquidity yields an LP token. None of those is 1:1 with
+    // eEARN before maturity, so a raw `balanceOf` would be a wrong number rather
+    // than a useful one.
+    //
+    // So the amount reported here is the position's **underlying-equivalent**: what
+    // Pendle values the PT + YT + LP legs at, divided by the coin's own price. Two
+    // consequences worth knowing, both deliberate:
+    //  - it is market-priced, so it moves with the AMM rather than being a fixed
+    //    claim, and two reads seconds apart can differ;
+    //  - it comes from Pendle's API, so unlike every other adapter this `read`
+    //    depends on something other than chain state.
+    //
+    // Bare SY balances are not counted. SY is not tied to one market and is rare to
+    // hold directly; omitting it can only under-report, never misreport.
+    const baseUrl = (options.baseUrl ?? PENDLE_API).replace(/\/$/, "");
+    const load = options.load ??
+        (async (url) => {
+            const response = await fetch(url, {
+                headers: { Accept: "application/json" }
+            });
+            if (!response.ok)
+                throw new Error(`pendle api ${response.status}`);
+            return response.json();
+        });
+    return {
+        id: "pendle",
+        chain: "evm",
+        async discover(coin, ctx) {
+            return ctx.pointers.placements("pendle", coin);
+        },
+        // ctx is unused: Pendle values a position through its own API, not
+        // through the sui/evm readers.
+        async read(refs, account) {
+            if (refs.length === 0)
+                return [];
+            const readAt = new Date().toISOString();
+            const positions = (await load(`${baseUrl}/v1/dashboard/positions/database/${account}`));
+            // Resolve every chain id up front, so nothing downstream has to
+            // assert one is present.
+            const targets = refs.map(ref => {
+                const chainId = ref.chain.chainId;
+                if (chainId === undefined) {
+                    throw new Error(`pendle placement ${ref.venue} has no chainId`);
+                }
+                return { ref, chainId };
+            });
+            // One price call per chain, covering every coin asked about.
+            const coinsByChain = new Map();
+            for (const { ref, chainId } of targets) {
+                const coins = coinsByChain.get(chainId) ?? new Set();
+                coins.add(ref.coin.toLowerCase());
+                coinsByChain.set(chainId, coins);
+            }
+            const prices = new Map();
+            await Promise.all([...coinsByChain].map(async ([chainId, coins]) => {
+                const body = (await load(`${baseUrl}/v1/${chainId}/assets/prices?addresses=${[...coins].join(",")}`));
+                for (const [address, price] of Object.entries(body.prices ?? {})) {
+                    prices.set(`${chainId}-${address.toLowerCase()}`, price);
+                }
+            }));
+            const resolved = targets.map(({ ref, chainId }) => {
+                const chain = (positions.positions ?? []).find(p => p.chainId === chainId);
+                if (!chain)
+                    return undefined;
+                // Closed positions are scanned too: Pendle files a position
+                // there once exited, but a residual balance still counts.
+                const marketId = `${chainId}-${ref.venue.toLowerCase()}`;
+                const legs = [
+                    ...(chain.openPositions ?? []),
+                    ...(chain.closedPositions ?? [])
+                ].filter(p => p.marketId?.toLowerCase() === marketId);
+                if (legs.length === 0)
+                    return undefined;
+                const usd = legs.reduce((sum, p) => sum +
+                    (p.pt?.valuation ?? 0) +
+                    (p.yt?.valuation ?? 0) +
+                    (p.lp?.valuation ?? 0), 0);
+                if (usd <= 0)
+                    return undefined;
+                const price = prices.get(`${chainId}-${ref.coin.toLowerCase()}`);
+                if (!price) {
+                    throw new Error(`pendle: no price for ${ref.coin} on chain ${chainId}`);
+                }
+                const amount = toBaseUnits(usd / price, ref.decimals);
+                if (amount === 0n)
+                    return undefined;
+                return { ...ref, amount: amount.toString(), readAt };
+            });
+            return resolved.filter((p) => p !== undefined);
+        }
+    };
+}
+export const pendle = createPendleAdapter();

package/dist/src/placements/adapters/royco.d.ts

@@ -0,0 +1,2 @@
+import { ProtocolAdapter } from "../types.js";
+export declare const royco: ProtocolAdapter;

package/dist/src/placements/adapters/royco.js

@@ -0,0 +1,49 @@
+import { asContractAddress, decodeUint256, encodeBalanceOf } from "../evm.js";
+/** `convertToAssets(uint256)` */
+const CONVERT_TO_ASSETS = "0x07a2d13a";
+const WORD = 64;
+/**
+ * What `account` holds at one Royco tranche vault, in base units of `ref.coin`.
+ */
+async function trancheAssets(ref, account, ctx) {
+    if (!ctx.evm)
+        throw new Error("no evm reader configured");
+    const chainId = ref.chain.chainId;
+    if (chainId === undefined) {
+        throw new Error(`royco placement ${ref.venue} has no chainId`);
+    }
+    const vault = asContractAddress(ref.shareToken ?? ref.venue);
+    const shares = decodeUint256(await ctx.evm.call(chainId, vault, encodeBalanceOf(account), ref.rpcUrl));
+    if (shares === 0n)
+        return undefined;
+    // A tranche vault is not ERC-4626 despite the selector: convertToAssets
+    // returns AssetClaims { stAssets, jtAssets, nav }. The first two are the
+    // position in the deposit token's own decimals and are what the holder can
+    // claim; nav is a USD figure on a different scale. Taking one word — the
+    // obvious reading of a 4626 — reports a fraction of the position.
+    const raw = await ctx.evm.call(chainId, vault, `${CONVERT_TO_ASSETS}${shares.toString(16).padStart(WORD, "0")}`, ref.rpcUrl);
+    const body = raw.startsWith("0x") ? raw.slice(2) : raw;
+    if (body.length < WORD * 3) {
+        throw new Error(`royco: convertToAssets returned ${body.length / 2} bytes for ${ref.venue}`);
+    }
+    const stAssets = BigInt(`0x${body.slice(0, WORD)}`);
+    const jtAssets = BigInt(`0x${body.slice(WORD, WORD * 2)}`);
+    return stAssets + jtAssets;
+}
+export const royco = {
+    id: "royco",
+    chain: "evm",
+    async discover(coin, ctx) {
+        return ctx.pointers.placements("royco", coin);
+    },
+    async read(refs, account, ctx) {
+        const readAt = new Date().toISOString();
+        const resolved = await Promise.all(refs.map(async (ref) => {
+            const amount = await trancheAssets(ref, account, ctx);
+            if (amount === undefined)
+                return undefined;
+            return { ...ref, amount: amount.toString(), readAt };
+        }));
+        return resolved.filter((p) => p !== undefined);
+    }
+};

package/dist/src/placements/adapters/suilend.d.ts

@@ -0,0 +1 @@
+export declare const suilend: import("../types.js").ProtocolAdapter;

package/dist/src/placements/adapters/suilend.js

@@ -0,0 +1,57 @@
+import { coinTypesMatch, decimalToBaseUnits, toBigInt } from "../sui.js";
+import { createSuiVenueAdapter } from "./factory.js";
+export const suilend = createSuiVenueAdapter({
+    id: "suilend",
+    async read(ref, account, reader) {
+        // Suilend. An account holds an `ObligationOwnerCap` pointing at its obligation,
+        // which lists one deposit per coin.
+        //
+        // Deposits are denominated in cTokens, so they are converted through the
+        // reserve's exchange rate — total supplied over cTokens issued — to the
+        // underlying coin. Reading the raw cToken figure would under-report by whatever
+        // interest has accrued.
+        const markets = await reader.objects([ref.venue]);
+        const market = markets[ref.venue];
+        if (!market) {
+            throw new Error(`suilend: lending market ${ref.venue} not found on chain`);
+        }
+        const capType = ref.shareToken ??
+            `${market.type.split("::")[0]}::lending_market::ObligationOwnerCap`;
+        const caps = await reader.ownedObjects(account, capType);
+        if (caps.length === 0)
+            return undefined;
+        const reserves = (market.json.reserves ?? []);
+        const reserve = reserves.find(r => coinTypesMatch(r.coin_type ?? "", ref.coin));
+        if (!reserve)
+            return undefined;
+        const supplied = toBigInt(reserve.available_amount) +
+            decimalToBaseUnits(reserve.borrowed_amount);
+        const ctokens = toBigInt(reserve.ctoken_supply);
+        if (ctokens === 0n)
+            return undefined;
+        const obligationIds = caps
+            .map(cap => cap.json.obligation_id)
+            .filter((id) => Boolean(id));
+        const obligations = await reader.objects(obligationIds);
+        let deposited = 0n;
+        for (const id of obligationIds) {
+            const obligation = obligations[id];
+            if (!obligation)
+                continue;
+            // An account can hold obligations across several Suilend markets,
+            // and the same coin can be listed in more than one. Without this the
+            // deposits of every market would be summed into each venue's row.
+            if (obligation.json.lending_market_id !== ref.venue)
+                continue;
+            const deposits = (obligation.json.deposits ?? []);
+            for (const deposit of deposits) {
+                if (!coinTypesMatch(deposit.coin_type ?? "", ref.coin))
+                    continue;
+                deposited += toBigInt(deposit.deposited_ctoken_amount);
+            }
+        }
+        if (deposited === 0n)
+            return undefined;
+        return (deposited * supplied) / ctokens;
+    }
+});

package/dist/src/placements/batch.d.ts

@@ -0,0 +1,70 @@
+export interface TransportRequest {
+    items: number;
+    attempt: number;
+    status: number | "network-error";
+}
+export type BatchResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare class TransientError extends Error {
+    readonly retryAfterMs?: number;
+    constructor(message: string, retryAfterMs?: number);
+}
+export declare class ChunkTooLargeError extends Error {
+    constructor(message: string);
+}
+export declare class AbortedError extends Error {
+    constructor(message?: string);
+}
+export declare function retryAfterMs(header: string | null | undefined): number | undefined;
+export declare function isTransientStatus(status: number): boolean;
+export declare function isAbortError(error: unknown): boolean;
+export interface BatcherOptions<Item, Result> {
+    send: (items: Item[], attempt: number) => Promise<BatchResult<Result>[]>;
+    key: (item: Item) => string;
+    weight?: (item: Item) => number;
+    bytes?: (item: Item) => number;
+    maxWeight?: number;
+    maxBytes?: number;
+    concurrency?: number;
+    retries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    schedule?: (flush: () => void) => void;
+    signal?: AbortSignal;
+}
+export declare class Batcher<Item, Result> {
+    private readonly send;
+    private readonly key;
+    private readonly weight;
+    private readonly bytes;
+    private readonly maxWeight;
+    private readonly maxBytes;
+    private readonly concurrency;
+    private readonly retries;
+    private readonly baseDelayMs;
+    private readonly maxDelayMs;
+    private readonly sleep;
+    private readonly schedule;
+    private readonly signal?;
+    private readonly queue;
+    private readonly inFlight;
+    private readonly waiting;
+    private active;
+    private scheduled;
+    constructor(options: BatcherOptions<Item, Result>);
+    enqueue(item: Item): Promise<Result>;
+    private scheduleFlush;
+    private flush;
+    private chunk;
+    private run;
+    private retryLater;
+    private backoff;
+    private acquire;
+    private release;
+}