@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/src/utils/amount-formatter.ts

@@ -14,33 +14,24 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-
-/**
- * Amount Formatter
- * @module @aeternity/aepp-sdk/es/utils/amount-formatter
- * @example import { AmountFormatter } from '@aeternity/aepp-sdk'
- */
 import BigNumber from 'bignumber.js'
 import { isBigNumber } from './bignumber'
-import { ArgumentError, InvalidDenominationError } from './errors'
+import { ArgumentError } from './errors'
 
-/**
- * AE amount formats
- */
-export const AE_AMOUNT_FORMATS = {
-  AE: 'ae',
-  MILI_AE: 'miliAE',
-  MICRO_AE: 'microAE',
-  NANO_AE: 'nanoAE',
-  PICO_AE: 'picoAE',
-  FEMTO_AE: 'femtoAE',
-  AETTOS: 'aettos'
+export enum AE_AMOUNT_FORMATS {
+  AE = 'ae',
+  MILI_AE = 'miliAE',
+  MICRO_AE = 'microAE',
+  NANO_AE = 'nanoAE',
+  PICO_AE = 'picoAE',
+  FEMTO_AE = 'femtoAE',
+  AETTOS = 'aettos'
 }
 
 /**
  * DENOMINATION_MAGNITUDE
  */
-export const DENOMINATION_MAGNITUDE = {
+const DENOMINATION_MAGNITUDE = {
   [AE_AMOUNT_FORMATS.AE]: 0,
   [AE_AMOUNT_FORMATS.MILI_AE]: -3,
   [AE_AMOUNT_FORMATS.MICRO_AE]: -6,
@@ -48,50 +39,46 @@ export const DENOMINATION_MAGNITUDE = {
   [AE_AMOUNT_FORMATS.PICO_AE]: -12,
   [AE_AMOUNT_FORMATS.FEMTO_AE]: -15,
   [AE_AMOUNT_FORMATS.AETTOS]: -18
-}
+} as const
 
 /**
  * Convert amount to AE
- * @param {String|Number|BigNumber} value amount to convert
- * @param {Object} [options={}] options
- * @param {String} [options.denomination='aettos'] denomination of amount, can be ['ae', 'aettos']
- * @return {String}
+ * @param value - amount to convert
+ * @param options - options
+ * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
  */
 export const toAe = (
   value: string | number | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AETTOS } = {}
+  { denomination = AE_AMOUNT_FORMATS.AETTOS }: { denomination?: AE_AMOUNT_FORMATS } = {}
 ): string => formatAmount(value, { denomination, targetDenomination: AE_AMOUNT_FORMATS.AE })
 
 /**
  * Convert amount to aettos
- * @param {String|Number|BigNumber} value amount to convert
- * @param {Object} [options={}] options
- * @param {String} [options.denomination='ae'] denomination of amount, can be ['ae', 'aettos']
- * @return {String}
+ * @param value - amount to convert
+ * @param options - options
+ * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
  */
 export const toAettos = (
   value: string | number | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AE } = {}
+  { denomination = AE_AMOUNT_FORMATS.AE }: { denomination?: AE_AMOUNT_FORMATS } = {}
 ): string => formatAmount(value, { denomination })
 
 /**
  * Convert amount from one to other denomination
- * @param {String|Number|BigNumber} value amount to convert
- * @param {Object} [options={}] options
- * @param {String} [options.denomination='aettos'] denomination of amount, can be ['ae', 'aettos']
- * @param {String} [options.targetDenomination='aettos'] target denomination, can be ['ae', 'aettos']
- * @return {String}
+ * @param value - amount to convert
+ * @param options - options
+ * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
+ * @param options.targetDenomination - target denomination,
+ * can be ['ae', 'aettos']
  */
 export const formatAmount = (
-  value: string | number | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AETTOS, targetDenomination = AE_AMOUNT_FORMATS.AETTOS } = {}
+  value: string | number | bigint | BigNumber,
+  { denomination = AE_AMOUNT_FORMATS.AETTOS, targetDenomination = AE_AMOUNT_FORMATS.AETTOS }:
+  { denomination?: AE_AMOUNT_FORMATS, targetDenomination?: AE_AMOUNT_FORMATS }
 ): string => {
-  const denominations = Object.values(AE_AMOUNT_FORMATS)
-  if (!denominations.includes(denomination)) throw new InvalidDenominationError(`Invalid denomination: ${denomination}`)
-  if (!denominations.includes(targetDenomination)) throw new InvalidDenominationError(`Invalid target denomination: ${targetDenomination}`)
-  if (!isBigNumber(value)) throw new ArgumentError('value', `a number`, value)
+  if (!isBigNumber(value)) throw new ArgumentError('value', 'a number', value)
 
-  return new BigNumber(value)
+  return new BigNumber(typeof value === 'bigint' ? value.toString() : value)
     .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])
     .toFixed()
 }

