eco-solver 0.0.1-security → 1.5.1

package/src/liquidity-manager/services/liquidity-providers/LiFi/lifi-provider.service.spec.ts

@@ -0,0 +1,125 @@
+jest.mock('@lifi/sdk')
+
+import { FlowProducer, Queue } from 'bullmq'
+import { Test, TestingModule } from '@nestjs/testing'
+import { BullModule, getFlowProducerToken, getQueueToken } from '@nestjs/bullmq'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import * as LiFi from '@lifi/sdk'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { LiquidityManagerQueue } from '@/liquidity-manager/queues/liquidity-manager.queue'
+import { LiFiProviderService } from '@/liquidity-manager/services/liquidity-providers/LiFi/lifi-provider.service'
+import { KernelAccountClientV2Service } from '@/transaction/smart-wallets/kernel/kernel-account-client-v2.service'
+
+describe('LiFiProviderService', () => {
+  let lifiProviderService: LiFiProviderService
+  let kernelAccountClientService: KernelAccountClientV2Service
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let queue: DeepMocked<Queue>
+  let flowProducer: DeepMocked<FlowProducer>
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        LiFiProviderService,
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        {
+          provide: KernelAccountClientV2Service,
+          useValue: createMock<KernelAccountClientV2Service>(),
+        },
+      ],
+      imports: [
+        BullModule.registerQueue({ name: LiquidityManagerQueue.queueName }),
+        BullModule.registerFlowProducerAsync({ name: LiquidityManagerQueue.flowName }),
+      ],
+    })
+      .overrideProvider(getQueueToken(LiquidityManagerQueue.queueName))
+      .useValue(createMock<Queue>())
+      .overrideProvider(getFlowProducerToken(LiquidityManagerQueue.flowName))
+      .useValue(createMock<FlowProducer>())
+      .compile()
+
+    ecoConfigService = chainMod.get(EcoConfigService)
+    lifiProviderService = chainMod.get(LiFiProviderService)
+    kernelAccountClientService = chainMod.get(KernelAccountClientV2Service)
+
+    queue = chainMod.get(getQueueToken(LiquidityManagerQueue.queueName))
+    flowProducer = chainMod.get(getFlowProducerToken(LiquidityManagerQueue.flowName))
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('OnModuleInit', () => {
+    it('should configure LiFi SDK on init', async () => {
+      const mockGetClient = jest.spyOn(kernelAccountClientService, 'getClient')
+      mockGetClient.mockReturnValue({ account: { address: '0x123' } } as any)
+
+      jest.spyOn(ecoConfigService, 'getIntentSources').mockReturnValue([{ chainID: 10 }] as any)
+
+      const rpcUrls = { '10': 'http://op.rpc.com' }
+      jest.spyOn(ecoConfigService, 'getChainRPCs').mockReturnValue(rpcUrls)
+
+      await lifiProviderService.onModuleInit()
+
+      expect(mockGetClient).toHaveBeenCalled()
+      expect(lifiProviderService['walletAddress']).toEqual('0x123')
+      expect(LiFi.createConfig).toHaveBeenCalledWith(
+        expect.objectContaining({
+          integrator: 'Eco',
+          rpcUrls: { '10': [rpcUrls['10']] },
+        }),
+      )
+    })
+  })
+
+  describe('getQuote', () => {
+    it('should return a quote', async () => {
+      const mockTokenIn = {
+        chainId: 1,
+        config: { address: '0xTokenIn' },
+        balance: { decimals: 18 },
+      }
+      const mockTokenOut = {
+        chainId: 1,
+        config: { address: '0xTokenOut' },
+        balance: { decimals: 18 },
+      }
+      const mockRoute = {
+        fromAmount: '1000000000000000000',
+        toAmount: '2000000000000000000',
+        toAmountMin: '1900000000000000000',
+        steps: [],
+      }
+      jest.spyOn(LiFi, 'getRoutes').mockResolvedValue({ routes: [mockRoute] } as any)
+
+      const result = await lifiProviderService.getQuote(mockTokenIn as any, mockTokenOut as any, 1)
+
+      expect(result.amountIn).toEqual(BigInt(mockRoute.fromAmount))
+      expect(result.amountOut).toEqual(BigInt(mockRoute.toAmount))
+      expect(result.slippage).toBeCloseTo(0.05)
+      expect(result.tokenIn).toEqual(mockTokenIn)
+      expect(result.tokenOut).toEqual(mockTokenOut)
+      expect(result.strategy).toEqual('LiFi')
+      expect(result.context).toEqual(mockRoute)
+    })
+  })
+
+  describe('execute', () => {
+    it('should execute a quote', async () => {
+      const mockQuote = {
+        tokenIn: { config: { address: '0xTokenIn', chainId: 1 } },
+        tokenOut: { config: { address: '0xTokenOut', chainId: 1 } },
+        amountIn: BigInt(1000000000000000000),
+        amountOut: BigInt(2000000000000000000),
+        slippage: 0.05,
+        context: { gasCostUSD: 10, steps: [] },
+      }
+      const mockExecuteRoute = jest.spyOn(LiFi, 'executeRoute')
+
+      await lifiProviderService.execute(mockQuote as any)
+
+      expect(mockExecuteRoute).toHaveBeenCalledWith(mockQuote.context, expect.any(Object))
+    })
+  })
+})

