@0xobelisk/client 0.0.1 → 0.0.3

package/src/framework/loader.ts

@@ -0,0 +1,152 @@
+
+import { FieldsWithTypes, Type, parseTypeName } from './util'
+
+export type PrimitiveValue = string | number | boolean | bigint
+
+export class StructClassLoader {
+  private map: Map<
+    string,
+    {
+      numTypeParams: number
+      fromFields: (fields: Record<string, any>, typeArgs?: Type[]) => any
+      fromFieldsWithTypes: (item: FieldsWithTypes) => any
+    }
+  > = new Map()
+
+  register(...classes: any) {
+    for (const cls of classes) {
+      if (
+        '$typeName' in cls === false ||
+        '$numTypeParams' in cls === false ||
+        'fromFields' in cls === false ||
+        'fromFieldsWithTypes' in cls === false
+      ) {
+        throw new Error(`class ${cls.name} is not a valid struct class`)
+      }
+
+      const typeName = cls.$typeName
+      const numTypeParams = cls.$numTypeParams
+
+      this.map.set(typeName, {
+        numTypeParams,
+        fromFields: (fields: Record<string, any>, typeArgs: Type[] = []) => {
+          if (typeArgs.length !== numTypeParams) {
+            throw new Error(`expected ${numTypeParams} type args, got ${typeArgs.length}`)
+          }
+          if (numTypeParams === 0) {
+            return cls.fromFields(fields)
+          } else if (numTypeParams === 1) {
+            return cls.fromFields(typeArgs[0], fields)
+          } else {
+            return cls.fromFields(typeArgs, fields)
+          }
+        },
+        fromFieldsWithTypes: (item: FieldsWithTypes) => {
+          return cls.fromFieldsWithTypes(item)
+        },
+      })
+    }
+  }
+
+  fromFields(type: Type, value: Record<string, any> | PrimitiveValue) {
+    const ret = this.#handlePrimitiveValue(type, value, this.fromFields.bind(this))
+    if (ret !== undefined) {
+      return ret
+    }
+    value = value as FieldsWithTypes // type hint
+
+    const { typeName, typeArgs } = parseTypeName(type)
+
+    const loader = this.map.get(typeName)
+    if (!loader) {
+      throw new Error(`no loader registered for type ${typeName}, include relevant package in gen.toml`)
+    }
+
+    if (loader.numTypeParams !== typeArgs.length) {
+      throw new Error(`expected ${loader.numTypeParams} type args, got ${typeArgs.length}`)
+    }
+
+    return loader.fromFields(value, typeArgs)
+  }
+
+  fromFieldsWithTypes(type: Type, value: FieldsWithTypes | PrimitiveValue) {
+    const { typeName, typeArgs } = parseTypeName(type)
+
+    // some types are special-cased in the RPC so we need to handle this manually
+    // https://github.com/MystenLabs/sui/blob/416a980749ba8208917bae37a1ec1d43e50037b7/crates/sui-json-rpc-types/src/sui_move.rs#L482-L533
+    switch (typeName) {
+      case '0x1::string::String':
+      case '0x1::ascii::String':
+      case '0x2::url::Url':
+        return value
+      case '0x2::object::ID':
+        return value
+      case '0x2::object::UID':
+        return (value as unknown as { id: string }).id
+      case '0x2::balance::Balance': {
+        const loader = this.map.get('0x2::balance::Balance')
+        if (!loader) {
+          throw new Error('no loader registered for type 0x2::balance::Balance')
+        }
+        return loader.fromFields({ value }, typeArgs)
+      }
+      case '0x1::option::Option': {
+        if (value === null) {
+          return null
+        }
+
+        const loader = this.map.get('0x1::option::Option')
+        if (!loader) {
+          throw new Error('no loader registered for type 0x1::option::Option')
+        }
+        return loader.fromFieldsWithTypes({
+          type: type,
+          fields: { vec: [value] },
+        }).vec[0]
+      }
+    }
+
+    const ret = this.#handlePrimitiveValue(type, value, this.fromFieldsWithTypes.bind(this))
+    if (ret !== undefined) {
+      return ret
+    }
+    value = value as FieldsWithTypes // type hint
+
+    const loader = this.map.get(typeName)
+    if (!loader) {
+      throw new Error(`no loader registered for type ${typeName}, include relevant package in gen.toml`)
+    }
+
+    return loader.fromFieldsWithTypes(value)
+  }
+
+  #handlePrimitiveValue(type: Type, value: any, vecCb: (type: Type, value: any) => any) {
+    const { typeName, typeArgs } = parseTypeName(type)
+
+    switch (typeName) {
+      case 'bool':
+        return value as boolean
+      case 'u8':
+      case 'u16':
+      case 'u32':
+        return value as number
+      case 'u64':
+      case 'u128':
+      case 'u256':
+        return BigInt(value)
+      case 'address':
+        return value as string
+      case 'signer':
+        return value as string
+      case 'vector':
+        value = value as any[]
+        return value.map((item: any) => vecCb(typeArgs[0], item))
+      default:
+        return undefined
+    }
+  }
+}
+
+export const structClassLoaderSource = new StructClassLoader()
+export const structClassLoaderOnchain = new StructClassLoader()
+

