Merge pull request #193 from theforager/simulation-errors

fix: propagate ABCI errors instead of swallowing them

Author: pyramation

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

@@ -0,0 +1,111 @@
+import { abciQuery } from './rpc';
+import { ProtocolError, AbciError } from '@interchainjs/types';
+
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+describe('abciQuery', () => {
+  const endpoint = { url: 'http://localhost:26657', headers: {} };
+  const path = '/cosmos.tx.v1beta1.Service/Simulate';
+  const data = new Uint8Array([1, 2, 3]);
+
+  beforeEach(() => {
+    mockFetch.mockReset();
+  });
+
+  it('should throw ProtocolError on JSON-RPC error', async () => {
+    mockFetch.mockResolvedValue({
+      json: () => Promise.resolve({
+        error: { code: -32600, message: 'Invalid Request' },
+      }),
+    });
+
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow(ProtocolError);
+    await expect(abciQuery(endpoint, path, data)).rejects.toThrow('JSON-RPC error');
+  });
+
+  it('should throw AbciError on non-zero ABCI response code', async () => {
+    mockFetch.mockResolvedValue({
+      json: () => Promise.resolve({
+        result: {
+          response: {
+            code: 11,
+            log: 'out of gas in location: ReadFlat; gasWanted: 0, gasUsed: 1000',
+            value: '',
+          },
+        },
+      }),
+    });
+
+    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 AbciError with generic message when ABCI error has no log', async () => {
+    mockFetch.mockResolvedValue({
+      json: () => Promise.resolve({
+        result: {
+          response: {
+            code: 5,
+            log: '',
+            value: '',
+          },
+        },
+      }),
+    });
+
+    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 () => {
+    // Base64 encoded [4, 5, 6]
+    const base64Value = 'BAUG';
+    mockFetch.mockResolvedValue({
+      json: () => Promise.resolve({
+        result: {
+          response: {
+            code: 0,
+            log: '',
+            value: base64Value,
+          },
+        },
+      }),
+    });
+
+    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,13 +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) {
+    const log = response['log'] || 'Unknown error';
+    throw new AbciError(
+      `ABCI query failed (code ${response['code']}): ${log}`,
+      response['code'],
+      log
+    );
+  }
+
   try {
-    const result = fromBase64(json['result']['response']['value']);
+    const result = fromBase64(response['value']);
     return result;
   } catch (error) {
-    throw new Error(`Request Error: ${json['result']['response']['log']}`);
+    throw new ParseError(`Failed to decode ABCI response: ${response['log'] || 'invalid base64'}`);
   }
 }