suidouble 2.5.0 → 2.16.0

package/lib/SuiTransaction.js

@@ -1,37 +1,59 @@
 import SuiCommonMethods from './SuiCommonMethods.js';
 
+/**
+ * @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 {
-    constructor(params = {}) {
+    /**
+     * @param {Object} params
+     * @param {SuiMaster} params.suiMaster
+     * @param {SuiClientTypes.Transaction} params.data - raw transaction data
+     * @param {boolean} [params.debug]
+     */
+    constructor(params) {
         super(params);
 
         this._debug = !!params.debug;
+        /** @type {SuiMaster} */
         this._suiMaster = params.suiMaster;
         if (!this._suiMaster) {
             throw new Error('suiMaster is requried');
         }
 
-        this._data = params.data || {};
+        /** @type {?SuiClientTypes.Transaction} */
+        this._data = params.data;
 
+        /** @type {?{created: SuiObject[], mutated: SuiObject[], deleted: SuiObject[], objects: SuiObject[]}} */
         this._results = null;
+        /** @type {?SuiEvent[]} */
         this._events = null;
     }
 
+    /** @returns {?number} epoch the transaction executed in, or null if unavailable */
     get executedEpoch() {
-        if (this._data && this._data.effects && this._data.effects.executedEpoch) {
-            return BigInt(this._data.effects.executedEpoch);
+        if (this._data && this._data.epoch) {
+            return Number(this._data.epoch);
         }
-
         return null;
     }
 
+    /** @returns {?string} Base58-encoded transaction digest, or null if data isn't set */
     get digest() {
         if (this._data) {
             return this._data.digest;
         }
-
         return null;
     }
 
+    /** @returns {?bigint} net gas cost in MIST (computationCost + storageCost − storageRebate), or null */
     get gasUsed() {
         try {
             if (this._data && this._data.effects && this._data.effects.gasUsed) {
@@ -44,43 +66,41 @@ export default class SuiTransaction extends SuiCommonMethods {
         return null;
     }
 
+    /** @returns {SuiObject[]} objects deleted by this transaction */
     get deleted() {
         const results = this.results;
         return results.deleted;
     }
 
+    /** @returns {SuiObject[]} objects mutated (version changed) by this transaction */
     get mutated() {
         const results = this.results;
         return results.mutated;
     }
 
+    /** @returns {SuiObject[]} objects created by this transaction */
     get created() {
         const results = this.results;
         return results.created;
     }
 
+    /** @returns {?SuiClientTypes.Transaction} raw transaction data as received from the client */
     get data() {
         return this._data;
     }
 
-    get status() {
-        let status = null;
-        if (this.data && this.data.effects && this.data.effects.status && this.data.effects.status.status) {
-            status = this.data.effects.status.status;
-        }
-        return status;
-    }
-
+    /**
+     * Returns true if the transaction's status indicates success.
+     * @returns {boolean}
+     */
     isSuccessful() {
-        if (this.data && this.data.effects && this.data.effects.status && this.data.effects.status.status) {
-            if (this.data.effects.status.status == 'success') {
-                return true;
-            }
+        if (this.data && this.data.status && this.data.status.success) {
+            return true;
         }
-
         return false;
     }
 
+    /** @returns {SuiEvent[]} events emitted by this transaction, lazily built and cached */
     get events() {
         if (this._events) {
             return this._events;
@@ -93,7 +113,13 @@ export default class SuiTransaction extends SuiCommonMethods {
                 const suiEvent = new this._suiMaster.SuiEvent({
                     suiMaster: this._suiMaster,
                     debug: this._debug,
-                    data: event,
+                    data: {
+                        // map gRPC SuiClientTypes.Event shape → SuiEventData shape
+                        type: event.eventType,
+                        parsedJson: event.json,
+                        sender: event.sender,
+                        bcs: event.bcs,
+                    },
                 });
 
                 events.push(suiEvent);
@@ -104,70 +130,52 @@ export default class SuiTransaction extends SuiCommonMethods {
         return this._events;
     }
 
+    /**
+     * Parsed object-change results, lazily built from `effects.changedObjects` and cached.
+     * @returns {{created: SuiObject[], mutated: SuiObject[], deleted: SuiObject[], objects: SuiObject[]}}
+     */
     get results() {
         if (this._results) {
             return this._results;
         }
 
+        /** @type {Object.<string, SuiObject>} */
         const objects = {};
 
         const listCreated = [];
         const listMutated = [];
         const listDeleted = [];
 
-        if (this.data.objectChanges) {
-            for (const objectChange of this.data.objectChanges) {
+        if (this.data?.effects?.changedObjects) {
+            for (const objectChange of this.data.effects.changedObjects) {
                 if (objectChange.objectId) {
-                    if (objects[objectChange.objectId]) {
-    
-                    } else {
+                    const objectId = objectChange.objectId;
+                    const idOperation = objectChange.idOperation;
+                    const typeGuess = 
+                        (this.data.objectTypes && this.data.objectTypes[objectChange.objectId]) ?
+                        this.data.objectTypes[objectChange.objectId] : undefined;
+
+                    if (!objects[objectId]) {
                         const obj = new this._suiMaster.SuiObject({
                             suiMaster: this._suiMaster,
                             debug: this._debug,
-                            objectChange: objectChange,
+                            id: objectChange.objectId,
+                            version: objectChange.outputVersion,
+                            type: typeGuess,
                         });
-                        if (obj.address) {
-                            objects[obj.address] = obj;
-                        }
-                    }
-                }
-            }
-        }
-
-        if (this.data.effects) {
-            const events = ['created', 'mutated']; // events names are the same as properties in result.effects
-
-            for (const eventName of events) {
-                if ( this.data.effects[eventName] &&  this.data.effects[eventName].length) {
-                    for (const effect of this.data.effects[eventName]) {
-                        if (effect.reference && effect.reference.objectId) {
-                            if (objects[effect.reference.objectId]) {
-                                if (eventName === 'created') {
-                                    listCreated.push(objects[effect.reference.objectId]);
-                                } else if (eventName === 'mutated') {
-                                    listMutated.push(objects[effect.reference.objectId]);
-                                }
-                            }
-                        }
+                        objects[objectId] = obj;
                     }
-                }
-            }
-
-            if (this.data.effects.deleted) {
-                for (const effect of this.data.effects.deleted) {
-                    if (effect.objectId) {
-                        if (objects[effect.objectId]) {
-
-                        } else {
-                            const obj = new this._suiMaster.SuiObject({
-                                suiMaster: this._suiMaster,
-                                debug: this._debug,
-                                objectChange: effect,
-                            });
-                            objects[effect.objectId] = obj;
-                        }
-                        objects[effect.objectId].markAsDeleted();
-                        listDeleted.push(objects[effect.objectId]);
+                    
+
+                    if (idOperation == 'Created') { 
+                        listCreated.push(objects[objectId]);
+                    } else if (idOperation == 'Deleted') {
+                        listDeleted.push(objects[objectId]);
+                        objects[objectId].markAsDeleted();
+                    } else if (objectChange.inputVersion && objectChange.outputVersion 
+                        && objectChange.inputVersion != objectChange.outputVersion
+                    ) {
+                        listMutated.push(objects[objectId]);
                     }
                 }
             }
@@ -178,15 +186,52 @@ export default class SuiTransaction extends SuiCommonMethods {
             mutated: listMutated,
             deleted: listDeleted,
             objects: Object.values(objects),
-            status: this.status,
         };
 
         return this._results;
     }
 
+    /**
+     * 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
+     */
+    async waitForTransaction(input = /** @type {SuiClientTypes.WaitForTransactionOptions<{}>} */ ({})) {
+        if (!this.digest) {
+            throw new Error('can not waitForTransaction: digest is not set');
+        }
+
+        const result = await this._suiMaster.client.waitForTransaction(
+            /** @type {SuiClientTypes.WaitForTransactionOptions<{}>} */ ({
+                ...input,
+                digest: this.digest,
+            })
+        );
+
+        this._data = result.Transaction;
+        this._results = null;
+        this._events = null;
+
+        return 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() {
-        if (this.data.timestampMs) {
-            return parseInt(''+this.data.timestampMs, 10);
+        const ts = /** @type {any} */ (this.data)?.timestampMs;
+        if (ts) {
+            return parseInt(''+ts, 10);
         } else {
             return null;
         }

package/lib/SuiUtils.js

@@ -2,14 +2,17 @@ import SuiCommonMethods from './SuiCommonMethods.js';
 import { Inputs, Transaction } from '@mysten/sui/transactions';
 import { bcs } from '@mysten/sui/bcs';
 import { fromBase64 } from '@mysten/bcs';
-import { SuiJsonRpcClient, getJsonRpcFullnodeUrl, JsonRpcHTTPTransport } from '@mysten/sui/jsonRpc';
+import { SuiGrpcClient, GrpcWebFetchTransport } from '@mysten/sui/grpc';
+import { SuiGraphQLClient } from '@mysten/sui/graphql';
 import { normalizeSuiAddress } from '@mysten/sui/utils';
-import WebSocket from 'websocket';
-
-const WebSocketClient = WebSocket.w3cwebsocket;
 
 /**
+ * @import { SuiClientTypes } from "@mysten/sui/client"
  * @typedef {import("@mysten/sui/transactions").Argument} Argument
+ * @typedef {import("@mysten/sui/transactions").CallArg} CallArg
+ * @typedef {{ Pure: { bytes: string } }} PureInput
+ * @typedef {import("@mysten/sui/grpc").SuiGrpcClientOptions} SuiGrpcClientOptions
+ * @typedef {import("@mysten/sui/grpc").GrpcWebOptions} GrpcWebOptions
  */
 
 export { normalizeSuiAddress };
@@ -21,16 +24,16 @@ export default class SuiUtils extends SuiCommonMethods {
      * Attach the parameter input into transaction, to be used for moveCall
      * accepts an Inputs.Pure (result of .pureInput) or type + value directly
      * 
-     * @param {Transaction} tx 
-     * @param {string | Inputs.Pure} typeOrInput 
-     * @param {?Argument} value 
-     * @returns Argument
+     * @param {Transaction} tx
+     * @param {string | PureInput} typeOrInput - string type name, or already-serialised Pure input `{ Pure: { bytes } }`
+     * @param {*} [value]
+     * @returns {Argument}
      */
     static txInput(tx, typeOrInput, value = null) {
-        if (typeOrInput && typeOrInput.Pure && typeOrInput.Pure.bytes) {
-            return tx.pure(SuiUtils.pureInputToBytes(typeOrInput));
+        if (typeOrInput && /** @type {any} */ (typeOrInput).Pure && /** @type {any} */ (typeOrInput).Pure.bytes) {
+            return tx.pure(SuiUtils.pureInputToBytes(/** @type {PureInput} */ (typeOrInput)));
         } else {
-            return tx.pure(SuiUtils.pureInputToBytes(SuiUtils.pureInput(typeOrInput, value)));
+            return tx.pure(SuiUtils.pureInputToBytes(/** @type {any} */ (SuiUtils.pureInput(/** @type {string} */ (typeOrInput), value))));
         }
     }
 
@@ -47,9 +50,9 @@ export default class SuiUtils extends SuiCommonMethods {
      * 
      * if you are going to construct tx yourself, you'd better use SuiUtils.txInput static method
      * 
-     * @param {string} type 
-     * @param {value} value 
-     * @returns Inputs.Pure
+     * @param {string} type
+     * @param {*} value
+     * @returns {CallArg}
      */
     static pureInput(type, value) {
         let typeNormalized = type;
@@ -76,16 +79,43 @@ export default class SuiUtils extends SuiCommonMethods {
                 }
             }
         }
+
+        throw new Error(`pureInput: unsupported type "${typeNormalized}"`);
     }
 
     /**
      * Convert sui's PureInput into bcs serialized bytes
-     * @param {Inputs.Pure} pureInput 
+     * @param {PureInput} pureInput
      */
     static pureInputToBytes(pureInput) {
         return fromBase64(pureInput.Pure.bytes);
     }
 
+    /**
+     * Decode a Move `vector<u8>` field into a UTF-8 string.
+     *
+     * Accepts the shapes SUI returns across representations:
+     *   - base64 string (v2 gRPC/GraphQL JSON representation for byte vectors)
+     *   - Uint8Array
+     *   - array of numbers (legacy JSON-RPC shape)
+     *
+     * @param {string | Uint8Array | number[]} value
+     * @returns {string}
+     */
+    static bytesFieldToString(value) {
+        if (value == null) return '';
+        if (typeof value === 'string') {
+            return new TextDecoder().decode(fromBase64(value));
+        }
+        if (value instanceof Uint8Array) {
+            return new TextDecoder().decode(value);
+        }
+        if (Array.isArray(value)) {
+            return new TextDecoder().decode(new Uint8Array(value));
+        }
+        throw new Error('bytesFieldToString: unsupported value type');
+    }
+
     /**
      * Wrapper for sui's utils normalizeSuiAddress
      * Perform the following operations:
@@ -103,139 +133,161 @@ export default class SuiUtils extends SuiCommonMethods {
     }
 
     /**
-     * As SUI removed websocket dependency for a node, we'll have it here as constructor wrapper
-     *   returning native WebSocket in browser and websocket's w3cwebsocket in node
-     * @returns WebSocketClient
+     * Makes an instance of SuiGrpcClient pointed at a custom gRPC-web endpoint.
+     *
+     * `transportOptions` is passed through to GrpcWebFetchTransport — the same shape
+     * as `@protobuf-ts/grpcweb-transport`'s GrpcWebOptions:
+     *   - baseUrl   : string   — required, the gRPC-web endpoint
+     *   - format    : 'text' | 'binary' — wire format, defaults to 'text'
+     *   - fetchInit : RequestInit-ish — extra fetch options (credentials, cache, ...); `body`/`headers`/`method`/`signal` are reserved
+     *   - fetch     : typeof fetch — custom fetch implementation (useful for proxies, auth, logging)
+     *
+     * @example
+     * const client = SuiUtils.suiClientForRPC('mainnet', {
+     *     baseUrl: 'https://fullnode.mainnet.sui.io:443',
+     *     format: 'binary',
+     *     fetchInit: { credentials: 'include' },
+     *     fetch: (url, init) => fetch(url, { ...init, headers: { ...init.headers, 'x-api-key': 'xxx' } }),
+     * });
+     *
+     * @param {SuiClientTypes.Network} network
+     * @param {GrpcWebOptions} transportOptions
+     * @returns {SuiGrpcClient}
      */
-    static WebSocketConstructor() {
-        return WebSocketClient;
+    static suiClientForRPC(network, transportOptions) {
+        const transport = new GrpcWebFetchTransport(transportOptions);
+        return new SuiGrpcClient({ network, transport });
     }
 
     /**
-     * Makes an instance for SuiJsonRpcClient for a specific chain using RPC
-     * @param {Object} params parameters
-     * @param {string} params.chainname 'mainnet', 'devnet', 'testnet', 'localnet'
-     * @param {string} params.url rpc url
-     * @param {Object} params.rpc rpc settings
-     * @param {Object.<string, string>} params.rpc.headers rpc headers
-     * @returns {SuiJsonRpcClient}
+     * Build a SuiGraphQLClient reusing the network of an existing SuiGrpcClient.
+     *
+     * Picks the default Sui GraphQL endpoint for the network unless `overrides.url` is set.
+     * `overrides` is forwarded to SuiGraphQLClient (fetch, headers, queries, mvr, url).
+     *
+     * @param {SuiGrpcClient} grpcClient
+     * @param {Object} [overrides]
+     * @param {?string} [overrides.url]
+     * @param {?typeof fetch} [overrides.fetch]
+     * @param {?Object.<string, string>} [overrides.headers]
+     * @returns {SuiGraphQLClient}
      */
-    static suiClientForRPC(params = {}) {
-        const providerName = params.providerName || params.chainname || params.chain;
-        delete params.providerName;
-        delete params.chainname;
-        delete params.chain;
-        params.WebSocketConstructor = SuiUtils.WebSocketConstructor();
+    static suiGraphQLClientFromGrpc(grpcClient, overrides = {}) {
+        if (!grpcClient || !grpcClient.network) {
+            throw new Error('grpcClient with a network is required');
+        }
 
-        const transport = new JsonRpcHTTPTransport(params);
-        const client = new SuiJsonRpcClient({ transport: transport });
+        const defaultUrls = {
+            mainnet: 'https://sui-mainnet.mystenlabs.com/graphql',
+            testnet: 'https://graphql.testnet.sui.io/graphql',
+            devnet: 'https://graphql.devnet.sui.io/graphql',
+            localnet: 'http://127.0.0.1:9125/graphql',
+        };
 
-        client.providerName = providerName;
+        const url = overrides.url || defaultUrls[grpcClient.network];
+        if (!url) {
+            throw new Error(`no default GraphQL url for network "${grpcClient.network}" — pass overrides.url`);
+        }
 
-        return client;
+        return new SuiGraphQLClient({
+            ...overrides,
+            url,
+            network: grpcClient.network,
+        });
     }
 
     /**
-     * Makes an instance for SuiJsonRpcClient for a specific chain, eg: 'mainnet'
-     * @param {string} chainname 
-     * @returns {SuiJsonRpcClient}
+     * Makes an instance for SuiGrpcClient for a specific chain, eg: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+     * @param {SuiClientTypes.Network} network
+     * @returns {SuiGrpcClient}
      */
-    static suiClientFor(chainname) {
-        const normalizedChainname = (''+chainname).toLowerCase().split('sui:').join('');
-        const client = new SuiJsonRpcClient({
-            transport: new JsonRpcHTTPTransport({
-                url: getJsonRpcFullnodeUrl(normalizedChainname),
-                WebSocketConstructor: SuiUtils.WebSocketConstructor(),
-            }),
-        });
-        client.providerName = 'sui:'+normalizedChainname;
-        return client;
+    static suiClientFor(network) {
+        // strip optional 'sui:' prefix so both 'mainnet' and 'sui:mainnet' work
+        const normalized = SuiUtils.normalizeNetworkString(network) ?? network;
+        const baseUrls = {
+            mainnet: 'https://fullnode.mainnet.sui.io:443',
+            testnet: 'https://fullnode.testnet.sui.io:443',
+            devnet: 'https://fullnode.devnet.sui.io:443',
+            localnet: 'http://127.0.0.1:9000',
+        };
+        return SuiUtils.suiClientForRPC(normalized, { baseUrl: baseUrls[normalized] });
     }
 
     /**
-     * Normalize SuiJsonRpcClient parameter, accepting:
-     *   - different previous versions of sui.js library, 
-     *   - object of SuiJsonRpcClient class
-     *   - object of SuiLocalTestValidator class
-     *   - string of the chain name to connect to
-     * 
-     * @returns {SuiJsonRpcClient}
+     * Normalize client parameter into a SuiGrpcClient, accepting:
+     *   - an existing SuiGrpcClient instance
+     *   - a SuiLocalTestValidator instance
+     *   - a string chain name: 'local' | 'localnet' | 'dev' | 'devnet' | 'test' | 'testnet' | 'main' | 'mainnet'
+     *   - a legacy client object (sniffs network from endpoint / connection.fullnode / providerName)
+     *
+     * @param {SuiGrpcClient | string | Object} clientParam
+     * @returns {SuiGrpcClient | null}
      */
     static normalizeClient(clientParam) {
-        let client = null;
-        let providerName = null;
-        
-        if (clientParam) {
-            if (clientParam == 'local' || (clientParam.constructor && clientParam.constructor.name && clientParam.constructor.name == 'SuiLocalTestValidator')) {
-                if (clientParam == 'local') {
-                    client = SuiUtils.suiClientFor('localnet');
-                    providerName = 'sui:localnet'; 
-                } else {
-                    // SuiLocalTestValidator
-                    providerName = clientParam.providerName;
-                    client = clientParam.client;
-                }
-            } else if (clientParam == 'test' || clientParam == 'testnet') {
-                client = SuiUtils.suiClientFor('testnet');
-                providerName = 'sui:testnet';
-            } else if (clientParam == 'dev' || clientParam == 'devnet') {
-                client = SuiUtils.suiClientFor('devnet');
-                providerName = 'sui:devnet';
-            } else if (clientParam == 'main' || clientParam == 'mainnet') {
-                client = SuiUtils.suiClientFor('mainnet');
-                providerName = 'sui:mainnet';
-            } else {
-                if (clientParam && clientParam.constructor && (clientParam.endpoint || clientParam.transport)) {
-                    client = clientParam;
-                    let url = '';
-                    if (clientParam.endpoint) {
-                        // workaround set in SuiInBrowserAdapter
-                        url = clientParam.endpoint;
-                    } else if (clientParam.transport && clientParam.transport.websocketClient && clientParam.transport.websocketClient.endpoint) {
-                        url = clientParam.transport.websocketClient.endpoint;
-                    }
-
-                    if (clientParam.providerName) {
-                        providerName = clientParam.providerName;
-                        if (['devnet', 'mainnet', 'testnet', 'localnet'].indexOf(clientParam.providerName) !== -1) {
-                            providerName = 'sui:'+clientParam.providerName; // no prefix - add prefix
-                        }
-                    } else if (url.indexOf('devnet') !== -1) {
-                        providerName = 'sui:devnet';
-                    } else if (url.indexOf('testnet') !== -1) {
-                        providerName = 'sui:testnet';
-                    } else if (url.indexOf('mainnet') !== -1) {
-                        providerName = 'sui:mainnet';
-                    } else if (url.indexOf('127.0.0.1') !== -1) {
-                        providerName = 'sui:localnet';
-                    } else {
-                        // just keep provider name as unique to fullnode URL to keep separate ObjectStorage instances
-                        providerName = url.split('//')[1];
-                    }
-                } else if (clientParam && clientParam.connection && clientParam.connection.fullnode) {
-                    client = clientParam;
-
-                    if (clientParam.connection.fullnode.indexOf('devnet') !== -1) {
-                        providerName = 'sui:devnet';
-                    } else if (clientParam.connection.fullnode.indexOf('testnet') !== -1) {
-                        providerName = 'sui:testnet';
-                    } else if (clientParam.connection.fullnode.indexOf('mainnet') !== -1) {
-                        providerName = 'sui:mainnet';
-                    } else if (clientParam.connection.fullnode.indexOf('127.0.0.1') !== -1) {
-                        providerName = 'sui:localnet';
-                    } else {
-                        // just keep provider name as unique to fullnode URL to keep separate ObjectStorage instances
-                        providerName = clientParam.connection.fullnode;
-                    }
-                }
-            }
+        if (!clientParam) {
+            return null;
+        }
+
+        if (clientParam instanceof SuiGrpcClient) {
+            return clientParam;
         }
 
-        if (client) {
-            client.providerName = providerName;
-            return client;
+        const network = SuiUtils._sniffNetwork(clientParam);
+        if (!network) {
+            return null;
         }
 
+        return SuiUtils.suiClientFor(network);
+    }
+
+    /**
+     * Strip an optional "sui:" prefix and map short aliases ('local', 'dev', 'test', 'main')
+     * to full network names. Returns null if the string doesn't match a known network.
+     *
+     * @param {string} s
+     * @returns {SuiClientTypes.Network | null}
+     */
+    static normalizeNetworkString(s) {
+        if (typeof s !== 'string') return null;
+        const normalized = s.toLowerCase().replace(/^sui:/, '');
+        if (normalized === 'local' || normalized === 'localnet') return 'localnet';
+        if (normalized === 'dev' || normalized === 'devnet') return 'devnet';
+        if (normalized === 'test' || normalized === 'testnet') return 'testnet';
+        if (normalized === 'main' || normalized === 'mainnet') return 'mainnet';
+        return null;
+    }
+
+    /**
+     * Extracts a SuiClientTypes.Network string from various inputs used historically by suidouble.
+     *
+     * @param {string | Object} clientParam
+     * @returns {SuiClientTypes.Network | null}
+     */
+    static _sniffNetwork(clientParam) {
+        if (typeof clientParam === 'string') {
+            return SuiUtils.normalizeNetworkString(clientParam);
+        }
+
+        if (clientParam.constructor && clientParam.constructor.name === 'SuiLocalTestValidator') {
+            return SuiUtils.normalizeNetworkString(clientParam.providerName) || 'localnet';
+        }
+
+        const fromNetwork = SuiUtils.normalizeNetworkString(clientParam.network);
+        if (fromNetwork) return fromNetwork;
+
+        const fromProvider = SuiUtils.normalizeNetworkString(clientParam.providerName);
+        if (fromProvider) return fromProvider;
+
+        const url = clientParam.endpoint
+            || (clientParam.transport && clientParam.transport.websocketClient && clientParam.transport.websocketClient.endpoint)
+            || (clientParam.connection && clientParam.connection.fullnode)
+            || '';
+
+        if (url.indexOf('devnet') !== -1) return 'devnet';
+        if (url.indexOf('testnet') !== -1) return 'testnet';
+        if (url.indexOf('mainnet') !== -1) return 'mainnet';
+        if (url.indexOf('127.0.0.1') !== -1 || url.indexOf('localhost') !== -1) return 'localnet';
+
         return null;
     }