@sentio/sdk 3.9.0-rc.9 → 4.0.0-rc.2

package/src/solana/solana-context.ts

@@ -1,5 +1,6 @@
-import { normalizeLabels, Labels, BaseContext, RecordMetaData } from '../index.js'
+import { normalizeLabels, Labels, BaseContext, RecordMetaData, RecordMetaDataSchema } from '../index.js'
 import { SolanaChainId } from '@sentio/chain'
+import { create } from '@bufbuild/protobuf'
 import type { TransactionResponse } from './solana-rpc-types.js'
 
 export class SolanaContext extends BaseContext {
@@ -30,7 +31,7 @@ export class SolanaContext extends BaseContext {
   }
 
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
+    return create(RecordMetaDataSchema, {
       address: this.address,
       contractName: this.programName,
       blockNumber: this.blockNumber,
@@ -40,6 +41,6 @@ export class SolanaContext extends BaseContext {
       chainId: this.getChainId(),
       name: name,
       labels: normalizeLabels(labels)
-    }
+    })
   }
 }

package/src/solana/solana-plugin.ts

@@ -1,15 +1,16 @@
 import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
-  ContractConfig,
+  ContractConfigSchema,
   DataBinding,
   HandlerType,
   InitResponse,
-  OnIntervalConfig,
+  InstructionHandlerConfigSchema,
+  OnIntervalConfigSchema,
   ProcessConfigResponse,
   ProcessResult
 } from '@sentio/protos'
-
-import { ServerError, Status } from 'nice-grpc'
+import { create } from '@bufbuild/protobuf'
+import { ConnectError, Code } from '@connectrpc/connect'
 
 import { SolanaProcessorState } from './solana-processor.js'
 import { Instruction as SolInstruction } from '@anchor-lang/core'
@@ -32,7 +33,7 @@ export class SolanaPlugin extends Plugin {
         continue
       }
 
