@exodus/ethereum-lib 0.0.9 → 0.2.0

package/src/abi/dai.js

@@ -0,0 +1,348 @@
+export default [
+  {
+    inputs: [{ internalType: 'uint256', name: 'chainId_', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'constructor',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: 'address', name: 'src', type: 'address' },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'guy',
+        type: 'address',
+      },
+      { indexed: false, internalType: 'uint256', name: 'wad', type: 'uint256' },
+    ],
+    name: 'Approval',
+    type: 'event',
+  },
+  {
+    anonymous: true,
+    inputs: [
+      { indexed: true, internalType: 'bytes4', name: 'sig', type: 'bytes4' },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'usr',
+        type: 'address',
+      },
+      { indexed: true, internalType: 'bytes32', name: 'arg1', type: 'bytes32' },
+      {
+        indexed: true,
+        internalType: 'bytes32',
+        name: 'arg2',
+        type: 'bytes32',
+      },
+      { indexed: false, internalType: 'bytes', name: 'data', type: 'bytes' },
+    ],
+    name: 'LogNote',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: 'address', name: 'src', type: 'address' },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'dst',
+        type: 'address',
+      },
+      { indexed: false, internalType: 'uint256', name: 'wad', type: 'uint256' },
+    ],
+    name: 'Transfer',
+    type: 'event',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'DOMAIN_SEPARATOR',
+    outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'PERMIT_TYPEHASH',
+    outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [
+      { internalType: 'address', name: '', type: 'address' },
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    name: 'allowance',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'usr', type: 'address' },
+      {
+        internalType: 'uint256',
+        name: 'wad',
+        type: 'uint256',
+      },
+    ],
+    name: 'approve',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [{ internalType: 'address', name: '', type: 'address' }],
+    name: 'balanceOf',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'usr', type: 'address' },
+      {
+        internalType: 'uint256',
+        name: 'wad',
+        type: 'uint256',
+      },
+    ],
+    name: 'burn',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'decimals',
+    outputs: [{ internalType: 'uint8', name: '', type: 'uint8' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [{ internalType: 'address', name: 'guy', type: 'address' }],
+    name: 'deny',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'usr', type: 'address' },
+      {
+        internalType: 'uint256',
+        name: 'wad',
+        type: 'uint256',
+      },
+    ],
+    name: 'mint',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'src', type: 'address' },
+      {
+        internalType: 'address',
+        name: 'dst',
+        type: 'address',
+      },
+      { internalType: 'uint256', name: 'wad', type: 'uint256' },
+    ],
+    name: 'move',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'name',
+    outputs: [{ internalType: 'string', name: '', type: 'string' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [{ internalType: 'address', name: '', type: 'address' }],
+    name: 'nonces',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'holder', type: 'address' },
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      { internalType: 'uint256', name: 'nonce', type: 'uint256' },
+      {
+        internalType: 'uint256',
+        name: 'expiry',
+        type: 'uint256',
+      },
+      { internalType: 'bool', name: 'allowed', type: 'bool' },
+      {
+        internalType: 'uint8',
+        name: 'v',
+        type: 'uint8',
+      },
+      { internalType: 'bytes32', name: 'r', type: 'bytes32' },
+      {
+        internalType: 'bytes32',
+        name: 's',
+        type: 'bytes32',
+      },
+    ],
+    name: 'permit',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'usr', type: 'address' },
+      {
+        internalType: 'uint256',
+        name: 'wad',
+        type: 'uint256',
+      },
+    ],
+    name: 'pull',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'usr', type: 'address' },
+      {
+        internalType: 'uint256',
+        name: 'wad',
+        type: 'uint256',
+      },
+    ],
+    name: 'push',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [{ internalType: 'address', name: 'guy', type: 'address' }],
+    name: 'rely',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'symbol',
+    outputs: [{ internalType: 'string', name: '', type: 'string' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'totalSupply',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'dst', type: 'address' },
+      {
+        internalType: 'uint256',
+        name: 'wad',
+        type: 'uint256',
+      },
+    ],
+    name: 'transfer',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      { internalType: 'address', name: 'src', type: 'address' },
+      {
+        internalType: 'address',
+        name: 'dst',
+        type: 'address',
+      },
+      { internalType: 'uint256', name: 'wad', type: 'uint256' },
+    ],
+    name: 'transferFrom',
+    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'version',
+    outputs: [{ internalType: 'string', name: '', type: 'string' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [{ internalType: 'address', name: '', type: 'address' }],
+    name: 'wards',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+]

package/src/abi/index.js

@@ -0,0 +1,7 @@
+import cdai from './cdai'
+import dai from './dai'
+
+export default {
+  cdai,
+  dai,
+}

package/src/constants.js

@@ -0,0 +1 @@
+export const CHAIN_IDS = { ethereum: 1, ethereumclassic: 61 }

package/src/create-contract/erc20.js

@@ -0,0 +1,77 @@
+import ethUtil from 'ethereumjs-util'
+
+// TODO: migrate to using solidity-contract
+export default function createContract(addresses, currency) {
+  // First 4 bytes of Keccak256('transfer(address,uint256)')
+  // const TRANSFER_METHOD_ID = ethUtil.bufferToHex(ethUtil.sha3('transfer(address,uint256)').slice(0, 4))
+  const TRANSFER_METHOD_ID = '0xa9059cbb'
+
+  // Keccak256('Transfer(address,address,uint256)')
+  // const TRANSFER_EVENT_ID = ethUtil.bufferToHex(ethUtil.sha3('Transfer(address,address,uint256)'))
+  const TRANSFER_EVENT_ID = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+
+  const transfer = {
+    METHOD_ID: TRANSFER_METHOD_ID,
+    EVENT_ID: TRANSFER_EVENT_ID,
+
+    build(to, bufAmount) {
+      return Buffer.concat([
+        ethUtil.toBuffer(TRANSFER_METHOD_ID),
+        ethUtil.zeros(12),
+        ethUtil.toBuffer(to),
+        ethUtil.zeros(32 - bufAmount.length),
+        bufAmount,
+      ])
+    },
+
+    test(data) {
+      return ethUtil.bufferToHex(data.slice(0, 4)) === TRANSFER_METHOD_ID
+    },
+
+    parse(data) {
+      if (!transfer.test(data)) throw new Error('It is not transfer data')
+
+      return {
+        to: ethUtil.bufferToHex(data.slice(16, 36)),
+        amount: currency.baseUnit(ethUtil.bufferToHex(data.slice(36, 68))),
+      }
+    },
+  }
+
+  // ethUtil.bufferToHex(ethUtil.sha3('approve(address,uint256)').slice(0, 4))
+  const APPROVE_METHOD_ID = '0x095ea7b3'
+
+  // TODO: not verified:
+  // ethUtil.bufferToHex(ethUtil.sha3('Approve(address,address,uint256)'))
+  const APPROVE_EVENT_ID = '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925'
+
+  const approve = {
+    METHOD_ID: APPROVE_METHOD_ID,
+    EVENT_ID: APPROVE_EVENT_ID,
+
+    build(address, bufAmount) {
+      return Buffer.concat([
+        ethUtil.toBuffer(APPROVE_METHOD_ID),
+        ethUtil.zeros(12),
+        ethUtil.toBuffer(address),
+        ethUtil.zeros(32 - bufAmount.length),
+        bufAmount,
+      ])
+    },
+
+    test(data) {
+      return ethUtil.bufferToHex(data.slice(0, 4)) === APPROVE_METHOD_ID
+    },
+
+    parse(data) {
+      if (!approve.test(data)) throw new Error('It is not approve data')
+
+      return {
+        address: ethUtil.bufferToHex(data.slice(16, 36)),
+        amount: currency.baseUnit(ethUtil.bufferToHex(data.slice(36, 68))),
+      }
+    },
+  }
+
+  return { addresses, transfer, approve }
+}

package/src/create-contract/index.js

@@ -0,0 +1,8 @@
+import createContractErc20 from './erc20'
+
+export default function createContract(addresses, currency, assetName) {
+  switch (assetName) {
+    default:
+      return createContractErc20(addresses, currency)
+  }
+}

package/src/encode.js

@@ -0,0 +1,36 @@
+import etherUtil from 'ethereumjs-util'
+
+export function validate(address) {
+  if (typeof address !== 'string') return false
+
+  // https://github.com/ethereumjs/ethereumjs-util/issues/54
+  if (address.slice(0, 2) !== '0x' || address.length !== 42) return false
+
+  if (!hasChecksum(address)) return true
+  return etherUtil.isValidChecksumAddress(address)
+}
+
+export function hasChecksum(address) {
+  if (/^0x[0-9A-F]{40}$/.test(address) || /^0x[0-9a-f]{40}$/.test(address)) return false
+  return true
+}
+
+export function encodePrivate(privKey) {
+  return '0x' + privKey.toString('hex')
+}
+
+export function encodePublic(compressedPubKey) {
+  const hash160bits = etherUtil.publicToAddress(compressedPubKey, true)
+  return etherUtil.toChecksumAddress(hash160bits.toString('hex'))
+}
+
+export function isValidPrivate(privateKey) {
+  if (privateKey.length !== 32 || !etherUtil.isValidPrivate(privateKey)) {
+    return false
+  }
+  return true
+}
+
+export function encodePublicFromPrivate(privateKey) {
+  return etherUtil.toChecksumAddress(etherUtil.privateToAddress(privateKey).toString('hex'))
+}

package/src/fee-data/ethereum.js

@@ -0,0 +1,11 @@
+import { FeeData } from '@exodus/asset-lib'
+
+export default new FeeData(
+  {
+    gasPrice: '20 Gwei',
+    max: '250 Gwei',
+    min: '1 Gwei',
+  },
+  'gasPrice',
+  'ethereum'
+)

package/src/fee-data/ethereumclassic.js

@@ -0,0 +1,11 @@
+import { FeeData } from '@exodus/asset-lib'
+
+export default new FeeData(
+  {
+    gasPrice: '20 Gwei',
+    max: '250 Gwei',
+    min: '1 Gwei',
+  },
+  'gasPrice',
+  'ethereumclassic'
+)

package/src/fee-data/index.js

@@ -0,0 +1,2 @@
+export { default as ethereum } from './ethereum'
+export { default as ethereumclassic } from './ethereumclassic'

package/src/index.js

@@ -0,0 +1,8 @@
+import createContract from './create-contract'
+import ABI from './abi'
+
+export { createContract, ABI }
+export * from './encode'
+export * from './unsigned-tx'
+export * from './utils'
+export * from './constants'

package/src/unsigned-tx/create-and-sign-tx.js

@@ -0,0 +1,13 @@
+/* @flow */
+import createUnsignedTx from './create-unsigned-tx'
+import signUnsignedTx from './sign-unsigned-tx'
+
+import type { ParsedTransaction, SignedTransaction } from '@exodus/models/lib/types'
+
+export default function createAndSignTx(
+  input: ParsedTransaction,
+  privateKey: Buffer
+): SignedTransaction {
+  const unsignedTx = createUnsignedTx(input)
+  return signUnsignedTx(unsignedTx, privateKey)
+}

package/src/unsigned-tx/create-unsigned-tx.js

@@ -0,0 +1,62 @@
+import ethUtil from 'ethereumjs-util'
+import { _isEthereumToken, currency2buffer } from '../utils'
+import { CHAIN_IDS } from '../constants'
+
+import type { UnsignedTransaction } from '#/app-models'
+
+export default function createUnsignedTx({
+  baseAsset,
+  asset,
+  address,
+  amount,
+  nonce,
+  txInput,
+  gasLimit,
+  gasPrice,
+  privateKey,
+  fromAddress,
+  chainId,
+}): UnsignedTransaction {
+  if (txInput) {
+    txInput = ethUtil.toBuffer(txInput) // If txInput is already a Buffer, then it is passed through
+  } else {
+    txInput = Buffer.alloc(0)
+  }
+
+  if (!chainId) chainId = CHAIN_IDS[baseAsset.name] // mainnet
+
+  const isEthereumToken = _isEthereumToken(asset)
+  const to = isEthereumToken ? asset.contract.addresses.current : address
+  let value = currency2buffer(isEthereumToken ? baseAsset.currency.ZERO : amount)
+
+  // TODO: check: present on desktop missing on mobile. This insures we never have a buffer specifying 0.
+  // In ETH, a buffer of zero length and a buffer specifying 0 imply different things
+  if (value.equals(Buffer.from([0]))) value = Buffer.alloc(0)
+
+  if (!fromAddress) {
+    if (privateKey) fromAddress = ethUtil.bufferToHex(ethUtil.privateToAddress(privateKey))
+    else throw new Error('createTx: Must pass fromAddress or privateKey in options')
+  }
+
+  const txData = {
+    nonce: nonce === 0 ? Buffer.alloc(0) : ethUtil.intToBuffer(nonce), // mobile: { nonce: ethUtil.intToBuffer(nonce) }
+    gasPrice: currency2buffer(gasPrice.toBase()), // mobile: { gasPrice: currency2buffer(gasPrice) }
+    gasLimit: ethUtil.intToBuffer(gasLimit),
+    to,
+    value,
+    data: txInput,
+    chainId,
+  }
+
+  const txMeta = {
+    assetName: asset.name,
+    // TODO: We should move away from putting the PK into txMeta, it is a bad practice. It is a potential PK exposure risk if the wrong PK gets included here.
+    privateKey, // Used for importing private key
+    fee: baseAsset.currency.baseUnit(gasPrice.toBase().toNumber() * gasLimit),
+  }
+
+  return {
+    txData,
+    txMeta,
+  }
+}

package/src/unsigned-tx/index.js

@@ -0,0 +1,4 @@
+export { default as createUnsignedTx } from './create-unsigned-tx'
+export { default as parseUnsignedTx } from './parse-unsigned-tx'
+export { default as signUnsignedTx } from './sign-unsigned-tx'
+export { default as createAndSignTx } from './create-and-sign-tx'

package/src/unsigned-tx/parse-unsigned-tx.js

@@ -0,0 +1,44 @@
+/* @flow */
+import * as ethUtil from 'ethereumjs-util'
+import assets from '@exodus/assets'
+import { _isEthereumToken, buffer2currency } from '../utils'
+import { CHAIN_IDS } from '../constants'
+
+import type { UnsignedTransaction, ParsedTransaction } from '@exodus/models/lib/types'
+
+export default function parseUnsignedTx(unsignedTx: UnsignedTransaction): ParsedTransaction {
+  const {
+    txData,
+    txMeta: { assetName },
+  } = unsignedTx
+  const asset = assets[assetName]
+  const isEthereumToken = _isEthereumToken(asset)
+  const baseAsset = isEthereumToken ? assets.ethereum : asset
+
+  const gasPrice = buffer2currency({ asset: baseAsset, value: txData.gasPrice })
+  const gasLimit = ethUtil.bufferToInt(txData.gasLimit)
+
+  let { to, chainId, data } = txData
+  let amount
+  const fee = gasPrice.mul(gasLimit)
+  if (isEthereumToken) {
+    const parsed = asset.contract.transfer.parse(data)
+    to = parsed.to
+    amount = parsed.amount
+  } else {
+    amount = buffer2currency({ asset: baseAsset, value: txData.value })
+  }
+
+  if (chainId !== CHAIN_IDS[baseAsset.name]) {
+    throw new Error(`invalid chainId ${chainId} for asset ${assetName}`)
+  }
+
+  return {
+    baseAsset,
+    asset,
+    from: null, // TODO: how?
+    to,
+    amount,
+    fee,
+  }
+}

package/src/unsigned-tx/sign-unsigned-tx.js

@@ -0,0 +1,19 @@
+/* @flow */
+import EthereumTx from 'ethereumjs-tx'
+
+import type { UnsignedTransaction, SignedTransaction } from '@exodus/models/lib/types'
+
+export default function signUnsignedTx(
+  unsignedTx: UnsignedTransaction,
+  privateKey: Buffer
+): SignedTransaction {
+  const { txData } = unsignedTx
+
+  const tx = new EthereumTx(txData)
+  tx.sign(privateKey)
+
+  // serialize and get txId
+  const rawTx = tx.serialize()
+  const txId = tx.hash().toString('hex')
+  return { rawTx, txId }
+}

package/src/utils.js

@@ -0,0 +1,28 @@
+import baseX from 'base-x'
+import * as ethUtil from 'ethereumjs-util'
+
+const base10 = baseX('0123456789')
+const base16 = baseX('0123456789abcdef')
+
+export const _isEthereumToken = (asset) => asset.assetType === 'ETHEREUM_ERC20'
+
+export function buffer2currency({ asset, value }) {
+  return asset.currency.baseUnit(base10.encode(value)).toDefault()
+}
+
+export function currency2buffer(value) {
+  const b10Value = value
+    .toBase()
+    .floor() // probably not necessary, but to be safe
+    .toString({ unit: false })
+
+  // Desktop: const hexValue = value.toBase()._number.toString(16)
+  const hexValue = base16.encode(base10.decode(b10Value))
+
+  if (hexValue.includes('.')) {
+    // <-- probably not necessary anymore
+    throw new RangeError(`${value.toBase().toString()} can not be converted to Buffer`)
+  }
+
+  return Buffer.from(ethUtil.padToEven(hexValue), 'hex')
+}