@typemove/iota 2.0.0 → 2.0.1-rc.1

package/src/sui-chain-adapter.ts

@@ -0,0 +1,113 @@
+import { toInternalModule } from './to-internal.js'
+import {
+  InternalMoveModule,
+  InternalMoveStruct,
+  ChainAdapter,
+  moduleQname,
+  SPLITTER,
+  TypeDescriptor
+} from '@typemove/move'
+
+import { IotaMoveNormalizedModule, IotaEvent, IotaMoveObject, IotaClient } from '@iota/iota-sdk/client'
+
+export class IotaChainAdapter extends ChainAdapter<
+  // IotaNetwork,
+  IotaMoveNormalizedModule,
+  IotaEvent | IotaMoveObject
+> {
+  async getChainId() {
+    return this.client.getChainIdentifier()
+  }
+  // static INSTANCE = new IotaChainAdapter()
+
+  client: IotaClient
+  constructor(client: IotaClient) {
+    super()
+    this.client = client
+  }
+
+  async fetchModule(
+    account: string,
+    module: string
+    // network: IotaNetwork
+  ): Promise<IotaMoveNormalizedModule> {
+    return await this.client.getNormalizedMoveModule({ package: account, module })
+  }
+
+  async fetchModules(
+    account: string
+    // network: IotaNetwork
+  ): Promise<IotaMoveNormalizedModule[]> {
+    const modules = await this.client.getNormalizedMoveModulesByPackage({
+      package: account
+    })
+    return Object.values(modules)
+  }
+
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    return params
+    // if (params.length === 0) {
+    //   return params
+    // }
+    // return params.slice(0, params.length - 1)
+  }
+
+  toInternalModules(modules: IotaMoveNormalizedModule[]): InternalMoveModule[] {
+    return Object.values(modules).map(toInternalModule)
+  }
+
+  getAllEventStructs(modules: InternalMoveModule[]): Map<string, InternalMoveStruct> {
+    const eventMap = new Map<string, InternalMoveStruct>()
+
+    for (const module of modules) {
+      const qname = moduleQname(module)
+
+      for (const struct of module.structs) {
+        const abilities = new Set(struct.abilities)
+        if (abilities.has('Drop') && abilities.has('Copy')) {
+          eventMap.set(qname + SPLITTER + struct.name, struct)
+        }
+      }
+    }
+    return eventMap
+  }
+
+  getType(base: IotaEvent | IotaMoveObject): string {
+    return base.type
+  }
+
+  getData(val: IotaEvent | IotaMoveObject) {
+    // if (val.parsedJson) {
+    //   return val.parsedJson as any
+    // }
+    if (val === undefined) {
+      throw Error('val is undefined')
+    }
+    if ('parsedJson' in val) {
+      return val.parsedJson as any
+    }
+    // if (IotaParsedData.is(val)) {
+    //   return val.fields as any
+    // }
+    if (val.dataType === 'moveObject') {
+      return val.fields as any
+    }
+    // if (IotaMoveObject.is(val)) {
+    //   return val.fields as any
+    // }
+    // This may not be perfect, just think everything has
+    if ('fields' in val) {
+      if ('type' in val && Object.keys(val).length === 2) {
+        return val.fields as any
+      }
+    }
+    return val as any
+  }
+  // validateAndNormalizeAddress(address: string) {
+  //   return validateAndNormalizeAddress(address)
+  // }
+}
+
+function getRpcClient(endpoint: string): IotaClient {
+  return new IotaClient({ url: endpoint })
+}

package/src/to-internal.ts

