eco-solver 0.0.1-security → 1.5.1

package/src/quote/schemas/quote-route.schema.ts

@@ -0,0 +1,30 @@
+import {
+  TokenAmountDataModel,
+  TokenAmountDataSchema,
+} from '@/intent/schemas/intent-token-amount.schema'
+import { QuoteRouteDataInterface } from '@/quote/dto/quote.route.data.dto'
+import {
+  QuoteRouteCallDataModel,
+  QuoteRouteCallDataSchema,
+} from '@/quote/schemas/quote-call.schema'
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { Hex } from 'viem'
+
+@Schema({ timestamps: true })
+export class QuoteRouteDataModel implements QuoteRouteDataInterface {
+  @Prop({ required: true, type: BigInt })
+  source: bigint
+  @Prop({ required: true, type: BigInt })
+  destination: bigint
+  @Prop({ required: true, type: String })
+  inbox: Hex
+  @Prop({ required: true, type: [TokenAmountDataSchema] })
+  tokens: TokenAmountDataModel[]
+  @Prop({ required: true, type: [QuoteRouteCallDataSchema] })
+  calls: QuoteRouteCallDataModel[]
+}
+
+export const QuoteRouteDataSchema = SchemaFactory.createForClass(QuoteRouteDataModel)
+QuoteRouteDataSchema.index({ source: 1 }, { unique: false })
+QuoteRouteDataSchema.index({ destination: 1 }, { unique: false })
+QuoteRouteDataSchema.index({ inbox: 1 }, { unique: false })

package/src/quote/schemas/quote-token.schema.ts

@@ -0,0 +1,14 @@
+import { RewardTokensInterface } from '@/contracts'
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { Hex } from 'viem'
+
+@Schema({ timestamps: true })
+export class QuoteRewardTokenDataModel implements RewardTokensInterface {
+  @Prop({ required: true, type: String })
+  token: Hex
+  @Prop({ required: true, type: BigInt })
+  amount: bigint
+}
+
+export const QuoteRewardTokenDataSchema = SchemaFactory.createForClass(QuoteRewardTokenDataModel)
+QuoteRewardTokenDataSchema.index({ token: 1 }, { unique: false })

package/src/quote/tests/quote.service.spec.ts

