Migrate suins to sdk-v2

Author: hayes-mysten

.changeset/suins-client-with-core-api.md

@@ -0,0 +1,31 @@
+---
+'@mysten/suins': major
+---
+
+Update SuinsClient to use ClientWithCoreApi for transport-agnostic client support (JSON-RPC, GraphQL, gRPC).
+
+**Breaking changes:**
+
+- `SuinsClient` now requires a client implementing `ClientWithCoreApi` instead of `SuiClient`
+- Package ID extraction now correctly uses `upgrade_cap.package` from state objects instead of object type
+
+**Migration:**
+
+```diff
+- import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
++ import { SuiJsonRpcClient, getJsonRpcFullnodeUrl } from '@mysten/sui/jsonRpc';
+  import { SuinsClient } from '@mysten/suins';
+
+- const suiClient = new SuiClient({ url: getFullnodeUrl('mainnet') });
++ const suiClient = new SuiJsonRpcClient({
++   url: getJsonRpcFullnodeUrl('mainnet'),
++   network: 'mainnet',
++ });
+
+  const suinsClient = new SuinsClient({
+    client: suiClient,
+    network: 'mainnet',
+  });
+```
+
+This change allows SuinsClient to work with any Sui client implementation (JSON-RPC, GraphQL, or gRPC).

packages/codegen/src/config.ts

@@ -5,23 +5,38 @@ import { isValidNamedPackage, isValidSuiObjectId } from '@mysten/sui/utils';
 import { cosmiconfig } from 'cosmiconfig';
 import * as z from 'zod/v4';
 
+export const moduleIncludeSchema = z.object({
+	types: z.array(z.string()).optional(),
+	functions: z.array(z.string()).optional(),
+});
+
+export const packageIncludeSchema = z.union([
+	z.array(z.string()),
+	z.record(z.string(), moduleIncludeSchema),
+]);
+
 export const onChainPackageSchema = z.object({
 	package: z.string().refine((name) => isValidNamedPackage(name) || isValidSuiObjectId(name), {
 		message: 'Invalid package name or package ID',
 	}),
 	packageName: z.string(),
 	path: z.never().optional(),
 	network: z.enum(['mainnet', 'testnet']),
+	include: packageIncludeSchema.optional(),
 });
 
 export const localPackageSchema = z.object({
 	path: z.string(),
 	package: z.string(),
 	packageName: z.string().optional(),
+	include: packageIncludeSchema.optional(),
 });
 
 export const packageConfigSchema = z.union([onChainPackageSchema, localPackageSchema]);
 
+export type ModuleInclude = z.infer<typeof moduleIncludeSchema>;
+export type PackageInclude = z.infer<typeof packageIncludeSchema>;
+
 export const importExtensionSchema = z.union([z.literal('.js'), z.literal('.ts'), z.literal('')]);
 export type ImportExtension = z.infer<typeof importExtensionSchema>;
 

packages/codegen/src/index.ts

@@ -7,7 +7,7 @@ import { MoveModuleBuilder } from './move-module-builder.js';
 import { existsSync, statSync } from 'node:fs';
 import { utilsContent } from './generate-utils.js';
 import { parse } from 'toml';