package/src/framework/util.ts

@@ -0,0 +1,219 @@
+
+import {
+  is,
+  ObjectCallArg,
+  ObjectId,
+  TransactionArgument,
+  TransactionBlock,
+  normalizeSuiAddress,
+  bcs,
+} from '@mysten/sui.js'
+import { BCS } from '@mysten/bcs'
+
+/** A Move type, e.g., `address`, `bool`, `u64`, `vector<u64>`, `0x2::sui::SUI`... */
+export type Type = string
+
+export interface FieldsWithTypes {
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  fields: Record<string, any>
+  type: string
+}
+
+export type ObjectArg = ObjectId | ObjectCallArg | TransactionArgument
+export type PureArg =
+  | bigint
+  | string
+  | number
+  | boolean
+  | null
+  | TransactionArgument
+  | Array<PureArg>
+export type GenericArg = ObjectArg | PureArg | Array<ObjectArg> | Array<PureArg> | Array<GenericArg>
+
+export function parseTypeName(name: Type): { typeName: string; typeArgs: Type[] } {
+  const parsed = bcs.parseTypeName(name)
+  return { typeName: parsed.name, typeArgs: parsed.params as string[] }
+}
+
+export function obj(txb: TransactionBlock, arg: ObjectArg) {
+  return is(arg, TransactionArgument) ? arg : txb.object(arg)
+}
+
+export function pure(txb: TransactionBlock, arg: PureArg, type: Type) {
+  if (is(arg, TransactionArgument)) {
+    return obj(txb, arg)
+  }
+
+  function convertType(type: Type): string {
+    const { typeName, typeArgs } = parseTypeName(type)
+    switch (typeName) {
+      case '0x1::string::String':
+      case '0x1::ascii::String':
+        return BCS.STRING
+      case '0x2::object::ID':
+        return BCS.ADDRESS
+      case '0x1::option::Option':
+        return `vector<${convertType(typeArgs[0])}>`
+      case 'vector':
+        return `vector<${convertType(typeArgs[0])}>`
+      default:
+        return type
+    }
+  }
+
+  function isOrHasNestedTransactionArgument(arg: PureArg): boolean {
+    if (Array.isArray(arg)) {
+      return arg.some(item => isOrHasNestedTransactionArgument(item))
+    }
+    return is(arg, TransactionArgument)
+  }
+
+  function convertArg(arg: PureArg, type: Type): PureArg {
+    const { typeName, typeArgs } = parseTypeName(type)
+    if (typeName === '0x1::option::Option') {
+      if (arg === null) {
+        return []
+      } else {
+        return [convertArg(arg, typeArgs[0])]
+      }
+    } else if (typeName === 'vector' && Array.isArray(arg)) {
+      return arg.map(item => convertArg(item, typeArgs[0]))
+    } else if (typeName === '0x2::object::ID' || typeName === 'address') {
+      return normalizeSuiAddress(arg as string)
+    } else {
+      return arg
+    }
+  }
+
+  // handle some cases when TransactionArgument is nested within a vector or option
+  const { typeName, typeArgs } = parseTypeName(type)
+  switch (typeName) {
+    case '0x1::option::Option':
+      if (arg === null) {
+        return txb.pure([], `vector<${convertType(typeArgs[0])}>`)
+      }
+      if (isOrHasNestedTransactionArgument(arg)) {
+        throw new Error('nesting TransactionArgument is not currently supported')
+      }
+      break
+    case 'vector':
+      if (!Array.isArray(arg)) {
+        throw new Error('expected an array for vector type')
+      }
+      if (arg.length === 0) {
+        return txb.pure([], `vector<${convertType(typeArgs[0])}>`)
+      }
+      if (arg.some(arg => Array.isArray(arg) && isOrHasNestedTransactionArgument(arg))) {
+        throw new Error('nesting TransactionArgument is not currently supported')
+      }
+      if (
+        is(arg[0], TransactionArgument) &&
+        arg.filter(arg => !is(arg, TransactionArgument)).length > 0
+      ) {
+        throw new Error('mixing TransactionArgument with other types is not currently supported')
+      }
+      if (is(arg[0], TransactionArgument)) {
+        return txb.makeMoveVec({
+          objects: arg as Array<TransactionArgument>,
+          type: typeArgs[0],
+        })
+      }
+  }
+
+  return txb.pure(convertArg(arg, type), convertType(type))
+}
+
+export function option(txb: TransactionBlock, type: Type, arg: GenericArg | null) {
+  if (arg === null) {
+    return pure(txb, arg, `0x1::option::Option<${type}>`)
+  }
+
+  if (typeArgIsPure(type)) {
+    return pure(txb, arg as PureArg | TransactionArgument, `0x1::option::Option<${type}>`)
+  } else if (is(arg, TransactionArgument)) {
+    return arg
+  } else {
+    if (arg === null) {
+      return pure(txb, arg, `vector<${type}>`)
+    }
+
+    // wrap it with some
+    const val = generic(txb, type, arg)
+    return txb.moveCall({
+      target: `0x1::option::some`,
+      typeArguments: [type],
+      arguments: [val],
+    })
+  }
+}
+
+export function generic(txb: TransactionBlock, type: Type, arg: GenericArg) {
+  if (typeArgIsPure(type)) {
+    return pure(txb, arg as PureArg | TransactionArgument, type)
+  } else {
+    const { typeName, typeArgs } = parseTypeName(type)
+    if (typeName === 'vector' && Array.isArray(arg)) {
+      const itemType = typeArgs[0]
+
+      return txb.makeMoveVec({
+        objects: arg.map(item => obj(txb, item as ObjectArg)),
+        type: itemType,
+      })
+    } else {
+      return obj(txb, arg as ObjectArg)
+    }
+  }
+}
+
+export function vector(
+  txb: TransactionBlock,
+  itemType: Type,
+  items: Array<GenericArg> | TransactionArgument
+) {
+  if (typeArgIsPure(itemType)) {
+    return pure(txb, items as PureArg, `vector<${itemType}>`)
+  } else if (is(items, TransactionArgument)) {
+    return items
+  } else {
+    const { typeName: itemTypeName, typeArgs: itemTypeArgs } = parseTypeName(itemType)
+    if (itemTypeName === '0x1::option::Option') {
+      const objects = items.map(item => option(txb, itemTypeArgs[0], item))
+      return txb.makeMoveVec({
+        objects,
+        type: itemType,
+      })
+    }
+
+    return txb.makeMoveVec({
+      objects: items as Array<TransactionArgument>,
+      type: itemType,
+    })
+  }
+}
+
+export function typeArgIsPure(type: Type): boolean {
+  const { typeName, typeArgs } = parseTypeName(type)
+  switch (typeName) {
+    case 'bool':
+    case 'u8':
+    case 'u16':
+    case 'u32':
+    case 'u64':
+    case 'u128':
+    case 'u256':
+    case 'address':
+    case 'signer':
+      return true
+    case 'vector':
+      return typeArgIsPure(typeArgs[0])
+    case '0x1::string::String':
+    case '0x1::ascii::String':
+    case '0x2::object::ID':
+      return true
+    case '0x1::option::Option':
+      return typeArgIsPure(typeArgs[0])
+    default:
+      return false
+  }
+}
+

