eco-solver 0.0.1-security → 1.5.2

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

@@ -0,0 +1,54 @@
+import { defineChain } from 'viem'
+import { chainConfig } from 'viem/op-stack'
+
+// settlement chain
+const sourceId = 84532 //base sepolia
+
+export const ecoSepolia = /*#__PURE__*/ defineChain({
+  ...chainConfig,
+  id: 471923,
+  name: 'Eco Test',
+  nativeCurrency: { name: 'Sepolia Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://eco-testnet.rpc.caldera.xyz/http'],
+      webSocket: ['wss://eco-testnet.rpc.caldera.xyz/ws'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'eco-testnet explorer',
+      url: 'https://eco-testnet.explorer.caldera.xyz/',
+      apiUrl: 'https://eco-testnet.explorer.caldera.xyz/api/v2',
+    },
+  },
+  contracts: {
+    ...chainConfig.contracts,
+    disputeGameFactory: {
+      [sourceId]: {
+        address: '0x01C6834a6EA1bd8CD69F38D5E657B53BdA53d684',
+      },
+    },
+    l2OutputOracle: {
+      [sourceId]: {
+        address: '0xb3EDAE5AB86f16242018c7cED4fBCabb3c784951',
+      },
+    },
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 4286263,
+    },
+    portal: {
+      [sourceId]: {
+        address: '0xb94EFa2bba9d52A67944c4bE1014D1A09F5d8939',
+      },
+    },
+    l1StandardBridge: {
+      [sourceId]: {
+        address: '0x635f8f0Ae3fEE30C408C5c4E0C44115a2d636e29',
+      },
+    },
+  },
+  sourceId,
+  testnet: true,
+})

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

@@ -0,0 +1,22 @@
+import { Chain } from 'viem'
+import { mainnet as vmainnet, sepolia as vsepolia } from 'viem/chains'
+
+export const ethereum: Chain = {
+  ...vmainnet,
+  rpcUrls: {
+    ...vmainnet.rpcUrls,
+    alchemy: {
+      http: ['https://eth-mainnet.g.alchemy.com/v2'],
+    },
+  },
+}
+
+export const sepolia: Chain = {
+  ...vsepolia,
+  rpcUrls: {
+    ...vsepolia.rpcUrls,
+    alchemy: {
+      http: ['https://eth-sepolia.g.alchemy.com/v2'],
+    },
+  },
+}

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

@@ -0,0 +1,53 @@
+import { defineChain } from 'viem'
+import { chainConfig } from 'viem/op-stack'
+
+// settlement chain
+const sourceId = 8453 //base mainnet
+
+export const helix = /*#__PURE__*/ defineChain({
+  ...chainConfig,
+  id: 8921733,
+  name: 'Helix Test',
+  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://helix-test.calderachain.xyz/http'],
+      webSocket: ['wss://helix-test.calderachain.xyz/ws'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'helix-test explorer',
+      url: 'https://helix-test.calderaexplorer.xyz',
+      apiUrl: 'https://helix-test.calderaexplorer.xyz/api/v2',
+    },
+  },
+  contracts: {
+    ...chainConfig.contracts,
+    disputeGameFactory: {
+      [sourceId]: {
+        address: '0x685eeDFd7280cbdC1B49E766a06b31D00dAEab2b',
+      },
+    },
+    l2OutputOracle: {
+      [sourceId]: {
+        address: '0xf3B21c72BFd684eC459697c48f995CDeb5E5DB9d',
+      },
+    },
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 4286263,
+    },
+    portal: {
+      [sourceId]: {
+        address: '0x8C3df798e9CA0826Cb9DB3530635aa719EB1E562',
+      },
+    },
+    l1StandardBridge: {
+      [sourceId]: {
+        address: '0xe746B6ac4c5Fca4770e0468D9aA62CbE6c55803A',
+      },
+    },
+  },
+  sourceId,
+})

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

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

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

@@ -0,0 +1,22 @@
+import { Chain } from 'viem'
+import { optimism as vop, optimismSepolia as vops } from 'viem/chains'
+
+export const optimism: Chain = {
+  ...vop,
+  rpcUrls: {
+    ...vop.rpcUrls,
+    alchemy: {
+      http: ['https://opt-mainnet.g.alchemy.com/v2'],
+    },
+  },
+}
+
+export const optimismSepolia: Chain = {
+  ...vops,
+  rpcUrls: {
+    ...vops.rpcUrls,
+    alchemy: {
+      http: ['https://opt-sepolia.g.alchemy.com/v2'],
+    },
+  },
+}

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

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