@@ -0,0 +1,127 @@
+import type {
+  IotaMoveNormalizedEnum,
+  IotaMoveNormalizedField,
+  IotaMoveNormalizedFunction,
+  IotaMoveNormalizedModule,
+  IotaMoveNormalizedStruct,
+  IotaMoveNormalizedType
+} from '@iota/iota-sdk/client'
+import {
+  InternalMoveEnum,
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  InternalMoveModule,
+  InternalMoveStruct,
+  InternalMoveStructField,
+  SPLITTER,
+  TypeDescriptor
+} from '@typemove/move'
+
+export function toInternalModule(module: IotaMoveNormalizedModule): InternalMoveModule {
+  return {
+    address: module.address,
+    exposedFunctions: Object.entries(module.exposedFunctions).map(([n, f]) => toInternalFunction(n, f)),
+    name: module.name,
+    structs: Object.entries(module.structs).map(([n, s]) => toInternalStruct(n, s)),
+    enums: Object.entries(module.enums || {}).map(([n, e]) => toInternalEnum(n, e))
+  }
+}
+
+function toInternalFunction(name: string, func: IotaMoveNormalizedFunction): InternalMoveFunction {
+  let visibility
+  switch (func.visibility) {
+    case 'Private':
+      visibility = InternalMoveFunctionVisibility.PRIVATE
+      break
+    case 'Public':
+      visibility = InternalMoveFunctionVisibility.PUBLIC
+      break
+    case 'Friend':
+      visibility = InternalMoveFunctionVisibility.FRIEND
+      break
+    default:
+      throw Error('No visibility for function' + name)
+  }
+  return {
+    typeParams: func.typeParameters.map((p: any) => {
+      return { constraints: p.abilities }
+    }),
+    isEntry: func.isEntry,
+    name: name,
+    params: func.parameters.map(toTypeDescriptor),
+    return: func.return.map(toTypeDescriptor),
+    visibility: visibility
+  }
+}
+
+function toInternalStruct(name: string, struct: IotaMoveNormalizedStruct): InternalMoveStruct {
+  return {
+    abilities: struct.abilities.abilities,
+    fields: struct.fields.map(toInternalField),
+    typeParams: struct.typeParameters.map((p: any) => {
+      return { constraints: p.constraints.abilities }
+    }),
+    isNative: false,
+    isEvent: false,
+    name: name
+  }
+}
+
+function toInternalEnum(name: string, enumType: IotaMoveNormalizedEnum): InternalMoveEnum {
+  return {
+    name: name,
+    abilities: enumType.abilities.abilities,
+    typeParams: enumType.typeParameters.map((p: any) => {
+      return { constraints: p.constraints.abilities }
+    }),
+    variants: Object.entries(enumType.variants).reduce((acc: { [key: string]: InternalMoveStructField[] }, [k, v]) => {
+      acc[k] = v.map(toInternalField)
+      return acc
+    }, {})
+  }
+}
+
+function toInternalField(module: IotaMoveNormalizedField): InternalMoveStructField {
+  return {
+    name: module.name,
+    type: toTypeDescriptor(module.type)
+  }
+}
+
+function toTypeDescriptor(normalizedType: IotaMoveNormalizedType): TypeDescriptor {
+  if (typeof normalizedType === 'string') {
+    return new TypeDescriptor(normalizedType)
+  }
+
+  if ('Struct' in normalizedType) {
+    const qname = [normalizedType.Struct.address, normalizedType.Struct.module, normalizedType.Struct.name].join(
+      SPLITTER
+    )
+
+    const args = normalizedType.Struct.typeArguments.map(toTypeDescriptor)
+
+    return new TypeDescriptor(qname, args)
+  }
+
+  if ('Vector' in normalizedType) {
+    return new TypeDescriptor('Vector', [toTypeDescriptor(normalizedType.Vector)])
+  }
+  if ('TypeParameter' in normalizedType) {
+    return new TypeDescriptor('T' + normalizedType.TypeParameter)
+  }
+
+  if ('Reference' in normalizedType) {
+    const res = toTypeDescriptor(normalizedType.Reference)
+    res.reference = true
+    return res
+  }
+
+  if ('MutableReference' in normalizedType) {
+    const res = toTypeDescriptor(normalizedType.MutableReference)
+    res.reference = true
+    res.mutable = true
+    return res
+  }
+
+  throw new Error('Unexpected sui type')
+}

package/src/transaction.ts

@@ -0,0 +1,127 @@
+import { Transaction, TransactionArgument, TransactionObjectInput } from '@iota/iota-sdk/transactions'
+
+export function isTransactionArgument(value: any): boolean {
+  if (typeof value !== 'object') return false
+  if (value === null || value === undefined) return false
+
+  return (
+    value.$kind === 'GasCoin' || value.$kind === 'Result' || value.$kind === 'NestedResult' || value.$kind === 'Input'
+  )
+}
+
+export function transactionArgumentOrObject(
+  value: TransactionObjectInput,
+  transactionBlock: Transaction
+): TransactionArgument {
+  // if (isTransactionArgument(value)) {
+  //   return value as TransactionArgument
+  // }
+  return transactionBlock.object(value)
+}
+
+export function transactionArgumentOrPure(value: any, transactionBlock: Transaction): any {
+  if (isTransactionArgument(value)) {
+    return value
+  }
+  return typeof value == 'string' ? transactionBlock.pure.string(value) : transactionBlock.pure.u64(value)
+}
+
+export function transactionArgumentOrPureString(
+  value: TransactionArgument | string,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.string(value as string)
+}
+
+export function transactionArgumentOrPureAddress(
+  value: TransactionArgument | string,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.address(value as string)
+}
+
+export function transactionArgumentOrPureU8(
+  value: TransactionArgument | number,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.u8(value as number)
+}
+
+export function transactionArgumentOrPureU16(
+  value: TransactionArgument | number,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.u16(value as number)
+}
+
+export function transactionArgumentOrPureU32(
+  value: TransactionArgument | number,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.u32(value as number)
+}
+
+export function transactionArgumentOrPureU64(
+  value: TransactionArgument | bigint | number | string,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.u64(value as number)
+}
+
+export function transactionArgumentOrPureU128(
+  value: TransactionArgument | bigint | number | string,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.u128(value as number)
+}
+
+export function transactionArgumentOrPureU256(
+  value: TransactionArgument | bigint | number | string,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.u256(value as number)
+}
+
+export function transactionArgumentOrPureBool(
+  value: TransactionArgument | boolean,
+  transactionBlock: Transaction
+): TransactionArgument {
+  if (isTransactionArgument(value)) {
+    return value as TransactionArgument
+  }
+  return transactionBlock.pure.bool(value as boolean)
+}
+
+// TODO vector might be nested
+export function transactionArgumentOrVec(value: any, transactionBlock: Transaction): any {
+  if (isTransactionArgument(value)) {
+    return value
+  }
+  return transactionBlock.makeMoveVec({
+    elements: value.map((a: any) => transactionBlock.object(a))
+  })
+}