@sentio/sdk 4.0.0-rc.1 → 4.0.0-rc.3

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[]) {

package/src/store/store.ts

@@ -13,14 +13,14 @@ import {
   UpdateValues
 } from './types.js'
 import {
-  DBRequest,
-  DBRequest_DBUpdate,
-  Entity as EntityStruct,
+  DBRequest_DBUpdateSchema,
+  type Entity as EntityStruct,
   EntityUpdateData_Operator,
-  RichValue,
+  type RichValue,
   DBRequest_DBOperator,
-  DBResponse
+  type DBResponse
 } from '@sentio/protos'
+import { type MessageInitShape } from '@bufbuild/protobuf'
 import { IStoreContext, PluginManager } from '@sentio/runtime'
 import { Cursor } from './cursor.js'
 import { serializeRichValue } from './util.js'
@@ -76,15 +76,16 @@ export class Store {
     const entityName = getEntityName(entity)
 
     const promise = this.context.sendRequest({
-      get: {
+      case: 'get',
+      value: {
         entity: entityName,
         id: id.toString()
       }
     })
 
     const data = (await promise) as DBResponse
-    if (data.entityList?.entities[0]) {
-      const entityData = data.entityList?.entities[0]
+    if (data.value.case === 'entityList' && data.value.value.entities[0]) {
+      const entityData = data.value.value.entities[0]
       return this.newEntity(entity, entityData)
     }
 
@@ -116,32 +117,34 @@ export class Store {
     }
 
     await this.context.sendRequest({
-      delete: request
+      case: 'delete',
+      value: request
     })
   }
 
   async update<T extends Entity>(entity: EntityClass<T>, values: UpdateValues<any>): Promise<void> {
     if (values.id) {
-      const update: DBRequest_DBUpdate = {
+      const update: MessageInitShape<typeof DBRequest_DBUpdateSchema> = {
         entity: [getEntityName(entity)],
         id: [values.id.toString()],
         entityData: [{ fields: {} }]
       }
+      const fields = update.entityData![0].fields!
       for (const [key, value] of Object.entries(values)) {
         if (key !== 'id') {
           const field = getEntityField(entity, key)
           if (value instanceof AddOp) {
-            update.entityData[0].fields[field] = {
+            fields[field] = {
               op: EntityUpdateData_Operator.ADD,
               value: serializeRichValue(value.value)
             }
           } else if (value instanceof MultiplyOp) {
-            update.entityData[0].fields[field] = {
+            fields[field] = {
               op: EntityUpdateData_Operator.MULTIPLY,
               value: serializeRichValue(value.value)
             }
           } else if (value !== undefined) {
-            update.entityData[0].fields[field] = {
+            fields[field] = {
               op: EntityUpdateData_Operator.SET,
               value: serializeRichValue(value)
             }
@@ -149,7 +152,8 @@ export class Store {
         }
       }
       await this.context.sendRequest({
-        update
+        case: 'update',
+        value: update
       })
     } else {
       throw new Error('Update must have id field')
@@ -158,15 +162,15 @@ export class Store {
 
   async upsert<T extends Entity>(entity: T | T[]): Promise<void> {
     const entities = Array.isArray(entity) ? entity : [entity]
-    const request = {
-      upsert: {
+    await this.context.sendRequest({
+      case: 'upsert',
+      value: {
         entity: entities.map((e) => getEntityName(e)),
         // data: entities.map((e) => serialize(e.data)),
         id: entities.map((e) => e.id.toString()),
         entityData: entities.map((e: any) => e._data)
       }
-    } as DBRequest
-    await this.context.sendRequest(request)
+    })
   }
 
   async *listIterator<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
@@ -177,7 +181,8 @@ export class Store {
 
     while (true) {
       const response: DBResponse = await this.listRequest(entity, filters || [], cursor)
-      for (const data of response.entityList?.entities || []) {
+      const entities = response.value.case === 'entityList' ? response.value.value.entities : []
+      for (const data of entities) {
         yield this.newEntity(entity, data)
       }
       if (!response.nextCursor) {
@@ -196,7 +201,8 @@ export class Store {
 
     while (true) {
       const response: DBResponse = await this.listRequest(entity, filters || [], cursor, batchSize)
-      const entities = (response.entityList?.entities || []).map((data) => this.newEntity(entity, data))
+      const list = response.value.case === 'entityList' ? response.value.value.entities : []
+      const entities = list.map((data) => this.newEntity(entity, data))
       yield entities
       if (!response.nextCursor) {
         break
@@ -213,7 +219,8 @@ export class Store {
   ): Promise<DBResponse> {
     const response = (await this.context.sendRequest(
       {
-        list: {
+        case: 'list',
+        value: {
           entity: getEntityName(entity),
           cursor,
           pageSize,
@@ -259,7 +266,8 @@ export class Store {
     if (cursor) {
       const response = await this.listRequest(entity, filters || [], cursor.cursor, cursor.pageSize)
       cursor.cursor = response.nextCursor
-      return response.entityList?.entities.map((data) => this.newEntity(entity, data)) || []
+      const list = response.value.case === 'entityList' ? response.value.value.entities : []
+      return list.map((data) => this.newEntity(entity, data))
     }
     // TODO Array.fromAsync when upgrade to node 22
     return this.fromAsync(this.listIterator(entity, filters ?? []))

package/src/store/types.ts

@@ -1,4 +1,4 @@
-import { RichStruct, RichValue } from '@sentio/protos'
+import { type RichStruct, type RichValue, timestampDate } from '@sentio/protos'
 import { BigDecimalConverter, BigIntConverter } from './convert.js'
 import { getEntityName, Store } from './store.js'
 import { PluginManager } from '@sentio/runtime'
@@ -70,38 +70,29 @@ export abstract class AbstractEntity {
 }
 
 function toJSValue(value: RichValue): any {
-  if (value.nullValue != null) {
-    return null
-  }
-  if (value.bytesValue != null) {
-    return value.bytesValue
-  }
-  if (value.stringValue != null) {
-    return value.stringValue
-  }
-  if (value.bigdecimalValue != null) {
-    return BigDecimalConverter.to(value)
-  }
-  if (value.bigintValue != null) {
-    return BigIntConverter.to(value)
-  }
-  if (value.boolValue != null) {
-    return value.boolValue
-  }
-  if (value.timestampValue != null) {
-    return value.timestampValue
-  }
-  if (value.floatValue != null) {
-    return value.floatValue
-  }
-  if (value.intValue != null) {
-    return value.intValue
-  }
-  if (value.listValue != null) {
-    return value.listValue.values.map(toJSValue)
-  }
-  if (value.int64Value) {
-    return value.int64Value
+  switch (value.value.case) {
+    case 'nullValue':
+      return null
+    case 'bytesValue':
+      return value.value.value
+    case 'stringValue':
+      return value.value.value
+    case 'bigdecimalValue':
+      return BigDecimalConverter.to(value)
+    case 'bigintValue':
+      return BigIntConverter.to(value)
+    case 'boolValue':
+      return value.value.value
+    case 'timestampValue':
+      return timestampDate(value.value.value)
+    case 'floatValue':
+      return value.value.value
+    case 'intValue':
+      return value.value.value
+    case 'listValue':
+      return value.value.value.values.map(toJSValue)
+    case 'int64Value':
+      return value.value.value
   }
   throw new Error('Unknown value type:' + JSON.stringify(value))
 }

package/src/store/util.ts

@@ -1,25 +1,24 @@
-import type { RichValue } from '@sentio/protos'
+import { type RichValue, RichValueSchema, RichValue_NullValue, timestampFromDate } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { toBigInteger, toBigDecimal } from '../core/numberish.js'
 import { BigDecimal } from '@sentio/bigdecimal'
 
 export function serializeRichValue(v: any): RichValue {
   if (v == null) {
-    return { nullValue: 0 }
+    return create(RichValueSchema, { value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE } })
   }
   if (typeof v == 'boolean') {
-    return { boolValue: v }
+    return create(RichValueSchema, { value: { case: 'boolValue', value: v } })
   }
   if (typeof v == 'string') {
-    return { stringValue: v }
+    return create(RichValueSchema, { value: { case: 'stringValue', value: v } })
   }
 
   if (typeof v == 'number') {
-    return { floatValue: v }
+    return create(RichValueSchema, { value: { case: 'floatValue', value: v } })
   }
   if (typeof v == 'bigint') {
-    return {
-      bigintValue: toBigInteger(v)
-    }
+    return create(RichValueSchema, { value: { case: 'bigintValue', value: toBigInteger(v) } })
   }
 
   if (BigDecimal.isBigNumber(v)) {
@@ -27,25 +26,21 @@ export function serializeRichValue(v: any): RichValue {
   }
 
   if (v instanceof Date) {
-    return {
-      timestampValue: v
-    }
+    return create(RichValueSchema, { value: { case: 'timestampValue', value: timestampFromDate(v) } })
   }
 
   if (v instanceof Uint8Array) {
-    return { bytesValue: v }
+    return create(RichValueSchema, { value: { case: 'bytesValue', value: v } })
   }
 
   if (Array.isArray(v)) {
-    return {
-      listValue: { values: v.map((v) => serializeRichValue(v)) }
-    }
+    return create(RichValueSchema, {
+      value: { case: 'listValue', value: { values: v.map((v) => serializeRichValue(v)) } }
+    })
   }
   throw new Error('Unsupported type for serialization: ' + typeof v)
 }
 
 function serializeBigDecimal(v: BigDecimal): RichValue {
-  return {
-    bigdecimalValue: toBigDecimal(v)
-  }
+  return create(RichValueSchema, { value: { case: 'bigdecimalValue', value: toBigDecimal(v) } })
 }

package/src/sui/context.ts

@@ -1,4 +1,5 @@
-import { RecordMetaData } from '@sentio/protos'
+import { type RecordMetaData, RecordMetaDataSchema } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { type Labels, normalizeLabels } from '../index.js'
 import { getClient, SuiNetwork } from './network.js'
 import type { GrpcTypes, SuiGrpcClient } from '@mysten/sui/grpc'
@@ -47,7 +48,7 @@ export class SuiContext extends MoveContext<SuiNetwork, ModuleWithAddress, SuiEv
   }
 
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
+    return create(RecordMetaDataSchema, {
       address: this.address,
       contractName: this.moduleName,
       blockNumber: this.checkpoint,
@@ -57,7 +58,7 @@ export class SuiContext extends MoveContext<SuiNetwork, ModuleWithAddress, SuiEv
       chainId: this.getChainId(),
       name: name,
       labels: normalizeLabels(labels)
-    }
+    })
   }
 
   get client(): SuiGrpcClient {
@@ -101,7 +102,7 @@ export class SuiObjectChangeContext extends MoveContext<
   }
 
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
+    return create(RecordMetaDataSchema, {
       address: this.address,
       contractName: '*',
       blockNumber: this.checkpoint,
@@ -111,7 +112,7 @@ export class SuiObjectChangeContext extends MoveContext<
       chainId: this.getChainId(),
       name: name,
       labels: normalizeLabels(labels)
-    }
+    })
   }
 
   get client(): SuiGrpcClient {
@@ -153,7 +154,7 @@ export class SuiAddressContext extends MoveAccountContext<
   }
 
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
+    return create(RecordMetaDataSchema, {
       address: this.address,
       contractName: this.contractName,
       blockNumber: this.checkpoint,
@@ -163,7 +164,7 @@ export class SuiAddressContext extends MoveAccountContext<
       chainId: this.getChainId(),
       name: name,
       labels: normalizeLabels(labels)
-    }
+    })
   }
 
   get client(): SuiGrpcClient {