@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/src/tx/builder/helpers.js

@@ -1,26 +1,30 @@
-import * as R from 'ramda'
 import BigNumber from 'bignumber.js'
-
-import {
-  decodeBase58Check,
-  decodeBase64Check,
-  encodeBase58Check, encodeBase64Check,
-  hash,
-  salt
-} from '../../utils/crypto'
+import bs58 from 'bs58'
+import { hash, salt, sha256hash } from '../../utils/crypto'
 import { toBytes } from '../../utils/bytes'
 import {
   ID_TAG_PREFIX,
   PREFIX_ID_TAG,
   NAME_BID_RANGES,
-  NAME_BID_MAX_LENGTH,
-  NAME_FEE,
   NAME_FEE_BID_INCREMENT,
   NAME_BID_TIMEOUTS,
   NAME_MAX_LENGTH_FEE,
-  NAME_ID_KEY
+  POINTER_KEY_BY_PREFIX
 } from './schema'
 import { ceil } from '../../utils/bignumber'
+import {
+  PrefixMismatchError,
+  DecodeError,
+  EncodeError,
+  PayloadLengthError,
+  TagNotFoundError,
+  PrefixNotFoundError,
+  InvalidNameError,
+  IllegalBidFeeError,
+  NoDefaultAensPointerError,
+  ArgumentError,
+  InvalidChecksumError
+} from '../../utils/errors'
 
 /**
  * JavaScript-based Transaction builder helper function's
@@ -31,8 +35,6 @@ import { ceil } from '../../utils/bignumber'
 
 export const createSalt = salt
 
-const base64Types = ['tx', 'st', 'ss', 'pi', 'ov', 'or', 'cb', 'cs', 'ba']
-
 /**
  * Build a contract public key
  * @function
@@ -78,11 +80,11 @@ export function formatSalt (salt) {
 }
 
 /**
- * Encode a domain name
+ * Encode an AENS name
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
  * @param {String} name Name to encode
- * @return {String} `nm_` prefixed encoded domain name
+ * @return {String} `nm_` prefixed encoded AENS name
  */
 export function produceNameId (name) {
   ensureNameValid(name)
@@ -103,24 +105,72 @@ export function produceNameId (name) {
  */
 export function commitmentHash (name, salt = createSalt()) {
   ensureNameValid(name)
-  return `cm_${encodeBase58Check(hash(Buffer.concat([Buffer.from(name.toLowerCase()), formatSalt(salt)])))}`
+  return encode(hash(Buffer.concat([Buffer.from(name.toLowerCase()), formatSalt(salt)])), 'cm')
+}
+
+// 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 = {
+  ak: 32,
+  ct: 32,
+  ok: 32
+}
+
+function ensureValidLength (data, type) {
+  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 => sha256hash(sha256hash(payload)).slice(0, 4)
+
+const addChecksum = (input) => {
+  const payload = Buffer.from(input)
+  return Buffer.concat([payload, getChecksum(payload)])
+}
+
+function getPayload (buffer) {
+  const payload = buffer.slice(0, -4)
+  if (!getChecksum(payload).equals(buffer.slice(-4))) throw new InvalidChecksumError()
+  return payload
+}
+
+const base64 = {
+  encode: buffer => addChecksum(buffer).toString('base64'),
+  decode: string => getPayload(Buffer.from(string, 'base64'))
+}
+
+const base58 = {
+  encode: buffer => bs58.encode(addChecksum(buffer)),
+  decode: 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 Base58check or Base64check encoded and prefixed string (ex tx_..., sg_..., ak_....)
+ * @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, requiredPrefix) {
-  const [prefix, payload, extra] = data.split('_')
-  if (extra) throw new Error(`Encoded string have extra parts: ${data}`)
+  if (typeof data !== 'string') throw new DecodeError(`Encoded should be a string, got ${data} instead`)
+  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 Error(`Encoded string have a wrong type: ${prefix} (expected: ${requiredPrefix})`)
+    throw new PrefixMismatchError(prefix, requiredPrefix)
   }
-  return (base64Types.includes(prefix) ? decodeBase64Check : decodeBase58Check)(payload)
+  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
 }
 
 /**
@@ -132,9 +182,13 @@ export function decode (data, requiredPrefix) {
  * @return {String} Encoded string Base58check or Base64check data
  */
 export function encode (data, type) {
-  return `${type}_${base64Types.includes(type)
-    ? encodeBase64Check(data)
-    : encodeBase58Check(data)}`
+  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)}`
 }
 
 /**
@@ -145,9 +199,10 @@ export function encode (data, type) {
  * @return {Buffer} Buffer Buffer with ID tag and decoded HASh
  */
 export function writeId (hashId) {
+  if (typeof hashId !== 'string') throw new ArgumentError('hashId', 'a string', hashId)
   const prefix = hashId.slice(0, 2)
   const idTag = PREFIX_ID_TAG[prefix]
-  if (!idTag) throw new Error(`Id tag for prefix ${prefix} not found.`)
+  if (!idTag) throw new TagNotFoundError(prefix)
   return Buffer.from([...toBytes(idTag), ...decode(hashId, prefix)])
 }
 
@@ -159,9 +214,9 @@ export function writeId (hashId) {
  * @return {String} Encoided hash string with prefix
  */
 export function readId (buf) {
-  const tag = buf.readUIntBE(0, 1)
+  const tag = Buffer.from(buf).readUIntBE(0, 1)
   const prefix = ID_TAG_PREFIX[tag]
-  if (!prefix) throw new Error(`Prefix for id-tag ${tag} not found.`)
+  if (!prefix) throw new PrefixNotFoundError(tag)
   return encode(buf.slice(1, buf.length), prefix)
 }
 
@@ -184,14 +239,15 @@ export function writeInt (val) {
  * @return {String} Buffer Buffer from number(BigEndian)
  */
 export function readInt (buf = Buffer.from([])) {
-  return BigNumber(buf.toString('hex'), 16).toString(10)
+  return new BigNumber(Buffer.from(buf).toString('hex'), 16).toString(10)
 }
 
 /**
  * Helper function to build pointers for name update TX
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {Array} pointers - Array of pointers ([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])
+ * @param {Array} pointers - Array of pointers
+ * ([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])
  * @return {Array} Serialized pointers array
  */
 export function buildPointers (pointers) {
@@ -207,7 +263,8 @@ export function buildPointers (pointers) {
  * Helper function to read pointers from name update TX
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {Array} pointers - Array of pointers ([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])
+ * @param {Array} pointers - Array of pointers
+ * ([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])
  * @return {Array} Deserialize pointer array
  */
 export function readPointers (pointers) {
@@ -219,8 +276,10 @@ export function readPointers (pointers) {
   )
 }
 
+const AENS_SUFFIX = '.chain'
+
 /**
- * Ensure that name is valid
+ * Ensure that AENS name is valid
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
  * @param {string} name
@@ -228,12 +287,12 @@ export function readPointers (pointers) {
  * @throws Error
  */
 export function ensureNameValid (name) {
-  if (!name || typeof name !== 'string') throw new Error('Name must be a string')
-  if (!name.endsWith('.chain')) throw new Error(`Name should end with .chain: ${name}`)
+  if (!name || typeof name !== 'string') throw new InvalidNameError('Name must be a string')
+  if (!name.endsWith(AENS_SUFFIX)) throw new InvalidNameError(`Name should end with ${AENS_SUFFIX}: ${name}`)
 }
 
 /**
- * Is name valid
+ * Is AENS name valid
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
  * @param {string} name
@@ -249,63 +308,44 @@ export function isNameValid (name) {
 }
 
 /**
- * What kind of a hash is this? If it begins with 'ak_' it is an
- * account key, if with 'ok_' it's an oracle key.
- *
- * @param s - the hash.
- * returns the type, or throws an exception if type not found.
+ * @param identifier - account/oracle/contract address, or channel
+ * @returns {String} default AENS pointer key
+ * @throws exception when default key not defined
  */
-export function classify (s) {
-  if (!s.match(/^[a-z]{2}_.+/)) {
-    throw new Error('Not a valid hash')
-  }
-
-  const klass = s.substr(0, 2)
-  if (klass in NAME_ID_KEY) {
-    return NAME_ID_KEY[klass]
-  } else {
-    throw new Error(`Unknown class ${klass}`)
-  }
+export function getDefaultPointerKey (identifier) {
+  decode(identifier)
+  const prefix = identifier.substr(0, 2)
+  return POINTER_KEY_BY_PREFIX[prefix] ||
+    (() => { throw new NoDefaultAensPointerError(prefix) })()
 }
 
 /**
- * Validate name pointers array
+ * Get the minimum AENS name fee
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {String[]} pointers Pointers array. Allowed values is: account(ak_), oracle(ok_), contract(ct_), channel(ch_)
- * @return {Boolean}
+ * @param {String} name the AENS name to get the fee for
+ * @return {String} the minimum fee for the AENS name auction
  */
-export function validatePointers (pointers = []) {
-  return !pointers
-    .find(p => !p || typeof p !== 'string' || !['ak', 'ok', 'ct', 'ch'].includes(p.split('_')[0]))
-}
-
-/**
- * Get the minimum name fee for a domain
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {String} domain the domain name to get the fee for
- * @return {String} the minimum fee for the domain auction
- */
-export function getMinimumNameFee (domain) {
-  const nameLength = domain.replace('.chain', '').length
-  return NAME_BID_RANGES[nameLength >= NAME_MAX_LENGTH_FEE ? NAME_MAX_LENGTH_FEE : nameLength]
+export function getMinimumNameFee (name) {
+  ensureNameValid(name)
+  const nameLength = name.length - AENS_SUFFIX.length
+  return NAME_BID_RANGES[Math.min(nameLength, NAME_MAX_LENGTH_FEE)]
 }
 
 /**
  * Compute bid fee for AENS auction
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {String} domain the domain name to get the fee for
+ * @param {String} name the AENS name to get the fee for
  * @param {Number|String} startFee Auction start fee
  * @param {Number} [increment=0.5] Bid multiplier(In percentage, must be between 0 and 1)
  * @return {String} Bid fee
  */
-export function computeBidFee (domain, startFee = NAME_FEE, increment = NAME_FEE_BID_INCREMENT) {
-  if (!(Number(increment) === increment && increment % 1 !== 0)) throw new Error(`Increment must be float. Current increment ${increment}`)
-  if (increment < NAME_FEE_BID_INCREMENT) throw new Error(`minimum increment percentage is ${NAME_FEE_BID_INCREMENT}`)
+export function computeBidFee (name, startFee, increment = NAME_FEE_BID_INCREMENT) {
+  if (!(Number(increment) === increment && increment % 1 !== 0)) throw new IllegalBidFeeError(`Increment must be float. Current increment ${increment}`)
+  if (increment < NAME_FEE_BID_INCREMENT) throw new IllegalBidFeeError(`minimum increment percentage is ${NAME_FEE_BID_INCREMENT}`)
   return ceil(
-    BigNumber(BigNumber(startFee).eq(NAME_FEE) ? getMinimumNameFee(domain) : startFee).times(BigNumber(NAME_FEE_BID_INCREMENT).plus(1))
+    BigNumber(startFee ?? getMinimumNameFee(name)).times(BigNumber(NAME_FEE_BID_INCREMENT).plus(1))
   )
 }
 
@@ -313,26 +353,28 @@ export function computeBidFee (domain, startFee = NAME_FEE, increment = NAME_FEE
  * Compute auction end height
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {String} domain the domain name to get the fee for
+ * @param {String} name
  * @param {Number|String} claimHeight Auction starting height
  * @return {String} Auction end height
  */
-export function computeAuctionEndBlock (domain, claimHeight) {
-  return R.cond([
-    [R.lt(5), R.always(NAME_BID_TIMEOUTS[4].plus(claimHeight))],
-    [R.lt(9), R.always(NAME_BID_TIMEOUTS[8].plus(claimHeight))],
-    [R.lte(NAME_BID_MAX_LENGTH), R.always(NAME_BID_TIMEOUTS[12].plus(claimHeight))],
-    [R.T, R.always(BigNumber(claimHeight))]
-  ])(domain.replace('.chain', '').length).toString(10)
+export function computeAuctionEndBlock (name, claimHeight) {
+  ensureNameValid(name)
+  const length = name.length - AENS_SUFFIX.length
+  const h = (length <= 4 && NAME_BID_TIMEOUTS[4]) ||
+    (length <= 8 && NAME_BID_TIMEOUTS[8]) ||
+    (length <= 12 && NAME_BID_TIMEOUTS[12]) ||
+    NAME_BID_TIMEOUTS[13]
+  return h.plus(claimHeight).toString(10)
 }
 
 /**
  * Is name accept going to auction
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {String} name Transaction abiVersion
+ * @param {String} name
  * @return {Boolean}
  */
 export function isAuctionName (name) {
-  return name.replace('.chain', '').length < 13
+  ensureNameValid(name)
+  return name.length < 13 + AENS_SUFFIX.length
 }

package/src/tx/builder/index.js

@@ -2,18 +2,17 @@ import BigNumber from 'bignumber.js'
 import { decode as rlpDecode, encode as rlpEncode } from 'rlp'
 import { AE_AMOUNT_FORMATS, formatAmount } from '../../utils/amount-formatter'
 import { hash } from '../../utils/crypto'
+import { Field } from './field-types'
 
 import {
   DEFAULT_FEE,
   FIELD_TYPES,
   OBJECT_ID_TX_TYPE,
-  PREFIX_ID_TAG,
   TX_DESERIALIZATION_SCHEMA,
   TX_FEE_BASE_GAS,
   TX_FEE_OTHER_GAS,
   TX_SERIALIZATION_SCHEMA,
   TX_TYPE,
-  VALIDATION_MESSAGE,
   VSN
 } from './schema'
 import {
@@ -28,6 +27,7 @@ import {
 } from './helpers'
 import { toBytes } from '../../utils/bytes'
 import MPTree from '../../utils/mptree'
+import { InvalidTxParamsError, SchemaNotFoundError } from '../../utils/errors'
 
 /**
  * JavaScript-based Transaction builder
@@ -50,7 +50,6 @@ function deserializeField (value, type, prefix) {
       return { vmVersion: readInt(Buffer.from([vm])), abiVersion: readInt(Buffer.from([abi])) }
     }
     case FIELD_TYPES.amount:
-      return readInt(value)
     case FIELD_TYPES.int:
       return readInt(value)
     case FIELD_TYPES.id:
@@ -99,11 +98,12 @@ function deserializeField (value, type, prefix) {
           {}
         )
     default:
+      if (type.prototype instanceof Field) return type.deserialize(value)
       return value
   }
 }
 
-function serializeField (value, type, prefix) {
+function serializeField (value, type, prefix, params) {
   switch (type) {
     case FIELD_TYPES.amount:
     case FIELD_TYPES.int:
@@ -144,44 +144,55 @@ function serializeField (value, type, prefix) {
         default: return value
       }
     default:
+      if (type.prototype instanceof Field) return type.serialize(value, params)
       return value
   }
 }
 
-function validateField (value, key, type, prefix) {
-  const assert = (valid, params) => valid ? {} : { [key]: VALIDATION_MESSAGE[type](params) }
+function validateField (value, type, prefix) {
   // All fields are required
-  if (value === undefined || value === null) return { [key]: 'Field is required' }
+  if (value === undefined || value === null) return 'Field is required'
 
   // Validate type of value
   switch (type) {
     case FIELD_TYPES.amount:
     case FIELD_TYPES.int: {
-      const isMinusValue = (!isNaN(value) || BigNumber.isBigNumber(value)) && BigNumber(value).lt(0)
-      return assert((!isNaN(value) || BigNumber.isBigNumber(value)) && BigNumber(value).gte(0), { value, isMinusValue })
+      if (isNaN(value) && !BigNumber.isBigNumber(value)) {
+        return `${value} is not of type Number or BigNumber`
+      }
+      if (new BigNumber(value).lt(0)) return `${value} must be >= 0`
+      return
     }
     case FIELD_TYPES.id: {
       const prefixes = Array.isArray(prefix) ? prefix : [prefix]
-      const p = prefixes.find(p => p === value.split('_')[0])
-      return assert(p && PREFIX_ID_TAG[value.split('_')[0]], { value, prefix })
+      if (!prefixes.includes(value.split('_')[0])) {
+        return `'${value}' prefix doesn't match expected prefix '${prefix}'`
+      }
+      return
     }
