@typemove/aptos 1.13.5-rc.2 → 2.0.0-rc.1

package/src/account-resource-client.ts

@@ -1,69 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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'
-
-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[]> {
-    return await this.client.getAccountModules({
-      accountAddress: account
-    })
-  }
-
-  async fetchModule(account: string, module: string): Promise<MoveModuleBytecode> {
-    return await this.client.getAccountModule({
-      accountAddress: account,
-      moduleName: module
-    })
-  }
-
-  toInternalModules(modules: MoveModuleBytecode[]): InternalMoveModule[] {
-    return modules.flatMap((m) => (m.abi ? [toInternalModule(m)] : []))
-  }
-
-  // Drop bytecode from cached ABI files — only `abi` is consumed by codegen,
-  // and bytecode is ~50% of each Aptos ABI JSON's bytes.
-  override toPersistableModules(modules: MoveModuleBytecode[]) {
-    return modules.map(({ abi }) => ({ abi }))
-  }
-
-  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)
-  // }
-}