@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/src/utils/errors.ts

@@ -1,11 +1,10 @@
-/**
- * Error module
- * @module @aeternity/aepp-sdk/es/utils/errors
- * @example import { BytecodeMismatchError } from '@aeternity/aepp-sdk'
- */
+import BigNumber from 'bignumber.js'
+import { ValidatorResult } from '../tx/validator'
+import { EncodedData } from './encoder'
 
 /**
  * aepp-sdk originated error
+ * @category exception
  */
 export abstract class BaseError extends Error {
   constructor (message: string) {
@@ -14,6 +13,9 @@ export abstract class BaseError extends Error {
   }
 }
 
+/**
+ * @category exception
+ */
 export class AccountError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -21,6 +23,9 @@ export class AccountError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class AensError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -28,6 +33,9 @@ export class AensError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class AeppError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -35,6 +43,9 @@ export class AeppError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class ChannelError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -42,6 +53,9 @@ export class ChannelError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class CompilerError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -49,6 +63,9 @@ export class CompilerError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class ContractError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -56,6 +73,9 @@ export class ContractError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class CryptographyError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -63,6 +83,9 @@ export class CryptographyError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class NodeError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -70,6 +93,9 @@ export class NodeError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class TransactionError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -77,6 +103,9 @@ export class TransactionError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class WalletError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -84,14 +113,19 @@ export class WalletError extends BaseError {
   }
 }
 
