@exodus/ethereum-api 2.8.1 → 2.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -10,15 +10,22 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@exodus/ethereum-lib": "^2.13.1",
+    "@exodus/asset-lib": "^3.5.4",
+    "@exodus/ethereum-lib": "^2.13.2",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/simple-retry": "^0.0.6",
     "fetchival": "0.3.3",
     "make-concurrent": "4.0.0",
+    "minimalistic-assert": "^1.0.1",
     "ms": "^2.1.1",
     "url": "0.10.3",
     "url-join": "4.0.0",
     "ws": "6.1.0"
   },
-  "gitHead": "0266f50330e737c4cce09987e490a103f6cbfa8c"
+  "devDependencies": {
+    "@exodus/assets": "^8.0.67",
+    "@exodus/assets-base": "^8.0.136",
+    "@exodus/models": "^8.7.2"
+  },
+  "gitHead": "b0b9075484b6cef16d59946c054f5fe8c79d89d6"
 }

package/src/eth-like-util.js

@@ -1,5 +1,6 @@
 import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken } from '@exodus/ethereum-lib'
 import { eth, serverMap, getServer } from './exodus-eth-server'
+import { memoizeLruCache } from '@exodus/asset-lib'
 
 // Mobile only.
 // Behavior is buggy, because the default server used is ethereum.
@@ -67,3 +68,9 @@ export async function transactionExists({ asset, txId }) {
   const txResult = await server.getTransactionByHash(txId)
   return txResult && txResult.hash === txId
 }
+
+export const getIsForwarderContract = memoizeLruCache(
+  isForwarderContract,
+  ({ asset, address }) => `${asset.name}:${address}`,
+  { max: 100 }
+)

package/src/exodus-eth-server/api.js

@@ -56,6 +56,12 @@ export function create(defaultURL) {
       }
     },
 
