@ember-finance/sdk 2.11.0-pre.2 → 2.11.0-pre.4

package/dist/src/api/v2/models/coin-placement.d.ts

@@ -15,12 +15,30 @@
  * @interface CoinPlacement
  */
 export interface CoinPlacement {
+    /**
+     * Stable identity for this placement, for a client to key a list on. A protocol can list the same coin at several venues — the same pair at two fee tiers, or the two tranches of one market — so protocol and label together do not identify a row. Survives a re-sync.
+     * @type {string}
+     * @memberof CoinPlacement
+     */
+    id: string;
     /**
      * Adapter id, e.g. \"bluefin-spot\"
      * @type {string}
      * @memberof CoinPlacement
      */
     protocol: string;
+    /**
+     * The protocol\'s display name, e.g. \"Current Finance\". Absent when the protocol is not in our catalogue yet — render `protocol` then.
+     * @type {string}
+     * @memberof CoinPlacement
+     */
+    protocolName?: string;
+    /**
+     * Icon for the protocol. Absent when the protocol is not in our catalogue yet.
+     * @type {string}
+     * @memberof CoinPlacement
+     */
+    protocolLogoUrl?: string;
     /**
      * Chain identifier as catalogued, e.g. \"sui-mainnet\".
      * @type {string}

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

@@ -0,0 +1,61 @@
+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 function retryAfterMs(header: string | null | undefined): number | undefined;
+export declare function isTransientStatus(status: number): 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;
+    sleep?: (ms: number) => Promise<void>;
+    schedule?: (flush: () => void) => void;
+}
+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 sleep;
+    private readonly schedule;
+    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 backoff;
+    private acquire;
+    private release;
+}

package/dist/src/placements/batch.js

@@ -0,0 +1,166 @@
+export class TransientError extends Error {
+    constructor(message, retryAfterMs) {
+        super(message);
+        this.name = "TransientError";
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export class ChunkTooLargeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ChunkTooLargeError";
+    }
+}
+export function retryAfterMs(header) {
+    if (!header)
+        return undefined;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const at = Date.parse(header);
+    return Number.isNaN(at) ? undefined : Math.max(0, at - Date.now());
+}
+export function isTransientStatus(status) {
+    return status === 429 || status >= 500;
+}
+const defaultSleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const defaultSchedule = (flush) => {
+    setTimeout(flush, 0);
+};
+export class Batcher {
+    constructor(options) {
+        this.queue = [];
+        this.inFlight = new Map();
+        this.waiting = [];
+        this.active = 0;
+        this.scheduled = false;
+        this.send = options.send;
+        this.key = options.key;
+        this.weight = options.weight ?? (() => 1);
+        this.bytes = options.bytes ?? (() => 0);
+        this.maxWeight = options.maxWeight ?? 10;
+        this.maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
+        this.concurrency = options.concurrency ?? 3;
+        this.retries = options.retries ?? 3;
+        this.baseDelayMs = options.baseDelayMs ?? 300;
+        this.sleep = options.sleep ?? defaultSleep;
+        this.schedule = options.schedule ?? defaultSchedule;
+    }
+    enqueue(item) {
+        const key = this.key(item);
+        const shared = this.inFlight.get(key);
+        if (shared)
+            return shared;
+        const promise = new Promise((resolve, reject) => {
+            this.queue.push({ item, resolve, reject });
+        });
+        this.inFlight.set(key, promise);
+        const forget = () => {
+            if (this.inFlight.get(key) === promise)
+                this.inFlight.delete(key);
+        };
+        promise.then(forget, forget);
+        this.scheduleFlush();
+        return promise;
+    }
+    scheduleFlush() {
+        if (this.scheduled)
+            return;
+        this.scheduled = true;
+        this.schedule(() => {
+            this.scheduled = false;
+            this.flush();
+        });
+    }
+    flush() {
+        const pending = this.queue.splice(0);
+        for (const chunk of this.chunk(pending)) {
+            void this.run(chunk, 1);
+        }
+    }
+    chunk(pending) {
+        const chunks = [];
+        let current = [];
+        let weight = 0;
+        let bytes = 0;
+        for (const entry of pending) {
+            const entryWeight = this.weight(entry.item);
+            const entryBytes = this.bytes(entry.item);
+            const overflows = weight + entryWeight > this.maxWeight ||
+                bytes + entryBytes > this.maxBytes;
+            if (current.length > 0 && overflows) {
+                chunks.push(current);
+                current = [];
+                weight = 0;
+                bytes = 0;
+            }
+            current.push(entry);
+            weight += entryWeight;
+            bytes += entryBytes;
+        }
+        if (current.length > 0)
+            chunks.push(current);
+        return chunks;
+    }
+    async run(chunk, attempt) {
+        await this.acquire();
+        let results;
+        try {
+            results = await this.send(chunk.map(entry => entry.item), attempt);
+        }
+        catch (error) {
+            this.release();
+            if (error instanceof ChunkTooLargeError && chunk.length > 1) {
+                const half = Math.ceil(chunk.length / 2);
+                void this.run(chunk.slice(0, half), 1);
+                void this.run(chunk.slice(half), 1);
+                return;
+            }
+            if (error instanceof TransientError && attempt <= this.retries) {
+                await this.sleep(error.retryAfterMs ?? this.backoff(attempt));
+                void this.run(chunk, attempt + 1);
+                return;
+            }
+            const failure = error instanceof Error ? error : new Error(String(error));
+            for (const entry of chunk)
+                entry.reject(failure);
+            return;
+        }
+        this.release();
+        chunk.forEach((entry, index) => {
+            const result = results[index];
+            if (result === undefined) {
+                entry.reject(new Error("batch: no result for item"));
+                return;
+            }
+            if (result.ok === true) {
+                entry.resolve(result.value);
+                return;
+            }
+            entry.reject(result.error);
+        });
+    }
+    backoff(attempt) {
+        const base = this.baseDelayMs * 2 ** (attempt - 1);
+        const jitter = base * 0.3 * (Math.random() * 2 - 1);
+        return Math.round(base + jitter);
+    }
+    acquire() {
+        if (this.active < this.concurrency) {
+            this.active += 1;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => {
+            this.waiting.push(() => {
+                this.active += 1;
+                resolve();
+            });
+        });
+    }
+    release() {
+        this.active -= 1;
+        const next = this.waiting.shift();
+        if (next)
+            next();
+    }
+}

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

@@ -8,6 +8,7 @@ export declare class PlacementsClient {
     constructor(ctx: PlacementsContext);
     /** One vault, one account. */
     forAccount(vaultId: string, account: string, options?: ForAccountOptions): Promise<AccountShares[]>;
+    forAccounts(vaultIds: string[], account: string, options?: ForAccountOptions): Promise<AccountShares[]>;
     private sharesForCoin;
     private walletBalance;
     private coveredBalance;

package/dist/src/placements/client.js

@@ -24,6 +24,16 @@ function addressFits(chain, account) {
         return false;
     return chain === "evm" ? hex.length <= 40 : hex.length <= 64;
 }
+function unresolvedVault(vaultId, reason) {
+    return {
+        vaultId,
+        coin: { coin: "", chain: { type: "sui" }, decimals: 0 },
+        available: "0",
+        covered: undefined,
+        placements: [],
+        failures: [{ protocol: "vault", stage: "discover", reason }]
+    };
+}
 export class PlacementsClient {
     constructor(ctx) {
         this.ctx = ctx;
@@ -35,6 +45,24 @@ export class PlacementsClient {
         const coins = await this.ctx.vaults.coinsForVault(vaultId);
         return Promise.all(coins.map(coin => this.sharesForCoin(vaultId, coin, account, options)));
     }
+    async forAccounts(vaultIds, account, options = {}) {
+        if (!this.ctx.vaults)
+            throw new Error("no vault resolver configured");
+        const vaults = this.ctx.vaults;
+        const resolved = await Promise.all(vaultIds.map(async (vaultId) => {
+            try {
+                return { vaultId, coins: await vaults.coinsForVault(vaultId) };
+            }
+            catch (error) {
+                return { vaultId, coins: undefined, reason: reasonOf(error) };
+            }
+        }));
+        return Promise.all(resolved.flatMap(entry => entry.coins
+            ? entry.coins.map(coin => this.sharesForCoin(entry.vaultId, coin, account, options))
+            : [
+                Promise.resolve(unresolvedVault(entry.vaultId, entry.reason ?? ""))
+            ]));
+    }
     async sharesForCoin(vaultId, coin, account, options) {
         const failures = [];
         // A vault on several chains issues a coin on each, so for any one

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

@@ -1,11 +1,15 @@
 import { EvmReader } from "./types.js";
+import { TransportRequest } from "./batch.js";
 export declare function encodeBalanceOf(owner: string): string;
 export declare function asContractAddress(address: string): string;
 export declare function decodeUint256(hex: string): bigint;
-/**
- * JSON-RPC reader over `fetch`, so it runs unchanged in the browser.
- *
- * Pass a dedicated endpoint per chain in production: the public RPCs used for
- * development are rate-limited and carry no SLA.
- */
-export declare function jsonRpcEvmReader(endpoints?: Record<number, string>): EvmReader;
+export interface JsonRpcEvmReaderOptions {
+    maxCalls?: number;
+    concurrency?: number;
+    retries?: number;
+    baseDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    fetch?: typeof globalThis.fetch;
+    onRequest?: (request: TransportRequest) => void;
+}
+export declare function jsonRpcEvmReader(endpoints?: Record<number, string>, options?: JsonRpcEvmReaderOptions): EvmReader;

package/dist/src/placements/evm.js

@@ -1,3 +1,4 @@
+import { Batcher, ChunkTooLargeError, TransientError, isTransientStatus, retryAfterMs } from "./batch.js";
 /** `balanceOf(address)` */
 const BALANCE_OF_SELECTOR = "0x70a08231";
 export function encodeBalanceOf(owner) {
@@ -15,34 +16,94 @@ export function decodeUint256(hex) {
         return 0n;
     return BigInt(hex);
 }
-/**
- * JSON-RPC reader over `fetch`, so it runs unchanged in the browser.
- *
- * Pass a dedicated endpoint per chain in production: the public RPCs used for
- * development are rate-limited and carry no SLA.
- */
-export function jsonRpcEvmReader(endpoints = {}) {
+function jsonRpcRequest(call, id) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        method: "eth_call",
+        params: [{ to: call.to, data: call.data }, "latest"]
+    };
+}
+function toResult(entry) {
+    if (!entry)
+        return { ok: false, error: new Error("evm rpc: no result for call") };
+    if (entry.error)
+        return { ok: false, error: new Error(`evm rpc: ${entry.error.message}`) };
+    return { ok: true, value: entry.result ?? "0x" };
+}
+export function jsonRpcEvmReader(endpoints = {}, options = {}) {
+    const fetchImpl = options.fetch ??
+        ((input, init) => globalThis.fetch(input, init));
+    const onRequest = options.onRequest;
+    const batchers = new Map();
+    const singleOnly = new Set();
+    const post = async (endpoint, body, items, attempt) => {
+        try {
+            const response = await fetchImpl(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body)
+            });
+            onRequest?.({ items, attempt, status: response.status });
+            return response;
+        }
+        catch (error) {
+            onRequest?.({ items, attempt, status: "network-error" });
+            throw new TransientError(`evm rpc: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const send = async (endpoint, calls, attempt) => {
+        const batched = calls.length > 1;
+        if (batched && singleOnly.has(endpoint)) {
+            throw new ChunkTooLargeError("evm rpc: batch unsupported");
+        }
+        const body = batched
+            ? calls.map((call, id) => jsonRpcRequest(call, id))
+            : jsonRpcRequest(calls[0], 1);
+        const response = await post(endpoint, body, calls.length, attempt);
+        if (isTransientStatus(response.status)) {
+            throw new TransientError(`evm rpc ${response.status}`, retryAfterMs(response.headers?.get("retry-after")));
+        }
+        if (!response.ok) {
+            if (batched) {
+                singleOnly.add(endpoint);
+                throw new ChunkTooLargeError(`evm rpc ${response.status}`);
+            }
+            throw new Error(`evm rpc ${response.status}`);
+        }
+        const parsed = (await response.json());
+        if (!batched) {
+            return [toResult(Array.isArray(parsed) ? parsed[0] : parsed)];
+        }
+        if (!Array.isArray(parsed)) {
+            singleOnly.add(endpoint);
+            throw new ChunkTooLargeError("evm rpc: batch unsupported");
+        }
+        const byId = new Map(parsed.map(entry => [Number(entry.id), entry]));
+        return calls.map((_, id) => toResult(byId.get(id)));
+    };
+    const batcherFor = (endpoint) => {
+        const existing = batchers.get(endpoint);
+        if (existing)
+            return existing;
+        const batcher = new Batcher({
+            send: (calls, attempt) => send(endpoint, calls, attempt),
+            key: call => `${call.to.toLowerCase()}:${call.data.toLowerCase()}`,
+            maxWeight: options.maxCalls ?? 20,
+            concurrency: options.concurrency,
+            retries: options.retries,
+            baseDelayMs: options.baseDelayMs,
+            sleep: options.sleep
+        });
+        batchers.set(endpoint, batcher);
+        return batcher;
+    };
     return {
         async call(chainId, to, data, override) {
             const endpoint = override ?? endpoints[chainId];
             if (!endpoint)
                 throw new Error(`no evm endpoint for chain ${chainId}`);
-            const response = await fetch(endpoint, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: 1,
-                    method: "eth_call",
-                    params: [{ to, data }, "latest"]
-                })
-            });
-            if (!response.ok)
-                throw new Error(`evm rpc ${response.status}`);
-            const body = (await response.json());
-            if (body.error)
-                throw new Error(`evm rpc: ${body.error.message}`);
-            return body.result ?? "0x";
+            return batcherFor(endpoint).enqueue({ to, data });
         }
     };
 }

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

@@ -1,4 +1,5 @@
 export * from "./types.js";
+export * from "./batch.js";
 export * from "./registry.js";
 export * from "./client.js";
 export * from "./pointers.js";

package/dist/src/placements/index.js

@@ -1,4 +1,5 @@
 export * from "./types.js";
+export * from "./batch.js";
 export * from "./registry.js";
 export * from "./client.js";
 export * from "./pointers.js";

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

@@ -1,4 +1,5 @@
 import { SuiReader } from "./types.js";
+import { TransportRequest } from "./batch.js";
 /**
  * Canonical form for a Sui coin type: `0x` stripped from the address segment,
  * lowercased and left-padded to 64 hex chars.
@@ -28,8 +29,16 @@ export declare function tableId(field: unknown): string | undefined;
  */
 export declare function decimalToBaseUnits(field: unknown): bigint;
 export declare function toBigInt(field: unknown): bigint;
-/**
- * GraphQL-backed reader. Uses `fetch` only, so it runs in the browser as well
- * as Node: the Sui GraphQL endpoint answers with `access-control-allow-origin: *`.
- */
-export declare function graphqlSuiReader(endpoint?: string): SuiReader;
+export declare const DEFAULT_SUI_GRAPHQL_ENDPOINT = "https://graphql.mainnet.sui.io/graphql";
+export interface GraphqlSuiReaderOptions {
+    endpoint?: string;
+    maxRootFields?: number;
+    maxBytes?: number;
+    concurrency?: number;
+    retries?: number;
+    baseDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    fetch?: typeof globalThis.fetch;
+    onRequest?: (request: TransportRequest) => void;
+}
+export declare function graphqlSuiReader(options?: string | GraphqlSuiReaderOptions): SuiReader;

package/dist/src/placements/sui.js

@@ -1,3 +1,4 @@
+import { Batcher, ChunkTooLargeError, TransientError, isTransientStatus, retryAfterMs } from "./batch.js";
 const GRAPHQL_PAGE_SIZE = 50;
 /**
  * Canonical form for a Sui coin type: `0x` stripped from the address segment,
@@ -84,59 +85,140 @@ export function toBigInt(field) {
         return 0n;
     return BigInt(String(field));
 }
-async function query(endpoint, gql) {
-    const response = await fetch(endpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query: gql })
+export const DEFAULT_SUI_GRAPHQL_ENDPOINT = "https://graphql.mainnet.sui.io/graphql";
+const OBJECTS_ALIAS = "objects";
+const OBJECT_SELECTION = "{ address asMoveObject { contents { type { repr } json } } }";
+const OBJECT_KEY_WEIGHT = 0.25;
+const OBJECT_KEY_BYTES = 90;
+function normalizeAddress(address) {
+    return address.trim().toLowerCase().replace(/^0x/, "").padStart(64, "0");
+}
+function buildDocument(chunk) {
+    const roots = [];
+    const ids = chunk.flatMap(item => (item.kind === "object" ? [item.id] : []));
+    if (ids.length > 0) {
+        const keys = ids.map(id => `{ address: "${id}" }`).join(", ");
+        roots.push(`${OBJECTS_ALIAS}: multiGetObjects(keys: [${keys}]) ${OBJECT_SELECTION}`);
+    }
+    chunk.forEach((item, index) => {
+        if (item.kind === "field")
+            roots.push(`r${index}: ${item.field}`);
     });
-    if (!response.ok) {
-        throw new Error(`sui graphql ${response.status}`);
+    return `{ ${roots.join(" ")} }`;
+}
+function distribute(chunk, body) {
+    const pathErrors = new Map();
+    const rootErrors = [];
+    for (const error of body.errors ?? []) {
+        const alias = error.path?.[0];
+        if (typeof alias === "string") {
+            pathErrors.set(alias, error.message);
+        }
+        else {
+            rootErrors.push(error.message);
+        }
     }
-    const body = (await response.json());
-    if (body.errors?.length) {
-        throw new Error(`sui graphql: ${body.errors.map(e => e.message).join("; ")}`);
+    if (rootErrors.length > 0) {
+        const message = `sui graphql: ${rootErrors.join("; ")}`;
+        if (chunk.length > 1)
+            throw new ChunkTooLargeError(message);
+        throw new Error(message);
     }
-    if (!body.data)
-        throw new Error("sui graphql: empty response");
-    return body.data;
+    const data = body.data ?? {};
+    const objectsByAddress = new Map();
+    for (const node of data[OBJECTS_ALIAS] ?? []) {
+        const contents = node?.asMoveObject?.contents;
+        if (!node || !contents)
+            continue;
+        objectsByAddress.set(normalizeAddress(node.address), {
+            address: node.address,
+            type: contents.type.repr,
+            json: contents.json
+        });
+    }
+    return chunk.map((item, index) => {
+        const alias = item.kind === "object" ? OBJECTS_ALIAS : `r${index}`;
+        const message = pathErrors.get(alias);
+        if (message !== undefined) {
+            return { ok: false, error: new Error(`sui graphql: ${message}`) };
+        }
+        if (item.kind === "object") {
+            return { ok: true, value: objectsByAddress.get(normalizeAddress(item.id)) };
+        }
+        return { ok: true, value: data[alias] };
+    });
 }
-/**
- * GraphQL-backed reader. Uses `fetch` only, so it runs in the browser as well
- * as Node: the Sui GraphQL endpoint answers with `access-control-allow-origin: *`.
- */
-export function graphqlSuiReader(endpoint = "https://graphql.mainnet.sui.io/graphql") {
+export function graphqlSuiReader(options = {}) {
+    const config = typeof options === "string" ? { endpoint: options } : options;
+    const endpoint = config.endpoint ?? DEFAULT_SUI_GRAPHQL_ENDPOINT;
+    const fetchImpl = config.fetch ??
+        ((input, init) => globalThis.fetch(input, init));
+    const onRequest = config.onRequest;
+    const send = async (chunk, attempt) => {
+        const document = buildDocument(chunk);
+        let response;
+        try {
+            response = await fetchImpl(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ query: document })
+            });
+        }
+        catch (error) {
+            onRequest?.({ items: chunk.length, attempt, status: "network-error" });
+            throw new TransientError(`sui graphql: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        onRequest?.({ items: chunk.length, attempt, status: response.status });
+        if (isTransientStatus(response.status)) {
+            throw new TransientError(`sui graphql ${response.status}`, retryAfterMs(response.headers?.get("retry-after")));
+        }
+        if (!response.ok) {
+            const message = `sui graphql ${response.status}`;
+            if (chunk.length > 1)
+                throw new ChunkTooLargeError(message);
+            throw new Error(message);
+        }
+        const body = (await response.json());
+        if (!body.data && !body.errors?.length) {
+            throw new Error("sui graphql: empty response");
+        }
+        return distribute(chunk, body);
+    };
+    const batcher = new Batcher({
+        send,
+        key: item => item.kind === "object" ? `object:${normalizeAddress(item.id)}` : item.field,
+        weight: item => (item.kind === "object" ? OBJECT_KEY_WEIGHT : 1),
+        bytes: item => (item.kind === "object" ? OBJECT_KEY_BYTES : item.field.length),
+        maxWeight: config.maxRootFields ?? 10,
+        maxBytes: config.maxBytes ?? 4500,
+        concurrency: config.concurrency,
+        retries: config.retries,
+        baseDelayMs: config.baseDelayMs,
+        sleep: config.sleep
+    });
+    const field = (gql) => batcher.enqueue({ kind: "field", field: gql });
     return {
         async objects(ids) {
             const unique = [...new Set(ids)];
-            if (unique.length === 0)
-                return {};
-            const keys = unique.map(id => `{ address: "${id}" }`).join(", ");
-            const data = await query(endpoint, `{ multiGetObjects(keys: [${keys}]) { address asMoveObject { contents { type { repr } json } } } }`);
+            const found = await Promise.all(unique.map(id => batcher.enqueue({ kind: "object", id })));
             const out = {};
-            for (const node of data.multiGetObjects ?? []) {
-                const contents = node?.asMoveObject?.contents;
-                if (!contents)
-                    continue;
-                out[node.address] = {
-                    address: node.address,
-                    type: contents.type.repr,
-                    json: contents.json
-                };
+            for (const object of found) {
+                if (object)
+                    out[object.address] = object;
             }
             return out;
         },
         async balance(owner, coinType) {
-            const data = await query(endpoint, `{ address(address: "${owner}") { balance(coinType: "${coinType}") { totalBalance } } }`);
-            return data.address?.balance?.totalBalance ?? "0";
+            const data = await field(`address(address: "${owner}") { balance(coinType: "${coinType}") { totalBalance } }`);
+            return data?.balance?.totalBalance ?? "0";
         },
         async ownedObjects(owner, type) {
             const owned = [];
             let cursor = null;
             for (;;) {
                 const after = cursor ? `, after: "${cursor}"` : "";
-                const page = await query(endpoint, `{ address(address: "${owner}") { objects(first: ${GRAPHQL_PAGE_SIZE}${after}, filter: { type: "${type}" }) { pageInfo { hasNextPage endCursor } nodes { address contents { type { repr } json } } } } }`);
-                const container = page.address?.objects;
+                const page = await field(`address(address: "${owner}") { objects(first: ${GRAPHQL_PAGE_SIZE}${after}, filter: { type: "${type}" }) { pageInfo { hasNextPage endCursor } nodes { address contents { type { repr } json } } } }`);
+                const container = page?.objects;
                 if (!container)
                     break;
                 for (const node of container.nodes ?? []) {
@@ -155,19 +237,16 @@ export function graphqlSuiReader(endpoint = "https://graphql.mainnet.sui.io/grap
             return owned;
         },
         async dynamicField(parentId, key) {
-            const data = await query(endpoint, `{ address(address: "${parentId}") { dynamicField(name: { type: "${key.type}", bcs: "${key.bcs}" }) { value { ... on MoveValue { json } } } } }`);
-            return data.address?.dynamicField?.value?.json;
+            const data = await field(`address(address: "${parentId}") { dynamicField(name: { type: "${key.type}", bcs: "${key.bcs}" }) { value { ... on MoveValue { json } } } }`);
+            return data?.dynamicField?.value?.json;
         },
         async dynamicFields(parentId, limit) {
             const fields = [];
             let cursor = null;
-            // Paged rather than fetched by name: addressing a table entry by key
-            // needs the key BCS-encoded, and these tables are small enough
-            // (tens of entries) that a full walk is cheaper than that machinery.
             for (;;) {
                 const after = cursor ? `, after: "${cursor}"` : "";
-                const page = await query(endpoint, `{ address(address: "${parentId}") { dynamicFields(first: ${GRAPHQL_PAGE_SIZE}${after}) { pageInfo { hasNextPage endCursor } nodes { name { json } value { ... on MoveValue { type { repr } json } } } } } }`);
-                const container = page.address?.dynamicFields;
+                const page = await field(`address(address: "${parentId}") { dynamicFields(first: ${GRAPHQL_PAGE_SIZE}${after}) { pageInfo { hasNextPage endCursor } nodes { name { json } value { ... on MoveValue { type { repr } json } } } } }`);
+                const container = page?.dynamicFields;
                 if (!container)
                     break;
                 for (const node of container.nodes ?? []) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@ember-finance/sdk",
     "description": "Ember Protocol SDK",
-    "version": "2.11.0-pre.2",
+    "version": "2.11.0-pre.4",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",