package/src/liquidity-manager/services/liquidity-providers/LiFi/lifi-provider.service.ts

@@ -0,0 +1,117 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { parseUnits } from 'viem'
+import { createConfig, EVM, executeRoute, getRoutes, RoutesRequest, SDKConfig } from '@lifi/sdk'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { logLiFiProcess } from '@/liquidity-manager/services/liquidity-providers/LiFi/utils/get-transaction-hashes'
+import { KernelAccountClientV2Service } from '@/transaction/smart-wallets/kernel/kernel-account-client-v2.service'
+import { RebalanceQuote, Strategy, TokenData } from '@/liquidity-manager/types/types'
+
+@Injectable()
+export class LiFiProviderService implements OnModuleInit {
+  private logger = new Logger(LiFiProviderService.name)
+  private walletAddress: string
+
+  constructor(
+    private readonly ecoConfigService: EcoConfigService,
+    private readonly kernelAccountClientService: KernelAccountClientV2Service,
+  ) {}
+
+  async onModuleInit() {
+    // Use first intent source's network as the default network
+    const [intentSource] = this.ecoConfigService.getIntentSources()
+
+    const client = await this.kernelAccountClientService.getClient(intentSource.chainID)
+    this.walletAddress = client.account!.address
+
+    // Configure LiFi providers
+    createConfig({
+      integrator: 'Eco',
+      rpcUrls: this.getLiFiRPCUrls(),
+      providers: [
+        EVM({
+          getWalletClient: () => Promise.resolve(client),
+          switchChain: (chainId) => this.kernelAccountClientService.getClient(chainId),
+        }),
+      ],
+    })
+  }
+
+  getStrategy(): Strategy {
+    return 'LiFi'
+  }
+
+  async getQuote(
+    tokenIn: TokenData,
+    tokenOut: TokenData,
+    swapAmount: number,
+  ): Promise<RebalanceQuote> {
+    const routesRequest: RoutesRequest = {
+      // Origin chain
+      fromAddress: this.walletAddress,
+      fromChainId: tokenIn.chainId,
+      fromTokenAddress: tokenIn.config.address,
+      fromAmount: parseUnits(swapAmount.toString(), tokenIn.balance.decimals).toString(),
+
+      // Destination chain
+      toAddress: this.walletAddress,
+      toChainId: tokenOut.chainId,
+      toTokenAddress: tokenOut.config.address,
+    }
+
+    const result = await getRoutes(routesRequest)
+
+    const [route] = result.routes
+
+    const slippage = 1 - parseFloat(route.toAmountMin) / parseFloat(route.toAmount)
+
+    return {
+      amountIn: BigInt(route.fromAmount),
+      amountOut: BigInt(route.toAmount),
+      slippage: slippage,
+      tokenIn: tokenIn,
+      tokenOut: tokenOut,
+      strategy: this.getStrategy(),
+      context: route,
+    }
+  }
+
+  async execute(quote: RebalanceQuote<'LiFi'>) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: 'LiFiProviderService: executing quote',
+        properties: {
+          tokenIn: quote.tokenIn.config.address,
+          chainIn: quote.tokenIn.config.chainId,
+          tokenOut: quote.tokenIn.config.address,
+          chainOut: quote.tokenIn.config.chainId,
+          amountIn: quote.amountIn,
+          amountOut: quote.amountOut,
+          slippage: quote.slippage,
+          gasCostUSD: quote.context.gasCostUSD,
+          steps: quote.context.steps.map((step) => ({
+            type: step.type,
+            tool: step.tool,
+          })),
+        },
+      }),
+    )
+
+    // Execute the quote
+    return executeRoute(quote.context, {
+      updateRouteHook: (route) => logLiFiProcess(this.logger, route),
+      acceptExchangeRateUpdateHook: () => Promise.resolve(true),
+    })
+  }
+
+  private getLiFiRPCUrls() {
+    const rpcUrl = this.ecoConfigService.getChainRPCs()
+    const lifiRPCUrls: SDKConfig['rpcUrls'] = {}
+
+    for (const chainId in rpcUrl) {
+      lifiRPCUrls[parseInt(chainId)] = [rpcUrl[chainId]]
+    }
+
+    return lifiRPCUrls
+  }
+}

