Display user-friendly messages for JSON RPC errors

.changeset/red-mice-argue.md

@@ -0,0 +1,11 @@
+---
+"@near-js/providers": patch
+"@near-js/utils": patch
+---
+
+Display user-friendly messages for JSON RPC errors:
+
+- MethodNotFound
+- CodeDoesNotExist
+- AccessKeyDoesNotExist
+- AccountDoesNotExist

packages/accounts/test/providers_errors.test.js

@@ -0,0 +1,114 @@
+const { JsonRpcProvider } = require('@near-js/providers');
+const testUtils = require('./test-utils');
+let ERRORS_JSON = require('../../utils/lib/errors/error_messages.json');
+const { KeyPair } = require('@near-js/crypto');
+
+jest.setTimeout(30000);
+
+const withProvider = (fn) => {
+    const config = Object.assign(
+        require('./config')(process.env.NODE_ENV || 'test')
+    );
+    const provider = new JsonRpcProvider({ url: config.nodeUrl });
+    return () => fn(provider);
+};
+
+test(
+    'JSON RPC Error: MethodNotFound',
+    withProvider(async (provider) => {
+        const near = await testUtils.setUpTestConnection();
+        const account = await testUtils.createAccount(near);
+        const contract = await testUtils.deployContract(
+            account,
+            testUtils.generateUniqueString('test')
+        );
+
+        await contract.setValue({ args: { value: 'hello' } });
+
+        try {
+            const response = await provider.query({
+                request_type: 'call_function',
+                finality: 'final',
+                account_id: contract.contractId,
+                method_name: 'methodNameThatDoesNotExist',
+                args_base64: '',
+            });
+            expect(response).toBeUndefined();
+        } catch (e) {
+            const errorType = 'MethodNotFound';
+            expect(e.type).toEqual(errorType);
+            expect(e.message).toEqual(ERRORS_JSON[errorType]);
+        }
+    })
+);
+
+test(
+    'JSON RPC Error: CodeDoesNotExist',
+    withProvider(async (provider) => {
+        try {
+            const response = await provider.query({
+                request_type: 'call_function',
+                finality: 'final',
+                account_id: 'test.near',
+                method_name: 'methodNameThatDoesNotExistOnContractNotDeployed',
+                args_base64: '',
+            });
+            expect(response).toBeUndefined();
+        } catch (e) {
+            const errorType = 'CodeDoesNotExist';
+            expect(e.type).toEqual(errorType);
+            expect(e.message.split(' ').slice(0, 5)).toEqual(
+                ERRORS_JSON[errorType].split(' ').slice(0, 5)
+            );
+        }
+    })
+);
+
+test(
+    'JSON RPC Error: AccountDoesNotExist',
+    withProvider(async (provider) => {
+        const accountName = 'abc.near';
+        try {
+            const response = await provider.query({
+                request_type: 'call_function',
+                finality: 'final',
+                account_id: accountName,
+                method_name: 'methodNameThatDoesNotExistOnContractNotDeployed',
+                args_base64: '',
+            });
+            expect(response).toBeUndefined();
+        } catch (e) {
+            const errorType = 'AccountDoesNotExist';
+            expect(e.type).toEqual(errorType);
+            expect(e.message.split(' ').slice(0, 5)).toEqual(
+                ERRORS_JSON[errorType].split(' ').slice(0, 5)
+            );
+        }
+    })
+);
+
+test(
+    'JSON RPC Error: AccessKeyDoesNotExist',
+    withProvider(async (provider) => {
+        const near = await testUtils.setUpTestConnection();
+        const { accountId } = await testUtils.createAccount(near);
+
+        try {
+            const response = await provider.query({
+                request_type: 'view_access_key',
+                finality: 'final',
+                account_id: accountId,
+                public_key: KeyPair.fromRandom('ed25519')
+                    .getPublicKey()
+                    .toString(),
+            });
+            expect(response).toBeUndefined();
+        } catch (e) {
+            const errorType = 'AccessKeyDoesNotExist';
+            expect(e.type).toEqual(errorType);
+            expect(e.message.split(' ').slice(0, 5)).toEqual(
+                ERRORS_JSON[errorType].split(' ').slice(0, 5)
+            );
+        }
+    })
+);

packages/providers/src/json-rpc-provider.ts

@@ -7,9 +7,11 @@
  */
 import {
     baseEncode,
+    formatError,
     getErrorTypeFromErrorMessage,
     Logger,
     parseRpcError,
+    ServerError,
 } from '@near-js/utils';
 import {
     AccessKeyWithPublicKey,
@@ -366,7 +368,17 @@ export class JsonRpcProvider extends Provider {
                             throw new TypedError(errorMessage, 'TimeoutError');
                         }
 
-                        throw new TypedError(errorMessage, getErrorTypeFromErrorMessage(response.error.data, response.error.name));
+                        const errorType = getErrorTypeFromErrorMessage(response.error.data, '');
+                        if (errorType) {
+                            throw new TypedError(formatError(errorType, params), errorType);
+                        }
+                        throw new TypedError(errorMessage, response.error.name);
+                    }
+                } else if (typeof response.result?.error === 'string') {
+                    const errorType = getErrorTypeFromErrorMessage(response.result.error, '');
+
+                    if (errorType) {
+                        throw new ServerError(formatError(errorType, params), errorType);
                     }
                 }
                 // Success when response.error is not exist

packages/utils/fetch_error_schema.js

@@ -2,8 +2,8 @@ const https = require('https');
 const fs = require('fs');
 
 const ERROR_SCHEMA_URL =
-    'https://raw.githubusercontent.com/nearprotocol/nearcore/4c1149974ccf899dbcb2253a3e27cbab86dc47be/chain/jsonrpc/res/rpc_errors_schema.json';
-const TARGET_SCHEMA_FILE_PATH = `${process.argv[2] ||  process.cwd()}/src/errors/rpc_error_schema.json'`;
+    'https://raw.githubusercontent.com/near/nearcore/master/chain/jsonrpc/res/rpc_errors_schema.json';
+const TARGET_SCHEMA_FILE_PATH = `${process.argv[2] ||  process.cwd()}/src/errors/rpc_error_schema.json`;
 
 https
     .get(ERROR_SCHEMA_URL, resp => {

packages/utils/src/errors/error_messages.json

@@ -56,6 +56,7 @@
     "AccountAlreadyExists": "Can't create a new account {{account_id}}, because it already exists",
     "InvalidChain": "Transaction parent block hash doesn't belong to the current chain",
     "AccountDoesNotExist": "Can't complete the action because account {{account_id}} doesn't exist",
+    "AccessKeyDoesNotExist": "Can't complete the action because access key {{public_key}} doesn't exist",
     "MethodNameMismatch": "Transaction method name {{method_name}} isn't allowed by the access key",
     "DeleteAccountHasRent": "Account {{account_id}} can't be deleted. It has {{#formatNear}}{{balance}}{{/formatNear}}, which is enough to cover the rent",
     "DeleteAccountHasEnoughBalance": "Account {{account_id}} can't be deleted. It has {{#formatNear}}{{balance}}{{/formatNear}}, which is enough to cover it's storage",