chore: fix error msg mapping

Author: ivan-angjelkoski

packages/exceptions/src/exceptions/base.ts

@@ -102,17 +102,20 @@ export abstract class ConcreteException extends Error implements Exception {
   }
 
   public parseContext(errorContext?: ErrorContext) {
-    const { contextModule, type, code, context } = errorContext || {
-      contextModule: 'Unknown',
-      context: 'Unknown',
-      code: UnspecifiedErrorCode,
-      type: ErrorType.Unspecified,
-    }
+    const { contextModule, type, code, context, contextCode } =
+      errorContext || {
+        contextModule: 'Unknown',
+        context: 'Unknown',
+        code: UnspecifiedErrorCode,
+        type: ErrorType.Unspecified,
+        contextCode: undefined,
+      }
 
     this.context = context
     this.contextModule = contextModule
     this.type = type || ErrorType.Unspecified
     this.code = code || UnspecifiedErrorCode
+    this.contextCode = contextCode
   }
 
   public setType(type: ErrorType) {

packages/exceptions/src/exceptions/messages.ts

@@ -288,6 +288,9 @@ const exchangeErrorMap = {
     'Client order id already exists',
   [ChainExchangeModuleErrorCode.ErrInvalidCid]:
     'Client order id is invalid. Max length is 36 chars',
+  [ChainExchangeModuleErrorCode.ErrInvalidClosingDirection]:
+    'Invalid closing direction',
+  [ChainExchangeModuleErrorCode.ErrInvalidNotional]: 'Invalid notional',
 }
 
 const insuranceErrorMap = {
@@ -1445,6 +1448,12 @@ export const chainErrorMessagesMap: Record<
     module: TransactionChainErrorModule.Exchange,
   },
 
+  'invalid notional': {
+    message: 'Invalid notional',
+    code: ChainExchangeModuleErrorCode.ErrInvalidNotional,
+    module: TransactionChainErrorModule.Exchange,
+  },
+
   'empty validator address': {
     message: 'empty validator address',
     code: ChainStakingErrorCodes.ErrEmptyValidatorAddr,

packages/exceptions/src/exceptions/types/codes.ts

@@ -332,6 +332,10 @@ export const ChainExchangeModuleErrorCode = {
   ErrClientOrderIdAlreadyExists: 97,
   // client order id is invalid. Max length is 36 chars
   ErrInvalidCid: 98,
+  // invalid closing direction
+  ErrInvalidClosingDirection: 99,
+  // invalid notional
+  ErrInvalidNotional: 100,
 } as const
 
 export type ChainExchangeModuleErrorCode =

packages/exceptions/src/exceptions/utils/maps.ts

@@ -130,7 +130,8 @@ export const mapFailedTransactionMessage = (
     return reason
   }
 
-  const ABCICode = context && context.code ? context.code : getABCICode(message)
+  const ABCICode =
+    context && context.contextCode ? context.contextCode : getABCICode(message)
   const contextModule = context?.contextModule || getContextModule(message)
   const reason = getReason(message)
 

packages/sdk-ts/src/client/base/BaseGrpcConsumer.ts

@@ -1,6 +1,7 @@
 import { RpcError } from '@protobuf-ts/runtime-rpc'
 import {
   UnspecifiedErrorCode,
+  TransactionException,
   grpcErrorCodeToErrorCode,
   GrpcUnaryRequestException,
 } from '@injectivelabs/exceptions'
@@ -81,19 +82,81 @@ export default class BaseGrpcConsumer {
   }
 
   /**
-   * Centralized error handler for gRPC calls
-   * Converts RpcError to GrpcUnaryRequestException with proper error codes
+   * Extracts the ABCI error code from a gRPC error message.
+   * Chain errors contain patterns like: {key:"ABCICode" value:"100"}
+   */
+  private getABCICodeFromMessage(message: string): number | undefined {
+    const ABCICodePattern = /{key:"ABCICode"[ \t]+value:"(.*?)"}/g
+    const ABCICode = ABCICodePattern.exec(message)
+
+    if (!ABCICode || ABCICode.length < 2) {
+      return undefined
+    }
+
+    return Number(ABCICode[1])
+  }
+
+  /**
+   * Extracts the codespace/module from a gRPC error message.
+   * Chain errors contain patterns like: {key:"Codespace" value:"exchange"}
+   */
+  private getCodespaceFromMessage(message: string): string | undefined {
+    const codespacePattern = /{key:"Codespace"[ \t]+value:"(.*?)"}/g
+    const codespace = codespacePattern.exec(message)
+
+    if (!codespace || codespace.length < 2) {
+      return undefined
+    }
+
+    return codespace[1]
+  }
+
+  /**
+   * Centralized error handler for gRPC calls.
+   * When the error contains chain error details (ABCI code and codespace),
+   * throws a TransactionException which will map the error to a user-friendly message.
+   * Otherwise throws a GrpcUnaryRequestException for generic gRPC errors.
    */
   protected handleGrpcError(e: unknown, context: string): never {
     if (e instanceof RpcError) {
-      throw new GrpcUnaryRequestException(new Error(e.message), {
+      const message = e.message
+      const abciCode = this.getABCICodeFromMessage(message)
+      const codespace = this.getCodespaceFromMessage(message)
+
+      // If we have chain error details, throw TransactionException
+      // which will map the error to a user-friendly message
+      if (abciCode && codespace) {
+        throw new TransactionException(new Error(message), {
+          code: grpcErrorCodeToErrorCode(Number(e.code)),
+          context,
+          contextModule: codespace,
+          contextCode: abciCode,
+        })
+      }
+
+      throw new GrpcUnaryRequestException(new Error(message), {
         code: grpcErrorCodeToErrorCode(Number(e.code)),
         context,
         contextModule: this.module,
       })
     }
 
-    throw new GrpcUnaryRequestException(e as Error, {
+    const error = e as Error
+    const message = error?.message || ''
+    const abciCode = this.getABCICodeFromMessage(message)
+    const codespace = this.getCodespaceFromMessage(message)
+
+    // If we have chain error details, throw TransactionException
+    if (abciCode && codespace) {
+      throw new TransactionException(error, {
+        code: UnspecifiedErrorCode,
+        context,
+        contextModule: codespace,
+        contextCode: abciCode,
+      })
+    }
+
+    throw new GrpcUnaryRequestException(error, {
       code: UnspecifiedErrorCode,
       context,
       contextModule: this.module,