package/src/common/chains/supported.ts

@@ -0,0 +1,26 @@
+import { Chain } from 'viem'
+import { ecoSepolia } from './definitions/eco'
+import { helix } from './definitions/helix'
+import { optimism, optimismSepolia } from './definitions/optimism'
+import { base, baseSepolia } from './definitions/base'
+import { arbitrum } from './definitions/arbitrum'
+import { mantle } from './definitions/mantle'
+import { polygon } from './definitions/polygon'
+import { ethereum, sepolia } from './definitions/ethereum'
+
+/**
+ * List of supported chains for the solver that have modified RPC URLs or are defined in the project
+ */
+export const ChainsSupported: Chain[] = [
+  optimism,
+  optimismSepolia,
+  base,
+  baseSepolia,
+  ecoSepolia,
+  helix,
+  arbitrum,
+  mantle,
+  polygon,
+  ethereum,
+  sepolia,
+]

package/src/common/chains/transport.ts

@@ -0,0 +1,19 @@
+import { Chain, http, HttpTransport, webSocket, WebSocketTransport } from 'viem'
+import { getRpcUrl } from '../viem/utils'
+
+/**
+ * Returns a transport for the chain with the given api key
+ *
+ * @param chain the chain to get the transport for
+ * @param apiKey the alchemy api key
+ * @param websocketEnabled whether to use websocket or not, defaults to true
+ * @returns the websocket or http transport
+ */
+export function getTransport(
+  chain: Chain,
+  apiKey?: string,
+  websocketEnabled: boolean = false,
+): WebSocketTransport | HttpTransport {
+  const { url, isWebsocket } = getRpcUrl(chain, apiKey, websocketEnabled)
+  return isWebsocket ? webSocket(url, { keepAlive: true, reconnect: true }) : http(url)
+}

package/src/common/errors/eco-error.ts

