eco-solver 0.0.1-security → 1.5.0

package/src/common/utils/strings.ts

@@ -0,0 +1,49 @@
+import { Hex } from 'viem'
+
+export function getRandomString() {
+  return Math.random().toString(36).slice(2)
+}
+
+export function getDestinationNetworkAddressKey(
+  chainID: number | bigint,
+  tokenAddress: string,
+): string {
+  return `${chainID}-${tokenAddress}`
+}
+
+/**
+ * Appends the service name to the intent hash for the job id, else it will be the same for all intents
+ * as they progress down the processing pipe and interfere in the queue
+ *
+ * @param intentHash the hash of the intent to fulfill
+ * @param logIndex the transaction index of the intent to fulfill. Necessary if multiple intents are in the same transaction
+ * @returns
+ */
+export function getIntentJobId(
+  serviceName: string,
+  intentHash: Hex | undefined,
+  logIndex: number = 0,
+): string {
+  return `${serviceName}-${intentHash}-${logIndex}`
+}
+
+/**
+ * Obscures the center of a string, leaving a number of characters visible at the start and end
+ * @param str the string to obscure
+ * @param visibleChars number of characters at the start and end of the string to leave visible
+ * @returns
+ */
+export function obscureCenter(str: string, visibleChars: number = 2): string {
+  if (visibleChars <= 0) {
+    return str
+  }
+  if (str.length <= visibleChars * 2) {
+    return '*'.repeat(str.length) // If string is too short, obscure all characters
+  }
+
+  const start = str.slice(0, visibleChars)
+  const end = str.slice(-visibleChars)
+  const middle = '*'.repeat(str.length - visibleChars * 2)
+
+  return `${start}${middle}${end}`
+}

package/src/common/utils/tests/objects.spec.ts

@@ -0,0 +1,23 @@
+import { hashObject, serializeObject } from '@/common/utils/objects'
+import { keccak256, toBytes } from 'viem'
+
+describe('serializeObject', () => {
+  it('should serialize an object with sorted keys', () => {
+    const obj = { b: 2, a: 1 }
+    const expected = '{"a":1,"b":2}'
+    expect(serializeObject(obj)).toBe(expected)
+  })
+
+  it('should handle an empty object', () => {
+    expect(serializeObject({})).toBe('{}')
+  })
+})
+
+describe('hashObject', () => {
+  it('should return a keccak256 hash of the serialized object', () => {
+    const obj = { foo: 'bar', num: 42 }
+    const json = serializeObject(obj)
+    const expectedHash = keccak256(toBytes(json))
+    expect(hashObject(obj)).toBe(expectedHash)
+  })
+})

package/src/common/utils/tests/strings.spec.ts

@@ -0,0 +1,22 @@
+import { obscureCenter } from '@/common/utils/strings'
+
+describe('obscureCenter', () => {
+  it('should obscure the center of a string with default visible characters', () => {
+    expect(obscureCenter('hello world')).toBe('he*******ld')
+  })
+
+  it('should obscure the center with a custom number of visible characters', () => {
+    expect(obscureCenter('typescript', 3)).toBe('typ****ipt')
+  })
+
+  it('should return a string of asterisks if the input length is less than or equal to twice the visibleChars', () => {
+    expect(obscureCenter('test', 2)).toBe('****')
+    expect(obscureCenter('hi', 1)).toBe('**')
+    expect(obscureCenter('abcdef', 3)).toBe('******')
+  })
+
+  it('should return the same string if the visible chars is negative or 0', () => {
+    expect(obscureCenter('abcdef', -1)).toBe('abcdef')
+    expect(obscureCenter('abcdef', 0)).toBe('abcdef')
+  })
+})

package/src/common/viem/contracts.ts

@@ -0,0 +1,25 @@
+import {
+  Abi,
+  ContractFunctionName,
+  Hex,
+  prepareEncodeFunctionData,
+  PrepareEncodeFunctionDataParameters,
+  slice as vslice,
+} from 'viem'
+
+/**
+ * Gets the hex selector of the function.
+ * @param parameters the parameters to encode, abi and functionName
+ * @returns the hex selector of the function
+ */
+export function getSelector<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi>,
+>(parameters: PrepareEncodeFunctionDataParameters<abi, functionName>): Hex {
+  return prepareEncodeFunctionData(parameters).functionName
+}
+
+// Get the first 4 bytes of the data that is the hash of the function signature
+export function getFunctionBytes(data: Hex): Hex {
+  return vslice(data, 0, 4)
+}

package/src/common/viem/tests/utils.spec.ts