+    stop() {
+      if (ws.isCreated()) {
+        ws.close()
+      }
+    },
+
     ws,
 
     async getBalance(address, opts) {

package/src/exodus-eth-server/index.js

@@ -5,7 +5,7 @@ const EXODUS_ETC_SERVER_URL = 'https://getc.a.exodus.io/wallet/v1/'
 const EXODUS_BSC_SERVER_URL = 'https://bsc.a.exodus.io/wallet/v1/'
 const EXODUS_POLYGON_SERVER_URL = 'https://polygon.a.exodus.io/wallet/v1/'
 const EXODUS_AVAXC_SERVER_URL = 'https://avax-c.a.exodus.io/wallet/v1/'
-const EXODUS_FTM_SERVER_URL = 'https://ftm.a.exodus.io/wallet/v1/'
+const EXODUS_FTM_SERVER_URL = 'https://fantom.a.exodus.io/wallet/v1/'
 
 // allow self-signed certs
 // process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'

package/src/exodus-eth-server/ws.js

@@ -12,6 +12,7 @@ export default function createWebSocket(getURL) {
   let ws
   let pingIntervalId = null
   let opened = false
+  let isWSOpened = false
   let openTimeoutId
 
   function subscribeAddress(address) {
@@ -24,6 +25,11 @@ export default function createWebSocket(getURL) {
     ws.send(data)
   }
 
+  function clearPing() {
+    clearInterval(pingIntervalId)
+    pingIntervalId = null
+  }
+
   function onMessage(data) {
     data = JSON.parse(data)
     switch (data.type) {
@@ -42,7 +48,7 @@ export default function createWebSocket(getURL) {
     if (ws) return
 
     ws = new WebSocket(getURL())
-    ws.onerror = () => {}
+    ws.onerror = (e) => {}
     ws.onmessage = (e) => {
       try {
         onMessage(e.data)
@@ -51,13 +57,18 @@ export default function createWebSocket(getURL) {
     ws.onopen = () => {
       for (const address of addresses.values()) subscribeAddress(address)
       subscribeGasPrice()
-      pingIntervalId = setInterval(() => ws.ping(), PING_INTERVAL)
+      if (typeof ws.ping === 'function') {
+        pingIntervalId = setInterval(() => ws.ping(), PING_INTERVAL)
+      } else {
+        console.warn('Client side ping not available')
+      }
+      isWSOpened = true
       events.emit('open')
     }
     ws.onclose = () => {
       ws = null
-      clearInterval(pingIntervalId)
-      pingIntervalId = null
+      isWSOpened = false
+      clearPing()
       if (opened) {
         openTimeoutId = setTimeout(open, reconnectDelay())
       }
@@ -67,17 +78,16 @@ export default function createWebSocket(getURL) {
 
   function close() {
     opened = false
+    isWSOpened = false
     clearTimeout(openTimeoutId)
     if (!ws) return
-
     ws.onerror = null
     ws.onmessage = null
     ws.onopen = null
     ws.onclose = null
     ws.close()
     ws = null
-    clearInterval(pingIntervalId)
-    pingIntervalId = null
+    clearPing()
     events.emit('close')
   }
 
@@ -94,5 +104,5 @@ export default function createWebSocket(getURL) {
     if (ws) subscribeAddress(address)
   }
 
-  return { events, open, close, watch, isCreated: () => !!ws, isOpened: () => !!pingIntervalId }
+  return { events, open, close, watch, isCreated: () => !!ws, isOpened: () => isWSOpened }
 }

package/src/fee-monitor/fantom.js

@@ -1,5 +1,5 @@
 import { EthereumLikeFeeMonitor } from '@exodus/ethereum-lib'
-import { fantommainnet as fantomServer } from '../exodus-eth-server'
+import { ftm as fantomServer } from '../exodus-eth-server'
 
 export class FantomFeeMonitor extends EthereumLikeFeeMonitor {
   constructor({ updateFee }) {

package/src/index.js

@@ -1,4 +1,8 @@
+// Ideally, we should reduce the exports to just api.
+// If the client is importing one module specifically,
+// it's breaking the encapsulation
 export * from './eth-like-util'
 export * from './fee-monitor'
 export * from './gas-estimation'
 export * from './exodus-eth-server'
+export * from './tx-log'

package/src/tx-log/__tests__/asset-client-interface-test-helper.js

@@ -0,0 +1,22 @@
+import { InMemoryAssetClientInterface } from './in-memory-asset-client-interface'
+import assetMap from './assets-for-test-helper'
+import assert from 'minimalistic-assert'
+
+export const createAssetClientInterface = ({ logger, walletPublicKeys }) =>
+  new InMemoryAssetClientInterface({
+    logger,
+    assets: assetMap,
+    walletAccounts: { exodus0: { index: 0 }, exodus1: { index: 1 } },
+    wallet: {
+      genPublicKey: async ({ accountIndex, baseAssetName }) => {
+        const publicKey = walletPublicKeys[baseAssetName][accountIndex]
+        assert(
+          publicKey,
+          `public key for asset ${baseAssetName} index ${accountIndex} cannot be resolved!`
+        )
+        return Promise.resolve({
+          publicKey,
+        })
+      },
+    },
+  })

package/src/tx-log/__tests__/assets-for-test-helper.js

@@ -0,0 +1,30 @@
+import { mapValues } from 'lodash'
+import rawAssetMap from '@exodus/assets'
+import { encodePublic, isEthereumLike } from '@exodus/ethereum-lib'
+
+const copiedAssetMap = mapValues(rawAssetMap, (rawAsset) => ({ ...rawAsset }))
+
+export const keys = {
+  encodePublic,
+}
+
+// simulates how clients transform assets from @exodus/assets
+const expandRawAsset = (asset) => {
+  const rawAsset = rawAssetMap[asset.name]
+  asset.baseAsset = rawAssetMap[rawAsset.baseAsset.name]
+  asset.feeAsset = rawAssetMap[rawAsset.feeAsset.name]
+  if (asset.isCombined) {
+    asset.combinedAssetNames = asset.combinedAssetNames.filter((assetName) => asset[assetName])
+    asset.combinedAssets = asset.combinedAssetNames.map((assetName) => asset[assetName])
+  }
+  if (isEthereumLike(asset)) {
+    asset.keys = keys
+  }
+  if (asset.contract?.current) {
+    // transformation hack
+    asset.contract.address = asset.contract.current
+  }
+  return [asset.name, asset]
+}
+
+export default Object.fromEntries(Object.values(copiedAssetMap).map(expandRawAsset))

package/src/tx-log/__tests__/bsc-history-return-values-for-test-helper.js

@@ -0,0 +1,94 @@
+export default {
+  '0x90e481d9a664ebbe4be180d9501962255463036d': [
+    [
+      {
+        blockHash: '0xe8487b0e2a6f8410b2e05536e06fd75eaf2f091d6ab8d91c920b9916673e2757',
+        blockNumber: '0x10208d9',
+        timestamp: '0x6256c8f5',
+        confirmations: 1142596,
+        addressIndex: 0,
+        hash: '0xcf8d3f903e38b15ed0a32a0137faed35d74ebc15dec8b99f0300eb72be19b0b0',
+        nonce: '0x109',
+        gasPrice: '0x174876e80',
+        gas: '0x6f952',
+        gasUsed: '0x5cfc5',
+        to: '0xc748673057861a797275cd8a068abb95a902e8de',
+        from: '0xa9866ef5574a256b4b85ad2b80880da2ef1b0011',
+        value: '0x0',
+        status: 1,
+        error: null,
+        internal: [],
+        erc20: [
+          {
+            events: true,
+            address: '0xc748673057861a797275cd8a068abb95a902e8de',
+            from: '0xa9866ef5574a256b4b85ad2b80880da2ef1b0011',
+            to: '0x90e481d9a664ebbe4be180d9501962255463036d',
+            value: '0xcc74a8c9c5124',
+          },
+          {
+            events: false,
+            address: '0xc748673057861a797275cd8a068abb95a902e8de',
+            from: '0xa9866ef5574a256b4b85ad2b80880da2ef1b0011',
+            to: '0x90e481d9a664ebbe4be180d9501962255463036d',
+            value: '0xe32c49c3be860',
+          },
+        ],
+        erc721: [],
+        data:
+          '0xa9059cbb00000000000000000000000090e481d9a664ebbe4be180d9501962255463036d000000000000000000000000000000000000000000000000000e32c49c3be860',
+      },
+      {
+        blockHash: '0x499b9ba9c99064eeaded737c8a3135b52a10bbed460a064b14efe08810887ef3',
+        blockNumber: '0x1051668',
+        timestamp: '0x6260033c',
+        confirmations: 942517,
+        addressIndex: 2,
+        hash: '0xd9602fd41cb44e8d17e965de0c057245d4cb39c1250a3874b7c9f2dc3c9fe78e',
+        nonce: '0x4873d6',
+        gasPrice: '0x2540be400',
+        gas: '0x32918',
+        gasUsed: '0x5208',
+        to: '0x90e481d9a664ebbe4be180d9501962255463036d',
+        from: '0xa180fe01b906a1be37be6c534a3300785b20d947',
+        value: '0x21c0331d5dc000',
+        status: 1,
+        error: null,
+        internal: [],
+        erc20: [],
+        erc721: [],
+        data: '0x',
+      },
+      {
+        blockHash: '0x0b4e6b2aa26af46f803e55a644312fcda2b4b905b0023a9b995bdf38ccf0f8f7',
+        blockNumber: '0x1052328',
+        timestamp: '0x62602980',
+        confirmations: 939253,
+        addressIndex: 3,
+        hash: '0x7bcca25c1672d3de101a9a848c04413b40667fa77e97b939a366e775b89d62cd',
+        nonce: '0x88e362',
+        gasPrice: '0x2540be400',
+        gas: '0x32918',
+        gasUsed: '0xc7ab',
+        to: '0x0e09fabb73bd3ade0a17ecc321fd13a19e81ce82',
+        from: '0xe2fc31f816a9b94326492132018c3aecc4a93ae1',
+        value: '0x0',
+        status: 1,
+        error: null,
+        internal: [],
+        erc20: [
+          {
+            events: true,
+            address: '0x0e09fabb73bd3ade0a17ecc321fd13a19e81ce82',
+            from: '0xe2fc31f816a9b94326492132018c3aecc4a93ae1',
+            to: '0x90e481d9a664ebbe4be180d9501962255463036d',
+            value: '0x1fdd07d5d44c0000',
+          },
+        ],
+        erc721: [],
+        data:
+          '0xa9059cbb00000000000000000000000090e481d9a664ebbe4be180d9501962255463036d0000000000000000000000000000000000000000000000001fdd07d5d44c0000',
+      },
+    ],
+  ],
+}

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

@@ -0,0 +1,166 @@
+import { EthereumMonitor } from '../ethereum-monitor'
+import { size, omit } from 'lodash'
+import { AccountState } from '@exodus/models'
+import { once } from 'events'
+import { bsc 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_BSC_SERVER_URL = 'https://bsc.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 { bsc } = assetMap
+
+// Replacing default gasPrice to be sure WS will change it
+const dummyGasPrice = bsc.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: bsc.currency.ZERO,
+    tokenBalances: {},
+  }
+}
+
+bsc.api = {
+  createAccountState: () => EthereumAccountState,
+  getConfirmationsNumber: () => 2,
+  getFeeData: () => feeDataMock,
+}
+
+// Fernando's dev wallet. Profile 1 and Profile 2
+export const walletPublicKeys = {
+  bsc: [
+    Buffer.from('0273c38a3c31c31b361dc8d6b93e56c316e34991c478d3a14ea3fcd1ab552bc25e', 'hex'),
+    Buffer.from('02f33b1edf1016f6720518c776da30567fc7b7052ae6b596dd22909e0a87164f8d', 'hex'),
+  ],
+}
+
+describe('bsc monitor', () => {
+  test('can start monitor and update txs', async () => {
+    const assetClientInterface = createAssetClientInterface({ logger, walletPublicKeys })
+    const server = create(EXODUS_BSC_SERVER_URL)
+    const getHistoryV2 = jest.fn(async (...args) => {
+      const transactions = await server.getHistoryV2(...args)
+      return transactions.filter((tx) => {
+        return parseInt(tx.blockNumber, 16) < 0x1052330
+      })
+    })
+    const monitor = new EthereumMonitor({
+      interval: 20,
+      asset: bsc,
+      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.toDefault()).toEqual(expected.toDefault())
+        expect(actual.equals(expected)).toEqual(true)
+      }
+
+      expect((await txs('exodus0', 'bsc')).size).toEqual(1)
+      expect((await txs('exodus0', 'pancakeswap')).size).toEqual(1)
+      expect((await txs('exodus0', 'babydoge_bsc')).size).toEqual(1)
+
+      expectSameValue(
+        toBalanceFromTx(await txs('exodus0', 'bsc')),
+        bsc.currency.baseUnit(9500000000000000)
+      )
+      expectSameValue(
+        toBalanceFromTx(await txs('exodus0', 'pancakeswap')),
+        assetMap.pancakeswap.currency.defaultUnit(2.296)
+      )
+      const txBabyDodge = assetMap.babydoge_bsc.currency.defaultUnit('3596822.721089828')
+      expectSameValue(toBalanceFromTx(await txs('exodus0', 'babydoge_bsc')), txBabyDodge)
+
+      // Bsc and babydoge_bsc are special. Balance is loaded from getBalance RPC, not from transaction.
+      // see isRpcBalanceAsset
+      // It seems eth balances and tokenBalances are not being filled. Clients need to read tx like above
+      // NOTE THAT THESE BALANCE ASSERTIONS MAY FAIL IF TRANSFERING FUNDS..
+      expectSameValue(
+        (await state('exodus0', 'bsc')).balance,
+        assetMap.bsc.currency.defaultUnit(0.0095)
+      )
+      // Baby dodge balance is greater than tx balance due to the offchain rewards...
+      expect((await state('exodus0', 'bsc')).tokenBalances.babydoge_bsc.gt(txBabyDodge)).toEqual(
+        true
+      )
+      expectSameValue((await state('exodus1', 'bsc')).balance, bsc.currency.baseUnit(0))
+      expect((await state('exodus1', 'bsc')).tokenBalances).toEqual({
+        babydoge_bsc: assetMap.babydoge_bsc.currency.baseUnit(0),
+      })
+      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_BSC_SERVER_URL)
+    const assetClientInterface = createAssetClientInterface({ logger, walletPublicKeys })
+    const monitor = new EthereumMonitor({
+      interval: 20,
+      asset: bsc,
+      assetClientInterface,
+      logger,
+      server,
+    })
+    try {
+      expect(await assetClientInterface.getFeeData({ assetName: bsc.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: bsc.name })).not.toEqual(
+        feeDataMock
+      )
+      // gas price and origin are the changed ones.
+      expect(
+        omit(await assetClientInterface.getFeeData({ assetName: bsc.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__/bsc-monitor.test.js

@@ -0,0 +1,184 @@
+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 { bsc as feeData } from '@exodus/ethereum-lib/src/fee-data'
+import historyReturnValuesForTest from './bsc-history-return-values-for-test-helper'
+import { size, cloneDeep } from 'lodash'
+
+const { bsc } = assetMap
+
+export default class EthereumAccountState extends AccountState {
+  static defaults = {
+    cursor: '',
+    balance: bsc.currency.ZERO,
+    tokenBalances: {},
+  }
+}
+
+bsc.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 = {
+  bsc: [
+    Buffer.from('0273c38a3c31c31b361dc8d6b93e56c316e34991c478d3a14ea3fcd1ab552bc25e', 'hex'),
+    Buffer.from('02f33b1edf1016f6720518c776da30567fc7b7052ae6b596dd22909e0a87164f8d', 'hex'),
+  ],
+}
+
+describe('bsc 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: bsc,
+      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 || [])
+      }),
+
+      balanceOf: jest.fn((walletAddress, contractAddress) => {
+        // jest doesn't to have when-some-arg-then-some-value kind of mocking
+        // https://github.com/facebook/jest/issues/6180
+        const balances = {
+          [`${encodePublic(walletPublicKeys.bsc[0])}-${
+            assetMap.babydoge_bsc.contract.address
+          }`.toLowerCase()]: 3610932917151657,
+        }
+        const expectedKey = `${walletAddress}-${contractAddress}`.toLowerCase()
+        const balance = balances[expectedKey] || 0
+        return Promise.resolve({
+          confirmed: {
+            [contractAddress]: balance,
+          },
+        })
+      }),
+
+      getBalance: jest.fn((walletAddress) => {
+        const balances = {
+          [encodePublic(walletPublicKeys.bsc[0]).toLowerCase()]: 10500000000000000,
+        }
+        const balance = `${balances[walletAddress.toLowerCase()] || 0}`
+        return Promise.resolve({ confirmed: { value: balance } })
+      }),
+    }
+
+    const monitor = new EthereumMonitor({
+      interval: 20,
+      asset: bsc,
+      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.toDefault()).toEqual(expected.toDefault())
+      expect(actual.equals(expected)).toEqual(true)
+    }
+
+    expect((await txs('exodus0', 'bsc')).size).toEqual(1)
+    expect((await txs('exodus0', 'pancakeswap')).size).toEqual(1)
+    expect((await txs('exodus0', 'babydoge_bsc')).size).toEqual(1)
+
+    expectSameValue(toBalanceFromTx(await txs('exodus0', 'bsc')), bsc.currency.defaultUnit(0.0095))
+    expectSameValue(
+      toBalanceFromTx(await txs('exodus0', 'pancakeswap')),
+      assetMap.pancakeswap.currency.defaultUnit(2.296)
+    )
+    expectSameValue(
+      toBalanceFromTx(await txs('exodus0', 'babydoge_bsc')),
+      assetMap.babydoge_bsc.currency.defaultUnit('3596822.721089828')
+    )
+
+    // Bsc and babydoge_bsc are special. Balance is loaded from getBalance RPC, not from transaction.
+    // see isRpcBalanceAsset
+    // It seems eth balances and tokenBalances are not being filled. Clients need to read tx like above
+    expectSameValue((await state('exodus0', 'bsc')).balance, bsc.currency.defaultUnit(0.0105))
+    // balance is grater than transaction balance due to the off-chain rewards.
+    expect((await state('exodus0', 'bsc')).tokenBalances).toEqual({
+      babydoge_bsc: assetMap.babydoge_bsc.currency.baseUnit(3610932917151657),
+    })
+    expectSameValue((await state('exodus1', 'bsc')).balance, assetMap.bsc.currency.baseUnit(0))
+    expect((await state('exodus1', 'bsc')).tokenBalances).toEqual({
+      babydoge_bsc: assetMap.babydoge_bsc.currency.baseUnit(0),
+    })
+    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.bsc[0])).toEqual(
+      '0x90E481d9A664ebbE4Be180d9501962255463036d'
+    )
+    expect(encodePublic(walletPublicKeys.bsc[1])).toEqual(
+      '0xf6c138C36341138dDFC314a11038dA8264B7Ef09'
+    )
+  })
+})