@aeternity/aepp-sdk 10.0.0-beta.1 → 11.0.1

package/src/utils/crypto.js

@@ -21,17 +21,16 @@
  * @example import { Crypto } from '@aeternity/aepp-sdk'
  */
 
-import bs58check from 'bs58check'
-import ed2curve from 'ed2curve'
 import nacl from 'tweetnacl'
 import aesjs from 'aes-js'
-import shajs from 'sha.js'
 
-import { str2buf, toBytes } from './bytes'
-import { decode } from '../tx/builder/helpers'
+import { str2buf } from './bytes'
+import { encode, decode, sha256hash } from './encoder'
 import { hash } from './crypto-ts'
+import { NotImplementedError } from './errors'
 
 export * from './crypto-ts'
+export { sha256hash }
 
 const Ecb = aesjs.ModeOfOperation.ecb
 
@@ -44,7 +43,7 @@ const Ecb = aesjs.ModeOfOperation.ecb
 export function getAddressFromPriv (secret) {
   const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret))
   const publicBuffer = Buffer.from(keys.publicKey)
-  return `ak_${encodeBase58Check(publicBuffer)}`
+  return encode(publicBuffer, 'ak')
 }
 
 /**
@@ -55,34 +54,14 @@ export function getAddressFromPriv (secret) {
  * @return {Boolean} valid
  */
 export function isAddressValid (address, prefix = 'ak') {
-  if (typeof address !== 'string') return false
   try {
-    return decode(address, prefix).length === 32
+    decode(address, prefix)
+    return true
   } catch (e) {
     return false
   }
 }
 
-/**
- * Parse decimal address and return base58Check encoded address with prefix 'ak'
- * @rtype (input: String) => address: String
- * @param {String} decimalAddress - Address
- * @return {String} address
- */
-export function addressFromDecimal (decimalAddress) {
-  return aeEncodeKey(toBytes(decimalAddress, true))
-}
-
-/**
- * Calculate SHA256 hash of `input`
- * @rtype (input: String) => hash: String
- * @param {String} input - Data to hash
- * @return {String} Hash
- */
-export function sha256hash (input) {
-  return shajs('sha256').update(input).digest()
-}
-
 /**
  * Generate a random salt (positive integer)
  * @rtype () => salt: Number
@@ -92,66 +71,6 @@ export function salt () {
   return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER))
 }
 
-/**
- * Base64check encode given `input`
- * @rtype (input: String|buffer) => Buffer
- * @param {String} input - Data to encode
- * @return {Buffer} Base64check encoded data
- */
-export function encodeBase64Check (input) {
-  const buffer = Buffer.from(input)
-  const checksum = checkSumFn(input)
-  const payloadWithChecksum = Buffer.concat([buffer, checksum], buffer.length + 4)
-  return payloadWithChecksum.toString('base64')
-}
-
-export function checkSumFn (payload) {
-  return sha256hash(sha256hash(payload)).slice(0, 4)
-}
-
-function decodeRaw (buffer) {
-  const payload = buffer.slice(0, -4)
-  const checksum = buffer.slice(-4)
-  const newChecksum = checkSumFn(payload)
-
-  if (!checksum.equals(newChecksum)) return
-
-  return payload
-}
-
-/**
- * Base64check decode given `str`
- * @rtype (str: String) => Buffer
- * @param {String} str - Data to decode
- * @return {Buffer} Base64check decoded data
- */
-export function decodeBase64Check (str) {
-  const buffer = Buffer.from(str, 'base64')
-  const payload = decodeRaw(buffer)
-  if (!payload) throw new Error('Invalid checksum')
-  return Buffer.from(payload)
-}
-
-/**
- * Base58 encode given `input`
- * @rtype (input: String) => String
- * @param {String|Buffer} input - Data to encode
- * @return {String} Base58 encoded data
- */
-export function encodeBase58Check (input) {
-  return bs58check.encode(Buffer.from(input))
-}
-
-/**
- * Base58 decode given `str`
- * @rtype (str: String) => Buffer
- * @param {String} str - Data to decode
- * @return {Buffer} Base58 decoded data
- */
-export function decodeBase58Check (str) {
-  return bs58check.decode(str)
-}
-
 /**
  * Converts a positive integer to the smallest possible
  * representation in a binary digit representation
@@ -176,7 +95,7 @@ export function encodeUnsigned (value) {
 export function encodeContractAddress (owner, nonce) {
   const publicKey = decode(owner, 'ak')
   const binary = Buffer.concat([publicKey, encodeUnsigned(nonce)])
-  return `ct_${encodeBase58Check(hash(binary))}`
+  return encode(hash(binary), 'ct')
 }
 
 // KEY-PAIR HELPERS
@@ -193,7 +112,7 @@ export function generateKeyPairFromSecret (secret) {
 
 /**
  * Generate a random ED25519 keypair
- * @rtype (raw: Boolean) => {publicKey: String, secretKey: String} | {publicKey: Buffer, secretKey: Buffer}
+ * @rtype (raw: Boolean) => {publicKey: String | Buffer, secretKey: String | Buffer}
  * @param {Boolean} raw - Whether to return raw (binary) keys
  * @return {Object} Key pair
  */
@@ -211,7 +130,7 @@ export function generateKeyPair (raw = false) {
     }
   } else {
     return {
-      publicKey: `ak_${encodeBase58Check(publicBuffer)}`,
+      publicKey: encode(publicBuffer, 'ak'),
       secretKey: secretBuffer.toString('hex')
     }
   }
