removed encodeParams and decodeResp

Author: Zetazzz

networks/cosmos/src/adapters/base.ts

@@ -230,8 +230,6 @@ export interface IProtocolAdapter {
   getVersion(): ProtocolVersion;
   getSupportedMethods(): Set<RpcMethod>;
   getCapabilities(): ProtocolCapabilities;
-  encodeParams(method: RpcMethod, params: any): any;
-  decodeResponse(method: RpcMethod, response: any): any;
   encodeBytes(data: string): Uint8Array;
   decodeBytes(data: Uint8Array): string;
 }
@@ -357,179 +355,6 @@ export abstract class BaseAdapter implements RequestEncoder, ResponseDecoder, IC
     return this.version;
   }
 
-  encodeParams(method: RpcMethod, params: any): any {
-    // Convert camelCase to snake_case for Tendermint/CometBFT
-    if (!params) return {};
-
-    // Special handling for ABCI query using codec
-    if (method === RpcMethod.ABCI_QUERY) {
-      const encoded = this.encodeAbciQuery(params as AbciQueryParams);
-      // Convert to snake_case for RPC
-      return {
-        path: encoded.path,
-        data: encoded.data,
-        height: encoded.height,
-        prove: encoded.prove
-      };
-    }
-
-    // Special handling for commit using codec
-    if (method === RpcMethod.COMMIT) {
-      const encoded = this.encodeCommit(params as CommitParams);
-      return encoded;
-    }
-
-    // Special handling for block_results using codec
-    if (method === RpcMethod.BLOCK_RESULTS) {
-      const encoded = this.encodeBlockResults(params as BlockResultsParams);
-      return encoded;
-    }
-
-
-
-    // Convert height to string for block-related methods
-    if ((method === RpcMethod.BLOCK) &&
-        params.height !== undefined && typeof params.height === "number") {
-      params = { ...params, height: params.height.toString() };
-    }
-
-    // Convert height to string for validator and consensus methods
-    if ((method === RpcMethod.VALIDATORS || method === RpcMethod.CONSENSUS_PARAMS) &&
-        params.height !== undefined && typeof params.height === "number") {
-      params = { ...params, height: params.height.toString() };
-    }
-
-
-
-    // Special handling for genesis (no parameters)
-    if (method === RpcMethod.GENESIS) {
-      return undefined;
-    }
-
-
-
-
-
-    // Special handling for unconfirmed_txs using codec
-    if (method === RpcMethod.UNCONFIRMED_TXS) {
-      const encoded = this.encodeUnconfirmedTxs(params as UnconfirmedTxsParams);
-      return encoded;
-    }
-
-    // Special handling for validators using codec
-    if (method === RpcMethod.VALIDATORS) {
-      const encoded = this.encodeValidators(params as ValidatorsParams);
-      return encoded;
-    }
-
-    // Special handling for tx using codec
-    if (method === RpcMethod.TX) {
-      const encoded = this.encodeTx(params as TxParams);
-      return encoded;
-    }
-
-    // Special handling for tx_search using codec
-    if (method === RpcMethod.TX_SEARCH) {
-      const encoded = this.encodeTxSearch(params as TxSearchParams);
-      return encoded;
-    }
-
-
-
-    // Special handling for broadcast_tx_sync using codec
-    if (method === RpcMethod.BROADCAST_TX_SYNC) {
-      const encoded = this.encodeBroadcastTxSync(params as BroadcastTxParams);
-      return encoded;
-    }
-
-    // Special handling for broadcast_tx_async using codec
-    if (method === RpcMethod.BROADCAST_TX_ASYNC) {
-      const encoded = this.encodeBroadcastTxAsync(params as BroadcastTxParams);
-      return encoded;
-    }
-
-    // Special handling for broadcast_tx_commit using codec
-    if (method === RpcMethod.BROADCAST_TX_COMMIT) {
-      const encoded = this.encodeBroadcastTxCommit(params as BroadcastTxParams);
-      return encoded;
-    }
-
-    // Special handling for check_tx using codec
-    if (method === RpcMethod.CHECK_TX) {
-      const encoded = this.encodeCheckTx(params as CheckTxParams);
-      return encoded;
-    }
-
-    const encoded: any = {};
-    for (const [key, value] of Object.entries(params)) {
-      const snakeKey = this.camelToSnake(key);
-
-      // Handle hash parameters with 0x prefix
-      if (key === 'hash' && typeof value === 'string' && value.startsWith('0x')) {
-        // Convert hex to base64 for RPC
-        const hexString = value.slice(2); // Remove 0x prefix
-        const bytes = Buffer.from(hexString, 'hex');
-        encoded[snakeKey] = bytes.toString('base64');
-      }
-      // Handle Uint8Array data (especially for ABCI queries and broadcast)
-      else if (value instanceof Uint8Array) {
-        // For tx field in broadcast methods, encode as base64
-        if (key === 'tx') {
-          encoded[snakeKey] = Buffer.from(value).toString('base64');
-        } else {
-          // Convert Uint8Array to hex string for RPC
-          encoded[snakeKey] = this.decodeBytes(value);
-        }
-      }
-      else {
-        encoded[snakeKey] = value;
-      }
-    }
-    return encoded;
-  }
-
-  decodeResponse(method: RpcMethod, response: any): any {
-    // Use the version-specific decoder
-    switch (method) {
-      case RpcMethod.ABCI_INFO:
-        return this.decodeAbciInfo(response);
-      case RpcMethod.ABCI_QUERY:
-        return this.decodeAbciQuery(response);
-      case RpcMethod.BLOCK_RESULTS:
-        return this.decodeBlockResults(response);
-
-      case RpcMethod.CONSENSUS_PARAMS:
-        return this.decodeConsensusParams(response);
-
-
-
-      case RpcMethod.STATUS:
-        return this.decodeStatus(response);
-      case RpcMethod.NET_INFO:
-        return this.decodeNetInfo(response);
-      case RpcMethod.GENESIS:
-        return this.decodeGenesis(response);
-      case RpcMethod.GENESIS_CHUNKED:
-        return this.decodeGenesisChunked(response);
-      case RpcMethod.HEALTH:
-        return this.decodeHealth(response);
-
-      case RpcMethod.NUM_UNCONFIRMED_TXS:
-        return this.decodeNumUnconfirmedTxs(response);
-      case RpcMethod.COMMIT:
-        return this.decodeCommit(response);
-      case RpcMethod.BROADCAST_TX_SYNC:
-        return this.decodeBroadcastTxSync(response);
-      case RpcMethod.BROADCAST_TX_ASYNC:
-        return this.decodeBroadcastTxAsync(response);
-      case RpcMethod.BROADCAST_TX_COMMIT:
-        return this.decodeBroadcastTxCommit(response);
-      default:
-        // For unsupported methods, return raw response
-        return response;
-    }
-  }
-
   encodeBytes(data: string): Uint8Array {
     // Handle hex strings and base64
     if (data.startsWith('0x')) {

networks/cosmos/src/client-factory.ts

@@ -104,14 +104,11 @@ export class CosmosClientFactory {
     endpoint: string | WebSocketEndpoint,
     options: WebSocketClientOptions = {}
   ): Promise<ICosmosEventClient> {
-    // For WebSocket, we need to convert the endpoint to HTTP for detection
-    const httpEndpoint = this.convertToHttpEndpoint(endpoint);
-    const protocolAdapter = await this.getProtocolAdapter(httpEndpoint, options.protocolVersion);
     const rpcClient = new WebSocketRpcClient(endpoint, {
       reconnect: options.reconnect
     });
 
-    return new CosmosEventClient(rpcClient, protocolAdapter);
+    return new CosmosEventClient(rpcClient);
   }
 
   /**
@@ -135,7 +132,7 @@ export class CosmosClientFactory {
 
     return {
       queryClient: new CosmosQueryClient(httpRpcClient, protocolAdapter) as any,
-      eventClient: new CosmosEventClient(wsRpcClient, protocolAdapter)
+      eventClient: new CosmosEventClient(wsRpcClient)
     };
   }
 
@@ -155,7 +152,7 @@ export class CosmosClientFactory {
 
     return {
       queryClient: new CosmosQueryClient(rpcClient, protocolAdapter) as any,
-      eventClient: new CosmosEventClient(rpcClient, protocolAdapter)
+      eventClient: new CosmosEventClient(rpcClient)
     };
   }
 }

networks/cosmos/src/event/cosmos-event-client.ts

@@ -5,26 +5,24 @@ import { RpcMethod, EventType } from '../types/protocol';
 import { Block } from '../types/responses/common/block/block';
 import { BlockHeader } from '../types/responses/common/header/block-header';
 import { TxEvent, BlockEvent } from '../types/responses/common/event';
-import { IProtocolAdapter } from '../adapters/base';
 
 export class CosmosEventClient implements ICosmosEventClient {
   private activeSubscriptions = new Set<string>();
 
   constructor(
-    private rpcClient: IRpcClient,
-    private protocolAdapter: IProtocolAdapter
+    private rpcClient: IRpcClient
   ) {}
 
   async* subscribeToEvents<TEvent>(
-    eventType: string, 
+    eventType: string,
     filter?: unknown
   ): AsyncIterable<TEvent> {
     if (!this.rpcClient.isConnected()) {
       throw new SubscriptionError('RPC client not connected');
     }
 
     const subscriptionKey = `${eventType}_${JSON.stringify(filter)}`;
-    
+
     if (this.activeSubscriptions.has(subscriptionKey)) {
       throw new SubscriptionError(`Already subscribed to ${eventType}`);
     }
@@ -33,10 +31,12 @@ export class CosmosEventClient implements ICosmosEventClient {
 
     try {
       const params = { query: this.buildQuery(eventType, filter) };
-      const encodedParams = this.protocolAdapter.encodeParams(RpcMethod.SUBSCRIBE, params);
-      
+      // For SUBSCRIBE, just pass params directly since they're already in the correct format
+      const encodedParams = params;
+
       for await (const event of this.rpcClient.subscribe<any>(RpcMethod.SUBSCRIBE, encodedParams)) {
-        const decoded = this.protocolAdapter.decodeResponse(RpcMethod.SUBSCRIBE, event);
+        // For SUBSCRIBE, return the raw response as no specific decoding is needed
+        const decoded = event;
         yield decoded as TEvent;
       }
     } finally {
@@ -84,7 +84,7 @@ export class CosmosEventClient implements ICosmosEventClient {
 
   private buildQuery(eventType: string, filter?: unknown): string {
     let query = `tm.event='${eventType}'`;
-    
+
     if (filter && typeof filter === 'object') {
       const filterObj = filter as Record<string, any>;
       for (const [key, value] of Object.entries(filterObj)) {
@@ -95,7 +95,7 @@ export class CosmosEventClient implements ICosmosEventClient {
         query += ` AND ${key}='${value}'`;
       }
     }
-    
+
     return query;
   }
 }

networks/cosmos/src/query/__tests__/broadcast.test.ts

@@ -169,13 +169,13 @@ describe('CosmosQueryClient Broadcast Methods', () => {
     it('should encode tx as base64 for broadcast methods', () => {
       const tx = new Uint8Array([255, 128, 64, 32, 16]);
 
-      const syncParams = adapter.encodeParams(RpcMethod.BROADCAST_TX_SYNC, { tx });
+      const syncParams = adapter.encodeBroadcastTxSync({ tx });
       expect(syncParams.tx).toBe('/4BAIBA=');
 
-      const asyncParams = adapter.encodeParams(RpcMethod.BROADCAST_TX_ASYNC, { tx });
+      const asyncParams = adapter.encodeBroadcastTxAsync({ tx });
       expect(asyncParams.tx).toBe('/4BAIBA=');
 
-      const commitParams = adapter.encodeParams(RpcMethod.BROADCAST_TX_COMMIT, { tx });
+      const commitParams = adapter.encodeBroadcastTxCommit({ tx });
       expect(commitParams.tx).toBe('/4BAIBA=');
     });
   });