package/src/utils/autorest.ts

@@ -0,0 +1,90 @@
+import { RestError, PipelineResponse, PipelinePolicy } from '@azure/core-rest-pipeline'
+import { AdditionalPolicyConfig } from '@azure/core-client'
+import { pause } from './other'
+import semverSatisfies from './semver-satisfies'
+import { UnsupportedVersionError } from './errors'
+
+export const genRequestQueuesPolicy = (): AdditionalPolicyConfig => {
+  const requestQueues = new Map<string, Promise<unknown>>()
+
+  return {
+    policy: {
+      name: 'request-queues',
+      async sendRequest (request, next) {
+        const key = request.headers.get('__queue')
+        request.headers.delete('__queue')
+        const getResponse = async (): Promise<PipelineResponse> => await next(request)
+        if (key == null) return await getResponse()
+        const req = (requestQueues.get(key) ?? Promise.resolve()).then(getResponse, getResponse)
+        // TODO: remove after fixing https://github.com/aeternity/aeternity/issues/3803
+        // gap to ensure that node won't reject the nonce
+        requestQueues.set(key, req.then(async () => await pause(750)))
+        return await req
+      }
+    },
+    position: 'perCall'
+  }
+}
+
+export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
+  const pendingGetRequests = new Map<string, Promise<PipelineResponse>>()
+
+  return {
+    policy: {
+      name: 'combine-requests',
+      async sendRequest (request, next) {
+        if (request.method !== 'GET') return await next(request)
+        const key = JSON.stringify([request.url, request.body])
+        const response = pendingGetRequests.get(key) ?? next(request)
+        pendingGetRequests.set(key, response)
+        try {
+          return await response
+        } finally {
+          pendingGetRequests.delete(key)
+        }
+      }
+    },
+    position: 'perCall'
+  }
+}
+
+export const genErrorFormatterPolicy = (
+  getMessage: (b: any) => string
+): AdditionalPolicyConfig => ({
+  policy: {
+    name: 'error-formatter',
+    async sendRequest (request, next) {
+      try {
+        return await next(request)
+      } catch (error) {
+        if (!(error instanceof RestError) || error.request == null) throw error
+        if (error.response?.bodyAsText == null) throw error
+
+        let body
+        try {
+          body = JSON.parse(error.response.bodyAsText)
+        } catch (e) {
+          throw error
+        }
+        error.message = `${new URL(error.request.url).pathname.slice(1)} error`
+        const message = getMessage(body)
+        if (message !== '') error.message += `:${message}`
+        throw error
+      }
+    }
+  },
+  position: 'perCall'
+})
+
+export const genVersionCheckPolicy = (
+  name: string, ignorePath: string,
+  versionPromise: Promise<string>, geVersion: string, ltVersion: string
+): PipelinePolicy => ({
+  name: 'version-check',
+  async sendRequest (request, next) {
+    if (new URL(request.url).pathname === ignorePath) return await next(request)
+    const args = [await versionPromise, geVersion, ltVersion] as const
+    if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args)
+    return await next(request)
+  }
+})

package/src/utils/bignumber.ts

@@ -1,22 +1,20 @@
 /**
  * Big Number Helpers
- * @module @aeternity/aepp-sdk/es/utils/bignumber
- * @example import { isBigNumber, ceil } from '@aeternity/aepp-sdk/es/utils/bignumber'
  */
 import BigNumber from 'bignumber.js'
 
 /**
- * Check if value is BigNumber, Number or number string representation
- * @param {String|Number|BigNumber} number number to convert
- * @return {Boolean}
+ * Check if value is BigNumber, Number, BigInt or number string representation
+ * @param number - number to check
  */