package/src/liquidity-manager/services/liquidity-providers/LiFi/utils/get-transaction-hashes.ts

@@ -0,0 +1,16 @@
+import { Logger } from '@nestjs/common'
+import { RouteExtended } from '@lifi/sdk'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+
+export function logLiFiProcess(logger: Logger, route: RouteExtended) {
+  route.steps.forEach((step, index) => {
+    step.execution?.process.forEach((process) => {
+      logger.log(
+        EcoLogMessage.fromDefault({
+          message: `LiFi: Step ${index + 1}, Process ${process.type}:`,
+          properties: process,
+        }),
+      )
+    })
+  })
+}

package/src/liquidity-manager/tests/liquidity-manager.service.spec.ts

@@ -0,0 +1,142 @@
+import { FlowProducer, Queue } from 'bullmq'
+import { Model } from 'mongoose'
+import { getModelToken } from '@nestjs/mongoose'
+import { Test, TestingModule } from '@nestjs/testing'
+import { BullModule, getFlowProducerToken, getQueueToken } from '@nestjs/bullmq'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { BalanceService } from '@/balance/balance.service'
+import { LiquidityManagerQueue } from '@/liquidity-manager/queues/liquidity-manager.queue'
+import { LiquidityManagerService } from '@/liquidity-manager/services/liquidity-manager.service'
+import { LiquidityProviderService } from '@/liquidity-manager/services/liquidity-provider.service'
+import { CheckBalancesCronJobManager } from '@/liquidity-manager/jobs/check-balances-cron.job'
+import { RebalanceModel } from '@/liquidity-manager/schemas/rebalance.schema'
+
+describe('LiquidityManagerService', () => {
+  let liquidityManagerService: LiquidityManagerService
+  let liquidityProviderService: LiquidityProviderService
+  let balanceService: DeepMocked<BalanceService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let queue: DeepMocked<Queue>
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        LiquidityManagerService,
+        { provide: BalanceService, useValue: createMock<BalanceService>() },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        { provide: LiquidityProviderService, useValue: createMock<LiquidityProviderService>() },
+        {
+          provide: getModelToken(RebalanceModel.name),
+          useValue: createMock<Model<RebalanceModel>>(),
+        },
+      ],
+      imports: [
+        BullModule.registerQueue({ name: LiquidityManagerQueue.queueName }),
+        BullModule.registerFlowProducerAsync({ name: LiquidityManagerQueue.flowName }),
+      ],
+    })
+      .overrideProvider(getQueueToken(LiquidityManagerQueue.queueName))
+      .useValue(createMock<Queue>())
+      .overrideProvider(getFlowProducerToken(LiquidityManagerQueue.flowName))
+      .useValue(createMock<FlowProducer>())
+      .compile()
+
+    balanceService = chainMod.get(BalanceService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    liquidityManagerService = chainMod.get(LiquidityManagerService)
+    liquidityProviderService = chainMod.get(LiquidityProviderService)
+    queue = chainMod.get(getQueueToken(LiquidityManagerQueue.queueName))
+  })
+
+  const mockConfig = {
+    targetSlippage: 0.02,
+    intervalDuration: 1000,
+    thresholds: { surplus: 0.1, deficit: 0.2 },
+  }
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('onApplicationBootstrap', () => {
+    it('should start cron job', async () => {
+      const intervalDuration = 1000
+      jest
+        .spyOn(ecoConfigService, 'getLiquidityManager')
+        .mockReturnValue({ intervalDuration } as any)
+
+      await liquidityManagerService.onApplicationBootstrap()
+
+      const upsertJobScheduler = jest.spyOn(queue, 'upsertJobScheduler')
+      expect(upsertJobScheduler).toHaveBeenCalledWith(
+        CheckBalancesCronJobManager.jobSchedulerName,
+        { every: intervalDuration },
+        expect.anything(),
+      )
+    })
+
+    it('should set liquidity manager config', async () => {
+      const mockConfig = { test: 1000n }
+      jest.spyOn(ecoConfigService, 'getLiquidityManager').mockReturnValue(mockConfig as any)
+      await liquidityManagerService.onApplicationBootstrap()
+      expect(liquidityManagerService['config']).toEqual(mockConfig)
+    })
+  })
+
+  describe('analyzeTokens', () => {
+    it('should analyze tokens and return the analysis', async () => {
+      const mockTokens = [
+        { config: { targetBalance: 10 }, balance: { balance: 100n } },
+        { config: { targetBalance: 100 }, balance: { balance: 100n } },
+        { config: { targetBalance: 200 }, balance: { balance: 100n } },
+      ]
+
+      liquidityManagerService['config'] = mockConfig
+
+      jest.spyOn(balanceService, 'getAllTokenData').mockResolvedValue(mockTokens as any)
+
+      const result = await liquidityManagerService.analyzeTokens()
+
+      expect(result.items).toHaveLength(3)
+      expect(result.surplus.items).toHaveLength(1)
+      expect(result.deficit.items).toHaveLength(1)
+    })
+  })
+
+  describe('getOptimizedRebalancing', () => {
+    it('should return swap quotes if possible', async () => {
+      const mockDeficitToken = {
+        config: { chainId: 1 },
+        analysis: { diff: 100, balance: { current: 50 }, targetSlippage: { min: 150 } },
+      }
+      const mockSurplusTokens = [{ config: { chainId: 1 }, analysis: { diff: 200 } }]
+
+      jest
+        .spyOn(liquidityProviderService, 'getQuote')
+        .mockResolvedValue([{ amountOut: 100 }] as any)
+
+      const result = await liquidityManagerService.getOptimizedRebalancing(
+        mockDeficitToken as any,
+        mockSurplusTokens as any,
+      )
+
+      expect(result).toHaveLength(1)
+    })
+  })
+
+  describe('executeRebalancing', () => {
+    it('should execute rebalancing quotes', async () => {
+      const mockRebalanceData = {
+        rebalance: {
+          quotes: ['quote1', 'quote2'],
+        },
+      }
+      jest.spyOn(liquidityProviderService, 'execute').mockResolvedValue(undefined as any)
+
+      await liquidityManagerService.executeRebalancing(mockRebalanceData as any)
+
+      expect(liquidityProviderService.execute).toHaveBeenCalledTimes(2)
+    })
+  })
+})

