@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/src/utils/crypto.js

@@ -21,15 +21,14 @@
  * @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 } from '../tx/builder/helpers'
 import { hash } from './crypto-ts'
+import { NotImplementedError } from './errors'
 
 export * from './crypto-ts'
 
@@ -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,24 +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
@@ -92,66 +81,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 +105,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 +122,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 +140,7 @@ export function generateKeyPair (raw = false) {
     }
   } else {
     return {
-      publicKey: `ak_${encodeBase58Check(publicBuffer)}`,
+      publicKey: encode(publicBuffer, 'ak'),
       secretKey: secretBuffer.toString('hex')
     }
   }
@@ -272,7 +201,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 +213,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 +227,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
-}