suidouble 2.5.0 → 2.16.0

package/types/lib/SuiInBrowser.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Browser-side entry point for wallet integration. Manages a registry of SuiInBrowserAdapter
+ * instances (one per known wallet), tracks the active connection, and creates a SuiMaster
+ * pointing at the connected chain.
+ *
+ * Starts initialising itself 50 ms after construction so callers have time to attach listeners.
+ * Use SuiInBrowser.getSingleton({ defaultChain }) for the typical single-page-app pattern.
+ *
+ * Events emitted:
+ *   - 'adapter'      — a new SuiInBrowserAdapter was registered (detail: adapter)
+ *   - 'connected'    — the active adapter connected
+ *   - 'disconnected' — the active adapter disconnected
+ *   - 'rpc'          — the RPC endpoint was changed via setRPC
+ */
+export default class SuiInBrowser extends SuiCommonMethods {
+    static _singleInstances: {};
+    /**
+     * Returns the singleton SuiInBrowser instance for the given defaultChain, creating it if
+     * necessary. Ideal for single-page-app usage where one instance is shared across the app.
+     * @param {Object} [params]
+     * @param {string} [params.defaultChain]
+     * @returns {SuiInBrowser}
+     */
+    static getSingleton(params?: {
+        defaultChain?: string;
+    }): SuiInBrowser;
+    /**
+     * Returns the list of known wallet placeholder params used to pre-populate the adapter
+     * registry before the Wallet Standard registry is queried.
+     * @returns {Array<{name: string, icon: string, downloadUrls: Object}>}
+     */
+    static getPossibleWallets(): Array<{
+        name: string;
+        icon: string;
+        downloadUrls: any;
+    }>;
+    /**
+     * @param {Object} [params]
+     * @param {string} [params.defaultChain='sui:devnet'] - chain used before any wallet connects
+     * @param {boolean} [params.debug]
+     */
+    constructor(params?: {
+        defaultChain?: string;
+        debug?: boolean;
+    });
+    /** @type {Object.<string, SuiInBrowserAdapter>} */
+    _adapters: {
+        [x: string]: SuiInBrowserAdapter;
+    };
+    /** @type {string} */
+    _defaultChain: string;
+    /** @type {?SuiInBrowserAdapter} */
+    _activeAdapter: SuiInBrowserAdapter | null;
+    /** @type {?string} */
+    _connectedAddress: string | null;
+    /** @type {?string} */
+    _connectedChain: string | null;
+    /** @type {boolean} */
+    _isConnected: boolean;
+    /** @type {boolean} */
+    _isConnecting: boolean;
+    _client: import("@mysten/sui/grpc").SuiGrpcClient;
+    _suiMaster: SuiMaster;
+    /** @type {?Object} */
+    _rpcSettings: any | null;
+    /** @returns {?SuiInBrowserAdapter} The currently active wallet adapter, or null. */
+    get activeAdapter(): SuiInBrowserAdapter | null;
+    /**
+     * Returns the currently connected wallet address, or null if not connected.
+     * @returns {?string}
+     */
+    getAddress(): string | null;
+    /**
+     * Sign a transaction using the current `sui:signTransaction` feature.
+     * @param {Object} params
+     * @returns {Promise<SignatureWithBytes>}
+     */
+    signTransaction(params: any): Promise<SignatureWithBytes>;
+    /**
+     * Delegates to the active adapter using the legacy transaction-block API.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signAndExecuteTransactionBlock(params: any): Promise<any>;
+    /**
+     * Delegates to the active adapter using the current transaction API.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signAndExecuteTransaction(params: any): Promise<any>;
+    /** @returns {*} The gRPC client instance, or null if not yet initialised. */
+    get client(): any;
+    toSuiAddress(): string;
+    /**
+     * Ensures the client is initialised, then returns it.
+     * @returns {Promise<*>}
+     */
+    getClient(): Promise<any>;
+    /**
+     * Ensures the client is initialised, then returns the SuiMaster instance.
+     * @returns {Promise<SuiMaster>}
+     */
+    getSuiMaster(): Promise<SuiMaster>;
+    /** @returns {?SuiMaster} The current SuiMaster instance, or null if not yet initialised. */
+    get suiMaster(): SuiMaster | null;
+    /** @returns {boolean} True if a wallet adapter is currently connected. */
+    get isConnected(): boolean;
+    /** @returns {?string} The active wallet address, or null if not connected. */
+    get connectedAddress(): string | null;
+    /** @returns {?string} The chain the active adapter is connected to (e.g. 'sui:mainnet'), or null. */
+    get connectedChain(): string | null;
+    /** @returns {Object.<string, SuiInBrowserAdapter>} Map of adapter name to SuiInBrowserAdapter. */
+    get adapters(): {
+        [x: string]: SuiInBrowserAdapter;
+    };
+    /**
+     * Connects to a named adapter or an adapter instance. Returns false if the adapter is not
+     * found in the registry.
+     * @param {string|SuiInBrowserAdapter} adapterOrAdapterName
+     * @returns {Promise<boolean|void>}
+     */
+    connect(adapterOrAdapterName: string | SuiInBrowserAdapter): Promise<boolean | void>;
+    /**
+     * Called when an adapter fires its 'connected' event. Updates the active adapter, connected
+     * address and chain, rebuilds the gRPC client and SuiMaster, and emits 'connected'.
+     * @param {SuiInBrowserAdapter} suiInBrowserAdapter
+     */
+    adapterConnected(suiInBrowserAdapter: SuiInBrowserAdapter): void;
+    /**
+     * Switch connection to use custom RPC endpoint
+     * @param {Object} params parameters
+     * @param {string} params.url rpc url
+     * @param {Object} params.rpc rpc settings
+     * @param {Object.<string, string>} params.rpc.headers rpc headers
+     */
+    setRPC(params: {
+        url: string;
+        rpc: {
+            headers: {
+                [x: string]: string;
+            };
+        };
+    }): Promise<void>;
+    /**
+     * Called when an adapter fires its 'disconnected' event. Resets connection state and emits
+     * 'disconnected'.
+     * @param {SuiInBrowserAdapter} [_suiInBrowserAdapter]
+     */
+    adapterDisconnected(_suiInBrowserAdapter?: SuiInBrowserAdapter): void;
+    /**
+     * Registers a wallet adapter in the registry. If the adapter is new, creates a
+     * SuiInBrowserAdapter instance, wires up its events, and emits 'adapter'. If the adapter
+     * already exists and a standartAdapter is provided, updates it instead.
+     * @param {Object} adapterParams
+     * @param {string} [adapterParams.name]
+     * @param {Object} [adapterParams.standartAdapter]
+     * @param {string} [adapterParams.icon]
+     * @param {Object} [adapterParams.downloadUrls]
+     * @returns {void|false}
+     */
+    attachAdapter(adapterParams: {
+        name?: string;
+        standartAdapter?: any;
+        icon?: string;
+        downloadUrls?: any;
+    }): void | false;
+    /**
+     * Returns the currently connected chain, or the default chain if no wallet is connected.
+     * @returns {string}
+     */
+    getCurrentChain(): string;
+    /**
+     * Builds the gRPC client and SuiMaster for the current chain. No-op if already built.
+     * Uses _rpcSettings when a custom RPC endpoint has been set via setRPC.
+     * @returns {Promise<void>}
+     */
+    initClient(): Promise<void>;
+    /**
+     * Seeds the adapter registry from the known-wallets list and the live Wallet Standard
+     * registry, then subscribes to future 'register' events for dynamically installed wallets.
+     * @returns {Promise<void>}
+     */
+    initialize(): Promise<void>;
+}
+export type SuiGrpcClient = import("@mysten/sui/grpc").SuiGrpcClient;
+export type SignatureWithBytes = import("@mysten/sui/cryptography").SignatureWithBytes;
+import SuiCommonMethods from './SuiCommonMethods.js';
+import SuiInBrowserAdapter from './SuiInBrowserAdapter.js';
+import SuiMaster from './SuiMaster.js';

