@sentio/sdk 2.59.0-rc.4 → 2.59.0-rc.40

package/src/aptos/data.ts

@@ -0,0 +1,123 @@
+import { Data_AptEvent, Data_AptCall, Data_AptResource } from '@sentio/protos'
+import { UserTransactionResponse, MoveResource } from '@aptos-labs/ts-sdk'
+import { MoveCoder, decodeResourceChange, ResourceChange } from '@typemove/aptos'
+
+type Data_AptEvent_Ext = Data_AptEvent & {
+  _tx?: UserTransactionResponse
+  _event?: any
+  _decodedEvent?: any
+}
+
+type Data_AptCall_Ext = Data_AptCall & {
+  _tx?: UserTransactionResponse
+  _decodedCall?: any
+}
+
+type Data_AptResource_Ext = Data_AptResource & {
+  _resources?: MoveResource[]
+  _decodedResources?: ResourceChange<any>[]
+}
+
+export class AptEvent implements Data_AptEvent {
+  constructor(readonly data: Data_AptEvent_Ext) {}
+
+  get rawEvent(): string {
+    return this.data.rawEvent
+  }
+  get eventIndex(): number {
+    return this.data.eventIndex
+  }
+  get rawTransaction(): string {
+    return this.data.rawTransaction
+  }
+
+  get transaction() {
+    if (!this.data._tx) {
+      this.data._tx = JSON.parse(this.data.rawTransaction) as UserTransactionResponse
+      if (this.data._tx.events == null) {
+        this.data._tx.events = []
+      }
+    }
+    return this.data._tx
+  }
+
+  get event() {
+    if (!this.data._event) {
+      this.data._event = JSON.parse(this.data.rawEvent)
+    }
+    return this.data._event
+  }
+
+  async decodeEvent(coder: MoveCoder) {
+    if (!this.data._decodedEvent) {
+      this.data._decodedEvent = await coder.decodeEvent<any>(this.event)
+      return this.data._decodedEvent
+    }
+    return this.data._decodedEvent
+  }
+}
+
+export class AptCall implements Data_AptCall {
+  constructor(readonly data: Data_AptCall_Ext) {}
+
+  get rawTransaction(): string {
+    return this.data.rawTransaction
+  }
+
+  get transaction() {
+    if (!this.data._tx) {
+      this.data._tx = JSON.parse(this.data.rawTransaction) as UserTransactionResponse
+      if (this.data._tx.events == null) {
+        this.data._tx.events = []
+      }
+    }
+    return this.data._tx
+  }
+
+  async decodeCall(coder: MoveCoder) {
+    if (!this.data._decodedCall) {
+      const tx = this.transaction
+      let payload = tx.payload
+      if (payload.type === 'multisig_payload') {
+        payload = (payload as any).transaction_payload ?? payload
+      }
+      this.data._decodedCall = await coder.decodeFunctionPayload(payload as any)
+      return this.data._decodedCall
+    }
+    return this.data._decodedCall
+  }
+}
+
+export class AptResource implements Data_AptResource {
+  constructor(readonly data: Data_AptResource_Ext) {}
+
+  get version(): bigint {
+    return this.data.version
+  }
+
+  get timestampMicros(): bigint {
+    return this.data.timestampMicros
+  }
+
+  get rawResources(): string[] {
+    return this.data.rawResources
+  }
+
+  get resources(): MoveResource[] {
+    if (!this.data._resources) {
+      this.data._resources = this.data.rawResources.map((r) => JSON.parse(r) as MoveResource)
+    }
+    return this.data._resources
+  }
+
+  get timestamp(): Date {
+    return new Date(Number(this.data.timestampMicros) / 1000)
+  }
+
+  async decodeResources<T>(coder: MoveCoder): Promise<ResourceChange<T>[]> {
+    if (!this.data._decodedResources) {
+      this.data._decodedResources = await decodeResourceChange<T>(this.resources, coder)
+    }
+    return this.data._decodedResources as ResourceChange<T>[]
+  }
+}

package/src/aptos/index.ts

@@ -20,4 +20,6 @@ export { MoveCoder } from '@typemove/aptos'
 
 export { BUILTIN_TYPES } from '@typemove/move'
 
+export { type HandlerOptions, type PartitionHandler } from './models.js'
+
 // export * from './utils.js'

package/src/aptos/models.ts

@@ -27,3 +27,5 @@ export type TypedFunctionPayload<T extends Array<any>> = EntryFunctionPayloadRes
    */
   arguments_decoded: T
 }
