@typemove/aptos 2.0.0 → 2.0.1

package/src/account-resource-client.ts

@@ -0,0 +1,69 @@
+import {
+  AccountAddressInput,
+  Aptos,
+  MoveStructId,
+  LedgerVersionArg,
+  PaginationArgs,
+  MoveResource
+} from '@aptos-labs/ts-sdk'
+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: Aptos
+  constructor(client: Aptos) {
+    this.client = client
+  }
+
+  /**
+   * Get all resources of an account, same as `getAccountResources` in aptos client
+   * @param accountAddress
+   * @param query
+   */
+  async getAll(accountAddress: AccountAddressInput, options?: PaginationArgs & LedgerVersionArg) {
+    return this.client.getAccountResources({ accountAddress, options })
+  }
+
+  /**
+   * Match a single resource with exact type, resource type should not contain any type
+   * @param accountAddress
+   * @param resourceType
+   * @param options
+   */
+  async matchExact<T>(
+    accountAddress: AccountAddressInput,
+    resourceType: TypeDescriptor<T>,
+    options?: LedgerVersionArg
+  ): Promise<TypedMoveResource<T> | undefined> {
+    if (resourceType.existAnyType()) {
+      throw new Error('resource type for match call should not contain any type')
+    }
+    const typeStr = resourceType.getSignature() as MoveStructId
+    const result = await this.client.getAccountResource({ accountAddress, resourceType: typeStr, options })
+    const resource: MoveResource = {
+      type: typeStr,
+      data: result
+    }
+    return defaultMoveCoder(this.client.config).decodeResource<T>(resource)
+  }
+
+  /**
+   * 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 options
+   */
+  async matchAll<T>(
+    accountAddress: AccountAddressInput,
+    resourceType: TypeDescriptor<T>,
+    options?: PaginationArgs & LedgerVersionArg
+  ): Promise<TypedMoveResource<T>[]> {
+    const result = await this.client.getAccountResources({ accountAddress, options })
+    return defaultMoveCoder(this.client.config).filterAndDecodeResources<T>(resourceType, result)
+  }
+}

package/src/aptos-chain-adapter.ts

@@ -0,0 +1,132 @@
+import {
+  ChainAdapter,
+  moduleQname,
+  SPLITTER,
+  TypeDescriptor,
+  InternalMoveModule,
+  InternalMoveStruct
+} from '@typemove/move'
+
+import { Aptos, Event, MoveModuleBytecode, MoveResource } from '@aptos-labs/ts-sdk'
+import { toInternalModule } from './to-internal.js'
+
+// Drop bytecode — typemove's codegen only reads `m.abi`, and bytecode is
+// ~50% of each Aptos module entry's bytes. Cast is needed because
+// MoveModuleBytecode declares `bytecode: string` as required.
+function stripBytecode({ abi }: MoveModuleBytecode): MoveModuleBytecode {
+  return { abi } as MoveModuleBytecode
+}
+
+export class AptosChainAdapter extends ChainAdapter<MoveModuleBytecode, Event | MoveResource> {
+  // static INSTANCE = new AptosChainAdapter()
+  client: Aptos
+  private optimisticEventDetection: boolean = true
+
+  constructor(client: Aptos, optimisticEventDetection = true) {
+    super()
+    this.client = client
+    this.optimisticEventDetection = optimisticEventDetection
+  }
+
+  async fetchModules(account: string): Promise<MoveModuleBytecode[]> {
+    const modules = await this.client.getAccountModules({
+      accountAddress: account
+    })
+    return modules.map(stripBytecode)
+  }
+
+  async fetchModule(account: string, module: string): Promise<MoveModuleBytecode> {
+    const m = await this.client.getAccountModule({
+      accountAddress: account,
+      moduleName: module
+    })
+    return stripBytecode(m)
+  }
+
+  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>()
+    const structMap = new Map<string, InternalMoveStruct>()
+    for (const module of modules) {
+      const qname = moduleQname(module)
+      for (const struct of module.structs) {
+        const typeName = qname + SPLITTER + struct.name
+
+        // Skip deprecated v2 events
+        if (typeName == '0x1::coin::Deposit' || typeName == '0x1::coin::Withdraw') {
+          continue
+        }
+
+        structMap.set(typeName, struct)
+
+        // Check if struct is explicitly marked as event
+        if (struct.isEvent) {
+          eventMap.set(typeName, struct)
+          continue
+        }
+
+        if (struct.name.endsWith('Event')) {
+          // this is a hack to support some old events
+          eventMap.set(typeName, struct)
+          continue
+        }
+
+        // Check for native events: structs with EXACTLY drop and store abilities
+        if (this.optimisticEventDetection) {
+          const abilities = new Set(struct.abilities)
+          if (abilities.size === 2 && abilities.has('drop') && abilities.has('store')) {
+            eventMap.set(typeName, struct)
+          }
+        }
+      }
+    }
+
+    // Also check for legacy events (in EventHandle fields)
+    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)
+  // }
+}