@@ -0,0 +1,115 @@
+import { getRpcUrl, addressKeys, convertBigIntsToStrings } from '../utils'
+import { Chain, InvalidAddressError } from 'viem'
+
+describe('Viem Utils', () => {
+  describe('getRpcUrl', () => {
+    let mockChain: Chain
+
+    beforeEach(() => {
+      mockChain = {
+        rpcUrls: {
+          default: { http: ['https://default-url'], webSocket: ['wss://default-url'] },
+          secondary: { http: ['https://secondary-url'], webSocket: ['wss://secondary-url'] },
+        },
+      } as any
+    })
+
+    describe('when the chain has no secondary RPC URL', () => {
+      beforeEach(() => {
+        delete mockChain.rpcUrls.secondary
+      })
+
+      it('should return the default HTTP URL when websocket is disabled', () => {
+        const result = getRpcUrl(mockChain, undefined, false)
+        expect(result).toEqual({ url: mockChain.rpcUrls.default.http[0], isWebsocket: false })
+      })
+
+      it('should return the default WebSocket URL when websocket is enabled', () => {
+        const result = getRpcUrl(mockChain, undefined, true)
+        expect(result).toEqual({ url: mockChain.rpcUrls.default.webSocket![0], isWebsocket: true })
+      })
+    })
+
+    describe('when the chain has a secondary RPC URL', () => {
+      it('should return the secondary HTTP URL when websocket is disabled', () => {
+        const result = getRpcUrl(mockChain, undefined, false)
+        expect(result).toEqual({ url: mockChain.rpcUrls.secondary.http[0], isWebsocket: false })
+      })
+
+      it('should return the secondary WebSocket URL when websocket is enabled', () => {
+        const result = getRpcUrl(mockChain, undefined, true)
+        expect(result).toEqual({
+          url: mockChain.rpcUrls.secondary.webSocket![0],
+          isWebsocket: true,
+        })
+      })
+
+      it('should return the secondary HTTP URL when websocket is enabled but doesn`t exist', () => {
+        delete mockChain.rpcUrls.secondary.webSocket
+        const result = getRpcUrl(mockChain, undefined, true)
+        expect(result).toEqual({ url: mockChain.rpcUrls.secondary.http[0], isWebsocket: false })
+      })
+
+      it('should append the API key to the URL if provided', () => {
+        const apiKey = 'api-key'
+        const result = getRpcUrl(mockChain, apiKey, false)
+        expect(result).toEqual({
+          url: mockChain.rpcUrls.secondary.http[0] + `/${apiKey}`,
+          isWebsocket: false,
+        })
+      })
+    })
+  })
+
+  describe('addressKeys', () => {
+    const add = '0x6d9EedE368621F173E5c93384CFcCbfeE19f9609'
+    const unchecksumedAdd = '0x6d9eede368621f173e5c93384cfccbfee19f9609'
+    it('should return empty if the input is empty', () => {
+      const result = addressKeys({})
+      expect(result).toStrictEqual({})
+    })
+
+    it('should throw if a key isn`t a valid eth address', () => {
+      const invalidAddress = '0x123'
+      expect(() => addressKeys({ [add]: 11, [invalidAddress]: 22 })).toThrow(
+        new InvalidAddressError({ address: invalidAddress }),
+      )
+    })
+
+    it('should checksum all address keys in the top level of the object', () => {
+      const input = { [unchecksumedAdd]: 123 }
+      const result = addressKeys(input)
+      expect(result).toEqual({ [add]: 123 })
+    })
+  })
+
+  describe('convertBigIntsToStrings', () => {
+    it('should return null if the input is null', () => {
+      const result = convertBigIntsToStrings(null)
+      expect(result).toBeNull()
+    })
+
+    it('should return undefined if the input is undefined', () => {
+      const result = convertBigIntsToStrings(undefined)
+      expect(result).toBeUndefined()
+    })
+
+    it('should convert BigInt values to strings', () => {
+      const input = { a: BigInt(123), b: 456n }
+      const result = convertBigIntsToStrings(input)
+      expect(result).toEqual({ a: '123', b: '456' })
+    })
+
+    it('should handle nested objects with BigInt values', () => {
+      const input = { a: { b: BigInt(123) } }
+      const result = convertBigIntsToStrings(input)
+      expect(result).toEqual({ a: { b: '123' } })
+    })
+
+    it('should handle arrays with BigInt values', () => {
+      const input = [BigInt(123), 456n]
+      const result = convertBigIntsToStrings(input)
+      expect(result).toEqual(['123', '456'])
+    })
+  })
+})

package/src/common/viem/utils.ts