package/src/liquidity-manager/types/token-state.enum.ts

@@ -0,0 +1,5 @@
+export enum TokenState {
+  DEFICIT = 'DEFICIT',
+  SURPLUS = 'SURPLUS',
+  IN_RANGE = 'IN_RANGE',
+}

package/src/liquidity-manager/types/types.d.ts

@@ -0,0 +1,52 @@
+import { TokenBalance, TokenConfig } from '@/balance/types'
+import * as LiFi from '@lifi/sdk'
+
+type TokenState = 'DEFICIT' | 'SURPLUS' | 'IN_RANGE'
+
+interface TokenData {
+  chainId: number
+  config: TokenConfig
+  balance: TokenBalance
+}
+
+interface TokenBalanceAnalysis {
+  target: bigint
+  current: bigint
+  minimum: bigint
+  maximum: bigint
+}
+
+interface TokenAnalysis {
+  state: TokenState
+  diff: number
+  targetSlippage: { min: bigint; max: bigint }
+  balance: TokenBalanceAnalysis
+}
+
+interface TokenDataAnalyzed extends TokenData {
+  analysis: TokenAnalysis
+}
+
+// Strategy context
+
+type LiFiStrategyContext = LiFi.Route
+
+type Strategy = 'LiFi'
+type StrategyContext<S extends Strategy = Strategy> = S extends 'LiFi' ? LiFiStrategyContext : never
+
+// Quote
+
+interface RebalanceQuote<S extends Strategy = Strategy> {
+  amountIn: bigint
+  amountOut: bigint
+  slippage: number
+  tokenIn: TokenData
+  tokenOut: TokenData
+  strategy: S
+  context: StrategyContext<S>
+}
+
+interface RebalanceRequest {
+  token: TokenData
+  quotes: RebalanceQuote[]
+}