+
+export type { PartitionHandler, HandlerOptions } from '../core/index.js'

package/src/aptos/move-coder.ts

@@ -1,6 +1,7 @@
 import { AptosNetwork, getClient } from './network.js'
-import { MoveCoder } from '@typemove/aptos'
-import { Aptos } from '@aptos-labs/ts-sdk'
+import { MoveCoder, TypedFunctionPayload } from '@typemove/aptos'
+import { Aptos, EntryFunctionPayloadResponse } from '@aptos-labs/ts-sdk'
+import { TypeDescriptor, VECTOR_STR } from '@typemove/move'
 
 const CODERS = new Map<AptosNetwork, MoveCoder>()
 const URL_CODERS = new Map<string, MoveCoder>()
@@ -9,7 +10,8 @@ export function defaultMoveCoder(network: AptosNetwork = AptosNetwork.MAIN_NET):
   let coder = CODERS.get(network)
   if (!coder) {
     const client = getClient(network)
-    coder = new MoveCoder(getClient(network), network == AptosNetwork.INITIA_ECHELON)
+
+    coder = network == AptosNetwork.INITIA_ECHELON ? new InitiaMoveCoder(client) : new MoveCoder(client)
     CODERS.set(network, coder)
     URL_CODERS.set(client.config.fullnode || '', coder)
   }
@@ -29,3 +31,94 @@ export function defaultMoveCoderForClient(client: Aptos): MoveCoder {
   }
   return coder
 }
+
+export class InitiaMoveCoder extends MoveCoder {
+  constructor(client: Aptos) {
+    super(client, true)
+  }
+
+  async decodeFunctionPayload<T extends Array<any>>(
+    payload: EntryFunctionPayloadResponse
+  ): Promise<TypedFunctionPayload<T>> {
+    const func = await this.getMoveFunction(payload.function)
+    const paramsTypes = this.adapter.getMeaningfulFunctionParams(func.params)
+    const argumentsDecoded = []
+
+    for (let i = 0; i < paramsTypes.length; i++) {
+      const arg = payload.arguments[i]
+      const paramType = paramsTypes[i]
+      if (arg == null) {
+        argumentsDecoded.push(null)
+      } else {
+        argumentsDecoded.push(await this.decodeBase64(Buffer.from(arg, 'base64'), paramType))
+      }
+    }
+
+    return {
+      ...payload,
+      arguments_decoded: argumentsDecoded
+    } as TypedFunctionPayload<T>
+  }
+
+  protected async decodeBase64(b: Buffer, type: TypeDescriptor): Promise<any> {
+    switch (type.qname.toLowerCase()) {
+      case 'signer': // TODO check this, aptos only
+      case 'address':
+      case '0x1::string::String':
+        return b.toString()
+      case 'bool':
+        return b.readUInt8() !== 0 // Convert first byte to boolean
+      case 'u8':
+        return b.readUInt8()
+      case 'u16':
+        return b.readUInt16LE()
+      case 'u32':
+        return b.readUInt32LE()
+      case 'u64':
+        return b.readBigUInt64LE()
+      case 'u128':
+      case 'u256':
+        const hex = b.toString('hex')
+        const reversedHex = hex.match(/.{2}/g)?.reverse().join('') || ''
+        return BigInt('0x' + reversedHex)
+      case '0x1::object::object':
+        return b.toString('hex')
+      case VECTOR_STR:
+        // vector<u8> as hex string
+        if (type.typeArgs[0].qname === 'u8' || type.typeArgs[0].qname === 'U8') {
+          return b.toString('hex')
+        }
+
+        console.warn(`can't decode vector type: ${type.qname}, data: ${b.toString('base64')}`)
+        return b.toString('base64')
+      default:
+        // try enum type first
+        const enumType = await this.maybeGetMoveEnum(type.qname)
+        if (enumType) {
+          return b.toString('utf-8')
+        }
+
+        // Process complex type
+        /*const struct = await this.getMoveStruct(type.qname)
+
+        const typeCtx = new Map<string, TypeDescriptor>()
+        for (const [idx, typeArg] of type.typeArgs.entries()) {
+          typeCtx.set('T' + idx, typeArg)
+        }
+
+        const typedData: any = {}
+
+        for (const field of struct.fields) {
+          let filedType = field.type
+          filedType = filedType.applyTypeArgs(typeCtx)
+          const fieldValue = this.adapter.getData(data)[field.name]
+          const value = await this.decode(fieldValue, filedType)
+          typedData[field.name] = value
+        }*/
+
+        // todo: how to decode complex type?
+        console.warn(`can't decode type:${type.qname}, data: ${b.toString('base64')}`)
+        return b.toString('hex')
+    }
+  }
+}

