suidouble 2.5.0 → 2.16.0

package/types/lib/SuiMaster.d.ts

@@ -0,0 +1,333 @@
+/**
+ * @import { SuiClientTypes } from "@mysten/sui/client"
+ *
+ * @typedef {import("@mysten/sui/grpc").SuiGrpcClient} SuiGrpcClient
+ * @typedef {import("@mysten/sui/graphql").SuiGraphQLClient} SuiGraphQLClient
+ * @typedef {import("@mysten/sui/cryptography").Signer} SuiSigner
+ * @typedef {import("@mysten/sui/cryptography").Keypair} SuiKeypair
+ * @typedef {import("./SuiInBrowser.js").default} SuiInBrowser
+ */
+declare class SuiMaster extends SuiCommonMethods {
+    static instancesCount: number;
+    /**
+     * gRPC `ListOwnedObjects.objectType` only accepts a full struct type. A bare package address or
+     * `package::module` string needs the GraphQL path.
+     * @param {?string} type
+     * @returns {boolean}
+     */
+    static _typeNeedsGraphqlOwned(type: string | null): boolean;
+    /**
+     * SuiMaster constructor
+     * @param {Object} params - Initialization parameters
+     * @param {SuiSigner|SuiInBrowser} [params.signer] - instance of Sui SDK Signer (like Keypair) or SuiInBrowser for browser wallet signing
+     * @param {SuiKeypair} [params.keypair] - instance of Sui SDK Keypair
+     * @param {string} [params.privateKey] - private key in Sui format, starting with "suiprivkey1"
+     * @param {boolean} [params.debug] - enable debug mode
+     * @param {string} [params.phrase] - mnemonic phrase to derive keypair from
+     * @param {string} [params.keypairAlgo] - keypair algorithm to use with mnemonic phrase. One of 'ed25519' (default), 'secp256k1', 'secp256r1'
+     * @param {number} [params.accountIndex] - index of account to derive from mnemonic phrase. Default is 0
+     * @param {string} [params.as] - pseudo-random address generation seed string
+     * @param {SuiGrpcClient|string} [params.client] - instance of SuiGrpcClient or chain name to make SuiGrpcClient connected to it (like 'local', 'devnet', 'testnet', 'mainnet')
+     */
+    constructor(params: {
+        signer?: SuiSigner | SuiInBrowser;
+        keypair?: SuiKeypair;
+        privateKey?: string;
+        debug?: boolean;
+        phrase?: string;
+        keypairAlgo?: string;
+        accountIndex?: number;
+        as?: string;
+        client?: SuiGrpcClient | string;
+    });
+    _instanceN: number;
+    /** @type {SuiSigner|SuiInBrowser|null} */
+    _signer: SuiSigner | SuiInBrowser | null;
+    /** @type {SuiKeypair} */
+    _keypair: SuiKeypair;
+    /** @type {string} */
+    _address: string;
+    /** @type {SuiGrpcClient} */
+    _client: SuiGrpcClient;
+    /**
+     * Lazy — do not read directly, use the `graphqlClient` getter so it's built on first access.
+     * @type {?SuiGraphQLClient}
+     */
+    _graphqlClient: SuiGraphQLClient | null;
+    /** @type {string} */
+    _providerName: string;
+    /** @type {SuiMemoryObjectStorage} */
+    _objectStorage: SuiMemoryObjectStorage;
+    /** @type {boolean} */
+    _initialized: boolean;
+    /** @type {Object.<string, SuiPackage>} */
+    _packages: {
+        [x: string]: SuiPackage;
+    };
+    /** @type {SuiCoins} */
+    _suiCoins: SuiCoins;
+    /** @returns {typeof SuiUtils} static SuiUtils helper class */
+    get utils(): typeof SuiUtils;
+    /**
+     * Instance of SuiCoins class connected to this SuiMaster
+     *
+     * @type {SuiCoins}
+     */
+    get suiCoins(): SuiCoins;
+    /** @returns {bigint} `1_000_000_000n` — number of MIST per SUI */
+    get MIST_PER_SUI(): bigint;
+    /** @returns {typeof Transaction} SDK `Transaction` class, exposed to avoid extra imports at call sites */
+    get Transaction(): typeof Transaction;
+    /** @returns {typeof Commands} SDK `TransactionCommands` class, exposed to avoid extra imports at call sites */
+    get Commands(): typeof Commands;
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiObject contructor if you have instance of SuiMaster
+     */
+    get SuiObject(): typeof SuiObject;
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiTransaction contructor if you have instance of SuiMaster
+     */
+    get SuiTransaction(): typeof SuiTransaction;
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiEvent contructor if you have instance of SuiMaster
+     */
+    get SuiEvent(): typeof SuiEvent;
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiPaginatedResponse contructor if you have instance of SuiMaster
+     */
+    get SuiPaginatedResponse(): typeof SuiPaginatedResponse;
+    /**
+     * Storage storing all objects interacted by this suiMaster
+     *
+     * @type {SuiMemoryObjectStorage}
+     */
+    get objectStorage(): SuiMemoryObjectStorage;
+    /** @returns {number} monotonically increasing instance counter, useful for differentiating logs */
+    get instanceN(): number;
+    /** @returns {SuiGrpcClient} gRPC client for the connected chain */
+    get client(): SuiGrpcClient;
+    /**
+     * Lazily-built SuiGraphQLClient that reuses the network of this suiMaster's gRPC client.
+     * @returns {SuiGraphQLClient}
+     */
+    get graphqlClient(): SuiGraphQLClient;
+    /** @returns {string} connected chain identifier, e.g. `'mainnet'` or `'localnet'` */
+    get connectedChain(): string;
+    /**
+     * determine if this suiMaster is connected to mainnet or not
+     * @returns {boolean} is on mainnet
+     */
+    get onMainnet(): boolean;
+    /** @returns {?string} connected Sui address, or null in read-only mode before `initialize()` */
+    get address(): string | null;
+    /** @returns {SuiSigner|SuiInBrowser|null} active signer/keypair, or null in read-only mode */
+    get signer(): SuiSigner | SuiInBrowser | null;
+    /**
+     * Attach a smart contract package to this SuiMaster instance.
+     *
+     * @param {Object} params - Configuration parameters
+     * @param {?string} [params.path] - Local filesystem path to the Move package source code
+     * @param {?string} [params.id] - ID or address of the Move package on the Sui blockchain
+     * @param {?Array.<string>|string} [params.modules] - List of modules in the package to look on chain in the UpgradeCap owned by current address
+     *
+     * @returns {SuiPackage}
+     */
+    package(params?: {
+        path?: string | null;
+        id?: string | null;
+        modules?: (Array<string> | string) | null;
+    }): SuiPackage;
+    /**
+     * Attach a smart contract package to this SuiMaster instance.
+     *
+     * @param {Object} params - Configuration parameters
+     * @param {?string} [params.path] - Local filesystem path to the Move package source code
+     * @param {?string} [params.id] - ID or address of the Move package on the Sui blockchain
+     * @param {?Array.<string>|string} [params.modules] - List of modules in the package to look on chain in the UpgradeCap owned by current address
+     *
+     * @returns {SuiPackage}
+     */
+    addPackage(params: {
+        path?: string | null;
+        id?: string | null;
+        modules?: (Array<string> | string) | null;
+    }): SuiPackage;
+    /**
+     * Ensure `initialize()` has run, then return the gRPC client.
+     * @returns {Promise<SuiGrpcClient>}
+     */
+    getClient(): Promise<SuiGrpcClient>;
+    /**
+     * Resolve the connected address from the signer/keypair (if any) and mark the instance as
+     * ready. Idempotent — subsequent calls return immediately.
+     * @returns {Promise<boolean>}
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * Return the primary Name Service name for the connected wallet address, or null if none.
+     * Uses `client.core.defaultNameServiceName` (v2 gRPC).
+     * @returns {Promise<string | null>}
+     */
+    defaultNameServiceName(): Promise<string | null>;
+    /**
+     * Fetch many on-chain objects. The v2 client batches internally (50 per request).
+     *
+     * Per-item behavior:
+     *   - if a `SuiObject` is passed in, it is updated in place via `replaceWithSuiObjectIfNeeded`
+     *     and returned at its original index in the output array (same instance reference).
+     *   - if a string id is passed in, a freshly-constructed `SuiObject` is returned at that index.
+     *   - if an item couldn't be matched in the response, the original (or a new bare) SuiObject is
+     *     still placed at that index — no nulls, no skipped slots.
+     *
+     * Errors-in-results entries from the client are skipped silently. Returns `[]` for empty input.
+     *
+     * @param {Array<string | SuiObject>} idsOrSuiObjects - mix of object ids and/or SuiObject instances
+     * @param {SuiClientTypes.ObjectInclude} [include] - fields to include; defaults to content/json/display
+     * @returns {Promise<SuiObject[]>} array aligned with input order
+     */
+    getObjects(idsOrSuiObjects: Array<string | SuiObject>, include?: SuiClientTypes.ObjectInclude): Promise<SuiObject[]>;
+    /**
+     * Fetch a single on-chain object and return it wrapped in a SuiObject.
+     *
+     * @param {string | SuiObject} idOrSuiObject - object id, or a SuiObject instance whose `.address` will be used
+     * @param {SuiClientTypes.ObjectInclude} [include] - fields to include; defaults to content/json/display
+     * @returns {Promise<?SuiObject>} SuiObject populated from the api, or null if not found
+     */
+    getObject(idOrSuiObject: string | SuiObject, include?: SuiClientTypes.ObjectInclude): Promise<SuiObject | null>;
+    /**
+     * List objects owned by an address. Picks the right backend based on `input.type`:
+     *
+     *   - no type / full struct type (`pkg::mod::Struct[<...>]`) → gRPC `listOwnedObjects` (fast path)
+     *   - package (`pkg`) or module (`pkg::mod`) filter → GraphQL `address.objects` (gRPC can't parse those)
+     *
+     * @param {SuiClientTypes.ListOwnedObjectsOptions<SuiClientTypes.ObjectInclude>} input
+     * @param {Object} [extra]
+     * @param {string} [extra.order]
+     * @returns {Promise<SuiPaginatedResponse<SuiObject>>}
+     */
+    getOwnedObjects(input: SuiClientTypes.ListOwnedObjectsOptions<SuiClientTypes.ObjectInclude>, extra?: {
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiObject>>;
+    /**
+     * Sign and execute a transaction on the Sui blockchain.
+     * Uses the connected keypair or signer or browser extension wallet adapter to sign the transaction before submitting it.
+     *
+     * Throws on two failure paths, both with a normalised `executionError` + `digest` shape:
+     *
+     *  1. **`SimulationError`** (SDK, pre-submission) — thrown during `tx.build()` / gas selection
+     *     when the SDK simulates the transaction and detects an abort before even submitting.
+     *     `executionError` is set by the SDK; `digest` is `null` (no submission happened).
+     *
+     *  2. **`FailedTransaction`** (on-chain) — the transaction was submitted and executed but aborted.
+     *     Both `executionError` and `digest` are set.
+     *
+     * In both cases the error has:
+     *   - `message` — human-readable failure reason
+     *   - `executionError` — `SuiClientTypes.ExecutionError`:
+     *       `{ message, command?, MoveAbort?, SizeError?, CommandArgumentError?, TypeArgumentError?, ... }`
+     *   - `digest` — transaction digest, or `null` for pre-submission failures
+     *
+     * @param {{ transaction: Transaction, include?: SuiClientTypes.TransactionInclude, requestType?: string }} params
+     * @returns {Promise<SuiTransaction>}
+     * @throws {Error & { executionError: SuiClientTypes.ExecutionError, digest: ?string }} if the transaction fails on-chain
+     */
+    signAndExecuteTransaction(params: {
+        transaction: Transaction;
+        include?: SuiClientTypes.TransactionInclude;
+        requestType?: string;
+    }): Promise<SuiTransaction>;
+    /**
+     * Request SUI tokens from the faucet for the connected address.
+     * Only works on localnet, devnet, and testnet.
+     * @returns {Promise<bigint>} total MIST received across all coin objects
+     */
+    requestSuiFromFaucet(): Promise<bigint>;
+    /**
+     * Query the balance of specific coinType for an owner. If owner == null, returns balance of connected address owner
+     *
+     * @param {string} [coinType='0x2::sui::SUI']
+     * @param {?string} [owner] - defaults to the connected address
+     * @returns {Promise<bigint>}
+     */
+    getBalance(coinType?: string, owner?: string | null): Promise<bigint>;
+    /**
+     * Fetch events via the GraphQL `events` query. Lowest-level entry point —
+     * `SuiPackage.fetchEvents` and `SuiPackageModule.fetchEvents` both delegate here.
+     *
+     * The filter is a GraphQL `EventFilter`:
+     *   - `module` : "<package>" or "<package>::<module>"
+     *   - `type`   : "<package>::<module>::<EventName>" (or a prefix thereof)
+     *   - `sender` : SuiAddress
+     *   - `atCheckpoint` / `afterCheckpoint` / `beforeCheckpoint` : UInt53
+     *
+     * @param {Object} [params]
+     * @param {Object} [params.filter] - GraphQL EventFilter
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order] - Passed through to the underlying paginated response
+     * @returns {Promise<SuiPaginatedResponse<SuiEvent>>}
+     */
+    fetchEvents(params?: {
+        filter?: any;
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiEvent>>;
+    /**
+     * Fetch transactions via the GraphQL root `transactions(filter: TransactionFilter)` query.
+     *
+     * Accepts either a direct `params.filter` (GraphQL `TransactionFilter` shape) or the legacy
+     * convenience fields (`fromAddress`, `affectedAddress`, `affectedObject`, `function`, `atCheckpoint`,
+     * `afterCheckpoint`, `beforeCheckpoint`, `kind`) which get translated to the corresponding
+     * `TransactionFilter` fields.
+     *
+     * @param {Object} [params]
+     * @param {Object} [params.filter] - raw TransactionFilter; overrides the convenience fields if set
+     * @param {?string} [params.fromAddress]
+     * @param {?string} [params.affectedAddress]
+     * @param {?string} [params.affectedObject]
+     * @param {?string} [params.function]
+     * @param {?number} [params.atCheckpoint]
+     * @param {?number} [params.afterCheckpoint]
+     * @param {?number} [params.beforeCheckpoint]
+     * @param {?string} [params.kind]
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order]
+     * @returns {Promise<SuiPaginatedResponse<SuiTransaction>>}
+     */
+    fetchTransactions(params?: {
+        filter?: any;
+        fromAddress?: string | null;
+        affectedAddress?: string | null;
+        affectedObject?: string | null;
+        function?: string | null;
+        atCheckpoint?: number | null;
+        afterCheckpoint?: number | null;
+        beforeCheckpoint?: number | null;
+        kind?: string | null;
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiTransaction>>;
+}
+declare namespace SuiMaster {
+    export let MIST_PER_SUI: bigint;
+    export { Transaction };
+    export { Commands };
+    export { SuiUtils };
+}
+export default SuiMaster;
+export type SuiGrpcClient = import("@mysten/sui/grpc").SuiGrpcClient;
+export type SuiGraphQLClient = import("@mysten/sui/graphql").SuiGraphQLClient;
+export type SuiSigner = import("@mysten/sui/cryptography").Signer;
+export type SuiKeypair = import("@mysten/sui/cryptography").Keypair;
+export type SuiInBrowser = import("./SuiInBrowser.js").default;
+import SuiCommonMethods from './SuiCommonMethods.js';
+import SuiMemoryObjectStorage from './SuiMemoryObjectStorage.js';
+import SuiPackage from './SuiPackage.js';
+import SuiCoins from './SuiCoins.js';
+import SuiUtils from './SuiUtils.js';
+import { Transaction } from '@mysten/sui/transactions';
+import { TransactionCommands as Commands } from '@mysten/sui/transactions';
+import SuiObject from './SuiObject.js';
+import SuiTransaction from './SuiTransaction.js';
+import SuiEvent from './SuiEvent.js';
+import SuiPaginatedResponse from './SuiPaginatedResponse.js';
+import type { SuiClientTypes } from "@mysten/sui/client";

package/types/lib/SuiMemoryObjectStorage.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @typedef {import("./SuiMaster.js").default} SuiMaster
+ */
+/**
+ * In-memory registry of `SuiObject` instances keyed by normalized address. One instance is
+ * created per connected chain (see `instanceOf`). Used by `SuiPackageModule` and friends to
+ * deduplicate object references across moveCall results and queries.
+ *
+ * Sample usage:
+ * ```
+ * suiMemoryObjectStorage.push(id);
+ * suiMemoryObjectStorage.push(suiObject);
+ * await suiMemoryObjectStorage.fetchObjects();
+ * suiMemoryObjectStorage.byAddress(id);
+ * ```
+ */
+export default class SuiMemoryObjectStorage extends SuiCommonMethods {
+    static _instances: {};
+    /**
+     * Return (and lazily create) a shared SuiMemoryObjectStorage keyed by `validatorId`.
+     * Typically `validatorId` is the connected chain name (`sui:mainnet`, `sui:localnet`, …) so that
+     * objects from different chains stay isolated.
+     *
+     * @param {string} validatorId - identifier for the singleton slot (chain name by convention)
+     * @param {Object} params - Initialization parameters used only on first creation for that slot
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @param {boolean} [params.debug]
+     * @returns {SuiMemoryObjectStorage}
+     */
+    static instanceOf(validatorId: string, params: {
+        suiMaster: SuiMaster;
+        debug?: boolean;
+    }): SuiMemoryObjectStorage;
+    /**
+     * SuiMemoryObjectStorage constructor
+     * @param {Object} params - Initialization parameters
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @param {boolean} [params.debug]
+     */
+    constructor(params: {
+        suiMaster: SuiMaster;
+        debug?: boolean;
+    });
+    /** @type {SuiMaster} */
+    _suiMaster: SuiMaster;
+    /** @type {Object.<string, SuiObject>} */
+    _objects: {
+        [x: string]: SuiObject;
+    };
+    /** @returns {SuiObject[]} all stored SuiObjects, in insertion order */
+    asArray(): SuiObject[];
+    /**
+     * Find the most-recently-pushed object whose `typeName` (short type name, e.g. "ChatTopMessage")
+     * matches `typeName`. Ordering is by each object's `constructedAt` timestamp.
+     *
+     * @param {string} typeName
+     * @returns {?SuiObject}
+     */
+    findMostRecentByTypeName(typeName: string): SuiObject | null;
+    /**
+     * Return the first stored object for which `filterFunction` returns truthy.
+     * @param {(obj: SuiObject) => boolean} filterFunction
+     * @returns {?SuiObject}
+     */
+    find(filterFunction: (obj: SuiObject) => boolean): SuiObject | null;
+    /**
+     * Return the most-recently-constructed object (by `constructedAt`) that matches `filterFunction`.
+     * @param {(obj: SuiObject) => boolean} filterFunction
+     * @returns {?SuiObject}
+     */
+    findMostRecent(filterFunction: (obj: SuiObject) => boolean): SuiObject | null;
+    /**
+     * Store a SuiObject, or wrap a raw `0x…` id in a new SuiObject and store it.
+     * If an object with the same address is already stored, it is returned as-is (no replacement).
+     *
+     * @param {SuiObject | string} suiObjectOrId - a SuiObject instance, or a `0x…` id string
+     * @returns {?SuiObject} the stored instance, or null if input didn't look like either
+     */
+    push(suiObjectOrId: SuiObject | string): SuiObject | null;
+    /**
+     * Lookup by address. The address must already be in its normalized form (as produced by SuiObject).
+     * @param {string} address
+     * @returns {?SuiObject}
+     */
+    byAddress(address: string): SuiObject | null;
+    /**
+     * Refresh every non-deleted stored SuiObject's fields from chain.
+     * Delegates to `SuiMaster.getObjects(...)` which mutates the passed-in instances in place.
+     *
+     * @returns {Promise<SuiObject[]>}
+     */
+    fetchObjects(): Promise<SuiObject[]>;
+}
+export type SuiMaster = import("./SuiMaster.js").default;
+import SuiCommonMethods from './SuiCommonMethods.js';
+import SuiObject from './SuiObject.js';

package/types/lib/SuiObject.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @import { SuiClientTypes } from "@mysten/sui/client"
+ */
+/**
+ * @typedef {import("./SuiMaster.js").default} SuiMaster
+ */
+export default class SuiObject extends SuiCommonMethods {
+    /**
+     * Compare two Sui object IDs after normalisation.
+     * @param {string} id1
+     * @param {string} id2
+     * @returns {boolean}
+     */
+    static idsEqual(id1: string, id2: string): boolean;
+    /**
+     * Sui Object representation
+     *
+     * @param {Object} params - parameters
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @param {SuiClientTypes.Object} [params.raw] - raw data from api
+     * @param {?string} [params.id] - ID or address on the sui blockchain
+     * @param {string|number} [params.version] - object version
+     * @param {?string} [params.type] - fully-qualified Move type string
+     * @param {boolean} [params.debug]
+     */
+    constructor(params: {
+        suiMaster: SuiMaster;
+        raw?: SuiClientTypes.Object;
+        id?: string | null;
+        version?: string | number;
+        type?: string | null;
+        debug?: boolean;
+    });
+    /** @type {SuiMaster} */
+    _suiMaster: SuiMaster;
+    /** @type {?string} */
+    _id: string | null;
+    /** @type {?number} */
+    _version: number | null;
+    /** @type {?string} */
+    _type: string | null;
+    _fields: {};
+    _display: {};
+    _owner: any;
+    _localProperties: {};
+    _isDeleted: boolean;
+    _constructedAt: Date;
+    /**
+     * Fill local properties from raw SuiClientTypes.Object api response
+     * @param {SuiClientTypes.Object} raw
+     */
+    fillDataFromApi(raw: SuiClientTypes.Object): void;
+    /** @returns {Date} timestamp when this JS object was instantiated (useful for sorting by recency) */
+    get constructedAt(): Date;
+    /** @returns {boolean} true if this object has been marked deleted */
+    get isDeleted(): boolean;
+    /** @returns {boolean} true if the object is shared (owned by the network) */
+    get isShared(): boolean;
+    /** @returns {boolean} true if the object is immutable (frozen) */
+    get isImmutable(): boolean;
+    /**
+     * Check whether this object is address-owned by the given address or SuiObject.
+     * @param {string | SuiObject} addressOrSuiObject
+     * @returns {boolean}
+     */
+    isOwnedBy(addressOrSuiObject: string | SuiObject): boolean;
+    /** Mark this object as deleted on-chain and set `isDeleted` to true. */
+    markAsDeleted(): void;
+    /** @returns {?string} raw object id as stored (not normalised) */
+    get id(): string | null;
+    /** @returns {?string} fully-qualified Move type string, e.g. `'0x2::coin::Coin<0x2::sui::SUI>'` */
+    get type(): string | null;
+    /**
+     * Short type name — last `::` segment without `<T…>` suffix.
+     * @returns {?string} e.g. `'ChatTopMessage'`
+     */
+    get typeName(): string | null;
+    /**
+     * Check whether this object's normalised address equals `toId`.
+     * @param {string} toId
+     * @returns {boolean}
+     */
+    idEquals(toId: string): boolean;
+    /**
+     * Normalised 0x-padded Sui address, or null if the id is invalid.
+     * @returns {?string}
+     */
+    get address(): string | null;
+    /** @returns {Object} on-chain Move struct fields (populated by `fillDataFromApi` or `fetchFields`) */
+    get fields(): any;
+    /** @returns {Object} Display template rendered output (populated by `fillDataFromApi` or `fetchFields`) */
+    get display(): any;
+    /** @returns {Object} local-only property bag — never sent to chain, for caller convenience */
+    get localProperties(): any;
+    /** @returns {?number} object version (lamport timestamp), or null before `fetchFields` */
+    get version(): number | null;
+    /**
+     * Fetch transactions that interacted with this object, via GraphQL.
+     *
+     * @param {Object} [params]
+     * @param {number} [params.limit=10]
+     * @param {string} [params.order]
+     * @returns {Promise<SuiPaginatedResponse>}
+     */
+    fetchTransactions(params?: {
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<any>>;
+    /**
+     * Fetch dynamic fields owned by this object, paginated.
+     * @param {Object} [params]
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order]
+     * @returns {Promise<SuiPaginatedResponse>}
+     */
+    getDynamicFields(params?: {
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<any>>;
+    /**
+     * Fetch full field data for this object from chain and merge via `replaceWithSuiObjectIfNeeded`.
+     * Populates `fields`, `display`, `type`, and `version` if not already filled.
+     * @returns {Promise<this>}
+     */
+    fetchFields(): Promise<this>;
+    /**
+     * Replace data with another suiObject data if it's version is newer compared to this one
+     * @param {SuiObject} suiObject
+     */
+    replaceWithSuiObjectIfNeeded(suiObject: SuiObject): boolean;
+}
+export type SuiMaster = import("./SuiMaster.js").default;
+import SuiCommonMethods from './SuiCommonMethods.js';
+import type { SuiClientTypes } from "@mysten/sui/client";
+import SuiPaginatedResponse from './SuiPaginatedResponse.js';