eco-solver 0.0.1-security → 1.5.2

package/src/chain-monitor/tests/chain-sync.service.spec.ts

@@ -0,0 +1,190 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { ChainSyncService } from '../chain-sync.service'
+import { WatchCreateIntentService } from '../../watch/intent/watch-create-intent.service'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Test, TestingModule } from '@nestjs/testing'
+import { getModelToken } from '@nestjs/mongoose'
+import { IntentSourceModel } from '../../intent/schemas/intent-source.schema'
+import { Model } from 'mongoose'
+import { Solver, IntentSource } from '../../eco-configs/eco-config.types'
+import { entries } from 'lodash'
+import { KernelAccountClientService } from '../../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { IntentSourceAbi } from '@eco-foundation/routes-ts'
+
+describe('ChainSyncService', () => {
+  let chainSyncService: ChainSyncService
+  let accountService: DeepMocked<KernelAccountClientService>
+  let watchIntentService: DeepMocked<WatchCreateIntentService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        ChainSyncService,
+        {
+          provide: KernelAccountClientService,
+          useValue: createMock<KernelAccountClientService>(),
+        },
+        { provide: WatchCreateIntentService, useValue: createMock<WatchCreateIntentService>() },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        {
+          provide: getModelToken(IntentSourceModel.name),
+          useValue: createMock<Model<IntentSourceModel>>(),
+        },
+      ],
+    }).compile()
+
+    chainSyncService = chainMod.get(ChainSyncService)
+    accountService = chainMod.get(KernelAccountClientService)
+    watchIntentService = chainMod.get(WatchCreateIntentService)
+    ecoConfigService = chainMod.get(EcoConfigService) as DeepMocked<EcoConfigService>
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+  })
+
+  describe('on chain sync startup', () => {
+    it('should start a sync', async () => {
+      const mockSyncTxs = jest.fn()
+      chainSyncService.syncTxs = mockSyncTxs
+      await chainSyncService.onApplicationBootstrap()
+      expect(mockSyncTxs).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('on syncTxs', () => {
+    it('should start a sync for all source intent contracts', async () => {
+      const intentSources = [
+        { network: 'network1' },
+        { network: 'network2' },
+        { network: 'network3' },
+      ] as any
+      const mockSyncTxsPerSource = jest.fn()
+      chainSyncService.syncTxsPerSource = mockSyncTxsPerSource
+      ecoConfigService.getIntentSources.mockReturnValue(intentSources)
+
+      chainSyncService.syncTxs()
+      expect(mockSyncTxsPerSource).toHaveBeenCalledTimes(3)
+      expect(mockSyncTxsPerSource).toHaveBeenNthCalledWith(1, intentSources[0])
+      expect(mockSyncTxsPerSource).toHaveBeenNthCalledWith(2, intentSources[1])
+      expect(mockSyncTxsPerSource).toHaveBeenNthCalledWith(3, intentSources[2])
+    })
+  })
+
+  describe('on syncTxsPerSource', () => {
+    let mockGetContractEvents: jest.Mock
+
+    const intentSource = {
+      chainID: 123,
+      sourceAddress: '0x123',
+      network: 'network1',
+      provers: ['0x456', '0x789', '0xabc'],
+    } as unknown as IntentSource
+
+    const solvers = {
+      123: {
+        inboxAddress: '0x456',
+      },
+      456: {
+        inboxAddress: '0x789',
+      },
+      789: {
+        inboxAddress: '0xabc',
+      },
+    } as any as Solver[]
+
+    const model = { event: { blockNumber: 50n, sourceChainID: intentSource.chainID } }
+    const supportedChains = Object.keys(solvers).map((key) => BigInt(key))
+    beforeEach(() => {
+      mockGetContractEvents = jest.fn().mockResolvedValue([])
+
+      accountService.getClient = jest.fn().mockReturnValue({
+        getContractEvents: mockGetContractEvents,
+      })
+
+      ecoConfigService.getSolvers.mockReturnValue(solvers)
+    })
+
+    it('should set fromBlock to 0x0 when no transactions in db', async () => {
+      await chainSyncService.syncTxsPerSource(intentSource)
+      expect(mockGetContractEvents).toHaveBeenCalledTimes(1)
+      expect(mockGetContractEvents).toHaveBeenCalledWith({
+        address: intentSource.sourceAddress,
+        abi: IntentSourceAbi,
+        eventName: 'IntentCreated',
+        args: {
+          prover: intentSource.provers,
+        },
+        fromBlock: 0n,
+        toBlock: 'latest',
+      })
+    })
+
+    it('should set fromBlock to the block of the db transaction', async () => {
+      chainSyncService['getLastRecordedTx'] = jest.fn().mockResolvedValueOnce([model])
+
+      await chainSyncService.syncTxsPerSource(intentSource)
+      expect(mockGetContractEvents).toHaveBeenCalledTimes(1)
+      expect(mockGetContractEvents).toHaveBeenCalledWith({
+        address: intentSource.sourceAddress,
+        abi: IntentSourceAbi,
+        eventName: 'IntentCreated',
+        args: {
+          prover: intentSource.provers,
+        },
+        fromBlock: model.event.blockNumber + 1n, // we search from the next block
+        toBlock: 'latest',
+      })
+    })
+
+    it('should log when no transfers exist since last db record', async () => {
+      chainSyncService['getLastRecordedTx'] = jest.fn().mockResolvedValueOnce([model])
+      const mockLog = jest.fn()
+      chainSyncService['logger'].log = mockLog
+      await chainSyncService.syncTxsPerSource(intentSource)
+      expect(mockGetContractEvents).toHaveBeenCalledTimes(1)
+      expect(mockLog).toHaveBeenCalledTimes(1)
+      // we search from the next block
+      const searchFromBlock = model.event.blockNumber + 1n
+      expect(mockLog).toHaveBeenCalledWith({
+        msg: `No transactions found for source ${intentSource.network} to sync from block ${searchFromBlock}`,
+        chainID: model.event.sourceChainID,
+        fromBlock: searchFromBlock,
+      })
+    })
+
+    it('should process all the txs that are to a supported destination since the last saved blockNumber', async () => {
+      const unsupportedChain = 1000n
+      chainSyncService['getLastRecordedTx'] = jest.fn().mockResolvedValueOnce([model])
+      ecoConfigService.getSupportedChains.mockReturnValue(supportedChains)
+      const logs = [
+        { msg: 'firstlog', args: { destination: supportedChains[0] } },
+        { msg: 'secondlog', args: { destination: supportedChains[1] } },
+        { msg: 'thirdlog', args: { destination: unsupportedChain } },
+      ]
+      const returnLogs = logs
+        .filter((log) => supportedChains.includes(log.args.destination))
+        .map((log) => {
+          return {
+            ...log,
+            sourceNetwork: intentSource.network,
+            sourceChainID: intentSource.chainID,
+          }
+        })
+      const mockProcessJob = jest.fn()
+      const mockAddJob = jest.fn(() => mockProcessJob)
+      watchIntentService.addJob = mockAddJob as any
+      mockGetContractEvents.mockResolvedValueOnce(logs)
+      ecoConfigService.getIntentSources.mockReturnValue([intentSource])
+
+      await chainSyncService.syncTxs()
+      expect(mockAddJob).toHaveBeenCalledTimes(1)
+      expect(mockProcessJob).toHaveBeenCalledTimes(1)
+      expect(mockAddJob).toHaveBeenCalledWith(intentSource)
+      expect(mockProcessJob).toHaveBeenCalledWith(returnLogs)
+      expect(returnLogs).toHaveLength(2)
+    })
+  })
+})

package/src/commander/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: '../../.eslintrc.js',
+  rules: {
+    'no-console': 'off',
+  },
+}

package/src/commander/balance/balance-command.module.ts

@@ -0,0 +1,12 @@
+import { BalanceService } from '@/balance/balance.service'
+import { BalanceCommand } from '@/commander/balance/balance.command'
+import { TransferCommandModule } from '@/commander/transfer/transfer-command.module'
+import { CacheModule } from '@nestjs/cache-manager'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [CacheModule.register(), TransferCommandModule],
+  providers: [BalanceCommand, BalanceService],
+  exports: [BalanceCommand],
+})
+export class BalanceCommandModule {}

