suidouble 2.5.0 → 2.17.0-1

package/types/lib/SuiPackage.d.ts

@@ -0,0 +1,233 @@
+/**
+ * @typedef {import("./SuiMaster.js").default} SuiMaster
+ * @typedef {import("./SuiTransaction.js").default} SuiTransaction
+ * @typedef {import("./SuiEvent.js").default} SuiEvent
+ * @typedef {import("./SuiMemoryObjectStorage.js").default} SuiMemoryObjectStorage
+ * @typedef {import("@mysten/sui/transactions").Inputs} Inputs
+ */
+export default class SuiPackage extends SuiObject {
+    /**
+     * Smart Contract Package on Sui blockchain
+     *
+     * @param {Object} params - Configuration parameters
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @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
+     * @param {boolean} [params.debug] - Enable debug mode
+     */
+    constructor(params: {
+        suiMaster: SuiMaster;
+        path?: string | null;
+        id?: string | null;
+        modules?: (Array<string> | string) | null;
+        debug?: boolean;
+    });
+    /** @type {?string} */
+    _path: string | null;
+    /** @type {?Array.<string>|string} */
+    _expectedModules: (Array<string> | string) | null;
+    _isPublished: boolean;
+    _publishedVersion: number;
+    _upgradeCap: SuiObject;
+    _upgradeCapId: string;
+    _isBuilt: boolean;
+    _builtModules: any;
+    _builtDependencies: any;
+    _builtDigest: any;
+    /**
+     * Cached original package id (first published version). Stable across upgrades.
+     * Lazy — do not read directly, use `getOriginalPackageId()`.
+     * @type {?string}
+     */
+    _originalPackageId: string | null;
+    /** @type {Object.<string, SuiPackageModule>} */
+    _modules: {
+        [x: string]: SuiPackageModule;
+    };
+    /** @returns {SuiMemoryObjectStorage} shared object storage for this suiMaster */
+    get objectStorage(): SuiMemoryObjectStorage;
+    /** @returns {Object.<string, SuiPackageModule>} map of module name → SuiPackageModule */
+    get modules(): {
+        [x: string]: SuiPackageModule;
+    };
+    /**
+     * Ensure the package is on chain, then return the named module.
+     * @param {string} moduleName
+     * @returns {Promise<SuiPackageModule|undefined>}
+     */
+    getModule(moduleName: string): Promise<SuiPackageModule | undefined>;
+    /** @returns {boolean} true if the local Move project has been built via `build()` */
+    get isBuilt(): boolean;
+    /**
+     * Returns true if this package is confirmed published on chain.
+     * Swallows `checkOnChainIfNeeded` errors so it always resolves.
+     * @returns {Promise<boolean>}
+     */
+    isOnChain(): Promise<boolean>;
+    /**
+     * Shortcut for `suiMaster.utils.pureInput(type, value)` — build a BCS-serialised Pure input
+     * to use as a moveCall parameter.
+     * @param {string} type - BCS type name, e.g. `'u64'`, `'address'`, `'string'`
+     * @param {*} value
+     * @returns {ReturnType<Inputs['Pure']>}
+     */
+    arg(type: string, value: any): ReturnType<Inputs["Pure"]>;
+    /**
+     * Convenience wrapper — delegates to `this.modules[moduleName].moveCall(...)`.
+     * @param {string} moduleName
+     * @param {string} methodName
+     * @param {Array} params - see `SuiPackageModule.moveCall` for element shapes
+     * @param {string[]} [typeArguments]
+     * @returns {Promise<SuiTransaction>}
+     */
+    moveCall(moduleName: string, methodName: string, params: any[], typeArguments?: string[]): Promise<SuiTransaction>;
+    /**
+     * Fetch all events emitted by any module of this package, via the GraphQL `events` query.
+     * Uses the original (first-version) package id so the filter stays stable across upgrades.
+     * For module-scoped or event-type-scoped queries use `this.modules[name].fetchEvents(...)`.
+     *
+     * @param {Object} [params]
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order] - Passed through to the underlying paginated response
+     * @returns {Promise<SuiPaginatedResponse<SuiEvent>>}
+     */
+    fetchEvents(params?: {
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiEvent>>;
+    /**
+     * List objects of any type belonging to this package owned by the current SuiMaster address.
+     * Uses the original (first-version) package id and GraphQL (gRPC can't filter by package alone).
+     *
+     * For module-scoped or full-struct-type filtering use `this.modules[name].getOwnedObjects(...)`.
+     *
+     * @param {Object} [params]
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order]
+     * @returns {Promise<SuiPaginatedResponse<SuiObject>>}
+     */
+    getOwnedObjects(params?: {
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiObject>>;
+    /**
+     * Get the original (first-version) package id, stable across upgrades.
+     * Caches the value on first fetch.
+     *
+     * @returns {Promise<string>}
+     */
+    getOriginalPackageId(): Promise<string>;
+    checkOnChainIfNeeded(): Promise<boolean>;
+    /**
+     * Try to find package on chain using its modules names.
+     * Search for packages you own, in last versions of it
+     * List all UpgradeCap -> List packages -> Filter ( max version, all modules )
+     *
+     * @returns {Promise<?string>} id of the highest-version package that contains all expected modules, or null if none matched
+     */
+    tryToFindByExpectedModules(): Promise<string | null>;
+    /**
+     * Get published package version
+     *
+     * @param {Object} [options]
+     * @param {number} [options.timeout=10000] - total time in ms to keep polling if package is not found
+     *
+     * @returns {Promise<?number>} on-chain package version, or null if it could not be read before the timeout
+     */
+    getVersionOnChain(options?: {
+        timeout?: number;
+    }): Promise<number | null>;
+    /**
+     * Attach module to this package and add event listeners over it
+     *
+     * @param {string} moduleName
+     * @returns {boolean} true if the module was newly attached, false if it was already attached
+     */
+    attachModule(moduleName: string): boolean;
+    /**
+     * UpgradeCap is capability object required to publish updates for a package.
+     * We are trying to find it in owned objects with this function
+     *
+     * @returns {Promise<?string>} id of UpgradeCap for this package, or null if none is owned by the current address
+     */
+    getUpgradeCapId(): Promise<string | null>;
+    /**
+     * Read the result of a publish/upgrade transaction and update local package state:
+     * sets `_id`, `_publishedVersion`, `_isPublished` from the created `package` object,
+     * records `_upgradeCapId` from the created `UpgradeCap`, and refreshes on-chain version.
+     *
+     * @param {SuiTransaction} result - transaction result returned from publish()/upgrade()
+     * @returns {Promise<boolean>} true if the package is now marked as published
+     */
+    storeInfoFromPublishResult(result: SuiTransaction): Promise<boolean>;
+    /**
+     * Publish the Move package to the chain for the first time.
+     *
+     * Flow:
+     *  - build the local Move project if it has not been built yet
+     *  - throw if the package already has an on-chain address (use upgrade() instead)
+     *  - submit a publish transaction and transfer the returned UpgradeCap to the current address
+     *  - refresh local publish info from the result
+     *
+     * @param {Object} [params] - Configuration parameters
+     * @param {?string} [params.env] - Sui CLI env to switch to before building (forwarded to build())
+     * @returns {Promise<?string>} the on-chain package id, or null if publish info could not be read
+     * @throws if the package is already published
+     */
+    publish(params?: {
+        env?: string | null;
+    }): Promise<string | null>;
+    /**
+     * Upgrade an on-chain package to a newer version from local Move sources.
+     *
+     * Flow:
+     *  - ensure the package is known on chain (checkOnChainIfNeeded)
+     *  - build the local Move project if it has not been built yet
+     *  - authorize the upgrade using the owned UpgradeCap (COMPATIBLE policy)
+     *  - execute the upgrade transaction and commit it
+     *  - refresh local publish info from the result
+     *
+     * Requires an UpgradeCap owned by the current address.
+     *
+     * @param {Object} [params] - Configuration parameters
+     * @param {?string} [params.env] - Sui CLI env to switch to before building (forwarded to build())
+     * @returns {Promise<boolean>} true on successful upgrade (version incremented), false otherwise
+     */
+    upgrade(params?: {
+        env?: string | null;
+    }): Promise<boolean>;
+    /**
+     * Build the local Move project by invoking `sui move build --dump-bytecode-as-base64`
+     * and cache the resulting modules, dependencies and digest on the instance
+     * (`_builtModules`, `_builtDependencies`, `_builtDigest`). Sets `_isBuilt = true`.
+     *
+     * Must have a local source `path` set on the package — throws otherwise.
+     *
+     * @param {Object} [params] - Configuration parameters
+     * @param {?string} [params.env] - If set, runs `sui client switch --env <env>` before building
+     * @param {?boolean} [params.withUnpublishedDependencies] - Pass `--with-unpublished-dependencies` to the build command
+     * @returns {Promise<boolean>} true on success
+     * @throws if no local path is set
+     */
+    build(params?: {
+        env?: string | null;
+        withUnpublishedDependencies?: boolean | null;
+    }): Promise<boolean>;
+    /**
+     * Read the local `build/<pkg>/bytecode_modules` directory and return the list of compiled module names.
+     * Requires the package to have been built already (via `sui move build` or this instance's `build()`).
+     *
+     * @returns {Promise<string[]>} list of module names (without the `.mv` suffix)
+     * @throws if the local path is not set or the build directory can not be read
+     */
+    getModulesNamesFromBuild(): Promise<string[]>;
+}
+export type SuiMaster = import("./SuiMaster.js").default;
+export type SuiTransaction = import("./SuiTransaction.js").default;
+export type SuiEvent = import("./SuiEvent.js").default;
+export type SuiMemoryObjectStorage = import("./SuiMemoryObjectStorage.js").default;
+export type Inputs = any;
+import SuiObject from './SuiObject.js';
+import SuiPackageModule from './SuiPackageModule.js';
+import SuiPaginatedResponse from './SuiPaginatedResponse.js';

package/types/lib/SuiPackageModule.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @typedef {import("./SuiTransaction.js").default} SuiTransaction
+ * @typedef {import("./SuiMaster.js").default} SuiMaster
+ * @typedef {import("./SuiPackage.js").default} SuiPackage
+ * @typedef {import("./SuiEvent.js").default} SuiEvent
+ * @typedef {import("./SuiMemoryObjectStorage.js").default} SuiMemoryObjectStorage
+ * @typedef {import("@mysten/sui/transactions").CallArg} CallArg
+ */
+export default class SuiPackageModule extends SuiCommonMethods {
+    /**
+     * SuiPackageModule constructor
+     * @param {Object} params - Initialization parameters
+     * @param {SuiPackage} params.package - instance of SuiPackage this module is part of
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @param {string} params.moduleName - name of the Move module
+     * @param {boolean} [params.debug]
+     */
+    constructor(params: {
+        package: SuiPackage;
+        suiMaster: SuiMaster;
+        moduleName: string;
+        debug?: boolean;
+    });
+    _package: import("./SuiPackage.js").default;
+    _suiMaster: import("./SuiMaster.js").default;
+    _moduleName: string;
+    /**
+     * Shortcut for `suiMaster.utils.pureInput(type, value)` — build a BCS-serialised Pure input
+     * to use as a moveCall parameter.
+     * @param {string} type - BCS type name, e.g. `'u64'`, `'address'`, `'string'`
+     * @param {*} value
+     * @returns {CallArg}
+     */
+    arg(type: string, value: any): CallArg;
+    /** @returns {SuiMemoryObjectStorage} shared object storage for this suiMaster */
+    get objectStorage(): SuiMemoryObjectStorage;
+    /** @returns {Object.<string, SuiObject>} raw map of address → SuiObject */
+    get objects(): {
+        [x: string]: SuiObject;
+    };
+    /** @returns {SuiObject[]} all objects in storage as an array */
+    get objectsArray(): SuiObject[];
+    /**
+     * Add an object to the shared objectStorage by address or SuiObject instance.
+     * If the object is already stored, returns the existing instance.
+     * Emits `'added'` if a new bare SuiObject is created from an id string.
+     *
+     * @param {SuiObject | string} suiObjectOrAddress
+     * @returns {?SuiObject}
+     */
+    pushObject(suiObjectOrAddress: SuiObject | string): SuiObject | null;
+    /**
+     * Execute a Move function on this module.
+     *
+     * Builds a `Transaction` from `params`, signs and executes it, then syncs the local
+     * `objectStorage` with the effects.
+     *
+     * After the call the following events are emitted on this module:
+     *   - `'added'`   — for each created or first-seen-mutated SuiObject (payload: SuiObject)
+     *   - `'created'` — for each chain-created SuiObject (payload: SuiObject)
+     *   - `'deleted'` — for each deleted SuiObject (payload: SuiObject)
+     *
+     * `params` element shapes:
+     *   - `{ type, amount }` — coin argument; converted via `SuiCoin.coinOfAmountToTxCoin`
+     *   - `[{ type, amount }]` — single-element array → `vector<Coin<T>>` via `makeMoveVec`
+     *   - `'0x…'` string → `tx.object(id)`
+     *   - `{ Pure: { bytes } }` → already-serialised Pure input
+     *   - anything else → `tx.pure(value)`
+     *
+     * @param {string} methodName - name of the Move function to call
+     * @param {Array} params - call arguments
+     * @param {string[]} [typeArguments] - Move type parameters, e.g. `['0x2::sui::SUI']`
+     * @returns {Promise<SuiTransaction>}
+     */
+    moveCall(methodName: string, params: any[], typeArguments?: string[]): Promise<SuiTransaction>;
+    /**
+     * Sign and execute a pre-built Transaction, then sync `objectStorage` with the effects and
+     * emit change events on this module.
+     *
+     * Emits per-object events:
+     *   - `'added'`   — created objects not yet in storage, and first-seen mutated objects
+     *   - `'created'` — every chain-created object
+     *   - `'deleted'` — every deleted object
+     *
+     * @param {Transaction} tx
+     * @returns {Promise<SuiTransaction>}
+     */
+    executeTransaction(tx: Transaction): Promise<SuiTransaction>;
+    /**
+     * List objects of this module owned by the current SuiMaster address.
+     * Uses the original (first-version) package id so the filter is stable across upgrades.
+     *
+     * @param {Object} [params]
+     * @param {?string} [params.typeName] - If set, narrows the type filter to `<pkg>::<module>::<typeName>`.
+     *                                      Otherwise filters by `<pkg>::<module>`.
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order]
+     * @returns {Promise<SuiPaginatedResponse<SuiObject>>}
+     */
+    getOwnedObjects(params?: {
+        typeName?: string | null;
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiObject>>;
+    /**
+     * Fetch events emitted by this module, via the GraphQL `events` query.
+     * Uses the original (first-version) package id of the parent SuiPackage so the filter
+     * is stable across upgrades.
+     *
+     * @param {Object} [params]
+     * @param {?string} [params.eventTypeName] - If set, narrows the filter to a single event struct
+     *                                           (`<pkg>::<module>::<EventName>`). Otherwise fetches
+     *                                           all events emitted by any function in this module.
+     * @param {number} [params.limit=50]
+     * @param {string} [params.order] - Passed through to the underlying paginated response
+     * @returns {Promise<SuiPaginatedResponse<SuiEvent>>}
+     */
+    fetchEvents(params?: {
+        eventTypeName?: string | null;
+        limit?: number;
+        order?: string;
+    }): Promise<SuiPaginatedResponse<SuiEvent>>;
+    /**
+     * Refresh all objects in the shared objectStorage from chain.
+     * Delegates to `SuiMemoryObjectStorage.fetchObjects()`.
+     * @returns {Promise<SuiObject[]>}
+     */
+    fetchObjects(): Promise<SuiObject[]>;
+}
+export type SuiTransaction = import("./SuiTransaction.js").default;
+export type SuiMaster = import("./SuiMaster.js").default;
+export type SuiPackage = import("./SuiPackage.js").default;
+export type SuiEvent = import("./SuiEvent.js").default;
+export type SuiMemoryObjectStorage = import("./SuiMemoryObjectStorage.js").default;
+export type CallArg = import("@mysten/sui/transactions").CallArg;
+import SuiCommonMethods from './SuiCommonMethods.js';
+import SuiObject from './SuiObject.js';
+import { Transaction } from '@mysten/sui/transactions';
+import SuiPaginatedResponse from './SuiPaginatedResponse.js';

package/types/lib/SuiPaginatedResponse.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @import { SuiClientTypes } from "@mysten/sui/client"
+ */
+/**
+ * @typedef {import('./SuiObject.js').default} SuiObject
+ * @typedef {import('./SuiMaster.js').default} SuiMaster
+ * @typedef {{ filter?: object, limit?: number }} GraphqlEventsParams
+ * @typedef {{ owner: string, type?: string, limit?: number }} GraphqlOwnedObjectsParams
+ * @typedef {{ filter?: object, limit?: number }} GraphqlTransactionsParams
+ * @typedef {SuiClientTypes.ListOwnedObjectsOptions<SuiClientTypes.ObjectInclude>
+ *              | SuiClientTypes.ListCoinsOptions
+ *              | SuiClientTypes.ListDynamicFieldsOptions
+ *              | GraphqlEventsParams
+ *              | GraphqlOwnedObjectsParams
+ *              | GraphqlTransactionsParams } SuiPaginatedResponseParams
+ */
+/**
+ * @template {SuiObject | SuiTransaction | SuiEvent} T
+ */
+export default class SuiPaginatedResponse<T extends SuiObject | SuiTransaction | SuiEvent> extends SuiCommonMethods {
+    /**
+     * Accept 'asc' | 'ascending' | 'desc' | 'descending' (case-insensitive).
+     * Defaults to 'descending' (newest first).
+     * @param {?string} input
+     * @returns {'ascending' | 'descending'}
+     */
+    static _normalizeOrder(input: string | null): "ascending" | "descending";
+    /**
+     * Map a GraphQL Owner union node to the gRPC-style owner shape SuiObject consumes.
+     */
+    static _normalizeGraphqlOwner(owner: any): "Immutable" | {
+        AddressOwner: any;
+        ObjectOwner?: undefined;
+        ConsensusAddressOwner?: undefined;
+        Shared?: undefined;
+    } | {
+        ObjectOwner: any;
+        AddressOwner?: undefined;
+        ConsensusAddressOwner?: undefined;
+        Shared?: undefined;
+    } | {
+        ConsensusAddressOwner: any;
+        AddressOwner?: undefined;
+        ObjectOwner?: undefined;
+        Shared?: undefined;
+    } | {
+        Shared: {};
+        AddressOwner?: undefined;
+        ObjectOwner?: undefined;
+        ConsensusAddressOwner?: undefined;
+    };
+    /**
+     * @param {Object} params
+     * @param {SuiMaster} params.suiMaster
+     * @param {SuiPaginatedResponseParams} params.params
+     * @param {string} [params.method]
+     * @param {string} [params.order]
+     * @param {boolean} [params.debug]
+     */
+    constructor(params: {
+        suiMaster: SuiMaster;
+        params: SuiPaginatedResponseParams;
+        method?: string;
+        order?: string;
+        debug?: boolean;
+    });
+    _suiMaster: import("./SuiMaster.js").default;
+    _method: string;
+    /** @type {SuiPaginatedResponseParams} */
+    _params: SuiPaginatedResponseParams;
+    _order: "ascending" | "descending";
+    _hasNextPage: boolean;
+    _nextCursor: any;
+    /** @type {T[]} */
+    _data: T[];
+    /**
+     * Simple itterator to go over all list of items, not caring about pagination/cursors etc. It fetches next page when needed
+     * Optional maxLimit second parameter to stop when reached count
+     * @param {(item: T) => (void | Promise<void>)} callbackFunc
+     * @param {Number} maxLimit
+     */
+    forEach(callbackFunc: (item: T) => (void | Promise<void>), maxLimit?: number): Promise<void>;
+    get hasNextPage(): boolean;
+    /** @returns {T[]} */
+    get data(): T[];
+    nextPage(): Promise<false | T[]>;
+    fetch(params?: {}): Promise<T[]>;
+    /**
+     * Shared Relay-style GraphQL pagination:
+     *   - ascending  → `first` + `after`, `hasNextPage` / `endCursor`
+     *   - descending → `last`  + `before`, `hasPreviousPage` / `startCursor`
+     * `last` returns nodes ascending too, so descending callers get a reversed slice.
+     *
+     * @param {Object} config
+     * @param {string} config.query - GraphQL query declaring $first/$after/$last/$before + any extra vars
+     * @param {Object} [config.variables] - extra variables merged into the request (e.g. filter, owner)
+     * @param {(data: any) => any} config.extractConnection - pull the Connection (pageInfo + nodes) out of response.data
+     * @param {(node: any) => T} config.mapNode - turn a node into the wrapped T instance
+     * @param {string} [config.errorLabel='GraphQL query'] - prefix for errors
+     * @param {Object} [params]
+     * @param {?string} [params.cursor]
+     */
+    _fetchGraphqlPaginated(config: {
+        query: string;
+        variables?: any;
+        extractConnection: (data: any) => any;
+        mapNode: (node: any) => T;
+        errorLabel?: string;
+    }, params?: {
+        cursor?: string | null;
+    }): Promise<T[]>;
+    /**
+     * Paginate the GraphQL `events` query. `this._params` = { filter, limit } where
+     * `filter` is a GraphQL `EventFilter` (module/type/sender/checkpoint fields).
+     */
+    _fetchEventsGraphql(params?: {}): Promise<T[]>;
+    /**
+     * Paginate `address(address).objects(filter)` via GraphQL. `this._params` = { owner, type, limit }
+     * where `type` is a GraphQL `ObjectFilter.type` string.
+     */
+    _fetchOwnedObjectsGraphql(params?: {}): Promise<T[]>;
+    /**
+     * Paginate the GraphQL root `transactions(filter: TransactionFilter)` query.
+     * `this._params` = { filter, limit } where `filter` is a GraphQL `TransactionFilter`
+     * (`sentAddress`, `affectedAddress`, `affectedObject`, `function`, checkpoint bounds, `kind`).
+     */
+    _fetchTransactionsGraphql(params?: {}): Promise<T[]>;
+}
+export type SuiObject = import("./SuiObject.js").default;
+export type SuiMaster = import("./SuiMaster.js").default;
+export type GraphqlEventsParams = {
+    filter?: object;
+    limit?: number;
+};
+export type GraphqlOwnedObjectsParams = {
+    owner: string;
+    type?: string;
+    limit?: number;
+};
+export type GraphqlTransactionsParams = {
+    filter?: object;
+    limit?: number;
+};
+export type SuiPaginatedResponseParams = SuiClientTypes.ListOwnedObjectsOptions<SuiClientTypes.ObjectInclude> | SuiClientTypes.ListCoinsOptions | SuiClientTypes.ListDynamicFieldsOptions | GraphqlEventsParams | GraphqlOwnedObjectsParams | GraphqlTransactionsParams;
+import SuiTransaction from './SuiTransaction.js';
+import SuiEvent from './SuiEvent.js';
+import SuiCommonMethods from './SuiCommonMethods.js';
+import type { SuiClientTypes } from "@mysten/sui/client";

package/types/lib/SuiPseudoRandomAddress.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Deterministically derives an Ed25519 keypair (and thus a Sui address) from an arbitrary
+ * string seed. Useful for tests and local dev where you need a stable, human-readable
+ * "name" instead of a raw private key.
+ *
+ * The derivation is deterministic but **not cryptographically secure** — the hash function
+ * is intentionally simple. Do not use for production key management.
+ */
+export default class SuiPseudoRandomAddress {
+    /**
+     * Derive an Ed25519 keypair from an arbitrary string seed.
+     * The same string always produces the same keypair (and Sui address).
+     *
+     * @param {string} as - any string seed, e.g. `'alice'`, `'test-wallet-1'`
+     * @returns {Ed25519Keypair}
+     */
+    static stringToKeyPair(as: string): Ed25519Keypair;
+    /**
+     * Convert an arbitrary string seed into a BIP-39 mnemonic phrase by mapping the string
+     * to 32 pseudo-random bytes and running them through `entropyToMnemonic`.
+     *
+     * The byte derivation:
+     *  1. Repeats the string until it is at least 32 chars (appending `*"` so `'test'` and
+     *     `'testtest'` produce different entropy).
+     *  2. Maps each character to its char-code.
+     *  3. Folds any bytes beyond position 31 back into the first 32 via modular addition.
+     *
+     * @param {string} as - any string seed
+     * @returns {string} 24-word BIP-39 mnemonic derived from the seed
+     */
+    static stringToPhrase(as: string): string;
+}
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';

package/types/lib/SuiTransaction.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @import { SuiClientTypes } from "@mysten/sui/client"
+ * @typedef {import("./SuiMaster.js").default} SuiMaster
+ * @typedef {import("./SuiObject.js").default} SuiObject
+ * @typedef {import("./SuiEvent.js").default} SuiEvent
+ */
+/**
+ * Wrapper over a Sui transaction result. Lazily parses `effects.changedObjects` into
+ * typed `created`, `mutated`, `deleted` lists and wraps events in `SuiEvent` instances.
+ */
+export default class SuiTransaction extends SuiCommonMethods {
+    /**
+     * @param {Object} params
+     * @param {SuiMaster} params.suiMaster
+     * @param {SuiClientTypes.Transaction} params.data - raw transaction data
+     * @param {boolean} [params.debug]
+     */
+    constructor(params: {
+        suiMaster: SuiMaster;
+        data: SuiClientTypes.Transaction;
+        debug?: boolean;
+    });
+    /** @type {SuiMaster} */
+    _suiMaster: SuiMaster;
+    /** @type {?SuiClientTypes.Transaction} */
+    _data: SuiClientTypes.Transaction | null;
+    /** @type {?{created: SuiObject[], mutated: SuiObject[], deleted: SuiObject[], objects: SuiObject[]}} */
+    _results: {
+        created: SuiObject[];
+        mutated: SuiObject[];
+        deleted: SuiObject[];
+        objects: SuiObject[];
+    } | null;
+    /** @type {?SuiEvent[]} */
+    _events: SuiEvent[] | null;
+    /** @returns {?number} epoch the transaction executed in, or null if unavailable */
+    get executedEpoch(): number | null;
+    /** @returns {?string} Base58-encoded transaction digest, or null if data isn't set */
+    get digest(): string | null;
+    /** @returns {?bigint} net gas cost in MIST (computationCost + storageCost − storageRebate), or null */
+    get gasUsed(): bigint | null;
+    /** @returns {SuiObject[]} objects deleted by this transaction */
+    get deleted(): SuiObject[];
+    /** @returns {SuiObject[]} objects mutated (version changed) by this transaction */
+    get mutated(): SuiObject[];
+    /** @returns {SuiObject[]} objects created by this transaction */
+    get created(): SuiObject[];
+    /** @returns {?SuiClientTypes.Transaction} raw transaction data as received from the client */
+    get data(): SuiClientTypes.Transaction | null;
+    /**
+     * Returns true if the transaction's status indicates success.
+     * @returns {boolean}
+     */
+    isSuccessful(): boolean;
+    /** @returns {SuiEvent[]} events emitted by this transaction, lazily built and cached */
+    get events(): SuiEvent[];
+    /**
+     * Parsed object-change results, lazily built from `effects.changedObjects` and cached.
+     * @returns {{created: SuiObject[], mutated: SuiObject[], deleted: SuiObject[], objects: SuiObject[]}}
+     */
+    get results(): {
+        created: SuiObject[];
+        mutated: SuiObject[];
+        deleted: SuiObject[];
+        objects: SuiObject[];
+    };
+    /**
+     * Wait for this transaction to be finalised on chain, then refresh `_data` with the full result.
+     * Clears the cached `_results` and `_events` so getters recompute from the fresh data.
+     *
+     * @param {SuiClientTypes.WaitForTransactionOptions} [input] - extra options forwarded to `client.waitForTransaction`
+     * @returns {Promise<this>}
+     * @throws if `digest` is not set
+     */
+    waitForTransaction(input?: SuiClientTypes.WaitForTransactionOptions): Promise<this>;
+    /**
+     * Checkpoint timestamp in milliseconds since epoch, or null if unavailable.
+     *
+     * Only populated when the transaction was fetched via the GraphQL path
+     * (`SuiMaster.fetchTransactions`). Transactions returned from `signAndExecuteTransaction`
+     * or `waitForTransaction` (gRPC) do not carry a timestamp in their data shape and will
+     * always return null here.
+     *
+     * @returns {?number}
+     */
+    get timestampMs(): number | null;
+}
+export type SuiMaster = import("./SuiMaster.js").default;
+export type SuiObject = import("./SuiObject.js").default;
+export type SuiEvent = import("./SuiEvent.js").default;
+import SuiCommonMethods from './SuiCommonMethods.js';
+import type { SuiClientTypes } from "@mysten/sui/client";