@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/es/utils/crypto.mjs

@@ -19,48 +19,43 @@ const {
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
+import nacl from 'tweetnacl'; // js extension is required for mjs build, not importing the whole package to reduce bundle size
+// eslint-disable-next-line import/extensions
 
-/**
- * Crypto module
- * @module @aeternity/aepp-sdk/es/utils/crypto
- * @example import { Crypto } from '@aeternity/aepp-sdk'
- */
-import nacl from 'tweetnacl';
-import aesjs from 'aes-js';
+import _blakejsBlake2bJs from 'blakejs/blake2b.js';
+const {
+  blake2b
+} = _blakejsBlake2bJs;
+import _varuintBitcoin from 'varuint-bitcoin';
+const {
+  encode: varuintEncode
+} = _varuintBitcoin;
 import { str2buf } from "./bytes.mjs";
-import { encode, decode, sha256hash } from "./encoder.mjs";
-import { hash } from "./crypto-ts.mjs";
-import { NotImplementedError } from "./errors.mjs";
-export * from "./crypto-ts.mjs";
-export { sha256hash };
-const Ecb = aesjs.ModeOfOperation.ecb;
+import { concatBuffers } from "./other.mjs";
+import { decode, encode, Encoding } from "./encoder.mjs";
 /**
  * Generate address from secret key
- * @rtype (secret: String) => tx: Promise[String]
- * @param {String} secret - Private key
- * @return {String} Public key
+ * @param secret - Private key
+ * @returns Public key encoded as address
  */
 
 export function getAddressFromPriv(secret) {
-  const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret));
-
-  const publicBuffer = _Buffer.from(keys.publicKey);
-
-  return encode(publicBuffer, 'ak');
+  const secretBuffer = typeof secret === 'string' ? str2buf(secret) : secret;
+  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer);
+  return encode(keys.publicKey, Encoding.AccountAddress);
 }
 /**
  * Check if address is valid
- * @rtype (input: String) => valid: Boolean
- * @param {String} address - Address
- * @param {String} prefix Transaction prefix. Default: 'ak'
- * @return {Boolean} valid
+ * @param address - Address
+ * @param prefix - Transaction prefix. Default: 'ak'
+ * @returns is valid
  */
 
 export function isAddressValid(address) {
-  let prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'ak';
+  let prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Encoding.AccountAddress;
 
   try {
-    decode(address, prefix);
+    decode(address);
     return true;
   } catch (e) {
     return false;
@@ -68,19 +63,17 @@ export function isAddressValid(address) {
 }
 /**
  * Generate a random salt (positive integer)
- * @rtype () => salt: Number
- * @return {Number} random salt
+ * @returns random salt
  */
 
-export function salt() {
+export function genSalt() {
   return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER));
 }
 /**
  * Converts a positive integer to the smallest possible
  * representation in a binary digit representation
- * @rtype (value: Number) => Buffer
- * @param {Number} value - Value to encode
- * @return {Buffer} - Encoded data
+ * @param value - Value to encode
+ * @returns Encoded number
  */
 
 export function encodeUnsigned(value) {
@@ -88,29 +81,35 @@ export function encodeUnsigned(value) {
 
   binary.writeUInt32BE(value);
   return binary.slice(binary.findIndex(i => i !== 0));
+}
+/**
+ * Calculate 256bits Blake2b hash of `input`
+ * @param input - Data to hash
+ * @returns Hash
+ */
+
+export function hash(input) {
+  return _Buffer.from(blake2b(input, undefined, 32)); // 256 bits
 } // Todo Duplicated in tx builder. remove
 
 /**
  * Compute contract address
- * @rtype (owner: String, nonce: Number) => String
- * @param {String} owner - Address of contract owner
- * @param {Number} nonce - Round when contract was created
- * @return {String} - Contract address
+ * @category contract
+ * @param owner - Address of contract owner
+ * @param nonce - Round when contract was created
+ * @returns Contract address
  */
 
 export function encodeContractAddress(owner, nonce) {
-  const publicKey = decode(owner, 'ak');
-
-  const binary = _Buffer.concat([publicKey, encodeUnsigned(nonce)]);
-
-  return encode(hash(binary), 'ct');
+  const publicKey = decode(owner);
+  const binary = concatBuffers([publicKey, encodeUnsigned(nonce)]);
+  return encode(hash(binary), Encoding.ContractAddress);
 } // KEY-PAIR HELPERS
 
 /**
  * Generate keyPair from secret key
- * @rtype (secret: Uint8Array) => KeyPair
- * @param {Uint8Array} secret - secret key
- * @return {Object} - Object with Private(privateKey) and Public(publicKey) keys
+ * @param secret - secret key
+ * @returns Object with Private(privateKey) and Public(publicKey) keys
  */
 
 export function generateKeyPairFromSecret(secret) {
@@ -118,14 +117,12 @@ export function generateKeyPairFromSecret(secret) {
 }
 /**
  * Generate a random ED25519 keypair
- * @rtype (raw: Boolean) => {publicKey: String | Buffer, secretKey: String | Buffer}
- * @param {Boolean} raw - Whether to return raw (binary) keys
- * @return {Object} Key pair
+ * @param raw - Whether to return raw (binary) keys
+ * @returns Key pair
  */
 
 export function generateKeyPair() {
   let raw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-  // <node>/apps/aens/test/aens_test_utils.erl
   const keyPair = nacl.sign.keyPair();
 
   const publicBuffer = _Buffer.from(keyPair.publicKey);
@@ -137,48 +134,19 @@ export function generateKeyPair() {
       publicKey: publicBuffer,
       secretKey: secretBuffer
     };
-  } else {
-    return {
-      publicKey: encode(publicBuffer, 'ak'),
-      secretKey: secretBuffer.toString('hex')
-    };
   }
-}
-/**
- * Encrypt given data using `password`
- * @rtype (password: String, binaryData: Buffer) => Uint8Array
- * @param {String} password - Password to encrypt with
- * @param {Buffer} binaryData - Data to encrypt
- * @return {Uint8Array} Encrypted data
- */
-
-export function encryptKey(password, binaryData) {
-  const hashedPasswordBytes = sha256hash(password);
-  const aesEcb = new Ecb(hashedPasswordBytes);
-  return aesEcb.encrypt(binaryData);
-}
-/**
- * Decrypt given data using `password`
- * @rtype (password: String, encrypted: String) => Uint8Array
- * @param {String} password - Password to decrypt with
- * @param {String} encrypted - Data to decrypt
- * @return {Buffer} Decrypted data
- */
-
-export function decryptKey(password, encrypted) {
-  const encryptedBytes = _Buffer.from(encrypted);
 
-  const hashedPasswordBytes = sha256hash(password);
-  const aesEcb = new Ecb(hashedPasswordBytes);
-  return _Buffer.from(aesEcb.decrypt(encryptedBytes));
+  return {
+    publicKey: encode(publicBuffer, Encoding.AccountAddress),
+    secretKey: secretBuffer.toString('hex')
+  };
 } // SIGNATURES
 
 /**
  * Generate signature
- * @rtype (data: String|Buffer, privateKey: Buffer) => Buffer
- * @param {String|Buffer} data - Data to sign
- * @param {String|Buffer} privateKey - Key to sign with
- * @return {Buffer|Uint8Array} Signature
+ * @param data - Data to sign
+ * @param privateKey - Key to sign with
+ * @returns Signature
  */
 
 export function sign(data, privateKey) {
@@ -186,23 +154,22 @@ export function sign(data, privateKey) {
 }
 /**
  * Verify that signature was signed by public key
- * @rtype (str: String, signature: Buffer, publicKey: Buffer) => Boolean
- * @param {String|Buffer} str - Data to verify
- * @param {Buffer} signature - Signature to verify
- * @param {Buffer} publicKey - Key to verify against
- * @return {Boolean} Valid?
+ * @param data - Data to verify
+ * @param signature - Signature to verify
+ * @param publicKey - Key to verify against
+ * @returns Valid?
  */
 
-export function verify(str, signature, publicKey) {
-  return nacl.sign.detached.verify(new Uint8Array(str), signature, publicKey);
+export function verify(data, signature, publicKey) {
+  const publicKeyBuffer = typeof publicKey === 'string' ? str2buf(publicKey) : publicKey;
+  return nacl.sign.detached.verify(data, signature, publicKeyBuffer);
 }
 export function messageToHash(message) {
   const p = _Buffer.from('aeternity Signed Message:\n', 'utf8');
 
   const msg = _Buffer.from(message, 'utf8');
 
-  if (msg.length >= 0xFD) throw new NotImplementedError('Message too long');
-  return hash(_Buffer.concat([_Buffer.from([p.length]), p, _Buffer.from([msg.length]), msg]));
+  return hash(concatBuffers([varuintEncode(p.length), p, varuintEncode(msg.length), msg]));
 }
 export function signMessage(message, privateKey) {
   return sign(messageToHash(message), privateKey);
@@ -214,10 +181,9 @@ export function verifyMessage(str, signature, publicKey) {
  * Check key pair for validity
  *
  * Sign a message, and then verifying that signature
- * @rtype (privateKey: Buffer, publicKey: Buffer) => Boolean
- * @param {Buffer} privateKey - Private key to verify
- * @param {Buffer} publicKey - Public key to verify
- * @return {Boolean} Valid?
+ * @param privateKey - Private key to verify
+ * @param publicKey - Public key to verify
+ * @returns Valid?
  */
 
 export function isValidKeypair(privateKey, publicKey) {

package/es/utils/crypto.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/crypto.js"],"names":["nacl","aesjs","str2buf","encode","decode","sha256hash","hash","NotImplementedError","Ecb","ModeOfOperation","ecb","getAddressFromPriv","secret","keys","sign","keyPair","fromSecretKey","publicBuffer","from","publicKey","isAddressValid","address","prefix","e","salt","Math","floor","random","Number","MAX_SAFE_INTEGER","encodeUnsigned","value","binary","allocUnsafe","writeUInt32BE","slice","findIndex","i","encodeContractAddress","owner","nonce","concat","generateKeyPairFromSecret","generateKeyPair","raw","secretBuffer","secretKey","toString","encryptKey","password","binaryData","hashedPasswordBytes","aesEcb","encrypt","decryptKey","encrypted","encryptedBytes","decrypt","data","privateKey","detached","verify","str","signature","Uint8Array","messageToHash","message","p","msg","length","signMessage","verifyMessage","isValidKeypair"],"mappings":"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","sourcesContent":["/*\n * ISC License (ISC)\n * Copyright 2018 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\n\n/**\n * Crypto module\n * @module @aeternity/aepp-sdk/es/utils/crypto\n * @example import { Crypto } from '@aeternity/aepp-sdk'\n */\n\nimport nacl from 'tweetnacl'\nimport aesjs from 'aes-js'\n\nimport { str2buf } from './bytes'\nimport { encode, decode, sha256hash } from './encoder'\nimport { hash } from './crypto-ts'\nimport { NotImplementedError } from './errors'\n\nexport * from './crypto-ts'\nexport { sha256hash }\n\nconst Ecb = aesjs.ModeOfOperation.ecb\n\n/**\n * Generate address from secret key\n * @rtype (secret: String) => tx: Promise[String]\n * @param {String} secret - Private key\n * @return {String} Public key\n */\nexport function getAddressFromPriv (secret) {\n  const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret))\n  const publicBuffer = Buffer.from(keys.publicKey)\n  return encode(publicBuffer, 'ak')\n}\n\n/**\n * Check if address is valid\n * @rtype (input: String) => valid: Boolean\n * @param {String} address - Address\n * @param {String} prefix Transaction prefix. Default: 'ak'\n * @return {Boolean} valid\n */\nexport function isAddressValid (address, prefix = 'ak') {\n  try {\n    decode(address, prefix)\n    return true\n  } catch (e) {\n    return false\n  }\n}\n\n/**\n * Generate a random salt (positive integer)\n * @rtype () => salt: Number\n * @return {Number} random salt\n */\nexport function salt () {\n  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER))\n}\n\n/**\n * Converts a positive integer to the smallest possible\n * representation in a binary digit representation\n * @rtype (value: Number) => Buffer\n * @param {Number} value - Value to encode\n * @return {Buffer} - Encoded data\n */\nexport function encodeUnsigned (value) {\n  const binary = Buffer.allocUnsafe(4)\n  binary.writeUInt32BE(value)\n  return binary.slice(binary.findIndex(i => i !== 0))\n}\n\n// Todo Duplicated in tx builder. remove\n/**\n * Compute contract address\n * @rtype (owner: String, nonce: Number) => String\n * @param {String} owner - Address of contract owner\n * @param {Number} nonce - Round when contract was created\n * @return {String} - Contract address\n */\nexport function encodeContractAddress (owner, nonce) {\n  const publicKey = decode(owner, 'ak')\n  const binary = Buffer.concat([publicKey, encodeUnsigned(nonce)])\n  return encode(hash(binary), 'ct')\n}\n\n// KEY-PAIR HELPERS\n\n/**\n * Generate keyPair from secret key\n * @rtype (secret: Uint8Array) => KeyPair\n * @param {Uint8Array} secret - secret key\n * @return {Object} - Object with Private(privateKey) and Public(publicKey) keys\n */\nexport function generateKeyPairFromSecret (secret) {\n  return nacl.sign.keyPair.fromSecretKey(secret)\n}\n\n/**\n * Generate a random ED25519 keypair\n * @rtype (raw: Boolean) => {publicKey: String | Buffer, secretKey: String | Buffer}\n * @param {Boolean} raw - Whether to return raw (binary) keys\n * @return {Object} Key pair\n */\nexport function generateKeyPair (raw = false) {\n  // <node>/apps/aens/test/aens_test_utils.erl\n  const keyPair = nacl.sign.keyPair()\n\n  const publicBuffer = Buffer.from(keyPair.publicKey)\n  const secretBuffer = Buffer.from(keyPair.secretKey)\n\n  if (raw) {\n    return {\n      publicKey: publicBuffer,\n      secretKey: secretBuffer\n    }\n  } else {\n    return {\n      publicKey: encode(publicBuffer, 'ak'),\n      secretKey: secretBuffer.toString('hex')\n    }\n  }\n}\n\n/**\n * Encrypt given data using `password`\n * @rtype (password: String, binaryData: Buffer) => Uint8Array\n * @param {String} password - Password to encrypt with\n * @param {Buffer} binaryData - Data to encrypt\n * @return {Uint8Array} Encrypted data\n */\nexport function encryptKey (password, binaryData) {\n  const hashedPasswordBytes = sha256hash(password)\n  const aesEcb = new Ecb(hashedPasswordBytes)\n  return aesEcb.encrypt(binaryData)\n}\n\n/**\n * Decrypt given data using `password`\n * @rtype (password: String, encrypted: String) => Uint8Array\n * @param {String} password - Password to decrypt with\n * @param {String} encrypted - Data to decrypt\n * @return {Buffer} Decrypted data\n */\nexport function decryptKey (password, encrypted) {\n  const encryptedBytes = Buffer.from(encrypted)\n  const hashedPasswordBytes = sha256hash(password)\n  const aesEcb = new Ecb(hashedPasswordBytes)\n  return Buffer.from(aesEcb.decrypt(encryptedBytes))\n}\n\n// SIGNATURES\n\n/**\n * Generate signature\n * @rtype (data: String|Buffer, privateKey: Buffer) => Buffer\n * @param {String|Buffer} data - Data to sign\n * @param {String|Buffer} privateKey - Key to sign with\n * @return {Buffer|Uint8Array} Signature\n */\nexport function sign (data, privateKey) {\n  return nacl.sign.detached(Buffer.from(data), Buffer.from(privateKey))\n}\n\n/**\n * Verify that signature was signed by public key\n * @rtype (str: String, signature: Buffer, publicKey: Buffer) => Boolean\n * @param {String|Buffer} str - Data to verify\n * @param {Buffer} signature - Signature to verify\n * @param {Buffer} publicKey - Key to verify against\n * @return {Boolean} Valid?\n */\nexport function verify (str, signature, publicKey) {\n  return nacl.sign.detached.verify(new Uint8Array(str), signature, publicKey)\n}\n\nexport function messageToHash (message) {\n  const p = Buffer.from('aeternity Signed Message:\\n', 'utf8')\n  const msg = Buffer.from(message, 'utf8')\n  if (msg.length >= 0xFD) throw new NotImplementedError('Message too long')\n  return hash(Buffer.concat([Buffer.from([p.length]), p, Buffer.from([msg.length]), msg]))\n}\n\nexport function signMessage (message, privateKey) {\n  return sign(messageToHash(message), privateKey)\n}\n\nexport function verifyMessage (str, signature, publicKey) {\n  return verify(messageToHash(str), signature, publicKey)\n}\n\n/**\n * Check key pair for validity\n *\n * Sign a message, and then verifying that signature\n * @rtype (privateKey: Buffer, publicKey: Buffer) => Boolean\n * @param {Buffer} privateKey - Private key to verify\n * @param {Buffer} publicKey - Public key to verify\n * @return {Boolean} Valid?\n */\nexport function isValidKeypair (privateKey, publicKey) {\n  const message = Buffer.from('TheMessage')\n  const signature = sign(message, privateKey)\n  return verify(message, signature, publicKey)\n}\n"],"file":"crypto.mjs"}
+{"version":3,"file":"crypto.mjs","names":["nacl","str2buf","concatBuffers","decode","encode","Encoding","getAddressFromPriv","secret","secretBuffer","keys","sign","keyPair","fromSecretKey","publicKey","AccountAddress","isAddressValid","address","prefix","e","genSalt","Math","floor","random","Number","MAX_SAFE_INTEGER","encodeUnsigned","value","binary","allocUnsafe","writeUInt32BE","slice","findIndex","i","hash","input","from","blake2b","undefined","encodeContractAddress","owner","nonce","ContractAddress","generateKeyPairFromSecret","generateKeyPair","raw","publicBuffer","secretKey","toString","data","privateKey","detached","verify","signature","publicKeyBuffer","messageToHash","message","p","msg","varuintEncode","length","signMessage","verifyMessage","str","isValidKeypair"],"sources":["../../src/utils/crypto.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright 2018 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\nimport nacl, { SignKeyPair } from 'tweetnacl';\n// js extension is required for mjs build, not importing the whole package to reduce bundle size\n// eslint-disable-next-line import/extensions\nimport { blake2b } from 'blakejs/blake2b.js';\nimport { encode as varuintEncode } from 'varuint-bitcoin';\n\nimport { str2buf } from './bytes';\nimport { concatBuffers } from './other';\nimport {\n  decode, encode, Encoded, Encoding,\n} from './encoder';\n\n/**\n * Generate address from secret key\n * @param secret - Private key\n * @returns Public key encoded as address\n */\nexport function getAddressFromPriv(secret: string | Uint8Array): Encoded.AccountAddress {\n  const secretBuffer = typeof secret === 'string' ? str2buf(secret) : secret;\n  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer);\n  return encode(keys.publicKey, Encoding.AccountAddress);\n}\n\n/**\n * Check if address is valid\n * @param address - Address\n * @param prefix - Transaction prefix. Default: 'ak'\n * @returns is valid\n */\nexport function isAddressValid(\n  address: string,\n  prefix: Encoding = Encoding.AccountAddress,\n): boolean {\n  try {\n    decode(address as Encoded.Generic<typeof prefix>);\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Generate a random salt (positive integer)\n * @returns random salt\n */\nexport function genSalt(): number {\n  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER));\n}\n\n/**\n * Converts a positive integer to the smallest possible\n * representation in a binary digit representation\n * @param value - Value to encode\n * @returns Encoded number\n */\nexport function encodeUnsigned(value: number): Buffer {\n  const binary = Buffer.allocUnsafe(4);\n  binary.writeUInt32BE(value);\n  return binary.slice(binary.findIndex((i) => i !== 0));\n}\n\n/**\n * Calculate 256bits Blake2b hash of `input`\n * @param input - Data to hash\n * @returns Hash\n */\nexport function hash(input: string | Uint8Array): Buffer {\n  return Buffer.from(blake2b(input, undefined, 32)); // 256 bits\n}\n\n// Todo Duplicated in tx builder. remove\n/**\n * Compute contract address\n * @category contract\n * @param owner - Address of contract owner\n * @param nonce - Round when contract was created\n * @returns Contract address\n */\nexport function encodeContractAddress(\n  owner: Encoded.AccountAddress,\n  nonce: number,\n): Encoded.ContractAddress {\n  const publicKey = decode(owner);\n  const binary = concatBuffers([publicKey, encodeUnsigned(nonce)]);\n  return encode(hash(binary), Encoding.ContractAddress);\n}\n\n// KEY-PAIR HELPERS\n\n/**\n * Generate keyPair from secret key\n * @param secret - secret key\n * @returns Object with Private(privateKey) and Public(publicKey) keys\n */\nexport function generateKeyPairFromSecret(secret: Uint8Array): SignKeyPair {\n  return nacl.sign.keyPair.fromSecretKey(secret);\n}\n\n/**\n * Generate a random ED25519 keypair\n * @param raw - Whether to return raw (binary) keys\n * @returns Key pair\n */\nexport function generateKeyPair(raw: true): { publicKey: Buffer; secretKey: Buffer };\nexport function generateKeyPair(raw?: false): {\n  publicKey: Encoded.AccountAddress; secretKey: string;\n};\nexport function generateKeyPair(raw = false): {\n  publicKey: Encoded.AccountAddress | Buffer;\n  secretKey: string | Buffer;\n} {\n  const keyPair = nacl.sign.keyPair();\n  const publicBuffer = Buffer.from(keyPair.publicKey);\n  const secretBuffer = Buffer.from(keyPair.secretKey);\n\n  if (raw) {\n    return {\n      publicKey: publicBuffer,\n      secretKey: secretBuffer,\n    };\n  }\n  return {\n    publicKey: encode(publicBuffer, Encoding.AccountAddress),\n    secretKey: secretBuffer.toString('hex'),\n  };\n}\n\n// SIGNATURES\n\n/**\n * Generate signature\n * @param data - Data to sign\n * @param privateKey - Key to sign with\n * @returns Signature\n */\nexport function sign(data: string | Uint8Array, privateKey: string | Uint8Array): Uint8Array {\n  return nacl.sign.detached(Buffer.from(data), Buffer.from(privateKey));\n}\n\n/**\n * Verify that signature was signed by public key\n * @param data - Data to verify\n * @param signature - Signature to verify\n * @param publicKey - Key to verify against\n * @returns Valid?\n */\nexport function verify(\n  data: Uint8Array,\n  signature: Uint8Array,\n  publicKey: string | Uint8Array,\n): boolean {\n  const publicKeyBuffer = typeof publicKey === 'string' ? str2buf(publicKey) : publicKey;\n  return nacl.sign.detached.verify(data, signature, publicKeyBuffer);\n}\n\nexport function messageToHash(message: string): Buffer {\n  const p = Buffer.from('aeternity Signed Message:\\n', 'utf8');\n  const msg = Buffer.from(message, 'utf8');\n  return hash(concatBuffers([varuintEncode(p.length), p, varuintEncode(msg.length), msg]));\n}\n\nexport function signMessage(message: string, privateKey: string | Buffer): Uint8Array {\n  return sign(messageToHash(message), privateKey);\n}\n\nexport function verifyMessage(\n  str: string,\n  signature: Uint8Array,\n  publicKey: string | Uint8Array,\n): boolean {\n  return verify(messageToHash(str), signature, publicKey);\n}\n\n/**\n * Check key pair for validity\n *\n * Sign a message, and then verifying that signature\n * @param privateKey - Private key to verify\n * @param publicKey - Public key to verify\n * @returns Valid?\n */\nexport function isValidKeypair(\n  privateKey: string | Uint8Array,\n  publicKey: string | Uint8Array,\n): boolean {\n  const message = Buffer.from('TheMessage');\n  const signature = sign(message, privateKey);\n  return verify(message, signature, publicKey);\n}\n"],"mappings":"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"}

package/es/utils/encoder-types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L205-L230}
+ */
+export declare enum Encoding {
+    KeyBlockHash = "kh",
+    MicroBlockHash = "mh",
+    BlockPofHash = "bf",
+    BlockTxHash = "bx",
+    BlockStateHash = "bs",
+    Channel = "ch",
+    ContractAddress = "ct",
+    ContractBytearray = "cb",
+    ContractStoreKey = "ck",
+    ContractStoreValue = "cv",
+    Transaction = "tx",
+    TxHash = "th",
+    OracleAddress = "ok",
+    OracleQuery = "ov",
+    OracleQueryId = "oq",
+    OracleResponse = "or",
+    AccountAddress = "ak",
+    Signature = "sg",
+    Commitment = "cm",
+    PeerPubkey = "pp",
+    Name = "nm",
+    State = "st",
+    Poi = "pi",
+    StateTrees = "ss",
+    CallStateTree = "cs",
+    Bytearray = "ba"
+}
+export declare type KeyBlockHash = `${Encoding.KeyBlockHash}_${string}`;
+export declare type MicroBlockHash = `${Encoding.MicroBlockHash}_${string}`;
+export declare type BlockPofHash = `${Encoding.BlockPofHash}_${string}`;
+export declare type BlockTxHash = `${Encoding.BlockTxHash}_${string}`;
+export declare type BlockStateHash = `${Encoding.BlockStateHash}_${string}`;
+export declare type Channel = `${Encoding.Channel}_${string}`;
+export declare type ContractAddress = `${Encoding.ContractAddress}_${string}`;
+export declare type ContractBytearray = `${Encoding.ContractBytearray}_${string}`;
+export declare type ContractStoreKey = `${Encoding.ContractStoreKey}_${string}`;
+export declare type ContractStoreValue = `${Encoding.ContractStoreValue}_${string}`;
+export declare type Transaction = `${Encoding.Transaction}_${string}`;
+export declare type TxHash = `${Encoding.TxHash}_${string}`;
+export declare type OracleAddress = `${Encoding.OracleAddress}_${string}`;
+export declare type OracleQuery = `${Encoding.OracleQuery}_${string}`;
+export declare type OracleQueryId = `${Encoding.OracleQueryId}_${string}`;
+export declare type OracleResponse = `${Encoding.OracleResponse}_${string}`;
+export declare type AccountAddress = `${Encoding.AccountAddress}_${string}`;
+export declare type Signature = `${Encoding.Signature}_${string}`;
+export declare type Commitment = `${Encoding.Commitment}_${string}`;
+export declare type PeerPubkey = `${Encoding.PeerPubkey}_${string}`;
+export declare type Name = `${Encoding.Name}_${string}`;
+export declare type State = `${Encoding.State}_${string}`;
+export declare type Poi = `${Encoding.Poi}_${string}`;
+export declare type StateTrees = `${Encoding.StateTrees}_${string}`;
+export declare type CallStateTree = `${Encoding.CallStateTree}_${string}`;
+export declare type Bytearray = `${Encoding.Bytearray}_${string}`;
+export declare type Generic<Type extends Encoding> = `${Type}_${string}`;
+export declare type Any = `${Encoding}_${string}`;

package/es/utils/encoder-types.mjs

@@ -0,0 +1,36 @@
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L205-L230}
+ */
+export let Encoding;
+
+(function (Encoding) {
+  Encoding["KeyBlockHash"] = "kh";
+  Encoding["MicroBlockHash"] = "mh";
+  Encoding["BlockPofHash"] = "bf";
+  Encoding["BlockTxHash"] = "bx";
+  Encoding["BlockStateHash"] = "bs";
+  Encoding["Channel"] = "ch";
+  Encoding["ContractAddress"] = "ct";
+  Encoding["ContractBytearray"] = "cb";
+  Encoding["ContractStoreKey"] = "ck";
+  Encoding["ContractStoreValue"] = "cv";
+  Encoding["Transaction"] = "tx";
+  Encoding["TxHash"] = "th";
+  Encoding["OracleAddress"] = "ok";
+  Encoding["OracleQuery"] = "ov";
+  Encoding["OracleQueryId"] = "oq";
+  Encoding["OracleResponse"] = "or";
+  Encoding["AccountAddress"] = "ak";
+  Encoding["Signature"] = "sg";
+  Encoding["Commitment"] = "cm";
+  Encoding["PeerPubkey"] = "pp";
+  Encoding["Name"] = "nm";
+  Encoding["State"] = "st";
+  Encoding["Poi"] = "pi";
+  Encoding["StateTrees"] = "ss";
+  Encoding["CallStateTree"] = "cs";
+  Encoding["Bytearray"] = "ba";
+})(Encoding || (Encoding = {}));
+//# sourceMappingURL=encoder-types.mjs.map

package/es/utils/encoder-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-types.mjs","names":["Encoding"],"sources":["../../src/utils/encoder-types.ts"],"sourcesContent":["/**\n * @category transaction builder\n * @see {@link https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md}\n * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L205-L230}\n */\nexport enum Encoding {\n  KeyBlockHash = 'kh',\n  MicroBlockHash = 'mh',\n  BlockPofHash = 'bf',\n  BlockTxHash = 'bx',\n  BlockStateHash = 'bs',\n  Channel = 'ch',\n  ContractAddress = 'ct',\n  ContractBytearray = 'cb',\n  ContractStoreKey = 'ck',\n  ContractStoreValue = 'cv',\n  Transaction = 'tx',\n  TxHash = 'th',\n  OracleAddress = 'ok',\n  OracleQuery = 'ov',\n  OracleQueryId = 'oq',\n  OracleResponse = 'or',\n  AccountAddress = 'ak',\n  Signature = 'sg',\n  Commitment = 'cm',\n  PeerPubkey = 'pp',\n  Name = 'nm',\n  State = 'st',\n  Poi = 'pi',\n  StateTrees = 'ss',\n  CallStateTree = 'cs',\n  Bytearray = 'ba',\n}\n\nexport type KeyBlockHash = `${Encoding.KeyBlockHash}_${string}`;\nexport type MicroBlockHash = `${Encoding.MicroBlockHash}_${string}`;\nexport type BlockPofHash = `${Encoding.BlockPofHash}_${string}`;\nexport type BlockTxHash = `${Encoding.BlockTxHash}_${string}`;\nexport type BlockStateHash = `${Encoding.BlockStateHash}_${string}`;\nexport type Channel = `${Encoding.Channel}_${string}`;\nexport type ContractAddress = `${Encoding.ContractAddress}_${string}`;\nexport type ContractBytearray = `${Encoding.ContractBytearray}_${string}`;\nexport type ContractStoreKey = `${Encoding.ContractStoreKey}_${string}`;\nexport type ContractStoreValue = `${Encoding.ContractStoreValue}_${string}`;\nexport type Transaction = `${Encoding.Transaction}_${string}`;\nexport type TxHash = `${Encoding.TxHash}_${string}`;\nexport type OracleAddress = `${Encoding.OracleAddress}_${string}`;\nexport type OracleQuery = `${Encoding.OracleQuery}_${string}`;\nexport type OracleQueryId = `${Encoding.OracleQueryId}_${string}`;\nexport type OracleResponse = `${Encoding.OracleResponse}_${string}`;\nexport type AccountAddress = `${Encoding.AccountAddress}_${string}`;\nexport type Signature = `${Encoding.Signature}_${string}`;\nexport type Commitment = `${Encoding.Commitment}_${string}`;\nexport type PeerPubkey = `${Encoding.PeerPubkey}_${string}`;\nexport type Name = `${Encoding.Name}_${string}`;\nexport type State = `${Encoding.State}_${string}`;\nexport type Poi = `${Encoding.Poi}_${string}`;\nexport type StateTrees = `${Encoding.StateTrees}_${string}`;\nexport type CallStateTree = `${Encoding.CallStateTree}_${string}`;\nexport type Bytearray = `${Encoding.Bytearray}_${string}`;\n\nexport type Generic<Type extends Encoding> = `${Type}_${string}`;\nexport type Any = `${Encoding}_${string}`;\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,WAAYA,QAAZ;;WAAYA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;EAAAA,Q;GAAAA,Q,KAAAA,Q"}

package/es/utils/encoder.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import * as Encoded from './encoder-types';
+import { Encoding } from './encoder-types';
+export { Encoded, Encoding };
+/**
+ * Calculate SHA256 hash of `input`
+ * @param input - Data to hash
+ * @returns Hash
+ * @deprecated use `SubtleCrypto.digest` or `sha.js` package instead
+ */
+export declare function sha256hash(input: Uint8Array | string): Buffer;
+/**
+ * Decode data using the default encoding/decoding algorithm
+ * @param data - An Base58/64check encoded and prefixed string
+ * (ex tx_..., sg_..., ak_....)
+ * @returns Decoded data
+ */
+export declare function decode(data: Encoded.Any): Buffer;
+/**
+ * Encode data using the default encoding/decoding algorithm
+ * @param data - An decoded data
+ * @param type - Prefix of Transaction
+ * @returns Encoded string Base58check or Base64check data
+ */
+export declare function encode<Type extends Encoding>(data: Uint8Array, type: Type): Encoded.Generic<Type>;

package/es/utils/encoder.mjs

@@ -2,45 +2,67 @@ import _buffer from "buffer";
 const {
   Buffer: _Buffer
 } = _buffer;
-import * as bs58 from 'bs58';
-import _shaJs from 'sha.js';
+import _bs from 'bs58'; // js extension is required for mjs build, not importing the whole package to reduce bundle size
+// eslint-disable-next-line import/extensions
+
 const {
-  sha256
-} = _shaJs;
-import { DecodeError, EncodeError, InvalidChecksumError, PayloadLengthError, PrefixMismatchError } from "./errors.mjs";
+  encode: bs58Encode,
+  decode: bs58Decode
+} = _bs;
+import Sha256 from 'sha.js/sha256.js';
+import { DecodeError, ArgumentError, InvalidChecksumError, PayloadLengthError } from "./errors.mjs";
+import { concatBuffers, isKeyOfObject } from "./other.mjs";
+import * as Encoded from "./encoder-types.mjs";
+import { Encoding } from "./encoder-types.mjs";
+export { Encoded, Encoding };
 /**
  * Calculate SHA256 hash of `input`
- * @rtype (input: String) => hash: String
- * @param {Buffer|String} input - Data to hash
- * @return {String} Hash
+ * @param input - Data to hash
+ * @returns Hash
+ * @deprecated use `SubtleCrypto.digest` or `sha.js` package instead
  */
 
 export function sha256hash(input) {
-  return new sha256().update(input).digest();
-} // based on https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md
+  return new Sha256().update(input).digest();
+}
+/**
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L177-L202}
+ */
 
