@exodus/ethereum-lib 0.0.6 → 0.0.8

package/lib/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CHAIN_IDS = void 0;
+const CHAIN_IDS = {
+  ethereum: 1,
+  ethereumclassic: 61
+};
+exports.CHAIN_IDS = CHAIN_IDS;

package/lib/encode.js

@@ -4,8 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.validate = validate;
+exports.hasChecksum = hasChecksum;
 exports.encodePrivate = encodePrivate;
 exports.encodePublic = encodePublic;
+exports.isValidPrivate = isValidPrivate;
+exports.encodePublicFromPrivate = encodePublicFromPrivate;
 
 var _ethereumjsUtil = _interopRequireDefault(require("ethereumjs-util"));
 
@@ -15,10 +18,15 @@ 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 (/^0x[0-9A-F]{40}$/.test(address) || /^0x[0-9a-f]{40}$/.test(address)) return true;
+  if (!hasChecksum(address)) return true;
   return _ethereumjsUtil.default.isValidChecksumAddress(address);
 }
 
+function hasChecksum(address) {
+  if (/^0x[0-9A-F]{40}$/.test(address) || /^0x[0-9a-f]{40}$/.test(address)) return false;
+  return true;
+}
+
 function encodePrivate(privKey) {
   return '0x' + privKey.toString('hex');
 }
@@ -27,4 +35,16 @@ function encodePublic(compressedPubKey) {
   const hash160bits = _ethereumjsUtil.default.publicToAddress(compressedPubKey, true);
 
   return _ethereumjsUtil.default.toChecksumAddress(hash160bits.toString('hex'));
+}
+
+function isValidPrivate(privateKey) {
+  if (privateKey.length !== 32 || !_ethereumjsUtil.default.isValidPrivate(privateKey)) {
+    return false;
+  }
+
+  return true;
+}
+
+function encodePublicFromPrivate(privateKey) {
+  return _ethereumjsUtil.default.toChecksumAddress(_ethereumjsUtil.default.privateToAddress(privateKey).toString('hex'));
 }

package/lib/index.js

@@ -37,4 +37,43 @@ Object.keys(_encode).forEach(function (key) {
   });
 });
 
