@theqrl/wallet.js 0.1.2 → 0.2.0

package/src/dilithium.js

@@ -1,158 +0,0 @@
-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();
-    }
-  }
-
-  create() {
-    const pk = new Uint8Array(CryptoPublicKeyBytes);
-    const sk = new Uint8Array(CryptoSecretKeyBytes);
-    const seed = randomBytes(48);
-    const hashedSeed = new SHAKE(256);
-    hashedSeed.update(seed);
-    const seedBuf = hashedSeed.digest({ buffer: Buffer.alloc(32) });
-    cryptoSignKeypair(seedBuf, pk, sk);
-    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(this.seed);
-    const seedBuf = hashedSeed.digest({ buffer: Buffer.alloc(32) });
-    cryptoSignKeypair(seedBuf, pk, sk);
-    this.pk = pk;
-    this.sk = sk;
-  }
-
-  getPK() {
-    return this.pk;
-  }
-
-  getSK() {
-    return this.sk;
-  }
-
-  getSeed() {
-    return this.seed;
-  }
-
-  getHexSeed() {
-    return `0x${this.seed.toString('hex')}`;
-  }
-
-  getMnemonic() {
-    return SeedBinToMnemonic(this.seed);
-  }
-
-  getAddress() {
-    return getDilithiumAddressFromPK(this.pk);
-  }
-
-  // Seal the message, returns signature attached with message.
-  seal(message) {
-    return cryptoSign(message, this.sk, this.randomizedSigning);
-  }
-
-  // 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 openMessage(signatureMessage, pk) {
-  return cryptoSignOpen(signatureMessage, 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);
-}
-
-// ExtractSignature extracts signature from Signature attached with message.
-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,
-};

package/src/utils/mnemonic.js

@@ -1,93 +0,0 @@
-const { WordList } = require('../qrl/wordlist.js');
-
-function binToMnemonic(input) {
-  if (input.length % 3 !== 0) {
-    throw new Error('byte count needs to be a multiple of 3');
-  }
-  let mnemonic = '';
-  let separator = '';
-  for (let nibble = 0; nibble < input.length * 2; nibble += 3) {
-    const p = nibble >> 1;
-    const b1 = input[p];
-    let b2 = 0;
-    if (p + 1 < input.length) {
-      b2 = input[p + 1];
-    }
-    let idx = 0;
-    if (nibble % 2 === 0) {
-      idx = (b1 << 4) + (b2 >> 4);
-    } else {
-      idx = ((b1 & 0x0f) << 8) + b2;
-    }
-    mnemonic += separator + WordList[idx];
-    separator = ' ';
-  }
-  return mnemonic;
-}
-
-function SeedBinToMnemonic(input) {
-  return binToMnemonic(input);
-}
-
-function mnemonicToBin(mnemonic) {
-  const mnemonicWords = mnemonic.split(' ');
-  const wordCount = mnemonicWords.length;
-  if (wordCount % 2 !== 0) {
-    throw new Error('word count must be even');
-  }
-
-  const wordLookup = {};
-  WordList.map((word, i) => {
-    wordLookup[word] = i;
-    return word;
-  });
-
-  const result = new Uint8Array((wordCount * 15) / 10);
-
-  let current = 0;
-  let buffering = 0;
-  let resultIndex = 0;
-
-  mnemonicWords.map((w) => {
-    const value = wordLookup[w];
-    if (value === undefined || value === null) {
-      throw new Error('invalid word in mnemonic');
-    }
-
-    buffering += 3;
-    current = (current << 12) + value;
-    let shift;
-    let mask;
-    let tmp;
-    for (; buffering > 2; ) {
-      shift = 4 * (buffering - 2);
-      mask = (1 << shift) - 1;
-      tmp = current >> shift;
-      buffering -= 2;
-      current &= mask;
-      result[resultIndex] = tmp;
-      resultIndex++;
-    }
-    return w;
-  });
-
-  if (buffering > 0) {
-    result[resultIndex] = current & 0xff;
-    resultIndex++;
-  }
-  return result;
-}
-
-function MnemonicToSeedBin(mnemonic) {
-  const output = mnemonicToBin(mnemonic);
-
-  if (output.length !== 48) {
-    throw new Error('unexpected MnemonicToSeedBin output size');
-  }
-
-  const sizedOutput = new Uint8Array(48);
-  sizedOutput.set(output);
-  return output;
-}
-
-module.exports = { SeedBinToMnemonic, MnemonicToSeedBin };