-import type { ImportExtension, PackageConfig } from './config.js';
+import type { ImportExtension, PackageConfig, PackageInclude } from './config.js';
 export { type SuiCodegenConfig } from './config.js';
 
 export async function generateFromPackageSummary({
@@ -108,11 +108,43 @@ export async function generateFromPackageSummary({
 		modules.map((mod) => [`${mod.package}::${mod.module}`, mod.builder]),
 	);
 
+	const include: PackageInclude | undefined = 'include' in pkg ? pkg.include : undefined;
+
 	modules.forEach((mod) => {
-		if (mod.isMainPackage || !prune) {
+		if (!mod.isMainPackage && prune) {
+			return;
+		}
+
+		// If include is an array, it specifies which modules to include
+		if (Array.isArray(include)) {
+			if (!include.includes(mod.module)) {
+				return;
+			}
 			mod.builder.includeAllTypes(moduleBuilders);
 			mod.builder.includeAllFunctions({ privateMethods });
+			return;
+		}
+
+		// If include is a record, it specifies types/functions per module
+		if (include && mod.module in include) {
+			const moduleInclude = include[mod.module];
+			if (moduleInclude.types) {
+				mod.builder.includeTypes(moduleInclude.types, moduleBuilders);
+			}
+			if (moduleInclude.functions) {
+				mod.builder.includeFunctions({ names: moduleInclude.functions, privateMethods });
+			}
+			return;
 		}
+
+		// If include is specified but this module isn't in it, skip
+		if (include) {
+			return;
+		}
+
+		// Default: include everything
+		mod.builder.includeAllTypes(moduleBuilders);
+		mod.builder.includeAllFunctions({ privateMethods });
 	});
 
 	await generateUtils({ outputDir });

packages/codegen/src/move-module-builder.ts

@@ -117,7 +117,27 @@ export class MoveModuleBuilder extends FileBuilder {
 	}
 
 	includeAllFunctions({ privateMethods = 'entry' }: { privateMethods?: 'none' | 'entry' | 'all' }) {
-		for (const [name, func] of Object.entries(this.summary.functions)) {
+		this.includeFunctions({
+			names: Object.keys(this.summary.functions),
+			privateMethods,
+		});
+	}
+
+	includeFunctions({
+		names,
+		privateMethods = 'entry',
+	}: {
+		names: string[];
+		privateMethods?: 'none' | 'entry' | 'all';
+	}) {
+		for (const name of names) {
+			const func = this.summary.functions[name];
+			if (!func) {
+				throw new Error(
+					`Function ${name} not found in ${this.summary.id.address}::${this.summary.id.name}`,
+				);
+			}
+
 			if (func.macro_) {
 				continue;
 			}
@@ -212,9 +232,17 @@ export class MoveModuleBuilder extends FileBuilder {
 		this.#orderedTypes.push(name);
 	}
 
+	includeTypes(names: string[], moduleBuilders: Record<string, MoveModuleBuilder>) {
+		for (const name of names) {
+			this.includeType(name, moduleBuilders);
+		}
+	}
+
 	includeAllTypes(moduleBuilders: Record<string, MoveModuleBuilder>) {
-		Object.keys(this.summary.structs).forEach((name) => this.includeType(name, moduleBuilders));
-		Object.keys(this.summary.enums).forEach((name) => this.includeType(name, moduleBuilders));
+		this.includeTypes(
+			[...Object.keys(this.summary.structs), ...Object.keys(this.summary.enums)],
+			moduleBuilders,
+		);
 	}
 
 	async renderBCSTypes() {

packages/docs/content/sui/migrations/sui-2.0.mdx

@@ -387,3 +387,51 @@ If you were using the plugin with `@mysten/mvr-static`:
 
 The client will now automatically resolve `.move` names in transactions using the configured
 overrides or by querying the MVR API if no override is provided.
+
+## @mysten/suins: ClientWithCoreApi Support
+
+The `@mysten/suins` package now uses the transport-agnostic `ClientWithCoreApi` interface, allowing
+it to work with any Sui client implementation (JSON-RPC, GraphQL, or gRPC).
+
+**Breaking changes:**
+
+- `SuinsClient` now requires a client implementing `ClientWithCoreApi` instead of `SuiClient`
+- Internal package ID resolution now correctly extracts `upgrade_cap.package` from state objects
+
+**Migration:**
+
+Update your imports and client initialization:
+
+```diff
+- import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
++ import { SuiJsonRpcClient, getJsonRpcFullnodeUrl } from '@mysten/sui/jsonRpc';
+  import { SuinsClient } from '@mysten/suins';
+
+- const suiClient = new SuiClient({ url: getFullnodeUrl('mainnet') });
++ const suiClient = new SuiJsonRpcClient({
++   url: getJsonRpcFullnodeUrl('mainnet'),
++   network: 'mainnet',
++ });
+
+  const suinsClient = new SuinsClient({
+    client: suiClient,
+    network: 'mainnet',
+  });
+```
+
+You can also use GraphQL or gRPC clients:
+
+```ts
+import { SuiGraphQLClient } from '@mysten/sui/graphql';
+import { SuinsClient } from '@mysten/suins';
+
+const graphqlClient = new SuiGraphQLClient({
+	url: 'https://sui-mainnet.mystenlabs.com/graphql',
+	network: 'mainnet',
+});
+
+const suinsClient = new SuinsClient({
+	client: graphqlClient,
+	network: 'mainnet',
+});
+```

packages/sui/src/client/core.ts

@@ -8,6 +8,7 @@ import { normalizeStructTag, parseStructTag, SUI_ADDRESS_LENGTH } from '../utils
 import { BaseClient } from './client.js';
 import type { ClientWithExtensions, SuiClientTypes } from './types.js';
 import { MvrClient } from './mvr.js';
+import { bcs } from '../bcs/index.js';
 
 export type ClientWithCoreApi = ClientWithExtensions<{
 	core: CoreClient;
@@ -163,6 +164,34 @@ export abstract class CoreClient extends BaseClient implements SuiClientTypes.Tr
 		};
 	}
 
+	async getDynamicObjectField<Include extends SuiClientTypes.ObjectInclude = object>(
+		options: SuiClientTypes.GetDynamicObjectFieldOptions<Include>,
+	): Promise<SuiClientTypes.GetDynamicObjectFieldResponse<Include>> {
+		const resolvedNameType = (
+			await this.core.mvr.resolveType({
+				type: options.name.type,
+			})
+		).type;
+		const wrappedType = `0x2::dynamic_object_field::Wrapper<${resolvedNameType}>`;
+
+		const { dynamicField } = await this.getDynamicField({
+			parentId: options.parentId,
+			name: {
+				type: wrappedType,
+				bcs: options.name.bcs,
+			},
+			signal: options.signal,
+		});
+
+		const { object } = await this.getObject({
+			objectId: bcs.Address.parse(dynamicField.value.bcs),
+			signal: options.signal,
+			include: options.include,
+		});
+
+		return { object };
+	}
+
 	async waitForTransaction<Include extends SuiClientTypes.TransactionInclude = object>(
 		options: SuiClientTypes.WaitForTransactionOptions<Include>,
 	): Promise<SuiClientTypes.TransactionResult<Include>> {

packages/sui/src/client/types.ts

@@ -168,6 +168,18 @@ export namespace SuiClientTypes {
 		};
 	}
 
+	export interface GetDynamicObjectFieldOptions<
+		Include extends ObjectInclude = {},
+	> extends CoreClientMethodOptions {
+		parentId: string;
+		name: DynamicFieldName;
+		include?: Include;
+	}
+
+	export interface GetDynamicObjectFieldResponse<out Include extends ObjectInclude = {}> {
+		object: Object<Include>;
+	}
+
 	export interface DynamicFieldName {
 		type: string;
 		bcs: Uint8Array;

packages/suins/package.json

@@ -26,6 +26,7 @@
 		"src"
 	],
 	"scripts": {
+		"codegen": "sui-ts-codegen generate && pnpm lint:fix",
 		"clean": "rm -rf tsconfig.tsbuildinfo ./dist",
 		"build": "rm -rf dist && tsc --noEmit && tsdown",
 		"prettier:check": "prettier -c --ignore-unknown .",
@@ -45,6 +46,7 @@
 		"axios-retry": "^4.5.0"
 	},
 	"devDependencies": {
+		"@mysten/codegen": "workspace:*",
 		"@types/tmp": "^0.2.6",
 		"ts-retry-promise": "^0.8.1",
 		"typescript": "^5.9.3",

packages/suins/src/contracts/pyth/data_source.ts

@@ -0,0 +1,15 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import * as external_address from './deps/0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94/external_address.js';
+const $moduleName =
+	'0xabf837e98c26087cba0883c0a7a28326b1fa3c5e1e2c5abdb486f9e8f594c837::data_source';
+export const DataSource = new MoveStruct({
+	name: `${$moduleName}::DataSource`,
+	fields: {
+		emitter_chain: bcs.u64(),
+		emitter_address: external_address.ExternalAddress,
+	},
+});

packages/suins/src/contracts/pyth/deps/0x0000000000000000000000000000000000000000000000000000000000000002/object.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::object';
+export const UID = new MoveStruct({
+	name: `${$moduleName}::UID`,
+	fields: {
+		id: bcs.Address,
+	},
+});