package/types/lib/SuiInBrowserAdapter.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Wrapper over a single Wallet Standard adapter (e.g. Sui Wallet, Martian, Suiet).
+ * Abstracts away legacy `signAndExecuteTransactionBlock` vs the current
+ * `signAndExecuteTransaction` API, and normalises connection state changes into
+ * `'connected'` / `'disconnected'` events on this instance.
+ */
+export default class SuiInBrowserAdapter extends SuiCommonMethods {
+    /**
+     * @param {Object} [params]
+     * @param {Object} [params.standardAdapter] - raw Wallet Standard adapter from `@wallet-standard/core`
+     * @param {?string} [params.name] - display name used when no adapter is attached (e.g. "not installed" placeholder)
+     * @param {?string} [params.icon] - data-URI icon used when no adapter is attached
+     * @param {Object} [params.downloadUrls] - map of browser name → extension store URL (e.g. `{ chrome: 'https://…' }`)
+     * @param {boolean} [params.debug]
+     */
+    constructor(params?: {
+        standardAdapter?: any;
+        name?: string | null;
+        icon?: string | null;
+        downloadUrls?: any;
+        debug?: boolean;
+    });
+    /** @type {?Object} raw Wallet Standard adapter */
+    _standardAdapter: any | null;
+    /** @type {?string} */
+    _name: string | null;
+    /** @type {?string} */
+    _icon: string | null;
+    /** @type {Object.<string, string>} */
+    _downloadUrls: {
+        [x: string]: string;
+    };
+    /** @type {?string} */
+    _connectedAddress: string | null;
+    /** @type {?string} */
+    _connectedChain: string | null;
+    /** @type {boolean} */
+    _isConnected: boolean;
+    /**
+     * Sign and execute a transaction. Prefers the current `sui:signAndExecuteTransaction`
+     * feature; falls back to the legacy `sui:signAndExecuteTransactionBlock` for older wallets.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signAndExecuteTransaction(params: any): Promise<any>;
+    /**
+     * Sign and execute a transaction using the legacy `sui:signAndExecuteTransactionBlock` feature.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signAndExecuteTransactionBlock(params: any): Promise<any>;
+    /**
+     * Sign a transaction using the current `sui:signTransaction` feature.
+     * @param {Object} params
+     * @returns {Promise<SignatureWithBytes>}
+     */
+    signTransaction(params: any): Promise<SignatureWithBytes>;
+    /**
+     * Sign a transaction. Prefers the current `sui:signTransaction` feature;
+     * falls back to the legacy `sui:signTransactionBlock` for older wallets.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signTransactionBlock(params: any): Promise<any>;
+    /**
+     * Sign a personal/arbitrary message. Prefers `sui:signPersonalMessage`;
+     * falls back to `sui:signMessage` for older wallets.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signPersonalMessage(params: any): Promise<any>;
+    /**
+     * Alias for `signPersonalMessage`.
+     * @param {Object} params
+     * @returns {Promise<*>}
+     */
+    signMessage(params: any): Promise<any>;
+    /**
+     * Disconnect from the wallet and refresh connection state.
+     * @param {Object} [params]
+     * @returns {Promise<*>}
+     */
+    disconnect(params?: any): Promise<any>;
+    /**
+     * Return the Chrome Web Store download URL, or null if not configured.
+     * @returns {?string}
+     */
+    getDownloadURL(): string | null;
+    /**
+     * True when no underlying adapter has been attached (i.e. this is a "not installed" placeholder).
+     * @returns {boolean}
+     */
+    get isDefault(): boolean;
+    /** @returns {?string} currently connected Sui address, or null */
+    get connectedAddress(): string | null;
+    /** @returns {?string} currently connected chain identifier (e.g. `'sui:mainnet'`), or null */
+    get connectedChain(): string | null;
+    /** @returns {boolean} true if the wallet is connected and an address is available */
+    get isConnected(): boolean;
+    /**
+     * Request connection to the wallet. Errors are swallowed; connection state is refreshed
+     * via `connectionUpdated` regardless.
+     * @returns {Promise<void>}
+     */
+    connect(): Promise<void>;
+    /**
+     * Read the current connection state from the underlying adapter and update
+     * `connectedAddress`, `connectedChain`, and `isConnected`. Emits `'connected'` or
+     * `'disconnected'` if the state changed.
+     */
+    connectionUpdated(): void;
+    /**
+     * Attach a Wallet Standard adapter to this instance. No-op if already attached.
+     * Returns false and does nothing if the adapter has no `sui:` features.
+     * Subscribes to adapter `'change'` events to keep connection state up to date.
+     *
+     * @param {Object} standardAdapter - raw adapter from `@wallet-standard/core`
+     * @returns {boolean} false if the adapter lacks Sui features, undefined on success
+     */
+    setStandartAdapter(standardAdapter: any): boolean;
+    __standardAdapterChangeListener: () => void;
+    /**
+     * True if the adapter is installed and supports the minimum required Sui features
+     * (`sui:signAndExecuteTransaction` or `sui:signAndExecuteTransactionBlock`, plus `standard:events`).
+     * @returns {boolean}
+     */
+    get okForSui(): boolean;
+    /** @returns {boolean} true if a Wallet Standard adapter has been attached */
+    get isInstalled(): boolean;
+    /**
+     * Feature map from the underlying adapter, or an empty object if not installed.
+     * Keys are Wallet Standard feature strings (e.g. `'sui:signAndExecuteTransaction'`).
+     * @returns {Object}
+     */
+    get features(): any;
+    /**
+     * Display name — from the adapter if installed, otherwise from the constructor param.
+     * @returns {?string}
+     */
+    get name(): string | null;
+    /**
+     * Data-URI icon — from the adapter if installed, otherwise from the constructor param.
+     * @returns {?string}
+     */
+    get icon(): string | null;
+    /**
+     * Wallet version string from the adapter, or undefined if not installed.
+     * @returns {?string}
+     */
+    get version(): string | null;
+    /**
+     * Returns true if this adapter supports the given feature.
+     * Accepts either a `Feature` enum key (e.g. `'SUI_SIGN_TX'`) or a raw feature string.
+     * @param {string} featureName
+     * @returns {boolean}
+     */
+    hasFeature(featureName: string): boolean;
+    /**
+     * Return the feature object for `featureName`, or null if not available.
+     * Accepts either a `Feature` enum key (e.g. `'SUI_SIGN_TX'`) or a raw feature string.
+     * @param {string} featureName
+     * @returns {?Object}
+     */
+    getFeature(featureName: string): any | null;
+}
+export type SignatureWithBytes = import("@mysten/sui/cryptography").SignatureWithBytes;
+import SuiCommonMethods from './SuiCommonMethods.js';

