@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/es/tx/builder/index.js

@@ -1,36 +1,9 @@
-import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
-import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
-import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
-import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
-import _Object$defineProperties from "@babel/runtime-corejs3/core-js-stable/object/define-properties";
-import _Object$defineProperty from "@babel/runtime-corejs3/core-js-stable/object/define-property";
-import _typeof from "@babel/runtime-corejs3/helpers/typeof";
-import _toConsumableArray from "@babel/runtime-corejs3/helpers/toConsumableArray";
-import _defineProperty from "@babel/runtime-corejs3/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
-
-function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); if (enumerableOnly) { symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { var _context10; _forEachInstanceProperty(_context10 = ownKeys(Object(source), true)).call(_context10, function (key) { _defineProperty(target, key, source[key]); }); } else if (_Object$getOwnPropertyDescriptors) { _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)); } else { var _context11; _forEachInstanceProperty(_context11 = ownKeys(Object(source))).call(_context11, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
-import _reduceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reduce";
-import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
-import _Array$isArray from "@babel/runtime-corejs3/core-js-stable/array/is-array";
-import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
-import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
-import _Object$entries from "@babel/runtime-corejs3/core-js-stable/object/entries";
-import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
-import _Object$assign from "@babel/runtime-corejs3/core-js-stable/object/assign";
-import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
-import _JSON$stringify from "@babel/runtime-corejs3/core-js-stable/json/stringify";
-import _indexOfInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/index-of";
 import BigNumber from 'bignumber.js';
 import { decode as rlpDecode, encode as rlpEncode } from 'rlp';
 import { AE_AMOUNT_FORMATS, formatAmount } from '../../utils/amount-formatter';
-import { assertedType } from '../../utils/crypto';
+import { hash } from '../../utils/crypto';
 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 { readInt, readId, readPointers, writeId, writeInt, buildPointers, encode, decode, buildHash } from './helpers';
+import { readInt, readId, readPointers, writeId, writeInt, buildPointers, encode, decode } from './helpers';
 import { toBytes } from '../../utils/bytes';
 import MPTree from '../../utils/mptree';
 /**
@@ -40,7 +13,7 @@ import MPTree from '../../utils/mptree';
  * @example import { TxBuilder } from '@aeternity/aepp-sdk'
  */
 
-var ORACLE_TTL_TYPES = {
+const ORACLE_TTL_TYPES = {
   delta: 'delta',
   block: 'block'
 }; // SERIALIZE AND DESERIALIZE PART
@@ -51,10 +24,7 @@ function deserializeField(value, type, prefix) {
   switch (type) {
     case FIELD_TYPES.ctVersion:
       {
-        var _value = _slicedToArray(value, 3),
-            vm = _value[0],
-            abi = _value[2];
-
+        const [vm,, abi] = value;
         return {
           vmVersion: readInt(Buffer.from([vm])),
           abiVersion: readInt(Buffer.from([abi]))
@@ -64,14 +34,14 @@ function deserializeField(value, type, prefix) {
     case FIELD_TYPES.amount:
       return readInt(value);
 
-    case FIELD_TYPES["int"]:
+    case FIELD_TYPES.int:
       return readInt(value);
 
     case FIELD_TYPES.id:
       return readId(value);
 
     case FIELD_TYPES.ids:
-      return _mapInstanceProperty(value).call(value, readId);
+      return value.map(readId);
 
     case FIELD_TYPES.bool:
       return value[0] === 1;
@@ -95,9 +65,7 @@ function deserializeField(value, type, prefix) {
       return unpackTx(value, true);
 
     case FIELD_TYPES.rlpBinaries:
-      return _mapInstanceProperty(value).call(value, function (v) {
-        return unpackTx(v, true);
-      });
+      return value.map(v => unpackTx(v, true));
 
     case FIELD_TYPES.rawBinary:
       return value;
@@ -106,18 +74,14 @@ function deserializeField(value, type, prefix) {
       return value.toString('hex');
 
     case FIELD_TYPES.offChainUpdates:
-      return _mapInstanceProperty(value).call(value, function (v) {
-        return unpackTx(v, true);
-      });
+      return value.map(v => unpackTx(v, true));
 
     case FIELD_TYPES.callStack:
       // TODO: fix this
       return [readInt(value)];
 
     case FIELD_TYPES.mptrees:
-      return _mapInstanceProperty(value).call(value, function (t) {
-        return new MPTree(t);
-      });
+      return value.map(t => new MPTree(t));
 
     case FIELD_TYPES.callReturnType:
       switch (readInt(value)) {
@@ -135,18 +99,15 @@ function deserializeField(value, type, prefix) {
       }
 
     case FIELD_TYPES.sophiaCodeTypeInfo:
-      return _reduceInstanceProperty(value).call(value, function (acc, _ref) {
-        var _ref2 = _slicedToArray(_ref, 4),
-            funHash = _ref2[0],
-            fnName = _ref2[1],
-            argType = _ref2[2],
-            outType = _ref2[3];
-
-        return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, fnName.toString(), {
-          funHash: funHash,
-          argType: argType,
-          outType: outType
-        }));
+      return value.reduce((acc, _ref) => {
+        let [funHash, fnName, argType, outType] = _ref;
+        return { ...acc,
+          [fnName.toString()]: {
+            funHash,
+            argType,
+            outType
+          }
+        };
       }, {});
 
     default:
@@ -155,18 +116,16 @@ function deserializeField(value, type, prefix) {
 }
 
 function serializeField(value, type, prefix) {
-  var _context;
-
   switch (type) {
     case FIELD_TYPES.amount:
-    case FIELD_TYPES["int"]:
+    case FIELD_TYPES.int:
       return writeInt(value);
 
     case FIELD_TYPES.id:
       return writeId(value);
 
     case FIELD_TYPES.ids:
-      return _mapInstanceProperty(value).call(value, writeId);
+      return value.map(writeId);
 
     case FIELD_TYPES.bool:
       return Buffer.from([value ? 1 : 0]);
@@ -181,7 +140,7 @@ function serializeField(value, type, prefix) {
       return Buffer.from(value, 'hex');
 
     case FIELD_TYPES.signatures:
-      return _mapInstanceProperty(value).call(value, Buffer.from);
+      return value.map(Buffer.from);
 
     case FIELD_TYPES.payload:
       return typeof value === 'string' && value.split('_')[0] === 'ba' ? decode(value, 'ba') : toBytes(value);
@@ -192,13 +151,14 @@ function serializeField(value, type, prefix) {
     case FIELD_TYPES.pointers:
       return buildPointers(value);
 
+    case FIELD_TYPES.rlpBinary:
+      return value.rlpEncoded ?? value;
+
     case FIELD_TYPES.mptrees:
-      return _mapInstanceProperty(value).call(value, function (t) {
-        return t.serialize();
-      });
+      return value.map(t => t.serialize());
 
     case FIELD_TYPES.ctVersion:
-      return Buffer.from(_concatInstanceProperty(_context = []).call(_context, _toConsumableArray(toBytes(value.vmVersion)), [0], _toConsumableArray(toBytes(value.abiVersion))));
+      return Buffer.from([...toBytes(value.vmVersion), 0, ...toBytes(value.abiVersion)]);
 
     case FIELD_TYPES.callReturnType:
       switch (value) {
@@ -221,58 +181,51 @@ function serializeField(value, type, prefix) {
 }
 
 function validateField(value, key, type, prefix) {
-  var assert = function assert(valid, params) {
-    return valid ? {} : _defineProperty({}, key, VALIDATION_MESSAGE[type](params));
+  const assert = (valid, params) => valid ? {} : {
+    [key]: VALIDATION_MESSAGE[type](params)
   }; // All fields are required
 
 
-  if (value === undefined || value === null) return _defineProperty({}, key, 'Field is required'); // Validate type of value
+  if (value === undefined || value === null) return {
+    [key]: 'Field is required'
+  }; // Validate type of value
 
   switch (type) {
     case FIELD_TYPES.amount:
-    case FIELD_TYPES["int"]:
+    case FIELD_TYPES.int:
       {
-        var isMinusValue = (!isNaN(value) || BigNumber.isBigNumber(value)) && BigNumber(value).lt(0);
+        const isMinusValue = (!isNaN(value) || BigNumber.isBigNumber(value)) && BigNumber(value).lt(0);
         return assert((!isNaN(value) || BigNumber.isBigNumber(value)) && BigNumber(value).gte(0), {
-          value: value,
-          isMinusValue: isMinusValue
+          value,
+          isMinusValue
         });
       }
 
     case FIELD_TYPES.id:
-      if (_Array$isArray(prefix)) {
-        var p = _findInstanceProperty(prefix).call(prefix, function (p) {
-          return p === value.split('_')[0];
-        });
-
+      {
+        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: value,
-          prefix: prefix
+          value,
+          prefix
         });
       }
 
-      return assert(assertedType(value, prefix) && PREFIX_ID_TAG[value.split('_')[0]] && value.split('_')[0] === prefix, {
-        value: value,
-        prefix: prefix
-      });
-
     case FIELD_TYPES.binary:
       return assert(value.split('_')[0] === prefix, {
-        prefix: prefix,
-        value: value
+        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'));
+      return assert(typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'abiVersion') && Object.prototype.hasOwnProperty.call(value, 'vmVersion'));
 
     case FIELD_TYPES.pointers:
-      return assert(_Array$isArray(value) && !_findInstanceProperty(value).call(value, function (e) {
-        return e !== Object(e);
-      }), {
-        value: value
+      return assert(Array.isArray(value) && !value.find(e => e !== Object(e)), {
+        value
       });
 
     default:
@@ -281,45 +234,31 @@ function validateField(value, key, type, prefix) {
 }
 
 function transformParams(params, schema) {
-  var _context2, _context3;
-
-  var _ref5 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      denomination = _ref5.denomination;
-
-  params = _reduceInstanceProperty(_context2 = _filterInstanceProperty(schema).call(schema, function (_ref6) {
-    var _ref7 = _slicedToArray(_ref6, 2),
-        _ = _ref7[0],
-        t = _ref7[1];
-
+  let {
+    denomination
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  params = schema.filter(_ref2 => {
+    let [_, t] = _ref2;
     return t === FIELD_TYPES.amount;
-  })).call(_context2, function (acc, _ref8) {
-    var _ref9 = _slicedToArray(_ref8, 1),
-        key = _ref9[0];
-
-    return _objectSpread(_objectSpread({}, params), {}, _defineProperty({}, key, formatAmount(params[key], {
-      denomination: denomination
-    })));
+  }).reduce((acc, _ref3) => {
+    let [key] = _ref3;
+    return { ...params,
+      [key]: formatAmount(params[key], {
+        denomination
+      })
+    };
   }, params);
-
-  var schemaKeys = _mapInstanceProperty(schema).call(schema, function (_ref10) {
-    var _ref11 = _slicedToArray(_ref10, 1),
-        k = _ref11[0];
-
+  const schemaKeys = schema.map(_ref4 => {
+    let [k] = _ref4;
     return k;
   });
+  return Object.entries(params).reduce((acc, _ref5) => {
+    let [key, value] = _ref5;
+    if (schemaKeys.includes(key)) acc[key] = value;
 
-  return _reduceInstanceProperty(_context3 = _Object$entries(params)).call(_context3, function (acc, _ref12) {
-    var _context4;
-
-    var _ref13 = _slicedToArray(_ref12, 2),
-        key = _ref13[0],
-        value = _ref13[1];
-
-    if (_includesInstanceProperty(schemaKeys).call(schemaKeys, key)) acc[key] = value;
-
-    if (_includesInstanceProperty(_context4 = ['oracleTtl', 'queryTtl', 'responseTtl']).call(_context4, key)) {
-      acc["".concat(key, "Type")] = value.type === ORACLE_TTL_TYPES.delta ? 0 : 1;
-      acc["".concat(key, "Value")] = value.value;
+    if (['oracleTtl', 'queryTtl', 'responseTtl'].includes(key)) {
+      acc[`${key}Type`] = value.type === ORACLE_TTL_TYPES.delta ? 0 : 1;
+      acc[`${key}Value`] = value.value;
     }
 
     return acc;
@@ -328,12 +267,15 @@ function transformParams(params, schema) {
 
 
 function getOracleRelativeTtl(params, txType) {
-  var _TX_TYPE$oracleRegist;
-
-  var ttlKey = (_TX_TYPE$oracleRegist = {}, _defineProperty(_TX_TYPE$oracleRegist, TX_TYPE.oracleRegister, 'oracleTtl'), _defineProperty(_TX_TYPE$oracleRegist, TX_TYPE.oracleExtend, 'oracleTtl'), _defineProperty(_TX_TYPE$oracleRegist, TX_TYPE.oracleQuery, 'queryTtl'), _defineProperty(_TX_TYPE$oracleRegist, TX_TYPE.oracleResponse, 'responseTtl'), _TX_TYPE$oracleRegist)[txType];
-
-  if (params[ttlKey] || params["".concat(ttlKey, "Value")]) {
-    return params["".concat(ttlKey, "Value")] || params[ttlKey].value;
+  const ttlKey = {
+    [TX_TYPE.oracleRegister]: 'oracleTtl',
+    [TX_TYPE.oracleExtend]: 'oracleTtl',
+    [TX_TYPE.oracleQuery]: 'queryTtl',
+    [TX_TYPE.oracleResponse]: 'responseTtl'
+  }[txType];
+
+  if (params[ttlKey] || params[`${ttlKey}Value`]) {
+    return params[`${ttlKey}Value`] || params[ttlKey].value;
   }
 
   return 1;
@@ -352,32 +294,33 @@ function getOracleRelativeTtl(params, txType) {
  */
 
 
-export function calculateMinFee(txType, _ref14) {
-  var _ref14$gas = _ref14.gas,
-      gas = _ref14$gas === void 0 ? 0 : _ref14$gas,
-      params = _ref14.params,
-      vsn = _ref14.vsn;
-  var multiplier = BigNumber(1e9); // 10^9 GAS_PRICE
+export function calculateMinFee(txType, _ref6) {
+  let {
+    gas = 0,
+    params,
+    vsn
+  } = _ref6;
+  const multiplier = BigNumber(1e9); // 10^9 GAS_PRICE
 
   if (!params) return BigNumber(DEFAULT_FEE).times(multiplier).toString(10);
-  var actualFee = buildFee(txType, {
-    params: _objectSpread(_objectSpread({}, params), {}, {
+  let actualFee = buildFee(txType, {
+    params: { ...params,
       fee: 0
-    }),
-    multiplier: multiplier,
-    gas: gas,
-    vsn: vsn
+    },
+    multiplier,
+    gas,
+    vsn
   });
-  var expected = BigNumber(0);
+  let expected = BigNumber(0);
 
   while (!actualFee.eq(expected)) {
     actualFee = buildFee(txType, {
-      params: _objectSpread(_objectSpread({}, params), {}, {
+      params: { ...params,
         fee: actualFee
-      }),
-      multiplier: multiplier,
-      gas: gas,
-      vsn: vsn
+      },
+      multiplier,
+      gas,
+      vsn
     });
     expected = actualFee;
   }
@@ -394,22 +337,23 @@ export function calculateMinFee(txType, _ref14) {
  * @return {BigNumber}
  */
 
-function buildFee(txType, _ref15) {
-  var params = _ref15.params,
-      _ref15$gas = _ref15.gas,
-      gas = _ref15$gas === void 0 ? 0 : _ref15$gas,
-      multiplier = _ref15.multiplier,
-      vsn = _ref15.vsn;
-
-  var _buildTx = buildTx(_objectSpread({}, params), txType, {
-    vsn: vsn
-  }),
-      txWithOutFee = _buildTx.rlpEncoded;
-
-  var txSize = txWithOutFee.length;
-  return TX_FEE_BASE_GAS(txType).plus(TX_FEE_OTHER_GAS(txType)({
-    txSize: txSize,
-    relativeTtl: getOracleRelativeTtl(params, txType)
+function buildFee(txType, _ref7) {
+  let {
+    params,
+    gas = 0,
+    multiplier,
+    vsn
+  } = _ref7;
+  const {
+    rlpEncoded: txWithOutFee
+  } = buildTx({ ...params
+  }, txType, {
+    vsn
+  });
+  const txSize = txWithOutFee.length;
+  return TX_FEE_BASE_GAS(txType).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
   })).times(multiplier);
 }
 /**
@@ -428,22 +372,19 @@ function buildFee(txType, _ref15) {
 
 
 export function calculateFee() {
-  var fee = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  var txType = arguments.length > 1 ? arguments[1] : undefined;
-
-  var _ref16 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      _ref16$gas = _ref16.gas,
-      gas = _ref16$gas === void 0 ? 0 : _ref16$gas,
-      params = _ref16.params,
-      _ref16$showWarning = _ref16.showWarning,
-      showWarning = _ref16$showWarning === void 0 ? true : _ref16$showWarning,
-      vsn = _ref16.vsn;
-
-  if (!params && showWarning) console.warn("Can't build transaction fee, we will use DEFAULT_FEE(".concat(DEFAULT_FEE, ")"));
+  let fee = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  let txType = arguments.length > 1 ? arguments[1] : undefined;
+  let {
+    gas = 0,
+    params,
+    showWarning = true,
+    vsn
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!params && showWarning) console.warn(`Can't build transaction fee, we will use DEFAULT_FEE(${DEFAULT_FEE})`);
   return fee || calculateMinFee(txType, {
-    params: params,
-    gas: gas,
-    vsn: vsn
+    params,
+    gas,
+    vsn
   });
 }
 /**
@@ -456,23 +397,16 @@ export function calculateFee() {
  * @return {Object} Object with validation errors
  */
 
-export function validateParams(params, schema, _ref17) {
-  var _context5;
-
-  var _ref17$excludeKeys = _ref17.excludeKeys,
-      excludeKeys = _ref17$excludeKeys === void 0 ? [] : _ref17$excludeKeys;
-  return _reduceInstanceProperty(_context5 = _filterInstanceProperty(schema).call(schema, function (_ref18) {
-    var _ref19 = _slicedToArray(_ref18, 1),
-        key = _ref19[0];
-
-    return !_includesInstanceProperty(excludeKeys).call(excludeKeys, key) && key !== 'payload';
-  })).call(_context5, function (acc, _ref20) {
-    var _ref21 = _slicedToArray(_ref20, 3),
-        key = _ref21[0],
-        type = _ref21[1],
-        prefix = _ref21[2];
-
-    return _Object$assign(acc, validateField(params[key], key, type, prefix));
+export function validateParams(params, schema, _ref8) {
+  let {
+    excludeKeys = []
+  } = _ref8;
+  return schema.filter(_ref9 => {
+    let [key] = _ref9;
+    return !excludeKeys.includes(key) && key !== 'payload';
+  }).reduce((acc, _ref10) => {
+    let [key, type, prefix] = _ref10;
+    return Object.assign(acc, validateField(params[key], key, type, prefix));
   }, {});
 }
 /**
@@ -482,45 +416,36 @@ export function validateParams(params, schema, _ref17) {
  * @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) {
-  var _ref22 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      _ref22$excludeKeys = _ref22.excludeKeys,
-      excludeKeys = _ref22$excludeKeys === void 0 ? [] : _ref22$excludeKeys,
-      _ref22$denomination = _ref22.denomination,
-      denomination = _ref22$denomination === void 0 ? AE_AMOUNT_FORMATS.AETTOS : _ref22$denomination;
-
-  var filteredSchema = _filterInstanceProperty(schema).call(schema, function (_ref23) {
-    var _ref24 = _slicedToArray(_ref23, 1),
-        key = _ref24[0];
-
-    return !_includesInstanceProperty(excludeKeys).call(excludeKeys, key);
+  let {
+    excludeKeys = [],
+    denomination = AE_AMOUNT_FORMATS.AETTOS
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const filteredSchema = schema.filter(_ref11 => {
+    let [key] = _ref11;
+    return !excludeKeys.includes(key);
   }); // Transform `amount` type fields to `aettos`
 
-
   params = transformParams(params, filteredSchema, {
-    denomination: denomination
+    denomination
   }); // Validation
 
-  var valid = validateParams(params, schema, {
-    excludeKeys: excludeKeys
+  const valid = validateParams(params, schema, {
+    excludeKeys
   });
 
-  if (_Object$keys(valid).length) {
-    throw new Error('Transaction build error. ' + _JSON$stringify(valid));
+  if (Object.keys(valid).length) {
+    throw new Error('Transaction build error. ' + JSON.stringify(valid));
   }
 
-  return _mapInstanceProperty(filteredSchema).call(filteredSchema, function (_ref25) {
-    var _ref26 = _slicedToArray(_ref25, 3),
-        key = _ref26[0],
-        fieldType = _ref26[1],
-        prefix = _ref26[2];
-
+  return filteredSchema.map(_ref12 => {
+    let [key, fieldType, prefix] = _ref12;
     return serializeField(params[key], fieldType, prefix);
   });
 }
@@ -534,13 +459,11 @@ export function buildRawTx(params, schema) {
  */
 
 export function unpackRawTx(binary, schema) {
-  return _reduceInstanceProperty(schema).call(schema, function (acc, _ref27, index) {
-    var _ref28 = _slicedToArray(_ref27, 3),
-        key = _ref28[0],
-        fieldType = _ref28[1],
-        prefix = _ref28[2];
-
-    return _Object$assign(acc, _defineProperty({}, key, deserializeField(binary[index], fieldType, prefix)));
+  return schema.reduce((acc, _ref13, index) => {
+    let [key, fieldType, prefix] = _ref13;
+    return Object.assign(acc, {
+      [key]: deserializeField(binary[index], fieldType, prefix)
+    });
   }, {});
 }
 /**
@@ -551,24 +474,22 @@ export function unpackRawTx(binary, schema) {
  * @return {Object} Schema
  */
 
-var getSchema = function getSchema(_ref29) {
-  var vsn = _ref29.vsn,
-      objId = _ref29.objId,
-      type = _ref29.type;
-  var isDeserialize = !!objId;
-  var firstKey = isDeserialize ? objId : type;
-  var schema = isDeserialize ? TX_DESERIALIZATION_SCHEMA : TX_SERIALIZATION_SCHEMA;
+const getSchema = _ref14 => {
+  let {
+    vsn,
+    objId,
+    type
+  } = _ref14;
+  const isDeserialize = !!objId;
+  const firstKey = isDeserialize ? objId : type;
+  const schema = isDeserialize ? TX_DESERIALIZATION_SCHEMA : TX_SERIALIZATION_SCHEMA;
 
   if (!schema[firstKey]) {
-    var _context6;
-
-    throw new Error(_concatInstanceProperty(_context6 = "Transaction ".concat(isDeserialize ? 'deserialization' : 'serialization', " not implemented for ")).call(_context6, isDeserialize ? 'tag ' + objId : type));
+    throw new Error(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type}`);
   }
 
   if (!schema[firstKey][vsn]) {
-    var _context7, _context8;
-
-    throw new Error(_concatInstanceProperty(_context7 = _concatInstanceProperty(_context8 = "Transaction ".concat(isDeserialize ? 'deserialization' : 'serialization', " not implemented for ")).call(_context8, isDeserialize ? 'tag ' + objId : type, " version ")).call(_context7, vsn));
+    throw new Error(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type} version ${vsn}`);
   }
 
   return schema[firstKey][vsn];
@@ -580,50 +501,40 @@ var getSchema = function getSchema(_ref29) {
  * @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) {
-  var _context9;
-
-  var _ref30 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      _ref30$excludeKeys = _ref30.excludeKeys,
-      excludeKeys = _ref30$excludeKeys === void 0 ? [] : _ref30$excludeKeys,
-      _ref30$prefix = _ref30.prefix,
-      prefix = _ref30$prefix === void 0 ? 'tx' : _ref30$prefix,
-      _ref30$vsn = _ref30.vsn,
-      vsn = _ref30$vsn === void 0 ? VSN : _ref30$vsn,
-      _ref30$denomination = _ref30.denomination,
-      denomination = _ref30$denomination === void 0 ? AE_AMOUNT_FORMATS.AETTOS : _ref30$denomination;
-
-  var _getSchema = getSchema({
-    type: type,
-    vsn: vsn
-  }),
-      _getSchema2 = _slicedToArray(_getSchema, 2),
-      schema = _getSchema2[0],
-      tag = _getSchema2[1];
-
-  var binary = _filterInstanceProperty(_context9 = buildRawTx(_objectSpread(_objectSpread({}, params), {}, {
+  let {
+    excludeKeys = [],
+    prefix = 'tx',
+    vsn = VSN,
+    denomination = AE_AMOUNT_FORMATS.AETTOS
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const [schema, tag] = getSchema({
+    type,
+    vsn
+  });
+  const binary = buildRawTx({ ...params,
     VSN: vsn,
-    tag: tag
-  }), schema, {
-    excludeKeys: excludeKeys,
+    tag
+  }, schema, {
+    excludeKeys,
     denomination: params.denomination || denomination
-  })).call(_context9, function (e) {
-    return e !== undefined;
-  });
-
-  var rlpEncoded = rlpEncode(binary);
-  var tx = encode(rlpEncoded, prefix);
+  }).filter(e => e !== undefined);
+  const rlpEncoded = rlpEncode(binary);
+  const tx = encode(rlpEncoded, prefix);
   return {
-    tx: tx,
-    rlpEncoded: rlpEncoded,
-    binary: binary,
+    tx,
+    rlpEncoded,
+    binary,
     txObject: unpackRawTx(binary, schema)
   };
 }
@@ -631,32 +542,32 @@ export function buildTx(params, type) {
  * 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) {
-  var fromRlpBinary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'tx';
-  var rlpEncoded = fromRlpBinary ? encodedTx : decode(encodedTx, prefix);
-  var binary = rlpDecode(rlpEncoded);
-  var objId = readInt(binary[0]);
-  var vsn = readInt(binary[1]);
-
-  var _getSchema3 = getSchema({
-    objId: objId,
-    vsn: vsn
-  }),
-      _getSchema4 = _slicedToArray(_getSchema3, 1),
-      schema = _getSchema4[0];
-
+  let fromRlpBinary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  let prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'tx';
+  const rlpEncoded = fromRlpBinary ? encodedTx : decode(encodedTx, prefix);
+  const binary = rlpDecode(rlpEncoded);
+  const objId = readInt(binary[0]);
+  const vsn = readInt(binary[1]);
+  const [schema] = getSchema({
+    objId,
+    vsn
+  });
   return {
     txType: OBJECT_ID_TX_TYPE[objId],
     tx: unpackRawTx(binary, schema),
-    rlpEncoded: rlpEncoded,
-    binary: binary
+    rlpEncoded,
+    binary
   };
 }
 /**
@@ -664,23 +575,21 @@ export function unpackTx(encodedTx) {
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder
  * @param {String | Buffer} rawTx base64 or rlp encoded transaction
- * @param {Object} options
- * @param {Boolean} options.raw
  * @return {String} Transaction hash
  */
 
-export function buildTxHash(rawTx, options) {
-  if (typeof rawTx === 'string' && _indexOfInstanceProperty(rawTx).call(rawTx, 'tx_') !== -1) return buildHash('th', unpackTx(rawTx).rlpEncoded, options);
-  return buildHash('th', rawTx, options);
+export function buildTxHash(rawTx) {
+  const data = typeof rawTx === 'string' && rawTx.startsWith('tx_') ? decode(rawTx, 'tx') : rawTx;
+  return encode(hash(data), 'th');
 }
 export default {
-  calculateMinFee: calculateMinFee,
-  calculateFee: calculateFee,
-  unpackTx: unpackTx,
-  unpackRawTx: unpackRawTx,
-  buildTx: buildTx,
-  buildRawTx: buildRawTx,
-  validateParams: validateParams,
-  buildTxHash: buildTxHash
+  calculateMinFee,
+  calculateFee,
+  unpackTx,
+  unpackRawTx,
+  buildTx,
+  buildRawTx,
+  validateParams,
+  buildTxHash
 };
 //# sourceMappingURL=index.js.map