@exodus/ethereum-api 2.16.0 → 2.17.0

package/package/src/tx-log/__tests__/ethereum-monitor.integration.test.js

@@ -0,0 +1,163 @@
+import { EthereumMonitor } from '../ethereum-monitor'
+import { size, omit } from 'lodash'
+import { AccountState } from '@exodus/models'
+import { once } from 'events'
+import { ethereum as feeData } from '@exodus/ethereum-lib/src/fee-data'
+import assetMap from './assets-for-test-helper'
+import { expectSameValue, toBalanceFromTx } from './monitor-test-helper'
+import { create } from '../../exodus-eth-server/api'
+import {
+  PublicKeyAddressResolver,
+  logger,
+  InMemoryAssetClientInterface,
+} from '@exodus/assets-testing'
+
+const EXODUS_ETH_SERVER_URL = 'https://geth.a.exodus.io/wallet/v1/'
+
+jest.setTimeout(20000)
+
+const { ethereum } = assetMap
+
+// Replacing default gasPrice to be sure WS will change it
+const dummyGasPrice = ethereum.currency.Gwei(1) // 1 is the min fee...
+const feeDataMock = feeData.update({ gasPrice: dummyGasPrice.toString() })
+expect(feeDataMock.gasPrice).toEqual(dummyGasPrice)
+
+export default class EthereumAccountState extends AccountState {
+  static defaults = {
+    cursor: '',
+    balance: ethereum.currency.ZERO,
+    tokenBalances: {},
+  }
+}
+
+ethereum.api = {
+  createAccountState: () => EthereumAccountState,
+  getConfirmationsNumber: () => 2,
+  getFeeData: () => feeDataMock,
+}
+
+// Fernando's dev wallet. Profile 1 and Profile 2
+const walletPublicKeys = {
+  ethereum: [
+    Buffer.from('0273c38a3c31c31b361dc8d6b93e56c316e34991c478d3a14ea3fcd1ab552bc25e', 'hex'),
+    Buffer.from('02f33b1edf1016f6720518c776da30567fc7b7052ae6b596dd22909e0a87164f8d', 'hex'),
+  ],
+}
+
+describe('ethereum monitor', () => {
+  test('can start monitor and update txs', async () => {
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PublicKeyAddressResolver({ walletPublicKeys }),
+    })
+    const server = create(EXODUS_ETH_SERVER_URL)
+    const getHistoryV2 = jest.fn(async (...args) => {
+      const transactions = await server.getHistoryV2(...args)
+      return transactions.filter((tx) => {
+        return parseInt(tx.blockNumber, 16) < 14808250
+      })
+    })
+    const monitor = new EthereumMonitor({
+      interval: 10000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: { ...server, getHistoryV2 },
+    })
+    try {
+      await monitor.start()
+      expect(logger.error).not.toBeCalled()
+      expect(logger.warn).not.toBeCalled()
+
+      // Sintax sugar
+      const getTxLog = (walletAccount, assetName) => {
+        return assetClientInterface.getTxLog({ walletAccount, assetName })
+      }
+      const getState = (walletAccount, assetName) => {
+        return assetClientInterface.getAccountState({ walletAccount, assetName })
+      }
+
+      expect((await getTxLog('exodus0', 'ethereum')).size).toEqual(7)
+      expect((await getTxLog('exodus0', 'bat')).size).toEqual(1)
+      expect((await getTxLog('exodus0', 'tetherusd')).size).toEqual(3)
+      expect((await getTxLog('exodus1', 'ethereum')).size).toEqual(1)
+
+      expectSameValue(
+        toBalanceFromTx(await getTxLog('exodus0', 'ethereum')),
+        ethereum.currency.defaultUnit('0.051201488965893697') // string due to floating error
+      )
+      expectSameValue(
+        toBalanceFromTx(await getTxLog('exodus0', 'bat')),
+        assetMap.bat.currency.defaultUnit(8.42277112)
+      )
+      expectSameValue(
+        toBalanceFromTx(await getTxLog('exodus0', 'tetherusd')),
+        assetMap.tetherusd.currency.defaultUnit(7.414404)
+      )
+      expectSameValue(
+        toBalanceFromTx(await getTxLog('exodus1', 'ethereum')),
+        ethereum.currency.defaultUnit(0.00821921)
+      )
+
+      // It seems eth balances and tokenBalances are not being filled. Clients needs to read tx like above
+      const accountState0 = await getState('exodus0', 'ethereum')
+      expectSameValue(accountState0.balance, ethereum.currency.defaultUnit(0))
+      expect(accountState0.tokenBalances.steth).toBeDefined()
+      const accountState1 = await getState('exodus1', 'ethereum')
+      expectSameValue(accountState1.balance, ethereum.currency.defaultUnit(0))
+      expect(accountState1.tokenBalances.steth).toBeDefined()
+      expect(size(assetClientInterface.states)).toEqual(2)
+    } finally {
+      await monitor.stop()
+    }
+    expect(logger.error).not.toBeCalled()
+    expect(logger.warn).not.toBeCalled()
+    expect(monitor.timer.isRunning).toEqual(false)
+  })
+
+  test('can start and update gas price', async () => {
+    // ws is not reliable enough to finish on time.
+    const server = create(EXODUS_ETH_SERVER_URL)
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PublicKeyAddressResolver({ walletPublicKeys }),
+    })
+    const monitor = new EthereumMonitor({
+      interval: 10000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server,
+    })
+    try {
+      expect(await assetClientInterface.getFeeData({ assetName: ethereum.name })).toEqual(
+        feeDataMock
+      )
+
+      const oncePromise = once(assetClientInterface, 'fee-config-updated')
+      await monitor.start()
+      await oncePromise
+      // Once started, feeData gets updated
+      expect(await assetClientInterface.getFeeData({ assetName: ethereum.name })).not.toEqual(
+        feeDataMock
+      )
+      // gas price and origin are the changed ones.
+      expect(
+        omit(
+          await assetClientInterface.getFeeData({ assetName: ethereum.name }),
+          'gasPrice',
+          'origin'
+        )
+      ).toEqual(omit(feeDataMock, 'gasPrice', 'origin'))
+    } finally {
+      await monitor.stop()
+    }
+
+    expect(logger.error).not.toBeCalled()
+    expect(logger.warn).not.toBeCalled()
+    expect(monitor.timer.isRunning).toEqual(false)
+  })
+})