@@ -0,0 +1,155 @@
+import { Network } from 'alchemy-sdk'
+import { Logger } from '@nestjs/common'
+import * as _ from 'lodash'
+import { EcoLogMessage } from '../logging/eco-log-message'
+import { Chain, TransactionReceipt } from 'viem'
+import { AwsCredential } from '@/eco-configs/eco-config.types'
+
+export class EcoError extends Error {
+  // Alchemy Service
+  static AlchemyUnsupportedNetworkError(network: Network) {
+    return new EcoError(`App does not support network ${network}, check your config file`)
+  }
+  static AlchemyUnsupportedNetworkIDError(id: number) {
+    return new EcoError(`App does not support network ${id}, check your config file`)
+  }
+
+  static AlchemyServiceProviderError(network: string) {
+    return new EcoError(`Could not create alchemy provider ${network}`)
+  }
+
+  static BalanceServiceInvalidDecimals(address: string) {
+    return new EcoError(`Token has to be decimals 6, verify conversions before allowing ${address}`)
+  }
+
+  static IntentSourceDataNotFound(intentHash: string) {
+    return new EcoError(`Could not find data for intent hash ${intentHash}`)
+  }
+
+  static IntentValidationFailed(hash: string) {
+    return new EcoError(`Intent validation failed for intent hash ${hash}`)
+  }
+
+  static IntentSourceNotFound(chainID: number) {
+    return new EcoError(`Could not find an intent source for chain ${chainID}`)
+  }
+
+  static IntentSourceDataInvalidParams = new Error(
+    'IntentSource calls or tokens must have non-zero length',
+  )
+
+  static IntentSourceTargetConfigNotFound(target: string) {
+    return new EcoError(`Solver does not have target: ${target}`)
+  }
+
+  static TargetSelectorNotSupported(target: string) {
+    return new EcoError(`Solver does not have target: ${target}`)
+  }
+
+  static IntentSourceUnsupportedTargetType(targetType: string) {
+    return new EcoError(`Unsupported target type ${targetType}`)
+  }
+
+  static ChainConfigNotFound(chainID: string) {
+    return new EcoError(`Chain config not found for chain ${chainID}`)
+  }
+
+  static InvalidSimpleAccountConfig() {
+    return new EcoError(`The simple account config is invalid`)
+  }
+
+  static InvalidKernelAccountConfig() {
+    return new EcoError(`The kernel account config is invalid`)
+  }
+
+  static FeasibilityIntentNoTransactionError = new Error('No transaction data found')
+  static FulfillIntentNoTransactionError = new Error('No transaction data found')
+  static FulfillIntentBatchError = new Error('Could not fulfill batch transaction')
+  static FulfillIntentRevertError(receipt: TransactionReceipt) {
+    const msg = JSON.stringify(receipt, (_, v) => (typeof v === 'bigint' ? v.toString() : v))
+    return new Error(msg)
+  }
+
+  // ValidateIntent Service
+  static ValidateIntentDescructureFailed(err?: Error) {
+    return err || new Error('Desctructuring the intent from the intent hash failed')
+  }
+
+  // WatchIntent Service
+  static WatchEventUnsubscribeError = new Error('Could not unsubscribe from watch event')
+  static WatchEventUnsubscribeFromError(chainID: number) {
+    return new Error(`Could not unsubscribe from watch event for chain : ${chainID}`)
+  }
+  static WatchEventNoUnsubscribeError(chainID: number) {
+    return new Error(`There is no unwatch for chain : ${chainID}`)
+  }
+
+  // Viem
+
+  static UnsupportedChainError(chain: Chain) {
+    return new EcoError(
+      `App does not support chain ${chain.id}:${chain.name}, check your config file`,
+    )
+  }
+
+  static KmsCredentialsError(config?: AwsCredential) {
+    return new EcoError(`Could not get AWS KMS credentials: ${config}`)
+  }
+
+  // EcoConfig Service
+
+  static isEcoError(error: any): boolean {
+    return error instanceof EcoError
+  }
+
+  static getErrorObject(error: any): Error {
+    if (error instanceof Error) {
+      return error
+    }
+
+    return new Error(this.getErrorMessage(error))
+  }
+
+  static logErrorWithStack(error: any, caller: string, srcLogger: Logger, properties: object = {}) {
+    return this._logError(this.getErrorObject(error), caller, srcLogger, properties, true)
+  }
+
+  static _logError(
+    error: Error,
+    caller: string,
+    srcLogger: Logger,
+    properties: object,
+    logStack?: boolean,
+  ) {
+    srcLogger.error(
+      EcoLogMessage.fromDefault({
+        message: `${caller}: error`,
+        properties: {
+          error: error.message,
+          ...properties,
+        },
+      }),
+
+      logStack && error.stack,
+    )
+  }
+
+  static getErrorMessage(error: any): string {
+    if (_.isString(error)) {
+      return error
+    }
+
+    if (EcoError.isEcoError(error)) {
+      return error.toString()
+    }
+
+    return (
+      error.body ||
+      error.error?.reason ||
+      error.reason ||
+      error.message ||
+      error.enumKey ||
+      'Unexpected error occurred'
+    )
+  }
+}

package/src/common/events/constants.ts

@@ -0,0 +1,3 @@
+export const EVENTS = {
+  SOURCE_INTENT_CREATED: 'source_intent.created',
+}

package/src/common/events/viem.ts

@@ -0,0 +1,22 @@
+import { Log } from 'viem'
+
+/**
+ * {
+  blockNumber: 14672041,
+  blockHash: '0x8bc8fd6c46154a8b58b14ebfeb0a11e912eeb590b12a21d56a003269f8ed07f4',
+  transactionIndex: 1,
+  removed: false,
+  address: '0x6B79cD3fE2Eccd3a69c52e621a81d26E75983787',
+  data: '0x00000000000000000000000013e12300ad48e11df1b2d7b0f4d276e138cc566d00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000020059e4a58f9021a6f643125c738ee2b329b2233465b89bb3bcb4f22e3774c562310000000000000000000000000000000000000000000000000000000000000001000000000000000000000000ab1d243b07e99c91de9e4b80dfc2b07a8332a2f7000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000044a9059cbb000000000000000000000000cd80b973e7cbb93c21cc5ac0a5f45d12a32582aa00000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000d2d1162c689179e8ba7a3b936f80a010a0b5cf000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000004d2',
+  topics: [
+    '0x4d57d71884135619aa0097f5e665cc0257fcf37b35433f4b554f57a182e77416',
+    '0x341c195547c8becccdcb8390a2fd8bc416316224d7d4e1938137d45829407044',
+    '0x0000000000000000000000000000000000000000000000000000000000014a34',
+    '0x000000000000000000000000000000000000000000000000000000006696ab0a'
+  ],
+  transactionHash: '0xea380e5bc9ee1c4e196ac7548881fefaf9e5cc033aca8cdac9764cebd0b2d743',
+  logIndex: 2
+}
+ */
+
+export type ViemEventLog = Log & { sourceNetwork: string; sourceChainID: bigint }

