@typemove/sui 1.0.0-rc.10

package/src/tests/types/testnet/index.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as _0x1e2b124f746a339b3cf99b9f969393a96594519aafb1d06517aacfeeae20e7a5 from './0x1e2b124f746a339b3cf99b9f969393a96594519aafb1d06517aacfeeae20e7a5.js'
+export * as _0x6c4a21e3e7e6b6d51c4604021633e1d97e24e37a696f8c082cd48f37503e602a from './0x6c4a21e3e7e6b6d51c4604021633e1d97e24e37a696f8c082cd48f37503e602a.js'
+export * as _0xdee9 from './0xdee9.js'
+export * as _0xebaa2ad3eacc230f309cd933958cc52684df0a41ae7ac214d186b80f830867d2 from './0xebaa2ad3eacc230f309cd933958cc52684df0a41ae7ac214d186b80f830867d2.js'

package/src/to-internal.ts

@@ -0,0 +1,129 @@
+import type {
+  SuiMoveNormalizedField,
+  SuiMoveNormalizedFunction,
+  SuiMoveNormalizedModule,
+  SuiMoveNormalizedStruct,
+  SuiMoveNormalizedType,
+} from '@mysten/sui.js'
+import {
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  InternalMoveModule,
+  InternalMoveStruct,
+  InternalMoveStructField,
+  SPLITTER,
+  TypeDescriptor,
+} from '@typemove/move'
+
+export function toInternalModule(
+  module: SuiMoveNormalizedModule
+): 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)
+    ),
+  }
+}
+
+function toInternalFunction(
+  name: string,
+  func: SuiMoveNormalizedFunction
+): 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: SuiMoveNormalizedStruct
+): InternalMoveStruct {
+  return {
+    abilities: struct.abilities.abilities,
+    fields: struct.fields.map(toInternalField),
+    typeParams: struct.typeParameters.map((p: any) => {
+      return { constraints: p.constraints.abilities }
+    }),
+    isNative: false,
+    name: name,
+  }
+}
+
+function toInternalField(
+  module: SuiMoveNormalizedField
+): InternalMoveStructField {
+  return {
+    name: module.name,
+    type: toTypeDescriptor(module.type),
+  }
+}
+
+function toTypeDescriptor(
+  normalizedType: SuiMoveNormalizedType
+): 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/utils.ts

@@ -0,0 +1,62 @@
+import {
+  SuiTransactionBlockResponse,
+  MoveCallSuiTransaction,
+  getTransactionKind,
+  getProgrammableTransaction,
+  ProgrammableTransaction,
+  SuiTransaction,
+} from '@mysten/sui.js'
+
+export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
+  const txKind = getTransactionKind(txBlock)
+  if (!txKind) {
+    return []
+  }
+  const programmableTx: ProgrammableTransaction | undefined =
+    getProgrammableTransaction(txKind)
+  if (!programmableTx) {
+    return []
+  }
+
+  return programmableTx.transactions.flatMap((tx: SuiTransaction) => {
+    if ('MoveCall' in tx) {
+      const call = tx.MoveCall as MoveCallSuiTransaction
+
+      let pkg: string = call.package
+      if (
+        call.package.startsWith(
+          '0x000000000000000000000000000000000000000000000000000000000000000'
+        )
+      ) {
+        pkg = '0x' + pkg[pkg.length - 1]
+      }
+      call.package = pkg
+
+      return [call]
+    }
+    return []
+  })
+}
+
+// function isHex(value: string): boolean {
+//   return /^(0x|0X)?[a-fA-F0-9]+$/.test(value)
+// }
+//
+// function getHexByteLength(value: string): number {
+//   return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2
+// }
+//
+// export function isValidSuiAddress(value: string): value is SuiAddress {
+//   return isHex(value) && getHexByteLength(value) <= SUI_ADDRESS_LENGTH
+// }
+
+// export function validateAndNormalizeAddress(address: string): string {
+//   // if (isFrameworkAccount(address)) {
+//   //   const n = parseInt(address, 16)
+//   //   return `0x${n.toString(16)}`
+//   // }
+//   if (!isValidSuiAddress(address)) {
+//     throw Error('Not valid Address')
+//   }
+//   return normalizeSuiAddress(address)
+// }