package/package/src/tx-log/__tests__/ethereum-monitor.test.js

@@ -0,0 +1,211 @@
+import { EthereumMonitor } from '../ethereum-monitor'
+import { encodePublic } from '@exodus/ethereum-lib'
+import { toBalanceFromTx, expectSameValue, mockServer } from './monitor-test-helper'
+import assetMap from './assets-for-test-helper'
+import { AccountState } from '@exodus/models'
+import { ethereum as feeData } from '@exodus/ethereum-lib/src/fee-data'
+import historyReturnValuesForTest from './ethereum-history-return-values-for-test-helper'
+import historyReturnValuesUnknownToken from './ethereum-history-unknown-token-helper'
+import { size, cloneDeep } from 'lodash'
+import {
+  PublicKeyAddressResolver,
+  logger,
+  InMemoryAssetClientInterface,
+} from '@exodus/assets-testing'
+
+const { ethereum } = assetMap
+
+export default class EthereumAccountState extends AccountState {
+  static defaults = {
+    cursor: '',
+    balance: ethereum.currency.ZERO,
+    tokenBalances: {},
+  }
+}
+
+ethereum.api = {
+  createAccountState: () => EthereumAccountState,
+  getConfirmationsNumber: () => 2,
+  getFeeData: () => feeData,
+}
+// Fernando's dev wallet. Profile 1 and Profile 2
+const walletPublicKeys = {
+  ethereum: [
+    Buffer.from('0273c38a3c31c31b361dc8d6b93e56c316e34991c478d3a14ea3fcd1ab552bc25e', 'hex'),
+    Buffer.from('02f33b1edf1016f6720518c776da30567fc7b7052ae6b596dd22909e0a87164f8d', 'hex'),
+  ],
+}
+
+describe('ethereum monitor', () => {
+  test('ethereum can create monitor', () => {
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PublicKeyAddressResolver({ walletPublicKeys }),
+    })
+    const server = mockServer({})
+    const monitor = new EthereumMonitor({
+      interval: 10000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: server,
+    })
+    expect(monitor.server.getURL()).toEqual('https://mockMe')
+
+    expect(logger.warn).not.toBeCalled()
+    expect(logger.error).not.toBeCalled()
+  })
+
+  test('can start and stop monitor using simulated data', async () => {
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PublicKeyAddressResolver({ walletPublicKeys }),
+    })
+
+    const getHistoryV2Returns = cloneDeep(historyReturnValuesForTest)
+    const server = mockServer({ getHistoryV2Returns })
+
+    const monitor = new EthereumMonitor({
+      interval: 10000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: server,
+    })
+    await monitor.start()
+    await monitor.stop()
+    expect(logger.warn).not.toBeCalled()
+    expect(logger.error).not.toBeCalled()
+
+    // Sintax sugar
+    const getTxLog = (walletAccount, assetName) => {
+      return assetClientInterface.getTxLog({ walletAccount, assetName })
+    }
+    const getState = (walletAccount, assetName) => {
+      return assetClientInterface.getAccountState({ walletAccount, assetName })
+    }
+
+    expect((await getTxLog('exodus0', 'ethereum')).size).toEqual(7)
+    expect((await getTxLog('exodus0', 'bat')).size).toEqual(1)
+    expect((await getTxLog('exodus0', 'tetherusd')).size).toEqual(3)
+    expect((await getTxLog('exodus1', 'ethereum')).size).toEqual(1)
+
+    expectSameValue(
+      toBalanceFromTx(await getTxLog('exodus0', 'ethereum')),
+      ethereum.currency.defaultUnit('0.051201488965893697') // string due to floating error
+    )
+    expectSameValue(
+      toBalanceFromTx(await getTxLog('exodus0', 'bat')),
+      assetMap.bat.currency.defaultUnit(8.42277112)
+    )
+    expectSameValue(
+      toBalanceFromTx(await getTxLog('exodus0', 'tetherusd')),
+      assetMap.tetherusd.currency.defaultUnit(7.414404)
+    )
+    expectSameValue(
+      toBalanceFromTx(await getTxLog('exodus1', 'ethereum')),
+      ethereum.currency.defaultUnit(0.00821921)
+    )
+
+    // It seems eth balances and tokenBalances are not being filled. Clients needs to read tx like above
+    expectSameValue(
+      (await getState('exodus0', 'ethereum')).balance,
+      ethereum.currency.defaultUnit(0)
+    )
+    expect((await getState('exodus0', 'ethereum')).tokenBalances).toEqual({})
+    expectSameValue(
+      (await getState('exodus1', 'ethereum')).balance,
+      ethereum.currency.defaultUnit(0)
+    )
+    expect((await getState('exodus1', 'ethereum')).tokenBalances).toEqual({})
+    expect(size(assetClientInterface.states)).toEqual(2)
+
+    expect(logger.error).not.toBeCalled()
+    expect(logger.warn).not.toBeCalled()
+    expect(monitor.timer.isRunning).toEqual(false)
+  })
+
+  test('emits unknown-tokens events', async () => {
+    const walletPublicKeys = {
+      ethereum: [
+        Buffer.from('03f583b2ccd8cc072baabecf9e124783d8112e0ee76b893e8b341e54d910729fbe', 'hex'),
+        Buffer.from('03ab984a086ae1c31207e642ce7c17b9f0811a1cdc66cbe8f78f940a646462b3a8', 'hex'),
+      ],
+    }
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PublicKeyAddressResolver({ walletPublicKeys }),
+    })
+
+    const getHistoryV2Returns = cloneDeep(historyReturnValuesUnknownToken)
+    const server = mockServer({ getHistoryV2Returns })
+
+    const monitor = new EthereumMonitor({
+      interval: 10000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: server,
+    })
+
+    const handler = jest.fn(() => {})
+    monitor.on('unknown-tokens', handler)
+
+    await monitor.start()
+    await monitor.stop()
+    expect(logger.warn).not.toBeCalled()
+    expect(logger.error).not.toBeCalled()
+
+    const toBalanceFromTx = (txSet) => {
+      return txSet.getMutations().slice(-1)[0].balance
+    }
+
+    // Sintax sugar
+    const getTxLog = (walletAccount, assetName) => {
+      return assetClientInterface.getTxLog({ walletAccount, assetName })
+    }
+    const getState = (walletAccount, assetName) => {
+      return assetClientInterface.getAccountState({ walletAccount, assetName })
+    }
+
+    const expectSameValue = (actual, expected) => {
+      expect(actual).toEqual(expected)
+      expect(actual.equals(expected)).toEqual(true)
+    }
+
+    expect((await getTxLog('exodus0', 'ethereum')).size).toEqual(25)
+
+    expectSameValue(
+      toBalanceFromTx(await getTxLog('exodus0', 'ethereum')),
+      ethereum.currency.defaultUnit('0.040838166275376413') // string due to floating error
+    )
+
+    // It seems eth balances and tokenBalances are not being filled. Clients needs to read tx like above
+    expectSameValue(
+      (await getState('exodus0', 'ethereum')).balance,
+      ethereum.currency.defaultUnit(0)
+    )
+    expect((await getState('exodus0', 'ethereum')).tokenBalances).toEqual({})
+    expect(size(assetClientInterface.states)).toEqual(2)
+
+    expect(logger.error).not.toBeCalled()
+    expect(logger.warn).not.toBeCalled()
+    expect(monitor.timer.isRunning).toEqual(false)
+
+    // unknown token call checks
+    expect(handler.mock.calls.length).toBe(1)
+    expect(handler.mock.calls[0][0]).toEqual(['0xa2cd3d43c775978a96bdbf12d733d5a1ed94fb18'])
+  })
+
+  test('validate address', () => {
+    expect(encodePublic(walletPublicKeys.ethereum[0])).toEqual(
+      '0x90E481d9A664ebbE4Be180d9501962255463036d'
+    )
+    expect(encodePublic(walletPublicKeys.ethereum[1])).toEqual(
+      '0xf6c138C36341138dDFC314a11038dA8264B7Ef09'
+    )
+  })
+})

