@typemove/sui 1.0.0-rc.19 → 1.0.0-rc.21

package/src/codegen/codegen.ts

@@ -1,4 +1,4 @@
-import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject } from '@mysten/sui.js'
+import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject } from '@mysten/sui.js/client'
 
 import * as fs from 'fs'
 import chalk from 'chalk'
@@ -35,9 +35,8 @@ class SuiCodegen extends AbstractCodegen<
   SuiMoveNormalizedModule,
   SuiEvent | SuiMoveObject
 > {
-  ADDRESS_TYPE = 'SuiAddress'
-  REFERENCE_TYPE = 'ObjectId'
-  SYSTEM_PACKAGE = '@mysten/sui.js'
+  ADDRESS_TYPE = 'string'
+  SYSTEM_PACKAGE = '@typemove/sui'
   // ADDRESS_TYPE = 'string'
   // MAIN_NET = SuiNetwork.MAIN_NET
   // TEST_NET = SuiNetwork.TEST_NET
@@ -113,12 +112,12 @@ class SuiCodegen extends AbstractCodegen<
     for (const [idx, arg] of func.params.entries()) {
       if (arg.reference) {
         args.push({
-          paramType: 'ObjectId | ObjectCallArg | TransactionArgument',
+          paramType: `${this.ADDRESS_TYPE} | ObjectCallArg | TransactionArgument`,
           callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.object(args[${idx}]))`,
         })
       } else if (arg.isVector()) {
         args.push({
-          paramType: '(ObjectId | ObjectCallArg)[] | TransactionArgument',
+          paramType: `(${this.ADDRESS_TYPE} | ObjectCallArg)[] | TransactionArgument`,
           callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.makeMoveVec({
             objects: args[${idx}].map((a: any) => tx.object(a))
             // type: TODO
@@ -149,12 +148,12 @@ class SuiCodegen extends AbstractCodegen<
     const args = this.generateArgs(module, func)
 
     return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
-      provider: JsonRpcProvider,
+      client: SuiClient,
       args: [${args.map((a) => a.paramType).join(',')}],
       ${typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``} ) {
       const tx = new TransactionBlock()
       builder.${camel(normalizeToJSName(func.name))}(tx, args ${typeParamArg.length > 0 ? `, typeArguments` : ''})
-      const res = await provider.devInspectTransactionBlock({
+      const res = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS
       })
@@ -202,7 +201,9 @@ class SuiCodegen extends AbstractCodegen<
     return `
       ${super.generateImports()}
       import { ZERO_ADDRESS } from '@typemove/sui'
-      import { TransactionBlock, TransactionArgument, ObjectCallArg, JsonRpcProvider } from '@mysten/sui.js'
+      import { TransactionBlock } from '@mysten/sui.js/transactions'
+      import { ObjectCallArg, TransactionArgument } from '@mysten/sui.js'
+      import { SuiClient } from '@mysten/sui.js/client'
     `
   }
 }

package/src/models.ts

@@ -1,23 +1,17 @@
-import type {
-  SuiEvent,
-  MoveCallSuiTransaction,
-  SuiMoveObject,
-} from '@mysten/sui.js'
+import type { SuiEvent, MoveCallSuiTransaction, SuiMoveObject } from '@mysten/sui.js/client'
 import { DecodedStruct } from '@typemove/move'
 
-export const ZERO_ADDRESS =
-  '0x0000000000000000000000000000000000000000000000000000000000000000'
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000'
 
 export type TypedEventInstance<T> = DecodedStruct<SuiEvent, T>
 export type TypedSuiMoveObject<T> = DecodedStruct<SuiMoveObject, T>
 
-export type TypedFunctionPayload<T extends Array<any>> =
-  MoveCallSuiTransaction & {
-    /**
-     * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
-     */
-    arguments_decoded: T
-  }
+export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}
 
 // export interface TypedExecutionResultType<T> extends ExecutionResultType {
 //

package/src/move-coder.ts

@@ -14,7 +14,7 @@ import {
   SuiEvent,
   SuiMoveNormalizedModule,
   SuiMoveObject,
-} from '@mysten/sui.js'
+} from '@mysten/sui.js/client'
 import { toInternalModule } from './to-internal.js'
 import { SuiChainAdapter } from './sui-chain-adapter.js'
 import { dynamic_field } from './builtin/0x2.js'
@@ -60,10 +60,7 @@ export class MoveCoder extends AbstractMoveCoder<
   decodeEvent<T>(event: SuiEvent): Promise<TypedEventInstance<T> | undefined> {
     return this.decodedStruct(event)
   }
-  filterAndDecodeEvents<T>(
-    type: TypeDescriptor<T> | string,
-    resources: SuiEvent[]
-  ): Promise<TypedEventInstance<T>[]> {
+  filterAndDecodeEvents<T>(type: TypeDescriptor<T> | string, resources: SuiEvent[]): Promise<TypedEventInstance<T>[]> {
     if (typeof type === 'string') {
       type = parseMoveType(type)
     }
@@ -77,9 +74,7 @@ export class MoveCoder extends AbstractMoveCoder<
   ): Promise<dynamic_field.Field<T1, T2>[]> {
     // const type = dynamic_field.Field.TYPE
     // Not using the code above to avoid cycle initialize failed
-    const type = new TypeDescriptor<dynamic_field.Field<T1, T2>>(
-      '0x2::dynamic_field::Field'
-    )
+    const type = new TypeDescriptor<dynamic_field.Field<T1, T2>>('0x2::dynamic_field::Field')
     type.typeArgs = [keyType, valueType]
     const res = await this.filterAndDecodeObjects(type, objects)
     return res.map((o) => o.data_decoded)
@@ -92,15 +87,8 @@ export class MoveCoder extends AbstractMoveCoder<
     return this.filterAndDecodeStruct(type, objects)
   }
 
-  async decodeFunctionPayload(
-    payload: MoveCallSuiTransaction,
-    inputs: SuiCallArg[]
-  ): Promise<MoveCallSuiTransaction> {
-    const functionType = [
-      payload.package,
-      payload.module,
-      payload.function,
-    ].join(SPLITTER)
+  async decodeFunctionPayload(payload: MoveCallSuiTransaction, inputs: SuiCallArg[]): Promise<MoveCallSuiTransaction> {
+    const functionType = [payload.package, payload.module, payload.function].join(SPLITTER)
     const func = await this.getMoveFunction(functionType)
     const params = this.adapter.getMeaningfulFunctionParams(func.params)
     const args = []
@@ -135,9 +123,7 @@ export class MoveCoder extends AbstractMoveCoder<
 const DEFAULT_ENDPOINT = 'https://fullnode.mainnet.sui.io/'
 const CODER_MAP = new Map<string, MoveCoder>()
 
-export function defaultMoveCoder(
-  endpoint: string = DEFAULT_ENDPOINT
-): MoveCoder {
+export function defaultMoveCoder(endpoint: string = DEFAULT_ENDPOINT): MoveCoder {
   let coder = CODER_MAP.get(endpoint)
   if (!coder) {
     coder = new MoveCoder(DEFAULT_ENDPOINT)

package/src/sui-chain-adapter.ts

@@ -7,14 +7,8 @@ import {
   SPLITTER,
   TypeDescriptor,
 } from '@typemove/move'
-import {
-  Connection,
-  JsonRpcProvider,
-  SuiMoveNormalizedModule,
-  SuiEvent,
-  SuiMoveObject,
-  SuiParsedData,
-} from '@mysten/sui.js'
+
+import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject, SuiClient } from '@mysten/sui.js/client'
 
 export class SuiChainAdapter extends ChainAdapter<
   // SuiNetwork,
@@ -55,9 +49,7 @@ export class SuiChainAdapter extends ChainAdapter<
     return Object.values(modules).map(toInternalModule)
   }
 
-  getAllEventStructs(
-    modules: InternalMoveModule[]
-  ): Map<string, InternalMoveStruct> {
+  getAllEventStructs(modules: InternalMoveModule[]): Map<string, InternalMoveStruct> {
     const eventMap = new Map<string, InternalMoveStruct>()
 
     for (const module of modules) {
@@ -78,10 +70,16 @@ export class SuiChainAdapter extends ChainAdapter<
   }
 
   getData(val: SuiEvent | SuiMoveObject) {
-    if (SuiEvent.is(val)) {
+    // if (val.parsedJson) {
+    //   return val.parsedJson as any
+    // }
+    if ('parsedJson' in val) {
       return val.parsedJson as any
     }
-    if (SuiParsedData.is(val)) {
+    // if (SuiParsedData.is(val)) {
+    //   return val.fields as any
+    // }
+    if (val.dataType === 'moveObject') {
       return val.fields as any
     }
     // if (SuiMoveObject.is(val)) {
@@ -108,6 +106,6 @@ export class SuiChainAdapter extends ChainAdapter<
 //   return 'https://fullnode.mainnet.sui.io/'
 // }
 
-function getRpcClient(endpoint: string): JsonRpcProvider {
-  return new JsonRpcProvider(new Connection({ fullnode: endpoint }))
+function getRpcClient(endpoint: string): SuiClient {
+  return new SuiClient({ url: endpoint })
 }

package/src/tests/types/testnet/0x1e2b124f746a339b3cf99b9f969393a96594519aafb1d06517aacfeeae20e7a5.ts

@@ -6,15 +6,11 @@
 
 import { TypeDescriptor, ANY_TYPE } from "@typemove/move";
 import { MoveCoder, defaultMoveCoder, TypedEventInstance } from "@typemove/sui";
-import { SuiAddress, ObjectId } from "@mysten/sui.js";
 
 import { ZERO_ADDRESS } from "@typemove/sui";
-import {
-  TransactionBlock,
-  TransactionArgument,
-  ObjectCallArg,
-  JsonRpcProvider,
-} from "@mysten/sui.js";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { ObjectCallArg, TransactionArgument } from "@mysten/sui.js";
+import { SuiClient } from "@mysten/sui.js/client";
 
 import { _0x2 } from "@typemove/sui/builtin";
 import { _0x1 } from "@typemove/sui/builtin";
@@ -87,9 +83,9 @@ export namespace oracle {
     export function copyKey<T0 = any>(
       tx: TransactionBlock,
       args: [
-        ObjectId | ObjectCallArg | TransactionArgument,
-        SuiAddress | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument
+        string | ObjectCallArg | TransactionArgument,
+        string | TransactionArgument,
+        string | ObjectCallArg | TransactionArgument
       ],
       typeArguments: [TypeDescriptor<T0> | string]
     ): TransactionArgument &
@@ -117,7 +113,7 @@ export namespace oracle {
     }
     export function getOracle<T0 = any>(
       tx: TransactionBlock,
-      args: [ObjectId | ObjectCallArg | TransactionArgument],
+      args: [string | ObjectCallArg | TransactionArgument],
       typeArguments: [TypeDescriptor<T0> | string]
     ): TransactionArgument & [TransactionArgument] {
       const _args: any[] = [];
@@ -141,7 +137,7 @@ export namespace oracle {
       tx: TransactionBlock,
       args: [
         bigint | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument
+        string | ObjectCallArg | TransactionArgument
       ],
       typeArguments: [TypeDescriptor<T0> | string]
     ): TransactionArgument & [TransactionArgument, TransactionArgument] {
@@ -166,12 +162,12 @@ export namespace oracle {
     export function update<T0 = any>(
       tx: TransactionBlock,
       args: [
-        ObjectId | ObjectCallArg | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument,
+        string | ObjectCallArg | TransactionArgument,
+        string | ObjectCallArg | TransactionArgument,
         bigint | TransactionArgument,
         bigint | TransactionArgument,
         bigint | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument
+        string | ObjectCallArg | TransactionArgument
       ],
       typeArguments: [TypeDescriptor<T0> | string]
     ): TransactionArgument &
@@ -212,66 +208,66 @@ export namespace oracle {
   }
   export namespace view {
     export async function copyKey<T0 = any>(
-      provider: JsonRpcProvider,
+      client: SuiClient,
       args: [
-        ObjectId | ObjectCallArg | TransactionArgument,
-        SuiAddress | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument
+        string | ObjectCallArg | TransactionArgument,
+        string | TransactionArgument,
+        string | ObjectCallArg | TransactionArgument
       ],
       typeArguments: [TypeDescriptor<T0> | string]
     ) {
       const tx = new TransactionBlock();
       builder.copyKey(tx, args, typeArguments);
-      const res = await provider.devInspectTransactionBlock({
+      const res = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
       return res;
     }
     export async function getOracle<T0 = any>(
-      provider: JsonRpcProvider,
-      args: [ObjectId | ObjectCallArg | TransactionArgument],
+      client: SuiClient,
+      args: [string | ObjectCallArg | TransactionArgument],
       typeArguments: [TypeDescriptor<T0> | string]
     ) {
       const tx = new TransactionBlock();
       builder.getOracle(tx, args, typeArguments);
-      const res = await provider.devInspectTransactionBlock({
+      const res = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
       return res;
     }
     export async function newOracle<T0 = any>(
-      provider: JsonRpcProvider,
+      client: SuiClient,
       args: [
         bigint | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument
+        string | ObjectCallArg | TransactionArgument
       ],
       typeArguments: [TypeDescriptor<T0> | string]
     ) {
       const tx = new TransactionBlock();
       builder.newOracle(tx, args, typeArguments);
-      const res = await provider.devInspectTransactionBlock({
+      const res = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
       return res;
     }
     export async function update<T0 = any>(
-      provider: JsonRpcProvider,
+      client: SuiClient,
       args: [
-        ObjectId | ObjectCallArg | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument,
+        string | ObjectCallArg | TransactionArgument,
+        string | ObjectCallArg | TransactionArgument,
         bigint | TransactionArgument,
         bigint | TransactionArgument,
         bigint | TransactionArgument,
-        ObjectId | ObjectCallArg | TransactionArgument
+        string | ObjectCallArg | TransactionArgument
       ],
       typeArguments: [TypeDescriptor<T0> | string]
     ) {
       const tx = new TransactionBlock();
       builder.update(tx, args, typeArguments);
-      const res = await provider.devInspectTransactionBlock({
+      const res = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });