@exodus/ethereum-lib 2.5.0 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-lib",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "Ethereum Library",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -23,5 +23,5 @@
   "peerDependencies": {
     "@exodus/assets": "8.0.x"
   },
-  "gitHead": "20021e426b0554c029a3c223cb5a2e06711358e3"
+  "gitHead": "71d126e789b161f5877db4a651a641061f00c7af"
 }

package/src/abi/index.js

@@ -2,6 +2,7 @@ import ant from './ant'
 import cdai from './cdai'
 import dai from './dai'
 import gnt from './gnt'
+import kyberv2 from './kyberv2.js'
 import loomv2Swap from './loomv2-swap'
 import repv2 from './repv2'
 import scdMcdMigration from './scd-mcd-migration'
@@ -11,6 +12,7 @@ export default {
   cdai,
   dai,
   gnt,
+  kyberv2,
   loomv2Swap,
   repv2,
   scdMcdMigration,

package/src/abi/kyberv2.js

@@ -0,0 +1,253 @@
+// https://etherscan.io/address/0xe5e8e834086f1a964f9a089eb6ae11796862e4ce#code
+
+export default [
+  {
+    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: 'account', type: 'address' },
+      { indexed: true, internalType: 'uint256', name: 'amount', type: 'uint256' },
+    ],
+    name: 'Migrated',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: 'address', name: 'account', type: 'address' },
+      { indexed: true, internalType: 'uint256', name: 'amount', type: 'uint256' },
+      { indexed: true, internalType: 'address', name: 'minter', type: 'address' },
+    ],
+    name: 'Minted',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: 'address', name: 'oldMinter', type: 'address' },
+      { indexed: true, internalType: 'address', name: 'newMinter', type: 'address' },
+    ],
+    name: 'MinterChanged',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: 'address', name: 'previousOwner', type: 'address' },
+      { indexed: true, internalType: 'address', name: 'newOwner', type: 'address' },
+    ],
+    name: 'OwnershipTransferred',
+    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: 'amount', 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: [{ internalType: 'uint256', name: 'amount', type: 'uint256' }],
+    name: 'burn',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'account', type: 'address' },
+      { internalType: 'uint256', name: 'amount', type: 'uint256' },
+    ],
+    name: 'burnFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'newMinter', type: 'address' }],
+    name: 'changeMinter',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'decimals',
+    outputs: [{ internalType: 'uint8', name: '', type: 'uint8' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'spender', type: 'address' },
+      { internalType: 'uint256', name: 'subtractedValue', type: 'uint256' },
+    ],
+    name: 'decreaseAllowance',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'contract IERC20', name: 'token', type: 'address' },
+      { internalType: 'uint256', name: 'amount', type: 'uint256' },
+    ],
+    name: 'emergencyERC20Drain',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'spender', type: 'address' },
+      { internalType: 'uint256', name: 'addedValue', type: 'uint256' },
+    ],
+    name: 'increaseAllowance',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: '_oldKNC', type: 'address' },
+      { internalType: 'address', name: '_minter', type: 'address' },
+    ],
+    name: 'initialize',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'account', type: 'address' },
+      { internalType: 'uint256', name: 'amount', type: 'uint256' },
+    ],
+    name: 'mint',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'uint256', name: 'amount', type: 'uint256' }],
+    name: 'mintWithOldKnc',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'minter',
+    outputs: [{ internalType: 'address', name: '', type: 'address' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'name',
+    outputs: [{ internalType: 'string', name: '', type: 'string' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'oldKNC',
+    outputs: [{ internalType: 'address', name: '', type: 'address' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'owner',
+    outputs: [{ internalType: 'address', name: '', type: 'address' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'renounceOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    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: 'recipient', type: 'address' },
+      { internalType: 'uint256', name: 'amount', type: 'uint256' },
+    ],
+    name: 'transfer',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: 'sender', type: 'address' },
+      { internalType: 'address', name: 'recipient', type: 'address' },
+      { internalType: 'uint256', name: 'amount', type: 'uint256' },
+    ],
+    name: 'transferFrom',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ internalType: 'address', name: 'newOwner', type: 'address' }],
+    name: 'transferOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+]

package/src/create-contract/index.js

@@ -2,6 +2,7 @@ import SolidityContract from '@exodus/solidity-contract'
 import ABI from '../abi'
 
 export default function createContract(address, assetName) {
+  // keep switch logic in anticipation of support for ERC721
   switch (assetName) {
     // case 'dai':
     //   return new SolidityContract(ABI.dai, address)
@@ -15,6 +16,8 @@ export default function createContract(address, assetName) {
       return new SolidityContract(ABI.gnt, address)
     case 'loomv2Swap':
       return new SolidityContract(ABI.loomv2Swap, address)
+    case 'kyberv2':
+      return new SolidityContract(ABI.kyberv2, address)
     default:
       return SolidityContract.erc20(address)
   }

package/src/monitor-utils/index.js

@@ -5,5 +5,6 @@ export { default as isConsideredSentTokenTx } from './is-considered-sent-token-t
 export { default as getHistoryFromServer } from './get-history-from-server'
 export { default as checkPendingTransactions } from './check-pending-transactions'
 export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check'
+export { subscribeToWSNotifications, enableWSUpdates } from './ws-updates'
 
 export type { PendingTransactionsDictionary } from './types'

package/src/monitor-utils/ws-updates.js

@@ -0,0 +1,59 @@
+import ms from 'ms'
+
+const subscribedToAddressNotificationsMap = new Map()
+const UPDATE_LOOP_INTERVAL = ms('5m')
+
+export function subscribeToWSNotifications({
+  addressesByWalletAccount,
+  tick,
+  getState,
+  server,
+  beforeStart = false,
+}) {
+  Object.entries(addressesByWalletAccount).forEach(([walletAccount, addresses]) => {
+    const address = String(Array.from(addresses)[0]).toLowerCase() // Only check m/0/0
+    const mapKey = `${server.getURL()}:${address}` // different chains might have the same addresses
+    if (subscribedToAddressNotificationsMap.has(mapKey)) return
+
+    server.ws.watch(address)
+    server.ws.events.on(`address-${address}`, () => {
+      tick({ refresh: false, getState, walletAccount })
+    })
+    subscribedToAddressNotificationsMap.set(mapKey, true)
+    if (!beforeStart) {
+      // tick for a new wallet account
+      tick({ refresh: false, getState, walletAccount })
+    }
+  })
+}
+
+export function enableWSUpdates({
+  interval,
+  server,
+  timer,
+  dispatch,
+  getState,
+  tickAllWalletAccounts,
+  tick,
+  addressesByWalletAccount,
+  beforeStart = false,
+}) {
+  const defaultInterval = interval
+
+  subscribeToWSNotifications({
+    server,
+    getState,
+    beforeStart,
+    tick,
+    addressesByWalletAccount,
+  })
+
+  server.ws.events.on('open', () => {
+    timer.setNewInterval(UPDATE_LOOP_INTERVAL)
+  })
+  server.ws.events.on('close', async () => {
+    await timer.setNewInterval(defaultInterval)
+    return tickAllWalletAccounts({ dispatch, getState })
+  })
+  server.ws.open()
+}

package/src/selectors/get-can-accelerate-tx-factory.js

@@ -8,16 +8,28 @@ const BumpType = {
   RBF: 2,
 }
 
+// Legacy compatibility with wallets
 export function getPendingNonExchangeTxs(activeWalletAccount, getTxLog, getIsExchangeTx) {
+  console.log('Using deprecated function getPendingNonExchangeTxs()')
+  return getAssetPendingNonExchangeTxs('ethereum', activeWalletAccount, getTxLog, getIsExchangeTx)
+}
+
+export function getAssetPendingNonExchangeTxs(
+  baseAssetName,
+  activeWalletAccount,
+  getTxLog,
+  getIsExchangeTx
+) {
   // check if the tx log even has pending transactions
   const result = isQueuedPendingTx(
     { data: { nonce: Number.MAX_SAFE_INTEGER } },
+    baseAssetName,
     activeWalletAccount,
     getTxLog
   )
   if (!result) return []
 
-  const txLog = getTxLog('ethereum', activeWalletAccount)
+  const txLog = getTxLog(baseAssetName, activeWalletAccount)
   const pendingNonExchangeTxs = []
   for (let index = isQueuedPendingTx.minIndex; index < txLog.size; index++) {
     const _tx = txLog.getAt(index)
@@ -29,8 +41,8 @@ export function getPendingNonExchangeTxs(activeWalletAccount, getTxLog, getIsExc
   return pendingNonExchangeTxs
 }
 
-function isQueuedPendingTx(tx, activeWalletAccount, getTxLog) {
-  const txLog = getTxLog('ethereum', activeWalletAccount)
+function isQueuedPendingTx(tx, baseAssetName, activeWalletAccount, getTxLog) {
+  const txLog = getTxLog(baseAssetName, activeWalletAccount)
   if (!txLog || txLog.size === 0) return false
 
   const txAtMinIndex = txLog.getAt(isQueuedPendingTx.minIndex)
@@ -105,11 +117,11 @@ export default (
       getIsExchangeTx
     ) => (tx) => {
       const assetName = tx.coinName
-      const asset = assets[assetName]
+      const baseAssetName = assets[assetName].baseAsset.name
       if (!getIsRbfEnabled(assetName))
         return wrapResponseToObject({ errorMessage: 'rbf is disabled' })
-      if (!['ETHEREUM_ERC20', 'ETHEREUM_LIKE'].includes(asset.assetType))
-        return wrapResponseToObject({ errorMessage: `not an ETH/ERC20 asset supplied` })
+      if (!['ethereum', 'bsc'].includes(baseAssetName))
+        return wrapResponseToObject({ errorMessage: `not an ETH/ERC20/BSC/BEP20 asset supplied` })
       if (!tx.pending || !tx.sent)
         return wrapResponseToObject({ errorMessage: 'can not bump a pending or received TX' })
       if (!tx.data || !tx.data.gasLimit)
@@ -119,16 +131,14 @@ export default (
       const personalNote = getPersonalNoteByTxId(tx.txId)
       if (personalNote && personalNote.dapp)
         return wrapResponseToObject({ errorMessage: 'can not bump a dapp TX' })
-      if (isQueuedPendingTx(tx, activeWalletAccount, getTxLog))
+      if (isQueuedPendingTx(tx, baseAssetName, activeWalletAccount, getTxLog))
         return wrapResponseToObject({ errorMessage: 'there is a stuck TX with lower nonce' })
 
       const { gasPrice: currentGasPrice } = getFeeData(assetName)
       const gasPriceToUse = calculateBumpedGasPrice(tx, currentGasPrice)
       const replacementFee = gasPriceToUse.mul(tx.data.gasLimit)
       const extraEthNeeded = replacementFee.sub(tx.feeAmount)
-      if (
-        !getIsEnoughBalanceToAccelerate(activeWalletAccount, asset.baseAsset.name, extraEthNeeded)
-      )
+      if (!getIsEnoughBalanceToAccelerate(activeWalletAccount, baseAssetName, extraEthNeeded))
         return wrapResponseToObject({ errorMessage: 'insufficient funds' })
 
       return wrapResponseToObject({ bumpType: BumpType.RBF })

package/src/selectors/index.js

@@ -2,6 +2,7 @@ export {
   default as getCanAccelerateTxFactory,
   calculateBumpedGasPrice,
   getPendingNonExchangeTxs,
+  getAssetPendingNonExchangeTxs,
 } from './get-can-accelerate-tx-factory'
 
 export { default as getIsEnoughBalanceToAccelerateSelectorFactory } from './get-is-enough-balance-to-accelerate-factory'

package/src/utils/calculate-extra-eth.js

@@ -0,0 +1,15 @@
+const defaultMultiplier = 1.1
+
+// if a wallet has 0 ETH the deposit needed should be more than the fee needed by <multiplier>
+// if a wallet has <N> ETH, the deposit needed should be the fee * <multiplier> - <N>
+export default function({ fee, balance, multiplier = defaultMultiplier }) {
+  if (typeof multiplier !== 'number' || multiplier < 1) multiplier = defaultMultiplier
+  if (balance.gt(fee)) return balance.unitType.ZERO
+
+  return fee
+    .mul(multiplier)
+    .toDefault()
+    .sub(balance)
+    .toFixed(4, 'ceil')
+    .toString()
+}

package/src/utils.js

@@ -6,6 +6,7 @@ const base10 = baseX('0123456789')
 const base16 = baseX('0123456789abcdef')
 
 export const isEthereumToken = (asset) => asset.assetType === 'ETHEREUM_ERC20'
+export const isBscToken = (asset) => asset.assetType === 'BSC_BEP20'
 export const isQuorumToken = (asset) => asset.assetType === 'QUORUM_ERC20'
 
 export function buffer2currency({ asset, value }) {