@aeternity/aepp-sdk 13.0.0-alpha.0 → 13.0.0-beta.0

package/src/tx/execution-cost.ts

@@ -0,0 +1,146 @@
+import { Encoded } from '../utils/encoder';
+import { buildTx, buildTxHash, unpackTx } from './builder';
+import { Tag } from './builder/constants';
+import { verify } from '../utils/crypto';
+import { getBufferToSign } from '../account/Memory';
+import { IllegalArgumentError, InternalError, TransactionError } from '../utils/errors';
+import Node from '../Node';
+import getTransactionSignerAddress from './transaction-signer';
+
+/**
+ * Calculates the cost of transaction execution
+ * Provides an upper cost of contract-call-related transactions because of `gasLimit`.
+ * Also assumes that oracle query fee is 0 unless it is provided in options.
+ * @param transaction - Transaction to calculate the cost of
+ * @param innerTx - Should be provided if transaction wrapped with Tag.PayingForTx
+ * @param gasUsed - Amount of gas actually used to make calculation more accurate
+ * @param queryFee - Oracle query fee
+ * @param isInitiator - Is transaction signer an initiator of state channel
+ */
+export function getExecutionCost(
+  transaction: Encoded.Transaction,
+  {
+    innerTx, gasUsed, queryFee, isInitiator,
+  }: {
+    innerTx?: 'fee-payer' | 'freeloader';
+    gasUsed?: number;
+    queryFee?: string;
+    isInitiator?: boolean;
+  } = {},
+): bigint {
+  const params = unpackTx(transaction);
+  if (params.tag === Tag.SignedTx) {
+    throw new IllegalArgumentError('Transaction shouldn\'t be a SignedTx, use `getExecutionCostBySignedTx` instead');
+  }
+
+  let res = 0n;
+  if ('fee' in params && innerTx !== 'freeloader') {
+    res += BigInt(params.fee);
+  }
+  if (params.tag === Tag.NameClaimTx) {
+    res += BigInt(params.nameFee);
+  }
+  if (params.tag === Tag.OracleQueryTx) {
+    res += BigInt(params.queryFee);
+  }
+  if (params.tag === Tag.OracleResponseTx) {
+    res -= BigInt(queryFee ?? 0);
+  }
+  if (params.tag === Tag.ChannelSettleTx) {
+    if (isInitiator === true) res -= BigInt(params.initiatorAmountFinal);
+    if (isInitiator === false) res -= BigInt(params.responderAmountFinal);
+  }
+  if (
+    ((params.tag === Tag.SpendTx && params.senderId !== params.recipientId)
+    || params.tag === Tag.ContractCreateTx || params.tag === Tag.ContractCallTx
+    || params.tag === Tag.ChannelDepositTx) && innerTx !== 'fee-payer'
+  ) {
+    res += BigInt(params.amount);
+  }
+  if (params.tag === Tag.ContractCreateTx) res += BigInt(params.deposit);
+  if (
+    (params.tag === Tag.ContractCreateTx || params.tag === Tag.ContractCallTx
+      || params.tag === Tag.GaAttachTx || params.tag === Tag.GaMetaTx)
+    && innerTx !== 'freeloader'
+  ) {
+    res += BigInt(params.gasPrice) * BigInt(gasUsed ?? params.gasLimit);
+  }
+  if (params.tag === Tag.GaMetaTx || params.tag === Tag.PayingForTx) {
+    res += getExecutionCost(
+      buildTx(params.tx.encodedTx),
+      params.tag === Tag.PayingForTx ? { innerTx: 'fee-payer' } : {},
+    );
+  }
+  return res;
+}
+
+/**
+ * Calculates the cost of signed transaction execution
+ * @param transaction - Transaction to calculate the cost of
+ * @param networkId - Network id used to sign the transaction
+ * @param options - Options
+ */
+export function getExecutionCostBySignedTx(
+  transaction: Encoded.Transaction,
+  networkId: string,
+  options?: Omit<Parameters<typeof getExecutionCost>[1], 'innerTx'>,
+): bigint {
+  const params = unpackTx(transaction, Tag.SignedTx);
+  if (params.encodedTx.tag === Tag.GaMetaTx) {
+    return getExecutionCost(buildTx(params.encodedTx), options);
+  }
+
+  const tx = buildTx(params.encodedTx);
+  const address = getTransactionSignerAddress(tx);
+  const [isInnerTx, isNotInnerTx] = [true, false]
+    .map((f) => verify(getBufferToSign(tx, networkId, f), params.signatures[0], address));
+  if (!isInnerTx && !isNotInnerTx) throw new TransactionError('Can\'t verify signature');
+  return getExecutionCost(
+    buildTx(params.encodedTx),
+    { ...isInnerTx && { innerTx: 'freeloader' }, ...options },
+  );
+}
+
+/**
+ * Calculates the cost of signed and not signed transaction execution using node
+ * @param transaction - Transaction to calculate the cost of
+ * @param node - Node to use
+ * @param isMined - Is transaction already mined or not
+ * @param options - Options
+ */
+export async function getExecutionCostUsingNode(
+  transaction: Encoded.Transaction,
+  node: Node,
+  { isMined, ...options }: { isMined?: boolean } & Parameters<typeof getExecutionCost>[1] = {},
+): Promise<bigint> {
+  let params = unpackTx(transaction);
+  const isSignedTx = params.tag === Tag.SignedTx;
+  const txHash = isSignedTx && isMined === true && buildTxHash(transaction);
+  if (params.tag === Tag.SignedTx) params = params.encodedTx;
+
+  // TODO: set gasUsed for PayingForTx after solving https://github.com/aeternity/aeternity/issues/4087
+  if (
+    options.gasUsed == null && txHash !== false
+    && [Tag.ContractCreateTx, Tag.ContractCallTx, Tag.GaAttachTx, Tag.GaMetaTx].includes(params.tag)
+  ) {
+    const { callInfo, gaInfo } = await node.getTransactionInfoByHash(txHash);
+    const combinedInfo = callInfo ?? gaInfo;
+    if (combinedInfo == null) {
+      throw new InternalError(`callInfo and gaInfo is not available for transaction ${txHash}`);
+    }
+    options.gasUsed = combinedInfo.gasUsed;
+  }
+
+  if (options.queryFee == null && Tag.OracleResponseTx === params.tag) {
+    options.queryFee = (await node.getOracleByPubkey(params.oracleId)).queryFee.toString();
+  }
+
+  if (options.isInitiator == null && Tag.ChannelSettleTx === params.tag && isMined !== true) {
+    const { initiatorId } = await node.getChannelByPubkey(params.channelId);
+    options.isInitiator = params.fromId === initiatorId;
+  }
+
+  return isSignedTx
+    ? getExecutionCostBySignedTx(transaction, await node.getNetworkId(), options)
+    : getExecutionCost(transaction, options);
+}

