@typemove/aptos 1.2.4-rc2 → 1.2.4-rc3

package/src/account-resource-client.ts

@@ -0,0 +1,58 @@
+import { AptosClient, MaybeHexString } from 'aptos'
+import { TypeDescriptor } from '@typemove/move'
+import { defaultMoveCoder } from './move-coder.js'
+import { TypedMoveResource } from './models.js'
+
+type ResourceQuery = {
+  ledgerVersion?: bigint | number
+}
+
+export class AccountResourceClient {
+  client: AptosClient
+  constructor(client: AptosClient) {
+    this.client = client
+  }
+
+  /**
+   * Get all resources of an account, same as `getAccountResources` in aptos client
+   * @param accountAddress
+   * @param query
+   */
+  async getAll(accountAddress: MaybeHexString, query?: ResourceQuery) {
+    return this.client.getAccountResources(accountAddress, query)
+  }
+
+  /**
+   * Match a single resource with exact type, resource type should not contain any type
+   * @param accountAddress
+   * @param resourceType
+   * @param query
+   */
+  async matchExact<T>(
+    accountAddress: MaybeHexString,
+    resourceType: TypeDescriptor<T>,
+    query?: ResourceQuery
+  ): Promise<TypedMoveResource<T> | undefined> {
+    if (resourceType.existAnyType()) {
+      throw new Error('resource type for match call should not contain any type')
+    }
+    const typeStr = resourceType.getSignature()
+    const result = await this.client.getAccountResource(accountAddress, typeStr, query)
+    return defaultMoveCoder(this.client.nodeUrl).decodeResource<T>(result)
+  }
+
+  /**
+   * Match all resources with type pattern, it could be a partial type like `amm.Pool<aptos_coin.AptosCoin.type(), ANY_TYPE>`
+   * @param accountAddress
+   * @param resourceType
+   * @param query
+   */
+  async matchAll<T>(
+    accountAddress: MaybeHexString,
+    resourceType: TypeDescriptor<T>,
+    query?: ResourceQuery
+  ): Promise<TypedMoveResource<T>[]> {
+    const result = await this.client.getAccountResources(accountAddress, query)
+    return defaultMoveCoder(this.client.nodeUrl).filterAndDecodeResources<T>(resourceType, result)
+  }
+}

package/src/aptos-chain-adapter.ts

@@ -0,0 +1,102 @@
+import {
+  ChainAdapter,
+  moduleQname,
+  SPLITTER,
+  TypeDescriptor,
+  InternalMoveModule,
+  InternalMoveStruct
+} from '@typemove/move'
+import { AptosClient } from 'aptos'
+
+import { Event, MoveModuleBytecode, MoveResource } from './move-types.js'
+import { toInternalModule } from './to-internal.js'
+
+export class AptosChainAdapter extends ChainAdapter<MoveModuleBytecode, Event | MoveResource> {
+  // static INSTANCE = new AptosChainAdapter()
+  client: AptosClient
+  constructor(client: AptosClient) {
+    super()
+    this.client = client
+  }
+
+  async fetchModules(account: string): Promise<MoveModuleBytecode[]> {
+    return await this.client.getAccountModules(account)
+  }
+
+  async fetchModule(account: string, module: string): Promise<MoveModuleBytecode> {
+    return await this.client.getAccountModule(account, module)
+  }
+
+  toInternalModules(modules: MoveModuleBytecode[]): InternalMoveModule[] {
+    return modules.flatMap((m) => (m.abi ? [toInternalModule(m)] : []))
+  }
+
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    if (params.length === 0) {
+      return params
+    }
+    if (params[0].qname === 'signer' && params[0].reference) {
+      params = params.slice(1)
+    }
+    return params
+  }
+
+  getAllEventStructs(modules: InternalMoveModule[]) {
+    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('store')) {
+          eventMap.set(qname + SPLITTER + struct.name, struct)
+        }
+      }
+    }
+    return eventMap
+
+    // const eventMap = new Map<string, InternalMoveStruct>()
+    // const structMap = new Map<string, InternalMoveStruct>()
+    // for (const module of modules) {
+    //   const qname = moduleQname(module)
+    //   for (const struct of module.structs) {
+    //     structMap.set(qname + SPLITTER + struct.name, struct)
+    //   }
+    // }
+    //
+    // for (const module of modules) {
+    //   for (const struct of module.structs) {
+    //     for (const field of struct.fields) {
+    //       const t = field.type
+    //       if (t.qname === '0x1::event::EventHandle') {
+    //         const event = t.typeArgs[0].qname
+    //         const eventStruct = structMap.get(event)
+    //         if (eventStruct) {
+    //           eventMap.set(event, eventStruct)
+    //         }
+    //       }
+    //     }
+    //   }
+    // }
+    // return eventMap
+  }
+
+  getType(data: Event | MoveResource): string {
+    return data.type
+  }
+
+  getData(data: Event | MoveResource) {
+    if ('data' in data && 'type' in data) {
+      return data.data
+    }
+    return data
+  }
+
+  async getChainId(): Promise<string> {
+    return (await this.client.getChainId()).toString()
+  }
+  // validateAndNormalizeAddress(address: string): string {
+  //   return validateAndNormalizeAddress(address)
+  // }
+}