@sentio/sdk 2.36.1 → 2.37.0-rc.10

package/src/fuel/fuel-processor.ts

@@ -89,30 +89,42 @@ export class FuelProcessor implements FuelBaseProcessor<FuelProcessorConfig> {
 
     const callHandler = {
       handler: async (call: Data_FuelCall) => {
-        const contract = new Contract(this.config.address, abi, this.provider)
-        const gqlTransaction = call.transaction
-        const tx = decodeFuelTransactionWithAbi(gqlTransaction, { [this.config.address]: abi }, this.provider)
+        try {
+          const contract = new Contract(this.config.address, abi, this.provider)
+          const gqlTransaction = call.transaction
+          const tx = decodeFuelTransactionWithAbi(gqlTransaction, { [this.config.address]: abi }, this.provider)
 
-        const ctx = new FuelContext(
-          this.config.chainId,
-          this.config.address,
-          this.config.name ?? this.config.address,
-          tx
-        )
-        for (const op of tx.operations) {
-          for (const call of op.calls || []) {
-            if (names.has(call.functionName)) {
-              const fn = contract.functions[call.functionName]
-              const args = Object.values(call.argumentsProvided || {})
-              const scope = fn(...args)
-              const invocationResult = new FuelCall(scope, tx, false, call.argumentsProvided, tx.logs)
-
-              await handler(invocationResult, ctx)
+          const ctx = new FuelContext(
+            this.config.chainId,
+            this.config.address,
+            this.config.name ?? this.config.address,
+            tx
+          )
+          for (const op of tx.operations) {
+            for (const call of op.calls || []) {
+              if (names.has(call.functionName)) {
+                const fn = contract.functions[call.functionName]
+                const args = Object.values(call.argumentsProvided || {})
+                const scope = fn(...args)
+                const invocationResult = new FuelCall(scope, tx, false, call.argumentsProvided, tx.logs)
+                await handler(invocationResult, ctx)
+              }
             }
           }
-        }
 
-        return ctx.stopAndGetResult()
+          return ctx.stopAndGetResult()
+        } catch (e) {
+          console.error(e)
+          return {
+            gauges: [],
+            counters: [],
+            events: [],
+            exports: [],
+            states: {
+              configUpdated: false
+            }
+          }
+        }
       },
       fetchConfig: {
         filters: Object.values(filters)
@@ -130,27 +142,40 @@ export class FuelProcessor implements FuelBaseProcessor<FuelProcessorConfig> {
 
     const callHandler = {
       handler: async (call: Data_FuelCall) => {
-        const gqlTransaction = call.transaction
-        const tx = decodeFuelTransactionWithAbi(
-          gqlTransaction,
-          { [this.config.address]: this.config.abi! },
-          this.provider
-        )
-
-        const results: ProcessResult[] = []
-        const logs = (tx.logs || []).filter((log) => logIds.has(log.logId))
-        for (const log of logs) {
-          const ctx = new FuelContext(
-            this.config.chainId,
-            this.config.address,
-            this.config.name ?? this.config.address,
-            tx
+        try {
+          const gqlTransaction = call.transaction
+          const tx = decodeFuelTransactionWithAbi(
+            gqlTransaction,
+            { [this.config.address]: this.config.abi! },
+            this.provider
           )
-          ctx.setLogIndex(log.receiptIndex)
-          await handler(log, ctx)
-          results.push(ctx.stopAndGetResult())
+
+          const results: ProcessResult[] = []
+          const logs = (tx.logs || []).filter((log) => logIds.has(log.logId))
+          for (const log of logs) {
+            const ctx = new FuelContext(
+              this.config.chainId,
+              this.config.address,
+              this.config.name ?? this.config.address,
+              tx
+            )
+            ctx.setLogIndex(log.receiptIndex)
+            await handler(log, ctx)
+            results.push(ctx.stopAndGetResult())
+          }
+          return mergeProcessResults(results)
+        } catch (e) {
+          console.error(e)
+          return {
+            gauges: [],
+            counters: [],
+            events: [],
+            exports: [],
+            states: {
+              configUpdated: false
+            }
+          }
         }
-        return mergeProcessResults(results)
       },
       logConfig: {
         logIds: Array.from(logIds)

package/src/store/codegen.ts

@@ -0,0 +1,256 @@
+import {
+  DirectiveNode,
+  GraphQLEnumType,
+  GraphQLField,
+  GraphQLInterfaceType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLOutputType,
+  GraphQLScalarType,
+  GraphQLSchema,
+  Kind,
+  isObjectType,
+  isInterfaceType,
+  isListType
+} from 'graphql'
+import * as fs from 'node:fs'
+import path from 'path'
+import mkdirp from 'mkdirp'
+import { schemaFromFile } from './schema.js'
+import chalk from 'chalk'
+
+export async function codegen(srcDir: string, outputDir: string) {
+  for (const file of fs.readdirSync(srcDir)) {
+    const f = path.join(srcDir, file)
+    const filePath = path.parse(f)
+    if (filePath.ext == '.graphql') {
+      const { schema, source } = schemaFromFile(f)
+      const target = path.join(outputDir, filePath.name + '.ts')
+      await codegenInternal(schema, source, target)
+      console.log(chalk.green(`Generated ${target}`))
+    }
+  }
+}
+
+async function codegenInternal(schema: GraphQLSchema, source: string, target: string) {
+  const results: string[] = [
+    '/* Autogenerated file. Do not edit manually. */\n',
+    '/* tslint:disable */',
+    '/* eslint-disable */',
+    "import {entity, derivedFrom, DateTime, Json, Bytes, ID, Entity, Store} from '@sentio/sdk/store'",
+    `import { DatabaseSchema, BigDecimal } from "@sentio/sdk"`
+  ]
+  const entities: string[] = []
+  for (const t of Object.values(schema.getTypeMap())) {
+    if (t.name.startsWith('__')) {
+      continue
+    }
+
+    if (t instanceof GraphQLObjectType) {
+      const entityContent = genEntity(t)
+      results.push(entityContent)
+      entities.push(t.name)
+    }
+    if (t instanceof GraphQLEnumType) {
+      results.push(genEnum(t))
+    }
+    if (t instanceof GraphQLInterfaceType) {
+      results.push(genInterface(t))
+    }
+  }
+
+  const contents =
+    results.join('\n') +
+    `\n
+const source = \`${source.replaceAll('`', '`')}\`
+DatabaseSchema.register({
+  source,
+  entities: {
+    ${entities.map((e) => `"${e}": ${e}`).join(',\n\t\t')}
+  }
+})
+`
+  await mkdirp(path.dirname(target))
+
+  fs.writeFileSync(target, contents)
+}
+
+const JsTypes: Record<string, string> = {
+  ID: 'string',
+  String: 'string',
+  Int: 'number',
+  Float: 'number',
+  Boolean: 'boolean',
+  BigInt: 'bigint',
+  BigDecimal: 'BigDecimal',
+  DateTime: 'Date',
+  Json: 'any',
+  Bytes: 'Uint8Array'
+}
+const graphqlTypes = Object.entries(JsTypes).reduce(
+  (acc, [k, v]) => {
+    acc[v] = k
+    return acc
+  },
+  {} as Record<string, string>
+)
+
+function genType(type: GraphQLOutputType): string {
+  if (type instanceof GraphQLNonNull) {
+    return genType(type.ofType)
+  } else if (type instanceof GraphQLScalarType) {
+    return type.name
+  } else if (type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType) {
+    return type.name
+  } else if (type instanceof GraphQLList) {
+    return `Array<${genType(type.ofType)}>`
+  } else if (type instanceof GraphQLEnumType) {
+    return type.name
+  } else {
+    throw new Error('Unsupported type: ' + type)
+  }
+}
+
+function isObject(type: GraphQLOutputType) {
+  if (type instanceof GraphQLNonNull) {
+    return isObject(type.ofType)
+  } else if (type instanceof GraphQLList) {
+    return isObject(type.ofType)
+  }
+  return isObjectType(type) || isInterfaceType(type)
+}
+
+function isList(type: GraphQLOutputType) {
+  if (type instanceof GraphQLNonNull) {
+    return isListType(type.ofType)
+  } else {
+    return isListType(type)
+  }
+}
+
+function getElementType(type: GraphQLOutputType) {
+  if (type instanceof GraphQLNonNull) {
+    return getElementType(type.ofType)
+  } else if (type instanceof GraphQLList) {
+    return type.ofType
+  }
+  return type
+}
+
+function genField(field: GraphQLField<any, any>) {
+  const isNonNull = field.type instanceof GraphQLNonNull
+  const directives = field.astNode?.directives?.map((d) => '\t' + directive2decorator(d) + '\n') || []
+
+  const type = genType(field.type)
+  const returnType = isNonNull ? type : `${type} | undefined`
+
+  if (isObject(field.type)) {
+    const t = getElementType(field.type)
+    const typeAsArg = isInterfaceType(t) ? `"${t}"` : genType(t)
+
+    if (isList(field.type)) {
+      return `${directives.join()}\tget ${field.name}(): Promise<${genType(t)}[]> { return this.getFieldObjectArray(${typeAsArg}, "${field.name}") as Promise<${genType(t)}[]> }
+  set ${field.name}(value: ${type} | ID[]) { this.set("${field.name}", value) }
+  get ${field.name}Ids(): ID[] { return this.get("${field.name}") }`
+    }
+
+    return `${directives.join()}\tget ${field.name}(): Promise<${genType(t)} | undefined> { return this.getFieldObject(${typeAsArg},"${field.name}") as Promise<${genType(t)} | undefined> }
+  set ${field.name}(value: ${type} | ID) { this.set("${field.name}", value) }
+  get ${field.name}Id(): ID | undefined { return this.get("${field.name}") }`
+  }
+
+  if (returnType == 'BigInt') {
+    return `${directives.join()}\tget ${field.name}(): ${returnType} { return BigInt(this.get("${field.name}")) }
+  set ${field.name}(value: ${type}) { this.set("${field.name}", value.toString()) }`
+  }
+  if (returnType == 'BigDecimal') {
+    return `${directives.join()}\tget ${field.name}(): ${returnType} { return new BigDecimal(this.get("${field.name}")) }
+  set ${field.name}(value: ${type}) { this.set("${field.name}", value.toString()) }`
+  }
+
+  if (returnType == 'Bytes') {
+    return `${directives.join()}\tget ${field.name}(): ${returnType} { return Uint8Array.from(Buffer.from(this.get<string>("${field.name}"), 'hex'))  ) }
+  set ${field.name}(value: ${type}) { this.set("${field.name}", Buffer.from(value).toString('hex')) }`
+  }
+
+  return `${directives.join()}\tget ${field.name}(): ${returnType} { return this.get("${field.name}") }
+  set ${field.name}(value: ${type}) { this.set("${field.name}", value) }`
+}
+
+function genDataType(t: GraphQLObjectType<any, any>) {
+  let output = `type ${t.name}Data = `
+  const relationsFields = Object.values(t.getFields()).filter((f) => isObject(f.type))
+  if (relationsFields.length > 0) {
+    output += `Omit<${t.name}, ${relationsFields.map((f) => `"${f.name}"`).join(' | ')}>`
+
+    output +=
+      ' & {' +
+      relationsFields
+        .map((f) => {
+          const type = genType(getElementType(f.type))
+          return `${f.name}?: ${isList(f.type) ? `Array<ID|${type}>` : `ID | ${type}`}`
+        })
+        .join(', ') +
+      '}'
+  } else {
+    output += `${t.name}`
+  }
+  return output
+}
+
+function genEntity(t: GraphQLObjectType<any, any>) {
+  const decorators = t.astNode?.directives?.filter((d) => d.name.value != 'entity').map(directive2decorator) || []
+
+  let impls = ''
+  if (t.getInterfaces().length > 0) {
+    impls +=
+      ' implements ' +
+      t
+        .getInterfaces()
+        .map((i) => i.name)
+        .join(', ')
+  }
+
+  return `
+${genDataType(t)}
+${decorators.join('\n')}
+@entity("${t.name}")
+export class ${t.name} extends Entity${impls} {
+  constructor(data: Partial<${t.name}Data>) {
+    super(data)
+  }
+${Object.values(t.getFields()).map(genField).join('\n')}
+}`
+}
+
+function genInterface(t: GraphQLInterfaceType) {
+  return `
+export interface ${t.name} {
+${Object.values(t.getFields())
+  .map((f) => `\t${f.name}: ${genType(f.type)}`)
+  .join('\n')}
+}`
+}
+
+export function directive2decorator(directive: DirectiveNode) {
+  let s = `@${directive.name.value}`
+  if (directive.arguments?.length) {
+    s += `(${directive.arguments
+      ?.map((arg) => {
+        return arg.value.kind === Kind.STRING ? `"${arg.value.value}"` : `${arg.value}`
+      })
+      .join(', ')})`
+  }
+  return s
+}
+
+function genEnum(t: GraphQLEnumType) {
+  return `
+export enum ${t.name} {
+${t
+  .getValues()
+  .map((v) => `\t${v.name}`)
+  .join(', ')}
+}`
+}

package/src/store/context.ts

@@ -0,0 +1 @@
+export { StoreContext } from '@sentio/runtime'

package/src/store/decorators.ts

@@ -0,0 +1,32 @@
+type Constructor = { new (...args: any[]): any }
+
+export function entity(name: string) {
+  return function <T extends Constructor>(constructor: T, context: any) {
+    constructor.prototype.entityName = name
+    return constructor
+  }
+}
+
+export function derivedFrom(field: string) {
+  return function (target: any, context: any) {}
+}
+
+export function unique(field: string) {
+  return function (target: any, context: any) {}
+}
+
+export function index(field: string[]) {
+  return function (target: any, context: any) {}
+}
+
+export function fulltext(query: string) {
+  return function (target: any, context: any) {}
+}
+
+export function cardinality(value: number) {
+  return function (target: any, context: any) {}
+}
+
+export function byteWeight(value: number) {
+  return function (target: any, context: any) {}
+}

package/src/store/entity.ts

@@ -0,0 +1,71 @@
+import { ID } from './types.js'
+import { PluginManager } from '@sentio/runtime'
+import { Store } from './store.js'
+
+export interface EntityClass<T extends Entity> {
+  new (data: any): T
+}
+
+export class Entity {
+  get id(): ID {
+    return this.get('id')
+  }
+
+  data: Record<string, any> = {}
+  constructor(data: any) {
+    Object.entries(data).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        this.data[key] = value.map((v) => this.getIdFromEntity(v))
+      } else {
+        this.data[key] = this.getIdFromEntity(value)
+      }
+    })
+  }
+
+  private getIdFromEntity(entity: any): any {
+    if (entity instanceof Entity) {
+      return entity.id
+    } else if (typeof entity === 'object' && entity.id) {
+      return entity.id
+    }
+    return entity
+  }
+
+  private getStore() {
+    const dbContext = PluginManager.INSTANCE.dbContextLocalStorage.getStore()
+    if (dbContext) {
+      return new Store(dbContext)
+    }
+    return undefined
+  }
+
+  get<T>(field: string): T {
+    return this.data[field]
+  }
+
+  set<T>(field: string, value: T | T[] | ID | ID[]): void {
+    if (Array.isArray(value) && value instanceof Entity) {
+      this.data[field] = value.map((v) => (v as Entity).id)
+    } else if (value instanceof Entity) {
+      this.data[field] = (value as Entity).id
+    }
+    this.data[field] = value
+  }
+
+  protected getFieldObject<T extends Entity>(entity: EntityClass<T> | string, field: string): Promise<T | undefined> {
+    const id = this.data[field]
+    return id ? (this.getStore()?.get(entity, id) as Promise<T>) : Promise.resolve(undefined)
+  }
+
+  protected getFieldObjectArray<T extends Entity>(entity: EntityClass<T>, field: string): Promise<T[]> {
+    const ids = this.data[field]
+    const promises = ids.map((id: string) => this.getStore()?.get(entity, id))
+    return Promise.all(promises) as Promise<T[]>
+  }
+
+  toString(): string {
+    const entityName = this.constructor.prototype.entityName
+    const id = this.id
+    return `${entityName}#${id} ${JSON.stringify(this.data)}`
+  }
+}

package/src/store/index.ts

@@ -0,0 +1,5 @@
+export * from './decorators.js'
+export * from './types.js'
+export * from './entity.js'
+export * from './store.js'
+export * from './context.js'

package/src/store/run.ts

@@ -0,0 +1,10 @@
+import { codegen } from './codegen.js'
+
+if (process.argv.length > 3) {
+  const srcFile = process.argv[2]
+  const targetDir = process.argv[3]
+  await codegen(srcFile, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/store/schema.ts

@@ -0,0 +1,35 @@
+import { buildASTSchema, DocumentNode, extendSchema, GraphQLSchema, parse, validateSchema } from 'graphql/index.js'
+import * as fs from 'node:fs'
+
+const customScalars = ['BigInt', 'BigDecimal', 'DateTime', 'JSON', 'Bytes', 'ID']
+
+const baseSchema = buildASTSchema(
+  parse(`
+    directive @entity on OBJECT
+    directive @query on INTERFACE
+    directive @derivedFrom(field: String!) on FIELD_DEFINITION
+    directive @unique on FIELD_DEFINITION
+    directive @index(fields: [String!] unique: Boolean) repeatable on OBJECT | FIELD_DEFINITION
+    directive @fulltext(query: String!) on FIELD_DEFINITION
+    directive @cardinality(value: Int!) on OBJECT | FIELD_DEFINITION
+    directive @byteWeight(value: Float!) on FIELD_DEFINITION
+    directive @variant on OBJECT # legacy
+    directive @jsonField on OBJECT # legacy
+    ${customScalars.map((name) => 'scalar ' + name).join('\n')}
+`)
+)
+
+export function buildSchema(doc: DocumentNode): GraphQLSchema {
+  const schema = extendSchema(baseSchema, doc)
+  const errors = validateSchema(schema).filter((err) => !/query root/i.test(err.message))
+  if (errors.length > 0) {
+    throw errors[0]
+  }
+  return schema
+}
+
+export function schemaFromFile(filePath: string) {
+  const source = fs.readFileSync(filePath, 'utf-8')
+  const doc = parse(source)
+  return { schema: buildSchema(doc), source }
+}

package/src/store/store.ts

@@ -0,0 +1,80 @@
+import { Entity, EntityClass } from './entity.js'
+import { StoreContext } from './context.js'
+import { DatabaseSchema } from '../core/index.js'
+
+export class Store {
+  constructor(private readonly context: StoreContext) {}
+
+  async get<T extends Entity>(entity: EntityClass<T> | string, id: string): Promise<T | undefined> {
+    const promise = this.context.sendRequest({
+      get: {
+        entity: typeof entity == 'string' ? entity : entity.prototype.entityName,
+        id
+      }
+    })
+
+    const data = (await promise) as any
+    if (data?.['id'] != null) {
+      return this.newEntity(entity, data)
+    }
+    return undefined
+  }
+
+  async delete(entity: EntityClass<any>, id: string | string[]): Promise<void> {
+    const toBeDeleted = []
+    if (Array.isArray(id)) {
+      for (const i of id) {
+        toBeDeleted.push({ entity: entity.prototype.entityName, id: i })
+      }
+    } else {
+      toBeDeleted.push({ entity: entity.prototype.entityName, id })
+    }
+    await this.context.sendRequest({
+      delete: {
+        entity: toBeDeleted.map((e) => e.entity) as string[],
+        id: toBeDeleted.map((e) => e.id) as string[]
+      }
+    })
+  }
+
+  async upsert<T extends Entity>(entity: T | T[]): Promise<void> {
+    const entities = Array.isArray(entity) ? entity : [entity]
+    const promise = this.context.sendRequest({
+      upsert: {
+        entity: entities.map((e) => e.constructor.prototype.entityName),
+        data: entities.map((e) => e.data),
+        id: entities.map((e) => e.id)
+      }
+    })
+
+    await promise
+  }
+
+  async list<T extends Entity>(entity: EntityClass<T>, limit?: number, offset?: number): Promise<T[]> {
+    const promise = this.context.sendRequest({
+      list: {
+        entity: entity.constructor.prototype.entityName,
+        limit,
+        offset
+      }
+    })
+
+    const list = (await promise) as any[]
+    return list.map((data) => {
+      return this.newEntity(entity, data)
+    })
+  }
+
+  private newEntity<T extends Entity>(entity: EntityClass<T> | string, data: any) {
+    if (typeof entity == 'string') {
+      const en = DatabaseSchema.findEntity(entity)
+      if (!en) {
+        // it is an interface
+        return new Entity(data) as T
+      }
+      entity = en
+    }
+
+    return new (entity as EntityClass<T>)(data)
+  }
+}

package/src/store/types.ts

@@ -0,0 +1,10 @@
+export type { BigDecimal } from '@sentio/bigdecimal'
+
+export type ID = string
+export type String = string
+export type Int = number
+export type Float = number
+export type Boolean = boolean
+export type DateTime = Date
+export type Json = any
+export type Bytes = Uint8Array

package/src/testing/test-processor-server.ts

@@ -2,12 +2,16 @@ import {
   AccountConfig,
   ContractConfig,
   DataBinding,
+  DeepPartial,
   Empty,
   ProcessBindingResponse,
   ProcessBindingsRequest,
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessorServiceImplementation,
+  ProcessStreamRequest,
+  ProcessStreamResponse,
+  ServerStreamingMethodResult,
   StartRequest
 } from '@sentio/protos'
 import { CallContext } from 'nice-grpc-common'
@@ -80,7 +84,14 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     return this.service.processBindings({ bindings: [request] }, context)
   }
 
-  processBindingsStream(request: AsyncIterable<DataBinding>, context: CallContext) {
-    return this.service.processBindingsStream(request, context)
+  processBindingsStream(
+    requests: AsyncIterable<ProcessStreamRequest>,
+    context: CallContext
+  ): ServerStreamingMethodResult<DeepPartial<ProcessStreamResponse>> {
+    throw new Error('Method not implemented.')
   }
+
+  // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+  //   return this.service.processBindingsStream(request, context)
+  // }
 }