-export const isBigNumber = (number: string | number | BigNumber): boolean =>
-  ['number', 'object', 'string', 'bigint'].includes(typeof number) &&
-  (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
+export const isBigNumber = (number: string | number | bigint | BigNumber): boolean => {
+  if (typeof number === 'bigint') return true
+  return ['number', 'object', 'string'].includes(typeof number) &&
+    (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
+}
 
 /**
  * BigNumber ceil operation
- * @param {BigNumber} bigNumber
- * @return {BigNumber}
  */
-export const ceil = (bigNumber: BigNumber): BigNumber => bigNumber.integerValue(BigNumber.ROUND_CEIL)
+export const ceil = (bigNumber: BigNumber): BigNumber => bigNumber
+  .integerValue(BigNumber.ROUND_CEIL)

package/src/utils/bytes.ts

@@ -18,16 +18,10 @@ import BigNumber from 'bignumber.js'
 import { NoSerializerFoundError, TypeError } from './errors'
 import { isBase64, isHex } from './string'
 
-/**
- * Bytes module
- * @module @aeternity/aepp-sdk/es/utils/bytes
- * @example import { Crypto } from '@aeternity/aepp-sdk'
- */
-
 /**
  * Convert bignumber to byte array
- * @param {BigNumber} x bignumber instance
- * @return Buffer
+ * @param x - bignumber instance
+ * @returns Buffer
  */
 export function bigNumberToByteArray (x: BigNumber): Buffer {
   if (!x.isInteger()) throw new TypeError(`Unexpected not integer value: ${x.toFixed()}`)
@@ -38,9 +32,9 @@ export function bigNumberToByteArray (x: BigNumber): Buffer {
 
 /**
  * Convert string, number, or BigNumber to byte array
- * @param {null|string|number|BigNumber} val
- * @param {boolean} big enables force conversion to BigNumber
- * @return Buffer
+ * @param val - value to convert
+ * @param big - enables force conversion to BigNumber
+ * @returns Buffer
  */
 export function toBytes (val?: null | string | number | BigNumber, big: boolean = false): Buffer {
   // Encode a value to bytes.
@@ -62,9 +56,9 @@ export function toBytes (val?: null | string | number | BigNumber, big: boolean
  * Convert a string to a Buffer.  If encoding is not specified, hex-encoding
  * will be used if the input is valid hex.  If the input is valid base64 but
  * not valid hex, base64 will be used.  Otherwise, utf8 will be used.
- * @param {string} str String to be converted.
- * @param {string} [enc] Encoding of the input string.
- * @return {buffer} Buffer containing the input data.
+ * @param str - String to be converted.
+ * @param enc - Encoding of the input string.
+ * @returns Buffer containing the input data.
  */
 export function str2buf (str: string, enc?: BufferEncoding): Buffer {
   return Buffer.from(
@@ -72,3 +66,7 @@ export function str2buf (str: string, enc?: BufferEncoding): Buffer {
     enc ?? (isHex(str) ? 'hex' : undefined) ?? (isBase64(str) ? 'base64' : undefined)
   )
 }
+
+export const bytesToHex = (b: Uint8Array): string => Buffer.from(b).toString('hex')
+
+export const hexToBytes = (s: string): Uint8Array => Buffer.from(s, 'hex')

package/src/utils/crypto.ts

@@ -0,0 +1,217 @@
+/*
+ * ISC License (ISC)
+ * Copyright 2018 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import nacl, { SignKeyPair } from 'tweetnacl'
+import aesjs from 'aes-js'
+import { blake2b, Data } from 'blakejs'
+import { encode as varuintEncode } from 'varuint-bitcoin'
+
+import { str2buf } from './bytes'
+import { concatBuffers } from './other'
+import { encode, decode, sha256hash, EncodedData, EncodingType } from './encoder'
+
+export { sha256hash }
+
+const Ecb = aesjs.ModeOfOperation.ecb
+
+/**
+ * Generate address from secret key
+ * @param secret - Private key
+ * @returns Public key encoded as address
+ */
+export function getAddressFromPriv (secret: string | Uint8Array): EncodedData<'ak'> {
+  const secretBuffer = typeof secret === 'string' ? str2buf(secret) : secret
+  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer)
+  return encode(keys.publicKey, 'ak')
+}
+
+/**
+ * Check if address is valid
+ * @param address - Address
+ * @param prefix - Transaction prefix. Default: 'ak'
+ * @returns is valid
+ */
+export function isAddressValid (address: string, prefix: EncodingType = 'ak'): boolean {
+  try {
+    decode(address as EncodedData<typeof prefix>)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+/**
+ * Generate a random salt (positive integer)
+ * @returns random salt
+ */
+export function salt (): number {
+  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
+ * @param value - Value to encode
+ * @returns Encoded number
+ */
+export function encodeUnsigned (value: number): Buffer {
+  const binary = Buffer.allocUnsafe(4)
+  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: Data): Buffer {
+  return Buffer.from(blake2b(input, undefined, 32)) // 256 bits
+}
+
+// Todo Duplicated in tx builder. remove
+/**
+ * Compute contract address
+ * @param owner - Address of contract owner
+ * @param nonce - Round when contract was created
+ * @returns Contract address
+ */
+export function encodeContractAddress (owner: EncodedData<'ak'>, nonce: number): EncodedData<'ct'> {
+  const publicKey = decode(owner)
+  const binary = concatBuffers([publicKey, encodeUnsigned(nonce)])
+  return encode(hash(binary), 'ct')
+}
+
+// KEY-PAIR HELPERS
+
+/**
+ * Generate keyPair from secret key
+ * @param secret - secret key
+ * @returns Object with Private(privateKey) and Public(publicKey) keys
+ */
+export function generateKeyPairFromSecret (secret: Uint8Array): SignKeyPair {
+  return nacl.sign.keyPair.fromSecretKey(secret)
+}
+
+/**
+ * Generate a random ED25519 keypair
+ * @param raw - Whether to return raw (binary) keys
+ * @returns Key pair
+ */
+export function generateKeyPair (raw: true): { publicKey: Buffer, secretKey: Buffer }
+export function generateKeyPair (raw?: false): { publicKey: EncodedData<'ak'>, secretKey: string }
+export function generateKeyPair (raw: boolean = false): {
+  publicKey: EncodedData<'ak'> | Buffer
+  secretKey: string | Buffer
+} {
+  const keyPair = nacl.sign.keyPair()
+  const publicBuffer = Buffer.from(keyPair.publicKey)
+  const secretBuffer = Buffer.from(keyPair.secretKey)
+
+  if (raw) {
+    return {
+      publicKey: publicBuffer,
+      secretKey: secretBuffer
+    }
+  } else {
+    return {
+      publicKey: encode(publicBuffer, 'ak'),
+      secretKey: secretBuffer.toString('hex')
+    }
+  }
+}
+
+/**
+ * Encrypt given data using `password`
+ * @param password - Password to encrypt with
+ * @param binaryData - Data to encrypt
+ * @returns Encrypted data
+ */
+export function encryptKey (password: string, binaryData: Uint8Array): Uint8Array {
+  const hashedPasswordBytes = sha256hash(password)
+  const aesEcb = new Ecb(hashedPasswordBytes)
+  return aesEcb.encrypt(binaryData)
+}
+
+/**
+ * Decrypt given data using `password`
+ * @param password - Password to decrypt with
+ * @param encrypted - Data to decrypt
+ * @returns Decrypted data
+ */
+export function decryptKey (password: string, encrypted: Uint8Array): Uint8Array {
+  const encryptedBytes = Buffer.from(encrypted)
+  const hashedPasswordBytes = sha256hash(password)
+  const aesEcb = new Ecb(hashedPasswordBytes)
+  return aesEcb.decrypt(encryptedBytes)
+}
+
+// SIGNATURES
+
+/**
+ * Generate signature
+ * @param data - Data to sign
+ * @param privateKey - Key to sign with
+ * @returns Signature
+ */
+export function sign (data: string | Uint8Array, privateKey: string | Uint8Array): Uint8Array {
+  return nacl.sign.detached(Buffer.from(data), Buffer.from(privateKey))
+}
+
+/**
+ * Verify that signature was signed by public key
+ * @param data - Data to verify
+ * @param signature - Signature to verify
+ * @param publicKey - Key to verify against
+ * @returns Valid?
+ */
+export function verify (
+  data: Uint8Array, signature: Uint8Array, publicKey: string | Uint8Array
+): boolean {
+  const publicKeyBuffer = typeof publicKey === 'string' ? str2buf(publicKey) : publicKey
+  return nacl.sign.detached.verify(data, signature, publicKeyBuffer)
+}
+
+export function messageToHash (message: string): Buffer {
+  const p = Buffer.from('aeternity Signed Message:\n', 'utf8')
+  const msg = Buffer.from(message, 'utf8')
+  return hash(concatBuffers([varuintEncode(p.length), p, varuintEncode(msg.length), msg]))
+}
+
+export function signMessage (message: string, privateKey: string | Buffer): Uint8Array {
+  return sign(messageToHash(message), privateKey)
+}
+
+export function verifyMessage (
+  str: string, signature: Uint8Array, publicKey: string | Uint8Array): boolean {
+  return verify(messageToHash(str), signature, publicKey)
+}
+
+/**
+ * Check key pair for validity
+ *
+ * Sign a message, and then verifying that signature
+ * @param privateKey - Private key to verify
+ * @param publicKey - Public key to verify
+ * @returns Valid?
+ */
+export function isValidKeypair (
+  privateKey: string | Uint8Array, publicKey: string | Uint8Array
+): boolean {
+  const message = Buffer.from('TheMessage')
+  const signature = sign(message, privateKey)
+  return verify(message, signature, publicKey)
+}

package/src/utils/encoder.ts

@@ -1,101 +1,98 @@
-import * as bs58 from 'bs58'
-import { sha256 } from 'sha.js'
+import { encode as bs58Encode, decode as bs58Decode } from 'bs58'
+import { sha256 as Sha256 } from 'sha.js'
 import {
   DecodeError,
-  EncodeError,
+  ArgumentError,
   InvalidChecksumError,
-  PayloadLengthError,
-  PrefixMismatchError
+  PayloadLengthError
 } from './errors'
+import { concatBuffers } from './other'
 
 /**
  * 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
  */
-export function sha256hash (input: Buffer | string) {
-  return new sha256().update(input).digest()
+export function sha256hash (input: Uint8Array | string): Buffer {
+  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']
+const base64Types = ['ba', 'cb', 'or', 'ov', 'pi', 'ss', 'cs', 'ck', 'cv', 'st', 'tx'] as const
+const base58Types = ['ak', 'bf', 'bs', 'bx', 'ch', 'cm', 'ct', 'kh', 'mh', 'nm', 'ok', 'oq', 'pp', 'sg', 'th'] as const
+
+export type EncodingType = typeof base64Types[number] | typeof base58Types[number]
+export type EncodedData<Type extends EncodingType> = `${Type}_${string}`
 // TODO: add all types with a fixed length
-const typesLength: { [name: string]: number } = {
+const typesLength: { [name in EncodingType]?: 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`)
+function ensureValidLength (data: Uint8Array, type: EncodingType): void {
+  const reqLen = typesLength[type]
+  if (reqLen == null || data.length === reqLen) return
+  throw new PayloadLengthError(`Payload should be ${reqLen} bytes, got ${data.length} instead`)
 }
 
-const getChecksum = (payload: Buffer | string) => sha256hash(sha256hash(payload)).slice(0, 4)
+const getChecksum = (payload: Uint8Array): Buffer =>
+  sha256hash(sha256hash(payload)).slice(0, 4)
 
-const addChecksum = (input: Buffer | string) => {
-  const payload = Buffer.from(input)
-  return Buffer.concat([payload, getChecksum(payload)])
+const addChecksum = (payload: Uint8Array): Buffer => {
+  return concatBuffers([payload, getChecksum(payload)])
 }
 
-function getPayload (buffer: Buffer) {
+function getPayload (buffer: 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'),
+  encode: (buffer: Uint8Array) => 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))
+  encode: (buffer: Uint8Array) => bs58Encode(addChecksum(buffer)),
+  decode: (string: string) => getPayload(Buffer.from(bs58Decode(string)))
+}
+
+const parseType = (maybeType: unknown): [EncodingType, typeof base64] => {
+  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: string, requiredPrefix?: string) {
+export function decode (data: EncodedData<EncodingType>): Buffer {
   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)
+  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, { decode }] = parseType(prefix)
+  const payload = 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: Buffer | string, type: string) {
-  const encoder = (base64Types.includes(type) && base64.encode) ||
-    (base58Types.includes(type) && base58.encode)
-  if (!encoder) {
-    throw new EncodeError(`Unknown type: ${type}`)
-  }
+export function encode<Type extends EncodingType> (
+  data: Uint8Array, type: Type
+): EncodedData<Type> {
+  const [, { encode }] = parseType(type)
   ensureValidLength(data, type)
-  return `${type}_${encoder(data)}`
+  return `${type}_${encode(data)}`
 }