@rabby-wallet/eth-simple-keyring 4.2.0 → 5.0.0-alpha

package/index.js

@@ -1,23 +1,15 @@
 const { EventEmitter } = require('events');
-const ethUtil = require('ethereumjs-util');
-const randomBytes = require('randombytes');
+// const Wallet = require('ethereumjs-wallet').default;
+const ethUtil = require('@ethereumjs/util');
+const sigUtil = require('@metamask/eth-sig-util');
+const { keccak256 } = require('ethereum-cryptography/keccak');
+const { getRandomBytesSync } = require('ethereum-cryptography/random');
 
 const type = 'Simple Key Pair';
-const {
-  concatSig,
-  decrypt,
-  getEncryptionPublicKey,
-  normalize,
-  personalSign,
-  signTypedData,
-  SignTypedDataVersion,
-} = require('@metamask/eth-sig-util');
 
 function generateKey() {
-  const privateKey = randomBytes(32);
-  // I don't think this is possible, but this validation was here previously,
-  // so it has been preserved just in case.
-  // istanbul ignore next
+  const privateKey = getRandomBytesSync(32);
+
   if (!ethUtil.isValidPrivate(privateKey)) {
     throw new Error(
       'Private key does not satisfy the curve requirements (ie. it is invalid)',
@@ -26,103 +18,192 @@ function generateKey() {
   return privateKey;
 }
 
+function add0x(hexadecimal) {
+  if (hexadecimal.startsWith('0x')) {
+    return hexadecimal;
+  }
+
+  if (hexadecimal.startsWith('0X')) {
+    return `0x${hexadecimal.substring(2)}`;
+  }
+
+  return `0x${hexadecimal}`;
+}
+
 class SimpleKeyring extends EventEmitter {
   constructor(opts) {
     super();
     this.type = type;
-    this._wallets = [];
+    this.wallets = [];
     this.deserialize(opts);
   }
 
-  async serialize() {
-    return this._wallets.map(({ privateKey }) => privateKey.toString('hex'));
+  serialize() {
+    return Promise.resolve(
+      this.wallets.map((w) =>
+        ethUtil.stripHexPrefix(ethUtil.bytesToHex(w.privateKey)),
+      ),
+    );
   }
 
-  async deserialize(privateKeys = []) {
-    this._wallets = privateKeys.map((hexPrivateKey) => {
-      const strippedHexPrivateKey = ethUtil.stripHexPrefix(hexPrivateKey);
-      const privateKey = Buffer.from(strippedHexPrivateKey, 'hex');
-      const publicKey = ethUtil.privateToPublic(privateKey);
-      return { privateKey, publicKey };
+  deserialize(privateKeys = []) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.wallets = privateKeys.map((hexPrivateKey) => {
+          let privk = hexPrivateKey;
+          if (!privk.startsWith('0x')) {
+            privk = ethUtil.addHexPrefix(privk);
+          }
+          const privateKey = ethUtil.hexToBytes(privk);
+          const publicKey = ethUtil.privateToPublic(privateKey);
+          return { privateKey, publicKey };
+        });
+      } catch (e) {
+        reject(e);
+      }
+      resolve();
     });
   }
 
-  async addAccounts(n = 1) {
+  addAccounts(n = 1) {
     const newWallets = [];
     for (let i = 0; i < n; i++) {
       const privateKey = generateKey();
-      const publicKey = ethUtil.privateToPublic(privateKey);
-      newWallets.push({ privateKey, publicKey });
+      newWallets.push({
+        privateKey,
+        publicKey: ethUtil.privateToPublic(privateKey),
+      });
     }
-    this._wallets = this._wallets.concat(newWallets);
+    this.wallets = this.wallets.concat(newWallets);
     const hexWallets = newWallets.map(({ publicKey }) =>
-      ethUtil.bufferToHex(ethUtil.publicToAddress(publicKey)),
+      add0x(ethUtil.bytesToHex(ethUtil.publicToAddress(publicKey))),
     );
-    return hexWallets;
+    return Promise.resolve(hexWallets);
   }
 
-  async getAccounts() {
-    return this._wallets.map(({ publicKey }) =>
-      ethUtil.bufferToHex(ethUtil.publicToAddress(publicKey)),
+  getAccounts() {
+    return Promise.resolve(
+      this.wallets.map(({ publicKey }) => {
+        return add0x(ethUtil.bytesToHex(ethUtil.publicToAddress(publicKey)));
+      }),
     );
   }
 
   // tx is an instance of the ethereumjs-transaction class.
-  async signTransaction(address, tx, opts = {}) {
-    const privKey = this._getPrivateKeyFor(address, opts);
-    const signedTx = tx.sign(privKey);
+  signTransaction(address, tx, opts = {}) {
+    const privKey = ethUtil.addHexPrefix(this.getPrivateKeyFor(address, opts));
+    const signedTx = tx.sign(Buffer.from(privKey, 'hex'));
     // Newer versions of Ethereumjs-tx are immutable and return a new tx object
-    return signedTx === undefined ? tx : signedTx;
+    return Promise.resolve(signedTx === undefined ? tx : signedTx);
   }
 
   // For eth_sign, we need to sign arbitrary data:
-  async signMessage(address, data, opts = {}) {
+  signMessage(address, data, opts = {}) {
     const message = ethUtil.stripHexPrefix(data);
-    const privKey = this._getPrivateKeyFor(address, opts);
+    const privKey = this.getPrivateKeyFor(address, opts);
     const msgSig = ethUtil.ecsign(Buffer.from(message, 'hex'), privKey);
-    const rawMsgSig = concatSig(msgSig.v, msgSig.r, msgSig.s);
-    return rawMsgSig;
+    const rawMsgSig = sigUtil.concatSig(msgSig.v, msgSig.r, msgSig.s);
+    return Promise.resolve(rawMsgSig);
+  }
+
+  // For eth_sign, we need to sign transactions:
+  newGethSignMessage(withAccount, msgHex, opts = {}) {
+    const privKey = this.getPrivateKeyFor(withAccount, opts);
+    const msgBuffer = ethUtil.toBuffer(msgHex);
+    const msgHash = ethUtil.hashPersonalMessage(msgBuffer);
+    const msgSig = ethUtil.ecsign(msgHash, privKey);
+    const rawMsgSig = sigUtil.concatSig(msgSig.v, msgSig.r, msgSig.s);
+    return Promise.resolve(rawMsgSig);
   }
 
   // For personal_sign, we need to prefix the message:
-  async signPersonalMessage(address, msgHex, opts = {}) {
-    const privKey = this._getPrivateKeyFor(address, opts);
-    const privateKey = Buffer.from(privKey, 'hex');
-    const sig = personalSign({ privateKey, data: msgHex });
-    return sig;
+  signPersonalMessage(address, msgHex, opts = {}) {
+    const privKey = ethUtil.stripHexPrefix(
+      ethUtil.bytesToHex(this.getPrivateKeyFor(address, opts)),
+    );
+    const sig = sigUtil.personalSign({
+      privateKey: privKey,
+      data: msgHex,
+    });
+    return Promise.resolve(sig);
   }
 
   // For eth_decryptMessage:
-  async decryptMessage(withAccount, encryptedData) {
+  decryptMessage(withAccount, encryptedData) {
     const wallet = this._getWalletForAccount(withAccount);
-    const privateKey = ethUtil.stripHexPrefix(wallet.privateKey);
-    const sig = decrypt({ privateKey, encryptedData });
-    return sig;
+    const privKey = ethUtil.stripHexPrefix(
+      ethUtil.bytesToHex(wallet.privateKey),
+    );
+    const sig = sigUtil.decrypt({
+      encryptedData,
+      privateKey: privKey,
+    });
+    return Promise.resolve(sig);
   }
 
   // personal_signTypedData, signs data along with the schema
-  async signTypedData(
-    withAccount,
-    typedData,
-    opts = { version: SignTypedDataVersion.V1 },
-  ) {
-    // Treat invalid versions as "V1"
-    const version = Object.keys(SignTypedDataVersion).includes(opts.version)
-      ? opts.version
-      : SignTypedDataVersion.V1;
+  signTypedData(withAccount, typedData, opts = { version: 'V1' }) {
+    switch (opts.version) {
+      case 'V1':
+        return this.signTypedData_v1(withAccount, typedData, opts);
+      case 'V3':
+        return this.signTypedData_v3(withAccount, typedData, opts);
+      case 'V4':
+        return this.signTypedData_v4(withAccount, typedData, opts);
+      default:
+        return this.signTypedData_v1(withAccount, typedData, opts);
+    }
+  }
 
-    const privateKey = this._getPrivateKeyFor(withAccount, opts);
-    return signTypedData({ privateKey, data: typedData, version });
+  // personal_signTypedData, signs data along with the schema
+  signTypedData_v1(withAccount, typedData, opts = {}) {
+    const privKey = ethUtil.stripHexPrefix(
+      ethUtil.bytesToHex(this.getPrivateKeyFor(withAccount, opts)),
+    );
+    const sig = sigUtil.signTypedData({
+      privateKey: Buffer.from(privKey, 'hex'),
+      data: typedData,
+      version: sigUtil.SignTypedDataVersion.V1,
+    });
+    return Promise.resolve(sig);
+  }
+
+  // personal_signTypedData, signs data along with the schema
+  signTypedData_v3(withAccount, typedData, opts = {}) {
+    const privKey = ethUtil.stripHexPrefix(
+      ethUtil.bytesToHex(this.getPrivateKeyFor(withAccount, opts)),
+    );
+    const sig = sigUtil.signTypedData({
+      privateKey: Buffer.from(privKey, 'hex'),
+      data: typedData,
+      version: sigUtil.SignTypedDataVersion.V3,
+    });
+    return Promise.resolve(sig);
+  }
+
+  // personal_signTypedData, signs data along with the schema
+  signTypedData_v4(withAccount, typedData, opts = {}) {
+    const privKey = ethUtil.stripHexPrefix(
+      ethUtil.bytesToHex(this.getPrivateKeyFor(withAccount, opts)),
+    );
+    const sig = sigUtil.signTypedData({
+      privateKey: Buffer.from(privKey, 'hex'),
+      data: typedData,
+      version: sigUtil.SignTypedDataVersion.V4,
+    });
+    return Promise.resolve(sig);
   }
 
   // get public key for nacl
-  async getEncryptionPublicKey(withAccount, opts = {}) {
-    const privKey = this._getPrivateKeyFor(withAccount, opts);
-    const publicKey = getEncryptionPublicKey(privKey);
-    return publicKey;
+  getEncryptionPublicKey(withAccount, opts = {}) {
+    const privKey = ethUtil.stripHexPrefix(
+      ethUtil.bytesToHex(this.getPrivateKeyFor(withAccount, opts)),
+    );
+    const publicKey = sigUtil.getEncryptionPublicKey(privKey);
+    return Promise.resolve(publicKey);
   }
 
-  _getPrivateKeyFor(address, opts = {}) {
+  getPrivateKeyFor(address, opts = {}) {
     if (!address) {
       throw new Error('Must specify address.');
     }
@@ -131,41 +212,49 @@ class SimpleKeyring extends EventEmitter {
   }
 
   // returns an address specific to an app
-  async getAppKeyAddress(address, origin) {
+  getAppKeyAddress(address, origin) {
     if (!origin || typeof origin !== 'string') {
       throw new Error(`'origin' must be a non-empty string`);
     }
-    const wallet = this._getWalletForAccount(address, {
-      withAppKeyOrigin: origin,
+    return new Promise((resolve, reject) => {
+      try {
+        const wallet = this._getWalletForAccount(address, {
+          withAppKeyOrigin: origin,
+        });
+        const appKeyAddress = sigUtil.normalize(
+          ethUtil.bytesToHex(ethUtil.publicToAddress(wallet.publicKey)),
+        );
+        return resolve(appKeyAddress);
+      } catch (e) {
+        return reject(e);
+      }
     });
-    const appKeyAddress = normalize(
-      ethUtil.publicToAddress(wallet.publicKey).toString('hex'),
-    );
-    return appKeyAddress;
   }
 
   // exportAccount should return a hex-encoded private key:
-  async exportAccount(address, opts = {}) {
+  exportAccount(address, opts = {}) {
     const wallet = this._getWalletForAccount(address, opts);
-    return wallet.privateKey.toString('hex');
+    return Promise.resolve(ethUtil.bytesToHex(wallet.privateKey));
   }
 
   removeAccount(address) {
     if (
-      !this._wallets
+      !this.wallets
         .map(({ publicKey }) =>
-          ethUtil.bufferToHex(ethUtil.publicToAddress(publicKey)).toLowerCase(),
+          add0x(
+            ethUtil.bytesToHex(ethUtil.publicToAddress(publicKey)),
+          ).toLowerCase(),
         )
         .includes(address.toLowerCase())
     ) {
       throw new Error(`Address ${address} not found in this keyring`);
     }
 
-    this._wallets = this._wallets.filter(
+    this.wallets = this.wallets.filter(
       ({ publicKey }) =>
-        ethUtil
-          .bufferToHex(ethUtil.publicToAddress(publicKey))
-          .toLowerCase() !== address.toLowerCase(),
+        add0x(
+          ethUtil.bytesToHex(ethUtil.publicToAddress(publicKey)),
+        ).toLowerCase() !== address.toLowerCase(),
     );
   }
 
@@ -173,10 +262,12 @@ class SimpleKeyring extends EventEmitter {
    * @private
    */
   _getWalletForAccount(account, opts = {}) {
-    const address = normalize(account);
-    let wallet = this._wallets.find(
+    const address = sigUtil.normalize(account);
+    let wallet = this.wallets.find(
       ({ publicKey }) =>
-        ethUtil.bufferToHex(ethUtil.publicToAddress(publicKey)) === address,
+        add0x(
+          ethUtil.bytesToHex(ethUtil.publicToAddress(publicKey)),
+        ).toLowerCase() === address.toLowerCase(),
     );
     if (!wallet) {
       throw new Error('Simple Keyring - Unable to find matching address.');
@@ -186,7 +277,7 @@ class SimpleKeyring extends EventEmitter {
       const { privateKey } = wallet;
       const appKeyOriginBuffer = Buffer.from(opts.withAppKeyOrigin, 'utf8');
       const appKeyBuffer = Buffer.concat([privateKey, appKeyOriginBuffer]);
-      const appKeyPrivateKey = ethUtil.keccak(appKeyBuffer, 256);
+      const appKeyPrivateKey = keccak256(appKeyBuffer);
       const appKeyPublicKey = ethUtil.privateToPublic(appKeyPrivateKey);
       wallet = { privateKey: appKeyPrivateKey, publicKey: appKeyPublicKey };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/eth-simple-keyring",
-  "version": "4.2.0",
+  "version": "5.0.0-alpha",
   "description": "A simple standard interface for a series of Ethereum private keys.",
   "keywords": [
     "ethereum",
@@ -30,8 +30,15 @@
     "lint:fix": "yarn lint:eslint --fix && yarn lint:misc --write"
   },
   "dependencies": {
-    "@metamask/eth-sig-util": "^4.0.0",
+    "@ethereumjs/util": "^9.0.0",
+    "@metamask/eth-sig-util": "^7.0.0",
+    "@metamask/utils": "^8.1.0",
+    "chai": "^4.3.4",
+    "eth-sig-util": "^3.0.1",
+    "ethereum-cryptography": "^2.1.2",
+    "ethereumjs-tx": "^2.1.2",
     "ethereumjs-util": "^7.0.9",
+    "ethereumjs-wallet": "^1.0.2",
     "randombytes": "^2.1.0"
   },
   "devDependencies": {

package/CHANGELOG.md

@@ -1,9 +0,0 @@
-# Changelog
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-[Unreleased]: https://github.com/MetaMask/eth-simple-keyring/