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

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

@@ -17,8 +17,12 @@ export declare class TransientError extends Error {
 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;
@@ -29,8 +33,10 @@ export interface BatcherOptions<Item, Result> {
     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;
@@ -42,8 +48,10 @@ export declare class Batcher<Item, Result> {
     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;
@@ -55,6 +63,7 @@ export declare class Batcher<Item, Result> {
     private flush;
     private chunk;
     private run;
+    private retryLater;
     private backoff;
     private acquire;
     private release;

package/dist/src/placements/batch.js

@@ -11,6 +11,12 @@ export class ChunkTooLargeError extends Error {
         this.name = "ChunkTooLargeError";
     }
 }
+export class AbortedError extends Error {
+    constructor(message = "aborted") {
+        super(message);
+        this.name = "AbortedError";
+    }
+}
 export function retryAfterMs(header) {
     if (!header)
         return undefined;
@@ -23,6 +29,10 @@ export function retryAfterMs(header) {
 export function isTransientStatus(status) {
     return status === 429 || status >= 500;
 }
+export function isAbortError(error) {
+    return (error instanceof AbortedError ||
+        (error instanceof Error && error.name === "AbortError"));
+}
 const defaultSleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 const defaultSchedule = (flush) => {
     setTimeout(flush, 0);
@@ -43,10 +53,14 @@ export class Batcher {
         this.concurrency = options.concurrency ?? 3;
         this.retries = options.retries ?? 3;
         this.baseDelayMs = options.baseDelayMs ?? 300;
+        this.maxDelayMs = options.maxDelayMs ?? 10000;
         this.sleep = options.sleep ?? defaultSleep;
         this.schedule = options.schedule ?? defaultSchedule;
+        this.signal = options.signal;
     }
     enqueue(item) {
+        if (this.signal?.aborted)
+            return Promise.reject(new AbortedError());
         const key = this.key(item);
         const shared = this.inFlight.get(key);
         if (shared)
@@ -103,6 +117,11 @@ export class Batcher {
         return chunks;
     }
     async run(chunk, attempt) {
+        if (this.signal?.aborted) {
+            for (const entry of chunk)
+                entry.reject(new AbortedError());
+            return;
+        }
         await this.acquire();
         let results;
         try {
@@ -117,8 +136,7 @@ export class Batcher {
                 return;
             }
             if (error instanceof TransientError && attempt <= this.retries) {
-                await this.sleep(error.retryAfterMs ?? this.backoff(attempt));
-                void this.run(chunk, attempt + 1);
+                await this.retryLater(chunk, attempt, error.retryAfterMs);
                 return;
             }
             const failure = error instanceof Error ? error : new Error(String(error));
@@ -127,6 +145,8 @@ export class Batcher {
             return;
         }
         this.release();
+        const throttled = [];
+        let retryAfter;
         chunk.forEach((entry, index) => {
             const result = results[index];
             if (result === undefined) {
@@ -137,8 +157,19 @@ export class Batcher {
                 entry.resolve(result.value);
                 return;
             }
+            if (result.error instanceof TransientError && attempt <= this.retries) {
+                throttled.push(entry);
+                retryAfter = retryAfter ?? result.error.retryAfterMs;
+                return;
+            }
             entry.reject(result.error);
         });
+        if (throttled.length > 0)
+            await this.retryLater(throttled, attempt, retryAfter);
+    }
+    async retryLater(chunk, attempt, retryAfter) {
+        await this.sleep(Math.min(retryAfter ?? this.backoff(attempt), this.maxDelayMs));
+        void this.run(chunk, attempt + 1);
     }
     backoff(attempt) {
         const base = this.baseDelayMs * 2 ** (attempt - 1);

package/dist/src/placements/client.js

@@ -31,7 +31,8 @@ function unresolvedVault(vaultId, reason) {
         available: "0",
         covered: undefined,
         placements: [],
-        failures: [{ protocol: "vault", stage: "discover", reason }]
+        failures: [{ protocol: "vault", stage: "discover", reason }],
+        unresolved: true
     };
 }
 export class PlacementsClient {
@@ -51,7 +52,15 @@ export class PlacementsClient {
         const vaults = this.ctx.vaults;
         const resolved = await Promise.all(vaultIds.map(async (vaultId) => {
             try {
-                return { vaultId, coins: await vaults.coinsForVault(vaultId) };
+                const coins = await vaults.coinsForVault(vaultId);
+                if (!Array.isArray(coins) || coins.length === 0) {
+                    return {
+                        vaultId,
+                        coins: undefined,
+                        reason: "resolver returned no coins"
+                    };
+                }
+                return { vaultId, coins };
             }
             catch (error) {
                 return { vaultId, coins: undefined, reason: reasonOf(error) };

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

@@ -1,5 +1,6 @@
 import { EvmReader } from "./types.js";
 import { TransportRequest } from "./batch.js";
+export type { 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;
@@ -8,8 +9,21 @@ export interface JsonRpcEvmReaderOptions {
     concurrency?: number;
     retries?: number;
     baseDelayMs?: number;
+    maxDelayMs?: number;
     sleep?: (ms: number) => Promise<void>;
     fetch?: typeof globalThis.fetch;
+    signal?: AbortSignal;
     onRequest?: (request: TransportRequest) => void;
+    multicall?: boolean;
 }
+interface EvmCall {
+    to: string;
+    data: string;
+}
+export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export declare function encodeAggregate3(calls: EvmCall[]): string;
+export declare function decodeAggregate3(data: string, count: number): {
+    success: boolean;
+    data: string;
+}[];
 export declare function jsonRpcEvmReader(endpoints?: Record<number, string>, options?: JsonRpcEvmReaderOptions): EvmReader;

package/dist/src/placements/evm.js

@@ -1,4 +1,4 @@
-import { Batcher, ChunkTooLargeError, TransientError, isTransientStatus, retryAfterMs } from "./batch.js";
+import { Batcher, ChunkTooLargeError, TransientError, isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
 /** `balanceOf(address)` */
 const BALANCE_OF_SELECTOR = "0x70a08231";
 export function encodeBalanceOf(owner) {
@@ -16,72 +16,240 @@ export function decodeUint256(hex) {
         return 0n;
     return BigInt(hex);
 }
-function jsonRpcRequest(call, id) {
-    return {
-        jsonrpc: "2.0",
-        id,
-        method: "eth_call",
-        params: [{ to: call.to, data: call.data }, "latest"]
+export const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+const AGGREGATE3_SELECTOR = "0x82ad56cb";
+const RATE_LIMITED = /too many requests|rate ?limit/i;
+const HEX = /^(0x)?[0-9a-fA-F]*$/;
+class HttpError extends Error {
+    constructor(status) {
+        super(`evm rpc ${status}`);
+        this.name = "HttpError";
+        this.status = status;
+    }
+}
+function stripHex(value) {
+    return value.trim().replace(/^0x/i, "");
+}
+function word(value) {
+    return BigInt(value).toString(16).padStart(64, "0");
+}
+function addressWord(address) {
+    return stripHex(address).toLowerCase().padStart(64, "0");
+}
+function bytesWords(data) {
+    const raw = stripHex(data);
+    const length = raw.length / 2;
+    const padded = raw.padEnd(Math.ceil(length / 32) * 64, "0");
+    return word(length) + padded;
+}
+export function encodeAggregate3(calls) {
+    const tuples = calls.map(call => addressWord(call.to) + word(1) + word(0x60) + bytesWords(call.data));
+    let offset = calls.length * 32;
+    const offsets = tuples.map(tuple => {
+        const current = offset;
+        offset += tuple.length / 2;
+        return word(current);
+    });
+    return (AGGREGATE3_SELECTOR +
+        word(0x20) +
+        word(calls.length) +
+        offsets.join("") +
+        tuples.join(""));
+}
+export function decodeAggregate3(data, count) {
+    const raw = stripHex(data);
+    const read = (byteOffset) => {
+        const slice = raw.slice(byteOffset * 2, byteOffset * 2 + 64);
+        if (slice.length !== 64)
+            throw new Error("multicall: truncated response");
+        return Number(BigInt(`0x${slice}`));
     };
+    const arrayOffset = read(0);
+    const length = read(arrayOffset);
+    if (length !== count)
+        throw new Error("multicall: result count mismatch");
+    const base = arrayOffset + 32;
+    const results = [];
+    for (let index = 0; index < length; index += 1) {
+        const tupleOffset = base + read(base + index * 32);
+        const success = read(tupleOffset) === 1;
+        const bytesOffset = tupleOffset + read(tupleOffset + 32);
+        const bytesLength = read(bytesOffset);
+        const start = (bytesOffset + 32) * 2;
+        const body = raw.slice(start, start + bytesLength * 2);
+        if (body.length !== bytesLength * 2)
+            throw new Error("multicall: truncated response");
+        results.push({ success, data: `0x${body}` });
+    }
+    return results;
+}
+function jsonRpcRequest(method, params, id) {
+    return { jsonrpc: "2.0", id, method, params };
+}
+function callRequest(call, id) {
+    return jsonRpcRequest("eth_call", [{ to: call.to, data: call.data }, "latest"], id);
+}
+function isRateLimited(entry) {
+    const error = entry?.error;
+    if (!error)
+        return false;
+    return error.code === -32005 || RATE_LIMITED.test(error.message ?? "");
 }
 function toResult(entry) {
     if (!entry)
         return { ok: false, error: new Error("evm rpc: no result for call") };
+    if (isRateLimited(entry)) {
+        return {
+            ok: false,
+            error: new TransientError(`evm rpc: ${entry.error?.message}`)
+        };
+    }
     if (entry.error)
         return { ok: false, error: new Error(`evm rpc: ${entry.error.message}`) };
     return { ok: true, value: entry.result ?? "0x" };
 }
+function validateCall(to, data) {
+    const address = stripHex(to);
+    if (!HEX.test(to) || address.length !== 40) {
+        throw new Error(`evm rpc: ${to} is not a contract address`);
+    }
+    const calldata = stripHex(data);
+    if (!HEX.test(data) || calldata.length % 2 !== 0) {
+        throw new Error(`evm rpc: calldata ${data} is not even-length hex`);
+    }
+}
 export function jsonRpcEvmReader(endpoints = {}, options = {}) {
     const fetchImpl = options.fetch ??
         ((input, init) => globalThis.fetch(input, init));
     const onRequest = options.onRequest;
+    const useMulticall = options.multicall ?? false;
     const batchers = new Map();
-    const singleOnly = new Set();
+    const modes = new Map();
+    const probes = new Map();
     const post = async (endpoint, body, items, attempt) => {
+        let response;
         try {
-            const response = await fetchImpl(endpoint, {
+            response = await fetchImpl(endpoint, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(body)
+                body: JSON.stringify(body),
+                signal: options.signal
             });
-            onRequest?.({ items, attempt, status: response.status });
-            return response;
         }
         catch (error) {
+            if (isAbortError(error))
+                throw 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);
+        onRequest?.({ items, attempt, status: response.status });
         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}`);
+        if (!response.ok)
+            throw new HttpError(response.status);
+        return response;
+    };
+    const rpc = async (endpoint, method, params, items, attempt) => {
+        const response = await post(endpoint, jsonRpcRequest(method, params, 1), items, attempt);
+        const parsed = (await response.json());
+        const entry = Array.isArray(parsed) ? parsed[0] : parsed;
+        if (isRateLimited(entry))
+            throw new TransientError(`evm rpc: ${entry?.error?.message}`);
+        return entry ?? {};
+    };
+    const detectMode = (endpoint, attempt) => {
+        const known = modes.get(endpoint);
+        if (known)
+            return Promise.resolve(known);
+        if (!useMulticall) {
+            modes.set(endpoint, "batch");
+            return Promise.resolve("batch");
+        }
+        const pending = probes.get(endpoint);
+        if (pending)
+            return pending;
+        const probe = (async () => {
+            let mode = "batch";
+            try {
+                const code = await rpc(endpoint, "eth_getCode", [MULTICALL3_ADDRESS, "latest"], 1, attempt);
+                if (!code.error && stripHex(code.result ?? "").length > 2)
+                    mode = "multicall";
+            }
+            catch (error) {
+                if (error instanceof TransientError || isAbortError(error))
+                    throw error;
+            }
+            modes.set(endpoint, mode);
+            return mode;
+        })();
+        probes.set(endpoint, probe);
+        const clear = () => probes.delete(endpoint);
+        probe.then(clear, clear);
+        return probe;
+    };
+    const sendMulticall = async (endpoint, calls, attempt) => {
+        let entry;
+        try {
+            entry = await rpc(endpoint, "eth_call", [{ to: MULTICALL3_ADDRESS, data: encodeAggregate3(calls) }, "latest"], calls.length, attempt);
+        }
+        catch (error) {
+            if (error instanceof TransientError || isAbortError(error))
+                throw error;
+            return undefined;
+        }
+        if (entry.error || !entry.result)
+            return undefined;
+        let decoded;
+        try {
+            decoded = decodeAggregate3(entry.result, calls.length);
+        }
+        catch {
+            return undefined;
+        }
+        return decoded.map(result => result.success
+            ? { ok: true, value: result.data }
+            : { ok: false, error: new Error("evm rpc: execution reverted") });
+    };
+    const sendBatch = async (endpoint, calls, attempt) => {
+        let response;
+        try {
+            response = await post(endpoint, calls.map((call, id) => callRequest(call, id)), calls.length, attempt);
+        }
+        catch (error) {
+            if (error instanceof HttpError) {
+                modes.set(endpoint, "single");
+                throw new ChunkTooLargeError(error.message);
             }
-            throw new Error(`evm rpc ${response.status}`);
+            throw error;
         }
         const parsed = (await response.json());
-        if (!batched) {
-            return [toResult(Array.isArray(parsed) ? parsed[0] : parsed)];
-        }
         if (!Array.isArray(parsed)) {
-            singleOnly.add(endpoint);
+            modes.set(endpoint, "single");
             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 sendSingle = async (endpoint, call, attempt) => {
+        const response = await post(endpoint, callRequest(call, 1), 1, attempt);
+        const parsed = (await response.json());
+        return [toResult(Array.isArray(parsed) ? parsed[0] : parsed)];
+    };
+    const send = async (endpoint, calls, attempt) => {
+        if (calls.length === 1)
+            return sendSingle(endpoint, calls[0], attempt);
+        const mode = await detectMode(endpoint, attempt);
+        if (mode === "single")
+            throw new ChunkTooLargeError("evm rpc: batch unsupported");
+        if (mode === "multicall") {
+            const aggregated = await sendMulticall(endpoint, calls, attempt);
+            if (aggregated)
+                return aggregated;
+            modes.set(endpoint, "batch");
+        }
+        return sendBatch(endpoint, calls, attempt);
+    };
     const batcherFor = (endpoint) => {
         const existing = batchers.get(endpoint);
         if (existing)
@@ -93,7 +261,9 @@ export function jsonRpcEvmReader(endpoints = {}, options = {}) {
             concurrency: options.concurrency,
             retries: options.retries,
             baseDelayMs: options.baseDelayMs,
-            sleep: options.sleep
+            maxDelayMs: options.maxDelayMs,
+            sleep: options.sleep,
+            signal: options.signal
         });
         batchers.set(endpoint, batcher);
         return batcher;
@@ -103,6 +273,7 @@ export function jsonRpcEvmReader(endpoints = {}, options = {}) {
             const endpoint = override ?? endpoints[chainId];
             if (!endpoint)
                 throw new Error(`no evm endpoint for chain ${chainId}`);
+            validateCall(to, data);
             return batcherFor(endpoint).enqueue({ to, data });
         }
     };

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

@@ -1,5 +1,4 @@
 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,5 +1,4 @@
 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,5 +1,6 @@
 import { SuiReader } from "./types.js";
 import { TransportRequest } from "./batch.js";
+export type { 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.
@@ -37,8 +38,10 @@ export interface GraphqlSuiReaderOptions {
     concurrency?: number;
     retries?: number;
     baseDelayMs?: number;
+    maxDelayMs?: number;
     sleep?: (ms: number) => Promise<void>;
     fetch?: typeof globalThis.fetch;
+    signal?: AbortSignal;
     onRequest?: (request: TransportRequest) => void;
 }
 export declare function graphqlSuiReader(options?: string | GraphqlSuiReaderOptions): SuiReader;

package/dist/src/placements/sui.js

@@ -1,4 +1,4 @@
-import { Batcher, ChunkTooLargeError, TransientError, isTransientStatus, retryAfterMs } from "./batch.js";
+import { Batcher, ChunkTooLargeError, TransientError, isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
 const GRAPHQL_PAGE_SIZE = 50;
 /**
  * Canonical form for a Sui coin type: `0x` stripped from the address segment,
@@ -90,14 +90,21 @@ const OBJECTS_ALIAS = "objects";
 const OBJECT_SELECTION = "{ address asMoveObject { contents { type { repr } json } } }";
 const OBJECT_KEY_WEIGHT = 0.25;
 const OBJECT_KEY_BYTES = 90;
+const SUI_ADDRESS = /^(0x)?[0-9a-fA-F]{1,64}$/;
 function normalizeAddress(address) {
     return address.trim().toLowerCase().replace(/^0x/, "").padStart(64, "0");
 }
+function isSuiAddress(value) {
+    return SUI_ADDRESS.test(value.trim());
+}
+function literal(value) {
+    return JSON.stringify(value);
+}
 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(", ");
+        const keys = ids.map(id => `{ address: ${literal(id)} }`).join(", ");
         roots.push(`${OBJECTS_ALIAS}: multiGetObjects(keys: [${keys}]) ${OBJECT_SELECTION}`);
     }
     chunk.forEach((item, index) => {
@@ -107,19 +114,25 @@ function buildDocument(chunk) {
     return `{ ${roots.join(" ")} }`;
 }
 function distribute(chunk, body) {
-    const pathErrors = new Map();
+    const aliasErrors = new Map();
+    const objectErrors = new Map();
     const rootErrors = [];
     for (const error of body.errors ?? []) {
         const alias = error.path?.[0];
-        if (typeof alias === "string") {
-            pathErrors.set(alias, error.message);
+        if (typeof alias !== "string") {
+            rootErrors.push(error.message);
+            continue;
+        }
+        const position = error.path?.[1];
+        if (alias === OBJECTS_ALIAS && typeof position === "number") {
+            objectErrors.set(position, error.message);
         }
         else {
-            rootErrors.push(error.message);
+            aliasErrors.set(alias, error.message);
         }
     }
-    if (rootErrors.length > 0) {
-        const message = `sui graphql: ${rootErrors.join("; ")}`;
+    if (rootErrors.length > 0 || (body.data == null && (body.errors?.length ?? 0) > 0)) {
+        const message = `sui graphql: ${[...rootErrors, ...aliasErrors.values(), ...objectErrors.values()].join("; ")}`;
         if (chunk.length > 1)
             throw new ChunkTooLargeError(message);
         throw new Error(message);
@@ -136,15 +149,21 @@ function distribute(chunk, body) {
             json: contents.json
         });
     }
+    let objectPosition = -1;
     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") {
+            objectPosition += 1;
+            const message = objectErrors.get(objectPosition) ?? aliasErrors.get(OBJECTS_ALIAS);
+            if (message !== undefined) {
+                return { ok: false, error: new Error(`sui graphql: ${message}`) };
+            }
             return { ok: true, value: objectsByAddress.get(normalizeAddress(item.id)) };
         }
+        const alias = `r${index}`;
+        const message = aliasErrors.get(alias);
+        if (message !== undefined) {
+            return { ok: false, error: new Error(`sui graphql: ${message}`) };
+        }
         return { ok: true, value: data[alias] };
     });
 }
@@ -161,10 +180,13 @@ export function graphqlSuiReader(options = {}) {
             response = await fetchImpl(endpoint, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ query: document })
+                body: JSON.stringify({ query: document }),
+                signal: config.signal
             });
         }
         catch (error) {
+            if (isAbortError(error))
+                throw error;
             onRequest?.({ items: chunk.length, attempt, status: "network-error" });
             throw new TransientError(`sui graphql: ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -194,12 +216,20 @@ export function graphqlSuiReader(options = {}) {
         concurrency: config.concurrency,
         retries: config.retries,
         baseDelayMs: config.baseDelayMs,
-        sleep: config.sleep
+        maxDelayMs: config.maxDelayMs,
+        sleep: config.sleep,
+        signal: config.signal
     });
     const field = (gql) => batcher.enqueue({ kind: "field", field: gql });
+    const requireAddress = (value, what) => {
+        if (!isSuiAddress(value))
+            throw new Error(`sui graphql: ${what} is not a sui address`);
+    };
     return {
         async objects(ids) {
             const unique = [...new Set(ids)];
+            for (const id of unique)
+                requireAddress(id, `object id ${id}`);
             const found = await Promise.all(unique.map(id => batcher.enqueue({ kind: "object", id })));
             const out = {};
             for (const object of found) {
@@ -209,15 +239,17 @@ export function graphqlSuiReader(options = {}) {
             return out;
         },
         async balance(owner, coinType) {
-            const data = await field(`address(address: "${owner}") { balance(coinType: "${coinType}") { totalBalance } }`);
+            requireAddress(owner, `owner ${owner}`);
+            const data = await field(`address(address: ${literal(owner)}) { balance(coinType: ${literal(coinType)}) { totalBalance } }`);
             return data?.balance?.totalBalance ?? "0";
         },
         async ownedObjects(owner, type) {
+            requireAddress(owner, `owner ${owner}`);
             const owned = [];
             let cursor = null;
             for (;;) {
-                const after = cursor ? `, after: "${cursor}"` : "";
-                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 after = cursor ? `, after: ${literal(cursor)}` : "";
+                const page = await field(`address(address: ${literal(owner)}) { objects(first: ${GRAPHQL_PAGE_SIZE}${after}, filter: { type: ${literal(type)} }) { pageInfo { hasNextPage endCursor } nodes { address contents { type { repr } json } } } }`);
                 const container = page?.objects;
                 if (!container)
                     break;
@@ -237,15 +269,17 @@ export function graphqlSuiReader(options = {}) {
             return owned;
         },
         async dynamicField(parentId, key) {
-            const data = await field(`address(address: "${parentId}") { dynamicField(name: { type: "${key.type}", bcs: "${key.bcs}" }) { value { ... on MoveValue { json } } } }`);
+            requireAddress(parentId, `parent ${parentId}`);
+            const data = await field(`address(address: ${literal(parentId)}) { dynamicField(name: { type: ${literal(key.type)}, bcs: ${literal(key.bcs)} }) { value { ... on MoveValue { json } } } }`);
             return data?.dynamicField?.value?.json;
         },
         async dynamicFields(parentId, limit) {
+            requireAddress(parentId, `parent ${parentId}`);
             const fields = [];
             let cursor = null;
             for (;;) {
-                const after = cursor ? `, after: "${cursor}"` : "";
-                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 after = cursor ? `, after: ${literal(cursor)}` : "";
+                const page = await field(`address(address: ${literal(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;

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

@@ -87,6 +87,7 @@ export interface AccountShares {
     covered?: string;
     placements: Placement[];
     failures: PlacementFailure[];
+    unresolved?: true;
 }
 export interface SuiObjectContents {
     address: string;

package/package.json

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