Merge error files

Author: danielailie

.vscode/settings.json

@@ -10,4 +10,5 @@
     "editor.codeActionsOnSave": {
         "source.organizeImports": "explicit"
       },
+    "prettier.printWidth": 120
 }

src/errors.ts

@@ -384,3 +384,67 @@ export class ErrSmartContractQuery extends Err {
         this.returnCode = returnCode;
     }
 }
+
+/**
+ * Signals a wrong mnemonic format.
+ */
+export class ErrWrongMnemonic extends Err {
+    public constructor() {
+        super("Wrong mnemonic format");
+    }
+}
+
+/**
+ * Signals a bad mnemonic entropy.
+ */
+export class ErrBadMnemonicEntropy extends Err {
+    public constructor(inner: Error) {
+        super("Bad mnemonic entropy", inner);
+    }
+}
+
+/**
+ * Signals a bad PEM file.
+ */
+export class ErrBadPEM extends Err {
+    public constructor(message?: string) {
+        super(message ? `Bad PEM: ${message}` : `Bad PEM`);
+    }
+}
+
+/**
+ * Signals an error related to signing a message (a transaction).
+ */
+export class ErrSignerCannotSign extends Err {
+    public constructor(inner: Error) {
+        super(`Cannot sign`, inner);
+    }
+}
+
+/**
+ * Signals a bad address.
+ */
+export class ErrBadAddress extends Err {
+    public constructor(value: string, inner?: Error) {
+        super(`Bad address: ${value}`, inner);
+    }
+}
+
+/**
+ * Signals an error that happened during a request against the Network.
+ */
+export class ErrNetworkProvider extends Err {
+    public constructor(url: string, error: string, inner?: Error) {
+        let message = `Request error on url [${url}]: [${error}]`;
+        super(message, inner);
+    }
+}
+
+/**
+ * Signals a generic error in the context of querying Smart Contracts.
+ */
+export class ErrContractQuery extends Err {
+    public constructor(originalError: Error) {
+        super(originalError.message.replace("executeQuery:", ""));
+    }
+}

src/networkProviders/apiNetworkProvider.ts

@@ -1,10 +1,10 @@
 import axios from "axios";
+import { ErrContractQuery, ErrNetworkProvider } from "../errors";
 import { AccountOnNetwork, GuardianData } from "./accounts";
 import { defaultAxiosConfig, defaultPagination } from "./config";
 import { BaseUserAgent } from "./constants";
 import { ContractQueryRequest } from "./contractQueryRequest";
 import { ContractQueryResponse } from "./contractQueryResponse";
-import { ErrContractQuery, ErrNetworkProvider } from "./errors";
 import { IAddress, IContractQuery, INetworkProvider, IPagination, ITransaction, ITransactionNext } from "./interface";
 import { NetworkConfig } from "./networkConfig";
 import { NetworkGeneralStatistics } from "./networkGeneralStatistics";