package/src/tx/transaction-signer.ts

@@ -0,0 +1,27 @@
+import { Encoded } from '../utils/encoder';
+import { buildTx, getSchema, unpackTx } from './builder';
+import { Tag } from './builder/constants';
+import { TransactionError, UnexpectedTsError } from '../utils/errors';
+
+/**
+ * Returns account address that signed a transaction
+ * @param transaction - transaction to get a signer of
+ */
+export default function getTransactionSignerAddress(
+  transaction: Encoded.Transaction,
+): Encoded.AccountAddress {
+  const params = unpackTx(transaction);
+  switch (params.tag) {
+    case Tag.SignedTx:
+      return getTransactionSignerAddress(buildTx(params.encodedTx));
+    case Tag.GaMetaTx:
+      return params.gaId;
+    default:
+  }
+
+  const nonce = getSchema(params.tag, params.version).find(([name]) => name === 'nonce')?.[1];
+  if (nonce == null) throw new TransactionError(`Transaction doesn't have nonce: ${Tag[params.tag]}`);
+  if (!('senderKey' in nonce)) throw new UnexpectedTsError();
+  const address = params[nonce.senderKey as keyof typeof params] as unknown as string;
+  return address.replace(/^ok_/, 'ak_') as Encoded.AccountAddress;
+}