package/src/common/logging/eco-log-message.ts

@@ -0,0 +1,74 @@
+import { EcoError } from '../errors/eco-error'
+
+interface BaseLoggingDataParams {
+  message: string
+  properties?: object
+}
+
+interface LoggingDataParamsWithUser extends BaseLoggingDataParams {
+  userID: string
+}
+
+interface LoggingDataParamsWithError extends BaseLoggingDataParams {
+  error: EcoError
+}
+
+interface LoggingDataParamsWithErrorAndUser extends LoggingDataParamsWithError {
+  userID: string
+}
+
+export class EcoLogMessage {
+  private readonly _content: object
+
+  private constructor(params: BaseLoggingDataParams) {
+    this._content = {
+      msg: params.message,
+      ...params.properties,
+    }
+  }
+
+  get content(): object {
+    return this._content
+  }
+
+  static fromDefault(params: BaseLoggingDataParams): object {
+    return new EcoLogMessage(params).content
+  }
+
+  static withUser(params: LoggingDataParamsWithUser): object {
+    const { message, userID, properties } = params
+
+    return this.fromDefault({
+      message,
+      properties: {
+        userID,
+        ...properties,
+      },
+    })
+  }
+
+  static withError(params: LoggingDataParamsWithError): object {
+    const { message, error, properties } = params
+
+    return this.fromDefault({
+      message,
+      properties: {
+        error: error.toString(),
+        ...properties,
+      },
+    })
+  }
+
+  static withErrorAndUser(params: LoggingDataParamsWithErrorAndUser): object {
+    const { message, userID, error, properties } = params
+
+    return this.fromDefault({
+      message,
+      properties: {
+        userID,
+        error: error.toString(),
+        ...properties,
+      },
+    })
+  }
+}

package/src/common/redis/constants.ts

@@ -0,0 +1,55 @@
+export const QUEUES: Record<any, QueueInterface> = {
+  SOURCE_INTENT: {
+    queue: 'source_intent',
+    prefix: '{source-intent}',
+    jobs: {
+      create_intent: 'create_intent',
+      validate_intent: 'validate_intent',
+      feasable_intent: 'feasable_intent',
+      fulfill_intent: 'fulfill_intent',
+      retry_intent: 'retry_intent',
+    },
+  },
+  INTERVAL: {
+    queue: 'interval',
+    prefix: '{interval}',
+    jobs: {
+      retry_infeasable_intents: 'retry_infeasable_intents',
+    },
+  },
+  INBOX: {
+    queue: 'inbox',
+    prefix: '{inbox}',
+    jobs: {
+      fulfillment: 'fulfillment',
+    },
+  },
+  ETH_SOCKET: {
+    queue: 'eth_socket',
+    prefix: '{eth_socket}',
+    jobs: {
+      erc20_balance_socket: 'erc20_balance_socket',
+    },
+  },
+  SIGNER: {
+    queue: 'signer',
+    prefix: '{signer}',
+    jobs: {
+      nonce_sync: 'nonce_sync',
+    },
+  },
+  SOLVER: {
+    queue: 'solver',
+    prefix: '{solver}',
+    jobs: {},
+  },
+}
+
+export interface QueueMetadata {
+  queue: string
+  prefix: string
+}
+
+export interface QueueInterface extends QueueMetadata {
+  jobs: Record<string, string>
+}

package/src/common/redis/redis-connection-utils.ts

