@defillama/sdk 5.0.235 → 5.0.236

package/build/chains/sui.js

@@ -0,0 +1,1135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceIntoChunks = exports.SuiGraphqlError = exports.fromU256 = exports.fromU128 = exports.fromU64 = exports.fromU32 = exports.fromU16 = exports.toU256 = exports.toU128 = exports.toU64 = exports.toU32 = exports.toU16 = exports.uleb128 = exports.EMPTY_STRUCT_BCS = exports.DUMMY_SENDER = exports.DEFAULT_RPC_ENDPOINTS = exports.DEFAULT_GRAPHQL_ENDPOINTS = exports.suiChains = void 0;
+exports.getGraphqlEndpoints = getGraphqlEndpoints;
+exports.getGraphqlEndpoint = getGraphqlEndpoint;
+exports.getRpcEndpoints = getRpcEndpoints;
+exports.getRpcEndpoint = getRpcEndpoint;
+exports.hasGraphql = hasGraphql;
+exports.hexToBytes = hexToBytes;
+exports.bytesToHex = bytesToHex;
+exports.textToBytes = textToBytes;
+exports.bytesToBase64 = bytesToBase64;
+exports.base64ToBytes = base64ToBytes;
+exports.uleb128Encode = uleb128Encode;
+exports.uleb128Decode = uleb128Decode;
+exports.toLittleEndian = toLittleEndian;
+exports.fromLittleEndian = fromLittleEndian;
+exports.normalizeSuiAddress = normalizeSuiAddress;
+exports.normalizeCoinType = normalizeCoinType;
+exports.splitTypeArgs = splitTypeArgs;
+exports.parseStructTag = parseStructTag;
+exports.typeTagToBytes = typeTagToBytes;
+exports.buildProgrammableMoveCallBytes = buildProgrammableMoveCallBytes;
+exports.buildTransactionDataBytes = buildTransactionDataBytes;
+exports.bcsDynamicFieldName = bcsDynamicFieldName;
+exports.shortenTypeAddresses = shortenTypeAddresses;
+exports.formatObject = formatObject;
+exports.toAddr = toAddr;
+exports.toParsedJson = toParsedJson;
+exports.graphqlCall = graphqlCall;
+exports.call = call;
+exports.rpcGetObject = rpcGetObject;
+exports.rpcGetObjects = rpcGetObjects;
+exports.getObject = getObject;
+exports.getObjects = getObjects;
+exports.getObjectsByType = getObjectsByType;
+exports.getOwnedObjects = getOwnedObjects;
+exports.queryEvents = queryEvents;
+exports.getDynamicFieldObject = getDynamicFieldObject;
+exports.getDynamicFieldObjects = getDynamicFieldObjects;
+exports.getCoinMetadata = getCoinMetadata;
+exports.getTokenSupply = getTokenSupply;
+exports.getAllBalances = getAllBalances;
+exports.getBalance = getBalance;
+exports.getCheckpoint = getCheckpoint;
+exports.getLatestCheckpoint = getLatestCheckpoint;
+exports.getCheckpointAtTimestamp = getCheckpointAtTimestamp;
+exports.devInspectTransactionBlock = devInspectTransactionBlock;
+exports.getInitialSharedVersion = getInitialSharedVersion;
+exports.callViewFunction = callViewFunction;
+/**
+ * Sui (GraphQL RPC + hand-rolled BCS codec) and IOTA (Sui fork, JSON-RPC) client.
+ *
+ * Replaces / consolidates:
+ *  - DefiLlama-Adapters `projects/helper/chain/sui.js` (BCS codec, GraphQL object / event /
+ *    dynamic-field readers, `devInspectTransactionBlock`, `getInitialSharedVersion`, `getTokenSupply`,
+ *    `normalizeCoinType`; the TVL-specific `dexExport` / `sumTokens` are intentionally not ported)
+ *  - DefiLlama-Adapters `projects/helper/chain/iota.js` (IOTA JSON-RPC `call` / `getObject` / `getObjects`)
+ *  - defillama-server `coins/src/adapters/utils/sui.ts` (`getAllBalances`, `getTokenInfo`, `queryEvents`, `getObjects`)
+ *  - peggedassets-server `src/adapters/peggedAssets/helper/sui.ts` (`getDynamicFieldObject` with `nameBcs`, `EMPTY_STRUCT_BCS`)
+ *  - dimension-adapters `helpers/sui.ts` (`graphqlCall` retry, windowed `queryEvents`, `eventModule` filter, `toParsedJson`)
+ *
+ * Endpoints: `SUI_GRAPH_RPC` (GraphQL, default `https://graphql.mainnet.sui.io/graphql`), `SUI_RPC`
+ * (JSON-RPC, default `https://sui-rpc.publicnode.com`) and `IOTA_RPC` (default `https://api.mainnet.iota.cafe`).
+ * Chains without a GraphQL endpoint (iota) transparently fall back to JSON-RPC for the reader helpers.
+ *
+ * Usage: `sdk.chains.sui.getObject({ objectId: '0x6' })`, `sdk.chains.sui.call({ chain: 'iota', method: 'iota_getLatestCheckpointSequenceNumber', params: [] })`
+ *
+ * Refs: https://docs.sui.io/concepts/data-access/graphql-rpc, https://docs.sui.io/develop/accessing-data/json-rpc-migration#method-mapping
+ */
+const rpc_1 = require("./rpc");
+Object.defineProperty(exports, "sliceIntoChunks", { enumerable: true, get: function () { return rpc_1.sliceIntoChunks; } });
+const debugLog_1 = require("../util/debugLog");
+// ---------------------------------------------------------------------------
+// config
+// ---------------------------------------------------------------------------
+exports.suiChains = ['sui', 'iota'];
+exports.DEFAULT_GRAPHQL_ENDPOINTS = {
+    sui: 'https://graphql.mainnet.sui.io/graphql',
+};
+exports.DEFAULT_RPC_ENDPOINTS = {
+    sui: 'https://sui-rpc.publicnode.com',
+    iota: 'https://api.mainnet.iota.cafe',
+};
+exports.DUMMY_SENDER = '0x' + '0'.repeat(64);
+/** BCS of a Move struct whose only member is `dummy_field: bool` (Wormhole-style `Key<T>` witness structs) */
+exports.EMPTY_STRUCT_BCS = 'AA==';
+const PAGE_SIZE = 50;
+const OBJECTS_PER_QUERY = 50;
+const RPC_OBJECTS_PER_QUERY = 9;
+const GRAPHQL_TIMEOUT = 60000;
+function getGraphqlEndpoints({ chain = 'sui' } = {}) {
+    return (0, rpc_1.getEndpoints)(chain, exports.DEFAULT_GRAPHQL_ENDPOINTS[chain], { envKey: `${chain.toUpperCase()}_GRAPH_RPC` });
+}
+function getGraphqlEndpoint(options = {}) {
+    return getGraphqlEndpoints(options)[0];
+}
+function getRpcEndpoints({ chain = 'sui' } = {}) {
+    return (0, rpc_1.getEndpoints)(chain, exports.DEFAULT_RPC_ENDPOINTS[chain]);
+}
+function getRpcEndpoint(options = {}) {
+    return getRpcEndpoints(options)[0];
+}
+/** true when the chain has a GraphQL endpoint (built-in default or `<CHAIN>_GRAPH_RPC`) */
+function hasGraphql(chain = 'sui') {
+    try {
+        getGraphqlEndpoints({ chain });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function rpcPrefix(chain = 'sui') {
+    return chain === 'iota' ? 'iota' : 'sui';
+}
+const TYPE_TAG_INDEXES = {
+    bool: 0, u8: 1, u64: 2, u128: 3, address: 4, signer: 5, u16: 8, u32: 9, u256: 10,
+};
+/** Hex string (with or without 0x) to a fixed-size byte array, left padded with zeros. Default size is a 32 byte address. */
+function hexToBytes(hex, size = 32) {
+    const normalized = String(hex).trim().replace(/^0x/i, '');
+    if (!/^[0-9a-fA-F]+$/.test(normalized) || normalized.length > size * 2)
+        throw new Error(`Invalid Sui hex value: ${hex}`);
+    return Array.from(Buffer.from(normalized.padStart(size * 2, '0'), 'hex'));
+}
+function bytesToHex(bytes) {
+    return '0x' + Buffer.from(bytes).toString('hex');
+}
+function textToBytes(value) {
+    return Array.from(Buffer.from(String(value), 'utf8'));
+}
+function bytesToBase64(bytes) {
+    return Buffer.from(bytes).toString('base64');
+}
+function base64ToBytes(value) {
+    return Array.from(Buffer.from(value, 'base64'));
+}
+function uleb128Encode(value) {
+    const bytes = [];
+    let num = Number(value);
+    if (!Number.isSafeInteger(num) || num < 0)
+        throw new Error(`Invalid uleb128 value: ${value}`);
+    do {
+        let byte = num % 0x80;
+        num = Math.floor(num / 0x80);
+        if (num > 0)
+            byte |= 0x80;
+        bytes.push(byte);
+    } while (num > 0);
+    return bytes;
+}
+/** Decode a uleb128 at `offset`; returns the value and how many bytes it consumed. */
+function uleb128Decode(data, offset = 0) {
+    const source = Uint8Array.from(data);
+    let value = 0;
+    let shift = 0;
+    let i = offset;
+    for (;;) {
+        if (i >= source.length)
+            throw new RangeError(`uleb128: unexpected end of data at offset ${i}`);
+        const byte = source[i++];
+        value += (byte & 0x7f) * Math.pow(2, shift);
+        if (!(byte & 0x80))
+            break;
+        shift += 7;
+        if (shift > 49)
+            throw new RangeError('uleb128: value exceeds safe integer range');
+    }
+    return { value, length: i - offset };
+}
+/** Alias kept for parity with the adapters helper */
+exports.uleb128 = uleb128Encode;
+function toLittleEndian(value, size) {
+    const bits = size * 8;
+    let big;
+    try {
+        if (typeof value === 'number' && !Number.isInteger(value))
+            throw new Error();
+        big = BigInt(value);
+    }
+    catch {
+        throw new Error(`Invalid u${bits} value: ${value}`);
+    }
+    const max = BigInt(1) << BigInt(bits);
+    if (big < BigInt(0) || big >= max)
+        throw new Error(`Value out of range for u${bits}: ${value}`);
+    const result = new Array(size).fill(0);
+    let i = 0;
+    while (big > BigInt(0)) {
+        result[i] = Number(big % BigInt(256));
+        big /= BigInt(256);
+        i += 1;
+    }
+    return result;
+}
+const toU16 = (value) => toLittleEndian(value, 2);
+exports.toU16 = toU16;
+const toU32 = (value) => toLittleEndian(value, 4);
+exports.toU32 = toU32;
+const toU64 = (value) => toLittleEndian(value, 8);
+exports.toU64 = toU64;
+const toU128 = (value) => toLittleEndian(value, 16);
+exports.toU128 = toU128;
+const toU256 = (value) => toLittleEndian(value, 32);
+exports.toU256 = toU256;
+function fromLittleEndian(data, offset = 0, size = 8) {
+    if (!Number.isInteger(offset) || offset < 0)
+        throw new RangeError(`Invalid byte offset: ${offset}`);
+    if (!Number.isInteger(size) || size < 1)
+        throw new RangeError(`Invalid integer byte size: ${size}`);
+    const source = Uint8Array.from(data);
+    if (source.length < offset + size)
+        throw new RangeError(`Expected ${size} bytes at offset ${offset}, got ${source.length}`);
+    let value = BigInt(0);
+    for (let i = offset + size - 1; i >= offset; i--)
+        value = (value << BigInt(8)) + BigInt(source[i]);
+    return value;
+}
+const fromU16 = (data, offset = 0) => fromLittleEndian(data, offset, 2);
+exports.fromU16 = fromU16;
+const fromU32 = (data, offset = 0) => fromLittleEndian(data, offset, 4);
+exports.fromU32 = fromU32;
+const fromU64 = (data, offset = 0) => fromLittleEndian(data, offset, 8);
+exports.fromU64 = fromU64;
+const fromU128 = (data, offset = 0) => fromLittleEndian(data, offset, 16);
+exports.fromU128 = fromU128;
+const fromU256 = (data, offset = 0) => fromLittleEndian(data, offset, 32);
+exports.fromU256 = fromU256;
+/** Lower-cased, 0x-prefixed, zero padded 64 hex char address */
+function normalizeSuiAddress(address) {
+    const hex = String(address).trim().replace(/^0x/i, '').toLowerCase();
+    if (!/^[0-9a-f]{1,64}$/.test(hex))
+        throw new Error(`Invalid Sui address: ${address}`);
+    return '0x' + hex.padStart(64, '0');
+}
+/**
+ * GraphQL returns coin types with the address zero padded to 64 hex chars (0x000...002::sui::SUI)
+ * while configs commonly use the short form (0x2::sui::SUI); this maps both to the padded form.
+ */
+function normalizeCoinType(coinType) {
+    const [addr, ...rest] = String(coinType).trim().split('::');
+    return [normalizeSuiAddress(addr), ...rest].join('::');
+}
+/** Split a comma separated generic argument list, respecting nested `<...>` */
+function splitTypeArgs(value) {
+    const items = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === '<')
+            depth++;
+        if (value[i] === '>') {
+            depth--;
+            if (depth < 0)
+                throw new Error(`Unbalanced type argument brackets: ${value}`);
+        }
+        if (value[i] === ',' && depth === 0) {
+            items.push(value.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    if (depth !== 0)
+        throw new Error(`Unbalanced type argument brackets: ${value}`);
+    const last = value.slice(start).trim();
+    if (last)
+        items.push(last);
+    return items;
+}
+function parseStructTag(type) {
+    const match = String(type).trim().match(/^([^:<>]+)::([^:<>]+)::([^<>]+)(?:<(.+)>)?$/);
+    if (!match)
+        throw new Error(`Invalid Sui struct tag: ${type}`);
+    return {
+        address: match[1],
+        module: match[2],
+        name: match[3],
+        typeParams: match[4] ? splitTypeArgs(match[4]) : [],
+    };
+}
+/** BCS `TypeTag` */
+function typeTagToBytes(type) {
+    const tag = String(type).trim();
+    if (TYPE_TAG_INDEXES[tag] !== undefined)
+        return [TYPE_TAG_INDEXES[tag]];
+    if (tag.startsWith('vector<') && tag.endsWith('>'))
+        return [6, ...typeTagToBytes(tag.slice(7, -1))];
+    const { address, module, name, typeParams } = parseStructTag(tag);
+    const moduleBytes = textToBytes(module);
+    const nameBytes = textToBytes(name);
+    const out = [
+        7,
+        ...hexToBytes(address),
+        ...uleb128Encode(moduleBytes.length),
+        ...moduleBytes,
+        ...uleb128Encode(nameBytes.length),
+        ...nameBytes,
+        ...uleb128Encode(typeParams.length),
+    ];
+    typeParams.forEach(p => out.push(...typeTagToBytes(p)));
+    return out;
+}
+/**
+ * BCS `TransactionKind::ProgrammableTransaction` with a single `MoveCall` command whose inputs are
+ * shared objects (enough for read-only view functions inspected through `devInspectTransactionBlock`).
+ */
+function buildProgrammableMoveCallBytes({ packageId, module, functionName, typeArguments = [], sharedObjects = [], arguments: moveArguments }) {
+    if (!packageId || !module || !functionName)
+        throw new Error('Missing packageId, module, or functionName');
+    const moduleBytes = textToBytes(module);
+    const functionBytes = textToBytes(functionName);
+    const args = moveArguments || sharedObjects.map((_, i) => ({ Input: i }));
+    const inputCount = sharedObjects.length;
+    const bytes = [0, ...uleb128Encode(sharedObjects.length)];
+    sharedObjects.forEach(({ objectId, initialSharedVersion, mutable = false }) => {
+        bytes.push(1, 1, ...hexToBytes(objectId), ...(0, exports.toU64)(initialSharedVersion), mutable ? 1 : 0);
+    });
+    bytes.push(...uleb128Encode(1), 0, ...hexToBytes(packageId), ...uleb128Encode(moduleBytes.length), ...moduleBytes, ...uleb128Encode(functionBytes.length), ...functionBytes, ...uleb128Encode(typeArguments.length));
+    typeArguments.forEach(t => bytes.push(...typeTagToBytes(t)));
+    bytes.push(...uleb128Encode(args.length));
+    args.forEach((arg) => {
+        var _a;
+        const input = typeof arg === 'number' ? arg : ((_a = arg.Input) !== null && _a !== void 0 ? _a : arg.input);
+        if (input === undefined || !Number.isInteger(input) || input < 0 || input > 0xffff)
+            throw new Error(`Unsupported Sui move call argument: ${JSON.stringify(arg)}`);
+        if (input >= inputCount)
+            throw new Error(`Sui move call argument input ${input} exceeds input count ${inputCount}`);
+        bytes.push(1, ...(0, exports.toU16)(input));
+    });
+    return Uint8Array.from(bytes);
+}
+/** BCS `TransactionData::V1` wrapping `kindBytes` with dummy gas data (gas payment left empty for `doGasSelection`) */
+function buildTransactionDataBytes(kindBytes, { sender = exports.DUMMY_SENDER, gasPrice = 1000, gasBudget = 50000000000 } = {}) {
+    return Uint8Array.from([
+        0, // TransactionData::V1
+        ...Array.from(kindBytes), // TransactionKind::ProgrammableTransaction
+        ...hexToBytes(sender), // sender
+        ...uleb128Encode(0), // GasData.payment: empty
+        ...hexToBytes(sender), // GasData.owner
+        ...(0, exports.toU64)(gasPrice), // GasData.price
+        ...(0, exports.toU64)(gasBudget), // GasData.budget
+        0, // TransactionExpiration::None
+    ]);
+}
+/** BCS (base64) of a dynamic field name of the given Move type */
+function bcsDynamicFieldName(nameType, value) {
+    const type = String(nameType).trim();
+    let bytes;
+    if (type === 'address' || type === 'signer' || type.endsWith('::object::ID') || type.endsWith('::object::UID'))
+        bytes = hexToBytes(value); // 32 byte address
+    else if (type === 'bool')
+        bytes = [value === true || value === 'true' || value === 1 ? 1 : 0];
+    else if (type === 'u8')
+        bytes = [Number(value) & 0xff];
+    else if (type === 'u16')
+        bytes = (0, exports.toU16)(value);
+    else if (type === 'u32')
+        bytes = (0, exports.toU32)(value);
+    else if (type === 'u64')
+        bytes = (0, exports.toU64)(value);
+    else if (type === 'u128')
+        bytes = (0, exports.toU128)(value);
+    else if (type === 'u256')
+        bytes = (0, exports.toU256)(value);
+    else if (type === 'vector<u8>') {
+        const b = Array.isArray(value) ? value.map(Number) : textToBytes(String(value));
+        bytes = [...uleb128Encode(b.length), ...b]; // length-prefixed
+    }
+    else if (type.endsWith('::string::String') || type.endsWith('::ascii::String') || type.endsWith('::type_name::TypeName')) {
+        const b = textToBytes(String(value));
+        bytes = [...uleb128Encode(b.length), ...b]; // String == vector<u8> of utf8
+    }
+    else
+        throw new Error(`[sui] unsupported dynamic field name type: ${nameType}`);
+    return bytesToBase64(bytes);
+}
+function normalizeFields(fields) {
+    if (!fields || typeof fields !== 'object')
+        return fields;
+    const normalized = {};
+    for (const [key, value] of Object.entries(fields)) {
+        if (key === 'id' && typeof value === 'string') {
+            normalized[key] = { id: value };
+        }
+        else if (Array.isArray(value)) {
+            normalized[key] = value.map((v) => (typeof v === 'object' && v !== null) ? wrapStruct(v) : v);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            normalized[key] = wrapStruct(value);
+        }
+        else {
+            normalized[key] = value;
+        }
+    }
+    return normalized;
+}
+function wrapStruct(obj) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+        return obj;
+    return { fields: normalizeFields(obj) };
+}
+/** Mirror the JSON-RPC type display: strip leading zeros from addresses, but keep a single leading zero on 64-char addresses */
+function shortenTypeAddresses(type) {
+    return String(type)
+        .replace(/0x0*([0-9a-fA-F])/g, '0x$1')
+        .replace(/0x([0-9a-fA-F]{63})(?![0-9a-fA-F])/g, '0x0$1');
+}
+function normalizeTypeRepr(type) {
+    return shortenTypeAddresses(String(type).replace(/,(?!\s)/g, ', '));
+}
+function rewrapWithLayout(value, layout) {
+    if (!layout || typeof layout === 'string') {
+        if (layout === 'address' && typeof value === 'string' && value && !value.startsWith('0x'))
+            return '0x' + value;
+        return value;
+    }
+    if (layout.vector !== undefined)
+        return Array.isArray(value) ? value.map((v) => rewrapWithLayout(v, layout.vector)) : value;
+    if (layout.struct) {
+        const { type, fields } = layout.struct;
+        if (type.endsWith('::object::UID'))
+            return { id: (value && typeof value === 'object') ? value.id : value };
+        if (type.endsWith('::object::ID') || type.endsWith('::string::String') || type.endsWith('::ascii::String'))
+            return (value && typeof value === 'object') ? Object.values(value)[0] : value;
+        const t = normalizeTypeRepr(type);
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            const f = {};
+            for (const fl of fields)
+                f[fl.name] = rewrapWithLayout(value[fl.name], fl.layout);
+            return { type: t, fields: f };
+        }
+        if (type.endsWith('::type_name::TypeName'))
+            return { type: t, fields: { [fields[0].name]: value } };
+        return value;
+    }
+    return value;
+}
+/**
+ * Shape GraphQL `MoveObject.contents` / `MoveValue` (`{ json, type: { repr, layout? } }`) like the
+ * JSON-RPC `content` (`{ dataType, type, fields }`), nested structs wrapped as `{ type, fields }`.
+ * With a layout, Option / TypeName / UID / ID / String are rewrapped exactly; without it (`skipLayout`)
+ * only the generic struct wrapping is applied.
+ */
+function formatObject(contents, address) {
+    var _a, _b;
+    if (!contents || !contents.type)
+        return null;
+    const layout = contents.type.layout;
+    let out;
+    if (layout) {
+        const rewrapped = rewrapWithLayout(contents.json, layout);
+        if (!rewrapped || typeof rewrapped !== 'object')
+            throw new Error(`Unexpected Sui move object shape for type ${contents.type.repr}`);
+        out = { type: rewrapped.type, fields: rewrapped.fields, dataType: 'moveObject' };
+    }
+    else {
+        out = { type: normalizeTypeRepr(contents.type.repr), fields: normalizeFields(contents.json), dataType: 'moveObject' };
+    }
+    const id = address !== null && address !== void 0 ? address : (_b = (_a = out.fields) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.id;
+    if (id)
+        out.id = id;
+    return out;
+}
+/** Prefix a bare hex object id with 0x */
+function toAddr(id) {
+    if (typeof id === 'string' && id && !id.startsWith('0x') && /^[0-9a-fA-F]+$/.test(id))
+        return '0x' + id;
+    return id;
+}
+/** Shape GraphQL `json` like the JSON-RPC `parsedJson` of an event (TypeName -> `{ name }`, String / ID unwrapped, UID -> `{ id }`) */
+function toParsedJson(value, layout) {
+    var _a;
+    if (value === null || value === undefined)
+        return value;
+    if (!layout || typeof layout === 'string')
+        return value; // bool / uN / address
+    if (layout.vector !== undefined)
+        return Array.isArray(value) ? value.map((v) => toParsedJson(v, layout.vector)) : value;
+    if (layout.struct) {
+        const { type, fields } = layout.struct;
+        const unwrap = (v) => (v && typeof v === 'object' && !Array.isArray(v)) ? Object.values(v)[0] : v;
+        if (type.endsWith('::type_name::TypeName'))
+            return { name: unwrap(value) };
+        if (type.endsWith('::ascii::String') || type.endsWith('::string::String') || type.endsWith('::object::ID'))
+            return unwrap(value);
+        if (type.endsWith('::object::UID'))
+            return { id: (value && typeof value === 'object') ? ((_a = value.id) !== null && _a !== void 0 ? _a : unwrap(value)) : value };
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const out = {};
+            for (const f of fields)
+                out[f.name] = toParsedJson(value[f.name], f.layout);
+            return out;
+        }
+        return value;
+    }
+    return value;
+}
+/** Shape a JSON-RPC `getObject` response (`{ data: { objectId, type, content, owner, version } }`) like `formatObject` */
+function formatRpcObject(data) {
+    var _a, _b;
+    if (!data)
+        return null;
+    const content = data.content;
+    if (!content)
+        return null;
+    const out = {
+        id: data.objectId,
+        type: (_a = content.type) !== null && _a !== void 0 ? _a : data.type,
+        fields: content.fields,
+        dataType: (_b = content.dataType) !== null && _b !== void 0 ? _b : 'moveObject',
+    };
+    if (data.version !== undefined)
+        out.version = data.version;
+    if (data.owner !== undefined)
+        out.owner = data.owner;
+    return out;
+}
+// ---------------------------------------------------------------------------
+// GraphQL transport
+// ---------------------------------------------------------------------------
+class SuiGraphqlError extends Error {
+    constructor(message, errors = []) {
+        super(message);
+        this.name = 'SuiGraphqlError';
+        this.errors = errors;
+    }
+}
+exports.SuiGraphqlError = SuiGraphqlError;
+const NON_RETRYABLE_GRAPHQL = /Unknown (field|argument|type)|Syntax Error|Cannot query field|Expected type|Invalid value|Variable ".*" of (required )?type/i;
+/** POST a GraphQL query; returns `data`, throws `SuiGraphqlError` on `errors` / empty data. Rotates endpoints and retries. */
+async function graphqlCall({ chain = 'sui', query, variables = {}, retries, timeout = GRAPHQL_TIMEOUT }) {
+    const endpoints = getGraphqlEndpoints({ chain });
+    const limiter = (0, rpc_1.getLimiter)(`${chain.toUpperCase()}_GRAPHQL`, 10);
+    const attempts = retries !== null && retries !== void 0 ? retries : Math.max(3, endpoints.length);
+    return (0, rpc_1.withRetry)(async (attempt) => {
+        var _a, _b, _c, _d, _e;
+        const endpoint = endpoints[attempt % endpoints.length];
+        const res = await limiter(() => (0, rpc_1.httpPost)(endpoint, { query, variables }, { timeout, retries: 1 }));
+        if (((_a = res === null || res === void 0 ? void 0 : res.errors) === null || _a === void 0 ? void 0 : _a.length) || !(res === null || res === void 0 ? void 0 : res.data)) {
+            const message = (_d = (_c = (_b = res === null || res === void 0 ? void 0 : res.errors) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : 'no data returned';
+            throw new SuiGraphqlError(`[${chain}] graphql: ${message}`, (_e = res === null || res === void 0 ? void 0 : res.errors) !== null && _e !== void 0 ? _e : []);
+        }
+        return res.data;
+    }, {
+        retries: attempts,
+        label: `${chain} graphql`,
+        shouldRetry: (e) => !(e instanceof SuiGraphqlError && NON_RETRYABLE_GRAPHQL.test(e.message)),
+    });
+}
+const CONTENTS_FULL = 'contents { json type { repr layout } }';
+const CONTENTS_LITE = 'contents { json type { repr } }';
+const contentsSelection = (skipLayout) => skipLayout ? CONTENTS_LITE : CONTENTS_FULL;
+/** Raw JSON-RPC call (`sui_*` / `suix_*` / `iota_*` / `iotax_*`); returns `result` */
+async function call({ chain = 'sui', method, params = [], retries, timeout }) {
+    if (!Array.isArray(params))
+        params = [params];
+    return (0, rpc_1.jsonRpc)(method, params, { chain, defaultEndpoints: exports.DEFAULT_RPC_ENDPOINTS[chain], retries, timeout });
+}
+const RPC_OBJECT_OPTIONS = { showType: true, showOwner: true, showContent: true };
+/** `<prefix>_getObject` shaped like `getObject` (`{ id, type, fields, dataType, version, owner }`), null when missing */
+async function rpcGetObject({ chain = 'sui', objectId }) {
+    const res = await call({ chain, method: `${rpcPrefix(chain)}_getObject`, params: [toAddr(objectId), RPC_OBJECT_OPTIONS] });
+    return formatRpcObject(res === null || res === void 0 ? void 0 : res.data);
+}
+/** `<prefix>_multiGetObjects` in chunks of 9, order preserving (null for missing objects) */
+async function rpcGetObjects({ chain = 'sui', objectIds }) {
+    if (!objectIds.length)
+        return [];
+    const method = `${rpcPrefix(chain)}_multiGetObjects`;
+    return (0, rpc_1.runInChunks)(objectIds, async (chunk) => {
+        var _a;
+        const ids = chunk.map(toAddr);
+        const result = await call({ chain, method, params: [ids, RPC_OBJECT_OPTIONS] });
+        const byId = {};
+        for (const r of result !== null && result !== void 0 ? result : [])
+            if ((_a = r === null || r === void 0 ? void 0 : r.data) === null || _a === void 0 ? void 0 : _a.objectId)
+                byId[normalizeSuiAddress(r.data.objectId)] = r.data;
+        return ids.map((id, i) => { var _a, _b; return formatRpcObject((_a = byId[normalizeSuiAddress(id)]) !== null && _a !== void 0 ? _a : (_b = result === null || result === void 0 ? void 0 : result[i]) === null || _b === void 0 ? void 0 : _b.data); });
+    }, { chunkSize: RPC_OBJECTS_PER_QUERY });
+}
+/** Move object contents shaped like the JSON-RPC `content` (`{ id, type, fields, dataType }`), null when missing */
+async function getObject({ chain = 'sui', objectId, skipLayout }) {
+    var _a, _b, _c, _d;
+    if (!hasGraphql(chain))
+        return rpcGetObject({ chain, objectId });
+    const data = await graphqlCall({
+        chain, query: `query ($address: SuiAddress!) {
+    object(address: $address) { address version asMoveObject { ${contentsSelection(skipLayout)} } }
+  }`, variables: { address: toAddr(objectId) }
+    });
+    const obj = formatObject((_b = (_a = data.object) === null || _a === void 0 ? void 0 : _a.asMoveObject) === null || _b === void 0 ? void 0 : _b.contents, (_c = data.object) === null || _c === void 0 ? void 0 : _c.address);
+    if (obj && ((_d = data.object) === null || _d === void 0 ? void 0 : _d.version) !== undefined)
+        obj.version = data.object.version;
+    return obj;
+}
+/** `multiGetObjects` in chunks of 50, order preserving (null for missing objects) */
+async function getObjects({ chain = 'sui', objectIds, skipLayout, concurrency = 5, sleep: sleepTime }) {
+    if (!objectIds.length)
+        return [];
+    if (!hasGraphql(chain))
+        return rpcGetObjects({ chain, objectIds });
+    const sel = contentsSelection(skipLayout);
+    return (0, rpc_1.runInChunks)(objectIds, async (chunk) => {
+        var _a;
+        const ids = chunk.map(toAddr);
+        const keys = ids.map((id) => `{ address: ${JSON.stringify(id)} }`).join(', ');
+        const data = await graphqlCall({ chain, query: `{ multiGetObjects(keys: [${keys}]) { address asMoveObject { ${sel} } } }` });
+        const nodes = (_a = data.multiGetObjects) !== null && _a !== void 0 ? _a : [];
+        const byAddress = {};
+        for (const o of nodes)
+            if (o === null || o === void 0 ? void 0 : o.address)
+                byAddress[normalizeSuiAddress(o.address)] = o;
+        return ids.map((id, i) => {
+            var _a, _b;
+            const node = (_a = byAddress[normalizeSuiAddress(id)]) !== null && _a !== void 0 ? _a : nodes[i];
+            return formatObject((_b = node === null || node === void 0 ? void 0 : node.asMoveObject) === null || _b === void 0 ? void 0 : _b.contents, node === null || node === void 0 ? void 0 : node.address);
+        });
+    }, { chunkSize: OBJECTS_PER_QUERY, concurrency: sleepTime ? 1 : concurrency, sleepTime });
+}
+/** All live objects of a Move type (optionally owned by `owner`), walking every page */
+async function getObjectsByType({ chain = 'sui', type, owner, skipLayout, limit, transform }) {
+    var _a;
+    if (!hasGraphql(chain)) {
+        if (!owner)
+            throw new Error(`[${chain}] getObjectsByType needs a GraphQL endpoint (set ${chain.toUpperCase()}_GRAPH_RPC) or an owner`);
+        return getOwnedObjects({ chain, owner, type, limit, transform });
+    }
+    const filter = owner ? `{ type: ${JSON.stringify(type)}, owner: ${JSON.stringify(toAddr(owner))} }` : `{ type: ${JSON.stringify(type)} }`;
+    const objects = [];
+    let after = null;
+    do {
+        const data = await graphqlCall({
+            chain, query: `query ($after: String) {
+      objects(first: ${PAGE_SIZE}, after: $after, filter: ${filter}) {
+        pageInfo { hasNextPage endCursor }
+        nodes { address asMoveObject { ${contentsSelection(skipLayout)} } }
+      }
+    }`, variables: { after }
+        });
+        const { pageInfo, nodes } = data.objects;
+        for (const n of nodes) {
+            const obj = formatObject((_a = n.asMoveObject) === null || _a === void 0 ? void 0 : _a.contents, n.address);
+            if (obj)
+                objects.push(obj);
+        }
+        after = pageInfo.hasNextPage ? pageInfo.endCursor : null;
+        if (limit && objects.length >= limit)
+            break;
+    } while (after);
+    const out = limit ? objects.slice(0, limit) : objects;
+    return (transform ? out.map(transform) : out);
+}
+/** Objects owned by an address, walking every page */
+async function getOwnedObjects({ chain = 'sui', owner, type, skipLayout, limit, transform }) {
+    var _a, _b;
+    const objects = [];
+    if (!hasGraphql(chain)) {
+        let cursor = null;
+        do {
+            const query = { filter: type ? { StructType: type } : null, options: { showType: true, showContent: true } };
+            const res = await call({ chain, method: `${rpcPrefix(chain)}x_getOwnedObjects`, params: [toAddr(owner), query, cursor, PAGE_SIZE] });
+            for (const n of (_a = res === null || res === void 0 ? void 0 : res.data) !== null && _a !== void 0 ? _a : []) {
+                const obj = formatRpcObject(n === null || n === void 0 ? void 0 : n.data);
+                if (obj)
+                    objects.push(obj);
+            }
+            cursor = (res === null || res === void 0 ? void 0 : res.hasNextPage) ? res.nextCursor : null;
+            if (limit && objects.length >= limit)
+                break;
+        } while (cursor);
+    }
+    else {
+        const filter = type ? `, filter: { type: ${JSON.stringify(type)} }` : '';
+        let after = null;
+        do {
+            const data = await graphqlCall({
+                chain, query: `query ($owner: SuiAddress!, $after: String) {
+        address(address: $owner) {
+          objects(first: ${PAGE_SIZE}, after: $after${filter}) {
+            pageInfo { hasNextPage endCursor }
+            nodes { address ${contentsSelection(skipLayout)} }
+          }
+        }
+      }`, variables: { owner: toAddr(owner), after }
+            });
+            const page = (_b = data.address) === null || _b === void 0 ? void 0 : _b.objects;
+            if (!page)
+                break;
+            for (const n of page.nodes) {
+                const obj = formatObject(n.contents, n.address);
+                if (obj)
+                    objects.push(obj);
+            }
+            after = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
+            if (limit && objects.length >= limit)
+                break;
+        } while (after);
+    }
+    const out = limit ? objects.slice(0, limit) : objects;
+    return (transform ? out.map(transform) : out);
+}
+function buildEventFilter({ eventType, eventModule, sender }) {
+    const parts = [];
+    if (eventType)
+        parts.push(`type: ${JSON.stringify(eventType)}`);
+    if (eventModule) {
+        const mod = typeof eventModule === 'string' ? eventModule : `${eventModule.package}::${eventModule.module}`;
+        parts.push(`module: ${JSON.stringify(mod)}`);
+    }
+    if (sender)
+        parts.push(`sender: ${JSON.stringify(toAddr(sender))}`);
+    return parts.length ? `, filter: { ${parts.join(', ')} }` : '';
+}
+function toSeconds(value) {
+    return value > 1e12 ? value / 1e3 : value;
+}
+/**
+ * Events matching a type / module / sender filter, cursor walking all pages (oldest first).
+ * With `startTimestamp` / `endTimestamp` the newest events are walked backwards and only the
+ * half-open window `[start, end)` is returned (as dimension-adapters did).
+ */
+async function queryEvents(options) {
+    const { chain = 'sui', limit, skipLayout, withMetadata, transform } = options;
+    if (!hasGraphql(chain))
+        throw new Error(`[${chain}] queryEvents needs a GraphQL endpoint (set ${chain.toUpperCase()}_GRAPH_RPC)`);
+    const filter = buildEventFilter(options);
+    const start = options.startTimestamp !== undefined ? toSeconds(options.startTimestamp) : undefined;
+    const end = options.endTimestamp !== undefined ? toSeconds(options.endTimestamp) : undefined;
+    const windowed = start !== undefined || end !== undefined;
+    const sel = `timestamp sender { address } ${contentsSelection(skipLayout)}`;
+    const items = [];
+    const shape = (node) => {
+        var _a, _b, _c;
+        const json = skipLayout ? node.contents.json : toParsedJson(node.contents.json, (_a = node.contents.type) === null || _a === void 0 ? void 0 : _a.layout);
+        if (!withMetadata)
+            return json;
+        const event = { type: (_b = node.contents.type) === null || _b === void 0 ? void 0 : _b.repr, timestamp: Date.parse(node.timestamp) / 1e3, sender: (_c = node.sender) === null || _c === void 0 ? void 0 : _c.address, json };
+        return event;
+    };
+    if (windowed) {
+        let before = null;
+        do {
+            const data = await graphqlCall({
+                chain, query: `query ($before: String) {
+        events(last: ${PAGE_SIZE}, before: $before${filter}) {
+          pageInfo { hasPreviousPage startCursor }
+          nodes { ${sel} }
+        }
+      }`, variables: { before }
+            });
+            const { pageInfo, nodes } = data.events; // ascending (oldest -> newest)
+            before = pageInfo.hasPreviousPage ? pageInfo.startCursor : null;
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const ts = Date.parse(nodes[i].timestamp) / 1e3;
+                if (end !== undefined && ts >= end)
+                    continue;
+                if (start !== undefined && ts < start) {
+                    before = null;
+                    break;
+                }
+                items.push(shape(nodes[i]));
+            }
+            if (!nodes.length)
+                before = null;
+            if (limit && items.length >= limit)
+                before = null;
+        } while (before);
+        items.reverse(); // oldest first, like the forward walk
+    }
+    else {
+        let after = null;
+        do {
+            const data = await graphqlCall({
+                chain, query: `query ($after: String) {
+        events(first: ${PAGE_SIZE}, after: $after${filter}) {
+          pageInfo { hasNextPage endCursor }
+          nodes { ${sel} }
+        }
+      }`, variables: { after }
+            });
+            const { pageInfo, nodes } = data.events;
+            after = pageInfo.hasNextPage ? pageInfo.endCursor : null;
+            for (const n of nodes)
+                items.push(shape(n));
+            if (limit && items.length >= limit)
+                after = null;
+        } while (after);
+    }
+    const out = limit ? items.slice(0, limit) : items;
+    return (transform ? out.map(transform) : out);
+}
+// ---------------------------------------------------------------------------
+// dynamic fields
+// ---------------------------------------------------------------------------
+/**
+ * Selects both the dynamic field's own object (`contents`, the `0x2::dynamic_field::Field<K, V>`
+ * wrapper with `fields.name` / `fields.value`) and its `value`. Dynamic *object* fields resolve to
+ * the child MoveObject; plain dynamic fields resolve to the Field wrapper, which is what the
+ * adapters historically read (`i.fields.value`) and the only shape that works for primitive values
+ * such as `0x2::object::ID`.
+ */
+const DYNAMIC_FIELD_VALUE_SELECTION = (skipLayout) => `${contentsSelection(skipLayout)} value {
+  __typename
+  ... on MoveValue { json type { repr ${skipLayout ? '' : 'layout'} } }
+  ... on MoveObject { address ${contentsSelection(skipLayout)} }
+}`;
+function formatDynamicFieldValue(node, fallbackAddress) {
+    const { value, contents } = node !== null && node !== void 0 ? node : {};
+    if ((value === null || value === void 0 ? void 0 : value.__typename) === 'MoveObject' && value.contents)
+        return formatObject(value.contents, value.address);
+    if (contents)
+        return formatObject(contents, fallbackAddress);
+    if (!value)
+        return null;
+    return formatObject({ json: value.json, type: value.type }, fallbackAddress);
+}
+/** One dynamic field (or dynamic object field) of `parent` by name; null when missing */
+async function getDynamicFieldObject({ chain = 'sui', parent, name, id, nameType, idType, nameBcs, skipLayout }) {
+    var _a, _b, _c, _d, _e;
+    const type = (_a = nameType !== null && nameType !== void 0 ? nameType : idType) !== null && _a !== void 0 ? _a : '0x2::object::ID';
+    const value = name !== null && name !== void 0 ? name : id;
+    const bcs = nameBcs !== null && nameBcs !== void 0 ? nameBcs : (value !== undefined ? bcsDynamicFieldName(type, value) : exports.EMPTY_STRUCT_BCS);
+    if (!hasGraphql(chain)) {
+        const res = await call({ chain, method: `${rpcPrefix(chain)}x_getDynamicFieldObject`, params: [toAddr(parent), { type, value: typeof value === 'bigint' ? value.toString() : value }] });
+        const obj = formatRpcObject(res === null || res === void 0 ? void 0 : res.data);
+        if (obj && value !== undefined)
+            obj.name = value;
+        return obj;
+    }
+    const sel = DYNAMIC_FIELD_VALUE_SELECTION(skipLayout);
+    const data = await graphqlCall({
+        chain, query: `query ($parent: SuiAddress!, $name: DynamicFieldName!) {
+    address(address: $parent) {
+      dynamicField(name: $name) { name { json } ${sel} }
+      dynamicObjectField(name: $name) { name { json } ${sel} }
+    }
+  }`, variables: { parent: toAddr(parent), name: { type, bcs } }
+    });
+    const df = (_c = (_b = data.address) === null || _b === void 0 ? void 0 : _b.dynamicObjectField) !== null && _c !== void 0 ? _c : (_d = data.address) === null || _d === void 0 ? void 0 : _d.dynamicField;
+    if (!df)
+        return null;
+    const obj = formatDynamicFieldValue(df);
+    if (obj)
+        obj.name = (_e = df.name) === null || _e === void 0 ? void 0 : _e.json;
+    return obj;
+}
+/** All dynamic fields of `parent` (Table / Bag / ObjectTable entries), walking every page. Each item carries `name` (the field key). */
+async function getDynamicFieldObjects({ chain = 'sui', parent, cursor = null, limit, pageSize = PAGE_SIZE, idFilter, skipLayout, sleep: sleepTime, onPage }) {
+    var _a, _b, _c, _d, _e, _f;
+    const size = Math.min(Math.max(1, Number(pageSize) || PAGE_SIZE), 50);
+    const items = [];
+    const addedIds = new Set();
+    const useRpc = !hasGraphql(chain);
+    const parentAddr = toAddr(parent);
+    let after = cursor;
+    const push = async (pageItems) => {
+        if (onPage)
+            await onPage(pageItems); // let callers start downstream reads while paging continues
+        else
+            items.push(...pageItems);
+    };
+    let count = 0;
+    do {
+        if (sleepTime)
+            await (0, rpc_1.sleep)(sleepTime);
+        const pageItems = [];
+        if (useRpc) {
+            const prefix = rpcPrefix(chain);
+            const page = await call({ chain, method: `${prefix}x_getDynamicFields`, params: [parentAddr, after, size] });
+            const ids = ((_a = page === null || page === void 0 ? void 0 : page.data) !== null && _a !== void 0 ? _a : []).map((f) => f.objectId);
+            const objs = await rpcGetObjects({ chain, objectIds: ids });
+            (_b = page === null || page === void 0 ? void 0 : page.data) === null || _b === void 0 ? void 0 : _b.forEach((f, i) => {
+                var _a, _b;
+                const obj = objs[i];
+                if (!obj || addedIds.has(obj.id))
+                    return;
+                obj.name = (_a = f.name) === null || _a === void 0 ? void 0 : _a.value;
+                if (idFilter && !idFilter({ objectId: obj.id, objectType: obj.type, name: (_b = obj.fields) === null || _b === void 0 ? void 0 : _b.name, key: obj.name }))
+                    return;
+                addedIds.add(obj.id);
+                pageItems.push(obj);
+            });
+            after = (page === null || page === void 0 ? void 0 : page.hasNextPage) ? page.nextCursor : null;
+        }
+        else {
+            const data = await graphqlCall({
+                chain, query: `query ($parent: SuiAddress!, $after: String) {
+        address(address: $parent) {
+          dynamicFields(first: ${size}, after: $after) {
+            pageInfo { hasNextPage endCursor }
+            nodes { address name { json } ${DYNAMIC_FIELD_VALUE_SELECTION(skipLayout)} }
+          }
+        }
+      }`, variables: { parent: parentAddr, after }
+            });
+            const df = (_c = data.address) === null || _c === void 0 ? void 0 : _c.dynamicFields;
+            if (!df)
+                throw new Error(`[${chain}] dynamicFields not available for ${parent} (endpoint may not index this object)`);
+            (0, debugLog_1.debugLog)(`[${chain}] fetched dynamic fields`, df.nodes.length, df.pageInfo.hasNextPage);
+            for (const n of df.nodes) {
+                const obj = formatDynamicFieldValue(n, n.address);
+                const objectId = (_d = obj === null || obj === void 0 ? void 0 : obj.id) !== null && _d !== void 0 ? _d : n.address;
+                if (!obj || !objectId || addedIds.has(objectId))
+                    continue;
+                obj.id = objectId;
+                obj.name = (_e = n.name) === null || _e === void 0 ? void 0 : _e.json; // the dynamic-field key (e.g. a coin TypeName), which the value object may not carry
+                if (idFilter && !idFilter({ objectId, objectType: obj.type, name: (_f = obj.fields) === null || _f === void 0 ? void 0 : _f.name, key: obj.name }))
+                    continue;
+                addedIds.add(objectId);
+                pageItems.push(obj);
+            }
+            after = df.pageInfo.hasNextPage ? df.pageInfo.endCursor : null;
+        }
+        count += pageItems.length;
+        await push(limit && count > limit ? pageItems.slice(0, pageItems.length - (count - limit)) : pageItems);
+        if (limit && count >= limit)
+            after = null;
+    } while (after);
+    return items;
+}
+/** `coinMetadata` (GraphQL) or `<prefix>x_getCoinMetadata` + `<prefix>x_getTotalSupply` (JSON-RPC) */
+async function getCoinMetadata({ chain = 'sui', coinType }) {
+    var _a, _b;
+    if (!hasGraphql(chain)) {
+        const prefix = rpcPrefix(chain);
+        const meta = await call({ chain, method: `${prefix}x_getCoinMetadata`, params: [coinType] });
+        if (!meta)
+            throw new Error(`[${chain}] Failed to fetch coin metadata for token: ${coinType}`);
+        let supply;
+        try {
+            const res = await call({ chain, method: `${prefix}x_getTotalSupply`, params: [coinType] });
+            supply = res === null || res === void 0 ? void 0 : res.value;
+        }
+        catch (e) {
+            (0, debugLog_1.debugLog)(`[${chain}] getTotalSupply failed for ${coinType}: ${e === null || e === void 0 ? void 0 : e.message}`);
+        }
+        return { decimals: meta.decimals, symbol: meta.symbol, name: meta.name, description: meta.description, iconUrl: meta.iconUrl, supply };
+    }
+    const data = await graphqlCall({
+        chain, query: `query ($coinType: String!) {
+    coinMetadata(coinType: $coinType) { decimals symbol name description iconUrl supply }
+  }`, variables: { coinType }
+    });
+    const meta = data.coinMetadata;
+    if (!meta)
+        throw new Error(`[${chain}] Failed to fetch coin metadata for token: ${coinType}`);
+    return { decimals: (_a = meta.decimals) !== null && _a !== void 0 ? _a : 0, symbol: meta.symbol, name: meta.name, description: meta.description, iconUrl: meta.iconUrl, supply: (_b = meta.supply) !== null && _b !== void 0 ? _b : undefined };
+}
+async function getTokenSupply({ chain = 'sui', coinType }) {
+    const { supply, decimals } = await getCoinMetadata({ chain, coinType });
+    if (supply === undefined || supply === null)
+        throw new Error(`[${chain}] supply not available for token: ${coinType}`);
+    return { supply: String(supply), decimals, normalized: Number(supply) / 10 ** decimals };
+}
+/** Every coin balance of `owner`, walking all pages */
+async function getAllBalances({ chain = 'sui', owner }) {
+    var _a, _b, _c;
+    const out = [];
+    if (!hasGraphql(chain)) {
+        const res = await call({ chain, method: `${rpcPrefix(chain)}x_getAllBalances`, params: [toAddr(owner)] });
+        for (const b of res !== null && res !== void 0 ? res : [])
+            out.push({ coinType: b.coinType, totalBalance: String(b.totalBalance) });
+        return out;
+    }
+    let after = null;
+    do {
+        const data = await graphqlCall({
+            chain, query: `query ($owner: SuiAddress!, $after: String) {
+      address(address: $owner) {
+        balances(first: ${PAGE_SIZE}, after: $after) {
+          nodes { coinType { repr } totalBalance }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }`, variables: { owner: toAddr(owner), after }
+        });
+        const balances = (_a = data.address) === null || _a === void 0 ? void 0 : _a.balances;
+        if (!balances)
+            break;
+        for (const n of (_b = balances.nodes) !== null && _b !== void 0 ? _b : [])
+            out.push({ coinType: n.coinType.repr, totalBalance: String(n.totalBalance) });
+        after = ((_c = balances.pageInfo) === null || _c === void 0 ? void 0 : _c.hasNextPage) ? balances.pageInfo.endCursor : null;
+    } while (after);
+    return out;
+}
+/** Balance of one coin type for `owner` (base units, '0' when none) */
+async function getBalance({ chain = 'sui', owner, coinType }) {
+    var _a, _b, _c, _d;
+    if (!hasGraphql(chain)) {
+        const res = await call({ chain, method: `${rpcPrefix(chain)}x_getBalance`, params: [toAddr(owner), coinType] });
+        return String((_a = res === null || res === void 0 ? void 0 : res.totalBalance) !== null && _a !== void 0 ? _a : '0');
+    }
+    const data = await graphqlCall({
+        chain, query: `query ($owner: SuiAddress!, $coinType: String!) {
+    address(address: $owner) { balance(coinType: $coinType) { totalBalance } }
+  }`, variables: { owner: toAddr(owner), coinType }
+    });
+    return String((_d = (_c = (_b = data.address) === null || _b === void 0 ? void 0 : _b.balance) === null || _c === void 0 ? void 0 : _c.totalBalance) !== null && _d !== void 0 ? _d : '0');
+}
+function shapeGraphqlCheckpoint(c) {
+    if (!c)
+        return null;
+    return { sequenceNumber: Number(c.sequenceNumber), timestamp: Math.floor(Date.parse(c.timestamp) / 1e3), digest: c.digest };
+}
+function shapeRpcCheckpoint(c) {
+    if (!c)
+        return null;
+    return { sequenceNumber: Number(c.sequenceNumber), timestamp: Math.floor(Number(c.timestampMs) / 1e3), digest: c.digest };
+}
+/** A checkpoint by sequence number; null when the endpoint no longer has it */
+async function getCheckpoint({ chain = 'sui', sequenceNumber }) {
+    if (!hasGraphql(chain)) {
+        const res = await call({ chain, method: `${rpcPrefix(chain)}_getCheckpoint`, params: [String(sequenceNumber)] });
+        return shapeRpcCheckpoint(res);
+    }
+    const data = await graphqlCall({
+        chain, query: `query ($seq: UInt53!) { checkpoint(sequenceNumber: $seq) { sequenceNumber timestamp digest } }`,
+        variables: { seq: Number(sequenceNumber) },
+    });
+    return shapeGraphqlCheckpoint(data.checkpoint);
+}
+async function getLatestCheckpoint({ chain = 'sui' } = {}) {
+    if (!hasGraphql(chain)) {
+        const prefix = rpcPrefix(chain);
+        const seq = await call({ chain, method: `${prefix}_getLatestCheckpointSequenceNumber`, params: [] });
+        const c = await getCheckpoint({ chain, sequenceNumber: seq });
+        if (!c)
+            throw new Error(`[${chain}] checkpoint ${seq} not found`);
+        return c;
+    }
+    const data = await graphqlCall({ chain, query: `{ checkpoint { sequenceNumber timestamp digest } }` });
+    const c = shapeGraphqlCheckpoint(data.checkpoint);
+    if (!c)
+        throw new Error(`[${chain}] latest checkpoint not available`);
+    return c;
+}
+/** Last checkpoint with `timestamp <= target` (binary search over sequence numbers, ~30 requests) */
+async function getCheckpointAtTimestamp({ chain = 'sui', timestamp }) {
+    const target = toSeconds(timestamp);
+    const latest = await getLatestCheckpoint({ chain });
+    if (latest.timestamp <= target)
+        return latest;
+    let lo = 0;
+    let hi = latest.sequenceNumber;
+    let best = null;
+    while (lo < hi) {
+        const mid = Math.floor((lo + hi + 1) / 2);
+        const c = await getCheckpoint({ chain, sequenceNumber: mid });
+        if (!c || c.timestamp <= target) {
+            // missing (pruned) checkpoints are treated as older than the target
+            if (c)
+                best = c;
+            lo = mid;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    if (best && best.sequenceNumber === lo)
+        return best;
+    const c = await getCheckpoint({ chain, sequenceNumber: lo });
+    if (!c)
+        throw new Error(`[${chain}] no checkpoint found at or before ${target}`);
+    return c;
+}
+/** Simulate a transaction kind and return the BCS return values of every command (GraphQL `simulateTransaction`, JSON-RPC `devInspectTransactionBlock`) */
+async function devInspectTransactionBlock({ chain = 'sui', txBytes, sender = exports.DUMMY_SENDER }) {
+    var _a, _b, _c, _d, _e;
+    const kindBytes = Array.from(txBytes);
+    if (!hasGraphql(chain)) {
+        const res = await call({ chain, method: `${rpcPrefix(chain)}_devInspectTransactionBlock`, params: [sender, bytesToBase64(kindBytes)] });
+        if (res === null || res === void 0 ? void 0 : res.error)
+            throw new Error(`[${chain}] devInspectTransactionBlock failed: ${res.error}`);
+        const status = (_b = (_a = res === null || res === void 0 ? void 0 : res.effects) === null || _a === void 0 ? void 0 : _a.status) === null || _b === void 0 ? void 0 : _b.status;
+        if (status && status !== 'success')
+            throw new Error(`[${chain}] devInspectTransactionBlock failed: ${(_c = res.effects.status.error) !== null && _c !== void 0 ? _c : status}`);
+        const results = ((_d = res === null || res === void 0 ? void 0 : res.results) !== null && _d !== void 0 ? _d : []).map((cmd) => {
+            var _a;
+            return ({
+                returnValues: ((_a = cmd.returnValues) !== null && _a !== void 0 ? _a : []).map((rv) => [Array.from(rv[0]), rv[1]]),
+            });
+        });
+        return { results, effects: res === null || res === void 0 ? void 0 : res.effects };
+    }
+    const value = bytesToBase64(buildTransactionDataBytes(kindBytes, { sender }));
+    const data = await graphqlCall({
+        chain, query: `query ($tx: JSON!) {
+    simulateTransaction(transaction: $tx, checksEnabled: false, doGasSelection: true) {
+      effects { status }
+      outputs { returnValues { value { bcs type { repr } } } }
+    }
+  }`, variables: { tx: { bcs: { value } } }
+    });
+    const sim = data.simulateTransaction;
+    if (((_e = sim === null || sim === void 0 ? void 0 : sim.effects) === null || _e === void 0 ? void 0 : _e.status) && sim.effects.status !== 'SUCCESS')
+        throw new Error(`[${chain}] simulateTransaction failed: ${sim.effects.status}`);
+    const results = ((sim === null || sim === void 0 ? void 0 : sim.outputs) || []).map((cmd) => ({
+        returnValues: (cmd.returnValues || []).map((rv) => { var _a; return [base64ToBytes(rv.value.bcs), (_a = rv.value.type) === null || _a === void 0 ? void 0 : _a.repr]; }),
+    }));
+    return { results, effects: sim === null || sim === void 0 ? void 0 : sim.effects };
+}
+/** `initialSharedVersion` of a shared object (needed to reference it as a transaction input) */
+async function getInitialSharedVersion({ chain = 'sui', objectId }) {
+    var _a, _b, _c, _d, _e;
+    if (!hasGraphql(chain)) {
+        const res = await call({ chain, method: `${rpcPrefix(chain)}_getObject`, params: [toAddr(objectId), { showOwner: true }] });
+        const version = (_c = (_b = (_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.owner) === null || _b === void 0 ? void 0 : _b.Shared) === null || _c === void 0 ? void 0 : _c.initial_shared_version;
+        if (version === undefined || version === null)
+            throw new Error(`[${chain}] object ${objectId} is not a shared object`);
+        return Number(version);
+    }
+    const data = await graphqlCall({
+        chain, query: `query ($address: SuiAddress!) {
+    object(address: $address) { owner { __typename ... on Shared { initialSharedVersion } } }
+  }`, variables: { address: toAddr(objectId) }
+    });
+    const version = (_e = (_d = data.object) === null || _d === void 0 ? void 0 : _d.owner) === null || _e === void 0 ? void 0 : _e.initialSharedVersion;
+    if (version === undefined || version === null)
+        throw new Error(`[${chain}] object ${objectId} is not a shared object`);
+    return Number(version);
+}
+/** Build a single MoveCall over shared objects, simulate it and return `[bcsBytes, typeRepr]` per return value */
+async function callViewFunction({ chain = 'sui', sharedObjects = [], sender, ...moveCall }) {
+    var _a, _b;
+    const refs = await Promise.all(sharedObjects.map(async (o) => {
+        if (typeof o !== 'string' && o.initialSharedVersion !== undefined)
+            return o;
+        const objectId = typeof o === 'string' ? o : o.objectId;
+        const initialSharedVersion = await getInitialSharedVersion({ chain, objectId });
+        return { objectId, initialSharedVersion, mutable: typeof o === 'string' ? false : o.mutable };
+    }));
+    const txBytes = buildProgrammableMoveCallBytes({ ...moveCall, sharedObjects: refs });
+    const { results } = await devInspectTransactionBlock({ chain, txBytes, sender });
+    return (_b = (_a = results[0]) === null || _a === void 0 ? void 0 : _a.returnValues) !== null && _b !== void 0 ? _b : [];
+}