package/src/tx/validator.ts

@@ -1,21 +1,16 @@
-import BigNumber from 'bignumber.js';
 import { hash, verify } from '../utils/crypto';
-import {
-  CtVersion,
-  PROTOCOL_VM_ABI,
-  RawTxObject,
-  TxParamsCommon,
-  TxSchema,
-  TxTypeSchemas,
-} from './builder/schema';
-import { Tag } from './builder/constants';
-import { TxUnpacked, unpackTx } from './builder';
-import { UnsupportedProtocolError } from '../utils/errors';
-import { concatBuffers, isAccountNotFoundError, isKeyOfObject } from '../utils/other';
-import { encode, Encoded, Encoding } from '../utils/encoder';
+import { TxUnpacked } from './builder/schema.generated';
+import { CtVersion, ProtocolToVmAbi } from './builder/field-types/ct-version';
+import { Tag, ConsensusProtocolVersion } from './builder/constants';
+import { buildTx, unpackTx } from './builder';
+import { concatBuffers, isAccountNotFoundError } from '../utils/other';
+import { Encoded, decode } from '../utils/encoder';
 import Node, { TransformNodeType } from '../Node';
 import { Account } from '../apis/node';
 import { genAggressiveCacheGetResponsesPolicy } from '../utils/autorest';
