@aeternity/aepp-sdk 10.0.0 → 11.0.0

package/src/utils/crypto.js

@@ -21,14 +21,14 @@
  * @example import { Crypto } from '@aeternity/aepp-sdk'
  */
 
-import bs58check from 'bs58check'
 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'
 
@@ -43,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')
 }
 
 /**
@@ -54,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
@@ -91,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
@@ -175,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
@@ -210,7 +140,7 @@ export function generateKeyPair (raw = false) {
     }
   } else {
     return {
-      publicKey: `ak_${encodeBase58Check(publicBuffer)}`,
+      publicKey: encode(publicBuffer, 'ak'),
       secretKey: secretBuffer.toString('hex')
     }
   }
@@ -271,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]))
 }
 
@@ -283,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
  *