@typemove/sui 1.2.0-rc.2 → 1.2.0-rc.3

package/src/codegen/codegen.ts

@@ -1,4 +1,4 @@
-import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject } from '@mysten/sui.js/client'
+import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject, SuiClient } from '@mysten/sui.js/client'
 
 import * as fs from 'fs'
 import chalk from 'chalk'
@@ -10,7 +10,7 @@ import {
   InternalMoveFunction,
   InternalMoveFunctionVisibility,
   normalizeToJSName,
-  camel,
+  camel
 } from '@typemove/move'
 import { join } from 'path'
 import { SuiChainAdapter } from '../sui-chain-adapter.js'
@@ -46,7 +46,7 @@ export class SuiCodegen extends AbstractCodegen<
   PAYLOAD_OPTIONAL = true
 
   constructor(endpoint: string) {
-    super(new SuiChainAdapter(endpoint))
+    super(new SuiChainAdapter(new SuiClient({ url: endpoint })))
   }
 
   readModulesFile(fullPath: string) {
@@ -113,7 +113,7 @@ export class SuiCodegen extends AbstractCodegen<
       if (arg.reference) {
         args.push({
           paramType: `${this.ADDRESS_TYPE} | ObjectCallArg | TransactionArgument`,
-          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.object(args[${idx}]))`,
+          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.object(args[${idx}]))`
         })
       } else if (arg.isVector()) {
         args.push({
@@ -121,12 +121,12 @@ export class SuiCodegen extends AbstractCodegen<
           callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.makeMoveVec({
             objects: args[${idx}].map((a: any) => tx.object(a))
             // type: TODO
-          }))`,
+          }))`
         })
       } else {
         args.push({
           paramType: `${this.generateTypeForDescriptor(arg, module.address)} | TransactionArgument`,
-          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.pure(args[${idx}]))`,
+          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.pure(args[${idx}]))`
         })
       }
     }
@@ -146,18 +146,22 @@ export class SuiCodegen extends AbstractCodegen<
       .join(',')
 
     const args = this.generateArgs(module, func)
+    const returnType = `${this.generateFunctionReturnTypeParameters(func, module.address)}`
 
     return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
       client: SuiClient,
       args: [${args.map((a) => a.paramType).join(',')}],
-      ${typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``} ) {
+      ${
+        typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``
+      } ): Promise<TypedDevInspectResults<${returnType}>> {
       const tx = new TransactionBlock()
       builder.${camel(normalizeToJSName(func.name))}(tx, args ${typeParamArg.length > 0 ? `, typeArguments` : ''})
-      const res = await client.devInspectTransactionBlock({
+      const insepctRes = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS
       })
-      return res
+      
+      return (await getMoveCoder(client)).decodeDevInspectResult<${returnType}>(insepctRes)
     }`
   }
 
@@ -200,7 +204,7 @@ export class SuiCodegen extends AbstractCodegen<
   generateImports(): string {
     return `
       ${super.generateImports()}
-      import { ZERO_ADDRESS } from '@typemove/sui'
+      import { ZERO_ADDRESS, TypedDevInspectResults, getMoveCoder } from '@typemove/sui'
       import { TransactionBlock } from '@mysten/sui.js/transactions'
       import { ObjectCallArg, TransactionArgument } from '@mysten/sui.js'
       import { SuiClient } from '@mysten/sui.js/client'

package/src/index.ts

@@ -1,3 +1,3 @@
 export * from './models.js'
 
-export { MoveCoder, defaultMoveCoder } from './move-coder.js'
+export { MoveCoder, defaultMoveCoder, getMoveCoder } from './move-coder.js'

package/src/models.ts

@@ -1,4 +1,4 @@
-import type { SuiEvent, MoveCallSuiTransaction, SuiMoveObject } from '@mysten/sui.js/client'
+import type { SuiEvent, MoveCallSuiTransaction, SuiMoveObject, DevInspectResults } from '@mysten/sui.js/client'
 import { DecodedStruct } from '@typemove/move'
 
 export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000'
@@ -13,6 +13,9 @@ export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction
   arguments_decoded: T
 }
 
