@exodus/ethereum-api 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -10,7 +10,7 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@exodus/ethereum-lib": "^0.2.4",
+    "@exodus/ethereum-lib": "^0.2.8",
     "fetchival": "0.3.3",
     "lodash": "^4.17.11",
     "make-concurrent": "4.0.0",
@@ -19,5 +19,5 @@
     "url-join": "4.0.0",
     "ws": "6.1.0"
   },
-  "gitHead": "cb562d91bae2c526403fb66ab8b05127a8f1d673"
+  "gitHead": "fc53854a8e60f021526fa8b6f4ac7fb5ccb0a5a4"
 }

package/src/gas-estimation.js

@@ -0,0 +1,99 @@
+import BN from 'bn.js'
+import * as ethUtil from 'ethereumjs-util'
+import { currency2buffer, isEthereumToken, getBaseAsset } from '@exodus/ethereum-lib'
+import { estimateGas } from './with-fallback'
+
+const EXTRA_PERCENTAGE = 20
+
+async function estimateGasLimit(
+  asset: Object,
+  fromAddress: string,
+  toAddress: string,
+  amount: Buffer | Object,
+  data: Buffer | string,
+  gasPrice: string,
+  extraPercentage: number = EXTRA_PERCENTAGE
+): number {
+  if (!Buffer.isBuffer(amount)) {
+    amount = currency2buffer(amount)
+  }
+
+  amount = ethUtil.bufferToHex(amount)
+  while (amount[2] === '0') amount = '0x' + amount.slice(3)
+  if (amount === '0x') amount = '0x0'
+
+  while (gasPrice[2] === '0') gasPrice = '0x' + gasPrice.slice(3)
+  if (gasPrice === '0x') gasPrice = '0x0'
+
+  const estimatedGas = await estimateGas({
+    asset,
+    from: fromAddress,
+    to: toAddress,
+    value: amount,
+    data: Buffer.isBuffer(data) ? ethUtil.bufferToHex(data) : data,
+    gasPrice,
+  })
+  return new BN(estimatedGas.slice(2), 16)
+    .imuln(100 + extraPercentage)
+    .idivn(100)
+    .toNumber()
+}
+
+export async function fetchGasLimit({
+  asset,
+  fromAddress,
+  toAddress,
+  txInput = '0x',
+  amount,
+  feeData,
+  bip70,
+  isContract,
+  throwOnError = true,
+  extraPercentage,
+}) {
+  const isToken = isEthereumToken(asset)
+  if (isToken) {
+    txInput = ethUtil.bufferToHex(asset.contract.transfer.build(toAddress, currency2buffer(amount)))
+    amount = getBaseAsset(asset).currency.ZERO
+    toAddress = asset.contract.addresses.current
+  } else if (!isContract) {
+    if (isContract === undefined) isContract = await asset.address.isContract(toAddress)
+    if (!isContract) return asset.gasLimit
+  }
+
+  if (!amount) {
+    amount = asset.currency.ZERO
+  }
+
+  let gasPrice = ethUtil.bufferToHex(currency2buffer(feeData.gasPrice))
+
+  if (bip70 && bip70.bitpay) {
+    if (bip70.bitpay.data) {
+      txInput = bip70.bitpay.data
+    }
+
+    if (bip70.bitpay.gasPrice) {
+      const bitPayGasPrice = ethUtil.bufferToHex(currency2buffer(bip70.bitpay.gasPrice))
+      if (new ethUtil.BN(bitPayGasPrice).gt(new ethUtil.BN(gasPrice))) {
+        gasPrice = bitPayGasPrice
+      }
+    }
+  }
+
+  try {
+    return await estimateGasLimit(
+      asset,
+      fromAddress,
+      toAddress,
+      amount,
+      txInput,
+      gasPrice,
+      extraPercentage
+    )
+  } catch (err) {
+    if (throwOnError) throw err
+    console.log('fetchGasLimit error', err)
+  }
+
+  return isToken ? asset.gasLimit : asset.contractGasLimit
+}

package/src/index.js

@@ -4,5 +4,6 @@ import * as etcWithFallback from './etc-with-fallback'
 
 export * from './with-fallback'
 export * from './fee-monitor'
+export * from './gas-estimation'
 export * from './exodus-eth-server'
 export { etherscan, ethWithFallback, etcWithFallback }

package/src/with-fallback.js

@@ -1,5 +1,4 @@
 import { get } from 'lodash'
-import { _isEthereumToken } from '@exodus/ethereum-lib'
 import { eth as ethServer, etc as etcServer } from './exodus-eth-server'
 import * as etherscan from './etherscan'
 
