@mysten/sui 1.31.0 → 1.33.0

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API(Work in Progress)",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "1.31.0",
+  "version": "1.33.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [
@@ -147,8 +147,8 @@
     "graphql": "^16.11.0",
     "poseidon-lite": "^0.2.0",
     "valibot": "^0.36.0",
-    "@mysten/bcs": "1.6.2",
-    "@mysten/utils": "0.0.1"
+    "@mysten/bcs": "1.6.3",
+    "@mysten/utils": "0.1.0"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",

package/src/client/client.ts

@@ -9,8 +9,8 @@ import type {
 	Experimental_SuiClientTypes,
 	SelfRegisteringClientExtension,
 } from '../experimental/types.js';
-import type { Transaction } from '../transactions/index.js';
-import { isTransaction } from '../transactions/index.js';
+import type { Transaction } from '../transactions/Transaction.js';
+import { isTransaction } from '../transactions/Transaction.js';
 import {
 	isValidSuiAddress,
 	isValidSuiObjectId,
@@ -101,6 +101,8 @@ import type {
 	VerifyZkLoginSignatureParams,
 	ZkLoginVerifyResult,
 } from './types/index.js';
+import { isValidNamedPackage } from '../utils/move-registry.js';
+import { hasMvrName } from '../experimental/mvr.js';
 
 export interface PaginationArguments<Cursor> {
 	/** Optional paging cursor */
@@ -119,6 +121,7 @@ export interface OrderArguments {
  */
 export type SuiClientOptions = NetworkOrTransport & {
 	network?: Experimental_SuiClientTypes.Network;
+	mvr?: Experimental_SuiClientTypes.MvrOptions;
 };
 
 type NetworkOrTransport =
@@ -140,7 +143,7 @@ export function isSuiClient(client: unknown): client is SuiClient {
 }
 
 export class SuiClient extends Experimental_BaseClient implements SelfRegisteringClientExtension {
-	core: JSONRpcTransport = new JSONRpcTransport(this);
+	core: JSONRpcTransport;
 	jsonRpc = this;
 	protected transport: SuiTransport;
 
@@ -156,6 +159,10 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	constructor(options: SuiClientOptions) {
 		super({ network: options.network ?? 'unknown' });
 		this.transport = options.transport ?? new SuiHTTPTransport({ url: options.url });
+		this.core = new JSONRpcTransport({
+			jsonRpcClient: this,
+			mvr: options.mvr,
+		});
 	}
 
 	async getRpcApiVersion({ signal }: { signal?: AbortSignal } = {}): Promise<string | undefined> {
@@ -171,15 +178,29 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	/**
 	 * Get all Coin<`coin_type`> objects owned by an address.
 	 */
-	async getCoins(input: GetCoinsParams): Promise<PaginatedCoins> {
-		if (!input.owner || !isValidSuiAddress(normalizeSuiAddress(input.owner))) {
+	async getCoins({
+		coinType,
+		owner,
+		cursor,
+		limit,
+		signal,
+	}: GetCoinsParams): Promise<PaginatedCoins> {
+		if (!owner || !isValidSuiAddress(normalizeSuiAddress(owner))) {
 			throw new Error('Invalid Sui address');
 		}
 
+		if (coinType && hasMvrName(coinType)) {
+			coinType = (
+				await this.core.mvr.resolveType({
+					type: coinType,
+				})
+			).type;
+		}
+
 		return await this.transport.request({
 			method: 'suix_getCoins',
-			params: [input.owner, input.coinType, input.cursor, input.limit],
-			signal: input.signal,
+			params: [owner, coinType, cursor, limit],
+			signal: signal,
 		});
 	}
 
@@ -201,14 +222,23 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	/**
 	 * Get the total coin balance for one coin type, owned by the address owner.
 	 */
-	async getBalance(input: GetBalanceParams): Promise<CoinBalance> {
-		if (!input.owner || !isValidSuiAddress(normalizeSuiAddress(input.owner))) {
+	async getBalance({ owner, coinType, signal }: GetBalanceParams): Promise<CoinBalance> {
+		if (!owner || !isValidSuiAddress(normalizeSuiAddress(owner))) {
 			throw new Error('Invalid Sui address');
 		}
+
+		if (coinType && hasMvrName(coinType)) {
+			coinType = (
+				await this.core.mvr.resolveType({
+					type: coinType,
+				})
+			).type;
+		}
+
 		return await this.transport.request({
 			method: 'suix_getBalance',
-			params: [input.owner, input.coinType],
-			signal: input.signal,
+			params: [owner, coinType],
+			signal: signal,
 		});
 	}
 
@@ -229,22 +259,38 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	/**
 	 * Fetch CoinMetadata for a given coin type
 	 */
-	async getCoinMetadata(input: GetCoinMetadataParams): Promise<CoinMetadata | null> {
+	async getCoinMetadata({ coinType, signal }: GetCoinMetadataParams): Promise<CoinMetadata | null> {
+		if (coinType && hasMvrName(coinType)) {
+			coinType = (
+				await this.core.mvr.resolveType({
+					type: coinType,
+				})
+			).type;
+		}
+
 		return await this.transport.request({
 			method: 'suix_getCoinMetadata',
-			params: [input.coinType],
-			signal: input.signal,
+			params: [coinType],
+			signal: signal,
 		});
 	}
 
 	/**
 	 *  Fetch total supply for a coin
 	 */
-	async getTotalSupply(input: GetTotalSupplyParams): Promise<CoinSupply> {
+	async getTotalSupply({ coinType, signal }: GetTotalSupplyParams): Promise<CoinSupply> {
+		if (coinType && hasMvrName(coinType)) {
+			coinType = (
+				await this.core.mvr.resolveType({
+					type: coinType,
+				})
+			).type;
+		}
+
 		return await this.transport.request({
 			method: 'suix_getTotalSupply',
-			params: [input.coinType],
-			signal: input.signal,
+			params: [coinType],
+			signal: signal,
 		});
 	}
 
@@ -264,13 +310,24 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	/**
 	 * Get Move function argument types like read, write and full access
 	 */
-	async getMoveFunctionArgTypes(
-		input: GetMoveFunctionArgTypesParams,
-	): Promise<SuiMoveFunctionArgType[]> {
+	async getMoveFunctionArgTypes({
+		package: pkg,
+		module,
+		function: fn,
+		signal,
+	}: GetMoveFunctionArgTypesParams): Promise<SuiMoveFunctionArgType[]> {
+		if (pkg && isValidNamedPackage(pkg)) {
+			pkg = (
+				await this.core.mvr.resolvePackage({
+					package: pkg,
+				})
+			).package;
+		}
+
 		return await this.transport.request({
 			method: 'sui_getMoveFunctionArgTypes',
-			params: [input.package, input.module, input.function],
-			signal: input.signal,
+			params: [pkg, module, fn],
+			signal: signal,
 		});
 	}
 
@@ -278,52 +335,93 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	 * Get a map from module name to
 	 * structured representations of Move modules
 	 */
-	async getNormalizedMoveModulesByPackage(
-		input: GetNormalizedMoveModulesByPackageParams,
-	): Promise<SuiMoveNormalizedModules> {
+	async getNormalizedMoveModulesByPackage({
+		package: pkg,
+		signal,
+	}: GetNormalizedMoveModulesByPackageParams): Promise<SuiMoveNormalizedModules> {
+		if (pkg && isValidNamedPackage(pkg)) {
+			pkg = (
+				await this.core.mvr.resolvePackage({
+					package: pkg,
+				})
+			).package;
+		}
+
 		return await this.transport.request({
 			method: 'sui_getNormalizedMoveModulesByPackage',
-			params: [input.package],
-			signal: input.signal,
+			params: [pkg],
+			signal: signal,
 		});
 	}
 
 	/**
 	 * Get a structured representation of Move module
 	 */
-	async getNormalizedMoveModule(
-		input: GetNormalizedMoveModuleParams,
-	): Promise<SuiMoveNormalizedModule> {
+	async getNormalizedMoveModule({
+		package: pkg,
+		module,
+		signal,
+	}: GetNormalizedMoveModuleParams): Promise<SuiMoveNormalizedModule> {
+		if (pkg && isValidNamedPackage(pkg)) {
+			pkg = (
+				await this.core.mvr.resolvePackage({
+					package: pkg,
+				})
+			).package;
+		}
+
 		return await this.transport.request({
 			method: 'sui_getNormalizedMoveModule',
-			params: [input.package, input.module],
-			signal: input.signal,
+			params: [pkg, module],
+			signal: signal,
 		});
 	}
 
 	/**
 	 * Get a structured representation of Move function
 	 */
-	async getNormalizedMoveFunction(
-		input: GetNormalizedMoveFunctionParams,
-	): Promise<SuiMoveNormalizedFunction> {
+	async getNormalizedMoveFunction({
+		package: pkg,
+		module,
+		function: fn,
+		signal,
+	}: GetNormalizedMoveFunctionParams): Promise<SuiMoveNormalizedFunction> {
+		if (pkg && isValidNamedPackage(pkg)) {
+			pkg = (
+				await this.core.mvr.resolvePackage({
+					package: pkg,
+				})
+			).package;
+		}
+
 		return await this.transport.request({
 			method: 'sui_getNormalizedMoveFunction',
-			params: [input.package, input.module, input.function],
-			signal: input.signal,
+			params: [pkg, module, fn],
+			signal: signal,
 		});
 	}
 
 	/**
 	 * Get a structured representation of Move struct
 	 */
-	async getNormalizedMoveStruct(
-		input: GetNormalizedMoveStructParams,
-	): Promise<SuiMoveNormalizedStruct> {
+	async getNormalizedMoveStruct({
+		package: pkg,
+		module,
+		struct,
+		signal,
+	}: GetNormalizedMoveStructParams): Promise<SuiMoveNormalizedStruct> {
+		if (pkg && isValidNamedPackage(pkg)) {
+			pkg = (
+				await this.core.mvr.resolvePackage({
+					package: pkg,
+				})
+			).package;
+		}
+
 		return await this.transport.request({
 			method: 'sui_getNormalizedMoveStruct',
-			params: [input.package, input.module, input.struct],
-			signal: input.signal,
+			params: [pkg, module, struct],
+			signal: signal,
 		});
 	}
 
@@ -335,12 +433,35 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 			throw new Error('Invalid Sui address');
 		}
 
+		const filter = input.filter
+			? {
+					...input.filter,
+				}
+			: undefined;
+
+		if (filter && 'MoveModule' in filter && isValidNamedPackage(filter.MoveModule.package)) {
+			filter.MoveModule = {
+				module: filter.MoveModule.module,
+				package: (
+					await this.core.mvr.resolvePackage({
+						package: filter.MoveModule.package,
+					})
+				).package,
+			};
+		} else if (filter && 'StructType' in filter && hasMvrName(filter.StructType)) {
+			filter.StructType = (
+				await this.core.mvr.resolveType({
+					type: filter.StructType,
+				})
+			).type;
+		}
+
 		return await this.transport.request({
 			method: 'suix_getOwnedObjects',
 			params: [
 				input.owner,
 				{
-					filter: input.filter,
+					filter,
 					options: input.options,
 				} as SuiObjectResponseQuery,
 				input.cursor,
@@ -396,21 +517,39 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	/**
 	 * Get transaction blocks for a given query criteria
 	 */
-	async queryTransactionBlocks(
-		input: QueryTransactionBlocksParams,
-	): Promise<PaginatedTransactionResponse> {
+	async queryTransactionBlocks({
+		filter,
+		options,
+		cursor,
+		limit,
+		order,
+		signal,
+	}: QueryTransactionBlocksParams): Promise<PaginatedTransactionResponse> {
+		if (filter && 'MoveFunction' in filter && isValidNamedPackage(filter.MoveFunction.package)) {
+			filter = {
+				...filter,
+				MoveFunction: {
+					package: (
+						await this.core.mvr.resolvePackage({
+							package: filter.MoveFunction.package,
+						})
+					).package,
+				},
+			};
+		}
+
 		return await this.transport.request({
 			method: 'suix_queryTransactionBlocks',
 			params: [
 				{
-					filter: input.filter,
-					options: input.options,
+					filter,
+					options,
 				} as SuiTransactionBlockResponseQuery,
-				input.cursor,
-				input.limit,
-				(input.order || 'descending') === 'descending',
+				cursor,
+				limit,
+				(order || 'descending') === 'descending',
 			],
-			signal: input.signal,
+			signal,
 		});
 	}
 
@@ -578,16 +717,56 @@ export class SuiClient extends Experimental_BaseClient implements SelfRegisterin
 	/**
 	 * Get events for a given query criteria
 	 */
-	async queryEvents(input: QueryEventsParams): Promise<PaginatedEvents> {
+	async queryEvents({
+		query,
+		cursor,
+		limit,
+		order,
+		signal,
+	}: QueryEventsParams): Promise<PaginatedEvents> {
+		if (query && 'MoveEventType' in query && hasMvrName(query.MoveEventType)) {
+			query = {
+				...query,
+				MoveEventType: (
+					await this.core.mvr.resolveType({
+						type: query.MoveEventType,
+					})
+				).type,
+			};
+		}
+
+		if (query && 'MoveEventModule' in query && isValidNamedPackage(query.MoveEventModule.package)) {
+			query = {
+				...query,
+				MoveEventModule: {
+					module: query.MoveEventModule.module,
+					package: (
+						await this.core.mvr.resolvePackage({
+							package: query.MoveEventModule.package,
+						})
+					).package,
+				},
+			};
+		}
+
+		if ('MoveModule' in query && isValidNamedPackage(query.MoveModule.package)) {
+			query = {
+				...query,
+				MoveModule: {
+					module: query.MoveModule.module,
+					package: (
+						await this.core.mvr.resolvePackage({
+							package: query.MoveModule.package,
+						})
+					).package,
+				},
+			};
+		}
+
 		return await this.transport.request({
 			method: 'suix_queryEvents',
-			params: [
-				input.query,
-				input.cursor,
-				input.limit,
-				(input.order || 'descending') === 'descending',
-			],
-			signal: input.signal,
+			params: [query, cursor, limit, (order || 'descending') === 'descending'],
+			signal,
 		});
 	}
 

package/src/experimental/cache.ts

@@ -41,6 +41,20 @@ export class ClientCache {
 		return result as T;
 	}
 
+	readSync<T>(key: [string, ...string[]], load: () => T): T {
+		const cacheKey = [this.#prefix, ...key].join(':');
+
+		if (this.#cache.has(cacheKey)) {
+			return this.#cache.get(cacheKey) as T;
+		}
+
+		const result = load();
+
+		this.#cache.set(cacheKey, result);
+
+		return result as T;
+	}
+
 	clear(prefix?: string[]) {
 		const prefixKey = [...this.#prefix, ...(prefix ?? [])].join(':');
 		if (!prefixKey) {

package/src/experimental/client.ts

@@ -14,9 +14,11 @@ import type {
 export abstract class Experimental_BaseClient {
 	network: Experimental_SuiClientTypes.Network;
 	cache = new ClientCache();
+	base: Experimental_BaseClient;
 
-	constructor({ network }: Experimental_SuiClientTypes.SuiClientOptions) {
+	constructor({ network, base }: Experimental_SuiClientTypes.SuiClientOptions) {
 		this.network = network;
+		this.base = base ?? this;
 	}
 
 	abstract core: Experimental_CoreClient;

package/src/experimental/core.ts

@@ -7,16 +7,34 @@ import { deriveDynamicFieldID } from '../utils/dynamic-fields.js';
 import { normalizeStructTag, parseStructTag, SUI_ADDRESS_LENGTH } from '../utils/sui-types.js';
 import { Experimental_BaseClient } from './client.js';
 import type { ClientWithExtensions, Experimental_SuiClientTypes } from './types.js';
+import { MvrClient } from './mvr.js';
 
 export type ClientWithCoreApi = ClientWithExtensions<{
 	core: Experimental_CoreClient;
 }>;
 
+export interface Experimental_CoreClientOptions
+	extends Experimental_SuiClientTypes.SuiClientOptions {
+	base: Experimental_BaseClient;
+	mvr?: Experimental_SuiClientTypes.MvrOptions;
+}
+
 export abstract class Experimental_CoreClient
 	extends Experimental_BaseClient
 	implements Experimental_SuiClientTypes.TransportMethods
 {
 	core = this;
+	mvr: Experimental_SuiClientTypes.MvrMethods;
+
+	constructor(options: Experimental_CoreClientOptions) {
+		super(options);
+		this.mvr = new MvrClient({
+			cache: this.base.cache.scope('core'),
+			url: options.mvr?.url,
+			pageSize: options.mvr?.pageSize,
+			overrides: options.mvr?.overrides,
+		});
+	}
 
 	abstract getObjects(
 		options: Experimental_SuiClientTypes.GetObjectsOptions,
@@ -93,6 +111,7 @@ export abstract class Experimental_CoreClient
 		}
 
 		const fieldType = parseStructTag(fieldObject.type);
+		const content = await fieldObject.content;
 
 		return {
 			dynamicField: {
@@ -112,7 +131,7 @@ export abstract class Experimental_CoreClient
 						typeof fieldType.typeParams[1] === 'string'
 							? fieldType.typeParams[1]
 							: normalizeStructTag(fieldType.typeParams[1]),
-					bcs: fieldObject.content.slice(SUI_ADDRESS_LENGTH + options.name.bcs.length),
+					bcs: content.slice(SUI_ADDRESS_LENGTH + options.name.bcs.length),
 				},
 			},
 		};

package/src/experimental/index.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Experimental_BaseClient } from './client.js';
-import type { ClientWithCoreApi } from './core.js';
+import type { ClientWithCoreApi, Experimental_CoreClientOptions } from './core.js';
 import { Experimental_CoreClient } from './core.js';
 import type {
 	ClientWithExtensions,
@@ -14,6 +14,7 @@ export { parseTransactionBcs, parseTransactionEffectsBcs } from './transports/ut
 export {
 	Experimental_BaseClient,
 	Experimental_CoreClient,
+	type Experimental_CoreClientOptions,
 	type ClientWithExtensions,
 	type Experimental_SuiClientTypes,
 	type SuiClientRegistration,