-// export interface TypedExecutionResultType<T> extends ExecutionResultType {
-//
-// }
+export type TypedDevInspectResults<T extends Array<any>> = DevInspectResults & {
+  /**
+   * Decoded return values using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  results_decoded?: T
+}

package/src/move-coder.ts

@@ -1,4 +1,4 @@
-import { TypedEventInstance, TypedFunctionPayload } from './models.js'
+import { TypedDevInspectResults, TypedEventInstance, TypedFunctionPayload } from './models.js'
 import {
   AbstractMoveCoder,
   ANY_TYPE,
@@ -13,7 +13,9 @@ import {
   SuiCallArg,
   SuiEvent,
   SuiMoveNormalizedModule,
-  SuiMoveObject
+  SuiMoveObject,
+  DevInspectResults,
+  SuiClient
 } from '@mysten/sui.js/client'
 import { toInternalModule } from './to-internal.js'
 import { SuiChainAdapter } from './sui-chain-adapter.js'
@@ -28,8 +30,8 @@ export class MoveCoder extends AbstractMoveCoder<
 > {
   bcs = new BCS(getSuiMoveConfig())
 
-  constructor(network: string) {
-    super(new SuiChainAdapter(network))
+  constructor(client: SuiClient) {
+    super(new SuiChainAdapter(client))
   }
 
   load(module: SuiMoveNormalizedModule): InternalMoveModule {
@@ -193,8 +195,15 @@ export class MoveCoder extends AbstractMoveCoder<
     }
   }
 
+  private bcsRegistered = new Set<string>()
+
   async registerBCSTypes(type: TypeDescriptor): Promise<void> {
-    // TODO maybe can we get rid of this
+    const sig = type.getNormalizedSignature()
+    if (this.bcsRegistered.has(sig)) {
+      return
+    }
+    this.bcsRegistered.add(sig)
+
     await this._registerBCSType('0x1::string::String')
 
     for (const typeArg of type.dependedTypes()) {
@@ -206,16 +215,58 @@ export class MoveCoder extends AbstractMoveCoder<
     await this.registerBCSTypes(type)
     return this.bcs.de(type.getNormalizedSignature(), data, encoding)
   }
+
+  async decodeDevInspectResult<T extends any[]>(insepctRes: DevInspectResults): Promise<TypedDevInspectResults<T>> {
+    const returnValues = []
+    if (insepctRes.results != null) {
+      for (const r of insepctRes.results) {
+        if (r.returnValues) {
+          const type = parseMoveType(r.returnValues[0][1])
+          const value = r.returnValues[0][0]
+          const bcsDecoded = await this.decodeBCS(type, new Uint8Array(value))
+          const decoded = await this.decodedType(bcsDecoded, type)
+          returnValues.push(decoded)
+        } else {
+          returnValues.push(null)
+        }
+      }
+    }
+    return { ...insepctRes, results_decoded: returnValues as any }
+  }
 }
 
 const DEFAULT_ENDPOINT = 'https://fullnode.mainnet.sui.io/'
 const CODER_MAP = new Map<string, MoveCoder>()
+const CHAIN_ID_CODER_MAP = new Map<string, MoveCoder>()
 
 export function defaultMoveCoder(endpoint: string = DEFAULT_ENDPOINT): MoveCoder {
   let coder = CODER_MAP.get(endpoint)
   if (!coder) {
-    coder = new MoveCoder(DEFAULT_ENDPOINT)
+    coder = new MoveCoder(new SuiClient({ url: DEFAULT_ENDPOINT }))
     CODER_MAP.set(endpoint, coder)
   }
   return coder
 }
+
+const PROVIDER_CODER_MAP = new Map<SuiClient, MoveCoder>()
+
+let DEFAULT_CHAIN_ID: string | undefined
+
+export async function getMoveCoder(client: SuiClient): Promise<MoveCoder> {
+  let coder = PROVIDER_CODER_MAP.get(client)
+  if (!coder) {
+    coder = new MoveCoder(client)
+    // TODO how to dedup
+    const id = await client.getChainIdentifier()
+    const defaultCoder = defaultMoveCoder()
+    if (!DEFAULT_CHAIN_ID) {
+      DEFAULT_CHAIN_ID = await defaultCoder.adapter.getChainId()
+    }
+    if (id === DEFAULT_CHAIN_ID) {
+      coder = defaultCoder
+    }
+
+    PROVIDER_CODER_MAP.set(client, coder)
+  }
+  return coder
+}

package/src/sui-chain-adapter.ts

@@ -15,23 +15,30 @@ export class SuiChainAdapter extends ChainAdapter<
   SuiMoveNormalizedModule,
   SuiEvent | SuiMoveObject
 > {
+  async getChainId() {
+    return this.client.getChainIdentifier()
+  }
   // static INSTANCE = new SuiChainAdapter()
 
+  client: SuiClient
+  constructor(client: SuiClient) {
+    super()
+    this.client = client
+  }
+
   async fetchModule(
     account: string,
     module: string
     // network: SuiNetwork
   ): Promise<SuiMoveNormalizedModule> {
-    const client = getRpcClient(this.endpoint)
-    return await client.getNormalizedMoveModule({ package: account, module })
+    return await this.client.getNormalizedMoveModule({ package: account, module })
   }
 
   async fetchModules(
     account: string
     // network: SuiNetwork
   ): Promise<SuiMoveNormalizedModule[]> {
-    const client = getRpcClient(this.endpoint)
-    const modules = await client.getNormalizedMoveModulesByPackage({
+    const modules = await this.client.getNormalizedMoveModulesByPackage({
       package: account
     })
     return Object.values(modules)

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

@@ -9,7 +9,11 @@ import { MoveCoder, TypedEventInstance } from "@typemove/sui";
 
 import { defaultMoveCoder } from "@typemove/sui";
 
-import { ZERO_ADDRESS } from "@typemove/sui";
+import {
+  ZERO_ADDRESS,
+  TypedDevInspectResults,
+  getMoveCoder,
+} from "@typemove/sui";
 import { TransactionBlock } from "@mysten/sui.js/transactions";
 import { ObjectCallArg, TransactionArgument } from "@mysten/sui.js";
 import { SuiClient } from "@mysten/sui.js/client";
@@ -217,27 +221,33 @@ export namespace oracle {
         string | ObjectCallArg | TransactionArgument,
       ],
       typeArguments: [TypeDescriptor<T0> | string],
-    ) {
+    ): Promise<TypedDevInspectResults<[]>> {
       const tx = new TransactionBlock();
       builder.copyKey(tx, args, typeArguments);
-      const res = await client.devInspectTransactionBlock({
+      const insepctRes = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
-      return res;
+
+      return (await getMoveCoder(client)).decodeDevInspectResult<[]>(
+        insepctRes,
+      );
     }
     export async function getOracle<T0 = any>(
       client: SuiClient,
       args: [string | ObjectCallArg | TransactionArgument],
       typeArguments: [TypeDescriptor<T0> | string],
-    ) {
+    ): Promise<TypedDevInspectResults<[bigint, bigint, bigint, bigint]>> {
       const tx = new TransactionBlock();
       builder.getOracle(tx, args, typeArguments);
-      const res = await client.devInspectTransactionBlock({
+      const insepctRes = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
-      return res;
+
+      return (await getMoveCoder(client)).decodeDevInspectResult<
+        [bigint, bigint, bigint, bigint]
+      >(insepctRes);
     }
     export async function newOracle<T0 = any>(
       client: SuiClient,
@@ -246,14 +256,17 @@ export namespace oracle {
         string | ObjectCallArg | TransactionArgument,
       ],
       typeArguments: [TypeDescriptor<T0> | string],
-    ) {
+    ): Promise<TypedDevInspectResults<[]>> {
       const tx = new TransactionBlock();
       builder.newOracle(tx, args, typeArguments);
-      const res = await client.devInspectTransactionBlock({
+      const insepctRes = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
-      return res;
+
+      return (await getMoveCoder(client)).decodeDevInspectResult<[]>(
+        insepctRes,
+      );
     }
     export async function update<T0 = any>(
       client: SuiClient,
@@ -266,14 +279,17 @@ export namespace oracle {
         string | ObjectCallArg | TransactionArgument,
       ],
       typeArguments: [TypeDescriptor<T0> | string],
-    ) {
+    ): Promise<TypedDevInspectResults<[]>> {
       const tx = new TransactionBlock();
       builder.update(tx, args, typeArguments);
-      const res = await client.devInspectTransactionBlock({
+      const insepctRes = await client.devInspectTransactionBlock({
         transactionBlock: tx,
         sender: ZERO_ADDRESS,
       });
-      return res;
+
+      return (await getMoveCoder(client)).decodeDevInspectResult<[]>(
+        insepctRes,
+      );
     }
   }
 }