@@ -19,9 +18,12 @@ export function withFallback(fn, fn2) {
 }
 
 export async function isContract(assetName, address) {
-  const server =
-    assetName === 'ethereumclassic' ? etcServer : withFallback(ethServer.getCode, etherscan.getCode)
-  const code = await server.getCode(address)
+  const _getCode =
+    assetName === 'ethereumclassic'
+      ? withFallback(etcServer.getCode, etcServer.getCode)
+      : withFallback(ethServer.getCode, etherscan.getCode)
+
+  const code = await _getCode(address)
   return code.length > 2
 }
 
@@ -29,48 +31,57 @@ export async function getNonce({ asset, address }) {
   if (!['ethereum', 'ethereumclassic'].includes(asset.name)) return
 
   const _getNonce =
-    asset.name === 'ethereum'
-      ? withFallback(ethServer.getTransactionCount, etherscan.getTransactionCount)
-      : etcServer.getTransactionCount
+    asset.name === 'ethereumclassic'
+      ? withFallback(etcServer.getTransactionCount, etcServer.getTransactionCount)
+      : withFallback(ethServer.getTransactionCount, etherscan.getTransactionCount)
 
   const nonce = await _getNonce(address)
   return parseInt(nonce, 16)
 }
 
 export async function estimateGas({ asset, ...args }) {
-  const useEthServer: boolean = asset.name === 'ethereum' || _isEthereumToken(asset)
-  return (useEthServer
-    ? withFallback(ethServer.estimateGas, etherscan.estimateGas)
-    : etcServer.estimateGas)(args)
+  const _estimateGas =
+    asset.name === 'ethereumclassic'
+      ? withFallback(etcServer.estimateGas, etcServer.estimateGas)
+      : withFallback(ethServer.estimateGas, etherscan.estimateGas)
+
+  return _estimateGas(args)
 }
 
-export async function getBalance({ asset, address }) {
-  const fetchEthereumBalance = withFallback(async (address) => {
-    const balances = await ethServer.getBalance(address)
-    return get(balances, 'confirmed.value', '0')
-  }, etherscan.fetchBalance)
+const fetchEthereumBalance = async (address, balanceField = 'value') => {
+  const balances = await ethServer.getBalance(address)
+  return get(balances, ['confirmed', balanceField], '0')
+}
 
-  const fetchEthereumClassicBalance = async (address) => {
-    const balances = await etcServer.getBalance(address)
-    return get(balances, 'confirmed.value', '0')
-  }
+const fetchEthereumClassicBalance = async (address) => {
+  const balances = await etcServer.getBalance(address)
+  return get(balances, 'confirmed.value', '0')
+}
+
+// Only Ethereum and Ethereumclassic, not ERC20
+export async function getBalance({ asset, address }) {
+  const _getBalance =
+    asset.name === 'ethereumclassic'
+      ? withFallback(fetchEthereumClassicBalance, fetchEthereumClassicBalance)
+      : withFallback(fetchEthereumBalance, etherscan.fetchBalance)
 
-  return (asset.name === 'ethereum' ? fetchEthereumBalance : fetchEthereumClassicBalance)(address)
+  return _getBalance(address)
 }
 
 // Only Ethereum ERC20, not Ethereumclassic
 export async function getTokenBalance({ asset, address }) {
-  const contractAddress = asset.contract.addresses.current.toLowerCase()
+  const _getTokenBalance = withFallback(
+    async (contractAddress, address) => fetchEthereumBalance(address, contractAddress),
+    etherscan.tokenBalance
+  )
 
-  return withFallback(async (contractAddress, address) => {
-    const balances = await ethServer.getBalance(address)
-    return get(balances, ['confirmed', contractAddress], '0')
-  }, etherscan.tokenBalance)(contractAddress, address)
+  const contractAddress = asset.contract.addresses.current.toLowerCase()
+  return _getTokenBalance(contractAddress, address)
 }
 
 // Returns function for supplied asset
 export function sendRawTransaction(asset) {
-  return asset.name === 'ethereum' || _isEthereumToken(asset)
-    ? withFallback(ethServer.sendRawTransaction, etherscan.sendRawTransaction)
-    : etcServer.sendRawTransaction
+  return asset.name === 'ethereumclassic'
+    ? withFallback(etcServer.sendRawTransaction, etcServer.sendRawTransaction)
+    : withFallback(ethServer.sendRawTransaction, etherscan.sendRawTransaction)
 }