-      const contractConfig = ContractConfig.fromPartial({
+      const contractConfig = create(ContractConfigSchema, {
         processorType: USER_PROCESSOR,
         contract: {
           name: solanaProcessor.contractName,
@@ -50,17 +51,17 @@ export class SolanaPlugin extends Plugin {
             break
           }
         }
-        contractConfig.instructionConfig = {
+        contractConfig.instructionConfig = create(InstructionHandlerConfigSchema, {
           innerInstruction: solanaProcessor.processInnerInstruction,
           parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
           rawDataInstruction: solanaProcessor.decodeInstruction !== null,
           fetchTx: fetchTx
-        }
+        })
       }
 
       for (const [idx, handler] of solanaProcessor.blockHandlers.entries()) {
         contractConfig.intervalConfigs.push(
-          OnIntervalConfig.fromPartial({
+          create(OnIntervalConfigSchema, {
             handlerId: idx,
             minutesInterval: handler.timeIntervalInMinutes,
             slotInterval: handler.slotInterval,
@@ -82,19 +83,19 @@ export class SolanaPlugin extends Plugin {
       case HandlerType.SOL_BLOCK:
         return this.processSolBlock(request)
       default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+        throw new ConnectError('No handle type registered ' + request.handlerType, Code.InvalidArgument)
     }
   }
 
   async processSolInstruction(request: DataBinding): Promise<ProcessResult> {
     if (!request.data) {
-      throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
+      throw new ConnectError('instruction data cannot be empty', Code.InvalidArgument)
     }
-    if (!request.data.solInstruction) {
-      throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
+    if (request.data.value.case !== 'solInstruction') {
+      throw new ConnectError('instruction data cannot be empty', Code.InvalidArgument)
     }
 
-    const instruction = request.data.solInstruction
+    const instruction = request.data.value.value
     const promises: Promise<ProcessResult>[] = []
 
     // Only have instruction handlers for solana processors
@@ -103,15 +104,17 @@ export class SolanaPlugin extends Plugin {
         let parsedInstruction: SolInstruction | null = null
 
         try {
-          if (instruction.parsed) {
-            parsedInstruction = processor.getParsedInstruction(instruction.parsed as { type: string; info: any })
+          if (instruction.rawParsed) {
+            parsedInstruction = processor.getParsedInstruction(
+              JSON.parse(instruction.rawParsed) as { type: string; info: any }
+            )
           } else if (instruction.instructionData) {
             parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
           }
         } catch (e) {
-          throw new ServerError(
-            Status.INTERNAL,
-            'Failed to decode instruction: ' + JSON.stringify(instruction) + errorString(e)
+          throw new ConnectError(
+            'Failed to decode instruction: ' + JSON.stringify(instruction) + errorString(e),
+            Code.Internal
           )
         }
         if (parsedInstruction == null) {
@@ -124,9 +127,9 @@ export class SolanaPlugin extends Plugin {
         const res = processor
           .handleInstruction(parsedInstruction, instruction.accounts, insHandler, instruction)
           .catch((e) => {
-            throw new ServerError(
-              Status.INTERNAL,
-              'Error processing instruction: ' + JSON.stringify(instruction) + '\n' + errorString(e)
+            throw new ConnectError(
+              'Error processing instruction: ' + JSON.stringify(instruction) + '\n' + errorString(e),
+              Code.Internal
             )
           })
 
@@ -137,10 +140,10 @@ export class SolanaPlugin extends Plugin {
   }
 
   async processSolBlock(request: DataBinding): Promise<ProcessResult> {
-    if (!request.data?.solBlock) {
-      throw new ServerError(Status.INVALID_ARGUMENT, 'block data cannot be empty')
+    if (request.data?.value.case !== 'solBlock') {
+      throw new ConnectError('block data cannot be empty', Code.InvalidArgument)
     }
-    const block = request.data.solBlock
+    const block = request.data.value.value
     const promises: Promise<ProcessResult>[] = []
     for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
       for (const handlerId of request.handlerIds) {

package/src/solana/solana-processor.ts

@@ -1,4 +1,5 @@
-import { Data_SolBlock, Data_SolInstruction, HandleInterval, ProcessResult } from '@sentio/protos'
+import { Data_SolBlock, Data_SolInstruction, HandleInterval, HandleIntervalSchema, ProcessResult } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { SolanaContext } from './solana-context.js'
 import { Instruction } from '@anchor-lang/core'
 import { SolanaBindOptions, SolanaFetchConfig } from './solana-options.js'
@@ -18,7 +19,11 @@ export interface InstructionCoder {
   decode(ix: Buffer | string, encoding?: 'hex' | 'base58'): Instruction | null
 }
 
-export type SolanaInstructionHandler = (instruction: Instruction, ctx: SolanaContext, accounts?: string[]) => void
+export type SolanaInstructionHandler<T extends Instruction = Instruction> = (
+  instruction: T,
+  ctx: SolanaContext,
+  accounts: string[]
+) => void
 
 export interface InstructionHandlerEntry {
   handler: SolanaInstructionHandler
@@ -79,12 +84,12 @@ export class SolanaBaseProcessor {
     SolanaProcessorState.INSTANCE.addValue(this)
   }
 
-  public onInstruction(
+  public onInstruction<T extends Instruction = Instruction>(
     instructionName: string,
-    handler: SolanaInstructionHandler,
-    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+    handler: SolanaInstructionHandler<T>,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, T>
   ) {
-    this.instructionHandlerMap.set(instructionName, { handler, handlerOptions })
+    this.instructionHandlerMap.set(instructionName, { handler, handlerOptions } as InstructionHandlerEntry)
     return this
   }
 
@@ -95,7 +100,10 @@ export class SolanaBaseProcessor {
   ): this {
     return this.onInterval(
       handler,
-      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
+      create(HandleIntervalSchema, {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      }),
       undefined
     )
   }
@@ -105,10 +113,14 @@ export class SolanaBaseProcessor {
     blockInterval = 1000,
     backfillBlockInterval = 4000
   ): this {
-    return this.onInterval(handler, undefined, {
-      recentInterval: blockInterval,
-      backfillInterval: backfillBlockInterval
-    })
+    return this.onInterval(
+      handler,
+      undefined,
+      create(HandleIntervalSchema, {
+        recentInterval: blockInterval,
+        backfillInterval: backfillBlockInterval
+      })
+    )
   }
 
   public onInterval<T>(

package/src/store/cache.ts

@@ -1,5 +1,6 @@
 import { IStoreContext } from '@sentio/runtime'
-import { DBRequest, DBResponse, RichStruct, RichValue } from '@sentio/protos'
+import { type DBResponse, type RichStruct, RichStructSchema } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { BaseContext } from '../core/index.js'
 
 /** Internal entity name used for cache storage */
@@ -64,17 +65,20 @@ export class MemoryCache {
    */
   public async get<T>(key: string): Promise<T | null> {
     const promise = this.storeContext.sendRequest({
-      get: {
+      case: 'get',
+      value: {
         entity: CacheItemEntityName,
         id: key
       }
     })
 
     const data = (await promise) as DBResponse
-    if (data.entityList?.entities[0]) {
-      const entityData = data.entityList?.entities[0]?.data as RichStruct
-      const value = entityData.fields['value'] as RichValue
-      return JSON.parse(value.stringValue!) as T
+    if (data.value.case === 'entityList' && data.value.value.entities[0]) {
+      const entityData = data.value.value.entities[0]?.data
+      const value = entityData?.fields['value']
+      if (value?.value.case === 'stringValue') {
+        return JSON.parse(value.value.value) as T
+      }
     }
 
     return null
@@ -94,24 +98,24 @@ export class MemoryCache {
    * ```
    */
   public async set<T>(key: string, value: T): Promise<void> {
-    const entityData: RichStruct = {
+    const entityData: RichStruct = create(RichStructSchema, {
       fields: {
         id: {
-          stringValue: key
+          value: { case: 'stringValue', value: key }
         },
         value: {
-          stringValue: JSON.stringify(value)
+          value: { case: 'stringValue', value: JSON.stringify(value) }
         }
       }
-    }
-    const request = {
-      upsert: {
+    })
+    await this.storeContext.sendRequest({
+      case: 'upsert',
+      value: {
         entity: [CacheItemEntityName],
         id: [key],
         entityData: [entityData]
       }
-    } as DBRequest
-    await this.storeContext.sendRequest(request)
+    })
   }
 
   /**
@@ -125,13 +129,13 @@ export class MemoryCache {
    * ```
    */
   public async delete(key: string): Promise<void> {
-    const request = {
-      delete: {
+    await this.storeContext.sendRequest({
+      case: 'delete',
+      value: {
         entity: [CacheItemEntityName],
         id: [key]
       }
-    } as DBRequest
-    await this.storeContext.sendRequest(request)
+    })
   }
 
   /**

package/src/store/codegen.ts

@@ -210,7 +210,7 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
               })
               fields.push({
                 name: f.name + 'ID' + (isMany ? 's' : ''),
-                type: isMany ? `Array<ID | undefined>` : `ID`,
+                type: isMany ? `Array<ID>` : `ID`,
                 annotations: []
               })
               if (isMany) {
@@ -317,7 +317,7 @@ export class ${c.name} ${c.parent ? `extends ${c.parent}` : ''} ${c.interfaces.l
 ${c.fields
   .map((f) => `${f.annotations.map((a) => `\n\t${a}`).join('')}\n\t${f.name}${f.optional ? '?' : ''}: ${f.type}`)
   .join('\n')}
-  ${isEntity ? `constructor(data: ${c.name}ConstructorInput) {super()}` : ''}
+  ${isEntity ? `constructor(data: Partial<${c.name}ConstructorInput>) {super()}` : ''}
   ${(c.methods ?? []).map(genMethod).join('\n')}
   
   ${

package/src/store/convert.ts

@@ -1,4 +1,5 @@
-import { RichValue, RichValue_NullValue } from '@sentio/protos'
+import { type RichValue, RichValueSchema, RichValue_NullValue, timestampDate, timestampFromDate } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import type { String, Int, Float, ID, Bytes, Timestamp, Boolean } from './types.js'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { toBigInteger, toBigDecimal } from '../core/numberish.js'
@@ -14,6 +15,10 @@ export interface ValueConverter<T> {
 
 export const ValueRequiredError = new Error('Value is required but received null or undefined')
 
+function nullRichValue(): RichValue {
+  return create(RichValueSchema, { value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE } })
+}
+
 export function required_<T>(converter: ValueConverter<T | undefined>): ValueConverter<T> {
   const { from, to, ...rest } = converter
   return {
@@ -24,7 +29,7 @@ export function required_<T>(converter: ValueConverter<T | undefined>): ValueCon
       return from(value)
     },
     to: (value: RichValue) => {
-      if (value == null || value.nullValue) {
+      if (value == null || value.value.case === 'nullValue') {
         throw ValueRequiredError
       }
       return to(value)!
@@ -37,14 +42,17 @@ export function required_<T>(converter: ValueConverter<T | undefined>): ValueCon
 export function array_<T>(converter: ValueConverter<T>): ValueConverter<T[]> {
   return {
     from: (value: T[]) => {
-      return {
-        listValue: {
-          values: value.map(converter.from)
+      return create(RichValueSchema, {
+        value: {
+          case: 'listValue',
+          value: {
+            values: value.map(converter.from)
+          }
         }
-      }
+      })
     },
     to: (value: RichValue) => {
-      return value.listValue?.values.map(converter.to) || []
+      return value.value.case === 'listValue' ? value.value.value.values.map(converter.to) : []
     },
     isArray: true,
     isRelation: converter.isRelation,
@@ -56,16 +64,14 @@ export function enumerate_<T extends string | number>(values: Record<T, string>)
   return {
     from: (value?: T) => {
       if (value == null) {
-        return {
-          nullValue: RichValue_NullValue.NULL_VALUE
-        }
-      }
-      return {
-        stringValue: values[value]
+        return nullRichValue()
       }
+      return create(RichValueSchema, {
+        value: { case: 'stringValue', value: values[value] }
+      })
     },
     to(v: RichValue): T {
-      return v.stringValue as T
+      return (v.value.case === 'stringValue' ? v.value.value : undefined) as T
     }
   }
 }
@@ -74,28 +80,24 @@ export function objectId_<T>(entityName: string): ValueConverter<T | ID> {
   return {
     from: (value: T | ID) => {
       if (typeof value == 'string') {
-        return {
-          stringValue: value
-        }
+        return create(RichValueSchema, { value: { case: 'stringValue', value } })
       }
       if (value instanceof Uint8Array) {
-        return {
-          stringValue: `0x${Buffer.from(value).toString('hex')}`
-        }
+        return create(RichValueSchema, {
+          value: { case: 'stringValue', value: `0x${Buffer.from(value).toString('hex')}` }
+        })
       }
 
       if (typeof value == 'object') {
         const entity = value as any
-        return {
-          stringValue: entity.id.toString()
-        }
-      }
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
+        return create(RichValueSchema, {
+          value: { case: 'stringValue', value: entity.id.toString() }
+        })
       }
+      return nullRichValue()
     },
     to(v) {
-      return v.stringValue as T | ID
+      return (v.value.case === 'stringValue' ? v.value.value : undefined) as T | ID
     },
     isRelation: true,
     relationName: entityName
@@ -105,137 +107,105 @@ export function objectId_<T>(entityName: string): ValueConverter<T | ID> {
 export const StringConverter: ValueConverter<String | undefined> = {
   from: (value?: String) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      stringValue: value
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'stringValue', value } })
   },
   to(v) {
-    return v.stringValue
+    return v.value.case === 'stringValue' ? v.value.value : undefined
   }
 }
 
 export const IntConverter: ValueConverter<Int | undefined> = {
   from: (value?: Int) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      intValue: Math.floor(value)
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'intValue', value: Math.floor(value) } })
   },
   to(v) {
-    return v.intValue as Int
+    return (v.value.case === 'intValue' ? v.value.value : undefined) as Int
   }
 }
 
 export const Int8Converter: ValueConverter<bigint | undefined> = {
   from: (value?: bigint) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      int64Value: BigInt(value)
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'int64Value', value: BigInt(value) } })
   },
   to(v) {
-    return v.int64Value
+    return v.value.case === 'int64Value' ? v.value.value : undefined
   }
 }
 
 export const FloatConverter: ValueConverter<Float | undefined> = {
   from: (value?: Float) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      floatValue: value
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'floatValue', value } })
   },
   to(v) {
-    return v.floatValue
+    return v.value.case === 'floatValue' ? v.value.value : undefined
   }
 }
 
 export const BooleanConverter: ValueConverter<Boolean | undefined> = {
   from: (value?: Boolean) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      boolValue: value
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'boolValue', value } })
   },
   to(v) {
-    return v.boolValue
+    return v.value.case === 'boolValue' ? v.value.value : undefined
   }
 }
 
 export const TimestampConverter: ValueConverter<Timestamp | undefined> = {
   from: (value: Timestamp | undefined) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      timestampValue: value
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'timestampValue', value: timestampFromDate(value) } })
   },
   to(v) {
-    return v.timestampValue
+    return v.value.case === 'timestampValue' ? timestampDate(v.value.value) : undefined
   }
 }
 
 export const BytesConverter: ValueConverter<Bytes | undefined> = {
   from: (value?: Bytes) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      bytesValue: value
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'bytesValue', value } })
   },
   to(v) {
-    return v.bytesValue
+    return v.value.case === 'bytesValue' ? v.value.value : undefined
   }
 }
 
 export const IDConverter: ValueConverter<ID | undefined> = {
   from(value: ID | undefined): RichValue {
     if (typeof value == 'string') {
-      return {
-        stringValue: value
-      }
+      return create(RichValueSchema, { value: { case: 'stringValue', value } })
     }
     if (value instanceof Uint8Array) {
-      return {
-        stringValue: `0x${Buffer.from(value).toString('hex')}`
-      }
-    }
-    return {
-      nullValue: RichValue_NullValue.NULL_VALUE
+      return create(RichValueSchema, {
+        value: { case: 'stringValue', value: `0x${Buffer.from(value).toString('hex')}` }
+      })
     }
+    return nullRichValue()
   },
   to(value: RichValue): ID | undefined {
-    if (value.stringValue) {
-      return value.stringValue as ID
+    if (value.value.case === 'stringValue' && value.value.value) {
+      return value.value.value as ID
     }
-    if (value.bytesValue) {
-      const v = `0x${Buffer.from(value.bytesValue).toString('hex')}`
+    if (value.value.case === 'bytesValue' && value.value.value) {
+      const v = `0x${Buffer.from(value.value.value).toString('hex')}`
       return v as ID
     }
     return undefined
@@ -245,15 +215,13 @@ export const IDConverter: ValueConverter<ID | undefined> = {
 export const BigDecimalConverter: ValueConverter<BigDecimal | undefined> = {
   from: (value?: BigDecimal): RichValue => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
+      return nullRichValue()
     }
-    return { bigdecimalValue: toBigDecimal(value) }
+    return create(RichValueSchema, { value: { case: 'bigdecimalValue', value: toBigDecimal(value) } })
   },
   to(v) {
-    const d = v.bigdecimalValue
-    if (d) {
+    if (v.value.case === 'bigdecimalValue') {
+      const d = v.value.value
       const i = bytesToBigInt(d.value!.data)
       let ret = new BigDecimal(i.toString())
       if (d.exp < 0) {
@@ -270,18 +238,14 @@ export const BigDecimalConverter: ValueConverter<BigDecimal | undefined> = {
 export const BigIntConverter: ValueConverter<bigint | undefined> = {
   from: (value?: bigint) => {
     if (value == null) {
-      return {
-        nullValue: RichValue_NullValue.NULL_VALUE
-      }
-    }
-    return {
-      bigintValue: toBigInteger(value)
+      return nullRichValue()
     }
+    return create(RichValueSchema, { value: { case: 'bigintValue', value: toBigInteger(value) } })
   },
   to(v) {
-    if (v.bigintValue) {
-      let res = bytesToBigInt(v.bigintValue?.data)
-      if (v.bigintValue.negative) {
+    if (v.value.case === 'bigintValue') {
+      let res = bytesToBigInt(v.value.value.data)
+      if (v.value.value.negative) {
         res = -res
       }
       return res

package/src/store/decorators.ts

@@ -16,7 +16,8 @@ import {
   TypeConverters,
   ValueConverter
 } from './convert.js'
-import { RichStruct } from '@sentio/protos'
+import { type RichStruct, RichStructSchema } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { getStore } from './store.js'
 
 type Constructor = { new (...args: any[]): any }
@@ -90,7 +91,7 @@ export function Entity(entityName: string) {
     }
 
     return class extends BaseClass {
-      readonly _data: RichStruct = { fields: {} }
+      readonly _data: RichStruct = create(RichStructSchema, { fields: {} })
       static entityName = entityName
 
       constructor(...args: any[]) {