@sentio/sdk 2.50.2-rc.2 → 2.51.0-rc.1

package/src/aptos/codegen/codegen.ts

@@ -28,6 +28,8 @@ class AptosNetworkCodegen extends BaseAptosCodegen {
   constructor(network: AptosNetwork) {
     const endpoint = getRpcEndpoint(network)
     super(endpoint)
+    const generator = this
+
     this.moduleGenerator = new (class extends SharedNetworkCodegen<
       AptosNetwork,
       MoveModuleBytecode,
@@ -37,12 +39,24 @@ class AptosNetworkCodegen extends BaseAptosCodegen {
       SYSTEM_PACKAGE = '@sentio/sdk/aptos'
       PREFIX = 'Aptos'
       NETWORK = AptosNetwork
+
+      protected generateExtra(address: string | undefined, module: InternalMoveModule): string {
+        return generator.generateExtra(address, module)
+      }
+
+      generateStructs(module: InternalMoveModule, struct: InternalMoveStruct, events: Set<string>) {
+        return generator.generateStructs(module, struct, events)
+      }
     })(network, this.chainAdapter)
   }
 
+  protected getGetDefaultCoder() {
+    return `defaultMoveCoderForClient(client)`
+  }
   generateModule(module: InternalMoveModule, allEventStructs: Map<string, InternalMoveStruct>) {
     return this.moduleGenerator.generateModule(module, allEventStructs)
   }
+
   generateImports() {
     return (
       this.moduleGenerator.generateImports() +
@@ -51,8 +65,8 @@ class AptosNetworkCodegen extends BaseAptosCodegen {
       import {
         MoveCoder, TypedEventInstance } from "@typemove/${this.PREFIX.toLowerCase()}"
       
-      import { defaultMoveCoder } from "${this.defaultCoderPackage()}"
-      import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId } from '@aptos-labs/ts-sdk'`
+      import { defaultMoveCoder, defaultMoveCoderForClient } from "${this.defaultCoderPackage()}"
+      import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId, InputViewFunctionData } from '@aptos-labs/ts-sdk'`
     )
   }
   generateLoadAll(isSystem: boolean): string {
@@ -74,11 +88,6 @@ class AptosCodegen {
       path.join(outputDir, 'movement-mainnet'),
       builtin
     )
-    // const num4 = await M2_TESTNET_CODEGEN.generate(
-    //   path.join(srcDir, 'm2-testnet'),
-    //   path.join(outputDir, 'm2-testnet'),
-    //   builtin
-    // )
     const num5 = await MOVEMENT_TESTNET_CODEGEN.generate(
       path.join(srcDir, 'movement-testnet'),
       path.join(outputDir, 'movement-testnet'),

package/src/aptos/context.ts

@@ -1,6 +1,6 @@
 import { RecordMetaData } from '@sentio/protos'
 import { type Labels, normalizeLabels } from '../index.js'
-import { MoveCoder } from './index.js'
+import { MoveCoder, RichAptosClientWithContext } from './index.js'
 import {
   Aptos,
   Event,
@@ -13,14 +13,33 @@ import { defaultMoveCoder } from './move-coder.js'
 import { AptosNetwork } from './network.js'
 import { Endpoints } from '@sentio/runtime'
 import { ServerError, Status } from 'nice-grpc'
-import { MoveAccountContext, MoveContext } from '../move/index.js'
+import { MoveContext } from '../move/index.js'
 
-export class AptosContext extends MoveContext<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
-  moduleName: string
+export abstract class AptosBaseContext extends MoveContext<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
   version: bigint
+  coder: MoveCoder
+
+  protected constructor(network: AptosNetwork, version: bigint, labels?: Labels) {
+    super(labels)
+    this.network = network
+    this.coder = defaultMoveCoder(this.network)
+    this.version = version
+  }
+
+  getClient(): Aptos {
+    let chainServer = Endpoints.INSTANCE.chainServer.get(this.network)
+    if (!chainServer) {
+      throw new ServerError(Status.INTERNAL, 'RPC endpoint not provided')
+    }
+    chainServer = chainServer + '/v1'
+    return new RichAptosClientWithContext(this, new AptosConfig({ fullnode: chainServer }))
+  }
+}
+
+export class AptosContext extends AptosBaseContext {
+  moduleName: string
   transaction: UserTransactionResponse
   eventIndex: number
-  coder: MoveCoder
 
   constructor(
     moduleName: string,
@@ -31,13 +50,10 @@ export class AptosContext extends MoveContext<AptosNetwork, MoveModuleBytecode,
     eventIndex: number,
     baseLabels: Labels | undefined
   ) {
-    super(baseLabels)
+    super(network, version, baseLabels)
     this.address = address.toLowerCase()
-    this.network = network
     this.moduleName = moduleName
-    this.version = version
     this.eventIndex = eventIndex
-    this.coder = defaultMoveCoder(network)
     if (transaction) {
       this.transaction = transaction
     }
@@ -71,22 +87,17 @@ export class AptosContext extends MoveContext<AptosNetwork, MoveModuleBytecode,
       throw new ServerError(Status.INTERNAL, 'RPC endpoint not provided')
     }
     chainServer = chainServer + '/v1'
-    return new Aptos(new AptosConfig({ fullnode: chainServer }))
+    return new RichAptosClientWithContext(this, new AptosConfig({ fullnode: chainServer }))
   }
 }
 
-export class AptosResourcesContext extends MoveAccountContext<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
-  version: bigint
+export class AptosResourcesContext extends AptosBaseContext {
   timestampInMicros: number
-  coder: MoveCoder
 
   constructor(network: AptosNetwork, address: string, version: bigint, timestampInMicros: number, baseLabels?: Labels) {
-    super(baseLabels)
+    super(network, version, baseLabels)
     this.address = address
-    this.network = network
-    this.version = version
     this.timestampInMicros = timestampInMicros
-    this.coder = defaultMoveCoder(network)
   }
 
   getChainId() {
@@ -110,13 +121,4 @@ export class AptosResourcesContext extends MoveAccountContext<AptosNetwork, Move
       labels: normalizeLabels(labels)
     }
   }
-
-  getClient(): Aptos {
-    let chainServer = Endpoints.INSTANCE.chainServer.get(this.network)
-    if (!chainServer) {
-      throw new ServerError(Status.INTERNAL, 'RPC endpoint not provided')
-    }
-    chainServer = chainServer + '/v1'
-    return new Aptos(new AptosConfig({ fullnode: chainServer }))
-  }
 }

package/src/aptos/ext/token.ts

@@ -2,14 +2,15 @@ import { getPriceByType } from '../../utils/index.js'
 import fetch from 'node-fetch'
 import { accountTypeString, parseMoveType, SPLITTER } from '@typemove/move'
 import { AptosNetwork, getClient } from '../network.js'
-import { coin } from '../builtin/0x1.js'
+import { coin, fungible_asset, type_info } from '../builtin/0x1.js'
 import { MoveStructId } from '@aptos-labs/ts-sdk'
 import { AptosChainId } from '@sentio/chain'
 import { DEFAULT_TOKEN_LIST, InternalTokenInfo } from './token-list.js'
 import { BaseCoinInfo } from '../../move/ext/index.js'
+import { RichAptosClient } from '../api.js'
 
 export interface TokenInfo extends BaseCoinInfo {
-  type: `0x${string}` // either tokenAddress or faAddress
+  type: `0x${string}` // either tokenAddress or faAddress, if both are present, tokenAddress is used
   tokenAddress?: `0x${string}`
   faAddress?: `0x${string}`
   name: string
@@ -92,48 +93,97 @@ export function isWhiteListToken(token: string): boolean {
   return TOKEN_MAP.has(accountTypeString(token))
 }
 
-const TOKEN_METADATA_CACHE = new Map<string, Promise<any | null>>()
+const TOKEN_METADATA_CACHE = new Map<string, Promise<TokenInfo>>()
+
+// Go to more common method
+function toTypeString(ty: type_info.TypeInfo) {
+  const module = Buffer.from(ty.module_name.replace('0x', ''), 'hex')
+  const name = Buffer.from(ty.struct_name.replace('0x', ''), 'hex')
+  return `${ty.account_address}::${module.toString('utf-8')}::${name.toString('utf-8')}`
+}
+
+async function getFungibleTokenInfo(client: RichAptosClient, faAddress: `0x${string}`): Promise<TokenInfo> {
+  const meta = await client.getTypedAccountResource({
+    accountAddress: faAddress,
+    resourceType: fungible_asset.Metadata.type()
+  })
+  if (!meta) {
+    throw Error('fa token not existed: ' + faAddress)
+  }
+
+  const paired = await coin.view.pairedCoin(client, { functionArguments: [faAddress] })
+  let type = faAddress
+  let tokeType
+  if (paired[0].vec[0]) {
+    tokeType = type = toTypeString(paired[0].vec[0]) as `0x${string}`
+  }
+
+  return {
+    type: type,
+    category: 'Native',
+    tokenAddress: tokeType,
+    faAddress: faAddress as `0x${string}`,
+    name: meta.name,
+    symbol: meta.symbol,
+    decimals: meta.decimals,
+    bridge: 'Native',
+    logoUrl: meta.icon_uri,
+    websiteUrl: meta.project_uri
+  }
+}
+
+async function getCoinTokenInfo(client: RichAptosClient, type: MoveStructId): Promise<TokenInfo> {
+  const account = type.split(SPLITTER)[0]
+
+  const info = await client.getTypedAccountResource({
+    accountAddress: account,
+    resourceType: coin.CoinInfo.type(parseMoveType(type))
+  })
+
+  if (!info) {
+    throw Error('coin not existed: ' + type)
+  }
+
+  const paired = await coin.view.pairedMetadata(client, { typeArguments: [type] })
+  let faAddress
+  if (paired[0].vec[0]) {
+    faAddress = paired[0].vec[0] as `0x${string}`
+  }
+
+  return {
+    type: type as `0x${string}`,
+    category: 'Native',
+    tokenAddress: type as `0x${string}`,
+    faAddress,
+    name: info.name,
+    symbol: info.symbol,
+    decimals: info.decimals,
+    bridge: 'Native'
+  }
+}
 
 // token: address of the fungible asset, e.g. "0xa", or the coin type, e.g. "0x1::aptos::AptosCoin"
 export async function getTokenInfoWithFallback(token: string, network?: AptosNetwork): Promise<TokenInfo> {
   const r = TOKEN_MAP.get(token)
-  if (!r) {
-    network = network || AptosNetwork.MAIN_NET
-    const key = network + '_' + token
-    let promise = TOKEN_METADATA_CACHE.get(key)
-    if (!promise) {
-      const client = getClient(network)
-      // client.getDigitalAssetData()
-
-      let account = token
-      let metadataType: MoveStructId = `0x1::fungible_asset::Metadata`
-      if (account.includes(SPLITTER)) {
-        account = account.split(SPLITTER)[0]
-        metadataType = coin.CoinInfo.type(parseMoveType(token)).getSignature() as MoveStructId
-      }
-
-      promise = client.getAccountResource({ accountAddress: account, resourceType: metadataType })
-      TOKEN_METADATA_CACHE.set(key, promise)
-    }
-    const meta = await promise
-    if (meta === null) {
-      throw Error('Coin not existed ' + key)
-    }
-
-    // const parts = type.split(SPLITTER)
-    return {
-      type: token as `0x${string}`,
-      category: 'Native',
-      tokenAddress: token as `0x${string}`,
-      name: meta.name,
-      symbol: meta.symbol,
-      decimals: meta.decimals,
-      bridge: 'Native',
-      logoUrl: meta.icon_uri,
-      websiteUrl: meta.project_uri
+  if (r) {
+    return r
+  }
+  network = network || AptosNetwork.MAIN_NET
+  const key = network + '_' + token
+  let promise = TOKEN_METADATA_CACHE.get(key)
+  const isFungibleAsset = !token.includes(SPLITTER)
+  const client = getClient(network)
+
+  if (!promise) {
+    if (isFungibleAsset) {
+      promise = getFungibleTokenInfo(client, token as `0x${string}`)
+    } else {
+      promise = getCoinTokenInfo(client, token as MoveStructId)
     }
+    TOKEN_METADATA_CACHE.set(key, promise)
   }
-  return r
+
+  return promise
 }
 
 export async function getPriceForToken(
@@ -141,9 +191,6 @@ export async function getPriceForToken(
   timestamp: number,
   network = AptosChainId.APTOS_MAINNET
 ): Promise<number> {
-  // if (!isWhiteListToken(token)) {
-  //   return 0.0
-  // }
   const date = new Date(timestamp / 1000)
   try {
     return (await getPriceByType(network, token, date)) || 0

package/src/aptos/index.ts

@@ -13,7 +13,7 @@ export * from './api.js'
 
 export { AptosPlugin } from './aptos-plugin.js'
 
-export { defaultMoveCoder } from './move-coder.js'
+export { defaultMoveCoder, defaultMoveCoderForClient } from './move-coder.js'
 
 export { MoveCoder } from '@typemove/aptos'
 

package/src/aptos/move-coder.ts

@@ -1,14 +1,31 @@
 import { AptosNetwork, getClient } from './network.js'
 import { MoveCoder } from '@typemove/aptos'
+import { Aptos } from '@aptos-labs/ts-sdk'
 
 const CODERS = new Map<AptosNetwork, MoveCoder>()
+const URL_CODERS = new Map<string, MoveCoder>()
 
 export function defaultMoveCoder(network: AptosNetwork = AptosNetwork.MAIN_NET): MoveCoder {
   let coder = CODERS.get(network)
   if (!coder) {
+    const client = getClient(network)
     coder = new MoveCoder(getClient(network))
     CODERS.set(network, coder)
+    URL_CODERS.set(client.config.fullnode || '', coder)
   }
 
   return coder
 }
+
+// TODO this function need to use used inside context, otherwise can't be init
+export function defaultMoveCoderForClient(client: Aptos): MoveCoder {
+  if (!client.config.fullnode) {
+    throw new Error('Fullnode is not defined')
+  }
+  let coder = URL_CODERS.get(client.config.fullnode)
+  if (!coder) {
+    coder = new MoveCoder(client)
+    URL_CODERS.set(client.config.fullnode, coder)
+  }
+  return coder
+}

package/src/aptos/network.ts

@@ -2,6 +2,7 @@ import { AptosChainId } from '@sentio/chain'
 import { Aptos, AptosConfig } from '@aptos-labs/ts-sdk'
 import { Labels } from '../core/index.js'
 import { Endpoints } from '@sentio/runtime'
+import { RichAptosClient } from './api.js'
 
 export type AptosNetwork = AptosChainId
 
@@ -39,7 +40,7 @@ export function getRpcEndpoint(network: AptosNetwork): string {
   }
 }
 
-export function getClient(network: AptosNetwork): Aptos {
+export function getClient(network: AptosNetwork): RichAptosClient {
   let chainServer = Endpoints.INSTANCE.chainServer.get(network)
   if (!chainServer) {
     chainServer = getRpcEndpoint(network)
@@ -47,5 +48,5 @@ export function getClient(network: AptosNetwork): Aptos {
   } else {
     chainServer = chainServer + '/v1'
   }
-  return new Aptos(new AptosConfig({ fullnode: chainServer }))
+  return new RichAptosClient(new AptosConfig({ fullnode: chainServer }))
 }

package/src/sui/builtin/0x1.ts

@@ -1963,7 +1963,7 @@ export namespace option {
       client: SuiClient,
       args: [option.Option<T0>],
       typeArguments: [TypeDescriptor<T0> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[]]>> {
       const tx = new Transaction();
       builder.toVec(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -1971,9 +1971,9 @@ export namespace option {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[]]>(
+        inspectRes,
+      );
     }
   }
 }
@@ -5527,7 +5527,7 @@ export namespace vector {
       client: SuiClient,
       args: [],
       typeArguments: [TypeDescriptor<T0> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[]]>> {
       const tx = new Transaction();
       builder.empty(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -5535,15 +5535,15 @@ export namespace vector {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[]]>(
+        inspectRes,
+      );
     }
     export async function flatten<T0 = any>(
       client: SuiClient,
       args: [string[]],
       typeArguments: [TypeDescriptor<T0> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[]]>> {
       const tx = new Transaction();
       builder.flatten(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -5551,9 +5551,9 @@ export namespace vector {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[]]>(
+        inspectRes,
+      );
     }
     export async function indexOf<T0 = any>(
       client: SuiClient,
@@ -5687,7 +5687,7 @@ export namespace vector {
       client: SuiClient,
       args: [T0],
       typeArguments: [TypeDescriptor<T0> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[]]>> {
       const tx = new Transaction();
       builder.singleton(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -5695,9 +5695,9 @@ export namespace vector {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[]]>(
+        inspectRes,
+      );
     }
     export async function swap<T0 = any>(
       client: SuiClient,

package/src/sui/builtin/0x2.ts

@@ -22698,7 +22698,7 @@ export namespace vec_map {
       client: SuiClient,
       args: [vec_map.VecMap<T0, T1>],
       typeArguments: [TypeDescriptor<T0> | string, TypeDescriptor<T1> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string, T1[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[], T1[]]>> {
       const tx = new Transaction();
       builder.intoKeysValues(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -22706,9 +22706,9 @@ export namespace vec_map {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string, T1[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[], T1[]]>(
+        inspectRes,
+      );
     }
     export async function isEmpty<T0 = any, T1 = any>(
       client: SuiClient,
@@ -22730,7 +22730,7 @@ export namespace vec_map {
       client: SuiClient,
       args: [string],
       typeArguments: [TypeDescriptor<T0> | string, TypeDescriptor<T1> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[]]>> {
       const tx = new Transaction();
       builder.keys(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -22738,9 +22738,9 @@ export namespace vec_map {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[]]>(
+        inspectRes,
+      );
     }
     export async function pop<T0 = any, T1 = any>(
       client: SuiClient,
@@ -22849,7 +22849,7 @@ export class vec_set extends SuiBaseProcessor {
 
 export namespace vec_set {
   export interface VecSet<T0> {
-    contents: T0[] | string;
+    contents: T0[];
   }
 
   export namespace VecSet {
@@ -23141,7 +23141,7 @@ export namespace vec_set {
       client: SuiClient,
       args: [vec_set.VecSet<T0>],
       typeArguments: [TypeDescriptor<T0> | string],
-    ): Promise<TypedDevInspectResults<[T0[] | string]>> {
+    ): Promise<TypedDevInspectResults<[T0[]]>> {
       const tx = new Transaction();
       builder.intoKeys(tx, args, typeArguments);
       const inspectRes = await client.devInspectTransactionBlock({
@@ -23149,9 +23149,9 @@ export namespace vec_set {
         sender: ZERO_ADDRESS,
       });
 
-      return (await getMoveCoder(client)).decodeDevInspectResult<
-        [T0[] | string]
-      >(inspectRes);
+      return (await getMoveCoder(client)).decodeDevInspectResult<[T0[]]>(
+        inspectRes,
+      );
     }
     export async function isEmpty<T0 = any>(
       client: SuiClient,