@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/es/tx/builder/index.mjs

@@ -1,4 +1,5 @@
 import _buffer from "buffer";
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
 const {
   Buffer: _Buffer
 } = _buffer;
@@ -10,26 +11,19 @@ const {
 } = _rlp;
 import { AE_AMOUNT_FORMATS, formatAmount } from "../../utils/amount-formatter.mjs";
 import { hash } from "../../utils/crypto.mjs";
-import { Field } from "./field-types.mjs";
-import { DEFAULT_FEE, FIELD_TYPES, OBJECT_ID_TX_TYPE, TX_DESERIALIZATION_SCHEMA, TX_FEE_BASE_GAS, TX_FEE_OTHER_GAS, TX_SERIALIZATION_SCHEMA, TX_TYPE, VSN } from "./schema.mjs";
-import { readInt, readId, readPointers, writeId, writeInt, buildPointers, encode, decode } from "./helpers.mjs";
+import { FIELD_TYPES, TX_SCHEMA, TX_TYPE } from "./schema.mjs";
+import { readInt, readId, readPointers, writeId, writeInt, buildPointers, encode, decode, buildContractId } from "./helpers.mjs";
 import { toBytes } from "../../utils/bytes.mjs";
 import MPTree from "../../utils/mptree.mjs";
-import { InvalidTxParamsError, SchemaNotFoundError } from "../../utils/errors.mjs";
+import { ArgumentError, InvalidTxParamsError, SchemaNotFoundError, DecodeError } from "../../utils/errors.mjs";
+import { isKeyOfObject } from "../../utils/other.mjs";
 /**
  * JavaScript-based Transaction builder
- * @module @aeternity/aepp-sdk/es/tx/builder
- * @export TxBuilder
- * @example import { TxBuilder } from '@aeternity/aepp-sdk'
  */