package/src/liquidity-manager/utils/address.ts

@@ -0,0 +1,5 @@
+import { Hex } from 'viem'
+
+export function shortAddr(addr: Hex | string): string {
+  return `${addr.slice(0, 6)}...${addr.slice(-4)}`
+}

package/src/liquidity-manager/utils/math.ts

@@ -0,0 +1,9 @@
+export function getSlippageRange(amount: bigint, slippage: number) {
+  const slippageFactor = BigInt(Math.round(slippage * 100000))
+  const base = 100000n
+
+  const min = (amount * (base - slippageFactor)) / base
+  const max = (amount * (base + slippageFactor)) / base
+
+  return { min, max }
+}

package/src/liquidity-manager/utils/serialize.spec.ts

@@ -0,0 +1,24 @@
+import { deserialize, serialize } from './serialize'
+
+describe('Serialize BigInt', () => {
+  it('serialize arrays correctly', () => {
+    const obj = { array: [1, 2, 3] }
+    const objDeserialized = deserialize(serialize(obj))
+
+    expect(Array.isArray(objDeserialized.array)).toBeTruthy()
+  })
+
+  it('serialize bigint in array correctly', () => {
+    const obj = { array: [1n, 2n, 3n] }
+    const objDeserialized = deserialize(serialize(obj))
+
+    expect(objDeserialized.array[0]).toBe(1n)
+  })
+
+  it('serialize bigint correctly', () => {
+    const obj = { number: 1, bigInt: 1n }
+    const objDeserialized = deserialize(serialize(obj))
+
+    expect(typeof objDeserialized.bigInt).toBe('bigint')
+  })
+})

package/src/liquidity-manager/utils/serialize.ts

@@ -0,0 +1,47 @@
+import * as _ from 'lodash'
+
+export type Serialize<T> = {
+  [K in keyof T]: T[K] extends bigint
+    ? { type: 'BigInt'; hex: string }
+    : T[K] extends object
+      ? Serialize<T[K]>
+      : T[K]
+}
+
+type SerializedBigInt = { type: 'BigInt'; hex: string }
+
+function isSerializedBigInt(data: any): data is SerializedBigInt {
+  return data && data.type === 'BigInt' && typeof data.hex === 'string'
+}
+
+function stringify(data: object) {
+  return JSON.stringify(data, (key, value) => {
+    if (typeof value === 'bigint') {
+      return { type: 'BigInt', hex: '0x' + value.toString(16) } as SerializedBigInt
+    }
+    return value
+  })
+}
+
+export function deserialize<T extends object>(data: Serialize<T>): T {
+  const deserialized: any = _.cloneDeep(data)
+
+  if (typeof data !== 'object') return data
+
+  for (const key in data) {
+    const item = data[key]
+    if (isSerializedBigInt(item)) {
+      deserialized[key] = BigInt(item.hex)
+    } else if (item && typeof item === 'object') {
+      deserialized[key] = deserialize(item)
+    } else {
+      deserialized[key] = item
+    }
+  }
+
+  return deserialized
+}
+
+export function serialize<T extends object>(data: T): Serialize<T> {
+  return JSON.parse(stringify(data))
+}

