@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/es/chain.mjs

@@ -17,9 +17,14 @@
 import { AE_AMOUNT_FORMATS, formatAmount } from "./utils/amount-formatter.mjs";
 import verifyTransaction from "./tx/validator.mjs";
 import { pause } from "./utils/other.mjs";
-import { isNameValid, produceNameId, decode } from "./tx/builder/helpers.mjs";
+import { isNameValid, produceNameId } from "./tx/builder/helpers.mjs";
 import { DRY_RUN_ACCOUNT } from "./tx/builder/schema.mjs";
-import { AensPointerContextError, DryRunError, InvalidAensNameError, InvalidTxError, RequestTimedOutError, TxTimedOutError, TxNotInChainError, InternalError } from "./utils/errors.mjs";
+import { AensPointerContextError, DryRunError, InvalidAensNameError, TransactionError, TxTimedOutError, TxNotInChainError, InternalError } from "./utils/errors.mjs";
+import { decode } from "./utils/encoder.mjs";
+
+/**
+ * @category chain
+ */
 export function _getPollInterval(type, _ref) {
   let {
     _expectedMineRate = 180000,
@@ -32,8 +37,139 @@ export function _getPollInterval(type, _ref) {
   }[type];
   return Math.min(base / 3, _maxPollInterval);
 }
+/**
+ * @category exception
+ */
+
+export class InvalidTxError extends TransactionError {
+  constructor(message, validation, transaction) {
+    super(message);
+    this.name = 'InvalidTxError';
+    this.validation = validation;
+    this.transaction = transaction;
+  }
+
+}
+/**
+ * Obtain current height of the chain
+ * @category chain
+ * @returns Current chain height
+ */
+
+export async function getHeight(_ref2) {
+  let {
+    onNode
+  } = _ref2;
+  return (await onNode.getCurrentKeyBlockHeight()).height;
+}
+/**
+ * Wait for a transaction to be mined
+ * @category chain
+ * @param th - The hash of transaction to poll
+ * @param options - Options
+ * @param options.interval - Interval (in ms) at which to poll the chain
+ * @param options.blocks - Number of blocks mined after which to fail
+ * @param options.onNode - Node to use
+ * @returns The transaction as it was mined
+ */
+
+export async function poll(th, _ref3) {
+  var _interval;
+
+  let {
+    blocks = 10,
+    interval,
+    onNode,
+    ...options
+  } = _ref3;
+  (_interval = interval) !== null && _interval !== void 0 ? _interval : interval = _getPollInterval('microblock', options);
+  const max = (await getHeight({
+    onNode
+  })) + blocks;
+
+  do {
+    const tx = await onNode.getTransactionByHash(th);
+    if (tx.blockHeight !== -1) return tx;
+    await pause(interval);
+  } while ((await getHeight({
+    onNode
+  })) < max);
+
+  throw new TxTimedOutError(blocks, th);
+}
+/**
+ * Wait for the chain to reach a specific height
+ * @category chain
+ * @param height - Height to wait for
+ * @param options - Options
+ * @param options.interval - Interval (in ms) at which to poll the chain
+ * @param options.onNode - Node to use
+ * @returns Current chain height
+ */
+
+export async function awaitHeight(height, _ref4) {
+  var _interval2;
+
+  let {
+    interval,
+    onNode,
+    ...options
+  } = _ref4;
+  (_interval2 = interval) !== null && _interval2 !== void 0 ? _interval2 : interval = _getPollInterval('block', options);
+  let currentHeight;
+
+  do {
+    if (currentHeight != null) await pause(interval);
+    currentHeight = (await onNode.getCurrentKeyBlockHeight()).height;
+  } while (currentHeight < height);
+
+  return currentHeight;
+}
+/**
+ * Wait for transaction confirmation
+ * @category chain
+ * @param txHash - Transaction hash
+ * @param options - Options
+ * @param options.confirm - Number of micro blocks to wait for transaction confirmation
+ * @param options.onNode - Node to use
+ * @returns Current Height
+ */
+
+export async function waitForTxConfirm(txHash, _ref5) {
+  let {
+    confirm = 3,
+    onNode,
+    ...options
+  } = _ref5;
+  const {
+    blockHeight
+  } = await onNode.getTransactionByHash(txHash);
+  const height = await awaitHeight(blockHeight + confirm, {
+    onNode,
+    ...options
+  });
+  const {
+    blockHeight: newBlockHeight
+  } = await onNode.getTransactionByHash(txHash);
+
+  switch (newBlockHeight) {
+    case -1:
+      throw new TxNotInChainError(txHash);
+
+    case blockHeight:
+      return height;
+
+    default:
+      return waitForTxConfirm(txHash, {
+        onNode,
+        confirm,
+        ...options
+      });
+  }
+}
 /**
  * Submit a signed transaction for mining
+ * @category chain
  * @param tx - Transaction to submit
  * @param options - Options
  * @param options.onNode - Node to use
@@ -44,7 +180,7 @@ export function _getPollInterval(type, _ref) {
  * @returns Transaction details
  */
 
-export async function sendTransaction(tx, _ref2) {
+export async function sendTransaction(tx, _ref6) {
   let {
     onNode,
     onAccount,
@@ -52,31 +188,37 @@ export async function sendTransaction(tx, _ref2) {
     waitMined = true,
     confirm,
     ...options
-  } = _ref2;
+  } = _ref6;
 
   if (verify) {
     const validation = await verifyTransaction(tx, onNode);
 
     if (validation.length > 0) {
-      const message = 'Transaction verification errors: ' + validation.map(v => v.message).join(', ');
+      const message = `Transaction verification errors: ${validation.map(v => v.message).join(', ')}`;
       throw new InvalidTxError(message, validation, tx);
     }
   }
 
   try {
-    var _await$onAccount$addr;
+    let __queue;
+
+    try {
+      __queue = onAccount != null ? `tx-${await onAccount.address(options)}` : null;
+    } catch (error) {
+      __queue = null;
+    }
 
     const {
       txHash
     } = await onNode.postTransaction({
       tx
-    }, {
+    }, __queue != null ? {
       requestOptions: {
         customHeaders: {
-          __queue: `tx-${(_await$onAccount$addr = await (onAccount === null || onAccount === void 0 ? void 0 : onAccount.address(options).catch(() => ''))) !== null && _await$onAccount$addr !== void 0 ? _await$onAccount$addr : ''}`
+          __queue
         }
       }
-    });
+    } : {});
 
     if (waitMined) {
       const pollResult = await poll(txHash, {
@@ -109,72 +251,33 @@ export async function sendTransaction(tx, _ref2) {
   } catch (error) {
     throw Object.assign(error, {
       rawTx: tx,
-      verifyTx: async () => await verifyTransaction(tx, onNode)
+      verifyTx: async () => verifyTransaction(tx, onNode)
     });
   }
 }
 
-/**
- * Wait for transaction confirmation
- * @param txHash - Transaction hash
- * @param options - Options
- * @param options.confirm - Number of micro blocks to wait for transaction confirmation
- * @param options.onNode - Node to use
- * @returns Current Height
- */
-export async function waitForTxConfirm(txHash, _ref3) {
-  let {
-    confirm = 3,
-    onNode,
-    ...options
-  } = _ref3;
-  const {
-    blockHeight
-  } = await onNode.getTransactionByHash(txHash);
-  const height = await awaitHeight(blockHeight + confirm, {
-    onNode,
-    ...options
-  });
-  const {
-    blockHeight: newBlockHeight
-  } = await onNode.getTransactionByHash(txHash);
-
-  switch (newBlockHeight) {
-    case -1:
-      throw new TxNotInChainError(txHash);
-
-    case blockHeight:
-      return height;
-
-    default:
-      return await waitForTxConfirm(txHash, {
-        onNode,
-        confirm,
-        ...options
-      });
-  }
-}
 /**
  * Get account by account public key
+ * @category chain
  * @param address - Account address (public key)
  * @param options - Options
  * @param options.height - Get account on specific block by block height
  * @param options.hash - Get account on specific block by micro block hash or key block hash
  * @param options.onNode - Node to use
  */
-
-export async function getAccount(address, _ref4) {
+export async function getAccount(address, _ref7) {
   let {
     height,
     hash,
     onNode
-  } = _ref4;
-  if (height != null) return await onNode.getAccountByPubkeyAndHeight(address, height);
-  if (hash != null) return await onNode.getAccountByPubkeyAndHash(address, hash);
-  return await onNode.getAccountByPubkey(address);
+  } = _ref7;
+  if (height != null) return onNode.getAccountByPubkeyAndHeight(address, height);
+  if (hash != null) return onNode.getAccountByPubkeyAndHash(address, hash);
+  return onNode.getAccountByPubkey(address);
 }
 /**
  * Request the balance of specified account
+ * @category chain
  * @param address - The public account address to obtain the balance for
  * @param options - Options
  * @param options.format
@@ -183,11 +286,11 @@ export async function getAccount(address, _ref4) {
  * @param options.hash - The block hash on which to obtain the balance for (default: top of chain)
  */
 
-export async function getBalance(address, _ref5) {
+export async function getBalance(address, _ref8) {
   let {
     format = AE_AMOUNT_FORMATS.AETTOS,
     ...options
-  } = _ref5;
+  } = _ref8;
   const {
     balance
   } = await getAccount(address, options).catch(() => ({
@@ -197,83 +300,9 @@ export async function getBalance(address, _ref5) {
     targetDenomination: format
   });
 }
-/**
- * Obtain current height of the chain
- * @returns Current chain height
- */
-
-export async function height(_ref6) {
-  let {
-    onNode
-  } = _ref6;
-  return (await onNode.getCurrentKeyBlockHeight()).height;
-}
-/**
- * Wait for the chain to reach a specific height
- * @param height - Height to wait for
- * @param options - Options
- * @param options.interval - Interval (in ms) at which to poll the chain
- * @param options.attempts - Number of polling attempts after which to fail
- * @param options.onNode - Node to use
- * @returns Current chain height
- */
-
-export async function awaitHeight(height, _ref7) {
-  var _interval;
-
-  let {
-    interval,
-    attempts = 20,
-    onNode,
-    ...options
-  } = _ref7;
-  (_interval = interval) !== null && _interval !== void 0 ? _interval : interval = _getPollInterval('block', options);
-  let currentHeight;
-
-  for (let i = 0; i < attempts; i++) {
-    if (i !== 0) await pause(interval);
-    currentHeight = (await onNode.getCurrentKeyBlockHeight()).height;
-    if (currentHeight >= height) return currentHeight;
-  }
-
-  throw new RequestTimedOutError((attempts - 1) * interval, currentHeight, height);
-}
-/**
- * Wait for a transaction to be mined
- * @param th - The hash of transaction to poll
- * @param options - Options
- * @param options.interval - Interval (in ms) at which to poll the chain
- * @param options.blocks - Number of blocks mined after which to fail
- * @param options.onNode - Node to use
- * @returns The transaction as it was mined
- */
-
-export async function poll(th, _ref8) {
-  var _interval2;
-
-  let {
-    blocks = 10,
-    interval,
-    onNode,
-    ...options
-  } = _ref8;
-  (_interval2 = interval) !== null && _interval2 !== void 0 ? _interval2 : interval = _getPollInterval('microblock', options);
-  const max = (await height({
-    onNode
-  })) + blocks;
-
-  do {
-    const tx = await onNode.getTransactionByHash(th);
-    if (tx.blockHeight !== -1) return tx;
-    await pause(interval);
-  } while ((await height({
-    onNode
-  })) < max);
-
-  throw new TxTimedOutError(blocks, th);
-}
 /**
  * Obtain current generation
+ * @category chain
  * @param options - Options
  * @param options.onNode - Node to use
  * @returns Current Generation
@@ -283,10 +312,11 @@ export async function getCurrentGeneration(_ref9) {
   let {
     onNode
   } = _ref9;
-  return await onNode.getCurrentGeneration();
+  return onNode.getCurrentGeneration();
 }
 /**
  * Get generation by hash or height
+ * @category chain
  * @param hashOrHeight - Generation hash or height
  * @param options - Options
  * @param options.onNode - Node to use
@@ -297,11 +327,12 @@ export async function getGeneration(hashOrHeight, _ref10) {
   let {
     onNode
   } = _ref10;
-  if (typeof hashOrHeight === 'number') return await onNode.getGenerationByHeight(hashOrHeight);
-  return await onNode.getGenerationByHash(hashOrHeight);
+  if (typeof hashOrHeight === 'number') return onNode.getGenerationByHeight(hashOrHeight);
+  return onNode.getGenerationByHash(hashOrHeight);
 }
 /**
  * Get micro block transactions
+ * @category chain
  * @param hash - Micro block hash
  * @param options - Options
  * @param options.onNode - Node to use
@@ -316,6 +347,7 @@ export async function getMicroBlockTransactions(hash, _ref11) {
 }
 /**
  * Get key block
+ * @category chain
  * @param hashOrHeight - Key block hash or height
  * @param options - Options
  * @param options.onNode - Node to use
@@ -326,11 +358,12 @@ export async function getKeyBlock(hashOrHeight, _ref12) {
   let {
     onNode
   } = _ref12;
-  if (typeof hashOrHeight === 'number') return await onNode.getKeyBlockByHeight(hashOrHeight);
-  return await onNode.getKeyBlockByHash(hashOrHeight);
+  if (typeof hashOrHeight === 'number') return onNode.getKeyBlockByHeight(hashOrHeight);
+  return onNode.getKeyBlockByHash(hashOrHeight);
 }
 /**
  * Get micro block header
+ * @category chain
  * @param hash - Micro block hash
  * @param options - Options
  * @param options.onNode - Node to use
@@ -341,7 +374,7 @@ export async function getMicroBlockHeader(hash, _ref13) {
   let {
     onNode
   } = _ref13;
-  return await onNode.getMicroBlockHeaderByHash(hash);
+  return onNode.getMicroBlockHeaderByHash(hash);
 }
 const txDryRunRequests = new Map();
 
@@ -389,10 +422,9 @@ async function txDryRunHandler(key, onNode) {
       tx,
       accountAddress
     } = rs[idx];
-    if (result === 'ok') return resolve({ ...resultPayload,
+    if (result === 'ok') resolve({ ...resultPayload,
       txEvents
-    });
-    reject(Object.assign(new DryRunError(reason), {
+    });else reject(Object.assign(new DryRunError(reason), {
       tx,
       accountAddress
     }));
@@ -400,6 +432,7 @@ async function txDryRunHandler(key, onNode) {
 }
 /**
  * Transaction dry-run
+ * @category chain
  * @param tx - transaction to execute
  * @param accountAddress - address that will be used to execute transaction
  * @param options - Options
@@ -422,7 +455,7 @@ export async function txDryRun(tx, accountAddress, _ref16) {
   const key = combine === true ? [top, txEvents].join() : 'immediate';
   const requests = (_txDryRunRequests$get = txDryRunRequests.get(key)) !== null && _txDryRunRequests$get !== void 0 ? _txDryRunRequests$get : [];
   txDryRunRequests.set(key, requests);
-  return await new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
     var _requests$timeout;
 
     requests.push({
@@ -446,6 +479,7 @@ export async function txDryRun(tx, accountAddress, _ref16) {
 }
 /**
  * Get contract byte code
+ * @category contract
  * @param contractId - Contract address
  * @param options - Options
  * @param options.onNode - Node to use
@@ -455,10 +489,11 @@ export async function getContractByteCode(contractId, _ref17) {
   let {
     onNode
   } = _ref17;
-  return await onNode.getContractCode(contractId);
+  return onNode.getContractCode(contractId);
 }
 /**
  * Get contract entry
+ * @category contract
  * @param contractId - Contract address
  * @param options - Options
  * @param options.onNode - Node to use
@@ -468,10 +503,11 @@ export async function getContract(contractId, _ref18) {
   let {
     onNode
   } = _ref18;
-  return await onNode.getContract(contractId);
+  return onNode.getContract(contractId);
 }
 /**
  * Get name entry
+ * @category AENS
  * @param name - AENS name
  * @param options - Options
  * @param options.onNode - Node to use
@@ -481,10 +517,11 @@ export async function getName(name, _ref19) {
   let {
     onNode
   } = _ref19;
-  return await onNode.getNameEntryByName(name);
+  return onNode.getNameEntryByName(name);
 }
 /**
  * Resolve AENS name and return name hash
+ * @category AENS
  * @param nameOrId - AENS name or address
  * @param key - in AENS pointers record
  * @param options - Options
@@ -502,16 +539,10 @@ export async function resolveName(nameOrId, key, _ref20) {
     onNode
   } = _ref20;
 
-  try {
-    const id = nameOrId;
-    decode(id);
-    return id;
-  } catch (error) {}
-
   if (isNameValid(nameOrId)) {
     if (verify || resolveByNode) {
       const name = await onNode.getNameEntryByName(nameOrId);
-      const pointer = name.pointers.find(pointer => pointer.key === key);
+      const pointer = name.pointers.find(p => p.key === key);
       if (pointer == null) throw new AensPointerContextError(nameOrId, key);
       if (resolveByNode) return pointer.id;
     }
@@ -519,6 +550,11 @@ export async function resolveName(nameOrId, key, _ref20) {
     return produceNameId(nameOrId);
   }
 
-  throw new InvalidAensNameError(`Invalid name or address: ${nameOrId}`);
+  try {
+    decode(nameOrId);
+    return nameOrId;
+  } catch (error) {
+    throw new InvalidAensNameError(`Invalid name or address: ${nameOrId}`);
+  }
 }
 //# sourceMappingURL=chain.mjs.map