package/src/commander/balance/balance.command.ts

@@ -0,0 +1,73 @@
+import { getAddress } from 'viem'
+import { Command, Option } from 'nest-commander'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { BalanceService } from '@/balance/balance.service'
+import { KernelAccountClientService } from '@/transaction/smart-wallets/kernel/kernel-account-client.service'
+import { jsonBigInt } from '@/commander/utils'
+import { ClientCommand } from '@/commander/transfer/client.command'
+
+@Command({
+  name: 'balance',
+  description: 'Displays the balance of the Kernel wallet',
+})
+export class BalanceCommand extends ClientCommand {
+  constructor(
+    protected readonly balanceService: BalanceService,
+    protected readonly kernelAccountClientService: KernelAccountClientService,
+    protected readonly ecoConfigService: EcoConfigService,
+  ) {
+    super(balanceService, kernelAccountClientService, ecoConfigService)
+  }
+
+  async run(passedParams: string[], options?: Record<string, any>): Promise<void> {
+    console.log(`Wallet address: ${await this.getWalletAddress()}`)
+    if (Object.values(options || {}).length === 0) {
+      console.log('No options provided, fetching all token data')
+      const data = await this.balanceService.getAllTokenData()
+      console.log(`Token data:`)
+      console.log(jsonBigInt(data))
+      return
+    }
+
+    if (options?.chainID && options?.token) {
+      console.log(`Fetching balance on ${options.chainID} for ${options.token}`)
+      const data = await this.balanceService.fetchTokenBalances(options.chainID, [options.token])
+
+      console.log(`Token data on chain : ${options.chainID}:`)
+      console.log(jsonBigInt(data))
+      return
+    }
+
+    if (options?.chainID) {
+      console.log(`Fetching all balances on ${options.chainID}`)
+      const data = await this.balanceService.fetchTokenBalancesForChain(options.chainID)
+      console.log(`Tokens data on chain : ${options.chainID}:`)
+      console.log(jsonBigInt(data))
+    }
+
+    console.log(`You must set the chainID and token to get the balance of a token`)
+  }
+
+  async getWalletAddress() {
+    const chains = this.ecoConfigService.getSupportedChains()
+    const client = await this.kernelAccountClientService.getClient(Number(chains[0]))
+    return client.kernelAccount.address
+  }
+
+  // 84532 0xAb1D243b07e99C91dE9E4B80DFc2B07a8332A2f7
+  @Option({
+    flags: '-c, --chainID <chainID>',
+    description: 'The chain ID for a token balance',
+  })
+  parseChainID(val: string) {
+    return Number(val)
+  }
+
+  @Option({
+    flags: '-t, --token <token>',
+    description: 'The token address to get the balance of',
+  })
+  parseToken(val: string) {
+    return getAddress(val)
+  }
+}

