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

package/src/iota/iota-plugin-part.ts

@@ -1,15 +1,20 @@
 import { USER_PROCESSOR } from '@sentio/runtime'
 import {
-  AccountConfig,
-  ContractConfig,
+  AccountConfigSchema,
+  ContractConfigSchema,
   HandlerType,
-  InitResponse,
-  MoveCallHandlerConfig,
-  MoveEventHandlerConfig,
-  MoveResourceChangeConfig,
-  ProcessConfigResponse,
-  StartRequest
+  type InitResponse,
+  type MoveCallHandlerConfig,
+  MoveCallHandlerConfigSchema,
+  type MoveEventHandlerConfig,
+  MoveEventHandlerConfigSchema,
+  MoveOnIntervalConfigSchema,
+  type MoveResourceChangeConfig,
+  MoveResourceChangeConfigSchema,
+  type ProcessConfigResponse,
+  type StartRequest
 } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 
 import { PartitionHandlerManager } from '../core/index.js'
 import { HandlerRegister } from '../core/handler-register.js'
@@ -75,7 +80,7 @@ export class IotaPluginPart {
       if (forChainId !== undefined && forChainId !== chainId.toString()) {
         continue
       }
-      const contractConfig = ContractConfig.fromPartial({
+      const contractConfig = create(ContractConfigSchema, {
         transactionConfig: [],
         processorType: USER_PROCESSOR,
         contract: {
@@ -90,7 +95,7 @@ export class IotaPluginPart {
       for (const handler of suiProcessor.eventHandlers) {
         const handlerId = this.handlerRegister.register(handler.handler, chainId)
         this.partitionManager.registerPartitionHandler(HandlerType.SUI_EVENT, handlerId, handler.partitionHandler)
-        const eventHandlerConfig: MoveEventHandlerConfig = {
+        const eventHandlerConfig: MoveEventHandlerConfig = create(MoveEventHandlerConfigSchema, {
           filters: handler.filters.map((f) => {
             return {
               type: f.type,
@@ -101,13 +106,13 @@ export class IotaPluginPart {
           fetchConfig: handler.fetchConfig,
           handlerId,
           handlerName: handler.handlerName
-        }
+        })
         contractConfig.moveEventConfigs.push(eventHandlerConfig)
       }
       for (const handler of suiProcessor.callHandlers) {
         const handlerId = this.handlerRegister.register(handler.handler, chainId)
         this.partitionManager.registerPartitionHandler(HandlerType.SUI_CALL, handlerId, handler.partitionHandler)
-        const functionHandlerConfig: MoveCallHandlerConfig = {
+        const functionHandlerConfig: MoveCallHandlerConfig = create(MoveCallHandlerConfigSchema, {
           filters: handler.filters.map((filter) => {
             return {
               function: filter.function,
@@ -121,18 +126,18 @@ export class IotaPluginPart {
           fetchConfig: handler.fetchConfig,
           handlerId,
           handlerName: handler.handlerName
-        }
+        })
         contractConfig.moveCallConfigs.push(functionHandlerConfig)
       }
       // deprecated, use objectType processor instead
       for (const handler of suiProcessor.objectChangeHandlers) {
         const handlerId = this.handlerRegister.register(handler.handler, chainId)
-        const objectChangeHandler: MoveResourceChangeConfig = {
+        const objectChangeHandler: MoveResourceChangeConfig = create(MoveResourceChangeConfigSchema, {
           types: typeof handler.type === 'string' ? [handler.type] : handler.type,
           handlerId,
           handlerName: handler.handlerName,
           includeDeleted: false
-        }
+        })
         contractConfig.moveResourceChangeConfigs.push(objectChangeHandler)
       }
       config.contractConfigs.push(contractConfig)
@@ -143,7 +148,7 @@ export class IotaPluginPart {
       if (forChainId !== undefined && forChainId !== chainId.toString()) {
         continue
       }
-      const accountConfig = AccountConfig.fromPartial({
+      const accountConfig = create(AccountConfigSchema, {
         address: processor.config.address,
         chainId: processor.getChainId(),
         startBlock: processor.config.startCheckpoint, // TODO maybe use another field
@@ -152,39 +157,41 @@ export class IotaPluginPart {
 
       for (const handler of processor.objectChangeHandlers) {
         const handlerId = this.handlerRegister.register(handler.handler, chainId)
-        const objectChangeHandler: MoveResourceChangeConfig = {
+        const objectChangeHandler: MoveResourceChangeConfig = create(MoveResourceChangeConfigSchema, {
           types: typeof handler.type === 'string' ? [handler.type] : handler.type,
           handlerId,
           handlerName: handler.handlerName,
           includeDeleted: false
-        }
+        })
         accountConfig.moveResourceChangeConfigs.push(objectChangeHandler)
       }
 
       for (const handler of processor.objectHandlers) {
         const handlerId = this.handlerRegister.register(handler.handler, chainId)
 
-        accountConfig.moveIntervalConfigs.push({
-          intervalConfig: {
-            handlerId: handlerId,
-            handlerName: handler.handlerName,
-            minutes: 0,
-            minutesInterval: handler.timeIntervalInMinutes,
-            slot: 0,
-            slotInterval: handler.checkPointInterval,
+        accountConfig.moveIntervalConfigs.push(
+          create(MoveOnIntervalConfigSchema, {
+            intervalConfig: {
+              handlerId: handlerId,
+              handlerName: handler.handlerName,
+              minutes: 0,
+              minutesInterval: handler.timeIntervalInMinutes,
+              slot: 0,
+              slotInterval: handler.checkPointInterval,
+              fetchConfig: undefined
+            },
+            type: handler.type || '',
+            ownerType: processor.ownerType,
+            resourceFetchConfig: handler.fetchConfig,
             fetchConfig: undefined
-          },
-          type: handler.type || '',
-          ownerType: processor.ownerType,
-          resourceFetchConfig: handler.fetchConfig,
-          fetchConfig: undefined
-        })
+          })
+        )
       }
 
       if (processor instanceof IotaAddressProcessor) {
         for (const handler of processor.callHandlers) {
           const handlerId = this.handlerRegister.register(handler.handler, chainId)
-          const functionHandlerConfig: MoveCallHandlerConfig = {
+          const functionHandlerConfig: MoveCallHandlerConfig = create(MoveCallHandlerConfigSchema, {
             filters: handler.filters.map((filter) => {
               return {
                 function: filter.function,
@@ -198,7 +205,7 @@ export class IotaPluginPart {
             fetchConfig: handler.fetchConfig,
             handlerId,
             handlerName: handler.handlerName
-          }
+          })
           accountConfig.moveCallConfigs.push(functionHandlerConfig)
         }
       }

package/src/iota/iota-processor.ts

@@ -1,7 +1,15 @@
-import { Data_SuiCall, Data_SuiEvent, Data_SuiObjectChange, MoveFetchConfig } from '@sentio/protos'
+import {
+  type Data_SuiCall,
+  type Data_SuiEvent,
+  type Data_SuiObjectChange,
+  type MoveFetchConfig,
+  MoveFetchConfigSchema,
+  timestampDate
+} from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { ListStateStorage } from '@sentio/runtime'
 import { IotaNetwork } from './network.js'
-import { ServerError, Status } from 'nice-grpc'
+import { ConnectError, Code } from '@connectrpc/connect'
 import { IotaContext, IotaObjectChangeContext } from './context.js'
 import {
   MoveCallIotaTransaction,
@@ -26,11 +34,11 @@ import { Required } from 'utility-types'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 import { HandlerOptions } from './models.js'
 
-export const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
+export const DEFAULT_FETCH_CONFIG: MoveFetchConfig = create(MoveFetchConfigSchema, {
   resourceChanges: false,
   allEvents: true,
   inputs: true
-}
+})
 
 export type IndexConfigure = Required<IotaBindOptions, 'startCheckpoint' | 'network'>
 
@@ -85,7 +93,7 @@ export class IotaBaseProcessor {
     handlerOptions?: HandlerOptions<MoveFetchConfig, T>
   ): IotaBaseProcessor {
     let _filters: EventFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
+    const _fetchConfig = create(MoveFetchConfigSchema, { ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -102,7 +110,7 @@ export class IotaBaseProcessor {
       handlerName: getHandlerName(),
       handler: async function (data) {
         if (!data.rawTransaction) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'event is null')
+          throw new ConnectError('event is null', Code.InvalidArgument)
         }
         const txn = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
         if (txn.events == null) {
@@ -116,7 +124,7 @@ export class IotaBaseProcessor {
           processor.moduleName,
           processor.config.network,
           processor.config.address,
-          data.timestamp || new Date(0),
+          data.timestamp ? timestampDate(data.timestamp) : new Date(0),
           data.slot,
           txn,
           idx,
@@ -150,7 +158,7 @@ export class IotaBaseProcessor {
     handlerOptions?: HandlerOptions<MoveFetchConfig, T>
   ): IotaBaseProcessor {
     let _filters: FunctionNameAndCallFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
+    const _fetchConfig = create(MoveFetchConfigSchema, { ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -165,7 +173,7 @@ export class IotaBaseProcessor {
       handlerName: getHandlerName(),
       handler: async function (data) {
         if (!data.rawTransaction) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
+          throw new ConnectError('call is null', Code.InvalidArgument)
         }
         const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
 
@@ -173,7 +181,7 @@ export class IotaBaseProcessor {
           processor.moduleName,
           processor.config.network,
           processor.config.address,
-          data.timestamp || new Date(0),
+          data.timestamp ? timestampDate(data.timestamp) : new Date(0),
           data.slot,
           tx,
           0,
@@ -183,7 +191,7 @@ export class IotaBaseProcessor {
           const calls: MoveCallIotaTransaction[] = getMoveCalls(tx)
           const txKind = tx.transaction?.data?.transaction
           if (!txKind) {
-            throw new ServerError(Status.INVALID_ARGUMENT, 'Unexpected getTransactionKind get empty')
+            throw new ConnectError('Unexpected getTransactionKind get empty', Code.InvalidArgument)
           }
 
           // getProgrammableTransaction(txKind)
@@ -236,7 +244,7 @@ export class IotaBaseProcessor {
     filter?: TransactionFilter,
     handlerOptions?: HandlerOptions<MoveFetchConfig, IotaTransactionBlockResponse>
   ): this {
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
+    const _fetchConfig = create(MoveFetchConfigSchema, { ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
 
     const processor = this
 
@@ -244,7 +252,7 @@ export class IotaBaseProcessor {
       handlerName: getHandlerName(),
       handler: async function (data) {
         if (!data.rawTransaction) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'transaction is null')
+          throw new ConnectError('transaction is null', Code.InvalidArgument)
         }
         const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
 
@@ -252,7 +260,7 @@ export class IotaBaseProcessor {
           processor.moduleName,
           processor.config.network,
           processor.config.address,
-          data.timestamp || new Date(0),
+          data.timestamp ? timestampDate(data.timestamp) : new Date(0),
           data.slot,
           tx,
           0,
@@ -283,7 +291,7 @@ export class IotaBaseProcessor {
     type: string | string[]
   ): this {
     if (this.config.network === IotaNetwork.TEST_NET) {
-      throw new ServerError(Status.INVALID_ARGUMENT, 'object change not supported in testnet')
+      throw new ConnectError('object change not supported in testnet', Code.InvalidArgument)
     }
     const processor = this
     this.objectChangeHandlers.push({
@@ -292,7 +300,7 @@ export class IotaBaseProcessor {
         const ctx = new IotaObjectChangeContext(
           processor.config.network,
           processor.config.address,
-          data.timestamp || new Date(0),
+          data.timestamp ? timestampDate(data.timestamp) : new Date(0),
           data.slot,
           data.txDigest,
           processor.config.baseLabels
@@ -324,7 +332,7 @@ export class IotaGlobalProcessor extends IotaBaseProcessor {
   ): this {
     // TODO enable more strict check
     // if (!filter.publicKeyPrefix || filter.publicKeyPrefix.length < 2) {
-    //   throw new ServerError(Status.INVALID_ARGUMENT, 'restriction too low for global processor')
+    //   throw new ConnectError('restriction too low for global processor', Code.InvalidArgument)
     // }
     return super.onTransactionBlock(handler, filter, fetchConfig)
   }

package/src/iota/network.ts

@@ -1,6 +1,6 @@
 import { SuiChainId } from '@sentio/chain'
 import { Endpoints } from '@sentio/runtime'
-// import { ServerError, Status } from 'nice-grpc'
+// import { ConnectError, Code } from '@connectrpc/connect'
 import { IotaClient } from '@iota/iota-sdk/client'
 
 export type IotaNetwork = SuiChainId
@@ -13,7 +13,7 @@ export function getClient(network: IotaNetwork): IotaClient {
   let chainServer = Endpoints.INSTANCE.chainServer.get(network)
   if (!chainServer) {
     chainServer = getRpcEndpoint(network)
-    // throw new ServerError(Status.INTERNAL, 'RPC endpoint not provided')
+    // throw new ConnectError('RPC endpoint not provided', Code.Internal)
   }
   return new IotaClient({ url: chainServer })
 }

package/src/move/filter.ts

@@ -1,5 +1,5 @@
 // TODO extends ArgumentsFilter
-import {
+import type {
   Data_AptCall,
   Data_AptResource,
   HandleInterval,

package/src/move/index.ts

@@ -3,4 +3,4 @@ export * from './move-context.js'
 
 export * from '@typemove/move'
 
-export { MoveFetchConfig } from '@sentio/protos'
+export type { MoveFetchConfig } from '@sentio/protos'

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'
@@ -99,7 +100,10 @@ export class SolanaBaseProcessor {
   ): this {
     return this.onInterval(
       handler,
-      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
+      create(HandleIntervalSchema, {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      }),
       undefined
     )
   }
@@ -109,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)
+    })
   }
 
   /**