@ember-finance/sdk 2.10.4 → 2.11.0-pre.1

package/dist/src/placements/client.js

@@ -0,0 +1,157 @@
+import { asContractAddress, decodeUint256, encodeBalanceOf } from "./evm.js";
+import { getAdapter, listAdapters } from "./registry.js";
+function reasonOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Resolves what one account holds of a vault's shares: in its wallet, wrapped
+ * for cover, and deployed elsewhere.
+ *
+ * A protocol that fails is reported in `failures` rather than thrown, so a
+ * single unreachable protocol does not zero an otherwise valid answer.
+ */
+/**
+ * Whether `account` could be an address on this chain.
+ *
+ * Only one direction is decidable: a 32-byte sui address fed to
+ * `balanceOf(address)` overflows the 20-byte word and the node reverts, so it
+ * is certainly not evm. A 20-byte address is a valid short-form sui address,
+ * so the reverse cannot be ruled out and is left to the chain to answer.
+ */
+function addressFits(chain, account) {
+    const hex = account.trim().replace(/^0x/i, "");
+    if (!/^[0-9a-fA-F]+$/.test(hex))
+        return false;
+    return chain === "evm" ? hex.length <= 40 : hex.length <= 64;
+}
+export class PlacementsClient {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** One vault, one account. */
+    async forAccount(vaultId, account, options = {}) {
+        if (!this.ctx.vaults)
+            throw new Error("no vault resolver configured");
+        const coins = await this.ctx.vaults.coinsForVault(vaultId);
+        return Promise.all(coins.map(coin => this.sharesForCoin(vaultId, coin, account, options)));
+    }
+    async sharesForCoin(vaultId, coin, account, options) {
+        const failures = [];
+        // A vault on several chains issues a coin on each, so for any one
+        // account all but one of them belongs to a wallet it does not have.
+        // Holding none of it is the true answer, and cheaper than asking.
+        if (!addressFits(coin.chain.type, account)) {
+            return {
+                vaultId,
+                coin,
+                available: "0",
+                covered: undefined,
+                placements: [],
+                failures
+            };
+        }
+        const [available, covered, placements] = await Promise.all([
+            this.walletBalance(coin, account).catch(error => {
+                failures.push({
+                    protocol: "wallet",
+                    stage: "read",
+                    coin: coin.coin,
+                    reason: reasonOf(error)
+                });
+                return "0";
+            }),
+            this.coveredBalance(coin, account).catch(error => {
+                failures.push({
+                    protocol: "opencover",
+                    stage: "read",
+                    coin: coin.coin,
+                    reason: reasonOf(error)
+                });
+                return undefined;
+            }),
+            this.placementsForCoin(coin, account, options, failures)
+        ]);
+        return { vaultId, coin, available, covered, placements, failures };
+    }
+    async walletBalance(coin, account) {
+        if (coin.chain.type === "sui") {
+            if (!this.ctx.sui)
+                throw new Error("no sui reader configured");
+            return this.ctx.sui.balance(account, coin.coin);
+        }
+        if (!this.ctx.evm)
+            throw new Error("no evm reader configured");
+        const chainId = coin.chain.chainId;
+        if (chainId === undefined)
+            throw new Error(`${coin.coin} has no chainId`);
+        const raw = await this.ctx.evm.call(chainId, asContractAddress(coin.coin), encodeBalanceOf(account), coin.rpcUrl);
+        return decodeUint256(raw).toString();
+    }
+    async coveredBalance(coin, account) {
+        const coverVault = await this.ctx.vaults?.coverVault?.(coin);
+        if (!coverVault)
+            return undefined;
+        if (!this.ctx.evm)
+            throw new Error("no evm reader configured");
+        const chainId = coin.chain.chainId;
+        if (chainId === undefined)
+            throw new Error(`${coin.coin} has no chainId`);
+        const raw = await this.ctx.evm.call(chainId, asContractAddress(coverVault), encodeBalanceOf(account), coin.rpcUrl);
+        return decodeUint256(raw).toString();
+    }
+    async placementsForCoin(coin, account, options, failures) {
+        const adapters = this.select(options.protocols, failures).filter(adapter => adapter.chain === coin.chain.type);
+        const discovered = await Promise.allSettled(adapters.map(adapter => adapter.discover(coin, this.ctx)));
+        const jobs = [];
+        discovered.forEach((result, index) => {
+            const adapter = adapters[index];
+            if (result.status === "rejected") {
+                failures.push({
+                    protocol: adapter.id,
+                    stage: "discover",
+                    coin: coin.coin,
+                    reason: reasonOf(result.reason)
+                });
+                return;
+            }
+            if (result.value.length > 0)
+                jobs.push({ adapter, refs: result.value });
+        });
+        // One read per adapter rather than per venue, so an adapter can batch
+        // every pointer it owns into as few chain round-trips as it can manage.
+        const read = await Promise.allSettled(jobs.map(job => job.adapter.read(job.refs, account, this.ctx)));
+        const placements = [];
+        read.forEach((result, index) => {
+            const { adapter } = jobs[index];
+            if (result.status === "rejected") {
+                failures.push({
+                    protocol: adapter.id,
+                    stage: "read",
+                    coin: coin.coin,
+                    reason: reasonOf(result.reason)
+                });
+                return;
+            }
+            placements.push(...result.value);
+        });
+        return placements;
+    }
+    select(protocols, failures) {
+        if (!protocols)
+            return listAdapters();
+        const selected = [];
+        for (const id of protocols) {
+            const adapter = getAdapter(id);
+            if (!adapter) {
+                failures.push({
+                    protocol: id,
+                    stage: "discover",
+                    reason: "no adapter registered"
+                });
+                continue;
+            }
+            selected.push(adapter);
+        }
+        return selected;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { EvmReader } from "./types.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;

package/dist/src/placements/evm.js

@@ -0,0 +1,48 @@
+/** `balanceOf(address)` */
+const BALANCE_OF_SELECTOR = "0x70a08231";
+export function encodeBalanceOf(owner) {
+    const address = owner.toLowerCase().replace(/^0x/, "").padStart(64, "0");
+    return `${BALANCE_OF_SELECTOR}${address}`;
+}
+export function asContractAddress(address) {
+    // An EVM node rejects an unprefixed `to` outright rather than coercing it,
+    // so a pointer carrying a bare address would fail the whole read.
+    const trimmed = address.trim();
+    return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+}
+export function decodeUint256(hex) {
+    if (!hex || hex === "0x")
+        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 = {}) {
+    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";
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./client.js";
+export * from "./pointers.js";
+export * from "./vaults.js";
+export * from "./sui.js";
+export * from "./evm.js";
+export * from "./adapters/index.js";

package/dist/src/placements/index.js

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./client.js";
+export * from "./pointers.js";
+export * from "./vaults.js";
+export * from "./sui.js";
+export * from "./evm.js";
+export * from "./adapters/index.js";

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

@@ -0,0 +1,24 @@
+import { PlatformEnv } from "../common/constants.js";
+import { PlacementRef, PointerSource } from "./types.js";
+/**
+ * Pointers held in memory. Useful for tests, and for pinning a known venue set
+ * without a round-trip.
+ */
+export declare function staticPointerSource(refs: PlacementRef[]): PointerSource;
+export interface HttpPointerSourceOptions {
+    /** Vaults API environment. Defaults to prod. */
+    env?: PlatformEnv;
+    /** Overrides `env` entirely. For a local deployment, or a proxy. */
+    baseUrl?: string;
+    path?: string;
+    /** How long a coin's rows may be reused, in milliseconds. Default 30s. */
+    cacheMs?: number;
+}
+/** Pointers from the vaults API. Defaults to prod. */
+export declare function httpPointerSource(options?: HttpPointerSourceOptions): PointerSource;
+/**
+ * Merges what every source returns, de-duplicated by venue. Earlier sources win,
+ * so a caller can pin rows ahead of a remote set. A source that throws is
+ * skipped rather than failing the set.
+ */
+export declare function mergePointerSources(...sources: PointerSource[]): PointerSource;

package/dist/src/placements/pointers.js

@@ -0,0 +1,125 @@
+import { environmentConfig } from "../common/constants.js";
+import { coinTypesMatch } from "./sui.js";
+/**
+ * Pointers held in memory. Useful for tests, and for pinning a known venue set
+ * without a round-trip.
+ */
+export function staticPointerSource(refs) {
+    return {
+        // Coins are compared with `coinTypesMatch` rather than by string
+        // equality, so a row pinned in one spelling still matches a caller
+        // passing another — a short Sui address against its padded form, say.
+        // Exact matching would fail by returning nothing, which reads as
+        // "listed nowhere".
+        async placements(protocol, coin) {
+            return refs.filter(ref => ref.protocol === protocol && coinTypesMatch(ref.coin, coin.coin));
+        }
+    };
+}
+/**
+ * Decimals scale every amount an adapter returns, so a missing or malformed
+ * value is a silent power-of-ten error rather than a visible failure.
+ */
+function requireDecimals(row) {
+    if (!Number.isInteger(row.decimals)) {
+        throw new Error(`placement ${row.protocol}/${row.venue} has no decimals`);
+    }
+    return row.decimals;
+}
+/** Pointers from the vaults API. Defaults to prod. */
+export function httpPointerSource(options = {}) {
+    // The cache window exists to collapse the burst a single `forAccount`
+    // makes, not to cache across a session: pointers change when a venue is
+    // added, and a long window would keep a new one invisible.
+    const baseUrl = options.baseUrl ?? environmentConfig[options.env ?? "prod"].apiHost;
+    const path = options.path ?? "/api/v2/vaults/placements";
+    const cacheMs = options.cacheMs ?? 30000;
+    /**
+     * One request per coin, not per (coin, protocol).
+     *
+     * `?coin=` already returns every protocol's rows, so asking once per adapter
+     * fetched the same list five times and threw four of them away. Reading one
+     * vault meant eight requests where two would do, and a caller sweeping every
+     * vault made hundreds — enough to be rate-limited, and a rejected discover
+     * drops that venue from the answer.
+     *
+     * In-flight requests are shared rather than merely cached, so the adapters
+     * racing each other at the start of a `forAccount` collapse into one call.
+     */
+    const inFlight = new Map();
+    const rowsForCoin = (coin) => {
+        const key = coin.coin.toLowerCase();
+        const hit = inFlight.get(key);
+        if (hit && Date.now() - hit.at < cacheMs)
+            return hit.rows;
+        const rows = (async () => {
+            const url = new URL(`${baseUrl.replace(/\/$/, "")}${path}`);
+            url.searchParams.set("coin", coin.coin);
+            const response = await fetch(url.toString(), {
+                headers: { Accept: "application/json" }
+            });
+            if (!response.ok) {
+                throw new Error(`pointer source ${response.status}`);
+            }
+            const body = (await response.json());
+            // The chain type comes from the coin, not the wire: an adapter only
+            // ever runs on its own chain, so a server that named it again could
+            // only ever disagree.
+            return (body.placements ?? []).map(placement => ({
+                protocol: placement.protocol,
+                chain: {
+                    type: coin.chain.type,
+                    chainId: placement.chainId,
+                    identifier: placement.chainIdentifier
+                },
+                venue: placement.venue,
+                coin: placement.coin,
+                decimals: requireDecimals(placement),
+                protocolName: placement.protocolName,
+                protocolLogoUrl: placement.protocolLogoUrl,
+                source: placement.source,
+                label: placement.label,
+                shareToken: placement.shareToken,
+                url: placement.url,
+                rpcUrl: placement.rpcUrl
+            }));
+        })();
+        // A failure is not cached: the next adapter should retry rather than
+        // inherit a rejection it never caused.
+        rows.catch(() => inFlight.delete(key));
+        inFlight.set(key, { at: Date.now(), rows });
+        return rows;
+    };
+    return {
+        async placements(protocol, coin) {
+            const rows = await rowsForCoin(coin);
+            return rows.filter(ref => ref.protocol === protocol);
+        }
+    };
+}
+/**
+ * Merges what every source returns, de-duplicated by venue. Earlier sources win,
+ * so a caller can pin rows ahead of a remote set. A source that throws is
+ * skipped rather than failing the set.
+ */
+export function mergePointerSources(...sources) {
+    return {
+        async placements(protocol, coin) {
+            const results = await Promise.allSettled(sources.map(source => source.placements(protocol, coin)));
+            const byVenue = new Map();
+            for (const result of results) {
+                if (result.status !== "fulfilled")
+                    continue;
+                for (const ref of result.value) {
+                    // Key on the chain type as well as its id: an evm row whose
+                    // chainId is absent would otherwise land in the same slot as
+                    // a sui row at the same venue string and silently replace it.
+                    const key = `${ref.chain.type}:${ref.chain.chainId ?? ""}:${ref.venue.toLowerCase()}`;
+                    if (!byVenue.has(key))
+                        byVenue.set(key, ref);
+                }
+            }
+            return [...byVenue.values()];
+        }
+    };
+}

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

@@ -0,0 +1,11 @@
+import { ChainType } from "../common/constants.js";
+import { ProtocolAdapter, ProtocolId } from "./types.js";
+/**
+ * Add a protocol. Re-registering an id replaces it, so a consumer can override
+ * a bundled adapter without forking the module.
+ */
+export declare function registerAdapter(adapter: ProtocolAdapter): void;
+export declare function getAdapter(id: ProtocolId): ProtocolAdapter | undefined;
+export declare function listAdapters(chain?: ChainType): ProtocolAdapter[];
+/** Drops every registration. Intended for tests. */
+export declare function resetAdapters(): void;

package/dist/src/placements/registry.js

@@ -0,0 +1,19 @@
+const adapters = new Map();
+/**
+ * Add a protocol. Re-registering an id replaces it, so a consumer can override
+ * a bundled adapter without forking the module.
+ */
+export function registerAdapter(adapter) {
+    adapters.set(adapter.id, adapter);
+}
+export function getAdapter(id) {
+    return adapters.get(id);
+}
+export function listAdapters(chain) {
+    const all = [...adapters.values()];
+    return chain ? all.filter(adapter => adapter.chain === chain) : all;
+}
+/** Drops every registration. Intended for tests. */
+export function resetAdapters() {
+    adapters.clear();
+}

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

@@ -0,0 +1,35 @@
+import { SuiReader } from "./types.js";
+/**
+ * Canonical form for a Sui coin type: `0x` stripped from the address segment,
+ * lowercased and left-padded to 64 hex chars.
+ *
+ * Object JSON returns unprefixed padded types ("0000..02::sui::SUI") while
+ * config and RPC use the short prefixed form ("0x2::sui::SUI"). Comparing the
+ * two without normalising silently never matches.
+ *
+ * Only the address is folded. It is hex, so case is not significant there, but
+ * the module and struct names are Move identifiers and two that differ only in
+ * case are two different types.
+ */
+export declare function normalizeCoinType(coinType: string): string;
+export declare function coinTypesMatch(a: string, b: string): boolean;
+/**
+ * A Sui address as GraphQL wants a dynamic-field key: base64 of its BCS
+ * encoding, which for an address is simply its 32 raw bytes.
+ */
+export declare function bcsAddress(address: string): string;
+/** Type arguments of a Move type, e.g. `Pool<A, B>` -> ["A", "B"]. */
+export declare function typeArguments(type: string): string[];
+/** The object id a Move table's entries actually hang off. */
+export declare function tableId(field: unknown): string | undefined;
+/**
+ * Some protocols wrap fixed-point numbers as `{ value }` scaled by 1e18.
+ * Returns base units, truncated — these feed balances, not accounting.
+ */
+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;

package/dist/src/placements/sui.js

@@ -0,0 +1,189 @@
+const GRAPHQL_PAGE_SIZE = 50;
+/**
+ * Canonical form for a Sui coin type: `0x` stripped from the address segment,
+ * lowercased and left-padded to 64 hex chars.
+ *
+ * Object JSON returns unprefixed padded types ("0000..02::sui::SUI") while
+ * config and RPC use the short prefixed form ("0x2::sui::SUI"). Comparing the
+ * two without normalising silently never matches.
+ *
+ * Only the address is folded. It is hex, so case is not significant there, but
+ * the module and struct names are Move identifiers and two that differ only in
+ * case are two different types.
+ */
+export function normalizeCoinType(coinType) {
+    const parts = coinType.trim().split("::");
+    if (parts.length < 2)
+        return coinType.trim().toLowerCase();
+    const address = parts[0].toLowerCase().replace(/^0x/, "").padStart(64, "0");
+    return [address, ...parts.slice(1)].join("::");
+}
+export function coinTypesMatch(a, b) {
+    return normalizeCoinType(a) === normalizeCoinType(b);
+}
+/**
+ * A Sui address as GraphQL wants a dynamic-field key: base64 of its BCS
+ * encoding, which for an address is simply its 32 raw bytes.
+ */
+export function bcsAddress(address) {
+    // Hand-rolled rather than via Buffer, because this runs in the browser.
+    const hex = address.trim().replace(/^0x/, "").toLowerCase().padStart(64, "0");
+    if (!/^[0-9a-f]{64}$/.test(hex))
+        throw new Error(`not a sui address: ${address}`);
+    let binary = "";
+    for (let i = 0; i < hex.length; i += 2) {
+        binary += String.fromCharCode(Number.parseInt(hex.slice(i, i + 2), 16));
+    }
+    return btoa(binary);
+}
+/** Type arguments of a Move type, e.g. `Pool<A, B>` -> ["A", "B"]. */
+export function typeArguments(type) {
+    const open = type.indexOf("<");
+    if (open === -1 || !type.endsWith(">"))
+        return [];
+    const inner = type.slice(open + 1, -1);
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of inner) {
+        if (ch === "<")
+            depth++;
+        if (ch === ">")
+            depth--;
+        if (ch === "," && depth === 0) {
+            args.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        args.push(current.trim());
+    return args;
+}
+/** The object id a Move table's entries actually hang off. */
+export function tableId(field) {
+    // Protocols wrap tables to different depths — `{ id }`, `{ table: { id } }`,
+    // `{ table: { table: { id } } }` — and the outer id resolves to nothing, so
+    // reading it returns an empty field list rather than an error.
+    const nested = field;
+    return nested?.table?.table?.id ?? nested?.table?.id ?? nested?.id;
+}
+/**
+ * Some protocols wrap fixed-point numbers as `{ value }` scaled by 1e18.
+ * Returns base units, truncated — these feed balances, not accounting.
+ */
+export function decimalToBaseUnits(field) {
+    const raw = field?.value ?? field;
+    if (raw === undefined || raw === null)
+        return 0n;
+    return BigInt(String(raw)) / 1000000000000000000n;
+}
+export function toBigInt(field) {
+    if (field === undefined || field === null)
+        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 })
+    });
+    if (!response.ok) {
+        throw new Error(`sui graphql ${response.status}`);
+    }
+    const body = (await response.json());
+    if (body.errors?.length) {
+        throw new Error(`sui graphql: ${body.errors.map(e => e.message).join("; ")}`);
+    }
+    if (!body.data)
+        throw new Error("sui graphql: empty response");
+    return body.data;
+}
+/**
+ * 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") {
+    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 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
+                };
+            }
+            return out;
+        },
+        async balance(owner, coinType) {
+            const data = await query(endpoint, `{ address(address: "${owner}") { balance(coinType: "${coinType}") { totalBalance } } }`);
+            return data.address?.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;
+                if (!container)
+                    break;
+                for (const node of container.nodes ?? []) {
+                    if (!node.contents)
+                        continue;
+                    owned.push({
+                        address: node.address,
+                        type: node.contents.type.repr,
+                        json: node.contents.json
+                    });
+                }
+                if (!container.pageInfo?.hasNextPage)
+                    break;
+                cursor = container.pageInfo.endCursor;
+            }
+            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;
+        },
+        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;
+                if (!container)
+                    break;
+                for (const node of container.nodes ?? []) {
+                    fields.push({
+                        name: node.name?.json,
+                        valueType: node.value?.type?.repr ?? "",
+                        value: node.value?.json
+                    });
+                }
+                if (limit !== undefined && fields.length >= limit)
+                    break;
+                if (!container.pageInfo?.hasNextPage)
+                    break;
+                cursor = container.pageInfo.endCursor;
+            }
+            return limit === undefined ? fields : fields.slice(0, limit);
+        }
+    };
+}