package/src/commander/command-main.ts

@@ -0,0 +1,15 @@
+import { CommanderAppModule } from '@/commander/commander-app.module'
+import { CommandFactory } from 'nest-commander'
+import { Logger } from 'nestjs-pino'
+
+async function bootstrap() {
+  try {
+    const cmd = CommandFactory.createWithoutRunning(CommanderAppModule)
+    const lg = (await cmd).get(Logger)
+    ;(await cmd).useLogger(lg)
+    await CommandFactory.runApplication(await cmd)
+  } catch (e) {
+    console.error(e)
+  }
+}
+bootstrap()

package/src/commander/commander-app.module.ts

@@ -0,0 +1,31 @@
+import { BalanceCommandModule } from '@/commander/balance/balance-command.module'
+import { EcoConfigCommand } from '@/commander/eco-config.command'
+import { SafeCommandModule } from '@/commander/safe/safe-command.module'
+import { TransferCommandModule } from '@/commander/transfer/transfer-command.module'
+import { EcoConfigModule } from '@/eco-configs/eco-config.module'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { Module } from '@nestjs/common'
+import { LoggerModule } from 'nestjs-pino'
+
+@Module({
+  imports: [
+    EcoConfigModule.withAWS(),
+    BalanceCommandModule,
+    SafeCommandModule,
+    TransferCommandModule,
+    LoggerModule.forRootAsync({
+      inject: [EcoConfigService],
+      useFactory: async (configService: EcoConfigService) => {
+        const loggerConfig = configService.getLoggerConfig()
+        return {
+          pinoHttp: {
+            ...loggerConfig.pinoConfig.pinoHttp,
+            level: 'warn',
+          },
+        }
+      },
+    }),
+  ],
+  providers: [EcoConfigCommand],
+})
+export class CommanderAppModule {}

