@theqrl/wallet.js 0.0.1 → 0.1.1

package/README.md

@@ -0,0 +1,6 @@
+# wallet.js
+
+![test](https://github.com/theQRL/wallet.js/actions/workflows/test.yml/badge.svg)
+[![codecov](https://codecov.io/gh/theQRL/wallet.js/branch/main/graph/badge.svg?token=HHVBFBVGFR)](https://codecov.io/gh/theQRL/wallet.js)
+
+WIP helper library for QRL Dilithium wallet

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@theqrl/wallet.js",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "description": "",
-  "main": "src/index.js",
+  "main": "src/dilithium.js",
   "scripts": {
     "test": "mocha",
     "lint-check": "eslint 'src/**/*.js' 'test/**/*.js'",
-    "lint": "eslint --fix 'src/**/*.js' 'test/**/*.js'"
+    "lint": "eslint --fix 'src/**/*.js' 'test/**/*.js'",
+    "report-coverage": "c8 --reporter=text-lcov npm run test > coverage.lcov",
+    "coverage": "c8 npm run test"
   },
   "author": "QRL contributors <info@theqrl.org> (https://theqrl.org)",
   "license": "MIT",
   "dependencies": {
-    "@theqrl/dilithium5": "0.0.6",
+    "@theqrl/dilithium5": "^0.0.9",
     "randombytes": "^2.1.0",
     "sha3": "^2.1.4"
   },
-  "type": "module",
   "directories": {
     "lib": "src",
     "test": "test"
@@ -24,7 +25,15 @@
     "src"
   ],
   "devDependencies": {
+    "c8": "^7.13.0",
     "chai": "^4.3.7",
-    "mocha": "^10.2.0"
+    "codecov": "^3.8.3",
+    "eslint": "^8.37.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.7"
   }
 }

package/src/dilithium.js

@@ -1,176 +1,158 @@
-import pkg from 'randombytes';  // eslint-disable-line import/no-extraneous-dependencies
-import { SHAKE } from 'sha3'; // eslint-disable-line import/no-extraneous-dependencies
-import { cryptoSign, cryptoSignKeypair, cryptoSignOpen, cryptoSignVerify, cryptoSignSignature, CryptoPublicKeyBytes, CryptoSecretKeyBytes, SeedBytes, CryptoBytes } from '@theqrl/dilithium5';
-import { SeedBinToMnemonic } from './utils/mnemonic.js';
-const randomBytes = pkg;
-
-function New() {
-    var pk = new Uint8Array(CryptoPublicKeyBytes);
-    var sk = new Uint8Array(CryptoSecretKeyBytes);
+const { SHAKE } = require('sha3');
+const randomBytes = require('randombytes');
+
+const {
+  cryptoSign,
+  cryptoSignKeypair,
+  cryptoSignOpen,
+  cryptoSignVerify,
+  // cryptoSignSignature,
+  CryptoPublicKeyBytes,
+  CryptoSecretKeyBytes,
+  // SeedBytes,
+  CryptoBytes,
+} = require('@theqrl/dilithium5');
+const { SeedBinToMnemonic } = require('./utils/mnemonic.js');
+
+function getDilithiumDescriptor(address) {
+  /*
+        In case of Dilithium address, it doesn't have any choice of hashFunction,
+        height, addrFormatType. Thus keeping all those values to 0 and assigning
+        only signatureType in the descriptor.
+    */
+  if (!address) {
+    throw new Error('Address is not defined');
+  }
+  return 2 << 4;
+}
+
+function getDilithiumAddressFromPK(pk) {
+  const addressSize = 20;
+  const address = new Uint8Array(addressSize);
+  const descBytes = getDilithiumDescriptor(address);
+  address[0] = descBytes;
+  const hashedKey = new SHAKE(256);
+  hashedKey.update(Buffer.from(pk));
+  let hashedKeyDigest = hashedKey.digest({ buffer: Buffer.alloc(32), encoding: 'hex' });
+  hashedKeyDigest = hashedKeyDigest.slice(hashedKeyDigest.length - addressSize + 1);
+  for (let i = 0; i < hashedKeyDigest.length; i++) {
+    address[i + 1] = hashedKeyDigest[i];
+  }
+  return address;
+}
+
+class Dilithium {
+  constructor(seed = null) {
+    this.pk = null;
+    this.sk = null;
+    this.seed = seed;
+    this.randomizedSigning = false;
+    if (this.seed === null) {
+      this.create();
+    } else {
+      this.fromSeed();
+    }
+  }
 
-    var seed = randomBytes(48)
+  create() {
+    const pk = new Uint8Array(CryptoPublicKeyBytes);
+    const sk = new Uint8Array(CryptoSecretKeyBytes);
+    const seed = randomBytes(48);
     const hashedSeed = new SHAKE(256);
     hashedSeed.update(seed);
-    let seedBuf = hashedSeed.digest({ buffer: Buffer.alloc(32) })
-
+    const seedBuf = hashedSeed.digest({ buffer: Buffer.alloc(32) });
     cryptoSignKeypair(seedBuf, pk, sk);
-    let dilithium = {
-        pk: pk,
-        sk: sk,
-        seed: seed,
-        randomizedSigning: false,
-        GetPK: new Function,
-        GetSK: new Function,
-        GetSeed: new Function,
-        GetAddress: new Function,
-        GetMnemonic: new Function,
-        GetHexSeed: new Function,
-        Seal: new Function,
-        Sign: new Function,
-    }
-    dilithium.GetPK = GetPK.bind(dilithium)
-    dilithium.GetSK = GetSK.bind(dilithium)
-    dilithium.GetSeed = GetSeed.bind(dilithium)
-    dilithium.GetHexSeed = GetHexSeed.bind(dilithium)
-    dilithium.GetMnemonic = GetMnemonic.bind(dilithium)
-    dilithium.Seal = Seal.bind(dilithium)
-    dilithium.Sign = Sign.bind(dilithium)
-    dilithium.GetAddress = GetAddress.bind(dilithium)
-
-    return dilithium
-}
-
-function NewDilithiumFromSeed(seed) {
-    var pk = new Uint8Array(CryptoPublicKeyBytes);
-    var sk = new Uint8Array(CryptoSecretKeyBytes);
-
+    this.pk = pk;
+    this.sk = sk;
+    this.seed = seed;
+  }
+
+  fromSeed() {
+    const pk = new Uint8Array(CryptoPublicKeyBytes);
+    const sk = new Uint8Array(CryptoSecretKeyBytes);
     const hashedSeed = new SHAKE(256);
-    hashedSeed.update(seed);
-    let seedBuf = hashedSeed.digest({ buffer: Buffer.alloc(32) })
+    hashedSeed.update(this.seed);
+    const seedBuf = hashedSeed.digest({ buffer: Buffer.alloc(32) });
     cryptoSignKeypair(seedBuf, pk, sk);
-    let dilithium = {
-        pk: pk,
-        sk: sk,
-        seed: seed,
-        randomizedSigning: false,
-        GetPK: new Function,
-        GetSK: new Function,
-        GetSeed: new Function,
-        GetAddress: new Function,
-        GetMnemonic: new Function,
-        GetHexSeed: new Function,
-        Seal: new Function,
-        Sign: new Function,
-
-    }
-    dilithium.GetPK = GetPK.bind(dilithium)
-    dilithium.GetSK = GetSK.bind(dilithium)
-    dilithium.GetSeed = GetSeed.bind(dilithium)
-    dilithium.GetHexSeed = GetHexSeed.bind(dilithium)
-    dilithium.GetMnemonic = GetMnemonic.bind(dilithium)
-    dilithium.Seal = Seal.bind(dilithium)
-    dilithium.Sign = Sign.bind(dilithium)
-    dilithium.GetAddress = GetAddress.bind(dilithium)
-
-    return dilithium
-}
+    this.pk = pk;
+    this.sk = sk;
+  }
 
-function GetPK() {
-    return this.pk
-}
+  getPK() {
+    return this.pk;
+  }
 
-function GetSK() {
-    return this.sk
-}
+  getSK() {
+    return this.sk;
+  }
 
-function GetSeed() {
-    return this.seed
-}
+  getSeed() {
+    return this.seed;
+  }
 
-function GetHexSeed() {
-    return '0x' + this.seed.toString('hex')
-}
+  getHexSeed() {
+    return `0x${this.seed.toString('hex')}`;
+  }
 
-function GetMnemonic() {
-    return SeedBinToMnemonic(this.seed)
-}
+  getMnemonic() {
+    return SeedBinToMnemonic(this.seed);
+  }
 
-// Seal the message, returns signature attached with message.
-function Seal(message) {
-    return cryptoSign(message, this.sk, this.randomizedSigning)
-}
+  getAddress() {
+    return getDilithiumAddressFromPK(this.pk);
+  }
 
-// Sign the message, and return a detached signature. Detached signatures are
-// variable sized, but never larger than SIG_SIZE_PACKED.
-function Sign(message) {
-    let sm = cryptoSign(message, this.sk)
-    var signature = new Uint8Array(CryptoBytes)
-    signature = sm.slice(0, CryptoBytes)
-    return signature
-}
+  // Seal the message, returns signature attached with message.
+  seal(message) {
+    return cryptoSign(message, this.sk, this.randomizedSigning);
+  }
 
-function GetAddress() {
-    return GetDilithiumAddressFromPK(this.pk)
+  // Sign the message, and return a detached signature. Detached signatures are
+  // variable sized, but never larger than SIG_SIZE_PACKED.
+  sign(message) {
+    const sm = cryptoSign(message, this.sk);
+    let signature = new Uint8Array(CryptoBytes);
+    signature = sm.slice(0, CryptoBytes);
+    return signature;
+  }
 }
 
 // Open the sealed message m. Returns the original message sealed with signature.
 // In case the signature is invalid, nil is returned.
-function Open(signatureMessage, pk) {
-    return cryptoSignOpen(signatureMessage, pk)
+function openMessage(signatureMessage, pk) {
+  return cryptoSignOpen(signatureMessage, pk);
 }
 
-function Verify(message, signature, pk) {
-    return cryptoSignVerify(signature, message, pk)
+function verifyMessage(message, signature, pk) {
+  return cryptoSignVerify(signature, message, pk);
 }
 
 // ExtractMessage extracts message from Signature attached with message.
-function ExtractMessage(signatureMessage) {
-    return signatureMessage.slice(CryptoBytes, signatureMessage.length)
+function extractMessage(signatureMessage) {
+  return signatureMessage.slice(CryptoBytes, signatureMessage.length);
 }
 
 // ExtractSignature extracts signature from Signature attached with message.
-function ExtractSignature(signatureMessage) {
-    return signatureMessage.slice(0, CryptoBytes)
-}
-
-function GetDilithiumDescriptor() {
-    /*
-        In case of Dilithium address, it doesn't have any choice of hashFunction,
-        height, addrFormatType. Thus keeping all those values to 0 and assigning
-        only signatureType in the descriptor.
-    */
-    return 2 << 4
-}
-
-function GetDilithiumAddressFromPK(pk) {
-    let addressSize = 20
-    var address = new Uint8Array(addressSize)
-    let descBytes = GetDilithiumDescriptor()
-    address[0] = descBytes
-
-    var hashedKey = new SHAKE(256)
-    hashedKey.update(Buffer.from(pk))
-    let hashedKeyDigest = hashedKey.digest({ buffer: Buffer.alloc(32), encoding: 'hex' })
-    hashedKeyDigest = hashedKeyDigest.slice(hashedKeyDigest.length - addressSize + 1)
-    for (let i = 0; i < hashedKeyDigest.length; i++) {
-        address[i + 1] = hashedKeyDigest[i]
-    }
-    return address
-}
-
-function IsValidDilithiumAddress(address) {
-    let d = GetDilithiumDescriptor()
-    if (address[0] != d) {
-        return false
-    }
-
-    // TODO: Add checksum
-    return true
-}
-
-let DilithiumWallet;
-
-export default DilithiumWallet = {
-    New, NewDilithiumFromSeed, Open, Verify, ExtractMessage, ExtractSignature, GetDilithiumDescriptor, GetDilithiumAddressFromPK, IsValidDilithiumAddress
-}
-
+function extractSignature(signatureMessage) {
+  return signatureMessage.slice(0, CryptoBytes);
+}
+
+function isValidDilithiumAddress(address) {
+  const d = getDilithiumDescriptor(address);
+  if (address[0] !== d) {
+    return false;
+  }
+  // TODO: Add checksum
+  return true;
+}
+
+module.exports = {
+  Dilithium,
+  getDilithiumAddressFromPK,
+  getDilithiumDescriptor,
+  openMessage,
+  verifyMessage,
+  extractMessage,
+  extractSignature,
+  isValidDilithiumAddress,
+};