package/package/src/tx-log/__tests__/monitor-test-helper.js

@@ -0,0 +1,39 @@
+export const toBalanceFromTx = (txSet) => {
+  return txSet.getMutations().slice(-1)[0].balance
+}
+
+export const expectSameValue = (actual, expected) => {
+  expect(actual.toDefault().toString()).toEqual(expected.toDefault().toString())
+  expect(actual.equals(expected)).toEqual(true)
+}
+
+export const mockServer = ({ getHistoryV2Returns = {}, balances = {}, balancesOf = {} }) => {
+  return {
+    getURL() {
+      return 'https://mockMe'
+    },
+    ws: { watch: jest.fn(), events: { on: jest.fn() }, open: jest.fn() },
+
+    getHistoryV2: jest.fn(async (address) => {
+      const history = getHistoryV2Returns[address.toLowerCase()]
+      const txPage = history?.shift()
+      return txPage || []
+    }),
+
+    balanceOf: jest.fn(async (walletAddress, contractAddress) => {
+      // jest doesn't to have when-some-arg-then-some-value kind of mocking
+      // https://github.com/facebook/jest/issues/6180
+      const balance = balancesOf[walletAddress.toLowerCase()]?.[contractAddress.toLowerCase()] || 0
+      return {
+        confirmed: {
+          [contractAddress]: balance,
+        },
+      }
+    }),
+
+    getBalance: jest.fn(async (walletAddress) => {
+      const balance = `${balances[walletAddress.toLowerCase()] || 0}`
+      return { confirmed: { value: balance } }
+    }),
+  }
+}