+import { UnexpectedTsError } from '../utils/errors';
+import getTransactionSignerAddress from './transaction-signer';
+import { getExecutionCostUsingNode } from './execution-cost';
 
 export interface ValidatorResult {
   message: string;
@@ -24,108 +19,83 @@ export interface ValidatorResult {
 }
 
 type Validator = (
-  tx: {
-    encodedTx: TxUnpacked<TxSchema>;
-    signatures: Buffer[];
-    tx: TxUnpacked<TxSchema> & {
-      tx: TxTypeSchemas[Tag.SignedTx];
-    };
-    nonce?: number;
-    ttl?: number;
-    amount?: number;
-    fee?: number;
-    nameFee?: number;
-    ctVersion?: Partial<CtVersion>;
-    abiVersion?: number;
-    contractId?: Encoded.ContractAddress;
-  },
+  tx: TxUnpacked,
   options: {
     // TODO: remove after fixing node types
-    account?: TransformNodeType<Account> & { id: Encoded.AccountAddress };
+    account: TransformNodeType<Account> & { id: Encoded.AccountAddress };
     nodeNetworkId: string;
     parentTxTypes: Tag[];
     node: Node;
-    txType: Tag;
     height: number;
-    consensusProtocolVersion: number;
+    consensusProtocolVersion: ConsensusProtocolVersion;
   }
 ) => ValidatorResult[] | Promise<ValidatorResult[]>;
 
 const validators: Validator[] = [];
 
-const getSenderAddress = (
-  tx: TxParamsCommon | RawTxObject<TxSchema>,
-): Encoded.AccountAddress | undefined => [
-  'senderId', 'accountId', 'ownerId', 'callerId',
-  'oracleId', 'fromId', 'initiator', 'gaId', 'payerId',
-]
-  .map((key: keyof TxSchema) => tx[key])
-  .filter((a) => a)
-  .map((a) => a?.toString().replace(/^ok_/, 'ak_'))[0] as Encoded.AccountAddress | undefined;
+async function verifyTransactionInternal(
+  tx: TxUnpacked,
+  node: Node,
+  parentTxTypes: Tag[],
+): Promise<ValidatorResult[]> {
+  const address = getTransactionSignerAddress(buildTx(tx));
+  const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
+    node.getAccountByPubkey(address)
+      .catch((error) => {
+        if (!isAccountNotFoundError(error)) throw error;
+        return { id: address, balance: 0n, nonce: 0 };
+      })
+      // TODO: remove after fixing https://github.com/aeternity/aepp-sdk-js/issues/1537
+      .then((acc) => ({ ...acc, id: acc.id as Encoded.AccountAddress })),
+    node.getCurrentKeyBlockHeight(),
+    node.getNodeInfo(),
+  ]);
+
+  return (await Promise.all(
+    validators.map(async (v) => v(
+      tx,
+      {
+        node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
+      },
+    )),
+  )).flat();
+}
 
 /**
  * Transaction Validator
- * This function validates some of transaction properties,
+ * This function validates some transaction properties,
  * to make sure it can be posted it to the chain
  * @category transaction builder
  * @param transaction - Base64Check-encoded transaction
  * @param nodeNotCached - Node to validate transaction against
- * @param parentTxTypes - Types of parent transactions
  * @returns Array with verification errors
  * @example const errors = await verifyTransaction(transaction, node)
  */
 export default async function verifyTransaction(
-  transaction: Encoded.Transaction | Encoded.Poi,
+  transaction: Parameters<typeof unpackTx>[0],
   nodeNotCached: Node,
-  parentTxTypes: Tag[] = [],
 ): Promise<ValidatorResult[]> {
-  let node = nodeNotCached;
-  if (
-    !node.pipeline.getOrderedPolicies()
-      .some(({ name }) => name === 'aggressive-cache-get-responses')
-  ) {
-    node = new Node(nodeNotCached.$host, { ignoreVersion: true });
-    node.pipeline.addPolicy(genAggressiveCacheGetResponsesPolicy());
-  }
-
-  const { tx, txType } = unpackTx<Tag.SignedTx>(transaction);
-  const address = getSenderAddress(tx)
-    ?? (txType === Tag.SignedTx ? getSenderAddress(tx.encodedTx.tx) : undefined);
-  const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
-    address == null
-      ? undefined
-      : node.getAccountByPubkey(address)
-        .catch((error) => {
-          if (!isAccountNotFoundError(error)) throw error;
-          return { id: address, balance: 0n, nonce: 0 };
-        })
-        // TODO: remove after fixing https://github.com/aeternity/aepp-sdk-js/issues/1537
-        .then((acc) => ({ ...acc, id: acc.id as Encoded.AccountAddress })),
-    node.getCurrentKeyBlockHeight(),
-    node.getNodeInfo(),
-  ]);
-
-  return (await Promise.all(
-    validators.map((v) => v(
-      tx as any,
-      {
-        txType, node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
-      },
-    )),
-  )).flat();
+  const node = new Node(nodeNotCached.$host, {
+    ignoreVersion: true,
+    pipeline: nodeNotCached.pipeline.clone(),
+    additionalPolicies: [genAggressiveCacheGetResponsesPolicy()],
+  });
+  return verifyTransactionInternal(unpackTx(transaction), node, []);
 }
 
 validators.push(
-  ({ encodedTx, signatures }, { account, nodeNetworkId, parentTxTypes }) => {
-    if ((encodedTx ?? signatures) === undefined) return [];
-    if (account == null) return [];
-    if (signatures.length !== 1) return []; // TODO: Support multisignature?
+  (tx, { account, nodeNetworkId, parentTxTypes }) => {
+    if (tx.tag !== Tag.SignedTx) return [];
+    const { encodedTx, signatures } = tx;
+    if ((encodedTx ?? signatures) == null) return [];
+    if (signatures.length !== 1) return []; // TODO: Support multisignature like in state channels
     const prefix = Buffer.from([
       nodeNetworkId,
       ...parentTxTypes.includes(Tag.PayingForTx) ? ['inner_tx'] : [],
     ].join('-'));
-    const txWithNetworkId = concatBuffers([prefix, encodedTx.rlpEncoded]);
-    const txHashWithNetworkId = concatBuffers([prefix, hash(encodedTx.rlpEncoded)]);
+    const txBinary = decode(buildTx(encodedTx));
+    const txWithNetworkId = concatBuffers([prefix, txBinary]);
+    const txHashWithNetworkId = concatBuffers([prefix, hash(txBinary)]);
     if (verify(txWithNetworkId, signatures[0], account.id)
       || verify(txHashWithNetworkId, signatures[0], account.id)) return [];
     return [{
@@ -135,104 +105,80 @@ validators.push(
       checkedKeys: ['encodedTx', 'signatures'],
     }];
   },
-  async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
-    if ((encodedTx ?? tx) === undefined) return [];
-    return verifyTransaction(
-      encode((encodedTx ?? tx).rlpEncoded, Encoding.Transaction),
-      node,
-      [...parentTxTypes, txType],
-    );
+  async (tx, { node, parentTxTypes }) => {
+    let nestedTx;
+    if ('encodedTx' in tx) nestedTx = tx.encodedTx;
+    if ('tx' in tx) nestedTx = tx.tx;
+    if (nestedTx == null) return [];
+    return verifyTransactionInternal(nestedTx, node, [...parentTxTypes, tx.tag]);
   },
-  ({ ttl }, { height }) => {
-    if (ttl === undefined) return [];
-    ttl = +ttl;
-    if (ttl === 0 || ttl >= height) return [];
+  (tx, { height }) => {
+    if (!('ttl' in tx)) return [];
+    if (tx.ttl === 0 || tx.ttl >= height) return [];
     return [{
-      message: `TTL ${ttl} is already expired, current height is ${height}`,
+      message: `TTL ${tx.ttl} is already expired, current height is ${height}`,
       key: 'ExpiredTTL',
       checkedKeys: ['ttl'],
     }];
   },
-  ({
-    amount, fee, nameFee, tx,
-  }, { account, parentTxTypes, txType }) => {
-    if (account == null) return [];
-    if ((amount ?? fee ?? nameFee) === undefined) return [];
-    fee ??= 0;
-    const cost = new BigNumber(fee).plus(nameFee ?? 0).plus(amount ?? 0)
-      .plus(txType === Tag.PayingForTx ? (tx.tx.encodedTx.tx).fee : 0)
-      .minus(parentTxTypes.includes(Tag.PayingForTx) ? fee : 0);
-    if (cost.lte(account.balance.toString())) return [];
+  async (tx, { account, parentTxTypes, node }) => {
+    if (parentTxTypes.length !== 0) return [];
+    const cost = await getExecutionCostUsingNode(buildTx(tx), node).catch(() => 0n);
+    if (cost <= account.balance) return [];
     return [{
-      message: `Account balance ${account.balance.toString()} is not enough to execute the transaction that costs ${cost.toFixed()}`,
+      message: `Account balance ${account.balance} is not enough to execute the transaction that costs ${cost}`,
       key: 'InsufficientBalance',
-      checkedKeys: ['amount', 'fee', 'nameFee'],
+      checkedKeys: ['amount', 'fee', 'nameFee', 'gasLimit', 'gasPrice'],
     }];
   },
-  ({ signatures }, { account, txType }) => {
-    if (account == null) return [];
+  (tx, { account }) => {
     let message;
-    if (txType === Tag.SignedTx && account.kind === 'generalized' && signatures.length !== 0) {
+    if (tx.tag === Tag.SignedTx && account.kind === 'generalized' && tx.signatures.length !== 0) {
       message = 'Generalized account can\'t be used to generate SignedTx with signatures';
     }
-    if (txType === Tag.GaMetaTx && account.kind === 'basic') {
+    if (tx.tag === Tag.GaMetaTx && account.kind === 'basic') {
       message = 'Basic account can\'t be used to generate GaMetaTx';
     }
     if (message == null) return [];
     return [{ message, key: 'InvalidAccountType', checkedKeys: ['tag'] }];
   },
-  ({ nonce }, { account, parentTxTypes }) => {
-    if (nonce == null || account == null || parentTxTypes.includes(Tag.GaMetaTx)) return [];
-    nonce = +nonce;
-    const validNonce = account.nonce + 1;
-    if (nonce === validNonce) return [];
-    return [{
-      ...nonce < validNonce
-        ? {
-          message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
-          key: 'NonceAlreadyUsed',
-        }
-        : {
-          message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
-          key: 'NonceHigh',
-        },
-      checkedKeys: ['nonce'],
-    }];
-  },
-  ({ ctVersion, abiVersion }, { txType, consensusProtocolVersion }) => {
-    if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
-      throw new UnsupportedProtocolError(`Unsupported protocol: ${consensusProtocolVersion}`);
-    }
-    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion];
+  // TODO: revert nonce check
+  (tx, { consensusProtocolVersion }) => {
+    const oracleCall = Tag.Oracle === tx.tag || Tag.OracleRegisterTx === tx.tag;
+    const contractCreate = Tag.ContractCreateTx === tx.tag || Tag.GaAttachTx === tx.tag;
+    const contractCall = Tag.ContractCallTx === tx.tag || Tag.GaMetaTx === tx.tag;
+    const type = (oracleCall ? 'oracle-call' : null)
+      ?? (contractCreate ? 'contract-create' : null)
+      ?? (contractCall ? 'contract-call' : null);
+    if (type == null) return [];
+    const protocol = ProtocolToVmAbi[consensusProtocolVersion][type] as {
+      abiVersion: readonly any[];
+      vmVersion: readonly any[];
+    };
 
-    // If not contract create tx
-    if (ctVersion == null) ctVersion = { abiVersion };
-    const txProtocol = protocol[txType as keyof typeof protocol];
-    if (txProtocol == null) return [];
-    if (Object.entries(ctVersion).some(
-      ([
-        key,
-        value,
-      ]: [
-        key:keyof typeof txProtocol,
-        value:any]) => !(txProtocol[key].includes(+value as never)),
-    )) {
+    let ctVersion: Partial<CtVersion> | undefined;
+    if ('abiVersion' in tx) ctVersion = { abiVersion: tx.abiVersion };
+    if ('ctVersion' in tx) ctVersion = tx.ctVersion;
+    if (ctVersion == null) throw new UnexpectedTsError();
+    if (
+      !protocol.abiVersion.includes(ctVersion.abiVersion)
+      || (contractCreate && !protocol.vmVersion.includes(ctVersion.vmVersion))
+    ) {
       return [{
-        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(txProtocol)}`,
+        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(protocol)}`,
         key: 'VmAndAbiVersionMismatch',
         checkedKeys: ['ctVersion', 'abiVersion'],
       }];
     }
     return [];
   },
-  async ({ contractId }, { txType, node }) => {
-    if (Tag.ContractCallTx !== txType) return [];
-    contractId = contractId as Encoded.ContractAddress;
+  async (tx, { node }) => {
+    if (Tag.ContractCallTx !== tx.tag) return [];
     try {
-      const { active } = await node.getContract(contractId);
+      const { active } = await node.getContract(tx.contractId);
       if (active) return [];
       return [{
-        message: `Contract ${contractId} is not active`,
+        message: `Contract ${tx.contractId} is not active`,
         key: 'ContractNotActive',
         checkedKeys: ['contractId'],
       }];

package/src/utils/amount-formatter.ts

@@ -1,19 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
 import BigNumber from 'bignumber.js';
 import { isBigNumber } from './bignumber';
 import { ArgumentError } from './errors';

package/src/utils/autorest.ts

@@ -2,7 +2,7 @@ import { RestError, PipelineResponse, PipelinePolicy } from '@azure/core-rest-pi
 import { AdditionalPolicyConfig } from '@azure/core-client';
 import { pause } from './other';
 import semverSatisfies from './semver-satisfies';
-import { UnsupportedVersionError } from './errors';
+import { UnexpectedTsError, UnsupportedVersionError } from './errors';
 
 export const genRequestQueuesPolicy = (): AdditionalPolicyConfig => {
   const requestQueues = new Map<string, Promise<unknown>>();
@@ -48,18 +48,21 @@ export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
   };
 };
 
-export const genAggressiveCacheGetResponsesPolicy = (): PipelinePolicy => {
+export const genAggressiveCacheGetResponsesPolicy = (): AdditionalPolicyConfig => {
   const getRequests = new Map<string, Promise<PipelineResponse>>();
 
   return {
-    name: 'aggressive-cache-get-responses',
-    async sendRequest(request, next) {
-      if (request.method !== 'GET') return next(request);
-      const key = JSON.stringify([request.url, request.body]);
-      const response = getRequests.get(key) ?? next(request);
-      getRequests.set(key, response);
-      return response;
+    policy: {
+      name: 'aggressive-cache-get-responses',
+      async sendRequest(request, next) {
+        if (request.method !== 'GET') return next(request);
+        const key = JSON.stringify([request.url, request.body]);
+        const response = getRequests.get(key) ?? next(request);
+        getRequests.set(key, response);
+        return response;
+      },
     },
+    position: 'perCall',
   };
 };
 
@@ -94,15 +97,53 @@ export const genErrorFormatterPolicy = (
 export const genVersionCheckPolicy = (
   name: string,
   ignorePath: string,
-  versionPromise: Promise<string>,
+  versionPromise: Promise<string | Error>,
   geVersion: string,
   ltVersion: string,
 ): PipelinePolicy => ({
   name: 'version-check',
   async sendRequest(request, next) {
     if (new URL(request.url).pathname === ignorePath) return next(request);
-    const args = [await versionPromise, geVersion, ltVersion] as const;
+    const version = await versionPromise;
+    if (version instanceof Error) throw version;
+    const args = [version, geVersion, ltVersion] as const;
     if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args);
     return next(request);
   },
 });
+
+export const genRetryOnFailurePolicy = (
+  retryCount: number,
+  retryOverallDelay: number,
+): AdditionalPolicyConfig => ({
+  policy: {
+    name: 'retry-on-failure',
+    async sendRequest(request, next) {
+      const statusesToNotRetry = [200, 400, 403];
+
+      const intervals = new Array(retryCount).fill(0)
+        .map((_, idx) => ((idx + 1) / retryCount) ** 2);
+      const intervalSum = intervals.reduce((a, b) => a + b);
+      const intervalsInMs = intervals.map((el) => (el / intervalSum) * retryOverallDelay);
+
+      let error: Error | undefined;
+      for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+        if (error != null) {
+          if (
+            !(error instanceof RestError)
+            || statusesToNotRetry.includes(error.response?.status ?? 0)
+          ) throw error;
+          await pause(intervalsInMs[attempt - 1]);
+        }
+        try {
+          return await next(request);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (error == null) throw new UnexpectedTsError();
+      throw error;
+    },
+  },
+  position: 'perCall',
+});

package/src/utils/bytes.ts

@@ -1,19 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
 import BigNumber from 'bignumber.js';
 import { NoSerializerFoundError, TypeError } from './errors';
 
@@ -29,7 +13,7 @@ export function toBytes(val?: null | string | number | BigNumber, big = false):
   // If the value is an int it will be encoded as bytes big endian
   // Raises ValueError if the input is not an int or string
 
-  if (val === undefined || val === null) return Buffer.from([]);
+  if (val == null) return Buffer.from([]);
   if (Number.isInteger(val) || BigNumber.isBigNumber(val) || big) {
     if (!BigNumber.isBigNumber(val)) val = new BigNumber(val);
     if (!val.isInteger()) throw new TypeError(`Unexpected not integer value: ${val.toFixed()}`);