@@ -0,0 +1,444 @@
+const mockGetTransactionTargetData = jest.fn()
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { FeeService } from '@/fee/fee.service'
+import { ValidationChecks, ValidationService } from '@/intent/validation.sevice'
+import {
+  InfeasibleQuote,
+  InsufficientBalance,
+  InternalQuoteError,
+  InternalSaveError,
+  InvalidQuoteIntent,
+  QuoteError,
+  SolverUnsupported,
+} from '@/quote/errors'
+import { QuoteService } from '@/quote/quote.service'
+import { QuoteIntentModel } from '@/quote/schemas/quote-intent.schema'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { getModelToken } from '@nestjs/mongoose'
+import { Test, TestingModule } from '@nestjs/testing'
+import { Model } from 'mongoose'
+
+jest.mock('@/intent/utils', () => {
+  return {
+    ...jest.requireActual('@/intent/utils'),
+    getTransactionTargetData: mockGetTransactionTargetData,
+  }
+})
+
+describe('QuotesService', () => {
+  let quoteService: QuoteService
+  let feeService: DeepMocked<FeeService>
+  let validationService: DeepMocked<ValidationService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let quoteModel: DeepMocked<Model<QuoteIntentModel>>
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+  const mockLogError = jest.fn()
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        QuoteService,
+        { provide: FeeService, useValue: createMock<FeeService>() },
+        { provide: ValidationService, useValue: createMock<ValidationService>() },
+        { provide: FeeService, useValue: createMock<FeeService>() },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        {
+          provide: getModelToken(QuoteIntentModel.name),
+          useValue: createMock<Model<QuoteIntentModel>>(),
+        },
+      ],
+    }).compile()
+
+    quoteService = chainMod.get(QuoteService)
+    feeService = chainMod.get(FeeService)
+    validationService = chainMod.get(ValidationService)
+
+    ecoConfigService = chainMod.get(EcoConfigService)
+    quoteModel = chainMod.get(getModelToken(QuoteIntentModel.name))
+
+    quoteService['logger'].debug = mockLogDebug
+    quoteService['logger'].log = mockLogLog
+    quoteService['logger'].error = mockLogError
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+    mockLogError.mockClear()
+  })
+
+  describe('on getQuote', () => {
+    const quoteIntent = { reward: { tokens: [] }, route: {} } as any
+    it('should throw an error if it cant store the quote in the db ', async () => {
+      const failedStore = new Error('error')
+      quoteService.storeQuoteIntentData = jest.fn().mockResolvedValue(failedStore)
+      expect(await quoteService.getQuote({} as any)).toEqual(InternalSaveError(failedStore))
+    })
+
+    it('should return a 400 if it fails to validate the quote data', async () => {
+      quoteService.storeQuoteIntentData = jest.fn().mockResolvedValue({})
+      quoteService.validateQuoteIntentData = jest.fn().mockResolvedValue(SolverUnsupported)
+      expect(await quoteService.getQuote({} as any)).toEqual(SolverUnsupported)
+    })
+
+    it('should save any error in getting the quote to the db', async () => {
+      const failedStore = new Error('error')
+      quoteService.storeQuoteIntentData = jest.fn().mockResolvedValue(quoteIntent)
+      quoteService.validateQuoteIntentData = jest.fn().mockResolvedValue(undefined)
+      quoteService.generateQuote = jest.fn().mockImplementation(() => {
+        throw failedStore
+      })
+      const mockDb = jest.spyOn(quoteService, 'updateQuoteDb')
+      expect(await quoteService.getQuote({} as any)).toEqual(InternalQuoteError(failedStore))
+      expect(mockDb).toHaveBeenCalled()
+      expect(mockDb).toHaveBeenCalledWith(quoteIntent, InternalQuoteError(failedStore))
+    })
+
+    it('should return the quote', async () => {
+      const quoteReciept = { fee: 1n }
+      quoteService.storeQuoteIntentData = jest.fn().mockResolvedValue(quoteIntent)
+      quoteService.validateQuoteIntentData = jest.fn().mockResolvedValue(undefined)
+      quoteService.generateQuote = jest.fn().mockResolvedValue(quoteReciept)
+      const mockDb = jest.spyOn(quoteService, 'updateQuoteDb')
+      expect(await quoteService.getQuote({} as any)).toEqual(quoteReciept)
+      expect(mockDb).toHaveBeenCalled()
+      expect(mockDb).toHaveBeenCalledWith(quoteIntent, quoteReciept)
+    })
+  })
+
+  describe('on storeQuoteIntentData', () => {
+    it('should log error if storing fails', async () => {
+      const failedStore = new Error('error')
+      jest.spyOn(quoteModel, 'create').mockRejectedValue(failedStore)
+      const r = await quoteService.storeQuoteIntentData({} as any)
+      expect(r).toEqual(failedStore)
+      expect(mockLogError).toHaveBeenCalled()
+    })
+
+    it('should save the DTO and return a record', async () => {
+      const data = { fee: 1n }
+      jest.spyOn(quoteModel, 'create').mockResolvedValue(data as any)
+      const r = await quoteService.storeQuoteIntentData({} as any)
+      expect(r).toEqual(data)
+      expect(mockLogError).not.toHaveBeenCalled()
+      expect(mockLogLog).toHaveBeenCalled()
+    })
+  })
+
+  describe('on validateQuoteIntentData', () => {
+    const quoteIntentModel = {
+      _id: 'id9',
+      route: {
+        destination: 1n,
+      },
+    }
+    const failValidations: ValidationChecks = {
+      supportedProver: true,
+      supportedTargets: true,
+      supportedSelectors: true,
+      validTransferLimit: true,
+      validExpirationTime: true,
+      validDestination: false,
+      fulfillOnDifferentChain: true,
+    }
+    const validValidations: ValidationChecks = {
+      supportedProver: true,
+      supportedTargets: true,
+      supportedSelectors: true,
+      validTransferLimit: true,
+      validExpirationTime: true,
+      validDestination: true,
+      fulfillOnDifferentChain: true,
+    }
+    let updateQuoteDb: jest.SpyInstance
+    beforeEach(() => {
+      updateQuoteDb = jest.spyOn(quoteService, 'updateQuoteDb')
+    })
+
+    afterEach(() => {
+      updateQuoteDb.mockClear()
+    })
+
+    it('should return solver unsupported if no solver for destination', async () => {
+      ecoConfigService.getSolver = jest.fn().mockReturnValue(undefined)
+      expect(await quoteService.validateQuoteIntentData(quoteIntentModel as any)).toEqual(
+        SolverUnsupported,
+      )
+      expect(mockLogLog).toHaveBeenCalled()
+      expect(mockLogLog).toHaveBeenCalledWith({
+        msg: `validateQuoteIntentData: No solver found for destination : ${quoteIntentModel.route.destination}`,
+        quoteIntentModel,
+      })
+      expect(updateQuoteDb).toHaveBeenCalledWith(quoteIntentModel, { error: SolverUnsupported })
+    })
+
+    it('should return invalid quote if the quote fails validations', async () => {
+      ecoConfigService.getSolver = jest.fn().mockReturnValue({})
+      validationService.assertValidations = jest.fn().mockReturnValue(failValidations)
+
+      expect(await quoteService.validateQuoteIntentData(quoteIntentModel as any)).toEqual(
+        InvalidQuoteIntent(failValidations),
+      )
+      expect(mockLogLog).toHaveBeenCalled()
+      expect(mockLogLog).toHaveBeenCalledWith({
+        msg: `validateQuoteIntentData: Some validations failed`,
+        quoteIntentModel,
+        validations: failValidations,
+      })
+      expect(updateQuoteDb).toHaveBeenCalledWith(quoteIntentModel, {
+        error: InvalidQuoteIntent(failValidations),
+      })
+    })
+
+    it('should return infeasable if the quote is infeasable', async () => {
+      const error = QuoteError.SolverLacksLiquidity(1, '0x2', 4n, 3n, 2n)
+      ecoConfigService.getSolver = jest.fn().mockReturnValue({})
+      validationService.assertValidations = jest.fn().mockReturnValue(validValidations)
+      feeService.isRouteFeasible = jest.fn().mockResolvedValue({ error })
+      expect(await quoteService.validateQuoteIntentData(quoteIntentModel as any)).toEqual(
+        InfeasibleQuote(error),
+      )
+      expect(mockLogLog).toHaveBeenCalled()
+      expect(mockLogLog).toHaveBeenCalledWith({
+        msg: `validateQuoteIntentData: quote intent is not feasable ${quoteIntentModel._id}`,
+        quoteIntentModel,
+        feasable: false,
+        error: InfeasibleQuote(error),
+      })
+      expect(updateQuoteDb).toHaveBeenCalledWith(quoteIntentModel, {
+        error: InfeasibleQuote(error),
+      })
+    })
+
+    it('should return nothing if all the validations pass', async () => {
+      ecoConfigService.getSolver = jest.fn().mockReturnValue({})
+      validationService.assertValidations = jest.fn().mockReturnValue(validValidations)
+      feeService.isRouteFeasible = jest.fn().mockResolvedValue({})
+      expect(await quoteService.validateQuoteIntentData(quoteIntentModel as any)).toEqual(undefined)
+      expect(updateQuoteDb).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('on generateQuote', () => {
+    it('should return error on calculate tokens failed', async () => {
+      const error = new Error('error') as any
+      feeService.calculateTokens = jest.fn().mockResolvedValue({ error } as any)
+      expect(await quoteService.generateQuote({} as any)).toEqual(InternalQuoteError(error))
+    })
+
+    it('should return error on calculate tokens doesnt return the calculated tokens', async () => {
+      feeService.calculateTokens = jest.fn().mockResolvedValue({ calculated: undefined } as any)
+      expect(await quoteService.generateQuote({} as any)).toEqual(InternalQuoteError(undefined))
+    })
+
+    it('should return an insufficient balance if the reward doesnt meet the ask', async () => {
+      const calculated = {
+        solver: {},
+        rewards: [{ balance: 10n }, { balance: 102n }],
+        calls: [{ balance: 280n }, { balance: 102n }],
+        deficitDescending: [],
+      } as any
+      jest.spyOn(feeService, 'calculateTokens').mockResolvedValue({ calculated })
+      const ask = calculated.calls.reduce((a, b) => a + b.balance, 0n)
+      const askMock = jest.spyOn(feeService, 'getAsk').mockReturnValue(ask)
+      expect(await quoteService.generateQuote({ route: {} } as any)).toEqual(
+        InsufficientBalance(ask, 112n),
+      )
+      expect(askMock).toHaveBeenCalled()
+    })
+
+    describe('on building quote', () => {
+      beforeEach(() => {})
+
+      async function generateHelper(
+        calculated: any,
+        expectedTokens: { token: string; amount: bigint }[],
+      ) {
+        const ask = calculated.calls.reduce((a, b) => a + b.balance, 0n)
+        jest.spyOn(feeService, 'getAsk').mockReturnValue(ask)
+        jest.spyOn(feeService, 'calculateTokens').mockResolvedValue({ calculated })
+        feeService.deconvertNormalize = jest.fn().mockImplementation((amount) => {
+          return { balance: amount }
+        })
+        expect(await quoteService.generateQuote({ route: {} } as any)).toEqual({
+          tokens: expectedTokens,
+          expiryTime: expect.any(String),
+        })
+      }
+
+      it('should fill up the most deficit balance', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [
+            { address: '0x1', balance: 100n },
+            { address: '0x2', balance: 200n },
+          ],
+          calls: [{ balance: 50n }],
+          deficitDescending: [
+            { delta: { balance: -100n, address: '0x1' } },
+            { delta: { balance: -50n }, address: '0x2' },
+          ],
+        } as any
+        await generateHelper(calculated, [{ token: '0x1', amount: 50n }])
+      })
+
+      it('should fill deficit that has rewards to fill it', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [{ address: '0x2', balance: 200n }],
+          calls: [{ balance: 150n }],
+          deficitDescending: [
+            { delta: { balance: -100n, address: '0x1' } },
+            { delta: { balance: -50n, address: '0x2' } },
+          ],
+        } as any
+        await generateHelper(calculated, [{ token: '0x2', amount: 150n }])
+      })
+
+      it('should fill surplus if no deficit', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [{ address: '0x2', balance: 200n }],
+          calls: [{ balance: 40n }],
+          deficitDescending: [
+            { delta: { balance: 100n, address: '0x1' } },
+            { delta: { balance: 200n, address: '0x2' } },
+          ],
+        } as any
+        await generateHelper(calculated, [{ token: '0x2', amount: 40n }])
+      })
+
+      it('should fill partial deficits', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [
+            { address: '0x1', balance: 200n },
+            { address: '0x2', balance: 200n },
+          ],
+          calls: [{ balance: 150n }],
+          deficitDescending: [
+            { delta: { balance: -100n, address: '0x1' } },
+            { delta: { balance: -50n, address: '0x2' } },
+          ],
+        } as any
+        await generateHelper(calculated, [
+          { token: '0x1', amount: 100n },
+          { token: '0x2', amount: 50n },
+        ])
+      })
+
+      it('should fill surplus if deficit is not rewarded', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [{ address: '0x2', balance: 200n }],
+          calls: [{ balance: 150n }],
+          deficitDescending: [
+            { delta: { balance: -100n, address: '0x1' } },
+            { delta: { balance: 100n, address: '0x2' } },
+          ],
+        } as any
+        await generateHelper(calculated, [{ token: '0x2', amount: 150n }])
+      })
+
+      it('should fill deficit as much as it can and then surplus', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [
+            { address: '0x1', balance: 50n },
+            { address: '0x2', balance: 20n },
+            { address: '0x3', balance: 200n },
+          ],
+          calls: [{ balance: 150n }],
+          deficitDescending: [
+            { delta: { balance: -100n, address: '0x1' } },
+            { delta: { balance: -50n, address: '0x2' } },
+            { delta: { balance: 100n, address: '0x3' } },
+          ],
+        } as any
+        await generateHelper(calculated, [
+          { token: '0x1', amount: 50n },
+          { token: '0x2', amount: 20n },
+          { token: '0x3', amount: 80n },
+        ])
+      })
+
+      it('should fill deficit in remaining funds loop that can be filled when rewards dont allow order', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [
+            { address: '0x1', balance: 50n },
+            { address: '0x2', balance: 200n },
+          ],
+          calls: [{ balance: 250n }],
+          deficitDescending: [
+            { delta: { balance: -100n, address: '0x1' } },
+            { delta: { balance: -50n, address: '0x2' } },
+          ],
+        } as any
+        await generateHelper(calculated, [
+          { token: '0x1', amount: 50n },
+          { token: '0x2', amount: 200n },
+        ])
+      })
+
+      it('should fill surpluses in ascending order', async () => {
+        const calculated = {
+          solver: {},
+          rewards: [
+            { address: '0x1', balance: 150n },
+            { address: '0x2', balance: 150n },
+          ],
+          calls: [{ balance: 250n }],
+          deficitDescending: [
+            { delta: { balance: 10n, address: '0x1' } },
+            { delta: { balance: 20n, address: '0x2' } },
+          ],
+        } as any
+        await generateHelper(calculated, [
+          { token: '0x1', amount: 150n },
+          { token: '0x2', amount: 100n },
+        ])
+      })
+    })
+  })
+
+  describe('on getQuoteExpiryTime', () => {
+    it('should return the correct expiry time', async () => {
+      const expiryTime = quoteService.getQuoteExpiryTime()
+      expect(Number(expiryTime)).toBeGreaterThan(0)
+    })
+  })
+
+  describe('on updateQuoteDb', () => {
+    const _id = 'id9'
+    it('should return error if db save fails', async () => {
+      const failedStore = new Error('error')
+      jest.spyOn(quoteModel, 'updateOne').mockRejectedValue(failedStore)
+      const r = await quoteService.updateQuoteDb({ _id } as any)
+      expect(r).toEqual(failedStore)
+      expect(mockLogError).toHaveBeenCalled()
+    })
+
+    it('should save the DTO', async () => {
+      const data = { fee: 1n }
+      jest.spyOn(quoteModel, 'updateOne').mockResolvedValue(data as any)
+      const r = await quoteService.updateQuoteDb({ _id } as any)
+      expect(r).toBeUndefined()
+      expect(mockLogError).not.toHaveBeenCalled()
+      expect(jest.spyOn(quoteModel, 'updateOne')).toHaveBeenCalledWith({ _id }, { _id })
+    })
+
+    it('should save the DTO with a reciept', async () => {
+      const data = { fee: 1n }
+      const receipt = 'receipt'
+      jest.spyOn(quoteModel, 'updateOne').mockResolvedValue(data as any)
+      const r = await quoteService.updateQuoteDb({ _id, receipt } as any)
+      expect(r).toBeUndefined()
+      expect(mockLogError).not.toHaveBeenCalled()
+      expect(jest.spyOn(quoteModel, 'updateOne')).toHaveBeenCalledWith({ _id }, { _id, receipt })
+    })
+  })
+})