-
-const ORACLE_TTL_TYPES = {
-  delta: 'delta',
-  block: 'block'
-}; // SERIALIZE AND DESERIALIZE PART
+// SERIALIZE AND DESERIALIZE PART
 
 function deserializeField(value, type, prefix) {
-  if (!value) return '';
+  if (value == null) return '';
 
   switch (type) {
     case FIELD_TYPES.ctVersion:
@@ -43,8 +37,13 @@ function deserializeField(value, type, prefix) {
 
     case FIELD_TYPES.amount:
     case FIELD_TYPES.int:
+    case FIELD_TYPES.abiVersion:
+    case FIELD_TYPES.ttlType:
       return readInt(value);
 
+    case FIELD_TYPES.shortInt:
+      return +readInt(value);
+
     case FIELD_TYPES.id:
       return readId(value);
 
@@ -70,10 +69,10 @@ function deserializeField(value, type, prefix) {
       return readPointers(value);
 
     case FIELD_TYPES.rlpBinary:
-      return unpackTx(value, true);
+      return unpackTx(encode(value, 'tx'));
 
     case FIELD_TYPES.rlpBinaries:
-      return value.map(v => unpackTx(v, true));
+      return value.map(v => unpackTx(encode(v, 'tx')));
 
     case FIELD_TYPES.rawBinary:
       return value;
@@ -82,7 +81,7 @@ function deserializeField(value, type, prefix) {
       return value.toString('hex');
 
     case FIELD_TYPES.offChainUpdates:
-      return value.map(v => unpackTx(v, true));
+      return value.map(v => unpackTx(encode(v, 'tx')));
 
     case FIELD_TYPES.callStack:
       // TODO: fix this
@@ -119,17 +118,20 @@ function deserializeField(value, type, prefix) {
       }, {});
 
     default:
-      if (type.prototype instanceof Field) return type.deserialize(value);
+      if (type instanceof Object && 'deserialize' in type) return type.deserialize(value);
       return value;
   }
 }
 
-function serializeField(value, type, prefix, params) {
+function serializeField(value, type, params) {
   var _value$rlpEncoded;
 
   switch (type) {
     case FIELD_TYPES.amount:
     case FIELD_TYPES.int:
+    case FIELD_TYPES.shortInt:
+    case FIELD_TYPES.abiVersion:
+    case FIELD_TYPES.ttlType:
       return writeInt(value);
 
     case FIELD_TYPES.id:
@@ -139,13 +141,13 @@ function serializeField(value, type, prefix, params) {
       return value.map(writeId);
 
     case FIELD_TYPES.bool:
-      return _Buffer.from([value ? 1 : 0]);
+      return _Buffer.from([value === true ? 1 : 0]);
 
     case FIELD_TYPES.binary:
-      return decode(value, prefix);
+      return decode(value);
 
     case FIELD_TYPES.stateTree:
-      return decode(value, 'ss');
+      return decode(value);
 
     case FIELD_TYPES.hex:
       return _Buffer.from(value, 'hex');
@@ -154,7 +156,7 @@ function serializeField(value, type, prefix, params) {
       return value.map(_Buffer.from);
 
     case FIELD_TYPES.payload:
-      return typeof value === 'string' && value.split('_')[0] === 'ba' ? decode(value, 'ba') : toBytes(value);
+      return typeof value === 'string' && value.split('_')[0] === 'ba' ? decode(value) : toBytes(value);
 
     case FIELD_TYPES.string:
       return toBytes(value);
@@ -166,7 +168,7 @@ function serializeField(value, type, prefix, params) {
       return (_value$rlpEncoded = value.rlpEncoded) !== null && _value$rlpEncoded !== void 0 ? _value$rlpEncoded : value;
 
     case FIELD_TYPES.mptrees:
-      return value.map(t => t.serialize());
+      return value.map(t => t.serialize(''));
 
     case FIELD_TYPES.ctVersion:
       return _Buffer.from([...toBytes(value.vmVersion), 0, ...toBytes(value.abiVersion)]);
@@ -187,24 +189,25 @@ function serializeField(value, type, prefix, params) {
       }
 
     default:
-      if (type.prototype instanceof Field) return type.serialize(value, params);
+      if (type instanceof Object && 'serialize' in type) return type.serialize(value, params);
       return value;
   }
 }
 
 function validateField(value, type, prefix) {
   // All fields are required
-  if (value === undefined || value === null) return 'Field is required'; // Validate type of value
+  if (value == null) return 'Field is required'; // Validate type of value
 
   switch (type) {
     case FIELD_TYPES.amount:
     case FIELD_TYPES.int:
+    case FIELD_TYPES.shortInt:
       {
         if (isNaN(value) && !BigNumber.isBigNumber(value)) {
-          return `${value} is not of type Number or BigNumber`;
+          return `${String(value)} is not of type Number or BigNumber`;
         }
 
-        if (new BigNumber(value).lt(0)) return `${value} must be >= 0`;
+        if (new BigNumber(value).lt(0)) return `${String(value)} must be >= 0`;
         return;
       }
 
@@ -212,15 +215,19 @@ function validateField(value, type, prefix) {
       {
         const prefixes = Array.isArray(prefix) ? prefix : [prefix];
 
-        if (!prefixes.includes(value.split('_')[0])) {
-          return `'${value}' prefix doesn't match expected prefix '${prefix}'`;
+        if (!_includesInstanceProperty(prefixes).call(prefixes, value.split('_')[0])) {
+          if (prefix == null) {
+            return `'${String(value)}' prefix doesn't exist'`;
+          }
+
+          return `'${String(value)}' prefix doesn't match expected prefix '${prefix.toString()}'`;
         }
 
         return;
       }
 
     case FIELD_TYPES.ctVersion:
-      if (!(value !== null && value !== void 0 && value.abiVersion) || !(value !== null && value !== void 0 && value.vmVersion)) {
+      if (!(Boolean(value.abiVersion) && Boolean(value.vmVersion))) {
         return 'Value must be an object with "vmVersion" and "abiVersion" fields';
       }
 
@@ -229,7 +236,7 @@ function validateField(value, type, prefix) {
     case FIELD_TYPES.pointers:
       if (!Array.isArray(value)) return 'Value must be of type Array';
 
-      if (value.some(p => !(p !== null && p !== void 0 && p.key) || !(p !== null && p !== void 0 && p.id))) {
+      if (value.some(p => !(Boolean(p.key) && Boolean(p.id)))) {
         return 'Value must contains only object\'s like \'{key: "account_pubkey", id: "ak_lkamsflkalsdalksdlasdlasdlamd"}\'';
       }
 
@@ -245,9 +252,9 @@ function transformParams(params, schema) {
     denomination
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   params = schema.filter(_ref2 => {
-    let [_, t] = _ref2;
+    let [, t] = _ref2;
     return t === FIELD_TYPES.amount;
-  }).reduce((acc, _ref3) => {
+  }).reduce((params, _ref3) => {
     let [key] = _ref3;
     return { ...params,
       [key]: formatAmount(params[key], {
@@ -255,290 +262,101 @@ function transformParams(params, schema) {
       })
     };
   }, params);
-  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;
-
-    if (['oracleTtl', 'queryTtl', 'responseTtl'].includes(key)) {
-      acc[`${key}Type`] = value.type === ORACLE_TTL_TYPES.delta ? 0 : 1;
-      acc[`${key}Value`] = value.value;
-    }
-
-    return acc;
-  }, {});
-} // INTERFACE
-
-
-function getOracleRelativeTtl(params, txType) {
-  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;
-}
-/**
- * Calculate min fee
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder/index
- * @rtype (txType, { gas = 0, params }) => String
- * @param {String} txType - Transaction type
- * @param {Options} options - Options object
- * @param {String|Number} options.gas - Gas amount
- * @param {Object} options.params - Tx params
- * @return {String|Number}
- * @example calculateMinFee('spendTx', { gas, params })
- */
-
-
-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);
-  let actualFee = buildFee(txType, {
-    params: { ...params,
-      fee: 0
-    },
-    multiplier,
-    gas,
-    vsn
-  });
-  let expected = BigNumber(0);
-
-  while (!actualFee.eq(expected)) {
-    actualFee = buildFee(txType, {
-      params: { ...params,
-        fee: actualFee
-      },
-      multiplier,
-      gas,
-      vsn
-    });
-    expected = actualFee;
-  }
-
-  return expected.toString(10);
-}
-/**
- * Calculate fee based on tx type and params
- * @param txType
- * @param params
- * @param gas
- * @param multiplier
- * @param vsn
- * @return {BigNumber}
- */
-
-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);
-}
-/**
- * Calculate fee
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @rtype (fee, txType, gas = 0) => String
- * @param {String|Number} fee - fee
- * @param {String} txType - Transaction type
- * @param {Options} options - Options object
- * @param {String|Number} options.gas - Gas amount
- * @param {Object} options.params - Tx params
- * @return {String|Number}
- * @example calculateFee(null, 'spendTx', { gas, params })
- */
-
-
-export function calculateFee() {
-  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,
-    gas,
-    vsn
-  });
+  return params;
 }
 /**
  * Validate transaction params
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {Object} params Object with tx params
- * @param {Array} schema Transaction schema
- * @param {Array} excludeKeys  Array of keys to exclude for validation
- * @return {Object} Object with validation errors
+ * @param params - Object with tx params
+ * @param schema - Transaction schema
+ * @param excludeKeys - Array of keys to exclude for validation
+ * @returns Object with validation errors
  */
 
-export function validateParams(params, schema, _ref8) {
+
+export function validateParams(params, schema, _ref4) {
   let {
     excludeKeys = []
-  } = _ref8;
+  } = _ref4;
   return Object.fromEntries(schema // TODO: allow optional keys in schema
-  .filter(_ref9 => {
-    let [key] = _ref9;
-    return !excludeKeys.includes(key) && !['payload', 'nameFee', 'deposit'].includes(key);
-  }).map(_ref10 => {
-    let [key, type, prefix] = _ref10;
+  .filter(_ref5 => {
+    var _context;
+
+    let [key] = _ref5;
+    return !_includesInstanceProperty(excludeKeys).call(excludeKeys, key) && !_includesInstanceProperty(_context = ['payload', 'nameFee', 'deposit', 'gasPrice']).call(_context, key);
+  }).map(_ref6 => {
+    let [key, type, prefix] = _ref6;
     return [key, validateField(params[key], type, prefix)];
-  }).filter(_ref11 => {
-    let [, message] = _ref11;
+  }).filter(_ref7 => {
+    let [, message] = _ref7;
     return message;
   }));
 }
-/**
- * Build binary transaction
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {Object} params Object with tx params
- * @param {Array} schema Transaction schema
- * @param {Object} [options={}] options
- * @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) {
-  let {
-    excludeKeys = [],
-    denomination = AE_AMOUNT_FORMATS.AETTOS
-  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  const filteredSchema = schema.filter(_ref12 => {
-    let [key] = _ref12;
-    return !excludeKeys.includes(key);
-  }); // Transform `amount` type fields to `aettos`
-
-  params = transformParams(params, filteredSchema, {
-    denomination
-  }); // Validation
-
-  const valid = validateParams(params, schema, {
-    excludeKeys
-  });
-
-  if (Object.keys(valid).length) {
-    throw new InvalidTxParamsError('Transaction build error. ' + JSON.stringify(valid));
-  }
-
-  return filteredSchema.map(_ref13 => {
-    let [key, fieldType, prefix] = _ref13;
-    return serializeField(params[key], fieldType, prefix, params);
-  });
-}
 /**
  * Unpack binary transaction
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {Array} binary Array with binary transaction field's
- * @param {Array} schema Transaction schema
- * @return {Object} Object with transaction field's
+ * @param binary - Array with binary transaction field's
+ * @param schema - Transaction schema
+ * @returns Object with transaction field's
  */
 
 export function unpackRawTx(binary, schema) {
-  return schema.reduce((acc, _ref14, index) => {
-    let [key, fieldType, prefix] = _ref14;
+  return schema.reduce((acc, _ref8, index) => {
+    let [key, fieldType, prefix] = _ref8;
     return Object.assign(acc, {
       [key]: deserializeField(binary[index], fieldType, prefix)
     });
   }, {});
 }
-/**
- * Get transaction serialization/deserialization schema
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {{ vsn: String, objId: Number, type: String }}
- * @throws {Error} Schema not found error
- * @return {Object} Schema
- */
-
-const getSchema = _ref15 => {
-  let {
-    vsn,
-    objId,
-    type
-  } = _ref15;
-  const isDeserialize = !!objId;
-  const firstKey = isDeserialize ? objId : type;
-  const schema = isDeserialize ? TX_DESERIALIZATION_SCHEMA : TX_SERIALIZATION_SCHEMA;
-
-  if (!schema[firstKey]) {
-    throw new SchemaNotFoundError(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type}`);
-  }
 
-  if (!schema[firstKey][vsn]) {
-    throw new SchemaNotFoundError(`Transaction ${isDeserialize ? 'deserialization' : 'serialization'} not implemented for ${isDeserialize ? 'tag ' + objId : type} version ${vsn}`);
-  }
-
-  return schema[firstKey][vsn];
-};
 /**
  * Build transaction hash
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {Object} params Object with tx params
- * @param {String} type Transaction type
- * @param {Object} [options={}] options
- * @param {String[]} [options.excludeKeys] Array of keys to exclude for validation and build
- * @param {String} [options.prefix] Prefix of transaction
- * @throws {Error} Validation error
- * @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
+ * @param _params - Object with tx params
+ * @param type - Transaction type
+ * @param options - options
+ * @param options.excludeKeys - Array of keys to exclude for validation and build
+ * @param options.denomination - Denomination of amounts
+ * @param options.prefix - Prefix of transaction
+ * @throws {@link InvalidTxParamsError}
+ * @returns object
+ * @returns object.tx Base64Check transaction hash with 'tx_' prefix
+ * @returns object.rlpEncoded rlp encoded transaction
+ * @returns object.binary binary transaction
  */
+export function buildTx(_params, type) {
+  var _vsn;
 
-
-export function buildTx(params, type) {
   let {
     excludeKeys = [],
     prefix = 'tx',
-    vsn = VSN,
+    vsn,
     denomination = AE_AMOUNT_FORMATS.AETTOS
   } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  const [schema, tag] = getSchema({
-    type,
-    vsn
+  const schemas = TX_SCHEMA[type];
+  (_vsn = vsn) !== null && _vsn !== void 0 ? _vsn : vsn = Math.max(...Object.keys(schemas).map(a => +a));
+  if (!isKeyOfObject(vsn, schemas)) throw new SchemaNotFoundError('serialization', TX_TYPE[type], vsn);
+  const schema = schemas[vsn];
+  let params = _params;
+  params.VSN = vsn;
+  params.tag = type;
+  const filteredSchema = schema.filter(_ref9 => {
+    let [key] = _ref9;
+    return !_includesInstanceProperty(excludeKeys).call(excludeKeys, key);
+  }); // Transform `amount` type fields to `aettos`
+
+  params = transformParams(params, filteredSchema, {
+    denomination
+  }); // Validation
+
+  const valid = validateParams(params, schema, {
+    excludeKeys
   });
-  const binary = buildRawTx({ ...params,
-    VSN: vsn,
-    tag
-  }, schema, {
-    excludeKeys,
-    denomination: params.denomination || denomination
+
+  if (Object.keys(valid).length > 0) {
+    throw new InvalidTxParamsError('Transaction build error. ' + JSON.stringify(valid));
+  }
+
+  const binary = filteredSchema.map(_ref10 => {
+    let [key, fieldType] = _ref10;
+    return serializeField(params[key], fieldType, params);
   }).filter(e => e !== undefined);
   const rlpEncoded = rlpEncode(binary);
   const tx = encode(rlpEncoded, prefix);
@@ -549,58 +367,58 @@ export function buildTx(params, type) {
     txObject: unpackRawTx(binary, schema)
   };
 }
+
 /**
  * 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 {Boolean} fromRlpBinary Unpack from RLP encoded transaction (default: false)
- * @param {String} prefix - Prefix of data
- * @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
+ * @param encodedTx - Transaction to unpack
+ * @param txType - Expected transaction type
+ * @returns object
+ * @returns object.tx Object with transaction param's
+ * @returns object.txType Transaction type
  */
-
-export function unpackTx(encodedTx) {
-  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);
+export function unpackTx(encodedTx, txType) {
+  const rlpEncoded = decode(encodedTx);
   const binary = rlpDecode(rlpEncoded);
-  const objId = readInt(binary[0]);
-  const vsn = readInt(binary[1]);
-  const [schema] = getSchema({
-    objId,
-    vsn
-  });
+  const objId = +readInt(binary[0]);
+  if (!isKeyOfObject(objId, TX_SCHEMA)) throw new DecodeError(`Unknown transaction tag: ${objId}`);
+  if (txType != null && txType !== objId) throw new DecodeError(`Expected transaction to have ${TX_TYPE[txType]} tag, got ${TX_TYPE[objId]} instead`);
+  const vsn = +readInt(binary[1]);
+  if (!isKeyOfObject(vsn, TX_SCHEMA[objId])) throw new SchemaNotFoundError('deserialization', `tag ${objId}`, vsn);
+  const schema = TX_SCHEMA[objId][vsn];
   return {
-    txType: OBJECT_ID_TX_TYPE[objId],
+    txType: objId,
     tx: unpackRawTx(binary, schema),
-    rlpEncoded,
-    binary
+    rlpEncoded
   };
 }
 /**
  * Build a transaction hash
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder
- * @param {String | Buffer} rawTx base64 or rlp encoded transaction
- * @return {String} Transaction hash
+ * @param rawTx - base64 or rlp encoded transaction
+ * @returns Transaction hash
  */
 
 export function buildTxHash(rawTx) {
-  const data = typeof rawTx === 'string' && rawTx.startsWith('tx_') ? decode(rawTx, 'tx') : rawTx;
+  const data = typeof rawTx === 'string' && rawTx.startsWith('tx_') ? decode(rawTx) : rawTx;
   return encode(hash(data), 'th');
 }
-export default {
-  calculateMinFee,
-  calculateFee,
-  unpackTx,
-  unpackRawTx,
-  buildTx,
-  buildRawTx,
-  validateParams,
-  buildTxHash
-};
+/**
+ * Build a contract public key by contractCreateTx or gaAttach
+ * @param contractTx - Transaction
+ * @returns Contract public key
+ */
+
+export function buildContractIdByContractTx(contractTx) {
+  var _context2;
+
+  const {
+    txType,
+    tx
+  } = unpackTx(contractTx);
+
+  if (!_includesInstanceProperty(_context2 = [TX_TYPE.contractCreate, TX_TYPE.gaAttach]).call(_context2, txType)) {
+    throw new ArgumentError('contractCreateTx', 'a contractCreateTx or gaAttach', txType);
+  }
+
+  return buildContractId(tx.ownerId, +tx.nonce);
+}
 //# sourceMappingURL=index.mjs.map