package/src/commander/eco-config.command.ts

@@ -0,0 +1,20 @@
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { Command, CommandRunner } from 'nest-commander'
+
+@Command({
+  name: 'configs',
+  arguments: '[task]',
+  description: 'A parameter parse',
+})
+export class EcoConfigCommand extends CommandRunner {
+  constructor(private readonly configService: EcoConfigService) {
+    super()
+  }
+
+  async run(passedParams: string[], options?: Record<string, any>): Promise<void> {
+    console.log('CLI Params', passedParams)
+    console.log('CLI Options', options)
+    console.log('configService: ', this.configService.getSupportedChains())
+    return Promise.resolve(undefined)
+  }
+}

package/src/commander/safe/safe-command.module.ts

@@ -0,0 +1,11 @@
+import { SafeCommand } from '@/commander/safe/safe.command'
+import { TransferCommandModule } from '@/commander/transfer/transfer-command.module'
+import { CacheModule } from '@nestjs/cache-manager'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [CacheModule.register(), TransferCommandModule],
+  providers: [SafeCommand],
+  exports: [SafeCommand],
+})
+export class SafeCommandModule {}

package/src/commander/safe/safe.command.ts

@@ -0,0 +1,70 @@
+import { getAddress } from 'viem'
+import { Command, CommandRunner, Option } from 'nest-commander'
+import { getExecutorTransferData } from '@/transaction/smart-wallets/kernel/create.kernel.account'
+import { GLOBAL_CONSTANTS } from '@rhinestone/module-sdk'
+
+@Command({
+  name: 'safe',
+  description:
+    'Generates the transaction calldata for a safe transaction on the OwnableExecutor module',
+})
+export class SafeCommand extends CommandRunner {
+  constructor() {
+    super()
+  }
+
+  async run(passedParams: string[], options?: Record<string, any>): Promise<void> {
+    if (options?.to && options?.amount && options?.token && options?.kernel) {
+      console.log(
+        `Transfer:
+        amount: ${options.amount}
+        token ${options.token}
+        to ${options.to}
+        kernel ${options.kernel}`,
+      )
+      const data = getExecutorTransferData(options?.kernel, {
+        to: options.to,
+        amount: options.amount,
+        tokenAddress: options.token,
+      })
+      console.log(`OwnableExecutor transfer data: ${data}`)
+      console.log(
+        `Should execute data on OwnableExecutor contract: ${GLOBAL_CONSTANTS.OWNABLE_EXECUTOR_ADDRESS}`,
+      )
+      return
+    }
+    console.log('You must set the to, amount, token and kernelAddress to generate the calldata')
+  }
+
+  @Option({
+    flags: '-k, --kernel <kernel>',
+    description: 'The kernel wallet address for the executor to call, which it owns',
+  })
+  parseKernelAddress(val: string) {
+    return getAddress(val)
+  }
+
+  @Option({
+    flags: '-t, --to <to>',
+    description: 'The recipient of the transaction',
+  })
+  parseTo(val: string) {
+    return getAddress(val)
+  }
+
+  @Option({
+    flags: '-a, --amount <amount>',
+    description: 'The amount in the decimals of the token to transfer',
+  })
+  parseAmount(val: string) {
+    return BigInt(val)
+  }
+
+  @Option({
+    flags: '-tk, --token <token>',
+    description: 'The ERC20 token address to transfer',
+  })
+  parseToken(val: string) {
+    return getAddress(val)
+  }
+}

