@mysten/sui 1.25.0 → 1.26.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.25.0",
+  "version": "1.26.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [

package/src/client/client.ts

@@ -3,6 +3,12 @@
 import { fromBase58, toBase64, toHex } from '@mysten/bcs';
 
 import type { Signer } from '../cryptography/index.js';
+import { Experimental_SuiClient } from '../experimental/client.js';
+import { JSONRpcTransport } from '../experimental/transports/jsonRPC.js';
+import type {
+	Experimental_SuiClientTypes,
+	SelfRegisteringClientExtension,
+} from '../experimental/types.js';
 import type { Transaction } from '../transactions/index.js';
 import { isTransaction } from '../transactions/index.js';
 import {
@@ -106,7 +112,9 @@ export interface OrderArguments {
  * Configuration options for the SuiClient
  * You must provide either a `url` or a `transport`
  */
-export type SuiClientOptions = NetworkOrTransport;
+export type SuiClientOptions = NetworkOrTransport & {
+	network?: Experimental_SuiClientTypes.Network;
+};
 
 type NetworkOrTransport =
 	| {
@@ -126,7 +134,8 @@ export function isSuiClient(client: unknown): client is SuiClient {
 	);
 }
 
-export class SuiClient {
+export class SuiClient extends Experimental_SuiClient implements SelfRegisteringClientExtension {
+	core: JSONRpcTransport = new JSONRpcTransport(this);
 	protected transport: SuiTransport;
 
 	get [SUI_CLIENT_BRAND]() {
@@ -139,6 +148,7 @@ export class SuiClient {
 	 * @param options configuration options for the API Client
 	 */
 	constructor(options: SuiClientOptions) {
+		super({ network: options.network ?? 'unknown' });
 		this.transport = options.transport ?? new SuiHTTPTransport({ url: options.url });
 	}
 
@@ -826,4 +836,13 @@ export class SuiClient {
 		// This should never happen, because the above case should always throw, but just adding it in the event that something goes horribly wrong.
 		throw new Error('Unexpected error while waiting for transaction block.');
 	}
+
+	experimental_asClientExtension(this: SuiClient) {
+		return {
+			name: 'jsonRPC',
+			register: () => {
+				return this;
+			},
+		} as const;
+	}
 }

package/src/experimental/client.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+/* eslint-disable @typescript-eslint/ban-types */
+
+import type { Experimental_CoreClient } from './core.js';
+import type {
+	ClientWithExtensions,
+	Experimental_SuiClientTypes,
+	Simplify,
+	SuiClientRegistration,
+	UnionToIntersection,
+} from './types.js';
+
+export abstract class Experimental_SuiClient {
+	network: Experimental_SuiClientTypes.Network;
+
+	constructor({ network }: Experimental_SuiClientTypes.SuiClientOptions) {
+		this.network = network;
+	}
+
+	abstract core: Experimental_CoreClient;
+
+	$extend<const Registrations extends SuiClientRegistration<this>[]>(
+		...registrations: Registrations
+	) {
+		return Object.create(
+			this,
+			Object.fromEntries(
+				registrations.map((registration) => {
+					if ('experimental_asClientExtension' in registration) {
+						const { name, register } = registration.experimental_asClientExtension();
+						return [name, { value: register(this) }];
+					}
+					return [registration.name, { value: registration.register(this) }];
+				}),
+			),
+		) as ClientWithExtensions<
+			Simplify<
+				Omit<
+					{
+						[K in keyof this]: this[K];
+					},
+					keyof Experimental_SuiClient
+				> &
+					UnionToIntersection<
+						{
+							[K in keyof Registrations]: Registrations[K] extends SuiClientRegistration<
+								this,
+								infer Name extends string,
+								infer Extension
+							>
+								? {
+										[K2 in Name]: Extension;
+									}
+								: never;
+						}[number]
+					>
+			>
+		>;
+	}
+}

package/src/experimental/core.ts

@@ -0,0 +1,46 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Experimental_SuiClient } from './client.js';
+import type { Experimental_SuiClientTypes } from './types.js';
+
+export abstract class Experimental_CoreClient
+	extends Experimental_SuiClient
+	implements Experimental_SuiClientTypes.TransportMethods
+{
+	core = this;
+
+	abstract getObjects(
+		options: Experimental_SuiClientTypes.GetObjectsOptions,
+	): Promise<Experimental_SuiClientTypes.GetObjectsResponse>;
+
+	abstract getCoins(
+		options: Experimental_SuiClientTypes.GetCoinsOptions,
+	): Promise<Experimental_SuiClientTypes.GetCoinsResponse>;
+
+	abstract getOwnedObjects(
+		options: Experimental_SuiClientTypes.GetOwnedObjectsOptions,
+	): Promise<Experimental_SuiClientTypes.GetOwnedObjectsResponse>;
+
+	abstract getBalance(
+		options: Experimental_SuiClientTypes.GetBalanceOptions,
+	): Promise<Experimental_SuiClientTypes.GetBalanceResponse>;
+
+	abstract getAllBalances(
+		options: Experimental_SuiClientTypes.GetAllBalancesOptions,
+	): Promise<Experimental_SuiClientTypes.GetAllBalancesResponse>;
+
+	abstract getTransaction(
+		options: Experimental_SuiClientTypes.GetTransactionOptions,
+	): Promise<Experimental_SuiClientTypes.GetTransactionResponse>;
+
+	abstract executeTransaction(
+		options: Experimental_SuiClientTypes.ExecuteTransactionOptions,
+	): Promise<Experimental_SuiClientTypes.ExecuteTransactionResponse>;
+
+	abstract dryRunTransaction(
+		options: Experimental_SuiClientTypes.DryRunTransactionOptions,
+	): Promise<Experimental_SuiClientTypes.DryRunTransactionResponse>;
+
+	abstract getReferenceGasPrice(): Promise<Experimental_SuiClientTypes.GetReferenceGasPriceResponse>;
+}

package/src/experimental/errors.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ObjectResponseError } from '../client/index.js';
+
+export class SuiClientError extends Error {}
+
+export class ObjectError extends SuiClientError {
+	code: string;
+
+	constructor(code: string, message: string) {
+		super(message);
+		this.code = code;
+	}
+
+	static fromResponse(response: ObjectResponseError, objectId?: string): ObjectError {
+		switch (response.code) {
+			case 'notExists':
+				return new ObjectError(response.code, `Object ${response.object_id} does not exist`);
+			case 'dynamicFieldNotFound':
+				return new ObjectError(
+					response.code,
+					`Dynamic field not found for object ${response.parent_object_id}`,
+				);
+			case 'deleted':
+				return new ObjectError(response.code, `Object ${response.object_id} has been deleted`);
+			case 'displayError':
+				return new ObjectError(response.code, `Display error: ${response.error}`);
+			case 'unknown':
+			default:
+				return new ObjectError(
+					response.code,
+					`Unknown error while loading object${objectId ? ` ${objectId}` : ''}`,
+				);
+		}
+	}
+}

package/src/experimental/transports/jsonRPC.ts

@@ -0,0 +1,263 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { fromBase64 } from '@mysten/bcs';
+
+import { bcs } from '../../bcs/index.js';
+import type {
+	ObjectOwner,
+	SuiClient,
+	SuiObjectData,
+	SuiTransactionBlockResponse,
+} from '../../client/index.js';
+import { batch } from '../../transactions/plugins/utils.js';
+import { Transaction } from '../../transactions/Transaction.js';
+import { Experimental_CoreClient } from '../core.js';
+import { ObjectError } from '../errors.js';
+import type { Experimental_SuiClientTypes } from '../types.js';
+
+export class JSONRpcTransport extends Experimental_CoreClient {
+	#jsonRpcClient: SuiClient;
+
+	constructor(jsonRpcClient: SuiClient) {
+		super({ network: jsonRpcClient.network });
+		this.#jsonRpcClient = jsonRpcClient;
+	}
+
+	async getObjects(options: Experimental_SuiClientTypes.GetObjectsOptions) {
+		const batches = batch(options.objectIds, 50);
+		const results: Experimental_SuiClientTypes.GetObjectsResponse['objects'] = [];
+
+		for (const batch of batches) {
+			const objects = await this.#jsonRpcClient.multiGetObjects({
+				ids: batch,
+				options: {
+					showOwner: true,
+					showType: true,
+				},
+			});
+
+			for (const [idx, object] of objects.entries()) {
+				if (object.error) {
+					results.push(ObjectError.fromResponse(object.error, batch[idx]));
+				} else {
+					results.push(parseObject(object.data!));
+				}
+			}
+		}
+
+		return {
+			objects: results,
+		};
+	}
+	async getOwnedObjects(options: Experimental_SuiClientTypes.GetOwnedObjectsOptions) {
+		const objects = await this.#jsonRpcClient.getOwnedObjects({
+			owner: options.address,
+			limit: options.limit,
+			cursor: options.cursor,
+		});
+
+		return {
+			objects: objects.data.map((result) => {
+				if (result.error) {
+					throw ObjectError.fromResponse(result.error);
+				}
+
+				return parseObject(result.data!);
+			}),
+			hasNextPage: objects.hasNextPage,
+			cursor: objects.nextCursor ?? null,
+		};
+	}
+
+	async getCoins(options: Experimental_SuiClientTypes.GetCoinsOptions) {
+		const coins = await this.#jsonRpcClient.getCoins({
+			owner: options.address,
+			coinType: options.coinType,
+		});
+
+		return {
+			objects: coins.data.map((coin) => {
+				return {
+					id: coin.coinObjectId,
+					version: coin.version,
+					digest: coin.digest,
+					balance: BigInt(coin.balance),
+					type: `0x2::coin::Coin<${coin.coinType}>`,
+					content: Coin.serialize({
+						id: coin.coinObjectId,
+						balance: {
+							value: coin.balance,
+						},
+					}).toBytes(),
+					owner: {
+						$kind: 'ObjectOwner' as const,
+						ObjectOwner: options.address,
+					},
+				};
+			}),
+			hasNextPage: coins.hasNextPage,
+			cursor: coins.nextCursor ?? null,
+		};
+	}
+
+	async getBalance(options: Experimental_SuiClientTypes.GetBalanceOptions) {
+		const balance = await this.#jsonRpcClient.getBalance({
+			owner: options.address,
+			coinType: options.coinType,
+		});
+
+		return {
+			balance: {
+				coinType: balance.coinType,
+				balance: BigInt(balance.totalBalance),
+			},
+		};
+	}
+	async getAllBalances(options: Experimental_SuiClientTypes.GetAllBalancesOptions) {
+		const balances = await this.#jsonRpcClient.getAllBalances({
+			owner: options.address,
+		});
+
+		return {
+			balances: balances.map((balance) => ({
+				coinType: balance.coinType,
+				balance: BigInt(balance.totalBalance),
+			})),
+			hasNextPage: false,
+			cursor: null,
+		};
+	}
+	async getTransaction(options: Experimental_SuiClientTypes.GetTransactionOptions) {
+		const transaction = await this.#jsonRpcClient.getTransactionBlock({
+			digest: options.digest,
+			options: {
+				showRawInput: true,
+				showObjectChanges: true,
+				showRawEffects: true,
+				showEvents: true,
+			},
+		});
+
+		return {
+			transaction: parseTransaction(transaction),
+		};
+	}
+	async executeTransaction(options: Experimental_SuiClientTypes.ExecuteTransactionOptions) {
+		const transaction = await this.#jsonRpcClient.executeTransactionBlock({
+			transactionBlock: options.transaction,
+			signature: options.signatures,
+			options: {
+				showEffects: true,
+				showEvents: true,
+			},
+		});
+
+		return {
+			transaction: parseTransaction(transaction),
+		};
+	}
+	async dryRunTransaction(options: Experimental_SuiClientTypes.DryRunTransactionOptions) {
+		const tx = Transaction.from(options.transaction);
+		const result = await this.#jsonRpcClient.dryRunTransactionBlock({
+			transactionBlock: options.transaction,
+		});
+
+		return {
+			transaction: {
+				digest: await tx.getDigest(),
+				// TODO: Effects aren't returned as bcs from dryRun, once we define structured effects we can return those instead
+				effects: result.effects as never,
+				signatures: [],
+				bcs: options.transaction,
+			},
+		};
+	}
+	async getReferenceGasPrice() {
+		const referenceGasPrice = await this.#jsonRpcClient.getReferenceGasPrice();
+		return {
+			referenceGasPrice,
+		};
+	}
+}
+
+function parseObject(object: SuiObjectData): Experimental_SuiClientTypes.ObjectResponse {
+	return {
+		id: object.objectId,
+		version: object.version,
+		digest: object.digest,
+		type: object.type!,
+		content:
+			object.bcs?.dataType === 'moveObject' ? fromBase64(object.bcs.bcsBytes) : new Uint8Array(),
+		owner: parseOwner(object.owner!),
+	};
+}
+
+function parseOwner(owner: ObjectOwner): Experimental_SuiClientTypes.ObjectOwner {
+	if (owner === 'Immutable') {
+		return {
+			$kind: 'Immutable',
+			Immutable: true,
+		};
+	}
+
+	if ('ConsensusV2' in owner) {
+		return {
+			$kind: 'ConsensusV2',
+			ConsensusV2Owner: {
+				authenticator: {
+					$kind: 'SingleOwner',
+					SingleOwner: owner.ConsensusV2.authenticator.SingleOwner,
+				},
+				startVersion: owner.ConsensusV2.start_version,
+			},
+		};
+	}
+
+	if ('AddressOwner' in owner) {
+		return {
+			$kind: 'AddressOwner',
+			AddressOwner: owner.AddressOwner,
+		};
+	}
+
+	if ('ObjectOwner' in owner) {
+		return {
+			$kind: 'ObjectOwner',
+			ObjectOwner: owner.ObjectOwner,
+		};
+	}
+
+	if ('Shared' in owner) {
+		return {
+			$kind: 'Shared',
+			Shared: {
+				initialSharedVersion: owner.Shared.initial_shared_version,
+			},
+		};
+	}
+
+	throw new Error(`Unknown owner type: ${JSON.stringify(owner)}`);
+}
+
+function parseTransaction(
+	transaction: SuiTransactionBlockResponse,
+): Experimental_SuiClientTypes.TransactionResponse {
+	const parsedTx = bcs.SenderSignedData.parse(fromBase64(transaction.rawTransaction!))[0];
+
+	return {
+		digest: transaction.digest,
+		effects: new Uint8Array(transaction.rawEffects!),
+		bcs: bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes(),
+		signatures: parsedTx.txSignatures,
+	};
+}
+
+const Balance = bcs.struct('Balance', {
+	value: bcs.u64(),
+});
+
+const Coin = bcs.struct('Coin', {
+	id: bcs.Address,
+	balance: Balance,
+});