-/* Common error patterns */
+/**
+ * @category exception
+ */
 export class ArgumentError extends BaseError {
   constructor (argumentName: string, requirement: string, argumentValue: any) {
-    super(`${argumentName} should be ${requirement}, got ${argumentValue} instead`)
+    super(`${argumentName} should be ${requirement}, got ${String(argumentValue)} instead`)
     this.name = 'ArgumentError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class IllegalArgumentError extends CryptographyError {
   constructor (message: string) {
     super(message)
@@ -99,6 +133,9 @@ export class IllegalArgumentError extends CryptographyError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class ArgumentCountMismatchError extends BaseError {
   constructor (functionName: string, requiredCount: number, providedCount: number) {
     super(`${functionName} expects ${requiredCount} arguments, got ${providedCount} instead`)
@@ -106,6 +143,9 @@ export class ArgumentCountMismatchError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InsufficientBalanceError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -113,20 +153,9 @@ export class InsufficientBalanceError extends BaseError {
   }
 }
 
-export class InvalidDenominationError extends BaseError {
-  constructor (message: string) {
-    super(message)
-    this.name = 'InvalidDenominationError'
-  }
-}
-
-export class InvalidNameError extends BaseError {
-  constructor (message: string) {
-    super(message)
-    this.name = 'InvalidNameError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class MissingParamError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -134,13 +163,9 @@ export class MissingParamError extends BaseError {
   }
 }
 
-export class NoBrowserFoundError extends BaseError {
-  constructor () {
-    super('Browser is not detected')
-    this.name = 'NoBrowserFoundError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class NoSerializerFoundError extends BaseError {
   constructor () {
     super('Byte serialization not supported')
@@ -148,8 +173,10 @@ export class NoSerializerFoundError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class RequestTimedOutError extends BaseError {
-  constructor (requestTime: number);
   constructor (requestTime: number, currentHeight?: number, height?: number) {
     if (currentHeight !== undefined && height !== undefined) {
       super(`Giving up after ${requestTime}ms, current height: ${currentHeight}, desired height: ${height}`)
@@ -160,17 +187,22 @@ export class RequestTimedOutError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class TxTimedOutError extends BaseError {
-  constructor (blocks: number, th: string, status?: string) {
+  constructor (blocks: number, th: string) {
     super([
       `Giving up after ${blocks} blocks mined`,
-      `transaction hash: ${th}`,
-      ...status ? [`status: ${status}`] : []
+      `transaction hash: ${th}`
     ].join(', '))
     this.name = 'TxTimedOutError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class TypeError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -178,6 +210,9 @@ export class TypeError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnsupportedPlatformError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -185,6 +220,9 @@ export class UnsupportedPlatformError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnsupportedProtocolError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -192,6 +230,9 @@ export class UnsupportedProtocolError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class NotImplementedError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -199,6 +240,9 @@ export class NotImplementedError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnsupportedVersionError extends BaseError {
   constructor (dependency: string, version: string, geVersion: string, ltVersion: string) {
     super(`Unsupported ${dependency} version ${version}. Supported: >= ${geVersion} < ${ltVersion}`)
@@ -206,6 +250,9 @@ export class UnsupportedVersionError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InternalError extends BaseError {
   constructor (message: string) {
     super(message)
@@ -213,7 +260,19 @@ export class InternalError extends BaseError {
   }
 }
 
-/* keypair an account related errors */
+/**
+ * @category exception
+ */
+export class UnexpectedTsError extends InternalError {
+  constructor (message: string = 'Expected to not happen, required for TS') {
+    super(message)
+    this.name = 'UnexpectedTsError'
+  }
+}
+
+/**
+ * @category exception
+ */
 export class InvalidKeypairError extends AccountError {
   constructor (message: string) {
     super(message)
@@ -221,6 +280,9 @@ export class InvalidKeypairError extends AccountError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnavailableAccountError extends AccountError {
   constructor (address: string) {
     super(`Account for ${address} not available`)
@@ -228,7 +290,9 @@ export class UnavailableAccountError extends AccountError {
   }
 }
 
-/* errors originating from AENS operation */
+/**
+ * @category exception
+ */
 export class AensPointerContextError extends AensError {
   constructor (nameOrId: string, prefix: string) {
     super(`Name ${nameOrId} don't have pointers for ${prefix}`)
@@ -236,13 +300,19 @@ export class AensPointerContextError extends AensError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InsufficientNameFeeError extends AensError {
-  constructor (nameFee: number, minNameFee: number) {
-    super(`the provided fee ${nameFee} is not enough to execute the claim, required: ${minNameFee}`)
+  constructor (nameFee: BigNumber, minNameFee: BigNumber) {
+    super(`the provided fee ${nameFee.toString()} is not enough to execute the claim, required: ${minNameFee.toString()}`)
     this.name = 'InsufficientNameFeeError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class InvalidAensNameError extends AensError {
   constructor (message: string) {
     super(message)
@@ -250,14 +320,9 @@ export class InvalidAensNameError extends AensError {
   }
 }
 
-/* Aepp Errors */
-export class DuplicateCallbackError extends AeppError {
-  constructor () {
-    super('Callback Already exist')
-    this.name = 'DuplicateCallbackError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class InvalidRpcMessageError extends AeppError {
   constructor (message: string) {
     super(`Received invalid message: ${message}`)
@@ -265,13 +330,19 @@ export class InvalidRpcMessageError extends AeppError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class MissingCallbackError extends AeppError {
-  constructor (id: string) {
+  constructor (id: number) {
     super(`Can't find callback for this messageId ${id}`)
     this.name = 'MissingCallbackError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnAuthorizedAccountError extends AeppError {
   constructor (onAccount: string) {
     super(`You do not have access to account ${onAccount}`)
@@ -279,6 +350,9 @@ export class UnAuthorizedAccountError extends AeppError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnknownRpcClientError extends AeppError {
   constructor (id: string) {
     super(`RpcClient with id ${id} do not exist`)
@@ -286,6 +360,9 @@ export class UnknownRpcClientError extends AeppError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnsubscribedAccountError extends AeppError {
   constructor () {
     super('You are not subscribed for an account.')
@@ -293,7 +370,9 @@ export class UnsubscribedAccountError extends AeppError {
   }
 }
 
-/* Channel originated errors */
+/**
+ * @category exception
+ */
 export class ChannelCallError extends ChannelError {
   constructor (message: string) {
     super(message)
@@ -301,6 +380,9 @@ export class ChannelCallError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class ChannelConnectionError extends ChannelError {
   constructor (message: string) {
     super(message)
@@ -308,6 +390,9 @@ export class ChannelConnectionError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class ChannelPingTimedOutError extends ChannelError {
   constructor () {
     super('Server pong timed out')
@@ -315,6 +400,9 @@ export class ChannelPingTimedOutError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnexpectedChannelMessageError extends ChannelError {
   constructor (message: string) {
     super(message)
@@ -322,6 +410,9 @@ export class UnexpectedChannelMessageError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnknownChannelStateError extends ChannelError {
   constructor () {
     super('State Channels FSM entered unknown state')
@@ -329,8 +420,9 @@ export class UnknownChannelStateError extends ChannelError {
   }
 }
 
-/* compiler issued errors */
-/* errors from option validations */
+/**
+ * @category exception
+ */
 export class InvalidAuthDataError extends CompilerError {
   constructor (message: string) {
     super(message)
@@ -338,7 +430,9 @@ export class InvalidAuthDataError extends CompilerError {
   }
 }
 
-/* contract invocation errors */
+/**
+ * @category exception
+ */
 export class BytecodeMismatchError extends ContractError {
   constructor (source: string) {
     super(`Contract ${source} do not correspond to the bytecode deployed on the chain`)
@@ -346,6 +440,9 @@ export class BytecodeMismatchError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class DuplicateContractError extends ContractError {
   constructor () {
     super('Contract already deployed')
@@ -353,6 +450,9 @@ export class DuplicateContractError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InactiveContractError extends ContractError {
   constructor (contractAddress: string) {
     super(`Contract with address ${contractAddress} not active`)
@@ -360,6 +460,9 @@ export class InactiveContractError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InvalidMethodInvocationError extends ContractError {
   constructor (message: string) {
     super(message)
@@ -367,6 +470,9 @@ export class InvalidMethodInvocationError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class MissingContractAddressError extends ContractError {
   constructor (message: string) {
     super(message)
@@ -374,6 +480,9 @@ export class MissingContractAddressError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class MissingContractDefError extends ContractError {
   constructor () {
     super('Either ACI or source code is required')
@@ -381,6 +490,9 @@ export class MissingContractDefError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class MissingFunctionNameError extends ContractError {
   constructor () {
     super('Function name is required')
@@ -388,14 +500,22 @@ export class MissingFunctionNameError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class NodeInvocationError extends ContractError {
-  constructor (message?: string) {
-    message = message ?? ''
-    super(`Invocation failed${message === '' ? '' : `: "${message}"`}`)
+  transaction: string
+
+  constructor (message: string, transaction: string) {
+    super(`Invocation failed${message == null ? '' : `: "${message}"`}`)
     this.name = 'NodeInvocationError'
+    this.transaction = transaction
   }
 }
 
+/**
+ * @category exception
+ */
 export class NoSuchContractFunctionError extends ContractError {
   constructor (name: string) {
     super(`Function ${name} doesn't exist in contract`)
@@ -403,15 +523,21 @@ export class NoSuchContractFunctionError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class NotPayableFunctionError extends ContractError {
   constructor (amount: string, fn: string) {
     super(
       `You try to pay "${amount}" to function "${fn}" which is not payable. ` +
-      'Only payable function can accept tokens')
+      'Only payable function can accept coins')
     this.name = 'NotPayableFunctionError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class MissingEventDefinitionError extends ContractError {
   constructor (eventNameHash: string, eventAddress: string) {
     super(
@@ -422,8 +548,11 @@ export class MissingEventDefinitionError extends ContractError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class AmbiguousEventDefinitionError extends ContractError {
-  constructor (eventAddress: string, matchedEvents: [string, string][]) {
+  constructor (eventAddress: string, matchedEvents: Array<[string, string]>) {
     super(
       `Found multiple definitions of "${matchedEvents[0][1]}" event emitted by ${eventAddress}` +
       ` in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts` +
@@ -433,7 +562,9 @@ export class AmbiguousEventDefinitionError extends ContractError {
   }
 }
 
-/* cryptography errors */
+/**
+ * @category exception
+ */
 export class InvalidChecksumError extends CryptographyError {
   constructor () {
     super('Invalid checksum')
@@ -441,27 +572,19 @@ export class InvalidChecksumError extends CryptographyError {
   }
 }
 
-export class InvalidDerivationPathError extends CryptographyError {
-  constructor () {
-    super('Invalid path')
-    this.name = 'InvalidDerivationPathError'
-  }
-}
-
-export class InvalidKeyError extends CryptographyError {
-  constructor (message: string) {
-    super(message)
-    this.name = 'InvalidKeyError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class InvalidPasswordError extends CryptographyError {
-  constructor (message: string) {
-    super(message)
+  constructor () {
+    super('Invalid password or nonce')
     this.name = 'InvalidPasswordError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class MerkleTreeHashMismatchError extends CryptographyError {
   constructor () {
     super('Node hash is not equal to provided one')
@@ -469,6 +592,9 @@ export class MerkleTreeHashMismatchError extends CryptographyError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class MissingNodeInTreeError extends CryptographyError {
   constructor (message: string) {
     super(message)
@@ -476,20 +602,9 @@ export class MissingNodeInTreeError extends CryptographyError {
   }
 }
 
-export class UnsupportedAlgorithmError extends CryptographyError {
-  constructor (algo: string) {
-    super(algo + ' is not available')
-    this.name = 'UnsupportedAlgorithmError'
-  }
-}
-
-export class NotHardenedSegmentError extends CryptographyError {
-  constructor (message: string) {
-    super(message)
-    this.name = 'NotHardenedSegmentError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class UnknownNodeLengthError extends CryptographyError {
   constructor (nodeLength: number) {
     super(`Unknown node length: ${nodeLength}`)
@@ -497,6 +612,9 @@ export class UnknownNodeLengthError extends CryptographyError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnknownPathNibbleError extends CryptographyError {
   constructor (nibble: number) {
     super(`Unknown path nibble: ${nibble}`)
@@ -504,21 +622,9 @@ export class UnknownPathNibbleError extends CryptographyError {
   }
 }
 
-export class UnsupportedChildIndexError extends CryptographyError {
-  constructor (index: string) {
-    super(`Child index #${index} is not supported`)
-    this.name = 'UnsupportedChildIndexError'
-  }
-}
-
-/* Node errors */
-export class DisconnectedError extends NodeError {
-  constructor () {
-    super('Can not get node info. Node is not connected')
-    this.name = 'DisconnectedError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class DuplicateNodeError extends NodeError {
   constructor (name: string) {
     super(`Node with name ${name} already exist`)
@@ -526,6 +632,9 @@ export class DuplicateNodeError extends NodeError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class NodeNotFoundError extends NodeError {
   constructor (message: string) {
     super(message)
@@ -533,7 +642,9 @@ export class NodeNotFoundError extends NodeError {
   }
 }
 
-/* transaction related errors */
+/**
+ * @category exception
+ */
 export class DecodeError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -541,13 +652,9 @@ export class DecodeError extends TransactionError {
   }
 }
 
-export class EncodeError extends TransactionError {
-  constructor (message: string) {
-    super(message)
-    this.name = 'EncodeError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class PayloadLengthError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -555,6 +662,9 @@ export class PayloadLengthError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class DryRunError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -562,6 +672,9 @@ export class DryRunError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class IllegalBidFeeError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -569,6 +682,9 @@ export class IllegalBidFeeError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InvalidSignatureError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -576,13 +692,23 @@ export class InvalidSignatureError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class InvalidTxError extends TransactionError {
-  constructor (message: string) {
+  validation: ValidatorResult[]
+  transaction: EncodedData<'tx'>
+  constructor (message: string, validation: ValidatorResult[], transaction: EncodedData<'tx'>) {
     super(message)
     this.name = 'InvalidTxError'
+    this.validation = validation
+    this.transaction = transaction
   }
 }
 
+/**
+ * @category exception
+ */
 export class InvalidTxParamsError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -590,34 +716,29 @@ export class InvalidTxParamsError extends TransactionError {
   }
 }
 
-export class NoDefaultAensPointerError extends TransactionError {
-  constructor (prefix: string) {
-    super(`Default AENS pointer key is not defined for ${prefix} prefix`)
-    this.name = 'NoDefaultAensPointerError'
-  }
-}
-
-export class PrefixMismatchError extends TransactionError {
-  constructor (prefix: string, requiredPrefix: string) {
-    super(`Encoded string have a wrong type: ${prefix} (expected: ${requiredPrefix})`)
-    this.name = 'PrefixMismatchError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class PrefixNotFoundError extends TransactionError {
-  constructor (tag: string) {
+  constructor (tag: number) {
     super(`Prefix for id-tag ${tag} not found.`)
     this.name = 'PrefixNotFoundError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class SchemaNotFoundError extends TransactionError {
-  constructor (message: string) {
-    super(message)
+  constructor (schemaName: string, key: string, version: number) {
+    super(`Transaction ${schemaName} not implemented for ${key} version ${version}`)
     this.name = 'SchemaNotFoundError'
   }
 }
 
+/**
+ * @category exception
+ */
 export class TagNotFoundError extends TransactionError {
   constructor (prefix: string) {
     super(`Id tag for prefix ${prefix} not found.`)
@@ -625,6 +746,9 @@ export class TagNotFoundError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class TxNotInChainError extends TransactionError {
   constructor (txHash: string) {
     super(`Transaction ${txHash} is removed from chain`)
@@ -632,6 +756,9 @@ export class TxNotInChainError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnknownTxError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -639,6 +766,9 @@ export class UnknownTxError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnsupportedABIversionError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -646,6 +776,9 @@ export class UnsupportedABIversionError extends TransactionError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class UnsupportedVMversionError extends TransactionError {
   constructor (message: string) {
     super(message)
@@ -653,7 +786,9 @@ export class UnsupportedVMversionError extends TransactionError {
   }
 }
 
-/* Wallet Errors */
+/**
+ * @category exception
+ */
 export class AlreadyConnectedError extends WalletError {
   constructor (message: string) {
     super(message)
@@ -661,13 +796,9 @@ export class AlreadyConnectedError extends WalletError {
   }
 }
 
-export class MessageDirectionError extends WalletError {
-  constructor (message: string) {
-    super(message)
-    this.name = 'MessageDirectionError'
-  }
-}
-
+/**
+ * @category exception
+ */
 export class NoWalletConnectedError extends WalletError {
   constructor (message: string) {
     super(message)
@@ -675,6 +806,9 @@ export class NoWalletConnectedError extends WalletError {
   }
 }
 
+/**
+ * @category exception
+ */
 export class RpcConnectionError extends WalletError {
   constructor (message: string) {
     super(message)