@@ -0,0 +1,106 @@
+import { Logger } from '@nestjs/common'
+import { RegisterQueueOptions } from '@nestjs/bullmq'
+import * as Redis from 'ioredis'
+import { EcoError } from '../errors/eco-error'
+import { EcoLogMessage } from '../logging/eco-log-message'
+import { QueueMetadata } from './constants'
+import { RedisConfig } from '../../eco-configs/eco-config.types'
+import { RedlockRedisClient } from '../../nest-redlock/nest-redlock.service'
+
+export class RedisConnectionUtils {
+  private static logger = new Logger(RedisConnectionUtils.name)
+
+  static getRedisConnection(redisConfig: RedisConfig): Redis.Redis | Redis.Cluster {
+    const connection = redisConfig.connection
+
+    if (this.isClusterConnection(connection)) {
+      return new Redis.Cluster(
+        connection as Redis.ClusterNode[],
+        RedisConnectionUtils.getClusterOptions(redisConfig),
+      )
+    }
+
+    return new Redis.Redis(connection as Redis.RedisOptions)
+  }
+
+  static getQueueOptions(queue: QueueMetadata, redisConfig: RedisConfig): RegisterQueueOptions {
+    try {
+      const connection = redisConfig.connection
+      const { queue: name, prefix } = queue
+
+      if (this.isClusterConnection(connection)) {
+        return this.getQueueOptionsForCluster(
+          name,
+          prefix,
+          connection as Redis.ClusterNode[],
+          redisConfig,
+        )
+      }
+
+      return {
+        name,
+        prefix,
+        connection,
+      } as RegisterQueueOptions
+    } catch (ex) {
+      EcoError.logErrorWithStack(
+        ex.message,
+        `getQueueOptions: Invalid queue configuration`,
+        this.logger,
+        {
+          queue,
+        },
+      )
+
+      throw ex
+    }
+  }
+
+  static getClientsForRedlock(redisConfig: RedisConfig): RedlockRedisClient[] {
+    const connection = redisConfig.connection
+    if (this.isClusterConnection(connection)) {
+      return [
+        new Redis.Cluster(
+          connection as Redis.ClusterNode[],
+          RedisConnectionUtils.getClusterOptions(redisConfig),
+        ),
+      ]
+    }
+
+    return [new Redis.Redis(connection as Redis.RedisOptions)]
+  }
+
+  private static isClusterConnection(connection: Redis.ClusterNode | Redis.ClusterNode[]): boolean {
+    return Array.isArray(connection)
+  }
+
+  private static getQueueOptionsForCluster(
+    name: string,
+    prefix: string,
+    connection: Redis.ClusterNode[],
+    redisConfig: RedisConfig,
+  ): RegisterQueueOptions {
+    // Setup a cluster.
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `getQueueOptionsForCluster: Setting up a redis cluster`,
+      }),
+    )
+
+    return {
+      name,
+      prefix,
+      connection: new Redis.Cluster(
+        connection,
+        RedisConnectionUtils.getClusterOptions(redisConfig),
+      ),
+    } as RegisterQueueOptions
+  }
+
+  private static getClusterOptions(redisConfig: RedisConfig): Redis.ClusterOptions {
+    return {
+      ...redisConfig.options.cluster,
+      redisOptions: redisConfig.options.single,
+    }
+  }
+}

package/src/common/routes/constants.ts

@@ -0,0 +1,3 @@
+export const API_ROOT = '/api/v1'
+export const BALANCE_ROUTE = '/balance'
+export const QUOTE_ROUTE = '/quote'

package/src/common/utils/objects.ts

@@ -0,0 +1,34 @@
+import { Hex, keccak256, toBytes } from 'viem'
+
+/**
+ * Deterministically serializes an object into a JSON string
+ */
+export function serializeObject(obj: object): string {
+  return JSON.stringify(obj, Object.keys(obj).sort())
+}
+
+/**
+ * Hashes an object using keccak256
+ */
+export function hashObject(obj: object): Hex {
+  const json = serializeObject(obj)
+  const hash = keccak256(toBytes(json))
+  return hash
+}
+
+/**
+ * Lowercase all top-level keys of the given `object` to lowercase.
+ *
+ * @returns {Object}
+ */
+export function lowercaseKeys(obj: Record<string, any>): Record<string, any> | undefined {
+  if (!obj) {
+    return undefined
+  }
+
+  return Object.entries(obj).reduce((carry, [key, value]) => {
+    carry[key.toLowerCase()] = value
+
+    return carry
+  }, {})
+}