package/package/src/tx-log/__tests__/steth-monitor.integration.test.js

@@ -0,0 +1,91 @@
+import { EthereumMonitor } from '../ethereum-monitor'
+import { AccountState } from '@exodus/models'
+import { ethereum as feeData } from '@exodus/ethereum-lib/src/fee-data'
+import assetMap from './assets-for-test-helper'
+import { toBalanceFromTx } from './monitor-test-helper'
+import { create } from '../../exodus-eth-server/api'
+import { PlainAddressResolver, logger, InMemoryAssetClientInterface } from '@exodus/assets-testing'
+import { getBalances } from '../../get-balances'
+
+const EXODUS_ETH_SERVER_URL = 'https://geth.a.exodus.io/wallet/v1/'
+
+jest.setTimeout(20000)
+
+const { ethereum } = assetMap
+
+// Replacing default gasPrice to be sure WS will change it
+const dummyGasPrice = ethereum.currency.Gwei(1) // 1 is the min fee...
+const feeDataMock = feeData.update({ gasPrice: dummyGasPrice.toString() })
+expect(feeDataMock.gasPrice).toEqual(dummyGasPrice)
+
+export default class EthereumAccountState extends AccountState {
+  static defaults = {
+    cursor: '',
+    balance: ethereum.currency.ZERO,
+    tokenBalances: {},
+  }
+}
+
+ethereum.api = {
+  createAccountState: () => EthereumAccountState,
+  getConfirmationsNumber: () => 2,
+  getFeeData: () => feeDataMock,
+}
+
+export const walletAddresses = {
+  ethereum: ['0xed0eebb4d520a6b0eccc4df8e5214e7a6697c111'],
+}
+
+describe('steth ethereum monitor', () => {
+  test('can start monitor and validate steth offchain rewards', async () => {
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PlainAddressResolver({ walletAddresses }),
+    })
+    const server = create(EXODUS_ETH_SERVER_URL)
+
+    const monitor = new EthereumMonitor({
+      interval: 100000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server,
+    })
+    try {
+      await monitor.start()
+
+      expect(logger.error).not.toBeCalled()
+      expect(logger.warn).not.toBeCalled()
+      // Sintax sugar
+      const getTxLog = (walletAccount, assetName) => {
+        return assetClientInterface.getTxLog({ walletAccount, assetName })
+      }
+      const accountState = await assetClientInterface.getAccountState({
+        walletAccount: 'exodus0',
+        assetName: 'ethereum',
+      })
+      const { balance: stEthBalance } = getBalances({
+        asset: assetMap.steth,
+        txLog: await getTxLog('exodus0', 'steth'),
+        accountState,
+      })
+      const { balance: ethereumBalance } = getBalances({
+        asset: assetMap.ethereum,
+        txLog: await getTxLog('exodus0', 'ethereum'),
+        accountState,
+      })
+
+      const stEthBalanceFromTx = toBalanceFromTx(await getTxLog('exodus0', 'steth'))
+
+      expect(ethereumBalance.gt(assetMap.ethereum.currency.ZERO)).toEqual(true)
+      expect(stEthBalanceFromTx.lt(stEthBalance)).toEqual(true)
+    } finally {
+      await monitor.stop()
+    }
+
+    expect(logger.error).not.toBeCalled()
+    expect(logger.warn).not.toBeCalled()
+    expect(monitor.timer.isRunning).toEqual(false)
+  })
+})