package/types/lib/SuiLocalTestValidator.d.ts

@@ -0,0 +1,92 @@
+/** @typedef {import("@mysten/sui/grpc").SuiGrpcClient} SuiGrpcClient */
+/**
+ * Manages a local `sui start` test-validator process. The singleton pattern (`launch` / `stop`)
+ * means only one validator runs per test suite even when called from multiple test files.
+ *
+ * When `testFallbackEnabled` is true and `sui start` fails (e.g. Sui CLI not installed),
+ * the instance transparently switches to `sui:devnet` so tests can still run against a live node.
+ */
+export default class SuiLocalTestValidator extends SuiCommonMethods {
+    /** @type {?SuiLocalTestValidator} */
+    static __instance: SuiLocalTestValidator | null;
+    /**
+     * Launch the local sui node (singleton). If already running, returns the existing instance.
+     * Don't forget to call `.stop()` after usage.
+     *
+     * @param {Object} [params]
+     * @param {boolean} [params.testFallbackEnabled]
+     * @param {?number} [params.epochDuration]
+     * @returns {Promise<SuiLocalTestValidator>}
+     */
+    static launch(params?: {
+        testFallbackEnabled?: boolean;
+        epochDuration?: number | null;
+    }): Promise<SuiLocalTestValidator>;
+    /**
+     * Stop the singleton local sui node if running.
+     * @returns {Promise<void>}
+     */
+    static stop(): Promise<void>;
+    /**
+     * @param {Object} [params]
+     * @param {boolean} [params.testFallbackEnabled] - fall back to devnet if the local node can't start
+     * @param {?number} [params.epochDuration] - custom epoch duration in ms (only valid with `--force-regenesis`)
+     * @param {boolean} [params.debug]
+     */
+    constructor(params?: {
+        testFallbackEnabled?: boolean;
+        epochDuration?: number | null;
+        debug?: boolean;
+    });
+    /** @type {?Object} spawned child process */
+    _child: any | null;
+    /** @type {boolean} */
+    _active: boolean;
+    /**
+     * When true, falls back to sui:devnet if the local node can't be started.
+     * @type {boolean}
+     */
+    _testFallbackEnabled: boolean;
+    /** @type {?number} */
+    _epochDuration: number | null;
+    /** @type {string} */
+    _providerName: string;
+    /** @returns {string} active chain identifier, e.g. `'sui:localnet'` or `'sui:devnet'` after fallback */
+    get providerName(): string;
+    /**
+     * gRPC client for the currently active chain.
+     * @returns {SuiGrpcClient}
+     */
+    get client(): SuiGrpcClient;
+    /** @returns {boolean} true once the node is up and accepting transactions */
+    get active(): boolean;
+    /**
+     * @param {number} port
+     * @returns {Promise<boolean>} true if the port accepts a TCP connection within 3 seconds
+     */
+    isPortThere(port: number): Promise<boolean>;
+    /**
+     * Poll `isPortThere` every 500 ms until the port is open or the timeout elapses.
+     * @param {number} port
+     * @param {number} timeout - total wait time in ms
+     * @returns {Promise<boolean>}
+     */
+    waitForPort(port: number, timeout: number): Promise<boolean>;
+    /**
+     * Start `sui start --with-faucet --with-indexer --with-graphql --force-regenesis`,
+     * wait for the faucet (port 9123) and GraphQL (port 9125) to come up,
+     * then return this instance with `active === true`.
+     *
+     * If `testFallbackEnabled` is set and the spawn fails, silently switches to devnet.
+     *
+     * @returns {Promise<SuiLocalTestValidator>}
+     */
+    launch(): Promise<SuiLocalTestValidator>;
+    /**
+     * Kill the child `sui start` process if it is running.
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+}
+export type SuiGrpcClient = import("@mysten/sui/grpc").SuiGrpcClient;
+import SuiCommonMethods from "./SuiCommonMethods.js";