move to custom error types in rpc

Author: theforager

packages/types/src/errors.ts

@@ -6,7 +6,8 @@ export enum ErrorCode {
   PARSE_ERROR = "PARSE_ERROR",
   INVALID_RESPONSE = "INVALID_RESPONSE",
   SUBSCRIPTION_ERROR = "SUBSCRIPTION_ERROR",
-  PROTOCOL_ERROR = "PROTOCOL_ERROR"
+  PROTOCOL_ERROR = "PROTOCOL_ERROR",
+  ABCI_ERROR = "ABCI_ERROR"
 }
 
 export enum ErrorCategory {
@@ -62,4 +63,24 @@ export class SubscriptionError extends QueryClientError {
 export class ProtocolError extends QueryClientError {
   readonly code = ErrorCode.PROTOCOL_ERROR;
   readonly category = ErrorCategory.PROTOCOL;
+}
+
+/**
+ * Error thrown when an ABCI query returns a non-zero response code.
+ * This indicates the chain application rejected the query (e.g., simulation failure,
+ * invalid transaction, out of gas during execution).
+ */
+export class AbciError extends QueryClientError {
+  readonly code = ErrorCode.ABCI_ERROR;
+  readonly category = ErrorCategory.SERVER;
+
+  constructor(
+    message: string,
+    /** The ABCI response code (non-zero indicates error) */
+    public readonly abciCode: number,
+    /** The log message from the ABCI response */
+    public readonly log: string
+  ) {
+    super(message);
+  }
 }

packages/utils/src/rpc.spec.ts

@@ -1,4 +1,5 @@
 import { abciQuery } from './rpc';
+import { ProtocolError, AbciError } from '@interchainjs/types';
 
 // Mock fetch globally
 const mockFetch = jest.fn();
@@ -13,17 +14,18 @@ describe('abciQuery', () => {
     mockFetch.mockReset();
   });
 
-  it('should throw on JSON-RPC error', async () => {
+  it('should throw ProtocolError on JSON-RPC error', async () => {
     mockFetch.mockResolvedValue({
       json: () => Promise.resolve({
-        error: 'Internal error',
+        error: { code: -32600, message: 'Invalid Request' },
       }),
     });
 
-    await expect(abciQuery(endpoint, path, data)).rejects.toThrow('Request Error: Internal error');
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow(ProtocolError);
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow('JSON-RPC error');
   });
 
-  it('should throw on non-zero ABCI response code', async () => {
+  it('should throw AbciError on non-zero ABCI response code', async () => {
     mockFetch.mockResolvedValue({
       json: () => Promise.resolve({
         result: {
@@ -36,12 +38,19 @@ describe('abciQuery', () => {
       }),
     });
 
-    await expect(abciQuery(endpoint, path, data)).rejects.toThrow(
-      'ABCI Error (code 11): out of gas in location: ReadFlat; gasWanted: 0, gasUsed: 1000'
-    );
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow(AbciError);
+
+    try {
+      await abciQuery(endpoint, path, data);
+    } catch (e) {
+      expect(e).toBeInstanceOf(AbciError);
+      const abciError = e as AbciError;
+      expect(abciError.abciCode).toBe(11);
+      expect(abciError.log).toBe('out of gas in location: ReadFlat; gasWanted: 0, gasUsed: 1000');
+    }
   });
 
-  it('should throw with generic message when ABCI error has no log', async () => {
+  it('should throw AbciError with generic message when ABCI error has no log', async () => {
     mockFetch.mockResolvedValue({
       json: () => Promise.resolve({
         result: {
@@ -54,7 +63,15 @@ describe('abciQuery', () => {
       }),
     });
 
-    await expect(abciQuery(endpoint, path, data)).rejects.toThrow('ABCI Error (code 5): Unknown error');
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow(AbciError);
+
+    try {
+      await abciQuery(endpoint, path, data);
+    } catch (e) {
+      const abciError = e as AbciError;
+      expect(abciError.abciCode).toBe(5);
+      expect(abciError.log).toBe('Unknown error');
+    }
   });
 
   it('should return decoded value on success (code 0)', async () => {
@@ -75,4 +92,20 @@ describe('abciQuery', () => {
     const result = await abciQuery(endpoint, path, data);
     expect(result).toEqual(new Uint8Array([4, 5, 6]));
   });
+
+  it('should preserve instanceof Error for backward compatibility', async () => {
+    mockFetch.mockResolvedValue({
+      json: () => Promise.resolve({
+        result: {
+          response: {
+            code: 11,
+            log: 'test error',
+            value: '',
+          },
+        },
+      }),
+    });
+
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow(Error);
+  });
 });

packages/utils/src/rpc.ts

@@ -1,4 +1,4 @@
-import { HttpEndpoint, Rpc } from '@interchainjs/types';
+import { HttpEndpoint, Rpc, ProtocolError, AbciError, ParseError } from '@interchainjs/types';
 import { toHttpEndpoint } from './endpoint';
 import { fromBase64, toBase64, toHex } from './encoding';
 import { randomId } from './random';
@@ -48,20 +48,25 @@ export async function abciQuery(
   const resp = await fetch(endpoint.url, req);
   const json = await resp.json();
   if (json['error'] != void 0) {
-    throw new Error(`Request Error: ${json['error']}`);
+    throw new ProtocolError(`JSON-RPC error: ${JSON.stringify(json['error'])}`);
   }
   const response = json['result']['response'];
 
   // Check ABCI response code - non-zero indicates an error
   if (response['code'] !== 0) {
-    throw new Error(`ABCI Error (code ${response['code']}): ${response['log'] || 'Unknown error'}`);
+    const log = response['log'] || 'Unknown error';
+    throw new AbciError(
+      `ABCI query failed (code ${response['code']}): ${log}`,
+      response['code'],
+      log
+    );
   }
 
   try {
     const result = fromBase64(response['value']);
     return result;
   } catch (error) {
-    throw new Error(`Request Error: ${response['log'] || 'Failed to decode response'}`);
+    throw new ParseError(`Failed to decode ABCI response: ${response['log'] || 'invalid base64'}`);
   }
 }