-const base64Types = ['ba', 'cb', 'or', 'ov', 'pi', 'ss', 'cs', 'ck', 'cv', 'st', 'tx'];
-const base58Types = ['ak', 'bf', 'bs', 'bx', 'ch', 'cm', 'ct', 'kh', 'mh', 'nm', 'ok', 'oq', 'pp', 'sg', 'th']; // TODO: add all types with a fixed length
+const base64Types = [Encoding.ContractBytearray, Encoding.ContractStoreKey, Encoding.ContractStoreValue, Encoding.Transaction, Encoding.OracleQuery, Encoding.OracleResponse, Encoding.State, Encoding.Poi, Encoding.StateTrees, Encoding.CallStateTree, Encoding.Bytearray];
+const base58Types = [Encoding.KeyBlockHash, Encoding.MicroBlockHash, Encoding.BlockPofHash, Encoding.BlockTxHash, Encoding.BlockStateHash, Encoding.Channel, Encoding.ContractAddress, Encoding.TxHash, Encoding.OracleAddress, Encoding.OracleQueryId, Encoding.AccountAddress, Encoding.Signature, Encoding.Commitment, Encoding.PeerPubkey, Encoding.Name];
+/**
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L261-L286}
+ */
 
-const typesLength = {
-  ak: 32,
-  ct: 32,
-  ok: 32
+const byteSizeForType = {
+  [Encoding.KeyBlockHash]: 32,
+  [Encoding.MicroBlockHash]: 32,
+  [Encoding.BlockPofHash]: 32,
+  [Encoding.BlockTxHash]: 32,
+  [Encoding.BlockStateHash]: 32,
+  [Encoding.Channel]: 32,
+  [Encoding.ContractAddress]: 32,
+  [Encoding.TxHash]: 32,
+  [Encoding.OracleAddress]: 32,
+  [Encoding.OracleQueryId]: 32,
+  [Encoding.AccountAddress]: 32,
+  [Encoding.Signature]: 64,
+  [Encoding.Commitment]: 32,
+  [Encoding.PeerPubkey]: 32,
+  [Encoding.State]: 32
 };
 
 function ensureValidLength(data, type) {
-  if (!typesLength[type]) return;
-  if (data.length === typesLength[type]) return;
-  throw new PayloadLengthError(`Payload should be ${typesLength[type]} bytes, got ${data.length} instead`);
+  if (!isKeyOfObject(type, byteSizeForType)) return;
+  const reqLen = byteSizeForType[type];
+  if (reqLen == null || data.length === reqLen) return;
+  throw new PayloadLengthError(`Payload should be ${reqLen} bytes, got ${data.length} instead`);
 }
 
 const getChecksum = payload => sha256hash(sha256hash(payload)).slice(0, 4);
 
-const addChecksum = input => {
-  const payload = _Buffer.from(input);
-
-  return _Buffer.concat([payload, getChecksum(payload)]);
-};
+const addChecksum = payload => concatBuffers([payload, getChecksum(payload)]);
 
 function getPayload(buffer) {
   const payload = buffer.slice(0, -4);
@@ -53,54 +75,44 @@ const base64 = {
   decode: string => getPayload(_Buffer.from(string, 'base64'))
 };
 const base58 = {
-  encode: buffer => bs58.encode(addChecksum(buffer)),
-  decode: string => getPayload(bs58.decode(string))
+  encode: buffer => bs58Encode(addChecksum(buffer)),
+  decode: string => getPayload(_Buffer.from(bs58Decode(string)))
+};
+
+const parseType = maybeType => {
+  const base64Type = base64Types.find(t => t === maybeType);
+  if (base64Type != null) return [base64Type, base64];
+  const base58Type = base58Types.find(t => t === maybeType);
+  if (base58Type != null) return [base58Type, base58];
+  throw new ArgumentError('prefix', `one of ${[...base58Types, ...base64Types].join(', ')}`, maybeType);
 };
 /**
  * Decode data using the default encoding/decoding algorithm
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {string} data An Base58/64check encoded and prefixed string (ex tx_..., sg_..., ak_....)
- * @param {string} [requiredPrefix] Ensure that data have this prefix
- * @return {Buffer} Decoded data
+ * @param data - An Base58/64check encoded and prefixed string
+ * (ex tx_..., sg_..., ak_....)
+ * @returns Decoded data
  */
 
-export function decode(data, requiredPrefix) {
-  const [prefix, encodedPayload, extra] = data.split('_');
-  if (!encodedPayload) throw new DecodeError(`Encoded string missing payload: ${data}`);
-  if (extra) throw new DecodeError(`Encoded string have extra parts: ${data}`);
-
-  if (requiredPrefix && requiredPrefix !== prefix) {
-    throw new PrefixMismatchError(prefix, requiredPrefix);
-  }
-
-  const decoder = base64Types.includes(prefix) && base64.decode || base58Types.includes(prefix) && base58.decode;
 
-  if (!decoder) {
-    throw new DecodeError(`Encoded string have unknown type: ${prefix}`);
-  }
-
-  const payload = decoder(encodedPayload);
-  ensureValidLength(payload, prefix);
+export function decode(data) {
+  const [prefix, encodedPayload, extra] = data.split('_');
+  if (encodedPayload == null) throw new DecodeError(`Encoded string missing payload: ${data}`);
+  if (extra != null) throw new DecodeError(`Encoded string have extra parts: ${data}`);
+  const [type, encoder] = parseType(prefix);
+  const payload = encoder.decode(encodedPayload);
+  ensureValidLength(payload, type);
   return payload;
 }
 /**
  * Encode data using the default encoding/decoding algorithm
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {Buffer|String} data  An decoded data
- * @param {string} type Prefix of Transaction
- * @return {String} Encoded string Base58check or Base64check data
+ * @param data - An decoded data
+ * @param type - Prefix of Transaction
+ * @returns Encoded string Base58check or Base64check data
  */
 
 export function encode(data, type) {
-  const encoder = base64Types.includes(type) && base64.encode || base58Types.includes(type) && base58.encode;
-
-  if (!encoder) {
-    throw new EncodeError(`Unknown type: ${type}`);
-  }
-
+  const [, encoder] = parseType(type);
   ensureValidLength(data, type);
-  return `${type}_${encoder(data)}`;
+  return `${type}_${encoder.encode(data)}`;
 }
 //# sourceMappingURL=encoder.mjs.map