feat: handle MethodNotFound errors in JsonRpcProvider

packages/near-api-js/src/providers/json-rpc-provider.ts

@@ -28,7 +28,7 @@ import { ConnectionInfo, fetchJson } from '../utils/web';
 import { TypedError, ErrorContext } from '../utils/errors';
 import { baseEncode } from 'borsh';
 import exponentialBackoff from '../utils/exponential-backoff';
-import { parseRpcError, getErrorTypeFromErrorMessage } from '../utils/rpc_errors';
+import { parseRpcError, getErrorTypeFromErrorMessage, ServerError, formatError } from '../utils/rpc_errors';
 import { SignedTransaction } from '../transaction';
 
 /** @hidden */
@@ -349,6 +349,11 @@ export class JsonRpcProvider extends Provider {
 
                         throw new TypedError(errorMessage, getErrorTypeFromErrorMessage(response.error.data, response.error.name));
                     }
+                } else if (typeof response.result?.error === 'string') {
+                    const errorType = getErrorTypeFromErrorMessage(response.result.error, '');
+                    if (errorType) {
+                        throw new ServerError(formatError(errorType, { method }), errorType);
+                    }
                 }
                 // Success when response.error is not exist
                 return response;

packages/near-api-js/src/utils/rpc_errors.ts

@@ -96,6 +96,8 @@ export function getErrorTypeFromErrorMessage(errorMessage, errorType) {
             return 'AccessKeyDoesNotExist';
         case /wasm execution failed with error: FunctionCallError\(CompilationError\(CodeDoesNotExist/.test(errorMessage):
             return 'CodeDoesNotExist';
+        case /wasm execution failed with error: FunctionCallError\(MethodResolveError\(MethodNotFound/.test(errorMessage):
+            return 'MethodNotFound';
         case /Transaction nonce \d+ must be larger than nonce of the used access key \d+/.test(errorMessage):
             return 'InvalidNonce';
         default:

packages/near-api-js/test/providers_errors.test.js

@@ -0,0 +1,70 @@
+const nearApi = require('../src/index');
+const testUtils  = require('./test-utils');
+let ERRORS_JSON = require('../src/res/error_messages.json');
+
+jest.setTimeout(20000);
+
+const withProvider = (fn) => {
+    const config = Object.assign(require('./config')(process.env.NODE_ENV || 'test'));
+    const provider = new nearApi.providers.JsonRpcProvider(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).toEqual(`[-32000] Server error: account ${accountName} does not exist while viewing`);
+    }
+}));