package/src/commander/transfer/client.command.ts

@@ -0,0 +1,24 @@
+import { CommandRunner } from 'nest-commander'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { BalanceService } from '@/balance/balance.service'
+import { KernelAccountClientService } from '@/transaction/smart-wallets/kernel/kernel-account-client.service'
+
+export abstract class ClientCommand extends CommandRunner {
+  constructor(
+    protected readonly balanceService: BalanceService,
+    protected readonly kernelAccountClientService: KernelAccountClientService,
+    protected readonly ecoConfigService: EcoConfigService,
+  ) {
+    super()
+  }
+
+  async getClient(chainID?: number) {
+    return await this.kernelAccountClientService.getClient(Number(chainID || 0))
+  }
+
+  async getWalletAddress(chainID?: number) {
+    const chains = this.ecoConfigService.getSupportedChains()
+    const client = await this.kernelAccountClientService.getClient(Number(chains[chainID || 0]))
+    return client.kernelAccount.address
+  }
+}

package/src/commander/transfer/transfer-command.module.ts

@@ -0,0 +1,26 @@
+import { BalanceService } from '@/balance/balance.service'
+import { TransferCommand } from '@/commander/transfer/transfer.command'
+import { KmsService } from '@/kms/kms.service'
+import { SignerKmsService } from '@/sign/signer-kms.service'
+import { KernelAccountClientService } from '@/transaction/smart-wallets/kernel/kernel-account-client.service'
+import { CacheModule } from '@nestjs/cache-manager'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [CacheModule.register()],
+  providers: [
+    TransferCommand,
+    KmsService,
+    SignerKmsService,
+    KernelAccountClientService,
+    BalanceService,
+  ],
+  exports: [
+    TransferCommand,
+    KmsService,
+    SignerKmsService,
+    KernelAccountClientService,
+    BalanceService,
+  ],
+})
+export class TransferCommandModule {}

package/src/commander/transfer/transfer.command.ts