package/src/index.ts

@@ -7,4 +7,5 @@ export { Obelisk } from './obelisk';
 export { SuiAccountManager } from './libs/suiAccountManager';
 export { SuiTxBlock } from './libs/suiTxBuilder';
 export { SuiRpcProvider } from './libs/suiRpcProvider';
+export { SuiContractFactory } from './libs/suiContractFactory';
 export type * from './types';

package/src/libs/suiContractFactory/index.ts

@@ -0,0 +1,121 @@
+import { SuiMoveNormalizedModules} from '@mysten/sui.js';
+import type { ContractFactoryParams, SuiMoveMoudleValueType } from './types';
+export type ApiTypes = 'promise' | 'rxjs';
+
+// export interface ContractQuery {
+//   (origin: AccountId | string | Uint8Array, options: ContractOptions, ...params: unknown[]): SuiTransactionBlockResponse<ApiType, ContractCallOutcome>;
+// }
+
+// export type MapMessageQuery<ApiType extends ApiTypes> = Record<string, ContractQuery<ApiType>>;
+
+// // function createQuery <ApiType extends ApiTypes> (meta: AbiMessage, fn: (origin: string | AccountId | Uint8Array, options: ContractOptions, params: unknown[]) => ContractCallResult<ApiType, ContractCallOutcome>): ContractQuery<ApiType> {
+// //   return withMeta(meta, (origin: string | AccountId | Uint8Array, options: ContractOptions, ...params: unknown[]): ContractCallResult<ApiType, ContractCallOutcome> =>
+// //     fn(origin, options, params)
+// //   );
+// // }
+
+// export type MapMessageTx<ApiType extends ApiTypes> = Record<string, ContractTx<ApiType>>;
+
+// export interface ContractOptions {
+//   gasLimit?: bigint | string | number | BN | WeightV2;
+//   storageDepositLimit?: bigint | string | number | BN | null;
+//   value?: bigint | BN | string | number;
+// }
+
+// export interface ContractTx {
+//   (options: ContractOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType>;
+// }
+export class SuiContractFactory {
+  public packageId: string;
+  public metadata: SuiMoveNormalizedModules | undefined;
+  // readonly #query: MapMessageQuery<ApiTypes> = {};
+  // readonly #tx: MapMessageTx<ApiTypes> = {};
+  /**
+   * Support the following ways to init the SuiToolkit:
+   * 1. mnemonics
+   * 2. secretKey (base64 or hex)
+   * If none of them is provided, will generate a random mnemonics with 24 words.
+   *
+   * @param mnemonics, 12 or 24 mnemonics words, separated by space
+   * @param secretKey, base64 or hex string, when mnemonics is provided, secretKey will be ignored
+   */
+  constructor({ packageId, metadata }: ContractFactoryParams = {}) {
+    // If the mnemonics or secretKey is provided, use it
+    // Otherwise, generate a random mnemonics with 24 words
+    this.packageId = packageId || '';
+    this.metadata = metadata || undefined;
+  }
+
+  getFuncByModuleName(moduleName: string) {
+    Object.values(this.metadata as SuiMoveNormalizedModules).forEach(
+      (value) => {
+        const data = value as SuiMoveMoudleValueType;
+        console.log(`moudle name: ${data.name}`);
+        // console.log(data.exposedFunctions)
+        Object.entries(data.exposedFunctions).forEach(([key, value]) => {
+          console.log(`\tfunc name: ${key}`);
+          Object.values(value.parameters).forEach((values) => {
+            // console.log(values)
+          });
+        });
+      }
+    );
+  }
+
+  getAllFunc() {
+    Object.values(this.metadata as SuiMoveNormalizedModules).forEach(
+      (value) => {
+        const data = value as SuiMoveMoudleValueType;
+        console.log(`moudle name: ${data.name}`);
+        // console.log(data.exposedFunctions)
+        Object.entries(data.exposedFunctions).forEach(([key, value]) => {
+          console.log(`\tfunc name: ${key}`);
+          console.log(`\t\t${value.parameters.length}`);
+          Object.values(value.parameters).forEach((values) => {
+            // console.log(values)
+            console.log(`\t\targs: ${values}`);
+          });
+        });
+      }
+    );
+  }
+
+  getAllModule() {
+    Object.values(this.metadata as SuiMoveNormalizedModules).forEach(
+      (value, index) => {
+        const data = value as SuiMoveMoudleValueType;
+        console.log(`${index}. ${data.name}`);
+      }
+    );
+  }
+  async worldCall() {}
+
+  //   async call(arguments: ({
+  //     kind: "Input";
+  //     index: number;
+  //     type?: "object" | "pure" | undefined;
+  //     value?: any;
+  // } | {
+  //     kind: "GasCoin";
+  // } | {
+  //     kind: "Result";
+  //     index: number;
+  // } | {
+  //     kind: "NestedResult";
+  //     index: number;
+  //     resultIndex: number;
+  // })[], derivePathParams?: DerivePathParams) {
+  //     const tx = new TransactionBlock();
+  //     tx.moveCall({
+  //       target: `${this.packageId}::${}::${}`,
+  //       arguments,
+  //     })
+  //     return ;
+  //   }
+}
+
+// function createTx <ApiType extends ApiTypes> (meta: AbiMessage, fn: (options: ContractOptions, params: unknown[]) => SubmittableExtrinsic<ApiType>): ContractTx<ApiType> {
+//   return withMeta(meta, (options: ContractOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType> =>
+//     fn(options, params)
+//   );
+// }