package/src/sign/atomic-signer.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { NonceService } from './nonce.service'
+import { privateKeyAndNonceToAccountSigner } from './sign.helper'
+import { SignerService } from './signer.service'
+import { Hex, PrivateKeyAccount } from 'viem'
+
+@Injectable()
+export class AtomicSignerService extends SignerService {
+  constructor(
+    readonly nonceService: NonceService,
+    readonly ecoConfigService: EcoConfigService,
+  ) {
+    super(ecoConfigService)
+  }
+
+  protected buildAccount(): PrivateKeyAccount {
+    return privateKeyAndNonceToAccountSigner(this.nonceService, this.getPrivateKey())
+  }
+
+  protected override getPrivateKey(): Hex {
+    return this.ecoConfigService.getEth().simpleAccount.signerPrivateKey
+  }
+}

package/src/sign/atomic.nonce.service.ts

@@ -0,0 +1,114 @@
+import { Hex, NonceManagerSource, Prettify, PublicClient } from 'viem'
+import type { Address } from 'abitype'
+import { Model, QueryOptions } from 'mongoose'
+import type { Client } from 'viem/_types/clients/createClient'
+import { Injectable, Logger } from '@nestjs/common'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { getAtomicNonceKey } from './sign.helper'
+
+export type AtomicKeyParams = {
+  address: Hex
+  chainId: number
+}
+
+export type AtomicKeyClientParams = Prettify<
+  Pick<AtomicKeyParams, 'address'> & {
+    client: PublicClient
+  }
+>
+
+export type AtomicGetParameters = Prettify<AtomicKeyParams & { client: Client }>
+
+/** An atomic JSON-RPC source for a nonce manager. It initializes the nonce
+ * to the current RPC returned transaction count, then it stores and increments
+ * the nonce through an atomic call locally. Ie. a database that can enforce atomicity.
+ *
+ * This way the account for the nonce can be shared amongs multiple processes simultaneously without
+ * the treat of nonce collisions. Such as in a kubernetes cluster.
+ */
+@Injectable()
+export abstract class AtomicNonceService<T extends { nonce: number }>
+  implements NonceManagerSource
+{
+  protected logger = new Logger(AtomicNonceService.name)
+
+  constructor(protected model: Model<T>) {}
+
+  async syncNonces(): Promise<void> {
+    const params: AtomicKeyClientParams[] = await this.getSyncParams()
+    if (params.length === 0) {
+      return
+    }
+
+    const nonceSyncs = params.map(async (param: AtomicKeyClientParams) => {
+      const { address, client } = param
+      const nonceNum = await client.getTransactionCount({ address, blockTag: 'pending' })
+
+      return {
+        nonceNum,
+        chainID: client.chain?.id,
+        address: address,
+      }
+    })
+
+    try {
+      const updatedNonces = await Promise.all(nonceSyncs)
+      const updates = updatedNonces.map(async (nonce) => {
+        const { address, chainID } = nonce
+        const key = getAtomicNonceKey({ address, chainId: chainID ?? 0 })
+        const query = { key }
+        const updates = { $set: { nonce: nonce.nonceNum, chainID, address } }
+        const options = { upsert: true, new: true }
+        this.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: `AtomicNonceService: updating nonce in sync`,
+            properties: {
+              query,
+              updates,
+            },
+          }),
+        )
+        return this.model.findOneAndUpdate(query, updates, options).exec()
+      })
+
+      await Promise.all(updates)
+    } catch (e) {
+      EcoLogMessage.fromDefault({
+        message: `Error syncing nonces`,
+        properties: {
+          error: e,
+        },
+      })
+    }
+  }
+
+  async get(parameters: AtomicGetParameters): Promise<number> {
+    return await this.getIncNonce(parameters)
+  }
+
+  async set(params: AtomicGetParameters, nonce: number): Promise<void> {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+  async getIncNonce(parameters: AtomicGetParameters): Promise<number> {
+    const query = { key: getAtomicNonceKey(parameters) }
+    const updates = { $inc: { nonce: 1 } }
+    const options: QueryOptions = {
+      upsert: true, //creates a new document if one doesn't exist
+      new: true, //returns the updated document instead of the document before update
+    }
+    //get and increment from db
+    const updateResponse = await this.model.findOneAndUpdate(query, updates, options).exec()
+    return updateResponse?.nonce ?? 0
+  }
+
+  protected async getSyncParams(): Promise<AtomicKeyClientParams[]> {
+    return []
+  }
+
+  async getNonces(): Promise<T[]> {
+    return this.model.find().exec()
+  }
+
+  static getNonceQueueKey(address: Address, chainId: number): string {
+    return `${address}.${chainId}`
+  }
+}