@@ -25,7 +25,7 @@ export class ApiNetworkProvider implements INetworkProvider {
     private url: string;
     private config: NetworkProviderConfig;
     private backingProxyNetworkProvider;
-    private userAgentPrefix = `${BaseUserAgent}/api`
+    private userAgentPrefix = `${BaseUserAgent}/api`;
 
     constructor(url: string, config?: NetworkProviderConfig) {
         this.url = url;
@@ -71,37 +71,50 @@ export class ApiNetworkProvider implements INetworkProvider {
         return await this.backingProxyNetworkProvider.getGuardianData(address);
     }
 
-    async getFungibleTokensOfAccount(address: IAddress, pagination?: IPagination): Promise<FungibleTokenOfAccountOnNetwork[]> {
+    async getFungibleTokensOfAccount(
+        address: IAddress,
+        pagination?: IPagination,
+    ): Promise<FungibleTokenOfAccountOnNetwork[]> {
         pagination = pagination || defaultPagination;
 
         let url = `accounts/${address.bech32()}/tokens?${this.buildPaginationParams(pagination)}`;
         let response: any[] = await this.doGetGeneric(url);
-        let tokens = response.map(item => FungibleTokenOfAccountOnNetwork.fromHttpResponse(item));
+        let tokens = response.map((item) => FungibleTokenOfAccountOnNetwork.fromHttpResponse(item));
 
         // TODO: Fix sorting
         tokens.sort((a, b) => a.identifier.localeCompare(b.identifier));
         return tokens;
     }
 
-    async getNonFungibleTokensOfAccount(address: IAddress, pagination?: IPagination): Promise<NonFungibleTokenOfAccountOnNetwork[]> {
+    async getNonFungibleTokensOfAccount(
+        address: IAddress,
+        pagination?: IPagination,
+    ): Promise<NonFungibleTokenOfAccountOnNetwork[]> {
         pagination = pagination || defaultPagination;
 
         let url = `accounts/${address.bech32()}/nfts?${this.buildPaginationParams(pagination)}`;
         let response: any[] = await this.doGetGeneric(url);
-        let tokens = response.map(item => NonFungibleTokenOfAccountOnNetwork.fromApiHttpResponse(item));
+        let tokens = response.map((item) => NonFungibleTokenOfAccountOnNetwork.fromApiHttpResponse(item));
 
         // TODO: Fix sorting
         tokens.sort((a, b) => a.identifier.localeCompare(b.identifier));
         return tokens;
     }
 
-    async getFungibleTokenOfAccount(address: IAddress, tokenIdentifier: string): Promise<FungibleTokenOfAccountOnNetwork> {
+    async getFungibleTokenOfAccount(
+        address: IAddress,
+        tokenIdentifier: string,
+    ): Promise<FungibleTokenOfAccountOnNetwork> {
         let response = await this.doGetGeneric(`accounts/${address.bech32()}/tokens/${tokenIdentifier}`);
         let tokenData = FungibleTokenOfAccountOnNetwork.fromHttpResponse(response);
         return tokenData;
     }
 
-    async getNonFungibleTokenOfAccount(address: IAddress, collection: string, nonce: number): Promise<NonFungibleTokenOfAccountOnNetwork> {
+    async getNonFungibleTokenOfAccount(
+        address: IAddress,
+        collection: string,
+        nonce: number,
+    ): Promise<NonFungibleTokenOfAccountOnNetwork> {
         let nonceAsHex = new Nonce(nonce).hex();
         let response = await this.doGetGeneric(`accounts/${address.bech32()}/nfts/${collection}-${nonceAsHex}`);
         let tokenData = NonFungibleTokenOfAccountOnNetwork.fromApiHttpResponse(response);
@@ -116,7 +129,7 @@ export class ApiNetworkProvider implements INetworkProvider {
 
         let response: any[] = await this.doGetGeneric(url);
 
-        return response.map(item => PairOnNetwork.fromApiHttpResponse(item));
+        return response.map((item) => PairOnNetwork.fromApiHttpResponse(item));
     }
 
     async getTransaction(txHash: string): Promise<TransactionOnNetwork> {

src/networkProviders/errors.ts

@@ -5,14 +5,14 @@ export { AccountOnNetwork } from "./accounts";
 export { ContractQueryResponse } from "./contractQueryResponse";
 export { ContractResultItem, ContractResults } from "./contractResults";
 export {
-    TransactionEvent as TransactionEventOnNetwork,
     TransactionEventData,
+    TransactionEvent as TransactionEventOnNetwork,
     TransactionEventTopic,
 } from "./transactionEvents";
 export { TransactionLogs as TransactionLogsOnNetwork } from "./transactionLogs";
 export { TransactionReceipt } from "./transactionReceipt";
-export { TransactionStatus } from "./transactionStatus";
 export { TransactionOnNetwork } from "./transactions";
+export { TransactionStatus } from "./transactionStatus";
 
 export { DefinitionOfFungibleTokenOnNetwork, DefinitionOfTokenCollectionOnNetwork } from "./tokenDefinitions";
 export { FungibleTokenOfAccountOnNetwork, NonFungibleTokenOfAccountOnNetwork } from "./tokens";

src/networkProviders/index.ts

@@ -1,27 +1,27 @@
 import axios from "axios";
+import { ErrContractQuery, ErrNetworkProvider } from "../errors";
 import { AccountOnNetwork, GuardianData } from "./accounts";
 import { defaultAxiosConfig } from "./config";
-import { EsdtContractAddress, BaseUserAgent } from "./constants";
+import { BaseUserAgent, EsdtContractAddress } from "./constants";
 import { ContractQueryRequest } from "./contractQueryRequest";
 import { ContractQueryResponse } from "./contractQueryResponse";
-import { ErrContractQuery, ErrNetworkProvider } from "./errors";
 import { IAddress, IContractQuery, INetworkProvider, IPagination, ITransaction, ITransactionNext } from "./interface";
 import { NetworkConfig } from "./networkConfig";
 import { NetworkGeneralStatistics } from "./networkGeneralStatistics";
+import { NetworkProviderConfig } from "./networkProviderConfig";
 import { NetworkStake } from "./networkStake";
 import { NetworkStatus } from "./networkStatus";
 import { DefinitionOfFungibleTokenOnNetwork, DefinitionOfTokenCollectionOnNetwork } from "./tokenDefinitions";
 import { FungibleTokenOfAccountOnNetwork, NonFungibleTokenOfAccountOnNetwork } from "./tokens";
 import { TransactionOnNetwork, prepareTransactionForBroadcasting } from "./transactions";
 import { TransactionStatus } from "./transactionStatus";
 import { extendUserAgent } from "./userAgent";
-import { NetworkProviderConfig } from "./networkProviderConfig";
 
 // TODO: Find & remove duplicate code between "ProxyNetworkProvider" and "ApiNetworkProvider".
 export class ProxyNetworkProvider implements INetworkProvider {
     private url: string;
     private config: NetworkProviderConfig;
-    private userAgentPrefix = `${BaseUserAgent}/proxy`
+    private userAgentPrefix = `${BaseUserAgent}/proxy`;
 
     constructor(url: string, config?: NetworkProviderConfig) {
         this.url = url;
@@ -65,40 +65,57 @@ export class ProxyNetworkProvider implements INetworkProvider {
         return accountGuardian;
     }
 
-    async getFungibleTokensOfAccount(address: IAddress, _pagination?: IPagination): Promise<FungibleTokenOfAccountOnNetwork[]> {
+    async getFungibleTokensOfAccount(
+        address: IAddress,
+        _pagination?: IPagination,
+    ): Promise<FungibleTokenOfAccountOnNetwork[]> {
         let url = `address/${address.bech32()}/esdt`;
         let response = await this.doGetGeneric(url);
         let responseItems: any[] = Object.values(response.esdts);
         // Skip NFTs / SFTs.
-        let responseItemsFiltered = responseItems.filter(item => !item.nonce);
-        let tokens = responseItemsFiltered.map(item => FungibleTokenOfAccountOnNetwork.fromHttpResponse(item));
+        let responseItemsFiltered = responseItems.filter((item) => !item.nonce);
+        let tokens = responseItemsFiltered.map((item) => FungibleTokenOfAccountOnNetwork.fromHttpResponse(item));
 
         // TODO: Fix sorting
         tokens.sort((a, b) => a.identifier.localeCompare(b.identifier));
         return tokens;
     }
 
-    async getNonFungibleTokensOfAccount(address: IAddress, _pagination?: IPagination): Promise<NonFungibleTokenOfAccountOnNetwork[]> {
+    async getNonFungibleTokensOfAccount(
+        address: IAddress,
+        _pagination?: IPagination,
+    ): Promise<NonFungibleTokenOfAccountOnNetwork[]> {
         let url = `address/${address.bech32()}/esdt`;
         let response = await this.doGetGeneric(url);
         let responseItems: any[] = Object.values(response.esdts);
         // Skip fungible tokens.
-        let responseItemsFiltered = responseItems.filter(item => item.nonce >= 0);
-        let tokens = responseItemsFiltered.map(item => NonFungibleTokenOfAccountOnNetwork.fromProxyHttpResponse(item));
+        let responseItemsFiltered = responseItems.filter((item) => item.nonce >= 0);
+        let tokens = responseItemsFiltered.map((item) =>
+            NonFungibleTokenOfAccountOnNetwork.fromProxyHttpResponse(item),
+        );
 
         // TODO: Fix sorting
         tokens.sort((a, b) => a.identifier.localeCompare(b.identifier));
         return tokens;
     }
 
-    async getFungibleTokenOfAccount(address: IAddress, tokenIdentifier: string): Promise<FungibleTokenOfAccountOnNetwork> {
+    async getFungibleTokenOfAccount(
+        address: IAddress,
+        tokenIdentifier: string,
+    ): Promise<FungibleTokenOfAccountOnNetwork> {
         let response = await this.doGetGeneric(`address/${address.bech32()}/esdt/${tokenIdentifier}`);
         let tokenData = FungibleTokenOfAccountOnNetwork.fromHttpResponse(response.tokenData);
         return tokenData;
     }
 
-    async getNonFungibleTokenOfAccount(address: IAddress, collection: string, nonce: number): Promise<NonFungibleTokenOfAccountOnNetwork> {
-        let response = await this.doGetGeneric(`address/${address.bech32()}/nft/${collection}/nonce/${nonce.valueOf()}`);
+    async getNonFungibleTokenOfAccount(
+        address: IAddress,
+        collection: string,
+        nonce: number,
+    ): Promise<NonFungibleTokenOfAccountOnNetwork> {
+        let response = await this.doGetGeneric(
+            `address/${address.bech32()}/nft/${collection}/nonce/${nonce.valueOf()}`,
+        );
         let tokenData = NonFungibleTokenOfAccountOnNetwork.fromProxyHttpResponseByNonce(response.tokenData);
         return tokenData;
     }
@@ -133,7 +150,7 @@ export class ProxyNetworkProvider implements INetworkProvider {
     }
 
     async sendTransactions(txs: (ITransaction | ITransactionNext)[]): Promise<string[]> {
-        const data = (txs).map((tx) => prepareTransactionForBroadcasting(tx));
+        const data = txs.map((tx) => prepareTransactionForBroadcasting(tx));
 
         const response = await this.doPostGeneric("transaction/send-multiple", data);
         const hashes = Array(txs.length).fill(null);
@@ -163,7 +180,10 @@ export class ProxyNetworkProvider implements INetworkProvider {
 
     async getDefinitionOfFungibleToken(tokenIdentifier: string): Promise<DefinitionOfFungibleTokenOnNetwork> {
         let properties = await this.getTokenProperties(tokenIdentifier);
-        let definition = DefinitionOfFungibleTokenOnNetwork.fromResponseOfGetTokenProperties(tokenIdentifier, properties);
+        let definition = DefinitionOfFungibleTokenOnNetwork.fromResponseOfGetTokenProperties(
+            tokenIdentifier,
+            properties,
+        );
         return definition;
     }
 
@@ -173,7 +193,7 @@ export class ProxyNetworkProvider implements INetworkProvider {
         let queryResponse = await this.queryContract({
             address: EsdtContractAddress,
             func: "getTokenProperties",
-            getEncodedArguments: () => [encodedIdentifier]
+            getEncodedArguments: () => [encodedIdentifier],
         });
 
         let properties = queryResponse.getReturnDataParts();

src/networkProviders/proxyNetworkProvider.ts

@@ -1,4 +1,4 @@
-import { ErrUnexpectedCondition } from "./errors";
+import { ErrUnexpectedCondition } from "./../errors";
 import { IAddress } from "./interface";
 import { Address } from "./primitives";
 import { TransactionEvent } from "./transactionEvents";
@@ -15,11 +15,14 @@ export class TransactionLogs {
         let result = new TransactionLogs();
         result.address = new Address(logs.address);
         result.events = (logs.events || []).map((event: any) => TransactionEvent.fromHttpResponse(event));
-        
+
         return result;
     }
 
-    findSingleOrNoneEvent(identifier: string, predicate?: (event: TransactionEvent) => boolean): TransactionEvent | undefined {
+    findSingleOrNoneEvent(
+        identifier: string,
+        predicate?: (event: TransactionEvent) => boolean,
+    ): TransactionEvent | undefined {
         let events = this.findEvents(identifier, predicate);
 
         if (events.length > 1) {
@@ -29,15 +32,18 @@ export class TransactionLogs {
         return events[0];
     }
 
-    findFirstOrNoneEvent(identifier: string, predicate?: (event: TransactionEvent) => boolean): TransactionEvent | undefined {
+    findFirstOrNoneEvent(
+        identifier: string,
+        predicate?: (event: TransactionEvent) => boolean,
+    ): TransactionEvent | undefined {
         return this.findEvents(identifier, predicate)[0];
     }
 
     findEvents(identifier: string, predicate?: (event: TransactionEvent) => boolean): TransactionEvent[] {
-        let events = this.events.filter(event => event.identifier == identifier);
+        let events = this.events.filter((event) => event.identifier == identifier);
 
         if (predicate) {
-            events = events.filter(event => predicate(event));
+            events = events.filter((event) => predicate(event));
         }
 
         return events;

src/networkProviders/transactionLogs.ts

@@ -1,4 +1,4 @@
-import { ErrInvariantFailed } from "./errors";
+import { ErrInvariantFailed } from "../errors";
 
 export function guardLength(withLength: { length?: number }, expectedLength: number) {
     let actualLength = withLength.length || 0;