package/src/libs/suiContractFactory/types.ts

@@ -0,0 +1,54 @@
+import { SuiMoveNormalizedModules, SuiMoveNormalizedType } from "@mysten/sui.js";
+
+export type ContractFactoryParams = {
+  packageId?: string;
+  metadata?: SuiMoveNormalizedModules;
+};
+
+
+export type SuiMoveMoudleValueType =  {
+    address: string;
+    name: string;
+    fileFormatVersion: number;
+    friends: {
+        address: string;
+        name: string;
+    }[];
+    structs: Record<string, {
+        fields: {
+            type: SuiMoveNormalizedType;
+            name: string;
+        }[];
+        abilities: {
+            abilities: string[];
+        };
+        typeParameters: {
+            constraints: {
+                abilities: string[];
+            };
+            isPhantom: boolean;
+        }[];
+    }>;
+    exposedFunctions: Record<string, {
+        visibility: "Private" | "Public" | "Friend";
+        isEntry: boolean;
+        typeParameters: {
+            abilities: string[];
+        }[];
+        parameters: SuiMoveNormalizedType[];
+        return: SuiMoveNormalizedType[];
+    }>;
+}
+
+
+export type SuiMoveMoudleFuncType = {
+    moudleName: string,
+    funcName: string,
+    visibility: "Private" | "Public" | "Friend";
+    isEntry: boolean;
+    typeParameters: {
+        abilities: string[];
+    }[];
+    parameters: SuiMoveNormalizedType[];
+    return: SuiMoveNormalizedType[];
+}