@@ -0,0 +1,78 @@
+import { Chain, getAddress, Hex } from 'viem'
+
+/**
+ * Gets the url for a chain with the given api key, either websocket or http. It tries
+ * to find a non default rpc url if it exists and returns the first one it finds,
+ * otherwise it returns the default one.
+ *
+ * @param chain the chain to get the url for
+ * @param apiKey the api key if it is required
+ * @param websocketEnabled whether to try the websocket url if there is one
+ * @returns
+ */
+export function getRpcUrl(
+  chain: Chain,
+  apiKey?: string,
+  websocketEnabled: boolean = false,
+): { url: string; isWebsocket: boolean } {
+  let rpcUrl = chain.rpcUrls.default
+  for (const key in chain.rpcUrls) {
+    if (key === 'default') {
+      continue
+    }
+    rpcUrl = chain.rpcUrls[key]
+    break
+  }
+  const isWebsocket =
+    websocketEnabled && rpcUrl.webSocket != undefined && rpcUrl.webSocket.length > 0
+  const url = isWebsocket ? rpcUrl.webSocket![0] : rpcUrl.http[0]
+
+  return {
+    url: apiKey ? url + '/' + apiKey : url,
+    isWebsocket,
+  }
+}
+
+/**
+ * Lowercase all top-level keys of the given `object` to lowercase.
+ *
+ * @returns {Object}
+ */
+export function addressKeys(obj: Record<Hex, any>): Record<Hex, any> {
+  return Object.entries(obj).reduce((carry, [key, value]) => {
+    carry[getAddress(key)] = value
+    return carry
+  }, {})
+}
+
+/**
+ * Recursively converts all BigInt values in an object to strings.
+ *
+ * @param {Object} obj - The object to process.
+ * @returns {Object} - The new object with BigInt values as strings.
+ */
+export function convertBigIntsToStrings(obj: any): any {
+  if (obj === null || obj === undefined) {
+    return obj
+  }
+
+  if (typeof obj === 'bigint') {
+    return obj.toString()
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(convertBigIntsToStrings)
+  }
+
+  if (typeof obj === 'object') {
+    return Object.entries(obj).reduce(
+      (carry, [key, value]) => {
+        carry[key] = convertBigIntsToStrings(value)
+        return carry
+      },
+      {} as Record<string, any>,
+    )
+  }
+
+  return obj
+}

package/src/contracts/ERC20.contract.ts

@@ -0,0 +1,389 @@
+import { ContractFunctionName, decodeEventLog, Hex } from 'viem'
+import { getSelector } from '../common/viem/contracts'
+import { TargetContractType } from '../eco-configs/eco-config.types'
+import { EcoError } from '../common/errors/eco-error'
+import { TransactionTargetData } from '@/intent/utils-intent.service'
+
+// Need to define the ABI as a const array to use in the type definition
+export const ERC20Abi = [
+  {
+    inputs: [
+      {
+        internalType: 'string',
+        name: 'name_',
+        type: 'string',
+      },
+      {
+        internalType: 'string',
+        name: 'symbol_',
+        type: 'string',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'constructor',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'allowance',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'needed',
+        type: 'uint256',
+      },
+    ],
+    name: 'ERC20InsufficientAllowance',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'sender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'balance',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'needed',
+        type: 'uint256',
+      },
+    ],
+    name: 'ERC20InsufficientBalance',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'approver',
+        type: 'address',
+      },
+    ],
+    name: 'ERC20InvalidApprover',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'receiver',
+        type: 'address',
+      },
+    ],
+    name: 'ERC20InvalidReceiver',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'sender',
+        type: 'address',
+      },
+    ],
+    name: 'ERC20InvalidSender',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+    ],
+    name: 'ERC20InvalidSpender',
+    type: 'error',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'Approval',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'from',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'Transfer',
+    type: 'event',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+    ],
+    name: 'allowance',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'approve',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'account',
+        type: 'address',
+      },
+    ],
+    name: 'balanceOf',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'decimals',
+    outputs: [
+      {
+        internalType: 'uint8',
+        name: '',
+        type: 'uint8',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'name',
+    outputs: [
+      {
+        internalType: 'string',
+        name: '',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'symbol',
+    outputs: [
+      {
+        internalType: 'string',
+        name: '',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'totalSupply',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'transfer',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'from',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'to',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'transferFrom',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: '',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const
+
+// The ERC20 contract function selectors
+export function getERC20Selector<functionName extends ContractFunctionName<typeof ERC20Abi>>(
+  functionName: functionName,
+) {
+  return getSelector({ abi: ERC20Abi, functionName })
+}
+
+export function decodeTransferLog(data: Hex, topics: [signature: Hex, ...args: Hex[]] | []) {
+  return decodeEventLog({
+    abi: ERC20Abi,
+    eventName: 'Transfer',
+    topics,
+    data,
+  })
+}
+
+export function isSupportedTokenType(targetType: TargetContractType): boolean {
+  switch (targetType) {
+    case 'erc20':
+      return true
+    case 'erc721':
+    case 'erc1155':
+    default:
+      throw EcoError.IntentSourceUnsupportedTargetType(targetType)
+  }
+}
+
+/**
+ * Verifies that a target is of type erc20 and that the selector is supported
+ * @param ttd the transaction target data
+ * @param permittedSelector the selector to check against, if not provided it will check against all erc20 selectors
+ * @returns
+ */
+export function isERC20Target(ttd: TransactionTargetData | null, permittedSelector?: Hex): boolean {
+  if (!ttd) {
+    return false
+  }
+  const isERC20 = ttd.targetConfig.contractType === 'erc20'
+  if (permittedSelector && ttd.selector !== permittedSelector) {
+    return false
+  }
+  switch (ttd.selector) {
+    case getERC20Selector('transfer'):
+      const correctArgs =
+        !!ttd.decodedFunctionData.args && ttd.decodedFunctionData.args.length === 2
+      return isERC20 && correctArgs
+    default:
+      return false
+  }
+}