-    case FIELD_TYPES.binary:
-      return assert(value.split('_')[0] === prefix, { prefix, value })
-    case FIELD_TYPES.string:
-      return assert(true)
     case FIELD_TYPES.ctVersion:
-      return assert(typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'abiVersion') && Object.prototype.hasOwnProperty.call(value, 'vmVersion'))
+      if (!value?.abiVersion || !value?.vmVersion) {
+        return 'Value must be an object with "vmVersion" and "abiVersion" fields'
+      }
+      return
     case FIELD_TYPES.pointers:
-      return assert(Array.isArray(value) && !value.find(e => e !== Object(e)), { value })
-    default:
-      return {}
+      if (!Array.isArray(value)) return 'Value must be of type Array'
+      if (value.some(p => !p?.key || !p?.id)) {
+        return 'Value must contains only object\'s like \'{key: "account_pubkey", id: "ak_lkamsflkalsdalksdlasdlasdlamd"}\''
+      }
+      if (value.length > 32) {
+        return `Expected 32 pointers or less, got ${value.length} instead`
+      }
   }
 }
 
 function transformParams (params, schema, { denomination } = {}) {
   params = schema
     .filter(([_, t]) => t === FIELD_TYPES.amount)
-    .reduce((acc, [key]) => ({ ...params, [key]: formatAmount(params[key], { denomination }) }), params)
+    .reduce(
+      (acc, [key]) => ({ ...params, [key]: formatAmount(params[key], { denomination }) }),
+      params
+    )
   const schemaKeys = schema.map(([k]) => k)
   return Object
     .entries(params)
@@ -256,7 +267,8 @@ function buildFee (txType, { params, gas = 0, multiplier, vsn }) {
     .plus(TX_FEE_OTHER_GAS(txType, txSize, {
       relativeTtl: getOracleRelativeTtl(params, txType),
       innerTxSize: [TX_TYPE.gaMeta, TX_TYPE.payingFor].includes(txType)
-        ? params.tx.tx.encodedTx.rlpEncoded.length : 0
+        ? params.tx.tx.encodedTx.rlpEncoded.length
+        : 0
     }))
     .times(multiplier)
 }
@@ -290,12 +302,14 @@ export function calculateFee (fee = 0, txType, { gas = 0, params, showWarning =
  * @return {Object} Object with validation errors
  */
 export function validateParams (params, schema, { excludeKeys = [] }) {
-  return schema
-    .filter(([key]) => !excludeKeys.includes(key) && key !== 'payload')
-    .reduce(
-      (acc, [key, type, prefix]) => Object.assign(acc, validateField(params[key], key, type, prefix)),
-      {}
-    )
+  return Object.fromEntries(
+    schema
+      // TODO: allow optional keys in schema
+      .filter(([key]) => !excludeKeys.includes(key) &&
+        !['payload', 'nameFee', 'deposit'].includes(key))
+      .map(([key, type, prefix]) => [key, validateField(params[key], type, prefix)])
+      .filter(([, message]) => message)
+  )
 }
 
 /**
@@ -305,12 +319,16 @@ export function validateParams (params, schema, { excludeKeys = [] }) {
  * @param {Object} params Object with tx params
  * @param {Array} schema Transaction schema
  * @param {Object} [options={}] options
- * @param {Array} [options.excludeKeys=[]] excludeKeys Array of keys to exclude for validation and build
- * @param {String} [options.denomination='aettos'] denomination Denomination of amounts (default: aettos)
+ * @param {String[]} [options.excludeKeys=[]] Array of keys to exclude for validation and build
+ * @param {String} [options.denomination='aettos'] Denomination of amounts
  * @throws {Error} Validation error
  * @return {Array} Array with binary fields of transaction
  */
-export function buildRawTx (params, schema, { excludeKeys = [], denomination = AE_AMOUNT_FORMATS.AETTOS } = {}) {
+export function buildRawTx (
+  params,
+  schema,
+  { excludeKeys = [], denomination = AE_AMOUNT_FORMATS.AETTOS } = {}
+) {
   const filteredSchema = schema.filter(([key]) => !excludeKeys.includes(key))
 
   // Transform `amount` type fields to `aettos`
@@ -318,11 +336,11 @@ export function buildRawTx (params, schema, { excludeKeys = [], denomination = A
   // Validation
   const valid = validateParams(params, schema, { excludeKeys })
   if (Object.keys(valid).length) {
-    throw new Error('Transaction build error. ' + JSON.stringify(valid))
+    throw new InvalidTxParamsError('Transaction build error. ' + JSON.stringify(valid))
   }
 
   return filteredSchema
-    .map(([key, fieldType, prefix]) => serializeField(params[key], fieldType, prefix))
+    .map(([key, fieldType, prefix]) => serializeField(params[key], fieldType, prefix, params))
 }
 
 /**
@@ -358,10 +376,10 @@ const getSchema = ({ vsn, objId, type }) => {
   const schema = isDeserialize ? TX_DESERIALIZATION_SCHEMA : TX_SERIALIZATION_SCHEMA
 
   if (!schema[firstKey]) {
-    throw new Error(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type}`)
+    throw new SchemaNotFoundError(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type}`)
   }
   if (!schema[firstKey][vsn]) {
-    throw new Error(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type} version ${vsn}`)
+    throw new SchemaNotFoundError(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type} version ${vsn}`)
   }
   return schema[firstKey][vsn]
 }
@@ -373,14 +391,25 @@ const getSchema = ({ vsn, objId, type }) => {
  * @param {Object} params Object with tx params
  * @param {String} type Transaction type
  * @param {Object} [options={}] options
- * @param {Object} [options.excludeKeys] excludeKeys Array of keys to exclude for validation and build
+ * @param {String[]} [options.excludeKeys] Array of keys to exclude for validation and build
  * @param {String} [options.prefix] Prefix of transaction
  * @throws {Error} Validation error
- * @return {Object} { tx, rlpEncoded, binary } Object with tx -> Base64Check transaction hash with 'tx_' prefix, rlp encoded transaction and binary transaction
+ * @returns {Object} object
+ * @returns {String} object.tx Base64Check transaction hash with 'tx_' prefix
+ * @returns {Buffer} object.rlpEncoded rlp encoded transaction
+ * @returns {Array<Buffer>} object.binary binary transaction
  */
-export function buildTx (params, type, { excludeKeys = [], prefix = 'tx', vsn = VSN, denomination = AE_AMOUNT_FORMATS.AETTOS } = {}) {
+export function buildTx (
+  params,
+  type,
+  { excludeKeys = [], prefix = 'tx', vsn = VSN, denomination = AE_AMOUNT_FORMATS.AETTOS } = {}
+) {
   const [schema, tag] = getSchema({ type, vsn })
-  const binary = buildRawTx({ ...params, VSN: vsn, tag }, schema, { excludeKeys, denomination: params.denomination || denomination }).filter(e => e !== undefined)
+  const binary = buildRawTx(
+    { ...params, VSN: vsn, tag },
+    schema,
+    { excludeKeys, denomination: params.denomination || denomination }
+  ).filter(e => e !== undefined)
 
   const rlpEncoded = rlpEncode(binary)
   const tx = encode(rlpEncoded, prefix)
@@ -392,10 +421,14 @@ export function buildTx (params, type, { excludeKeys = [], prefix = 'tx', vsn =
  * Unpack transaction hash
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {String|Buffer} encodedTx String or RLP encoded transaction array (if fromRlpBinary flag is true)
+ * @param {String|Buffer} encodedTx String or RLP encoded transaction array
+ * (if fromRlpBinary flag is true)
  * @param {Boolean} fromRlpBinary Unpack from RLP encoded transaction (default: false)
  * @param {String} prefix - Prefix of data
- * @return {Object} { tx, rlpEncoded, binary } Object with tx -> Object with transaction param's, rlp encoded transaction and binary transaction
+ * @returns {Object} object
+ * @returns {Object} object.tx Object with transaction param's
+ * @returns {Buffer} object.rlpEncoded rlp encoded transaction
+ * @returns {Array<Buffer>} object.binary binary transaction
  */
 export function unpackTx (encodedTx, fromRlpBinary = false, prefix = 'tx') {
   const rlpEncoded = fromRlpBinary ? encodedTx : decode(encodedTx, prefix)
@@ -420,4 +453,13 @@ export function buildTxHash (rawTx) {
   return encode(hash(data), 'th')
 }
 
-export default { calculateMinFee, calculateFee, unpackTx, unpackRawTx, buildTx, buildRawTx, validateParams, buildTxHash }
+export default {
+  calculateMinFee,
+  calculateFee,
+  unpackTx,
+  unpackRawTx,
+  buildTx,
+  buildRawTx,
+  validateParams,
+  buildTxHash
+}