@exodus/ethereum-api 2.8.2 → 2.8.4

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

@@ -0,0 +1,174 @@
+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 { createAssetClientInterface } from './asset-client-interface-test-helper'
+import { create } from '../../exodus-eth-server/api'
+
+const EXODUS_ETH_SERVER_URL = 'https://geth.a.exodus.io/wallet/v1/'
+
+jest.setTimeout(10000)
+
+export const logger = {
+  trace: jest.fn(),
+  debug: jest.fn(),
+  log: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+}
+
+afterEach(() => {
+  Object.values(logger).forEach((fn) => fn.mockReset())
+})
+
+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
+export const walletPublicKeys = {
+  ethereum: [
+    Buffer.from('0273c38a3c31c31b361dc8d6b93e56c316e34991c478d3a14ea3fcd1ab552bc25e', 'hex'),
+    Buffer.from('02f33b1edf1016f6720518c776da30567fc7b7052ae6b596dd22909e0a87164f8d', 'hex'),
+  ],
+}
+
+describe('ethereum monitor', () => {
+  test('can start monitor and update txs', async () => {
+    const assetClientInterface = createAssetClientInterface({ logger, 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: 20,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: { ...server, getHistoryV2 },
+    })
+    try {
+      await monitor.start()
+      expect(logger.error).not.toBeCalled()
+      expect(logger.warn).not.toBeCalled()
+      const toBalanceFromTx = (txSet) => {
+        return txSet.getMutations().slice(-1)[0].balance
+      }
+      // Sintax sugar
+      const txs = (walletAccount, assetName) => {
+        return assetClientInterface.getTxLog({ walletAccount, assetName })
+      }
+      const state = (walletAccount, assetName) => {
+        return assetClientInterface.getAccountState({ walletAccount, assetName })
+      }
+
+      const expectSameValue = (actual, expected) => {
+        expect(actual).toEqual(expected)
+        expect(actual.equals(expected)).toEqual(true)
+      }
+
+      expect((await txs('exodus0', 'ethereum')).size).toEqual(7)
+      expect((await txs('exodus0', 'bat')).size).toEqual(1)
+      expect((await txs('exodus0', 'tetherusd')).size).toEqual(3)
+      expect((await txs('exodus1', 'ethereum')).size).toEqual(1)
+
+      expectSameValue(
+        toBalanceFromTx(await txs('exodus0', 'ethereum')),
+        ethereum.currency.defaultUnit('0.051201488965893697') // string due to floating error
+      )
+      expectSameValue(
+        toBalanceFromTx(await txs('exodus0', 'bat')),
+        assetMap.bat.currency.defaultUnit(8.42277112)
+      )
+      expectSameValue(
+        toBalanceFromTx(await txs('exodus0', 'tetherusd')),
+        assetMap.tetherusd.currency.defaultUnit(7.414404)
+      )
+      expectSameValue(
+        toBalanceFromTx(await txs('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 state('exodus0', 'ethereum')).balance,
+        ethereum.currency.defaultUnit(0)
+      )
+      expect((await state('exodus0', 'ethereum')).tokenBalances).toEqual({})
+      expectSameValue(
+        (await state('exodus1', 'ethereum')).balance,
+        ethereum.currency.defaultUnit(0)
+      )
+      expect((await state('exodus1', 'ethereum')).tokenBalances).toEqual({})
+      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 = createAssetClientInterface({ logger, walletPublicKeys })
+    const monitor = new EthereumMonitor({
+      interval: 20,
+      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/src/tx-log/__tests__/ethereum-monitor.test.js

@@ -0,0 +1,160 @@
+import { EthereumMonitor } from '../ethereum-monitor'
+import { encodePublic } from '@exodus/ethereum-lib'
+import { createAssetClientInterface } from './asset-client-interface-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 { size, cloneDeep } from 'lodash'
+
+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,
+}
+
+export const logger = {
+  trace: jest.fn(),
+  debug: jest.fn(),
+  log: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn((...args) => console.error(args)),
+}
+
+afterEach(() => {
+  Object.values(logger).forEach((fn) => fn.mockReset())
+})
+
+// Fernando's dev wallet. Profile 1 and Profile 2
+export const walletPublicKeys = {
+  ethereum: [
+    Buffer.from('0273c38a3c31c31b361dc8d6b93e56c316e34991c478d3a14ea3fcd1ab552bc25e', 'hex'),
+    Buffer.from('02f33b1edf1016f6720518c776da30567fc7b7052ae6b596dd22909e0a87164f8d', 'hex'),
+  ],
+}
+
+describe('ethereum monitor', () => {
+  test('can create monitor', () => {
+    const server = {
+      getURL() {
+        return 'https://mockMe'
+      },
+      ws: { watch: jest.fn(), events: { on: jest.fn() } },
+
+      getHistoryV2: jest.fn(() => {
+        return Promise.resolve([])
+      }),
+    }
+    const monitor = new EthereumMonitor({
+      interval: 20,
+      asset: ethereum,
+      assetClientInterface: createAssetClientInterface({ logger }),
+      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 = createAssetClientInterface({ logger, walletPublicKeys })
+
+    const getHistoryV2Returns = cloneDeep(historyReturnValuesForTest)
+    const server = {
+      getURL() {
+        return 'https://mockMe'
+      },
+      ws: { watch: jest.fn(), events: { on: jest.fn() }, open: jest.fn() },
+
+      getHistoryV2: jest.fn((address) => {
+        const history = getHistoryV2Returns[address]
+        const txPage = history?.shift()
+        return Promise.resolve(txPage || [])
+      }),
+    }
+
+    const monitor = new EthereumMonitor({
+      interval: 20,
+      asset: ethereum,
+      assetClientInterface,
+      logger,
+      server: server,
+    })
+    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 txs = (walletAccount, assetName) => {
+      return assetClientInterface.getTxLog({ walletAccount, assetName })
+    }
+    const state = (walletAccount, assetName) => {
+      return assetClientInterface.getAccountState({ walletAccount, assetName })
+    }
+
+    const expectSameValue = (actual, expected) => {
+      expect(actual).toEqual(expected)
+      expect(actual.equals(expected)).toEqual(true)
+    }
+
+    expect((await txs('exodus0', 'ethereum')).size).toEqual(7)
+    expect((await txs('exodus0', 'bat')).size).toEqual(1)
+    expect((await txs('exodus0', 'tetherusd')).size).toEqual(3)
+    expect((await txs('exodus1', 'ethereum')).size).toEqual(1)
+
+    expectSameValue(
+      toBalanceFromTx(await txs('exodus0', 'ethereum')),
+      ethereum.currency.defaultUnit('0.051201488965893697') // string due to floating error
+    )
+    expectSameValue(
+      toBalanceFromTx(await txs('exodus0', 'bat')),
+      assetMap.bat.currency.defaultUnit(8.42277112)
+    )
+    expectSameValue(
+      toBalanceFromTx(await txs('exodus0', 'tetherusd')),
+      assetMap.tetherusd.currency.defaultUnit(7.414404)
+    )
+    expectSameValue(
+      toBalanceFromTx(await txs('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 state('exodus0', 'ethereum')).balance, ethereum.currency.defaultUnit(0))
+    expect((await state('exodus0', 'ethereum')).tokenBalances).toEqual({})
+    expectSameValue((await state('exodus1', 'ethereum')).balance, ethereum.currency.defaultUnit(0))
+    expect((await state('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('validate address', () => {
+    expect(encodePublic(walletPublicKeys.ethereum[0])).toEqual(
+      '0x90E481d9A664ebbE4Be180d9501962255463036d'
+    )
+    expect(encodePublic(walletPublicKeys.ethereum[1])).toEqual(
+      '0xf6c138C36341138dDFC314a11038dA8264B7Ef09'
+    )
+  })
+})

package/src/tx-log/__tests__/in-memory-asset-client-interface.js

@@ -0,0 +1,196 @@
+import { pickBy, isEmpty, partition, isObject, bindAll, functions } from 'lodash'
+import assert from 'minimalistic-assert'
+import { Tx, TxSet } from '@exodus/models'
+import { EventEmitter } from 'events'
+
+const getKey = ({ assetName, walletAccount }) => `${walletAccount}:${assetName}`
+const getAssetOnlyKey = ({ assetName }) => assetName
+
+const createTxSet = ({ txs, coinName, assets }) => {
+  const values = txs.map((tx) => Tx.fromJSON({ ...tx, date: tx.date || new Date(), coinName }))
+  return TxSet.fromArray(values, { assets })
+}
+
+const createBatch = () => {
+  const batch = []
+  const push = (promise) => batch.push(promise)
+  const exec = async () => {
+    // enforce sequential execution
+    for (const promise in batch) {
+      await promise
+    }
+  }
+  return { push, exec }
+}
+
+export class InMemoryAssetClientInterface extends EventEmitter {
+  constructor({ assets, logger, walletAccounts, wallet }) {
+    super()
+    assert(assets, 'assets is required')
+    assert(logger, 'logger is required')
+    assert(walletAccounts, 'walletAccounts is required')
+    assert(wallet, 'wallet is required')
+    assert(isObject(assets), 'assets must be an object indexed by asset name')
+    this.assets = assets
+    this.logger = logger
+    this.wallet = wallet
+    this.feeData = Object.values(assets)
+      .filter((asset) => asset.name === asset.baseAsset.name)
+      .filter((asset) => asset.api?.getFeeData)
+      .reduce((acc, asset) => ({ ...acc, [asset.name]: asset.api.getFeeData() }), {})
+    this.walletAccounts = walletAccounts
+    this.txs = {}
+    this.states = {}
+    bindAll(this, functions(this))
+  }
+
+  async getTxLog({ assetName, walletAccount }) {
+    const key = getKey({ assetName, walletAccount })
+    if (!this.txs[key]) {
+      return TxSet.EMPTY
+    }
+    return this.txs[key]
+  }
+
+  async updateTxLogAndNotify({ assetName, walletAccount, txs }) {
+    const batch = this.updateTxLogAndNotifyBatch({
+      assetName,
+      walletAccount,
+      txs,
+    })
+    return batch.exec()
+  }
+
+  updateTxLogAndNotifyBatch({ assetName, walletAccount, txs, batch = createBatch() }) {
+    batch.push(this.updateTxs({ assetName, walletAccount, txs }))
+    return batch
+  }
+
+  async updateTxs({ assetName, walletAccount, txs }) {
+    const currentTxLog = await this.getTxLog({ assetName, walletAccount })
+    const [existingLogItems, newLogItems] = partition(txs, (v) => currentTxLog.get(v.txId))
+    let newTxSet = currentTxLog
+    if (existingLogItems.length > 0) {
+      newTxSet = newTxSet.updateTxsProperties(existingLogItems)
+    }
+    if (newLogItems.length > 0) {
+      newTxSet = newTxSet.union(
+        createTxSet({ txs: newLogItems, coinName: assetName, assets: this.assets })
+      )
+    }
+    const key = getKey({ assetName, walletAccount })
+    if (newTxSet.size > 0) {
+      this.txs[key] = newTxSet
+    }
+  }
+
+  async getAccountState({ assetName, walletAccount }) {
+    const asset = this.assets[assetName]
+    const key = getKey({ assetName, walletAccount })
+
+    if (!this.states[key]) {
+      const accountState = asset.api?.createAccountState?.()?.create()
+      if (!accountState) {
+        throw new Error(`Asset ${asset.name} does not support account state!`)
+      }
+      this.states[key] = accountState
+    }
+    return this.states[key]
+  }
+
+  async updateAccountState({ assetName, walletAccount, newData }) {
+    this.updateAccountStateBatch({
+      assetName,
+      walletAccount,
+      newData,
+    }).exec()
+  }
+
+  updateAccountStateBatch({ assetName, walletAccount, newData, batch = createBatch() }) {
+    batch.push(
+      this._basicUpdateAccountState({
+        assetName,
+        walletAccount,
+        newData,
+      })
+    )
+    return batch
+  }
+
+  async _basicUpdateAccountState({ assetName, walletAccount, newData }) {
+    if (!isEmpty(newData)) {
+      const key = getKey({ assetName, walletAccount })
+      const currentAccountState = await this.getAccountState({ assetName, walletAccount })
+      const newAccountState = currentAccountState.merge(newData)
+      this.states[key] = newAccountState
+    }
+  }
+
+  async getReceiveAddresses({ assetName, walletAccount, chainIndex, addressIndex }) {
+    return [await this.getReceiveAddress({ assetName, walletAccount, chainIndex, addressIndex })]
+  }
+
+  async getReceiveAddress({ assetName, walletAccount, chainIndex, addressIndex }) {
+    const asset = this.assets[assetName]
+    const baseAsset = asset.baseAsset
+    assert(this.walletAccounts[walletAccount], 'Invalid walletAccount')
+    const accountIndex = this.walletAccounts[walletAccount].index
+    const { publicKey } = await this.wallet.genPublicKey({
+      baseAssetName: baseAsset.name,
+      accountIndex,
+      chainIndex,
+      addressIndex,
+    })
+    return asset.keys.encodePublic(publicKey).toString()
+  }
+
+  async getWalletAccountsByAsset() {
+    const baseAssets = Object.values(this.assets).filter(
+      (asset) => asset.name === asset.baseAsset.name
+    )
+    const walletAccountMap = {}
+    for (const baseAsset of baseAssets) {
+      walletAccountMap[baseAsset.name] = Object.keys(this.walletAccounts)
+    }
+    return walletAccountMap
+  }
+
+  async getWalletAccounts({ assetName }) {
+    const walletAccountMap = await this.getWalletAccountsByAsset()
+    const walletAccounts = walletAccountMap[assetName]
+    assert(walletAccounts, `${assetName} is not supported`)
+    return walletAccounts
+  }
+
+  async getAssetsForNetwork({ baseAssetName }) {
+    return pickBy(this.assets, (asset) => asset.baseAsset.name === baseAssetName)
+  }
+
+  async fetchToken({ assetId, baseAssetName }) {
+    throw new Error('implement!')
+  }
+
+  async addToken({ assetId, baseAssetName, allowedStatusList }) {
+    throw new Error('Implement!')
+  }
+
+  async getConfirmationsNumber({ assetName }) {
+    const baseAsset = this.assets[assetName].baseAsset
+    return baseAsset.api?.getConfirmationsNumber ? baseAsset.api.getConfirmationsNumber() : 1
+  }
+
+  async getFeeData({ assetName }) {
+    const feeData = this.feeData[getAssetOnlyKey({ assetName })]
+    if (!feeData) {
+      throw new Error(`Asset ${assetName} does not support fee data`)
+    }
+    return feeData
+  }
+
+  async updateFeeConfig({ assetName, feeConfig }) {
+    const currentFeeData = await this.getFeeData({ assetName })
+    const newFeeData = currentFeeData.update(feeConfig)
+    this.feeData[getAssetOnlyKey({ assetName })] = newFeeData
+    this.emit('fee-config-updated')
+  }
+}