@defillama/sdk 5.0.236 → 5.0.240

package/build/chains/sui.d.ts

@@ -1,365 +0,0 @@
-/**
- * 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
- */
-import { sliceIntoChunks } from "./rpc";
-export declare const suiChains: string[];
-export declare const DEFAULT_GRAPHQL_ENDPOINTS: Record<string, string>;
-export declare const DEFAULT_RPC_ENDPOINTS: Record<string, string>;
-export declare const DUMMY_SENDER: string;
-/** BCS of a Move struct whose only member is `dummy_field: bool` (Wormhole-style `Key<T>` witness structs) */
-export declare const EMPTY_STRUCT_BCS = "AA==";
-export interface ChainOptions {
-    /** 'sui' (default) or 'iota' */
-    chain?: string;
-}
-export declare function getGraphqlEndpoints({ chain }?: ChainOptions): string[];
-export declare function getGraphqlEndpoint(options?: ChainOptions): string;
-export declare function getRpcEndpoints({ chain }?: ChainOptions): string[];
-export declare function getRpcEndpoint(options?: ChainOptions): string;
-/** true when the chain has a GraphQL endpoint (built-in default or `<CHAIN>_GRAPH_RPC`) */
-export declare function hasGraphql(chain?: string): boolean;
-export type Bytes = number[] | Uint8Array;
-export type IntLike = number | string | bigint;
-/** Hex string (with or without 0x) to a fixed-size byte array, left padded with zeros. Default size is a 32 byte address. */
-export declare function hexToBytes(hex: string, size?: number): number[];
-export declare function bytesToHex(bytes: Bytes): string;
-export declare function textToBytes(value: string): number[];
-export declare function bytesToBase64(bytes: Bytes): string;
-export declare function base64ToBytes(value: string): number[];
-export declare function uleb128Encode(value: IntLike): number[];
-/** Decode a uleb128 at `offset`; returns the value and how many bytes it consumed. */
-export declare function uleb128Decode(data: Bytes, offset?: number): {
-    value: number;
-    length: number;
-};
-/** Alias kept for parity with the adapters helper */
-export declare const uleb128: typeof uleb128Encode;
-export declare function toLittleEndian(value: IntLike, size: number): number[];
-export declare const toU16: (value: IntLike) => number[];
-export declare const toU32: (value: IntLike) => number[];
-export declare const toU64: (value: IntLike) => number[];
-export declare const toU128: (value: IntLike) => number[];
-export declare const toU256: (value: IntLike) => number[];
-export declare function fromLittleEndian(data: Bytes, offset?: number, size?: number): bigint;
-export declare const fromU16: (data: Bytes, offset?: number) => bigint;
-export declare const fromU32: (data: Bytes, offset?: number) => bigint;
-export declare const fromU64: (data: Bytes, offset?: number) => bigint;
-export declare const fromU128: (data: Bytes, offset?: number) => bigint;
-export declare const fromU256: (data: Bytes, offset?: number) => bigint;
-/** Lower-cased, 0x-prefixed, zero padded 64 hex char address */
-export declare function normalizeSuiAddress(address: string): string;
-/**
- * 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.
- */
-export declare function normalizeCoinType(coinType: string): string;
-/** Split a comma separated generic argument list, respecting nested `<...>` */
-export declare function splitTypeArgs(value: string): string[];
-export interface StructTag {
-    address: string;
-    module: string;
-    name: string;
-    typeParams: string[];
-}
-export declare function parseStructTag(type: string): StructTag;
-/** BCS `TypeTag` */
-export declare function typeTagToBytes(type: string): number[];
-export interface SharedObjectRef {
-    objectId: string;
-    initialSharedVersion: IntLike;
-    mutable?: boolean;
-}
-export type MoveCallArgument = number | {
-    Input?: number;
-    input?: number;
-};
-export interface MoveCallParams {
-    packageId: string;
-    module: string;
-    functionName: string;
-    typeArguments?: string[];
-    /** shared objects become the transaction inputs, in order */
-    sharedObjects?: SharedObjectRef[];
-    /** defaults to one `Input(i)` per shared object */
-    arguments?: MoveCallArgument[];
-}
-/**
- * BCS `TransactionKind::ProgrammableTransaction` with a single `MoveCall` command whose inputs are
- * shared objects (enough for read-only view functions inspected through `devInspectTransactionBlock`).
- */
-export declare function buildProgrammableMoveCallBytes({ packageId, module, functionName, typeArguments, sharedObjects, arguments: moveArguments }: MoveCallParams): Uint8Array;
-export interface TransactionDataOptions {
-    sender?: string;
-    gasPrice?: IntLike;
-    gasBudget?: IntLike;
-}
-/** BCS `TransactionData::V1` wrapping `kindBytes` with dummy gas data (gas payment left empty for `doGasSelection`) */
-export declare function buildTransactionDataBytes(kindBytes: Bytes, { sender, gasPrice, gasBudget }?: TransactionDataOptions): Uint8Array;
-/** BCS (base64) of a dynamic field name of the given Move type */
-export declare function bcsDynamicFieldName(nameType: string, value: any): string;
-export interface SuiObject {
-    /** object address (from the query key, or the UID inside `fields.id`) */
-    id?: string;
-    type: string;
-    fields: any;
-    dataType: 'moveObject';
-    /** dynamic field key (`name.json`) when read via `getDynamicFieldObject(s)` */
-    name?: any;
-    version?: number | string;
-    owner?: any;
-    [key: string]: any;
-}
-/** Mirror the JSON-RPC type display: strip leading zeros from addresses, but keep a single leading zero on 64-char addresses */
-export declare function shortenTypeAddresses(type: string): string;
-/**
- * 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.
- */
-export declare function formatObject(contents: any, address?: string): SuiObject | null;
-/** Prefix a bare hex object id with 0x */
-export declare function toAddr(id: string): string;
-/** Shape GraphQL `json` like the JSON-RPC `parsedJson` of an event (TypeName -> `{ name }`, String / ID unwrapped, UID -> `{ id }`) */
-export declare function toParsedJson(value: any, layout: any): any;
-export declare class SuiGraphqlError extends Error {
-    errors: any[];
-    constructor(message: string, errors?: any[]);
-}
-export interface GraphqlCallOptions extends ChainOptions {
-    query: string;
-    variables?: Record<string, any>;
-    /** total attempts, default 3 (at least one per endpoint) */
-    retries?: number;
-    timeout?: number;
-}
-/** POST a GraphQL query; returns `data`, throws `SuiGraphqlError` on `errors` / empty data. Rotates endpoints and retries. */
-export declare function graphqlCall({ chain, query, variables, retries, timeout }: GraphqlCallOptions): Promise<any>;
-export interface CallOptions extends ChainOptions {
-    method: string;
-    params?: any;
-    retries?: number;
-    timeout?: number;
-}
-/** Raw JSON-RPC call (`sui_*` / `suix_*` / `iota_*` / `iotax_*`); returns `result` */
-export declare function call({ chain, method, params, retries, timeout }: CallOptions): Promise<any>;
-export interface RpcGetObjectOptions extends ChainOptions {
-    objectId: string;
-}
-/** `<prefix>_getObject` shaped like `getObject` (`{ id, type, fields, dataType, version, owner }`), null when missing */
-export declare function rpcGetObject({ chain, objectId }: RpcGetObjectOptions): Promise<SuiObject | null>;
-export interface RpcGetObjectsOptions extends ChainOptions {
-    objectIds: string[];
-}
-/** `<prefix>_multiGetObjects` in chunks of 9, order preserving (null for missing objects) */
-export declare function rpcGetObjects({ chain, objectIds }: RpcGetObjectsOptions): Promise<(SuiObject | null)[]>;
-export interface GetObjectOptions extends ChainOptions {
-    objectId: string;
-    /** drop the layout blob (~3.5x the json payload); only safe when reading plain fields */
-    skipLayout?: boolean;
-}
-/** Move object contents shaped like the JSON-RPC `content` (`{ id, type, fields, dataType }`), null when missing */
-export declare function getObject({ chain, objectId, skipLayout }: GetObjectOptions): Promise<SuiObject | null>;
-export interface GetObjectsOptions extends ChainOptions {
-    objectIds: string[];
-    skipLayout?: boolean;
-    /** parallel chunks of 50, default 5 */
-    concurrency?: number;
-    /** ms to wait between chunks (forces sequential chunks) */
-    sleep?: number;
-}
-/** `multiGetObjects` in chunks of 50, order preserving (null for missing objects) */
-export declare function getObjects({ chain, objectIds, skipLayout, concurrency, sleep: sleepTime }: GetObjectsOptions): Promise<(SuiObject | null)[]>;
-export interface GetObjectsByTypeOptions<T = SuiObject> extends ChainOptions {
-    type: string;
-    owner?: string;
-    skipLayout?: boolean;
-    /** stop after this many objects */
-    limit?: number;
-    transform?: (obj: SuiObject) => T;
-}
-/** All live objects of a Move type (optionally owned by `owner`), walking every page */
-export declare function getObjectsByType<T = SuiObject>({ chain, type, owner, skipLayout, limit, transform }: GetObjectsByTypeOptions<T>): Promise<T[]>;
-export interface GetOwnedObjectsOptions<T = SuiObject> extends ChainOptions {
-    owner: string;
-    /** struct type filter, e.g. `0x2::coin::Coin` */
-    type?: string;
-    skipLayout?: boolean;
-    limit?: number;
-    transform?: (obj: SuiObject) => T;
-}
-/** Objects owned by an address, walking every page */
-export declare function getOwnedObjects<T = SuiObject>({ chain, owner, type, skipLayout, limit, transform }: GetOwnedObjectsOptions<T>): Promise<T[]>;
-export interface SuiEvent {
-    type: string;
-    /** unix seconds */
-    timestamp: number;
-    sender?: string;
-    /** parsed event payload */
-    json: any;
-}
-export interface QueryEventsOptions<T = any> extends ChainOptions {
-    /** full event struct type, e.g. `0x...::pool::SwapEvent` */
-    eventType?: string;
-    /** emitting module, `package::module` or `{ package, module }` */
-    eventModule?: string | {
-        package: string;
-        module: string;
-    };
-    sender?: string;
-    /** unix seconds, inclusive. With a window the newest events are walked backwards until `startTimestamp`. */
-    startTimestamp?: number;
-    /** unix seconds, exclusive */
-    endTimestamp?: number;
-    /** stop after this many events */
-    limit?: number;
-    /** return raw `json` without the layout based `parsedJson` shaping (smaller responses) */
-    skipLayout?: boolean;
-    /** return `{ type, timestamp, sender, json }` instead of the bare payload */
-    withMetadata?: boolean;
-    transform?: (item: any) => T;
-}
-/**
- * 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).
- */
-export declare function queryEvents<T = any>(options: QueryEventsOptions<T>): Promise<T[]>;
-export interface GetDynamicFieldObjectOptions extends ChainOptions {
-    parent: string;
-    /** field name value (alias: `id`) */
-    name?: any;
-    id?: any;
-    /** Move type of the name (alias: `idType`), default `0x2::object::ID` */
-    nameType?: string;
-    idType?: string;
-    /** pre-encoded BCS (base64) of the name; overrides `name`. Defaults to `EMPTY_STRUCT_BCS` when no name is given. */
-    nameBcs?: string;
-    skipLayout?: boolean;
-}
-/** One dynamic field (or dynamic object field) of `parent` by name; null when missing */
-export declare function getDynamicFieldObject({ chain, parent, name, id, nameType, idType, nameBcs, skipLayout }: GetDynamicFieldObjectOptions): Promise<SuiObject | null>;
-export interface DynamicFieldFilterInput {
-    objectId: string;
-    objectType: string;
-    /** `fields.name` of the value, when present */
-    name?: any;
-    /** the dynamic field key (`name.json`) */
-    key?: any;
-}
-export interface GetDynamicFieldObjectsOptions extends ChainOptions {
-    parent: string;
-    /** resume from this cursor */
-    cursor?: string | null;
-    /** stop after this many objects (all pages by default) */
-    limit?: number;
-    /** page size, max 50 */
-    pageSize?: number;
-    idFilter?: (input: DynamicFieldFilterInput) => any;
-    skipLayout?: boolean;
-    /** ms to wait before each page */
-    sleep?: number;
-    /** receive each page as it arrives; the return value is then empty */
-    onPage?: (items: SuiObject[]) => any;
-}
-/** All dynamic fields of `parent` (Table / Bag / ObjectTable entries), walking every page. Each item carries `name` (the field key). */
-export declare function getDynamicFieldObjects({ chain, parent, cursor, limit, pageSize, idFilter, skipLayout, sleep: sleepTime, onPage }: GetDynamicFieldObjectsOptions): Promise<SuiObject[]>;
-export interface CoinTypeOptions extends ChainOptions {
-    coinType: string;
-}
-export interface CoinMetadata {
-    decimals: number;
-    symbol: string;
-    name: string;
-    description?: string;
-    iconUrl?: string;
-    /** total supply in base units, when the endpoint knows it */
-    supply?: string;
-}
-/** `coinMetadata` (GraphQL) or `<prefix>x_getCoinMetadata` + `<prefix>x_getTotalSupply` (JSON-RPC) */
-export declare function getCoinMetadata({ chain, coinType }: CoinTypeOptions): Promise<CoinMetadata>;
-export interface TokenSupply {
-    /** base units */
-    supply: string;
-    decimals: number;
-    /** supply / 10 ** decimals */
-    normalized: number;
-}
-export declare function getTokenSupply({ chain, coinType }: CoinTypeOptions): Promise<TokenSupply>;
-export interface OwnerOptions extends ChainOptions {
-    owner: string;
-}
-export interface CoinBalance {
-    /** zero padded coin type as returned by GraphQL */
-    coinType: string;
-    totalBalance: string;
-}
-/** Every coin balance of `owner`, walking all pages */
-export declare function getAllBalances({ chain, owner }: OwnerOptions): Promise<CoinBalance[]>;
-export interface GetBalanceOptions extends OwnerOptions {
-    coinType: string;
-}
-/** Balance of one coin type for `owner` (base units, '0' when none) */
-export declare function getBalance({ chain, owner, coinType }: GetBalanceOptions): Promise<string>;
-export interface Checkpoint {
-    sequenceNumber: number;
-    /** unix seconds */
-    timestamp: number;
-    digest?: string;
-}
-export interface GetCheckpointOptions extends ChainOptions {
-    sequenceNumber: number | string;
-}
-/** A checkpoint by sequence number; null when the endpoint no longer has it */
-export declare function getCheckpoint({ chain, sequenceNumber }: GetCheckpointOptions): Promise<Checkpoint | null>;
-export declare function getLatestCheckpoint({ chain }?: ChainOptions): Promise<Checkpoint>;
-export interface GetCheckpointAtTimestampOptions extends ChainOptions {
-    /** unix seconds */
-    timestamp: number;
-}
-/** Last checkpoint with `timestamp <= target` (binary search over sequence numbers, ~30 requests) */
-export declare function getCheckpointAtTimestamp({ chain, timestamp }: GetCheckpointAtTimestampOptions): Promise<Checkpoint>;
-export interface DevInspectOptions extends ChainOptions {
-    /** BCS `TransactionKind` bytes, e.g. from `buildProgrammableMoveCallBytes` */
-    txBytes: Bytes;
-    sender?: string;
-}
-export interface DevInspectResult {
-    /** per command: `[bcsBytes, typeRepr]` per return value */
-    results: {
-        returnValues: [number[], string | undefined][];
-    }[];
-    effects: any;
-}
-/** Simulate a transaction kind and return the BCS return values of every command (GraphQL `simulateTransaction`, JSON-RPC `devInspectTransactionBlock`) */
-export declare function devInspectTransactionBlock({ chain, txBytes, sender }: DevInspectOptions): Promise<DevInspectResult>;
-export interface GetInitialSharedVersionOptions extends ChainOptions {
-    objectId: string;
-}
-/** `initialSharedVersion` of a shared object (needed to reference it as a transaction input) */
-export declare function getInitialSharedVersion({ chain, objectId }: GetInitialSharedVersionOptions): Promise<number>;
-export interface ViewFunctionOptions extends ChainOptions, Omit<MoveCallParams, 'sharedObjects'> {
-    /** shared object ids (or refs); `initialSharedVersion` is looked up when missing */
-    sharedObjects?: (string | SharedObjectRef)[];
-    sender?: string;
-}
-/** Build a single MoveCall over shared objects, simulate it and return `[bcsBytes, typeRepr]` per return value */
-export declare function callViewFunction({ chain, sharedObjects, sender, ...moveCall }: ViewFunctionOptions): Promise<[number[], string | undefined][]>;
-export { sliceIntoChunks };