@@ -0,0 +1,138 @@
+import { encodeFunctionData, getAddress, Hex, erc20Abi, parseEther } from 'viem'
+import { Command, CommandRunner, Option } from 'nest-commander'
+import { KernelAccountClientService } from '@/transaction/smart-wallets/kernel/kernel-account-client.service'
+import { BalanceService } from '@/balance/balance.service'
+
+@Command({
+  name: 'transfer',
+  arguments: '<recipient>',
+  description:
+    'Moves ERC20 tokens from the Kernel wallet to another address, all values are in decimal 6 format',
+})
+export class TransferCommand extends CommandRunner {
+  constructor(
+    private readonly kernelAccountClientService: KernelAccountClientService,
+    private readonly balanceService: BalanceService,
+  ) {
+    super()
+  }
+
+  async run(passedParams: string[], options?: Record<string, any>): Promise<void> {
+    console.log('CLI TransferCommand Params', passedParams)
+    const recipient = getAddress(passedParams[0])
+    console.log('Recipient', recipient)
+
+    if (options?.native && options?.chainID) {
+      console.log(`Transfering native tokens to ${recipient} with amount: ${options.native}`)
+      await this.transferNative(options.chainID, recipient, options.native)
+      return
+    }
+
+    if (options?.everything && options?.chainID) {
+      console.log(`Transfering all tokens to ${recipient}`)
+      await this.transferTokens(options.chainID, recipient)
+      return
+    }
+
+    if (options?.token && options?.amount && options?.chainID) {
+      console.log(
+        `Transfering token: ${options.token} to ${recipient} with amount: ${options.amount}`,
+      )
+      await this.transferToken(options.chainID, options.token, recipient, options.amount)
+      return
+    }
+  }
+
+  @Option({
+    flags: '-t, --token <token>',
+    description: 'The address of the token to transfer',
+  })
+  parseToken(val: string) {
+    return getAddress(val)
+  }
+
+  @Option({
+    flags: '-a, --amount <amount>',
+    description: 'The amount in the decimals of the token to transfer',
+  })
+  parseAmount(val: string) {
+    return BigInt(val)
+  }
+
+  @Option({
+    flags: '-c, --chainID <chainID>',
+    description: 'The chain ID for a token balance',
+  })
+  parseChainID(val: string) {
+    return Number(val)
+  }
+
+  @Option({
+    flags: '-e, --everything',
+    description: 'True if the transfer should be done for all tokens',
+  })
+  parseEverything(val: string) {
+    console.log('parseEverything', val)
+    return true
+  }
+
+  @Option({
+    flags: '-n, --native <native>',
+    description: 'The amount of native tokens to send, in normal eth format',
+  })
+  parseNative(val: string) {
+    console.log('parseNative', val)
+    return parseEther(val)
+  }
+
+  /**
+   * Transfers a token to a recipient
+   * @param chainID the chain id
+   * @param token the token address
+   * @param recipient the recipient address
+   * @param amount the amount to transfer, assumes in correct decimal format for that token
+   */
+  async transferToken(chainID: number, token: Hex, recipient: Hex, amount: bigint) {
+    const client = await this.kernelAccountClientService.getClient(chainID)
+    const transferFunctionData = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: 'transfer',
+      args: [recipient, amount],
+    })
+    const receipt = await client.execute([
+      { to: token, data: transferFunctionData, value: BigInt(0) },
+    ])
+    console.log('Transfer Receipt', receipt)
+    await client.waitForTransactionReceipt({ hash: receipt, confirmations: 5 })
+  }
+
+  /**
+   * Sends all the tokens on a given chain to a recipient
+   * @param chainID the chain id
+   * @param recipient the recipient address
+   * @returns
+   */
+  async transferTokens(chainID: number, recipient: Hex) {
+    const tokens = await this.balanceService.fetchTokenBalancesForChain(chainID)
+    if (!tokens) {
+      console.log('No tokens found')
+      return
+    }
+    const filtered = Object.values(tokens).filter((token) => token.balance > BigInt(0))
+    for (const token of filtered) {
+      await this.transferToken(chainID, token.address, recipient, token.balance)
+    }
+  }
+
+  /**
+   * Transfers native tokens to a recipient
+   * @param chainID the chain id
+   * @param recipient the recipient address
+   * @param amount the amount to transfer in wei format
+   */
+  async transferNative(chainID: number, recipient: Hex, amount: bigint) {
+    const client = await this.kernelAccountClientService.getClient(chainID)
+    const receipt = await client.execute([{ to: recipient, value: amount }])
+    console.log('Transfer Receipt', receipt)
+  }
+}

package/src/commander/utils.ts

@@ -0,0 +1,8 @@
+/**
+ * Stringify data with BigInt support
+ * @param data the data to stringify
+ * @returns
+ */
+export function jsonBigInt(data: any) {
+  return JSON.stringify(data, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
+}

package/src/common/chains/definitions/arbitrum.ts

@@ -0,0 +1,12 @@
+import { Chain } from 'viem'
+import { arbitrum as varbitrum } from 'viem/chains'
+
+export const arbitrum: Chain = {
+  ...varbitrum,
+  rpcUrls: {
+    ...varbitrum.rpcUrls,
+    alchemy: {
+      http: ['https://arb-mainnet.g.alchemy.com/v2'],
+    },
+  },
+}

package/src/common/chains/definitions/base.ts

@@ -0,0 +1,21 @@
+import { Chain } from 'viem'
+import { base as vbase, baseSepolia as vbases } from 'viem/chains'
+
+export const base: Chain = {
+  ...vbase,
+  rpcUrls: {
+    ...vbase.rpcUrls,
+    alchemy: {
+      http: ['https://base-mainnet.g.alchemy.com/v2'],
+    },
+  },
+}
+export const baseSepolia: Chain = {
+  ...vbases,
+  rpcUrls: {
+    ...vbases.rpcUrls,
+    alchemy: {
+      http: ['https://base-sepolia.g.alchemy.com/v2'],
+    },
+  },
+}