+var _unsignedTx = require("./unsigned-tx");
+
+Object.keys(_unsignedTx).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _unsignedTx[key];
+    }
+  });
+});
+
+var _utils = require("./utils");
+
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+
+var _constants = require("./constants");
+
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createAndSignTx;
+
+var _createUnsignedTx = _interopRequireDefault(require("./create-unsigned-tx"));
+
+var _signUnsignedTx = _interopRequireDefault(require("./sign-unsigned-tx"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createAndSignTx(input, privateKey) {
+  const unsignedTx = (0, _createUnsignedTx.default)(input);
+  return (0, _signUnsignedTx.default)(unsignedTx, privateKey);
+}

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

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createUnsignedTx;
+
+var _ethereumjsUtil = _interopRequireDefault(require("ethereumjs-util"));
+
+var _utils = require("../utils");
+
+var _constants = require("../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createUnsignedTx({
+  baseAsset,
+  asset,
+  address,
+  amount,
+  nonce,
+  txInput,
+  gasLimit,
+  gasPrice,
+  privateKey,
+  fromAddress,
+  chainId
+}) {
+  if (txInput) {
+    txInput = _ethereumjsUtil.default.toBuffer(txInput); // If txInput is already a Buffer, then it is passed through
+  } else {
+    txInput = Buffer.alloc(0);
+  }
+
+  if (!chainId) chainId = _constants.CHAIN_IDS[baseAsset.name]; // mainnet
+
+  const isEthereumToken = (0, _utils._isEthereumToken)(asset);
+  const to = isEthereumToken ? asset.contract.addresses.current : address;
+  let value = (0, _utils.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 = _ethereumjsUtil.default.bufferToHex(_ethereumjsUtil.default.privateToAddress(privateKey));else throw new Error('createTx: Must pass fromAddress or privateKey in options');
+  }
+
+  const txData = {
+    nonce: nonce === 0 ? Buffer.alloc(0) : _ethereumjsUtil.default.intToBuffer(nonce),
+    // mobile: { nonce: ethUtil.intToBuffer(nonce) }
+    gasPrice: (0, _utils.currency2buffer)(gasPrice.toBase()),
+    // mobile: { gasPrice: currency2buffer(gasPrice) }
+    gasLimit: _ethereumjsUtil.default.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/lib/unsigned-tx/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createUnsignedTx", {
+  enumerable: true,
+  get: function () {
+    return _createUnsignedTx.default;
+  }
+});
+Object.defineProperty(exports, "parseUnsignedTx", {
+  enumerable: true,
+  get: function () {
+    return _parseUnsignedTx.default;
+  }
+});
+Object.defineProperty(exports, "signUnsignedTx", {
+  enumerable: true,
+  get: function () {
+    return _signUnsignedTx.default;
+  }
+});
+Object.defineProperty(exports, "createAndSignTx", {
+  enumerable: true,
+  get: function () {
+    return _createAndSignTx.default;
+  }
+});
+
+var _createUnsignedTx = _interopRequireDefault(require("./create-unsigned-tx"));
+
+var _parseUnsignedTx = _interopRequireDefault(require("./parse-unsigned-tx"));
+
+var _signUnsignedTx = _interopRequireDefault(require("./sign-unsigned-tx"));
+
+var _createAndSignTx = _interopRequireDefault(require("./create-and-sign-tx"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseUnsignedTx;
+
+var ethUtil = _interopRequireWildcard(require("ethereumjs-util"));
+
+var _assets = _interopRequireDefault(require("@exodus/assets"));
+
+var _utils = require("../utils");
+
+var _constants = require("../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function parseUnsignedTx(unsignedTx) {
+  const {
+    txData,
+    txMeta: {
+      assetName
+    }
+  } = unsignedTx;
+  const asset = _assets.default[assetName];
+  const isEthereumToken = (0, _utils._isEthereumToken)(asset);
+  const baseAsset = isEthereumToken ? _assets.default.ethereum : asset;
+  const gasPrice = (0, _utils.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 = (0, _utils.buffer2currency)({
+      asset: baseAsset,
+      value: txData.value
+    });
+  }
+
+  if (chainId !== _constants.CHAIN_IDS[baseAsset.name]) {
+    throw new Error(`invalid chainId ${chainId} for asset ${assetName}`);
+  }
+
+  return {
+    baseAsset,
+    asset,
+    from: null,
+    // TODO: how?
+    to,
+    amount,
+    fee
+  };
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = signUnsignedTx;
+
+var _ethereumjsTx = _interopRequireDefault(require("ethereumjs-tx"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function signUnsignedTx(unsignedTx, privateKey) {
+  const {
+    txData
+  } = unsignedTx;
+  const tx = new _ethereumjsTx.default(txData);
+  tx.sign(privateKey); // serialize and get txId
+
+  const rawTx = tx.serialize();
+  const txId = tx.hash().toString('hex');
+  return {
+    rawTx,
+    txId
+  };
+}

package/lib/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buffer2currency = buffer2currency;
+exports.currency2buffer = currency2buffer;
+exports._isEthereumToken = void 0;
+
+var _baseX = _interopRequireDefault(require("base-x"));
+
+var ethUtil = _interopRequireWildcard(require("ethereumjs-util"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const base10 = (0, _baseX.default)('0123456789');
+const base16 = (0, _baseX.default)('0123456789abcdef');
+
+const _isEthereumToken = asset => asset.assetType === 'ETHEREUM_ERC20';
+
+exports._isEthereumToken = _isEthereumToken;
+
+function buffer2currency({
+  asset,
+  value
+}) {
+  return asset.currency.baseUnit(base10.encode(value)).toDefault();
+}
+
+function currency2buffer(value) {
+  const b10Value = value.toBase().floor() // probably not necessary, but to be safe
+  .toString({
+    unit: false
+  });
+  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');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-lib",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Ethereum Library",
   "main": "lib/index.js",
   "files": [
@@ -14,10 +14,13 @@
   },
   "dependencies": {
     "@exodus/asset-lib": "^3.2.0",
+    "@exodus/models": "^8.2.0",
+    "base-x": "3.0.4",
+    "ethereumjs-tx": "1.3.7",
     "ethereumjs-util": "5.2.0"
   },
   "devDependencies": {
-    "@exodus/assets": "^6.0.0"
+    "@exodus/assets": "8.0.x"
   },
-  "gitHead": "99f75125595d161960a0c1f0708505b72d9c296f"
+  "gitHead": "c4340f5add8720d732046aa58488b71cdc092678"
 }