@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/utils/amount-formatter.ts

@@ -14,32 +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 } 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,
@@ -47,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 Error(`Invalid denomination: ${denomination}`)
-  if (!denominations.includes(targetDenomination)) throw new Error(`Invalid target denomination: ${targetDenomination}`)
-  if (!isBigNumber(value)) throw new Error(`Value ${value?.toString()} is not type of number`)
+  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,30 +1,20 @@
 /**
  * Big Number Helpers
- * @module @aeternity/aepp-sdk/es/utils/bignumber
- * @example import { parseBigNumber, isBigNumber, ceil } from '@aeternity/aepp-sdk/es/utils/bignumber'
  */
 import BigNumber from 'bignumber.js'
 
 /**
- * Convert number to string
- * @param {String|Number|BigNumber} number number to convert
- * @return {String}
+ * Check if value is BigNumber, Number, BigInt or number string representation
+ * @param number - number to check
  */
-export const parseBigNumber = (number: string | number | BigNumber): string =>
-  new BigNumber(number.toString()).toString(10)
-
-/**
- * Check if value is BigNumber, Number or number string representation
- * @param {String|Number|BigNumber} number number to convert
- * @return {Boolean}
- */
-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

@@ -15,21 +15,16 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 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 Error(`Unexpected not integer value: ${x.toFixed()}`)
+  if (!x.isInteger()) throw new TypeError(`Unexpected not integer value: ${x.toFixed()}`)
   let hexString = x.toString(16)
   if (hexString.length % 2 === 1) hexString = '0' + hexString
   return Buffer.from(hexString, 'hex')
@@ -37,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.
@@ -54,16 +49,16 @@ export function toBytes (val?: null | string | number | BigNumber, big: boolean
   if (typeof val === 'string') {
     return Buffer.from(val)
   }
-  throw new Error('Byte serialization not supported')
+  throw new NoSerializerFoundError()
 }
 
 /**
  * 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(
@@ -71,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

@@ -0,0 +1,98 @@
+import { encode as bs58Encode, decode as bs58Decode } from 'bs58'
+import { sha256 as Sha256 } from 'sha.js'
+import {
+  DecodeError,
+  ArgumentError,
+  InvalidChecksumError,
+  PayloadLengthError
+} from './errors'
+import { concatBuffers } from './other'
+
+/**
+ * Calculate SHA256 hash of `input`
+ * @param input - Data to hash
+ * @returns Hash
+ */
+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'] 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 in EncodingType]?: number } = {
+  ak: 32,
+  ct: 32,
+  ok: 32
+} as const
+
+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: Uint8Array): Buffer =>
+  sha256hash(sha256hash(payload)).slice(0, 4)
+
+const addChecksum = (payload: Uint8Array): Buffer => {
+  return concatBuffers([payload, getChecksum(payload)])
+}
+
+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: Uint8Array) => addChecksum(buffer).toString('base64'),
+  decode: (string: string) => getPayload(Buffer.from(string, 'base64'))
+}
+
+const base58 = {
+  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
+ * @param data - An Base58/64check encoded and prefixed string
+ * (ex tx_..., sg_..., ak_....)
+ * @returns Decoded data
+ */
+export function decode (data: EncodedData<EncodingType>): Buffer {
+  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, { decode }] = parseType(prefix)
+  const payload = decode(encodedPayload)
+  ensureValidLength(payload, type)
+  return payload
+}
+
+/**
+ * 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 function encode<Type extends EncodingType> (
+  data: Uint8Array, type: Type
+): EncodedData<Type> {
+  const [, { encode }] = parseType(type)
+  ensureValidLength(data, type)
+  return `${type}_${encode(data)}`
+}