@sentio/sdk 2.57.9-rc.1 → 2.57.9-rc.11

package/src/aptos/builtin/0x4.ts

@@ -4,7 +4,7 @@
 
 /* Generated types for 0x4, original address 0x4 */
 
-import { CallFilter, MoveFetchConfig } from "@sentio/sdk/move";
+import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move";
 import {
   AptosBindOptions,
   AptosBaseProcessor,
@@ -45,16 +45,26 @@ export class token extends AptosBaseProcessor {
   onEventMutation(
     func: (event: token.MutationInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): token {
-    this.onMoveEvent(func, { type: "token::Mutation" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "token::Mutation" },
+      fetchConfig,
+    );
     return this;
   }
 
   onEventMutationEvent(
     func: (event: token.MutationEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): token {
-    this.onMoveEvent(func, { type: "token::MutationEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "token::MutationEvent" },
+      fetchConfig,
+    );
     return this;
   }
 }
@@ -436,16 +446,26 @@ export class collection extends AptosBaseProcessor {
   onEventBurn(
     func: (event: collection.BurnInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::Burn" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::Burn" },
+      fetchConfig,
+    );
     return this;
   }
 
   onEventBurnEvent(
     func: (event: collection.BurnEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::BurnEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::BurnEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
@@ -455,10 +475,11 @@ export class collection extends AptosBaseProcessor {
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
     this.onMoveEvent(
       func,
-      { type: "collection::ConcurrentBurnEvent" },
+      { ...(eventFilter ?? {}), type: "collection::ConcurrentBurnEvent" },
       fetchConfig,
     );
     return this;
@@ -470,10 +491,11 @@ export class collection extends AptosBaseProcessor {
       ctx: AptosContext,
     ) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
     this.onMoveEvent(
       func,
-      { type: "collection::ConcurrentMintEvent" },
+      { ...(eventFilter ?? {}), type: "collection::ConcurrentMintEvent" },
       fetchConfig,
     );
     return this;
@@ -482,40 +504,65 @@ export class collection extends AptosBaseProcessor {
   onEventMint(
     func: (event: collection.MintInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::Mint" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::Mint" },
+      fetchConfig,
+    );
     return this;
   }
 
   onEventMintEvent(
     func: (event: collection.MintEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::MintEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::MintEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
   onEventMutation(
     func: (event: collection.MutationInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::Mutation" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::Mutation" },
+      fetchConfig,
+    );
     return this;
   }
 
   onEventMutationEvent(
     func: (event: collection.MutationEventInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::MutationEvent" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::MutationEvent" },
+      fetchConfig,
+    );
     return this;
   }
 
   onEventSetMaxSupply(
     func: (event: collection.SetMaxSupplyInstance, ctx: AptosContext) => void,
     fetchConfig?: Partial<MoveFetchConfig>,
+    eventFilter?: Omit<EventFilter, "type" | "account">,
   ): collection {
-    this.onMoveEvent(func, { type: "collection::SetMaxSupply" }, fetchConfig);
+    this.onMoveEvent(
+      func,
+      { ...(eventFilter ?? {}), type: "collection::SetMaxSupply" },
+      fetchConfig,
+    );
     return this;
   }
 }

package/src/bundle.config.ts

@@ -21,5 +21,5 @@ export default defineConfig({
   // dts: true,
   format: 'esm',
   keepNames: true,
-  external: [...external, /^@sentio\/(chain|runtime).*$/]
+  external: [...external, /^@sentio\/(chain|runtime).*$/, /^piscina.*$/]
 })

package/src/core/normalization.ts

@@ -1,7 +1,7 @@
 import { Labels } from './meter.js'
 import { BigDecimal } from './big-decimal.js'
 import { BN } from 'fuels'
-import { RichStruct, RichValue, RichValue_NullValue } from '@sentio/protos'
+import { CoinID, RichStruct, RichValue, RichValue_NullValue, TokenAmount } from '@sentio/protos'
 import { toBigInteger, toBigDecimal } from './numberish.js'
 
 export const SENTIO_BIGINT_STRING_SUFFIX = ':sto_bi'
@@ -116,6 +116,9 @@ function normalizeToRichValue(value: any): RichValue {
       const v = BigInt(value)
       return { bigintValue: toBigInteger(v) }
     case 'number':
+      if (isNaN(value) || !isFinite(value)) {
+        throw new Error("can't submit NaN or Infinity value")
+      }
       if (Number.isInteger(value)) {
         return { intValue: value }
       }
@@ -138,6 +141,9 @@ function normalizeToRichValue(value: any): RichValue {
       }
       if (BN.isBN(value)) {
         const value1 = new BigDecimal(value.toString())
+        if (value1.isNaN() || !value1.isFinite()) {
+          throw new Error("can't submit NaN or Infinity value")
+        }
         return { bigdecimalValue: toBigDecimal(value1) }
       }
       if (Array.isArray(value)) {
@@ -152,13 +158,16 @@ function normalizeToRichValue(value: any): RichValue {
         return { nullValue: RichValue_NullValue.UNRECOGNIZED }
       }
       if (typeof value === 'object') {
+        const tokenAmount = toTokenAmount(value)
+        if (tokenAmount) {
+          return { tokenValue: tokenAmount }
+        }
+
         return {
           structValue: normalizeToRichStruct(value)
         }
       }
 
-      // todo: support token value
-
       console.warn('Cannot submit unsupported type ' + typeof value)
       return { nullValue: RichValue_NullValue.UNRECOGNIZED }
   }
@@ -170,8 +179,64 @@ export function normalizeToRichStruct(...objs: any[]): RichStruct {
   }
   for (const obj of objs) {
     for (const [key, value] of Object.entries(obj)) {
-      ret.fields[key] = normalizeToRichValue(value)
+      try {
+        ret.fields[key] = normalizeToRichValue(value)
+      } catch (e) {
+        throw new Error("error when converting data for key '" + key + "': " + e.message)
+      }
+    }
+  }
+  return ret
+}
+
+function toTokenAmount(value: any): TokenAmount | undefined {
+  const ret = TokenAmount.create()
+
+  for (const key of Object.getOwnPropertyNames(value)) {
+    switch (key) {
+      case 'token':
+        const token = toCoinID(value.token)
+        if (!token) {
+          return undefined
+        }
+        ret.token = token
+        break
+      case 'amount':
+        if (value.amount instanceof BigDecimal) {
+          ret.amount = toBigDecimal(value)
+        } else if (typeof value.amount == 'string' || typeof value.amount == 'number') {
+          ret.amount = toBigDecimal(new BigDecimal(value.amount))
+        } else {
+          return undefined
+        }
+        break
+      case 'specifiedAt':
+        if (value.specifiedAt instanceof Date) {
+          ret.specifiedAt = value.specifiedAt
+        } else {
+          return undefined
+        }
+        break
+      default:
+        return undefined
     }
   }
+
+  return ret.amount && ret.token ? ret : undefined
+}
+
+function toCoinID(coin: any): CoinID | undefined {
+  const ret = CoinID.create()
+  if (typeof coin.symbol === 'string') {
+    return (ret.symbol = coin.symbol)
+  } else if (coin.hasOwnProperty('address')) {
+    ret.address = {
+      address: coin.address.address,
+      chain: coin.address.chain
+    }
+  } else {
+    return undefined
+  }
+
   return ret
 }

package/src/eth/abi-decoder/decode-worker.ts

@@ -0,0 +1,85 @@
+import { Interface, LogDescription, LogParams, ParamType, Result } from 'ethers'
+import { Piscina } from 'piscina'
+import { ServerError, Status } from 'nice-grpc'
+
+export interface IResult {
+  array?: any[]
+  keys: string[]
+}
+
+export function decodeTraceInline(contractViewInterface: any, inputs: readonly ParamType[], traceData: string): Result {
+  return contractViewInterface.getAbiCoder().decode(inputs, traceData, true)
+}
+
+export function decodeTrace({ inputs, traceData }: { inputs: ParamType[]; traceData: string }): IResult | null {
+  const fragments = Piscina['workerData']
+  const contractViewInterface = new Interface(fragments)
+  const result = decodeTraceInline(contractViewInterface, inputs, traceData)
+
+  const argsObj = result?.args.toObject(true)
+  const argsArray: any[] = []
+  const keys: string[] = []
+  for (const [key, value] of Object.entries(argsObj)) {
+    keys.push(key)
+    argsArray.push(value)
+  }
+
+  return {
+    array: argsArray,
+    keys: keys
+  }
+}
+
+export interface ILogDescription {
+  topic: string
+  args: {
+    array?: any[]
+    keys: string[]
+  } | null
+}
+
+export function parseLogInline(contractViewInterface: any, log: LogParams): LogDescription | null {
+  if (!log) {
+    throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
+  }
+  const logParam = log as any as { topics: Array<string>; data: string }
+  return contractViewInterface.parseLog(logParam)
+}
+
+export function parseLog({ log }: { log: LogParams }): ILogDescription | null {
+  const fragments = Piscina['workerData']
+  const contractViewInterface = new Interface(fragments)
+  const result = parseLogInline(contractViewInterface, log)
+  if (!result) {
+    return null
+  }
+
+  // can't serialize LogDescription, so return args and topics only
+  if (result?.args == null) {
+    return {
+      args: null,
+      topic: result.topic
+    }
+  }
+
+  const argsObj = result?.args.toObject(true)
+  const argsArray: any[] = []
+  const keys: string[] = []
+  for (const [key, value] of Object.entries(argsObj)) {
+    keys.push(key)
+    argsArray.push(value)
+  }
+
+  return {
+    args: {
+      array: argsArray,
+      keys: keys
+    },
+    topic: result.topic
+  }
+}
+
+export default {
+  parseLog,
+  decodeTrace
+}

package/src/eth/abi-decoder/index.ts

@@ -0,0 +1,133 @@
+import { LogDescription, LogParams, Result, ParamType } from 'ethers'
+import { GLOBAL_CONFIG, processMetrics } from '@sentio/runtime'
+import { Piscina } from 'piscina'
+
+import { decodeTraceInline, parseLogInline, IResult } from './decode-worker.js'
+
+function createOptions() {
+  const options: any = {
+    filename: findWorkFile(),
+    recordTiming: true
+  }
+  if (GLOBAL_CONFIG.execution.ethAbiDecoderConfig?.workerCount) {
+    try {
+      const workerNum = GLOBAL_CONFIG.execution.ethAbiDecoderConfig?.workerCount
+      options.maxThreads = workerNum
+      options.minThreads = workerNum
+    } catch (e) {}
+  }
+  return options
+}
+
+function findWorkFile() {
+  let baseUrl = import.meta.url
+  // find the base from @sentio/sdk
+  const index = baseUrl.indexOf('/@sentio/sdk/')
+  if (index > 0) {
+    baseUrl = baseUrl.substring(0, index + 13)
+  } else {
+    // dev environment, path is .../packages/sdk/src/eth/abi-decoder/parse-log-worker.ts
+    const index = baseUrl.indexOf('packages/sdk/')
+    if (index > 0) {
+      baseUrl = baseUrl.substring(0, index + 13)
+    }
+  }
+  return new URL('./lib/eth/abi-decoder/decode-worker.js', baseUrl).href
+}
+
+export async function parseLog(processor: any, log: LogParams) {
+  if (GLOBAL_CONFIG.execution.ethAbiDecoderConfig?.enabled) {
+    let workerPool = processor._logWorkerPool as Piscina
+    const contractView = processor.CreateBoundContractView()
+    const contractViewInterface = contractView.rawContract.interface
+    if (!workerPool) {
+      const fragments = contractViewInterface.fragments
+      const options = createOptions()
+      options.workerData = fragments
+
+      workerPool = new Piscina(options)
+      processor._logWorkerPool = workerPool
+    }
+    try {
+      const result = (await workerPool.run({ log }, { name: 'parseLog' })) as any
+      if (result) {
+        const fragment = contractViewInterface.getEvent(result.topic)
+
+        if (!fragment || fragment.anonymous) {
+          return null
+        }
+        return new LogDescription(fragment, result.topic, Result.fromItems(result.args?.array ?? [], result.args?.keys))
+      }
+    } catch (e) {
+      const skipWhenDecodeFailed = GLOBAL_CONFIG.execution.ethAbiDecoderConfig?.skipWhenDecodeFailed
+      console.error(`parseLog worker failed, skip: ${!!skipWhenDecodeFailed}, the error is:`, e)
+      if (!skipWhenDecodeFailed) {
+        throw e
+      }
+    } finally {
+      if (workerPool.waitTime && workerPool.runTime) {
+        const labels = {
+          chain_id: processor.config?.network,
+          processor: processor.config?.name,
+          workerPool: 'parseLog'
+        }
+        processMetrics.processor_worker_wait_time.record(workerPool.waitTime.average, labels)
+        processMetrics.processor_worker_run_time.record(workerPool.runTime?.average, labels)
+        processMetrics.processor_worker_utilization.record(workerPool.utilization, labels)
+        processMetrics.processor_worker_queue_size.record(workerPool.queueSize, labels)
+        processMetrics.processor_worker_completed.record(workerPool.completed, labels)
+      }
+    }
+    return null
+  } else {
+    const contractView = processor.CreateBoundContractView()
+    const contractViewInterface = contractView.rawContract.interface
+    return parseLogInline(contractViewInterface, log)
+  }
+}
+
+export async function decodeTrace(processor: any, inputs: readonly ParamType[], traceData: string) {
+  if (GLOBAL_CONFIG.execution.ethAbiDecoderConfig?.enabled) {
+    let workerPool = processor._traceWorkerPool
+    if (!workerPool) {
+      const contractView = processor.CreateBoundContractView()
+      const contractViewInterface = contractView.rawContract.interface
+      const fragments = contractViewInterface.fragments
+      const options = createOptions()
+      options.workerData = fragments
+
+      workerPool = new Piscina(options)
+      processor._traceWorkerPool = workerPool
+    }
+    try {
+      const result = (await workerPool.run({ inputs, traceData }, { name: 'decodeTrace' })) as IResult
+      if (result) {
+        return Result.fromItems(result.array ?? [], result.keys)
+      }
+    } catch (e) {
+      const skipWhenDecodeFailed = GLOBAL_CONFIG.execution.ethAbiDecoderConfig?.skipWhenDecodeFailed
+      console.error(`decode trace worker failed, skip: ${!!skipWhenDecodeFailed}, the error is:`, e)
+      if (!skipWhenDecodeFailed) {
+        throw e
+      }
+    } finally {
+      if (workerPool.waitTime && workerPool.runTime) {
+        const labels = {
+          chain_id: processor.config?.network,
+          processor: processor.config?.name,
+          workerPool: 'parseLog'
+        }
+        processMetrics.processor_worker_wait_time.record(workerPool.waitTime.average, labels)
+        processMetrics.processor_worker_run_time.record(workerPool.runTime?.average, labels)
+        processMetrics.processor_worker_utilization.record(workerPool.utilization, labels)
+        processMetrics.processor_worker_queue_size.record(workerPool.queueSize, labels)
+        processMetrics.processor_worker_completed.record(workerPool.completed, labels)
+      }
+    }
+    return null
+  } else {
+    const contractView = processor.CreateBoundContractView()
+    const contractViewInterface = contractView.rawContract.interface
+    return decodeTraceInline(contractViewInterface, inputs, traceData)
+  }
+}

package/src/eth/base-processor.ts

@@ -22,6 +22,7 @@ import { ListStateStorage } from '@sentio/runtime'
 import { EthChainId } from '@sentio/chain'
 import { getHandlerName, proxyHandlers, proxyProcessor } from '../utils/metrics.js'
 import { ALL_ADDRESS } from '../core/index.js'
+import { parseLog, decodeTrace } from './abi-decoder/index.js'
 
 export interface AddressOrTypeEventFilter extends DeferredTopicFilter {
   addressType?: AddressType
@@ -463,24 +464,9 @@ export abstract class BaseProcessor<
           contractView.address = log.address
         }
 
-        const ctx = new ContractContext<TContract, TBoundContractView>(
-          contractName,
-          contractView,
-          chainId,
-          data.timestamp,
-          block,
-          log,
-          undefined,
-          transaction,
-          transactionReceipt,
-          processor.config.baseLabels,
-          preparedData
-        )
-        const logParam = log as any as { topics: Array<string>; data: string }
-
         let parsed: LogDescription | null = null
         try {
-          parsed = contractView.rawContract.interface.parseLog(logParam)
+          parsed = await parseLog(processor, log)
         } catch (e) {
           // RangeError data out-of-bounds
           if (e instanceof Error) {
@@ -492,6 +478,19 @@ export abstract class BaseProcessor<
           throw e
         }
         if (parsed) {
+          const ctx = new ContractContext<TContract, TBoundContractView>(
+            contractName,
+            contractView,
+            chainId,
+            data.timestamp,
+            block,
+            log,
+            undefined,
+            transaction,
+            transactionReceipt,
+            processor.config.baseLabels,
+            preparedData
+          )
           const event: TypedEvent = { ...log, name: parsed.name, args: fixEmptyKey(parsed) }
           await handler(event, ctx)
           return ctx.stopAndGetResult()
@@ -529,11 +528,10 @@ export abstract class BaseProcessor<
           transactionReceipt,
           processor.config.baseLabels
         )
-        const logParam = log as any as { topics: Array<string>; data: string }
 
         let parsed: LogDescription | null = null
         try {
-          parsed = contractView.rawContract.interface.parseLog(logParam)
+          parsed = await parseLog(processor, log)
         } catch (e) {
           // RangeError data out-of-bounds
           if (e instanceof Error) {
@@ -714,7 +712,8 @@ export abstract class BaseProcessor<
         }
         const traceData = '0x' + trace.action.input.slice(10)
         try {
-          typedTrace.args = contractInterface.getAbiCoder().decode(fragment.inputs, traceData, true)
+          typedTrace.args = await decodeTrace(processor, fragment.inputs, traceData)
+          // typedTrace.args = contractInterface.getAbiCoder().decode(fragment.inputs, traceData, true)
         } catch (e) {
           if (!trace.error) {
             throw e
@@ -759,7 +758,7 @@ export abstract class BaseProcessor<
         }
         const traceData = '0x' + trace.action.input.slice(10)
         try {
-          typedTrace.args = contractInterface.getAbiCoder().decode(fragment.inputs, traceData, true)
+          typedTrace.args = await decodeTrace(processor, fragment.inputs, traceData)
         } catch (e) {
           if (!trace.error) {
             throw e

package/src/move/filter.ts

@@ -11,6 +11,7 @@ import {
 export interface EventFilter {
   type: string
   account?: string
+  eventAccount?: string
 }
 
 export interface FunctionNameAndCallFilter extends CallFilter {

package/src/move/shared-network-codegen.ts

@@ -113,8 +113,8 @@ export abstract class SharedNetworkCodegen<NetworkType, ModuleTypes, StructType>
     const source = `
 onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.name)}Instance, ctx: ${
       this.PREFIX
-    }Context) => void, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
-  this.onMoveEvent(func, { type: '${module.name}::${struct.name}' }, fetchConfig)
+    }Context) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type"|"account">): ${moduleName} {
+  this.onMoveEvent(func, {...eventFilter ?? {}, type: '${module.name}::${struct.name}' }, fetchConfig)
   return this
 }`
     return source
@@ -122,7 +122,7 @@ onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.nam
 
   generateImports() {
     return `
-    import { CallFilter, MoveFetchConfig } from "@sentio/sdk/move"
+    import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move"
     import {
       ${this.PREFIX}BindOptions, ${this.PREFIX}BaseProcessor,
       ${this.PREFIX}Network, TypedFunctionPayload,

package/src/store/codegen.ts

@@ -106,7 +106,7 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
   const imports: Import[] = [
     {
       module: '@sentio/sdk/store',
-      types: ['String', 'Int', 'BigInt', 'Float', 'ID', 'Bytes', 'Timestamp', 'Boolean'],
+      types: ['String', 'Int', 'BigInt', 'Float', 'ID', 'Bytes', 'Timestamp', 'Boolean', 'Int8'],
       importType: true
     },
     {

package/src/store/convert.ts

@@ -134,6 +134,22 @@ export const IntConverter: ValueConverter<Int | undefined> = {
   }
 }
 
+export const Int8Converter: ValueConverter<bigint | undefined> = {
+  from: (value?: bigint) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      int64Value: BigInt(value)
+    }
+  },
+  to(v) {
+    return v.int64Value
+  }
+}
+
 export const FloatConverter: ValueConverter<Float | undefined> = {
   from: (value?: Float) => {
     if (value == null) {
@@ -291,6 +307,7 @@ export const TypeConverters: Record<string, ValueConverter<any>> = {
   ID: IDConverter,
   Bytes: BytesConverter,
   Int: IntConverter,
+  Int8: Int8Converter,
   Float: FloatConverter,
   Timestamp: TimestampConverter
 }

package/src/store/decorators.ts

@@ -7,6 +7,7 @@ import {
   BytesConverter,
   FloatConverter,
   IDConverter,
+  Int8Converter,
   IntConverter,
   objectId_,
   required_,
@@ -161,6 +162,7 @@ export function column(type?: ValueConverter<any>) {
 
 export const IDColumn = column(IDConverter)
 export const IntColumn = column(IntConverter)
+export const Int8Column = column(Int8Converter)
 export const FloatColumn = column(FloatConverter)
 export const BigDecimalColumn = column(BigDecimalConverter)
 export const BigIntColumn = column(BigIntConverter)

package/src/store/schema.ts

@@ -2,7 +2,7 @@ import { buildASTSchema, DocumentNode, extendSchema, GraphQLSchema, parse, valid
 import * as fs from 'node:fs'
 import { GraphQLObjectType, GraphQLOutputType, isListType, isNonNullType } from 'graphql'
 
-const customScalars = ['BigInt', 'BigDecimal', 'Timestamp', 'JSON', 'Bytes', 'ID']
+const customScalars = ['BigInt', 'BigDecimal', 'Timestamp', 'JSON', 'Bytes', 'ID', 'Int8']
 
 const baseSchema = buildASTSchema(
   parse(`