package/src/liquidity-manager/utils/token.ts

@@ -0,0 +1,91 @@
+import { formatUnits, parseUnits } from 'viem'
+import { TokenBalance, TokenConfig } from '@/balance/types'
+import { TokenState } from '@/liquidity-manager/types/token-state.enum'
+import { getSlippageRange } from '@/liquidity-manager/utils/math'
+import { Mathb } from '@/utils/bigint'
+import {
+  TokenAnalysis,
+  TokenBalanceAnalysis,
+  TokenDataAnalyzed,
+} from '@/liquidity-manager/types/types'
+
+/**
+ * Analyzes a token's balance against its configuration and returns the analysis.
+ * @param tokenConfig - The configuration of the token.
+ * @param tokenBalance - The current balance of the token.
+ * @param percentage - The percentage thresholds for up and down.
+ * @returns The analysis of the token's balance.
+ */
+export function analyzeToken(
+  tokenConfig: TokenConfig,
+  tokenBalance: TokenBalance,
+  percentage: { down: number; up: number; targetSlippage: number },
+): TokenAnalysis {
+  const { decimals } = tokenBalance
+
+  // Calculate the maximum and minimum acceptable balances
+  const maximum = tokenConfig.targetBalance * (1 + percentage.up)
+  const minimum = tokenConfig.targetBalance * (1 - percentage.down)
+
+  // Create a balance analysis object
+  const balance: TokenBalanceAnalysis = {
+    current: tokenBalance.balance,
+    maximum: parseUnits(maximum.toString(), decimals),
+    minimum: parseUnits(minimum.toString(), decimals),
+    target: parseUnits(tokenConfig.targetBalance.toString(), decimals),
+  }
+
+  // Determine the state of the token based on its balance
+  const state = getTokenState(balance)
+  // Calculate the difference between the current balance and the target balance
+  const diffWei = getTokenBalanceDiff(balance)
+  const diff = parseFloat(formatUnits(diffWei, decimals))
+  const targetSlippage = getSlippageRange(
+    parseUnits(tokenConfig.targetBalance.toString(), decimals),
+    percentage.targetSlippage,
+  )
+
+  return { balance, diff, state, targetSlippage }
+}
+
+/**
+ * Determines the state of a token based on its balance.
+ * @param balance - The balance analysis of the token.
+ * @returns The state of the token.
+ */
+function getTokenState(balance: TokenBalanceAnalysis): TokenState {
+  const { current, minimum, maximum } = balance
+  if (current > maximum) return TokenState.SURPLUS
+  if (current < minimum) return TokenState.DEFICIT
+  return TokenState.IN_RANGE
+}
+
+/**
+ * Calculates the absolute difference between the current balance and the target balance of a token.
+ * @param balance - The balance analysis of the token.
+ * @returns The absolute difference of tokens balance and the target balance.
+ */
+function getTokenBalanceDiff(balance: TokenBalanceAnalysis): bigint {
+  return Mathb.abs(balance.current - balance.target)
+}
+
+/**
+ * Analyzes a group of tokens and returns the total difference and the items in the group.
+ * @param group - The group of analyzed token data.
+ * @returns The total difference and the items in the group.
+ */
+export function analyzeTokenGroup(group: TokenDataAnalyzed[]) {
+  // Sort the group by diff in descending order
+  const items = group.sort((a, b) => Number(b.analysis.diff - a.analysis.diff))
+  // Calculate the total difference for the group
+  const total = getGroupTotal(items)
+  return { total, items }
+}
+
+export function getGroupTotal(group: TokenDataAnalyzed[]) {
+  return group.reduce((acc, item) => acc + item.analysis.diff, 0)
+}
+
+export function getSortGroupByDiff(group: TokenDataAnalyzed[]) {
+  return group.sort((a, b) => b.analysis.diff - a.analysis.diff)
+}