package/package/src/tx-log/__tests__/uniswap-monitor.integration.test.js

@@ -0,0 +1,86 @@
+import { EthereumMonitor } from '../ethereum-monitor'
+import { AccountState } from '@exodus/models'
+import { ethereum as feeData } from '@exodus/ethereum-lib/src/fee-data'
+import assetMap from './assets-for-test-helper'
+import { expectSameValue, toBalanceFromTx } from './monitor-test-helper'
+import { create } from '../../exodus-eth-server/api'
+import { PlainAddressResolver, logger, InMemoryAssetClientInterface } from '@exodus/assets-testing'
+
+const EXODUS_ETH_SERVER_URL = 'https://geth.a.exodus.io/wallet/v1/'
+
+jest.setTimeout(20000)
+
+const { ethereum } = assetMap
+
+// Replacing default gasPrice to be sure WS will change it
+const dummyGasPrice = ethereum.currency.Gwei(1) // 1 is the min fee...
+const feeDataMock = feeData.update({ gasPrice: dummyGasPrice.toString() })
+expect(feeDataMock.gasPrice).toEqual(dummyGasPrice)
+
+export default class EthereumAccountState extends AccountState {
+  static defaults = {
+    cursor: '',
+    balance: ethereum.currency.ZERO,
+    tokenBalances: {},
+  }
+}
+
+ethereum.api = {
+  createAccountState: () => EthereumAccountState,
+  getConfirmationsNumber: () => 2,
+  getFeeData: () => feeDataMock,
+}
+
+// Taking address from https://etherscan.io/txs?a=0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
+export const walletAddresses = {
+  ethereum: ['0x1f6890cba6150c9f650efd7ee08d7978cfaba0dd'],
+}
+
+describe('uniswap ethereum monitor', () => {
+  test('can start monitor and update txs', async () => {
+    const assetClientInterface = new InMemoryAssetClientInterface({
+      logger,
+      assets: assetMap,
+      addressResolver: new PlainAddressResolver({ walletAddresses }),
+    })
+    const server = create(EXODUS_ETH_SERVER_URL)
+
+    const getHistoryV2 = jest.fn(async (...args) => {
+      const transactions = await server.getHistoryV2(...args)
+      return transactions.filter((tx) => {
+        return parseInt(tx.blockNumber, 16) < 14932172
+      })
+    })
+    server.getHistoryV2 = jest.fn(server.getHistoryV2)
+    const monitor = new EthereumMonitor({
+      interval: 100000,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: { ...server, getHistoryV2 },
+    })
+    try {
+      await monitor.start()
+
+      expect(logger.error).not.toBeCalled()
+      expect(logger.warn).not.toBeCalled()
+      // Sintax sugar
+      const getTxLog = (walletAccount, assetName) => {
+        return assetClientInterface.getTxLog({ walletAccount, assetName })
+      }
+      const allTxs = await getTxLog('exodus0', 'ethereum')
+      expect(allTxs.size).toEqual(47)
+
+      expectSameValue(
+        toBalanceFromTx(await getTxLog('exodus0', 'ethereum')),
+        ethereum.currency.defaultUnit('0.082018694406864644')
+      ) // string due to floating error
+    } finally {
+      await monitor.stop()
+    }
+
+    expect(logger.error).not.toBeCalled()
+    expect(logger.warn).not.toBeCalled()
+    expect(monitor.timer.isRunning).toEqual(false)
+  })
+})