@@ -272,7 +191,7 @@ export function verify (str, signature, publicKey) {
 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 Error('message too long')
+  if (msg.length >= 0xFD) throw new NotImplementedError('Message too long')
   return hash(Buffer.concat([Buffer.from([p.length]), p, Buffer.from([msg.length]), msg]))
 }
 
@@ -284,19 +203,6 @@ export function verifyMessage (str, signature, publicKey) {
   return verify(messageToHash(str), signature, publicKey)
 }
 
-/**
- * æternity readable public keys are the base58-encoded public key, prepended
- * with 'ak_'
- * @rtype (binaryKey: Buffer) => String
- * @param {Buffer} binaryKey - Key to encode
- * @return {String} Encoded key
- */
-export function aeEncodeKey (binaryKey) {
-  const publicKeyBuffer = Buffer.from(binaryKey, 'hex')
-  const pubKeyAddress = encodeBase58Check(publicKeyBuffer)
-  return `ak_${pubKeyAddress}`
-}
-
 /**
  * Check key pair for validity
  *
@@ -311,53 +217,3 @@ export function isValidKeypair (privateKey, publicKey) {
   const signature = sign(message, privateKey)
   return verify(message, signature, publicKey)
 }
-
-/**
- * This function encrypts a message using base58check encoded and 'ak' prefixed
- * publicKey such that only the corresponding secretKey will
- * be able to decrypt
- * @rtype (msg: String, publicKey: String) => Object
- * @param {Buffer} msg - Data to encode
- * @param {String} publicKey - Public key
- * @return {Object}
- */
-export function encryptData (msg, publicKey) {
-  const ephemeralKeyPair = nacl.box.keyPair()
-  const pubKeyUInt8Array = decode(publicKey, 'ak')
-  const nonce = nacl.randomBytes(nacl.box.nonceLength)
-
-  const encryptedMessage = nacl.box(
-    Buffer.from(msg),
-    nonce,
-    ed2curve.convertPublicKey(pubKeyUInt8Array),
-    ephemeralKeyPair.secretKey
-  )
-
-  return {
-    ciphertext: Buffer.from(encryptedMessage).toString('hex'),
-    ephemPubKey: Buffer.from(ephemeralKeyPair.publicKey).toString('hex'),
-    nonce: Buffer.from(nonce).toString('hex'),
-    version: 'x25519-xsalsa20-poly1305'
-  }
-}
-
-/**
- * This function decrypt a message using secret key
- * @rtype (secretKey: String, encryptedData: Object) => Buffer|null
- * @param {String} secretKey - Secret key
- * @param {Object} encryptedData - Encrypted data
- * @return {Buffer|null}
- */
-export function decryptData (secretKey, encryptedData) {
-  const receiverSecretKeyUint8Array = ed2curve.convertSecretKey(Buffer.from(secretKey, 'hex'))
-  const nonce = Buffer.from(encryptedData.nonce, 'hex')
-  const ciphertext = Buffer.from(encryptedData.ciphertext, 'hex')
-  const ephemPubKey = Buffer.from(encryptedData.ephemPubKey, 'hex')
-  const decrypted = nacl.box.open(
-    ciphertext,
-    nonce,
-    ephemPubKey,
-    receiverSecretKeyUint8Array
-  )
-  return decrypted ? Buffer.from(decrypted) : decrypted
-}

package/src/utils/encoder.ts

@@ -0,0 +1,101 @@
+import * as bs58 from 'bs58'
+import { sha256 } from 'sha.js'
+import {
+  DecodeError,
+  EncodeError,
+  InvalidChecksumError,
+  PayloadLengthError,
+  PrefixMismatchError
+} from './errors'
+
+/**
+ * Calculate SHA256 hash of `input`
+ * @rtype (input: String) => hash: String
+ * @param {Buffer|String} input - Data to hash
+ * @return {String} Hash
+ */
+export function sha256hash (input: Buffer | string) {
+  return new sha256().update(input).digest()
+}
+
+// based on https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md
+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 typesLength: { [name: string]: number } = {
+  ak: 32,
+  ct: 32,
+  ok: 32
+} as const
+
+function ensureValidLength (data: Buffer | string, type: string) {
+  if (!typesLength[type]) return
+  if (data.length === typesLength[type]) return
+  throw new PayloadLengthError(`Payload should be ${typesLength[type]} bytes, got ${data.length} instead`)
+}
+
+const getChecksum = (payload: Buffer | string) => sha256hash(sha256hash(payload)).slice(0, 4)
+
+const addChecksum = (input: Buffer | string) => {
+  const payload = Buffer.from(input)
+  return Buffer.concat([payload, getChecksum(payload)])
+}
+
+function getPayload (buffer: Buffer) {
+  const payload = buffer.slice(0, -4)
+  if (!getChecksum(payload).equals(buffer.slice(-4))) throw new InvalidChecksumError()
+  return payload
+}
+
+const base64 = {
+  encode: (buffer: Buffer | string) => addChecksum(buffer).toString('base64'),
+  decode: (string: string) => getPayload(Buffer.from(string, 'base64'))
+}
+
+const base58 = {
+  encode: (buffer: Buffer | string) => bs58.encode(addChecksum(buffer)),
+  decode: (string: string) => getPayload(bs58.decode(string))
+}
+
+/**
+ * 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
+ */
+export function decode (data: string, requiredPrefix?: string) {
+  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)
+  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
+ */
+export function encode (data: Buffer | string, type: string) {
+  const encoder = (base64Types.includes(type) && base64.encode) ||
+    (base58Types.includes(type) && base58.encode)
+  if (!encoder) {
+    throw new EncodeError(`Unknown type: ${type}`)
+  }
+  ensureValidLength(data, type)
+  return `${type}_${encoder(data)}`
+}