package/src/libs/suiRpcProvider/index.ts

@@ -6,6 +6,7 @@ import {
   getObjectFields,
   getObjectDisplay,
   getObjectVersion,
+  DynamicFieldName
 } from '@mysten/sui.js';
 import { requestFaucet } from './faucet';
 import { getDefaultNetworkParams } from './defaultChainConfigs';
@@ -54,6 +55,32 @@ export class SuiRpcProvider {
     return this.provider.getBalance({ owner: addr, coinType });
   }
 
+
+  async getDynamicFieldObject(parentId: string, name: string | DynamicFieldName) {
+    return this.provider.getDynamicFieldObject({ parentId, name })
+  }
+
+  async getDynamicFields(parentId: string, cursor?: string, limit?: number) {
+    return this.provider.getDynamicFields({ parentId, cursor, limit })
+  }
+
+  async getObject(id: string) {
+    const options = { showContent: true, showDisplay: true, showType: true };
+    const object = await this.provider.getObject({ id, options });
+    const objectId = getObjectId(object);
+    const objectType = getObjectType(object);
+    const objectVersion = getObjectVersion(object);
+    const objectFields = getObjectFields(object);
+    const objectDisplay = getObjectDisplay(object);
+    return {
+      objectId,
+      objectType,
+      objectVersion,
+      objectFields,
+      objectDisplay,
+    } as ObjectData;
+  }
+
   async getObjects(ids: string[]) {
     const options = { showContent: true, showDisplay: true, showType: true };
     const objects = await this.provider.multiGetObjects({ ids, options });
@@ -74,6 +101,10 @@ export class SuiRpcProvider {
     return parsedObjects as ObjectData[];
   }
 
+  async getNormalizedMoveModulesByPackage(packageId: string) {
+    return this.provider.getNormalizedMoveModulesByPackage({package: packageId});
+  }
+
   /**
    * @description Select coins that add up to the given amount.
    * @param addr the address of the owner

package/src/metadata/index.ts

@@ -0,0 +1,40 @@
+import {
+  RawSigner,
+  TransactionBlock,
+  DevInspectResults,
+  SuiTransactionBlockResponse, JsonRpcProvider, testnetConnection,
+  SuiMoveNormalizedModules, DynamicFieldPage, DynamicFieldName,
+} from '@mysten/sui.js';
+import { SuiAddress } from "@mysten/sui.js/src/types";
+import { SuiRpcProvider } from '../libs/suiRpcProvider';
+import { NetworkType } from '../libs/suiRpcProvider/types';
+import * as fs from 'fs';
+
+export async function initialize(networkType: NetworkType, packageId: string) {
+    const jsonFileName = `metadata/${packageId}.json`;
+
+    const rpcProvider = new SuiRpcProvider({
+      networkType,
+    });
+    try {
+      const data = await fs.promises.readFile(jsonFileName, 'utf-8');
+      const jsonData = JSON.parse(data);
+
+      return jsonData as SuiMoveNormalizedModules;
+    } catch (error) {
+      if (packageId !== undefined) {
+        const jsonData = await rpcProvider.getNormalizedMoveModulesByPackage(packageId);
+
+        fs.writeFile(jsonFileName, JSON.stringify(jsonData, null, 2), (err) => {
+          if (err) {
+            console.error('写入文件时出错:', err);
+          } else {
+            console.log('JSON 数据已保存到文件:', jsonFileName);
+          }
+        });
+        return jsonData as SuiMoveNormalizedModules;
+      } else {
+        console.error('please set your package id.');
+      }
+    }
+  }