package/src/aptos/network.ts

@@ -25,6 +25,7 @@ export class AptosBindOptions {
   network?: AptosNetwork = AptosNetwork.MAIN_NET
   client?: Aptos
   startVersion?: bigint | number
+  endVersion?: bigint | number
   baseLabels?: Labels
 }
 

package/src/btc/btc-plugin.ts

@@ -7,10 +7,12 @@ import {
   HandlerType,
   ProcessConfigResponse,
   ProcessResult,
+  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
 
 import { ServerError, Status } from 'nice-grpc'
+import { PartitionHandlerManager } from '../core/index.js'
 import { TemplateInstanceState } from '../core/template.js'
 import { BTCProcessorState } from './btc-processor.js'
 import { filters2Proto, TransactionFilter } from './filter.js'
@@ -27,6 +29,8 @@ export class BTCPlugin extends Plugin {
     blockHandlers: []
   }
 
+  partitionManager = new PartitionHandlerManager()
+
   async configure(config: ProcessConfigResponse) {
     const handlers: Handlers = {
       txHandlers: [],
@@ -47,6 +51,11 @@ export class BTCPlugin extends Plugin {
       })
       for (const callHandler of processor.callHandlers) {
         const handlerId = handlers.txHandlers.push(callHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(
+          HandlerType.BTC_TRANSACTION,
+          handlerId,
+          callHandler.partitionHandler
+        )
         const handlerName = callHandler.handlerName
 
         if (callHandler.filter) {
@@ -70,6 +79,7 @@ export class BTCPlugin extends Plugin {
 
       for (const blockHandler of processor.blockHandlers) {
         const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.BTC_BLOCK, handlerId, blockHandler.partitionHandler)
         contractConfig.intervalConfigs.push({
           slot: 0,
           slotInterval: blockHandler.blockInterval,
@@ -107,6 +117,34 @@ export class BTCPlugin extends Plugin {
     }
   }
 
+  async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
+    let data: any
+    switch (request.handlerType) {
+      case HandlerType.BTC_TRANSACTION:
+        if (!request.data?.btcTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "btcTransaction can't be empty")
+        }
+        data = request.data.btcTransaction
+        break
+      case HandlerType.BTC_BLOCK:
+        if (!request.data?.btcBlock) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "btcBlock can't be empty")
+        }
+        data = request.data.btcBlock
+        break
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+    const partitions = await this.partitionManager.processPartitionForHandlerType(
+      request.handlerType,
+      request.handlerIds,
+      data
+    )
+    return {
+      partitions
+    }
+  }
+
   async start(request: StartRequest) {}
 
   stateDiff(config: ProcessConfigResponse): boolean {

package/src/btc/btc-processor.ts

@@ -2,7 +2,7 @@ import { ListStateStorage } from '@sentio/runtime'
 import { BlockHandler, BTCBlock, BTCBlockContext, BTCContext, BTCOnIntervalFetchConfig, Transaction } from './types.js'
 import { Data_BTCBlock, Data_BTCTransaction, HandleInterval, ProcessResult } from '@sentio/protos'
 import { TransactionFilters } from './filter.js'
-import { PromiseOrVoid } from '../core/index.js'
+import { HandlerOptions, PromiseOrVoid } from '../core/index.js'
 import { ServerError, Status } from 'nice-grpc'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
@@ -26,7 +26,8 @@ export class BTCProcessor {
 
   public onTransaction(
     handler: (transaction: Transaction, ctx: BTCContext) => void | Promise<void>,
-    filter?: TransactionFilters
+    filter?: TransactionFilters,
+    handlerOptions?: HandlerOptions<object, Transaction>
   ) {
     const callHandler = {
       handlerName: getHandlerName(),
@@ -42,7 +43,16 @@ export class BTCProcessor {
         await handler(tx, ctx)
         return ctx.stopAndGetResult()
       },
-      filter
+      filter,
+      partitionHandler: async (call: Data_BTCTransaction): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const tx = call.transaction as Transaction
+          return p(tx)
+        }
+        return p
+      }
     }
     this.callHandlers.push(callHandler)
     return this
@@ -52,7 +62,7 @@ export class BTCProcessor {
     handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined,
-    fetchConfig?: BTCOnIntervalFetchConfig
+    handlerOptions?: HandlerOptions<BTCOnIntervalFetchConfig, BTCBlock>
   ): this {
     if (timeInterval) {
       if (timeInterval.backfillInterval < timeInterval.recentInterval) {
@@ -75,7 +85,7 @@ export class BTCProcessor {
         const block = {
           ...header
         } as BTCBlock
-        if (fetchConfig?.getTransactions) {
+        if (handlerOptions?.getTransactions) {
           block.tx = header.rawtx?.map((tx: any) => tx as Transaction)
         }
 
@@ -88,7 +98,21 @@ export class BTCProcessor {
         await handler(block, ctx)
         return ctx.stopAndGetResult()
       },
-      fetchConfig
+      fetchConfig: handlerOptions,
+      partitionHandler: async (data: Data_BTCBlock): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const header = data.block
+          if (!header) return undefined
+          const block = { ...header } as BTCBlock
+          if (handlerOptions?.getTransactions) {
+            block.tx = header.rawtx?.map((tx: any) => tx as Transaction)
+          }
+          return p(block)
+        }
+        return p
+      }
     })
     return this
   }
@@ -97,7 +121,7 @@ export class BTCProcessor {
     handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
     blockInterval = 250,
     backfillBlockInterval = 1000,
-    fetchConfig?: BTCOnIntervalFetchConfig
+    handlerOptions?: HandlerOptions<BTCOnIntervalFetchConfig, BTCBlock>
   ): this {
     return this.onInterval(
       handler,
@@ -106,7 +130,7 @@ export class BTCProcessor {
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
       },
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -114,13 +138,13 @@ export class BTCProcessor {
     handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
-    fetchConfig?: BTCOnIntervalFetchConfig
+    handlerOptions?: HandlerOptions<BTCOnIntervalFetchConfig, BTCBlock>
   ): this {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
       undefined,
-      fetchConfig
+      handlerOptions
     )
   }
 }
@@ -137,4 +161,5 @@ export type CallHandler<T> = {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   filter?: TransactionFilters
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }

package/src/btc/types.ts

@@ -126,8 +126,9 @@ export type BlockHandler = {
   handler: (block: Data_BTCBlock) => Promise<ProcessResult>
   handlerName: string
   fetchConfig?: BTCOnIntervalFetchConfig
+  partitionHandler?: (block: Data_BTCBlock) => Promise<string | undefined>
 }
 
 export type BTCOnIntervalFetchConfig = {
-  getTransactions: boolean
+  getTransactions?: boolean
 }

package/src/core/base-context.ts

@@ -1,15 +1,17 @@
 import { ProcessResult, RecordMetaData } from '@sentio/protos'
-import { EventLoggerBinding } from './event-logger.js'
-import { Meter, Labels } from './meter.js'
+import { EventLoggerBinding, EventLoggerBindingNew } from './event-logger.js'
+import { Meter, Labels, MeterNew } from './meter.js'
 import { ChainId } from '@sentio/chain'
-import { mergeProcessResults, PluginManager } from '@sentio/runtime'
+import { mergeProcessResultsInPlace, PluginManager } from '@sentio/runtime'
 import { Required } from 'utility-types'
 import { ServerError, Status } from 'nice-grpc'
 import { Store } from '../store/store.js'
 
 export abstract class BaseContext {
   meter: Meter
+  meterNew: MeterNew
   eventLogger: EventLoggerBinding
+  eventLoggerNew: EventLoggerBindingNew
   private _store: Store
   baseLabels: Labels
   private active: boolean
@@ -21,12 +23,13 @@ export abstract class BaseContext {
     gauges: [],
     states: {
       configUpdated: false
-    }
+    },
+    timeseriesResult: []
   }
 
   public update(res: Partial<ProcessResult>) {
     if (this.active) {
-      this._res = mergeProcessResults([this._res, ProcessResult.fromPartial(res)])
+      mergeProcessResultsInPlace(this._res, [ProcessResult.fromPartial(res)])
     } else {
       throw new ServerError(Status.INTERNAL, 'context not active, possible async function invoke without await')
     }
@@ -34,7 +37,9 @@ export abstract class BaseContext {
 
   protected constructor(baseLabels: Labels | undefined) {
     this.meter = new Meter(this)
+    this.meterNew = new MeterNew(this)
     this.eventLogger = new EventLoggerBinding(this)
+    this.eventLoggerNew = new EventLoggerBindingNew(this)
     this.baseLabels = baseLabels || {}
     this.active = true
     this.initStore()

package/src/core/event-logger.ts

@@ -6,7 +6,10 @@ import {
   EventLogConfig_Field,
   EventLogConfig_StructFieldType,
   EventTrackingResult,
-  LogLevel
+  LogLevel,
+  RichStruct,
+  TimeseriesResult,
+  TimeseriesResult_TimeseriesType
 } from '@sentio/protos'
 import { normalizeAttribute, normalizeLabels, normalizeToRichStruct } from './normalization.js'
 import { MapStateStorage, processMetrics } from '@sentio/runtime'
@@ -141,3 +144,44 @@ function checkEventName(eventName: string) {
     throw new Error(`Event name ${eventName} is already used in the database schema`)
   }
 }
+
+function emitNew<T>(ctx: BaseContext, eventName: string, event: Event<T>) {
+  const { distinctId, severity, message, ...payload } = event
+
+  const data: RichStruct = {
+    fields: {
+      severity: {
+        stringValue: (severity || LogLevel.INFO).toString()
+      },
+      message: {
+        stringValue: message || ''
+      },
+      distinctEntityId: {
+        stringValue: distinctId || ''
+      },
+      ...normalizeToRichStruct(ctx.baseLabels, payload).fields
+    }
+  }
+  const res: TimeseriesResult = {
+    metadata: ctx.getMetaData(eventName, {}),
+    type: TimeseriesResult_TimeseriesType.EVENT,
+    data,
+    runtimeInfo: undefined
+  }
+
+  processMetrics.process_eventemit_count.add(1)
+  ctx.update({ timeseriesResult: [res] })
+}
+
+export class EventLoggerBindingNew {
+  private readonly ctx: BaseContext
+
+  constructor(ctx: BaseContext) {
+    this.ctx = ctx
+  }
+
+  emit<T>(eventName: string, event: Event<T>) {
+    checkEventName(eventName)
+    emitNew(this.ctx, eventName, event)
+  }
+}

package/src/core/handler-options.ts

@@ -0,0 +1,40 @@
+/**
+ * Function type that extracts a partition key from data.
+ * @template D The data type to process
+ */
+export type PartitionHandler<D> = (data: D) => string | Promise<string>
+
+/**
+ * Handler options that extend fetch configuration with optional partitioning support.
+ * @template F The fetch configuration type (e.g., EthFetchConfig, MoveFetchConfig)
+ * @template D The data type that will be processed (e.g., Event, Transaction, Block)
+ */
+export type HandlerOptions<F, D> = Partial<F> & {
+  /**
+   * Optional partition key for data partitioning.
+   * Can be a static string or a function that computes the key from the data.
+   */
+  partitionKey?: string | PartitionHandler<D>
+}
+
+/**
+ * Merge two handler options, with the second options taking precedence over the first.
+ * @param options1 First handler options
+ * @param options2 Second handler options (takes precedence)
+ * @returns Merged handler options
+ */
+export function mergeHandlerOptions<F, D>(
+  options1?: HandlerOptions<F, D>,
+  options2?: HandlerOptions<F, D>
+): HandlerOptions<F, D> | undefined {
+  if (!options1 && !options2) return undefined
+  if (!options1) return options2
+  if (!options2) return options1
+
+  return {
+    ...options1,
+    ...options2,
+    // For partitionKey, the second option takes precedence
+    partitionKey: options2.partitionKey ?? options1.partitionKey
+  }
+}

package/src/core/index.ts

@@ -3,7 +3,18 @@ export type { PromiseOrValue, PromiseOrVoid } from './promises.js'
 export type { PartiallyOptional } from './partial-optional.js'
 export { BaseContext } from './base-context.js'
 export { normalizeLabels } from './normalization.js'
-export { CounterBinding, Meter, type Labels, GaugeBinding, Counter, Gauge, MetricOptions } from './meter.js'
+export {
+  CounterBinding,
+  Meter,
+  type Labels,
+  GaugeBinding,
+  Counter,
+  Gauge,
+  MetricOptions,
+  CounterNew,
+  GaugeNew,
+  MeterNew
+} from './meter.js'
 export { Exporter } from './exporter.js'
 export * from './event-logger.js'
 export { type Numberish, toBigInteger, toMetricValue } from './numberish.js'
@@ -11,3 +22,8 @@ export { type Numberish, toBigInteger, toMetricValue } from './numberish.js'
 export { CorePlugin } from './core-plugin.js'
 export { DatabaseSchema } from './database-schema.js'
 export * from './constants.js'
+export { type HandlerOptions, type PartitionHandler, mergeHandlerOptions } from './handler-options.js'
+export {
+  PartitionHandlerManager,
+  type PartitionHandler as PartitionHandlerFunction
+} from './partition-handler-manager.js'