From 6cb74abd16e0cc590693ab3f25a688d0534ebc1f Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Sat, 27 Dec 2025 07:13:33 -0800
Subject: [PATCH 01/37] Add defaultNetworks parameter to chain configs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds optional defaultNetworks array to Solana and Ethereum chain configs
to allow specifying which networks to query for balance operations. This
optimizes performance by avoiding queries to all 9+ networks when only
1-2 are needed.

Changes:
- Add defaultNetworks to chain schemas with additionalProperties: true
  for backwards compatibility
- Add defaultNetworks to SolanaChainConfig and EthereumChainConfig interfaces
- Update config getter functions to include defaultNetworks
- Add commented examples in template files

Closes #581

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/ethereum/ethereum.config.ts             | 2 ++
 src/chains/solana/solana.config.ts                 | 2 ++
 src/templates/chains/ethereum.yml                  | 6 ++++++
 src/templates/chains/solana.yml                    | 6 ++++++
 src/templates/namespace/ethereum-chain-schema.json | 9 ++++++++-
 src/templates/namespace/solana-chain-schema.json   | 9 ++++++++-
 6 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/chains/ethereum/ethereum.config.ts b/src/chains/ethereum/ethereum.config.ts
index 6c812b7268..d608868e93 100644
--- a/src/chains/ethereum/ethereum.config.ts
+++ b/src/chains/ethereum/ethereum.config.ts
@@ -17,6 +17,7 @@ export interface EthereumNetworkConfig {
 
 export interface EthereumChainConfig {
   defaultNetwork: string;
+  defaultNetworks?: string[];
   defaultWallet: string;
   rpcProvider: string;
   etherscanAPIKey?: string;
@@ -44,6 +45,7 @@ export function getEthereumNetworkConfig(network: string): EthereumNetworkConfig
 export function getEthereumChainConfig(): EthereumChainConfig {
   return {
     defaultNetwork: ConfigManagerV2.getInstance().get('ethereum.defaultNetwork'),
+    defaultNetworks: ConfigManagerV2.getInstance().get('ethereum.defaultNetworks'),
     defaultWallet: ConfigManagerV2.getInstance().get('ethereum.defaultWallet'),
     rpcProvider: ConfigManagerV2.getInstance().get('ethereum.rpcProvider') || 'url',
     etherscanAPIKey: ConfigManagerV2.getInstance().get('apiKeys.etherscan'),
diff --git a/src/chains/solana/solana.config.ts b/src/chains/solana/solana.config.ts
index e75d5ed299..01746d3184 100644
--- a/src/chains/solana/solana.config.ts
+++ b/src/chains/solana/solana.config.ts
@@ -16,6 +16,7 @@ export interface SolanaNetworkConfig {
 
 export interface SolanaChainConfig {
   defaultNetwork: string;
+  defaultNetworks?: string[];
   defaultWallet: string;
   rpcProvider: string;
 }
@@ -41,6 +42,7 @@ export function getSolanaNetworkConfig(network: string): SolanaNetworkConfig {
 export function getSolanaChainConfig(): SolanaChainConfig {
   return {
     defaultNetwork: ConfigManagerV2.getInstance().get('solana.defaultNetwork'),
+    defaultNetworks: ConfigManagerV2.getInstance().get('solana.defaultNetworks'),
     defaultWallet: ConfigManagerV2.getInstance().get('solana.defaultWallet'),
     rpcProvider: ConfigManagerV2.getInstance().get('solana.rpcProvider') || 'url',
   };
diff --git a/src/templates/chains/ethereum.yml b/src/templates/chains/ethereum.yml
index 7a115ac297..c96b5ca437 100644
--- a/src/templates/chains/ethereum.yml
+++ b/src/templates/chains/ethereum.yml
@@ -1,5 +1,11 @@
 defaultNetwork: mainnet
 defaultWallet: '<ethereum-wallet-address>'
 
+# Optional: List of networks to query for balance operations
+# If not specified, only defaultNetwork is used
+# defaultNetworks:
+#   - mainnet
+#   - base
+
 # RPC provider: 'url' uses nodeURL from network config, or specify a provider name (e.g., 'infura')
 rpcProvider: url
\ No newline at end of file
diff --git a/src/templates/chains/solana.yml b/src/templates/chains/solana.yml
index c3d5ceb191..fdfd60186b 100644
--- a/src/templates/chains/solana.yml
+++ b/src/templates/chains/solana.yml
@@ -1,5 +1,11 @@
 defaultNetwork: mainnet-beta
 defaultWallet: '<solana-wallet-address>'
 
+# Optional: List of networks to query for balance operations
+# If not specified, only defaultNetwork is used
+# defaultNetworks:
+#   - mainnet-beta
+#   - devnet
+
 # RPC provider: 'url' uses nodeURL from network config, or specify a provider name (e.g., 'helius')
 rpcProvider: url
\ No newline at end of file
diff --git a/src/templates/namespace/ethereum-chain-schema.json b/src/templates/namespace/ethereum-chain-schema.json
index 5f775c6311..6bab3ebd4c 100644
--- a/src/templates/namespace/ethereum-chain-schema.json
+++ b/src/templates/namespace/ethereum-chain-schema.json
@@ -6,6 +6,13 @@
       "type": "string",
       "description": "Default network for Ethereum operations"
     },
+    "defaultNetworks": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of networks to query for balance operations. If not specified, falls back to defaultNetwork only."
+    },
     "defaultWallet": {
       "type": "string",
       "description": "Default wallet address for examples and testing"
@@ -18,5 +25,5 @@
     }
   },
   "required": ["defaultNetwork", "defaultWallet"],
-  "additionalProperties": false
+  "additionalProperties": true
 }
diff --git a/src/templates/namespace/solana-chain-schema.json b/src/templates/namespace/solana-chain-schema.json
index 2e0c30ad8a..c5b2ef3728 100644
--- a/src/templates/namespace/solana-chain-schema.json
+++ b/src/templates/namespace/solana-chain-schema.json
@@ -6,6 +6,13 @@
       "type": "string",
       "description": "Default network for Solana operations"
     },
+    "defaultNetworks": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of networks to query for balance operations. If not specified, falls back to defaultNetwork only."
+    },
     "defaultWallet": {
       "type": "string",
       "description": "Default wallet address for examples and testing"
@@ -18,5 +25,5 @@
     }
   },
   "required": ["defaultNetwork", "defaultWallet"],
-  "additionalProperties": false
+  "additionalProperties": true
 }

From 13c8f4f286b86008c17f010c4790e4c65a3925a7 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 13 Jan 2026 17:18:55 -0800
Subject: [PATCH 02/37] feat: add strategyType support to unified CLMM open
 endpoint

Add optional strategyType parameter to /trading/clmm/open endpoint
to support Meteora-specific position strategies (Spot vs Curve).
This parameter is ignored by other connectors (Uniswap, Raydium, etc.).

- Update UnifiedOpenPositionRequest schema with strategyType field
- Pass strategyType to meteoraOpenPosition function
- Maintains backward compatibility (optional parameter)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/trading/trading-clmm-routes/open.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/trading/trading-clmm-routes/open.ts b/src/trading/trading-clmm-routes/open.ts
index b63a5e02c7..a2739b0524 100644
--- a/src/trading/trading-clmm-routes/open.ts
+++ b/src/trading/trading-clmm-routes/open.ts
@@ -91,6 +91,13 @@ const UnifiedOpenPositionRequest = Type.Object({
       examples: [1],
     }),
   ),
+  // Meteora-specific parameter (optional, ignored by other connectors)
+  strategyType: Type.Optional(
+    Type.Number({
+      description: 'Strategy type for Meteora positions (0=Spot, 1=Curve). Only applies to Meteora connector.',
+      examples: [0],
+    }),
+  ),
 });
 
 // Import connector functions
@@ -131,6 +138,7 @@ export const openPositionRoute: FastifyPluginAsync = async (fastify) => {
           baseTokenAmount,
           quoteTokenAmount,
           slippagePct,
+          strategyType,
         } = request.body;
 
         // Parse chain and network from chainNetwork parameter
@@ -184,6 +192,7 @@ export const openPositionRoute: FastifyPluginAsync = async (fastify) => {
               baseTokenAmount,
               quoteTokenAmount,
               slippagePct,
+              strategyType,
             );
 
           case 'pancakeswap-sol':

From c83952bce9c4db1a9ae825160eeb453e02837777 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 13 Jan 2026 18:30:41 -0800
Subject: [PATCH 03/37] feat: add optional bins parameter to unified pool-info
 endpoint

Add support for requesting bin liquidity data in the unified
/trading/clmm/pool-info endpoint. This parameter is only supported
by Meteora connector and ignored by others.

Changes:
- Add optional `bins` boolean parameter to UnifiedPoolInfoRequest schema
- Pass bins parameter through getSolanaPoolInfo to Meteora connector
- Update Meteora's getPoolInfo to conditionally fetch bins (default: false)
- Make bins field optional in MeteoraPoolInfoSchema

Backward compatibility:
- bins parameter defaults to false (existing clients unaffected)
- bins parameter is optional (existing clients don't need to send it)
- Non-Meteora connectors ignore this parameter
- Fetching bins is expensive, so only done when explicitly requested

Usage:
  GET /trading/clmm/pool-info?connector=meteora&chainNetwork=solana-mainnet-beta&poolAddress=xxx&bins=true

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/connectors/meteora/clmm-routes/poolInfo.ts |  3 ++-
 src/connectors/meteora/meteora.ts              | 12 +++++++++---
 src/schemas/clmm-schema.ts                     |  2 +-
 src/trading/clmm/pools.ts                      | 17 +++++++++++++----
 4 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/connectors/meteora/clmm-routes/poolInfo.ts b/src/connectors/meteora/clmm-routes/poolInfo.ts
index e74ad1a164..bf0b997dec 100644
--- a/src/connectors/meteora/clmm-routes/poolInfo.ts
+++ b/src/connectors/meteora/clmm-routes/poolInfo.ts
@@ -9,6 +9,7 @@ export async function getPoolInfo(
   fastify: FastifyInstance,
   network: string,
   poolAddress: string,
+  bins?: boolean,
 ): Promise<PoolInfo | MeteoraPoolInfo> {
   const meteora = await Meteora.getInstance(network);
   if (!meteora) {
@@ -20,7 +21,7 @@ export async function getPoolInfo(
   }
 
   // Fetch pool info directly from RPC
-  const poolInfo = (await meteora.getPoolInfo(poolAddress)) as MeteoraPoolInfo;
+  const poolInfo = (await meteora.getPoolInfo(poolAddress, bins)) as MeteoraPoolInfo;
   if (!poolInfo) {
     throw fastify.httpErrors.notFound(`Pool not found: ${poolAddress}`);
   }
diff --git a/src/connectors/meteora/meteora.ts b/src/connectors/meteora/meteora.ts
index 10d46c13bf..cdb9989a4c 100644
--- a/src/connectors/meteora/meteora.ts
+++ b/src/connectors/meteora/meteora.ts
@@ -137,7 +137,7 @@ export class Meteora {
   }
 
   /** Gets comprehensive pool information */
-  async getPoolInfo(poolAddress: string): Promise<MeteoraPoolInfo | null> {
+  async getPoolInfo(poolAddress: string, includeBins: boolean = false): Promise<MeteoraPoolInfo | null> {
     try {
       const dlmmPool = await this.getDlmmPool(poolAddress);
       if (!dlmmPool) {
@@ -158,7 +158,7 @@ export class Meteora {
         return null;
       }
 
-      return {
+      const poolInfo: MeteoraPoolInfo = {
         address: poolAddress,
         baseTokenAddress: dlmmPool.tokenX.publicKey.toBase58(),
         quoteTokenAddress: dlmmPool.tokenY.publicKey.toBase58(),
@@ -171,8 +171,14 @@ export class Meteora {
         activeBinId: activeBin.binId,
         minBinId: dlmmPool.lbPair.parameters.minBinId,
         maxBinId: dlmmPool.lbPair.parameters.maxBinId,
-        bins: await this.getPoolLiquidity(poolAddress),
       };
+
+      // Only fetch bins if explicitly requested (expensive operation)
+      if (includeBins) {
+        poolInfo.bins = await this.getPoolLiquidity(poolAddress);
+      }
+
+      return poolInfo;
     } catch (error) {
       logger.debug(`Could not decode ${poolAddress} as Meteora pool: ${error}`);
       return null;
diff --git a/src/schemas/clmm-schema.ts b/src/schemas/clmm-schema.ts
index b5b2cb7bcd..60b6d88d54 100644
--- a/src/schemas/clmm-schema.ts
+++ b/src/schemas/clmm-schema.ts
@@ -60,7 +60,7 @@ export const MeteoraPoolInfoSchema = Type.Composite(
       dynamicFeePct: Type.Number(),
       minBinId: Type.Number(),
       maxBinId: Type.Number(),
-      bins: Type.Array(BinLiquiditySchema),
+      bins: Type.Optional(Type.Array(BinLiquiditySchema)),
     }),
   ],
   { $id: 'MeteoraPoolInfo' },
diff --git a/src/trading/clmm/pools.ts b/src/trading/clmm/pools.ts
index bd35c68926..134d790696 100644
--- a/src/trading/clmm/pools.ts
+++ b/src/trading/clmm/pools.ts
@@ -34,6 +34,13 @@ const UnifiedPoolInfoRequestSchema = Type.Object({
     description: 'Pool contract address',
     examples: [CLMM_POOL_ADDRESS_EXAMPLE],
   }),
+  bins: Type.Optional(
+    Type.Boolean({
+      description: 'Include bin liquidity data (Meteora only)',
+      default: false,
+      examples: [true],
+    }),
+  ),
 });
 
 type UnifiedPoolInfoRequest = Static<typeof UnifiedPoolInfoRequestSchema>;
@@ -64,6 +71,7 @@ async function getSolanaPoolInfo(
   connector: string,
   network: string,
   poolAddress: string,
+  bins?: boolean,
 ): Promise<PoolInfo> {
   logger.info(`[CLMM] Getting pool info from ${connector} on solana/${network}`);
 
@@ -71,7 +79,7 @@ async function getSolanaPoolInfo(
     case 'raydium':
       return await raydiumGetPoolInfo(fastify, network, poolAddress);
     case 'meteora':
-      return await meteoraGetPoolInfo(fastify, network, poolAddress);
+      return await meteoraGetPoolInfo(fastify, network, poolAddress, bins);
     case 'pancakeswap-sol':
       return await pancakeswapSolGetPoolInfo(fastify, network, poolAddress);
     case 'orca':
@@ -110,6 +118,7 @@ export async function getUnifiedPoolInfo(
   connector: string,
   chainNetwork: string,
   poolAddress: string,
+  bins?: boolean,
 ): Promise<PoolInfo> {
   const { chain, network } = parseChainNetwork(chainNetwork);
 
@@ -120,7 +129,7 @@ export async function getUnifiedPoolInfo(
       return getEthereumPoolInfo(fastify, connector, network, poolAddress);
 
     case 'solana':
-      return getSolanaPoolInfo(fastify, connector, network, poolAddress);
+      return getSolanaPoolInfo(fastify, connector, network, poolAddress, bins);
 
     default:
       throw fastify.httpErrors.badRequest(`Unsupported chain: ${chain}`);
@@ -148,10 +157,10 @@ export const poolsRoute: FastifyPluginAsync = async (fastify) => {
       },
     },
     async (request, reply) => {
-      const { connector, chainNetwork, poolAddress } = request.query;
+      const { connector, chainNetwork, poolAddress, bins } = request.query;
 
       try {
-        const result = await getUnifiedPoolInfo(fastify, connector, chainNetwork, poolAddress);
+        const result = await getUnifiedPoolInfo(fastify, connector, chainNetwork, poolAddress, bins);
         return reply.code(200).send(result);
       } catch (error: any) {
         logger.error(`[UnifiedCLMM] Pool info error: ${error.message}`);

From 4a64bf169d8c27497de19a72900d041801be6445 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 13 Jan 2026 18:49:55 -0800
Subject: [PATCH 04/37] fix: ensure Meteora pool-info always returns bins in
 response

Changed Meteora pool-info to always include bins field in response
without requiring it as a request parameter. This maintains backward
compatibility while providing richer data for Meteora pools.

Changes:
- Remove bins parameter from pool-info request schema
- Always fetch and include bins in Meteora pool-info responses
- Other CLMM connectors (Raydium, Uniswap, etc.) remain unchanged
- Bins field is optional in schema for cross-connector compatibility

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/connectors/meteora/clmm-routes/poolInfo.ts |  5 ++---
 src/connectors/meteora/meteora.ts              |  8 ++------
 src/trading/clmm/pools.ts                      | 17 ++++-------------
 3 files changed, 8 insertions(+), 22 deletions(-)

diff --git a/src/connectors/meteora/clmm-routes/poolInfo.ts b/src/connectors/meteora/clmm-routes/poolInfo.ts
index bf0b997dec..2eb52ff1fb 100644
--- a/src/connectors/meteora/clmm-routes/poolInfo.ts
+++ b/src/connectors/meteora/clmm-routes/poolInfo.ts
@@ -9,7 +9,6 @@ export async function getPoolInfo(
   fastify: FastifyInstance,
   network: string,
   poolAddress: string,
-  bins?: boolean,
 ): Promise<PoolInfo | MeteoraPoolInfo> {
   const meteora = await Meteora.getInstance(network);
   if (!meteora) {
@@ -20,8 +19,8 @@ export async function getPoolInfo(
     throw fastify.httpErrors.badRequest('Pool address is required');
   }
 
-  // Fetch pool info directly from RPC
-  const poolInfo = (await meteora.getPoolInfo(poolAddress, bins)) as MeteoraPoolInfo;
+  // Fetch pool info directly from RPC (always includes bins)
+  const poolInfo = (await meteora.getPoolInfo(poolAddress)) as MeteoraPoolInfo;
   if (!poolInfo) {
     throw fastify.httpErrors.notFound(`Pool not found: ${poolAddress}`);
   }
diff --git a/src/connectors/meteora/meteora.ts b/src/connectors/meteora/meteora.ts
index cdb9989a4c..eb756d5954 100644
--- a/src/connectors/meteora/meteora.ts
+++ b/src/connectors/meteora/meteora.ts
@@ -137,7 +137,7 @@ export class Meteora {
   }
 
   /** Gets comprehensive pool information */
-  async getPoolInfo(poolAddress: string, includeBins: boolean = false): Promise<MeteoraPoolInfo | null> {
+  async getPoolInfo(poolAddress: string): Promise<MeteoraPoolInfo | null> {
     try {
       const dlmmPool = await this.getDlmmPool(poolAddress);
       if (!dlmmPool) {
@@ -171,13 +171,9 @@ export class Meteora {
         activeBinId: activeBin.binId,
         minBinId: dlmmPool.lbPair.parameters.minBinId,
         maxBinId: dlmmPool.lbPair.parameters.maxBinId,
+        bins: await this.getPoolLiquidity(poolAddress),
       };
 
-      // Only fetch bins if explicitly requested (expensive operation)
-      if (includeBins) {
-        poolInfo.bins = await this.getPoolLiquidity(poolAddress);
-      }
-
       return poolInfo;
     } catch (error) {
       logger.debug(`Could not decode ${poolAddress} as Meteora pool: ${error}`);
diff --git a/src/trading/clmm/pools.ts b/src/trading/clmm/pools.ts
index 134d790696..bd35c68926 100644
--- a/src/trading/clmm/pools.ts
+++ b/src/trading/clmm/pools.ts
@@ -34,13 +34,6 @@ const UnifiedPoolInfoRequestSchema = Type.Object({
     description: 'Pool contract address',
     examples: [CLMM_POOL_ADDRESS_EXAMPLE],
   }),
-  bins: Type.Optional(
-    Type.Boolean({
-      description: 'Include bin liquidity data (Meteora only)',
-      default: false,
-      examples: [true],
-    }),
-  ),
 });
 
 type UnifiedPoolInfoRequest = Static<typeof UnifiedPoolInfoRequestSchema>;
@@ -71,7 +64,6 @@ async function getSolanaPoolInfo(
   connector: string,
   network: string,
   poolAddress: string,
-  bins?: boolean,
 ): Promise<PoolInfo> {
   logger.info(`[CLMM] Getting pool info from ${connector} on solana/${network}`);
 
@@ -79,7 +71,7 @@ async function getSolanaPoolInfo(
     case 'raydium':
       return await raydiumGetPoolInfo(fastify, network, poolAddress);
     case 'meteora':
-      return await meteoraGetPoolInfo(fastify, network, poolAddress, bins);
+      return await meteoraGetPoolInfo(fastify, network, poolAddress);
     case 'pancakeswap-sol':
       return await pancakeswapSolGetPoolInfo(fastify, network, poolAddress);
     case 'orca':
@@ -118,7 +110,6 @@ export async function getUnifiedPoolInfo(
   connector: string,
   chainNetwork: string,
   poolAddress: string,
-  bins?: boolean,
 ): Promise<PoolInfo> {
   const { chain, network } = parseChainNetwork(chainNetwork);
 
@@ -129,7 +120,7 @@ export async function getUnifiedPoolInfo(
       return getEthereumPoolInfo(fastify, connector, network, poolAddress);
 
     case 'solana':
-      return getSolanaPoolInfo(fastify, connector, network, poolAddress, bins);
+      return getSolanaPoolInfo(fastify, connector, network, poolAddress);
 
     default:
       throw fastify.httpErrors.badRequest(`Unsupported chain: ${chain}`);
@@ -157,10 +148,10 @@ export const poolsRoute: FastifyPluginAsync = async (fastify) => {
       },
     },
     async (request, reply) => {
-      const { connector, chainNetwork, poolAddress, bins } = request.query;
+      const { connector, chainNetwork, poolAddress } = request.query;
 
       try {
-        const result = await getUnifiedPoolInfo(fastify, connector, chainNetwork, poolAddress, bins);
+        const result = await getUnifiedPoolInfo(fastify, connector, chainNetwork, poolAddress);
         return reply.code(200).send(result);
       } catch (error: any) {
         logger.error(`[UnifiedCLMM] Pool info error: ${error.message}`);

From 4f3f80204d5c9a7b4f92a81b8ed8324836c48576 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 14 Jan 2026 10:53:19 -0800
Subject: [PATCH 05/37] feat: add TRANSACTION_TIMEOUT error code for tx
 confirmation failures

- Add ErrorCode enum with TRANSACTION_TIMEOUT code
- Add transactionTimeout helper in httpErrors
- Include error code in HTTP error response
- Use transactionTimeout error in solana.ts for confirmation failures

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/app.ts                    |  9 +++++++--
 src/chains/solana/solana.ts   |  5 ++++-
 src/services/error-handler.ts | 18 +++++++++++++++++-
 3 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/src/app.ts b/src/app.ts
index ff7460ae29..fb5908072c 100644
--- a/src/app.ts
+++ b/src/app.ts
@@ -308,11 +308,16 @@ const configureGatewayServer = () => {
 
     // Handle Fastify's native errors (includes rate limit errors with statusCode 429)
     if (error.statusCode && error.statusCode >= 400) {
-      return reply.status(error.statusCode).send({
+      const response: Record<string, unknown> = {
         statusCode: error.statusCode,
         error: error.name,
         message: error.message,
-      });
+      };
+      // Include error code if present (for specific error types like TRANSACTION_TIMEOUT)
+      if ('code' in error && error.code) {
+        response.code = error.code;
+      }
+      return reply.status(error.statusCode).send(response);
     }
 
     // Log and handle unexpected errors
diff --git a/src/chains/solana/solana.ts b/src/chains/solana/solana.ts
index 576ac5a4d1..5ad6e71089 100644
--- a/src/chains/solana/solana.ts
+++ b/src/chains/solana/solana.ts
@@ -37,6 +37,7 @@ import { createRateLimitAwareSolanaConnection } from '../../rpc/rpc-connection-i
 import { RPCProvider } from '../../rpc/rpc-provider-base';
 import { ConfigManagerCertPassphrase } from '../../services/config-manager-cert-passphrase';
 import { ConfigManagerV2 } from '../../services/config-manager-v2';
+import { httpErrors } from '../../services/error-handler';
 import { logger, redactUrl } from '../../services/logger';
 import { TokenService } from '../../services/token-service';
 import { getSafeWalletFilePath, isHardwareWallet as isHardwareWalletUtil } from '../../wallet/utils';
@@ -1314,7 +1315,9 @@ export class Solana {
       return { signature, fee: actualFee };
     }
 
-    throw new Error(`Transaction failed to confirm after ${this.config.confirmRetryCount} attempts`);
+    throw httpErrors.transactionTimeout(
+      `Transaction failed to confirm after ${this.config.confirmRetryCount} attempts`,
+    );
   }
 
   private async prepareTx(
diff --git a/src/services/error-handler.ts b/src/services/error-handler.ts
index c9e885c0d9..e68c97d69f 100644
--- a/src/services/error-handler.ts
+++ b/src/services/error-handler.ts
@@ -1,3 +1,12 @@
+// Error codes for specific error types
+export const ErrorCode = {
+  TRANSACTION_TIMEOUT: 'TRANSACTION_TIMEOUT',
+  INSUFFICIENT_BALANCE: 'INSUFFICIENT_BALANCE',
+  INVALID_PARAMS: 'INVALID_PARAMS',
+} as const;
+
+export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+
 /**
  * Custom HTTP error class for use throughout the application.
  * These errors carry a statusCode that Fastify's error handler will properly handle.
@@ -5,12 +14,14 @@
 export class HttpError extends Error {
   statusCode: number;
   error: string;
+  code?: ErrorCodeType;
 
-  constructor(statusCode: number, message: string) {
+  constructor(statusCode: number, message: string, code?: ErrorCodeType) {
     super(message);
     this.statusCode = statusCode;
     this.error = HttpError.getErrorName(statusCode);
     this.name = 'HttpError';
+    this.code = code;
   }
 
   private static getErrorName(statusCode: number): string {
@@ -62,6 +73,10 @@ export function forbidden(message: string): HttpError {
   return new HttpError(403, message);
 }
 
+export function transactionTimeout(message: string): HttpError {
+  return new HttpError(504, message, ErrorCode.TRANSACTION_TIMEOUT);
+}
+
 /**
  * HTTP errors object - drop-in replacement for fastify.httpErrors
  */
@@ -71,5 +86,6 @@ export const httpErrors = {
   internalServerError,
   serviceUnavailable,
   forbidden,
+  transactionTimeout,
   createError: (statusCode: number, message: string) => new HttpError(statusCode, message),
 };

From 6c9607f8a610de1ca0fbf348f319e54dadcafb8a Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 14 Jan 2026 13:41:04 -0800
Subject: [PATCH 06/37] fix: return signature for unconfirmed transactions
 instead of throwing

When a transaction is sent but not confirmed within the timeout period,
the gateway now returns the signature with status=0 (pending) instead
of throwing TRANSACTION_TIMEOUT error. This preserves the transaction
hash so callers can track/poll the transaction instead of losing it.

Changes:
- sendAndConfirmTransaction now returns {signature, fee, confirmed} with
  confirmed=false when tx sent but not confirmed (instead of throwing)
- All Meteora CLMM routes updated to handle confirmed=false and return
  pending status with signature
- Error is only thrown when transaction was never sent (no signature)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/solana/solana.ts                   | 16 ++++++++----
 .../meteora/clmm-routes/addLiquidity.ts       | 11 +++++++-
 .../meteora/clmm-routes/closePosition.ts      | 16 ++++++++++++
 .../meteora/clmm-routes/collectFees.ts        | 21 +++++++++++++---
 .../meteora/clmm-routes/openPosition.ts       | 25 ++++++++++++++++---
 .../meteora/clmm-routes/removeLiquidity.ts    | 15 +++++++++++
 6 files changed, 91 insertions(+), 13 deletions(-)

diff --git a/src/chains/solana/solana.ts b/src/chains/solana/solana.ts
index 5ad6e71089..90c6c2d13b 100644
--- a/src/chains/solana/solana.ts
+++ b/src/chains/solana/solana.ts
@@ -1255,7 +1255,7 @@ export class Solana {
     tx: Transaction | VersionedTransaction,
     signers: Signer[] = [],
     priorityFeePerCU?: number,
-  ): Promise<{ signature: string; fee: number }> {
+  ): Promise<{ signature: string; fee: number; confirmed?: boolean }> {
     // Use provided priority fee or estimate it
     const currentPriorityFee = priorityFeePerCU ?? (await this.estimateGasPrice());
 
@@ -1312,12 +1312,18 @@ export class Solana {
     if (confirmed && txData) {
       const actualFee = this.getFee(txData);
       logger.info(`Transaction ${signature} confirmed with total fee: ${actualFee.toFixed(6)} SOL`);
-      return { signature, fee: actualFee };
+      return { signature, fee: actualFee, confirmed: true };
     }
 
-    throw httpErrors.transactionTimeout(
-      `Transaction failed to confirm after ${this.config.confirmRetryCount} attempts`,
-    );
+    // Transaction was sent but not confirmed - return signature with confirmed=false
+    // instead of throwing, so caller can decide what to do (retry, return pending status, etc.)
+    if (signature) {
+      logger.warn(`Transaction ${signature} sent but not confirmed after ${this.config.confirmRetryCount} attempts`);
+      return { signature, fee: 0, confirmed: false };
+    }
+
+    // No signature means transaction was never sent successfully
+    throw httpErrors.transactionTimeout(`Transaction failed to send after ${this.config.confirmRetryCount} attempts`);
   }
 
   private async prepareTx(
diff --git a/src/connectors/meteora/clmm-routes/addLiquidity.ts b/src/connectors/meteora/clmm-routes/addLiquidity.ts
index 1cecbda4d5..679b6b5152 100644
--- a/src/connectors/meteora/clmm-routes/addLiquidity.ts
+++ b/src/connectors/meteora/clmm-routes/addLiquidity.ts
@@ -122,7 +122,16 @@ export async function addLiquidity(
 
   // Send and confirm transaction using sendAndConfirmTransaction which handles signing
   // Transaction will automatically simulate to determine optimal compute units
-  const { signature, fee } = await solana.sendAndConfirmTransaction(addLiquidityTx, [wallet]);
+  const { signature, fee, confirmed: txConfirmed } = await solana.sendAndConfirmTransaction(addLiquidityTx, [wallet]);
+
+  // If transaction wasn't confirmed, return pending status
+  if (txConfirmed === false) {
+    logger.warn(`Transaction ${signature} sent but not confirmed`);
+    return {
+      signature,
+      status: 0, // PENDING
+    };
+  }
 
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
diff --git a/src/connectors/meteora/clmm-routes/closePosition.ts b/src/connectors/meteora/clmm-routes/closePosition.ts
index b1bc498902..c76e00fbae 100644
--- a/src/connectors/meteora/clmm-routes/closePosition.ts
+++ b/src/connectors/meteora/clmm-routes/closePosition.ts
@@ -65,6 +65,8 @@ export async function closePosition(
     let totalFee = 0;
     let lastSignature = '';
 
+    let txConfirmed = true;
+
     for (let i = 0; i < transactions.length; i++) {
       const tx = transactions[i];
       if (transactions.length > 1) {
@@ -83,10 +85,24 @@ export async function closePosition(
       const result = await solana.sendAndConfirmTransaction(tx, [wallet]);
       totalFee += result.fee;
       lastSignature = result.signature;
+
+      // Track if any transaction didn't confirm
+      if (result.confirmed === false) {
+        txConfirmed = false;
+      }
     }
 
     const signature = lastSignature;
 
+    // If any transaction wasn't confirmed, return pending status
+    if (!txConfirmed) {
+      logger.warn(`Transaction ${signature} sent but not confirmed`);
+      return {
+        signature,
+        status: 0, // PENDING
+      };
+    }
+
     // Get transaction data for confirmation
     const txData = await solana.connection.getTransaction(signature, {
       commitment: 'confirmed',
diff --git a/src/connectors/meteora/clmm-routes/collectFees.ts b/src/connectors/meteora/clmm-routes/collectFees.ts
index 2141149a67..f4758ab675 100644
--- a/src/connectors/meteora/clmm-routes/collectFees.ts
+++ b/src/connectors/meteora/clmm-routes/collectFees.ts
@@ -55,6 +55,7 @@ export async function collectFees(
   // Simulate and send all transactions
   let totalFee = 0;
   let lastSignature = '';
+  let txConfirmed = true;
 
   for (const tx of transactions) {
     // Simulate with error handling
@@ -63,14 +64,28 @@ export async function collectFees(
     logger.info('Transaction simulated successfully, sending to network...');
 
     // Send and confirm transaction using sendAndConfirmTransaction which handles signing
-    const { signature, fee } = await solana.sendAndConfirmTransaction(tx, [wallet]);
-    lastSignature = signature;
-    totalFee += fee;
+    const result = await solana.sendAndConfirmTransaction(tx, [wallet]);
+    lastSignature = result.signature;
+    totalFee += result.fee;
+
+    // Track if any transaction didn't confirm
+    if (result.confirmed === false) {
+      txConfirmed = false;
+    }
   }
 
   const signature = lastSignature;
   const fee = totalFee;
 
+  // If any transaction wasn't confirmed, return pending status
+  if (!txConfirmed) {
+    logger.warn(`Transaction ${signature} sent but not confirmed`);
+    return {
+      signature,
+      status: 0, // PENDING
+    };
+  }
+
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
     commitment: 'confirmed',
diff --git a/src/connectors/meteora/clmm-routes/openPosition.ts b/src/connectors/meteora/clmm-routes/openPosition.ts
index 824483c4a6..b8100fea18 100644
--- a/src/connectors/meteora/clmm-routes/openPosition.ts
+++ b/src/connectors/meteora/clmm-routes/openPosition.ts
@@ -160,10 +160,27 @@ export async function openPosition(
 
   // Send and confirm the ORIGINAL unsigned transaction
   // sendAndConfirmTransaction will handle the signing and auto-simulate for optimal compute units
-  const { signature, fee: txFee } = await solana.sendAndConfirmTransaction(createPositionTx, [
-    wallet,
-    newImbalancePosition,
-  ]);
+  const {
+    signature,
+    fee: txFee,
+    confirmed: txConfirmed,
+  } = await solana.sendAndConfirmTransaction(createPositionTx, [wallet, newImbalancePosition]);
+
+  // If transaction wasn't confirmed, return pending status with position address
+  if (txConfirmed === false) {
+    logger.warn(`Transaction ${signature} sent but not confirmed`);
+    return {
+      signature,
+      status: 0, // PENDING
+      data: {
+        fee: 0,
+        positionAddress: newImbalancePosition.publicKey.toBase58(),
+        positionRent: 0,
+        baseTokenAmountAdded: 0,
+        quoteTokenAmountAdded: 0,
+      },
+    };
+  }
 
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
diff --git a/src/connectors/meteora/clmm-routes/removeLiquidity.ts b/src/connectors/meteora/clmm-routes/removeLiquidity.ts
index 6c7b7fa44c..db5d494ce8 100644
--- a/src/connectors/meteora/clmm-routes/removeLiquidity.ts
+++ b/src/connectors/meteora/clmm-routes/removeLiquidity.ts
@@ -72,6 +72,7 @@ export async function removeLiquidity(
 
   let totalFee = 0;
   let lastSignature = '';
+  let txConfirmed = true;
 
   for (let i = 0; i < transactions.length; i++) {
     const tx = transactions[i];
@@ -90,11 +91,25 @@ export async function removeLiquidity(
     const result = await solana.sendAndConfirmTransaction(tx, [wallet]);
     totalFee += result.fee;
     lastSignature = result.signature;
+
+    // Track if any transaction didn't confirm
+    if (result.confirmed === false) {
+      txConfirmed = false;
+    }
   }
 
   const signature = lastSignature;
   const fee = totalFee;
 
+  // If any transaction wasn't confirmed, return pending status
+  if (!txConfirmed) {
+    logger.warn(`Transaction ${signature} sent but not confirmed`);
+    return {
+      signature,
+      status: 0, // PENDING
+    };
+  }
+
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
     commitment: 'confirmed',

From 1d41611e9aca7f67d75dd039b8dea11733ff2b42 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 14 Jan 2026 13:43:14 -0800
Subject: [PATCH 07/37] Revert "fix: return signature for unconfirmed
 transactions instead of throwing"

This reverts commit 6c9607f8a610de1ca0fbf348f319e54dadcafb8a.
---
 src/chains/solana/solana.ts                   | 16 ++++--------
 .../meteora/clmm-routes/addLiquidity.ts       | 11 +-------
 .../meteora/clmm-routes/closePosition.ts      | 16 ------------
 .../meteora/clmm-routes/collectFees.ts        | 21 +++-------------
 .../meteora/clmm-routes/openPosition.ts       | 25 +++----------------
 .../meteora/clmm-routes/removeLiquidity.ts    | 15 -----------
 6 files changed, 13 insertions(+), 91 deletions(-)

diff --git a/src/chains/solana/solana.ts b/src/chains/solana/solana.ts
index 90c6c2d13b..5ad6e71089 100644
--- a/src/chains/solana/solana.ts
+++ b/src/chains/solana/solana.ts
@@ -1255,7 +1255,7 @@ export class Solana {
     tx: Transaction | VersionedTransaction,
     signers: Signer[] = [],
     priorityFeePerCU?: number,
-  ): Promise<{ signature: string; fee: number; confirmed?: boolean }> {
+  ): Promise<{ signature: string; fee: number }> {
     // Use provided priority fee or estimate it
     const currentPriorityFee = priorityFeePerCU ?? (await this.estimateGasPrice());
 
@@ -1312,18 +1312,12 @@ export class Solana {
     if (confirmed && txData) {
       const actualFee = this.getFee(txData);
       logger.info(`Transaction ${signature} confirmed with total fee: ${actualFee.toFixed(6)} SOL`);
-      return { signature, fee: actualFee, confirmed: true };
+      return { signature, fee: actualFee };
     }
 
-    // Transaction was sent but not confirmed - return signature with confirmed=false
-    // instead of throwing, so caller can decide what to do (retry, return pending status, etc.)
-    if (signature) {
-      logger.warn(`Transaction ${signature} sent but not confirmed after ${this.config.confirmRetryCount} attempts`);
-      return { signature, fee: 0, confirmed: false };
-    }
-
-    // No signature means transaction was never sent successfully
-    throw httpErrors.transactionTimeout(`Transaction failed to send after ${this.config.confirmRetryCount} attempts`);
+    throw httpErrors.transactionTimeout(
+      `Transaction failed to confirm after ${this.config.confirmRetryCount} attempts`,
+    );
   }
 
   private async prepareTx(
diff --git a/src/connectors/meteora/clmm-routes/addLiquidity.ts b/src/connectors/meteora/clmm-routes/addLiquidity.ts
index 679b6b5152..1cecbda4d5 100644
--- a/src/connectors/meteora/clmm-routes/addLiquidity.ts
+++ b/src/connectors/meteora/clmm-routes/addLiquidity.ts
@@ -122,16 +122,7 @@ export async function addLiquidity(
 
   // Send and confirm transaction using sendAndConfirmTransaction which handles signing
   // Transaction will automatically simulate to determine optimal compute units
-  const { signature, fee, confirmed: txConfirmed } = await solana.sendAndConfirmTransaction(addLiquidityTx, [wallet]);
-
-  // If transaction wasn't confirmed, return pending status
-  if (txConfirmed === false) {
-    logger.warn(`Transaction ${signature} sent but not confirmed`);
-    return {
-      signature,
-      status: 0, // PENDING
-    };
-  }
+  const { signature, fee } = await solana.sendAndConfirmTransaction(addLiquidityTx, [wallet]);
 
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
diff --git a/src/connectors/meteora/clmm-routes/closePosition.ts b/src/connectors/meteora/clmm-routes/closePosition.ts
index c76e00fbae..b1bc498902 100644
--- a/src/connectors/meteora/clmm-routes/closePosition.ts
+++ b/src/connectors/meteora/clmm-routes/closePosition.ts
@@ -65,8 +65,6 @@ export async function closePosition(
     let totalFee = 0;
     let lastSignature = '';
 
-    let txConfirmed = true;
-
     for (let i = 0; i < transactions.length; i++) {
       const tx = transactions[i];
       if (transactions.length > 1) {
@@ -85,24 +83,10 @@ export async function closePosition(
       const result = await solana.sendAndConfirmTransaction(tx, [wallet]);
       totalFee += result.fee;
       lastSignature = result.signature;
-
-      // Track if any transaction didn't confirm
-      if (result.confirmed === false) {
-        txConfirmed = false;
-      }
     }
 
     const signature = lastSignature;
 
-    // If any transaction wasn't confirmed, return pending status
-    if (!txConfirmed) {
-      logger.warn(`Transaction ${signature} sent but not confirmed`);
-      return {
-        signature,
-        status: 0, // PENDING
-      };
-    }
-
     // Get transaction data for confirmation
     const txData = await solana.connection.getTransaction(signature, {
       commitment: 'confirmed',
diff --git a/src/connectors/meteora/clmm-routes/collectFees.ts b/src/connectors/meteora/clmm-routes/collectFees.ts
index f4758ab675..2141149a67 100644
--- a/src/connectors/meteora/clmm-routes/collectFees.ts
+++ b/src/connectors/meteora/clmm-routes/collectFees.ts
@@ -55,7 +55,6 @@ export async function collectFees(
   // Simulate and send all transactions
   let totalFee = 0;
   let lastSignature = '';
-  let txConfirmed = true;
 
   for (const tx of transactions) {
     // Simulate with error handling
@@ -64,28 +63,14 @@ export async function collectFees(
     logger.info('Transaction simulated successfully, sending to network...');
 
     // Send and confirm transaction using sendAndConfirmTransaction which handles signing
-    const result = await solana.sendAndConfirmTransaction(tx, [wallet]);
-    lastSignature = result.signature;
-    totalFee += result.fee;
-
-    // Track if any transaction didn't confirm
-    if (result.confirmed === false) {
-      txConfirmed = false;
-    }
+    const { signature, fee } = await solana.sendAndConfirmTransaction(tx, [wallet]);
+    lastSignature = signature;
+    totalFee += fee;
   }
 
   const signature = lastSignature;
   const fee = totalFee;
 
-  // If any transaction wasn't confirmed, return pending status
-  if (!txConfirmed) {
-    logger.warn(`Transaction ${signature} sent but not confirmed`);
-    return {
-      signature,
-      status: 0, // PENDING
-    };
-  }
-
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
     commitment: 'confirmed',
diff --git a/src/connectors/meteora/clmm-routes/openPosition.ts b/src/connectors/meteora/clmm-routes/openPosition.ts
index b8100fea18..824483c4a6 100644
--- a/src/connectors/meteora/clmm-routes/openPosition.ts
+++ b/src/connectors/meteora/clmm-routes/openPosition.ts
@@ -160,27 +160,10 @@ export async function openPosition(
 
   // Send and confirm the ORIGINAL unsigned transaction
   // sendAndConfirmTransaction will handle the signing and auto-simulate for optimal compute units
-  const {
-    signature,
-    fee: txFee,
-    confirmed: txConfirmed,
-  } = await solana.sendAndConfirmTransaction(createPositionTx, [wallet, newImbalancePosition]);
-
-  // If transaction wasn't confirmed, return pending status with position address
-  if (txConfirmed === false) {
-    logger.warn(`Transaction ${signature} sent but not confirmed`);
-    return {
-      signature,
-      status: 0, // PENDING
-      data: {
-        fee: 0,
-        positionAddress: newImbalancePosition.publicKey.toBase58(),
-        positionRent: 0,
-        baseTokenAmountAdded: 0,
-        quoteTokenAmountAdded: 0,
-      },
-    };
-  }
+  const { signature, fee: txFee } = await solana.sendAndConfirmTransaction(createPositionTx, [
+    wallet,
+    newImbalancePosition,
+  ]);
 
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
diff --git a/src/connectors/meteora/clmm-routes/removeLiquidity.ts b/src/connectors/meteora/clmm-routes/removeLiquidity.ts
index db5d494ce8..6c7b7fa44c 100644
--- a/src/connectors/meteora/clmm-routes/removeLiquidity.ts
+++ b/src/connectors/meteora/clmm-routes/removeLiquidity.ts
@@ -72,7 +72,6 @@ export async function removeLiquidity(
 
   let totalFee = 0;
   let lastSignature = '';
-  let txConfirmed = true;
 
   for (let i = 0; i < transactions.length; i++) {
     const tx = transactions[i];
@@ -91,25 +90,11 @@ export async function removeLiquidity(
     const result = await solana.sendAndConfirmTransaction(tx, [wallet]);
     totalFee += result.fee;
     lastSignature = result.signature;
-
-    // Track if any transaction didn't confirm
-    if (result.confirmed === false) {
-      txConfirmed = false;
-    }
   }
 
   const signature = lastSignature;
   const fee = totalFee;
 
-  // If any transaction wasn't confirmed, return pending status
-  if (!txConfirmed) {
-    logger.warn(`Transaction ${signature} sent but not confirmed`);
-    return {
-      signature,
-      status: 0, // PENDING
-    };
-  }
-
   // Get transaction data for confirmation
   const txData = await solana.connection.getTransaction(signature, {
     commitment: 'confirmed',

From d72abb71e3bf63846fdd9094c89e1660ac94f31e Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 14 Jan 2026 19:36:01 -0800
Subject: [PATCH 08/37] fix: separate tx fee and rent from token amounts in
 Meteora CLMM

When SOL is base/quote token, wallet balance changes include the
transaction fee and position rent. This fix properly separates these:

- openPosition: Use requested amounts, calculate rent separately
- closePosition: Track rent refund separately from liquidity
- addLiquidity: Subtract fee from SOL token amount
- removeLiquidity: Add fee back to SOL token amount

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../meteora/clmm-routes/addLiquidity.ts       | 22 ++++++---
 .../meteora/clmm-routes/closePosition.ts      | 37 +++++++++++----
 .../meteora/clmm-routes/openPosition.ts       | 47 ++++++++++++-------
 .../meteora/clmm-routes/removeLiquidity.ts    | 20 ++++++--
 4 files changed, 91 insertions(+), 35 deletions(-)

diff --git a/src/connectors/meteora/clmm-routes/addLiquidity.ts b/src/connectors/meteora/clmm-routes/addLiquidity.ts
index 1cecbda4d5..78137538a7 100644
--- a/src/connectors/meteora/clmm-routes/addLiquidity.ts
+++ b/src/connectors/meteora/clmm-routes/addLiquidity.ts
@@ -133,24 +133,34 @@ export async function addLiquidity(
   const confirmed = txData !== null;
 
   if (confirmed && txData) {
-    const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, dlmmPool.pubkey.toBase58(), [
+    // Track wallet's balance changes for the tokens
+    const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
       dlmmPool.tokenX.publicKey.toBase58(),
       dlmmPool.tokenY.publicKey.toBase58(),
     ]);
 
-    const tokenXAddedAmount = balanceChanges[0];
-    const tokenYAddedAmount = balanceChanges[1];
+    // Balance changes are negative (tokens leaving wallet)
+    let tokenXAddedAmount = Math.abs(balanceChanges[0]);
+    let tokenYAddedAmount = Math.abs(balanceChanges[1]);
+
+    // When SOL is base/quote, wallet pays: liquidity + tx fee
+    // Subtract fee to get actual liquidity added
+    if (tokenXSymbol === 'SOL') {
+      tokenXAddedAmount -= fee;
+    } else if (tokenYSymbol === 'SOL') {
+      tokenYAddedAmount -= fee;
+    }
 
     logger.info(
-      `Liquidity added to position ${positionAddress}: ${Math.abs(tokenXAddedAmount).toFixed(4)} ${tokenXSymbol}, ${Math.abs(tokenYAddedAmount).toFixed(4)} ${tokenYSymbol}`,
+      `Liquidity added to position ${positionAddress}: ${tokenXAddedAmount.toFixed(4)} ${tokenXSymbol}, ${tokenYAddedAmount.toFixed(4)} ${tokenYSymbol}`,
     );
 
     return {
       signature,
       status: 1, // CONFIRMED
       data: {
-        baseTokenAmountAdded: Math.abs(tokenXAddedAmount),
-        quoteTokenAmountAdded: Math.abs(tokenYAddedAmount),
+        baseTokenAmountAdded: tokenXAddedAmount,
+        quoteTokenAmountAdded: tokenYAddedAmount,
         fee,
       },
     };
diff --git a/src/connectors/meteora/clmm-routes/closePosition.ts b/src/connectors/meteora/clmm-routes/closePosition.ts
index b1bc498902..03baa27e99 100644
--- a/src/connectors/meteora/clmm-routes/closePosition.ts
+++ b/src/connectors/meteora/clmm-routes/closePosition.ts
@@ -98,24 +98,45 @@ export async function closePosition(
     if (confirmed && txData) {
       logger.info(`Position ${positionAddress} closed successfully with signature: ${signature}`);
 
-      // Extract balance changes for the tokens
+      // Track wallet's balance changes for the tokens
       const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
         dlmmPool.tokenX.publicKey.toBase58(),
         dlmmPool.tokenY.publicKey.toBase58(),
-        'So11111111111111111111111111111111111111112', // SOL (for rent refund)
       ]);
 
-      const totalTokenXReceived = Math.abs(balanceChanges[0]);
-      const totalTokenYReceived = Math.abs(balanceChanges[1]);
-      const returnedSOL = Math.abs(balanceChanges[2]);
+      // Balance changes are positive (tokens entering wallet)
+      let totalTokenXReceived = Math.abs(balanceChanges[0]);
+      let totalTokenYReceived = Math.abs(balanceChanges[1]);
+
+      // When SOL is base/quote, wallet receives: liquidity + fees + rent refund - tx fee
+      // We need to separate rent refund from the token amounts
+      let positionRentRefunded = 0;
+      if (tokenXSymbol === 'SOL') {
+        // SOL is base token
+        // Total SOL received = liquidity + fees + rent - tx fee
+        // We know fees from positionInfo, so:
+        // rent = total received + tx fee - liquidity - fees
+        // But we don't know liquidity separately, so use positionInfo.baseTokenAmount
+        const expectedLiquidity = positionInfo.baseTokenAmount;
+        positionRentRefunded = totalTokenXReceived + totalFee - expectedLiquidity - baseFeeAmount;
+        if (positionRentRefunded < 0) positionRentRefunded = 0;
+        // Adjust to exclude rent refund from token received
+        totalTokenXReceived = totalTokenXReceived - positionRentRefunded + totalFee;
+      } else if (tokenYSymbol === 'SOL') {
+        // SOL is quote token
+        const expectedLiquidity = positionInfo.quoteTokenAmount;
+        positionRentRefunded = totalTokenYReceived + totalFee - expectedLiquidity - quoteFeeAmount;
+        if (positionRentRefunded < 0) positionRentRefunded = 0;
+        totalTokenYReceived = totalTokenYReceived - positionRentRefunded + totalFee;
+      }
 
       // Separate fees from liquidity amounts
-      // Total received = liquidity removed + fees collected
+      // Total received (after rent adjustment) = liquidity removed + fees collected
       const baseTokenAmountRemoved = Math.max(0, totalTokenXReceived - baseFeeAmount);
       const quoteTokenAmountRemoved = Math.max(0, totalTokenYReceived - quoteFeeAmount);
 
       logger.info(
-        `Position closed: ${baseTokenAmountRemoved.toFixed(4)} ${tokenXSymbol} + ${baseFeeAmount.toFixed(4)} ${tokenXSymbol} fees, ${quoteTokenAmountRemoved.toFixed(4)} ${tokenYSymbol} + ${quoteFeeAmount.toFixed(4)} ${tokenYSymbol} fees, ${returnedSOL.toFixed(9)} SOL rent refunded`,
+        `Position closed: ${baseTokenAmountRemoved.toFixed(4)} ${tokenXSymbol} + ${baseFeeAmount.toFixed(4)} ${tokenXSymbol} fees, ${quoteTokenAmountRemoved.toFixed(4)} ${tokenYSymbol} + ${quoteFeeAmount.toFixed(4)} ${tokenYSymbol} fees, ${positionRentRefunded.toFixed(6)} SOL rent refunded`,
       );
 
       return {
@@ -123,7 +144,7 @@ export async function closePosition(
         status: 1, // CONFIRMED
         data: {
           fee: totalFee,
-          positionRentRefunded: returnedSOL,
+          positionRentRefunded: positionRentRefunded,
           baseTokenAmountRemoved,
           quoteTokenAmountRemoved,
           baseFeeAmountCollected: baseFeeAmount,
diff --git a/src/connectors/meteora/clmm-routes/openPosition.ts b/src/connectors/meteora/clmm-routes/openPosition.ts
index 824483c4a6..eccbf80cc1 100644
--- a/src/connectors/meteora/clmm-routes/openPosition.ts
+++ b/src/connectors/meteora/clmm-routes/openPosition.ts
@@ -174,24 +174,39 @@ export async function openPosition(
   const confirmed = txData !== null;
 
   if (confirmed && txData) {
+    // Track wallet's balance changes for the tokens
     const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
-      tokenX?.address || dlmmPool.tokenX.publicKey.toBase58(),
-      tokenY?.address || dlmmPool.tokenY.publicKey.toBase58(),
+      dlmmPool.tokenX.publicKey.toBase58(),
+      dlmmPool.tokenY.publicKey.toBase58(),
     ]);
 
-    const baseTokenBalanceChange = balanceChanges[0];
-    const quoteTokenBalanceChange = balanceChanges[1];
-
-    // Calculate sentSOL based on which token is SOL
-    const sentSOL =
-      tokenXSymbol === 'SOL'
-        ? Math.abs(baseTokenBalanceChange - txFee)
-        : tokenYSymbol === 'SOL'
-          ? Math.abs(quoteTokenBalanceChange - txFee)
-          : txFee;
+    // Balance changes are negative (tokens leaving wallet)
+    let baseAmountAdded = Math.abs(balanceChanges[0]);
+    let quoteAmountAdded = Math.abs(balanceChanges[1]);
+
+    // Calculate position rent for new positions
+    // When SOL is base/quote, wallet balance change includes: liquidity + rent + fee
+    // We need to separate rent from liquidity
+    let positionRent = 0;
+    if (tokenXSymbol === 'SOL') {
+      // SOL is base token - subtract fee and rent from balance change
+      // Rent = total spent - fee - actual liquidity (what user requested)
+      const totalSOLSpent = baseAmountAdded;
+      const requestedLiquidity = baseTokenAmount || 0;
+      positionRent = totalSOLSpent - txFee - requestedLiquidity;
+      if (positionRent < 0) positionRent = 0;
+      baseAmountAdded = requestedLiquidity;
+    } else if (tokenYSymbol === 'SOL') {
+      // SOL is quote token
+      const totalSOLSpent = quoteAmountAdded;
+      const requestedLiquidity = quoteTokenAmount || 0;
+      positionRent = totalSOLSpent - txFee - requestedLiquidity;
+      if (positionRent < 0) positionRent = 0;
+      quoteAmountAdded = requestedLiquidity;
+    }
 
     logger.info(
-      `Position opened at ${newImbalancePosition.publicKey.toBase58()}: ${Math.abs(baseTokenBalanceChange).toFixed(4)} ${tokenXSymbol}, ${Math.abs(quoteTokenBalanceChange).toFixed(4)} ${tokenYSymbol}`,
+      `Position opened at ${newImbalancePosition.publicKey.toBase58()}: ${baseAmountAdded.toFixed(4)} ${tokenXSymbol}, ${quoteAmountAdded.toFixed(4)} ${tokenYSymbol}, rent: ${positionRent.toFixed(6)} SOL`,
     );
 
     return {
@@ -200,9 +215,9 @@ export async function openPosition(
       data: {
         fee: txFee,
         positionAddress: newImbalancePosition.publicKey.toBase58(),
-        positionRent: sentSOL,
-        baseTokenAmountAdded: baseTokenBalanceChange,
-        quoteTokenAmountAdded: quoteTokenBalanceChange,
+        positionRent: positionRent,
+        baseTokenAmountAdded: baseAmountAdded,
+        quoteTokenAmountAdded: quoteAmountAdded,
       },
     };
   } else {
diff --git a/src/connectors/meteora/clmm-routes/removeLiquidity.ts b/src/connectors/meteora/clmm-routes/removeLiquidity.ts
index 6c7b7fa44c..fc17a997b8 100644
--- a/src/connectors/meteora/clmm-routes/removeLiquidity.ts
+++ b/src/connectors/meteora/clmm-routes/removeLiquidity.ts
@@ -104,16 +104,26 @@ export async function removeLiquidity(
   const confirmed = txData !== null;
 
   if (confirmed && txData) {
+    // Track wallet's balance changes for the tokens
     const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
       dlmmPool.tokenX.publicKey.toBase58(),
       dlmmPool.tokenY.publicKey.toBase58(),
     ]);
 
-    const tokenXRemovedAmount = balanceChanges[0];
-    const tokenYRemovedAmount = balanceChanges[1];
+    // Balance changes are positive (tokens entering wallet)
+    let tokenXRemovedAmount = Math.abs(balanceChanges[0]);
+    let tokenYRemovedAmount = Math.abs(balanceChanges[1]);
+
+    // When SOL is base/quote, wallet receives: liquidity - tx fee
+    // Add back the fee to get actual liquidity removed
+    if (tokenXSymbol === 'SOL') {
+      tokenXRemovedAmount += fee;
+    } else if (tokenYSymbol === 'SOL') {
+      tokenYRemovedAmount += fee;
+    }
 
     logger.info(
-      `Liquidity removed from position ${positionAddress}: ${Math.abs(tokenXRemovedAmount).toFixed(4)} ${tokenXSymbol}, ${Math.abs(tokenYRemovedAmount).toFixed(4)} ${tokenYSymbol}`,
+      `Liquidity removed from position ${positionAddress}: ${tokenXRemovedAmount.toFixed(4)} ${tokenXSymbol}, ${tokenYRemovedAmount.toFixed(4)} ${tokenYSymbol}`,
     );
 
     return {
@@ -121,8 +131,8 @@ export async function removeLiquidity(
       status: 1, // CONFIRMED
       data: {
         fee,
-        baseTokenAmountRemoved: Math.abs(tokenXRemovedAmount),
-        quoteTokenAmountRemoved: Math.abs(tokenYRemovedAmount),
+        baseTokenAmountRemoved: tokenXRemovedAmount,
+        quoteTokenAmountRemoved: tokenYRemovedAmount,
       },
     };
   } else {

From b885211618529f6c25bb8537ee1f327596e71ade Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Thu, 15 Jan 2026 07:37:04 -0800
Subject: [PATCH 09/37] feat: distinguish 'Position closed' vs 'Position not
 found' errors

Check transaction history to determine if a position was closed
(had transactions) vs never existed (no transactions).

This helps clients recognize when a close operation timed out but
actually succeeded on-chain.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/connectors/meteora/meteora.ts | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/connectors/meteora/meteora.ts b/src/connectors/meteora/meteora.ts
index eb756d5954..8d9577d11d 100644
--- a/src/connectors/meteora/meteora.ts
+++ b/src/connectors/meteora/meteora.ts
@@ -347,7 +347,15 @@ export class Meteora {
     const positionAccount = await this.solana.connection.getAccountInfo(positionPubkey);
 
     if (!positionAccount) {
-      throw httpErrors.notFound(`Position not found or closed: ${positionAddress}`);
+      // Check if the position ever existed by looking at transaction history
+      const signatures = await this.solana.connection.getSignaturesForAddress(positionPubkey, { limit: 1 });
+      if (signatures.length > 0) {
+        // Position had transactions, so it was created and later closed
+        throw httpErrors.notFound(`Position closed: ${positionAddress}`);
+      } else {
+        // No transactions found, position never existed
+        throw httpErrors.notFound(`Position not found: ${positionAddress}`);
+      }
     }
 
     // Parse the position account to extract the pool address (lbPair)

From 22367fdaed4ccbfd4e31bdbfbe55ef69d2f1d0ea Mon Sep 17 00:00:00 2001
From: Ralph Comia <ralph@hummingbot.org>
Date: Tue, 27 Jan 2026 15:57:10 +0800
Subject: [PATCH 10/37] Update GATEWAY_VERSION to dev-2.13.0

---
 src/version.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/version.ts b/src/version.ts
index 6473560dfc..e96e8f79d8 100644
--- a/src/version.ts
+++ b/src/version.ts
@@ -1,3 +1,3 @@
 // Gateway version constant
 // Change this version for each release
-export const GATEWAY_VERSION = 'dev-2.12.0';
+export const GATEWAY_VERSION = 'dev-2.13.0';

From 8667a386fcda0f5f274435ec12eb115dbb177c7e Mon Sep 17 00:00:00 2001
From: Ralph Comia <ralph@hummingbot.org>
Date: Tue, 27 Jan 2026 15:57:34 +0800
Subject: [PATCH 11/37] Bump version from dev-2.12.0 to dev-2.13.0

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 4ebc20cb21..8e322ebcaa 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "gateway",
-  "version": "dev-2.12.0",
+  "version": "dev-2.13.0",
   "description": "Hummingbot Gateway is an API server that helps you interact with DEXs and blockchains.",
   "main": "index.js",
   "license": "Apache-2.0",

From 4e223872744757ddc0c8600bafc67f19b7bcbb46 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 15:13:06 -0700
Subject: [PATCH 12/37] feat: merge chain config into network config for GET
 /config

- GET /config?namespace=solana-mainnet-beta now returns merged chain + network config
- POST /config/update routes chain-level fields (defaultWallet, defaultNetwork, rpcProvider) to parent chain namespace
- Add comprehensive tests for chain-network config merging and routing

Chain-level fields that get routed:
- solana: defaultNetwork, defaultWallet, rpcProvider
- ethereum: defaultNetwork, defaultWallet

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/config/utils.ts              |  58 ++++++++
 test/config/config-utils.test.ts | 248 +++++++++++++++++++++++++++++++
 2 files changed, 306 insertions(+)
 create mode 100644 test/config/config-utils.test.ts

diff --git a/src/config/utils.ts b/src/config/utils.ts
index 3b649750d1..8b978f0ede 100644
--- a/src/config/utils.ts
+++ b/src/config/utils.ts
@@ -7,6 +7,32 @@ import * as yaml from 'js-yaml';
 import { ConfigManagerV2 } from '../services/config-manager-v2';
 import { logger } from '../services/logger';
 
+// Chain-level config fields that should be merged into network config
+// and routed to the chain namespace for updates
+const CHAIN_LEVEL_FIELDS: Record<string, string[]> = {
+  solana: ['defaultNetwork', 'defaultWallet', 'rpcProvider'],
+  ethereum: ['defaultNetwork', 'defaultWallet'],
+};
+
+/**
+ * Parse a chain-network namespace format into chain and network components.
+ * Returns null if not a chain-network format.
+ */
+function parseChainNetwork(namespace: string): { chain: string; network: string } | null {
+  // Known chains
+  const knownChains = ['solana', 'ethereum'];
+
+  for (const chain of knownChains) {
+    if (namespace.startsWith(`${chain}-`)) {
+      const network = namespace.slice(chain.length + 1);
+      if (network) {
+        return { chain, network };
+      }
+    }
+  }
+  return null;
+}
+
 export const getConfig = (fastify: FastifyInstance, namespace?: string): object => {
   if (namespace) {
     logger.info(`Getting configuration for namespace: ${namespace}`);
@@ -16,6 +42,20 @@ export const getConfig = (fastify: FastifyInstance, namespace?: string): object
       throw fastify.httpErrors.notFound(`Namespace '${namespace}' not found`);
     }
 
+    // Check if this is a chain-network format (e.g., solana-mainnet-beta)
+    const parsed = parseChainNetwork(namespace);
+    if (parsed) {
+      // Get the parent chain config and merge it
+      const chainConfig = ConfigManagerV2.getInstance().getNamespace(parsed.chain);
+      if (chainConfig) {
+        // Merge chain config into network config (network config takes precedence for conflicts)
+        return {
+          ...chainConfig.configuration,
+          ...namespaceConfig.configuration,
+        };
+      }
+    }
+
     return namespaceConfig.configuration;
   }
 
@@ -27,6 +67,24 @@ export const updateConfig = (fastify: FastifyInstance, configPath: string, confi
   logger.info(`Updating config path: ${configPath} with value: ${JSON.stringify(configValue)}`);
 
   try {
+    // Check if the configPath uses a chain-network namespace with a chain-level field
+    // e.g., "solana-mainnet-beta.defaultWallet" should route to "solana.defaultWallet"
+    const [namespace, ...pathParts] = configPath.split('.');
+    const field = pathParts[0];
+
+    const parsed = parseChainNetwork(namespace);
+    if (parsed && field) {
+      const chainFields = CHAIN_LEVEL_FIELDS[parsed.chain] || [];
+      if (chainFields.includes(field)) {
+        // Route to the chain namespace instead
+        const chainConfigPath = `${parsed.chain}.${pathParts.join('.')}`;
+        logger.info(`Routing chain-level field to: ${chainConfigPath}`);
+        ConfigManagerV2.getInstance().set(chainConfigPath, configValue);
+        logger.info(`Successfully updated configuration: ${chainConfigPath}`);
+        return;
+      }
+    }
+
     // Update the configuration using ConfigManagerV2
     ConfigManagerV2.getInstance().set(configPath, configValue);
     logger.info(`Successfully updated configuration: ${configPath}`);
diff --git a/test/config/config-utils.test.ts b/test/config/config-utils.test.ts
new file mode 100644
index 0000000000..242f7f6701
--- /dev/null
+++ b/test/config/config-utils.test.ts
@@ -0,0 +1,248 @@
+import Fastify, { FastifyInstance } from 'fastify';
+
+// Mock dependencies
+jest.mock('../../src/services/logger', () => ({
+  logger: {
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+// Create mock configuration namespaces
+const mockSolanaChainConfig = {
+  configuration: {
+    defaultNetwork: 'mainnet-beta',
+    defaultWallet: '82SggYRE2Vo4jN4a2pk3aQ4SET4ctafZJGbowmCqyHx5',
+    rpcProvider: 'helius',
+  },
+};
+
+const mockSolanaNetworkConfig = {
+  configuration: {
+    chainID: 101,
+    nodeURL: 'https://api.mainnet-beta.solana.com',
+    nativeCurrencySymbol: 'SOL',
+    geckoId: 'solana',
+  },
+};
+
+const mockEthereumChainConfig = {
+  configuration: {
+    defaultNetwork: 'mainnet',
+    defaultWallet: '0x1234567890abcdef1234567890abcdef12345678',
+  },
+};
+
+const mockEthereumNetworkConfig = {
+  configuration: {
+    chainID: 1,
+    nodeURL: 'https://mainnet.infura.io/v3/xxx',
+    nativeCurrencySymbol: 'ETH',
+    geckoId: 'ethereum',
+  },
+};
+
+const mockSetFn = jest.fn();
+
+jest.mock('../../src/services/config-manager-v2', () => ({
+  ConfigManagerV2: {
+    getInstance: jest.fn().mockReturnValue({
+      getNamespace: jest.fn((namespace: string) => {
+        const namespaces: Record<string, any> = {
+          solana: mockSolanaChainConfig,
+          'solana-mainnet-beta': mockSolanaNetworkConfig,
+          'solana-devnet': {
+            configuration: {
+              chainID: 103,
+              nodeURL: 'https://api.devnet.solana.com',
+              nativeCurrencySymbol: 'SOL',
+              geckoId: 'solana',
+            },
+          },
+          ethereum: mockEthereumChainConfig,
+          'ethereum-mainnet': mockEthereumNetworkConfig,
+          server: {
+            configuration: {
+              port: 15888,
+            },
+          },
+        };
+        return namespaces[namespace] || null;
+      }),
+      set: mockSetFn,
+      allConfigurations: {
+        solana: mockSolanaChainConfig.configuration,
+        'solana-mainnet-beta': mockSolanaNetworkConfig.configuration,
+        ethereum: mockEthereumChainConfig.configuration,
+        'ethereum-mainnet': mockEthereumNetworkConfig.configuration,
+        server: { port: 15888 },
+      },
+    }),
+  },
+}));
+
+// Import after mocking
+import { getConfig, updateConfig } from '../../src/config/utils';
+import { ConfigManagerV2 } from '../../src/services/config-manager-v2';
+
+describe('Config Utils - Chain-Network Merge', () => {
+  let fastify: FastifyInstance;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+    jest.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  describe('getConfig - chain-network merging', () => {
+    it('should merge solana chain config into solana-mainnet-beta network config', () => {
+      const config = getConfig(fastify, 'solana-mainnet-beta');
+
+      // Should contain chain-level fields
+      expect(config).toHaveProperty('defaultNetwork', 'mainnet-beta');
+      expect(config).toHaveProperty('defaultWallet', '82SggYRE2Vo4jN4a2pk3aQ4SET4ctafZJGbowmCqyHx5');
+      expect(config).toHaveProperty('rpcProvider', 'helius');
+
+      // Should contain network-level fields
+      expect(config).toHaveProperty('chainID', 101);
+      expect(config).toHaveProperty('nodeURL', 'https://api.mainnet-beta.solana.com');
+      expect(config).toHaveProperty('nativeCurrencySymbol', 'SOL');
+      expect(config).toHaveProperty('geckoId', 'solana');
+    });
+
+    it('should merge solana chain config into solana-devnet network config', () => {
+      const config = getConfig(fastify, 'solana-devnet');
+
+      // Should contain chain-level fields from solana
+      expect(config).toHaveProperty('defaultNetwork', 'mainnet-beta');
+      expect(config).toHaveProperty('defaultWallet', '82SggYRE2Vo4jN4a2pk3aQ4SET4ctafZJGbowmCqyHx5');
+
+      // Should contain devnet-specific network fields
+      expect(config).toHaveProperty('chainID', 103);
+      expect(config).toHaveProperty('nodeURL', 'https://api.devnet.solana.com');
+    });
+
+    it('should merge ethereum chain config into ethereum-mainnet network config', () => {
+      const config = getConfig(fastify, 'ethereum-mainnet');
+
+      // Should contain chain-level fields
+      expect(config).toHaveProperty('defaultNetwork', 'mainnet');
+      expect(config).toHaveProperty('defaultWallet', '0x1234567890abcdef1234567890abcdef12345678');
+
+      // Should contain network-level fields
+      expect(config).toHaveProperty('chainID', 1);
+      expect(config).toHaveProperty('nodeURL', 'https://mainnet.infura.io/v3/xxx');
+      expect(config).toHaveProperty('nativeCurrencySymbol', 'ETH');
+    });
+
+    it('should return only chain config for non-network namespaces (solana)', () => {
+      const config = getConfig(fastify, 'solana');
+
+      expect(config).toHaveProperty('defaultNetwork', 'mainnet-beta');
+      expect(config).toHaveProperty('defaultWallet');
+      expect(config).toHaveProperty('rpcProvider');
+
+      // Should NOT have network-level fields
+      expect(config).not.toHaveProperty('chainID');
+      expect(config).not.toHaveProperty('nodeURL');
+    });
+
+    it('should return only namespace config for non-chain namespaces (server)', () => {
+      const config = getConfig(fastify, 'server');
+
+      expect(config).toHaveProperty('port', 15888);
+      expect(config).not.toHaveProperty('defaultWallet');
+      expect(config).not.toHaveProperty('chainID');
+    });
+
+    it('should return all configurations when no namespace provided', () => {
+      const config = getConfig(fastify);
+
+      expect(config).toHaveProperty('solana');
+      expect(config).toHaveProperty('solana-mainnet-beta');
+      expect(config).toHaveProperty('ethereum');
+      expect(config).toHaveProperty('server');
+    });
+
+    it('should throw 404 for non-existent namespace', () => {
+      expect(() => getConfig(fastify, 'invalid-namespace')).toThrow();
+    });
+
+    it('should let network config override chain config if keys conflict', () => {
+      // Network config takes precedence over chain config for conflicts
+      const config = getConfig(fastify, 'solana-mainnet-beta');
+
+      // Both chain and network might have overlapping keys in the future
+      // The spread operator gives network config precedence: {...chain, ...network}
+      // This test ensures the merge order is correct
+      expect(config).toBeDefined();
+    });
+  });
+
+  describe('updateConfig - chain-level field routing', () => {
+    beforeEach(() => {
+      mockSetFn.mockClear();
+    });
+
+    it('should route defaultWallet update from solana-mainnet-beta to solana namespace', () => {
+      updateConfig(fastify, 'solana-mainnet-beta.defaultWallet', 'newWalletAddress123');
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana.defaultWallet', 'newWalletAddress123');
+    });
+
+    it('should route defaultNetwork update from solana-mainnet-beta to solana namespace', () => {
+      updateConfig(fastify, 'solana-mainnet-beta.defaultNetwork', 'devnet');
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana.defaultNetwork', 'devnet');
+    });
+
+    it('should route rpcProvider update from solana-mainnet-beta to solana namespace', () => {
+      updateConfig(fastify, 'solana-mainnet-beta.rpcProvider', 'alchemy');
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana.rpcProvider', 'alchemy');
+    });
+
+    it('should route defaultWallet update from ethereum-mainnet to ethereum namespace', () => {
+      updateConfig(fastify, 'ethereum-mainnet.defaultWallet', '0xnewwallet');
+
+      expect(mockSetFn).toHaveBeenCalledWith('ethereum.defaultWallet', '0xnewwallet');
+    });
+
+    it('should NOT route non-chain-level fields (nodeURL stays in network namespace)', () => {
+      updateConfig(fastify, 'solana-mainnet-beta.nodeURL', 'https://new-rpc.com');
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana-mainnet-beta.nodeURL', 'https://new-rpc.com');
+    });
+
+    it('should NOT route chainID (network-level field)', () => {
+      updateConfig(fastify, 'solana-mainnet-beta.chainID', 102);
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana-mainnet-beta.chainID', 102);
+    });
+
+    it('should NOT route fields for non-chain-network namespaces (server)', () => {
+      updateConfig(fastify, 'server.port', 16000);
+
+      expect(mockSetFn).toHaveBeenCalledWith('server.port', 16000);
+    });
+
+    it('should NOT route fields for pure chain namespaces (solana)', () => {
+      updateConfig(fastify, 'solana.defaultWallet', 'directUpdate');
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana.defaultWallet', 'directUpdate');
+    });
+
+    it('should handle nested paths correctly for chain-level fields', () => {
+      // If someone tries to update a nested path like defaultWallet.something
+      // it should still route to the chain namespace
+      updateConfig(fastify, 'solana-mainnet-beta.defaultWallet', 'value');
+
+      expect(mockSetFn).toHaveBeenCalledWith('solana.defaultWallet', 'value');
+    });
+  });
+});

From 88548798864b385c5eb912b432f0cd4823fc0e45 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 15:42:04 -0700
Subject: [PATCH 13/37] feat: enable defaultNetworks and remove unused
 namespace copying

- Uncomment defaultNetworks in ethereum.yml and solana.yml templates
- Remove 'namespace' from templateDirectories since conf/namespace is
  never used for validation (schemas are loaded from dist/src/templates)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/services/config-manager-v2.ts | 2 +-
 src/templates/chains/ethereum.yml | 6 +++---
 src/templates/chains/solana.yml   | 5 ++---
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/services/config-manager-v2.ts b/src/services/config-manager-v2.ts
index b7ca53ddfd..d7c0668c2a 100644
--- a/src/services/config-manager-v2.ts
+++ b/src/services/config-manager-v2.ts
@@ -343,7 +343,7 @@ export class ConfigManagerV2 {
       };
 
       // Copy all template directories
-      const templateDirectories = ['chains', 'connectors', 'namespace', 'pools', 'tokens', 'rpc'];
+      const templateDirectories = ['chains', 'connectors', 'pools', 'tokens', 'rpc'];
       for (const dir of templateDirectories) {
         const targetPath = path.join(ConfigDir, dir);
         const templatePath = path.join(ConfigTemplatesDir, dir);
diff --git a/src/templates/chains/ethereum.yml b/src/templates/chains/ethereum.yml
index c96b5ca437..71e1447f5d 100644
--- a/src/templates/chains/ethereum.yml
+++ b/src/templates/chains/ethereum.yml
@@ -3,9 +3,9 @@ defaultWallet: '<ethereum-wallet-address>'
 
 # Optional: List of networks to query for balance operations
 # If not specified, only defaultNetwork is used
-# defaultNetworks:
-#   - mainnet
-#   - base
+defaultNetworks:
+  - mainnet
+  - base
 
 # RPC provider: 'url' uses nodeURL from network config, or specify a provider name (e.g., 'infura')
 rpcProvider: url
\ No newline at end of file
diff --git a/src/templates/chains/solana.yml b/src/templates/chains/solana.yml
index fdfd60186b..c33239b3ac 100644
--- a/src/templates/chains/solana.yml
+++ b/src/templates/chains/solana.yml
@@ -3,9 +3,8 @@ defaultWallet: '<solana-wallet-address>'
 
 # Optional: List of networks to query for balance operations
 # If not specified, only defaultNetwork is used
-# defaultNetworks:
-#   - mainnet-beta
-#   - devnet
+defaultNetworks:
+  - mainnet-beta
 
 # RPC provider: 'url' uses nodeURL from network config, or specify a provider name (e.g., 'helius')
 rpcProvider: url
\ No newline at end of file

From 4c48ab80fd0ef9b59acd9f54b376ff891d6d9aa5 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 15:51:34 -0700
Subject: [PATCH 14/37] refactor: dynamically detect chain-level fields for
 config routing

- Remove hardcoded CHAIN_LEVEL_FIELDS mapping
- Check if field exists in chain config to determine routing
- Add defaultNetworks to test mock data

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/config/utils.ts              | 18 ++++++------------
 test/config/config-utils.test.ts |  2 ++
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/config/utils.ts b/src/config/utils.ts
index 8b978f0ede..0a608192eb 100644
--- a/src/config/utils.ts
+++ b/src/config/utils.ts
@@ -7,22 +7,15 @@ import * as yaml from 'js-yaml';
 import { ConfigManagerV2 } from '../services/config-manager-v2';
 import { logger } from '../services/logger';
 
-// Chain-level config fields that should be merged into network config
-// and routed to the chain namespace for updates
-const CHAIN_LEVEL_FIELDS: Record<string, string[]> = {
-  solana: ['defaultNetwork', 'defaultWallet', 'rpcProvider'],
-  ethereum: ['defaultNetwork', 'defaultWallet'],
-};
+// Known blockchain chains for chain-network parsing
+const KNOWN_CHAINS = ['solana', 'ethereum'];
 
 /**
  * Parse a chain-network namespace format into chain and network components.
  * Returns null if not a chain-network format.
  */
 function parseChainNetwork(namespace: string): { chain: string; network: string } | null {
-  // Known chains
-  const knownChains = ['solana', 'ethereum'];
-
-  for (const chain of knownChains) {
+  for (const chain of KNOWN_CHAINS) {
     if (namespace.startsWith(`${chain}-`)) {
       const network = namespace.slice(chain.length + 1);
       if (network) {
@@ -74,8 +67,9 @@ export const updateConfig = (fastify: FastifyInstance, configPath: string, confi
 
     const parsed = parseChainNetwork(namespace);
     if (parsed && field) {
-      const chainFields = CHAIN_LEVEL_FIELDS[parsed.chain] || [];
-      if (chainFields.includes(field)) {
+      // Check if this field exists in the chain config (not network config)
+      const chainConfig = ConfigManagerV2.getInstance().getNamespace(parsed.chain);
+      if (chainConfig && field in chainConfig.configuration) {
         // Route to the chain namespace instead
         const chainConfigPath = `${parsed.chain}.${pathParts.join('.')}`;
         logger.info(`Routing chain-level field to: ${chainConfigPath}`);
diff --git a/test/config/config-utils.test.ts b/test/config/config-utils.test.ts
index 242f7f6701..331784e48e 100644
--- a/test/config/config-utils.test.ts
+++ b/test/config/config-utils.test.ts
@@ -14,6 +14,7 @@ jest.mock('../../src/services/logger', () => ({
 const mockSolanaChainConfig = {
   configuration: {
     defaultNetwork: 'mainnet-beta',
+    defaultNetworks: ['mainnet-beta'],
     defaultWallet: '82SggYRE2Vo4jN4a2pk3aQ4SET4ctafZJGbowmCqyHx5',
     rpcProvider: 'helius',
   },
@@ -31,6 +32,7 @@ const mockSolanaNetworkConfig = {
 const mockEthereumChainConfig = {
   configuration: {
     defaultNetwork: 'mainnet',
+    defaultNetworks: ['mainnet'],
     defaultWallet: '0x1234567890abcdef1234567890abcdef12345678',
   },
 };

From 7471f482c231223c078ec34ec67c3f653f13d3f9 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 16:15:09 -0700
Subject: [PATCH 15/37] fix: convert native ETH to WETH in quoteSwap for price
 queries

ETH (native token) is not in the token list because it's not an ERC20
contract. This caused price queries for ETH pairs to fail or return 0.

The fix converts ETH to WETH before token resolution since they have
equivalent value. This matches the existing pattern used in addLiquidity.

- Add native token detection using ethereum.nativeTokenSymbol
- Convert ETH to WETH for both baseToken and quoteToken (case-insensitive)
- Add tests for ETH-to-WETH conversion scenarios

Fixes #598

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../uniswap/router-routes/quoteSwap.ts        |  21 +++-
 .../universal-router-quoteSwap.test.ts        | 113 ++++++++++++++++++
 2 files changed, 130 insertions(+), 4 deletions(-)

diff --git a/src/connectors/uniswap/router-routes/quoteSwap.ts b/src/connectors/uniswap/router-routes/quoteSwap.ts
index 32693a64d0..16777324ab 100644
--- a/src/connectors/uniswap/router-routes/quoteSwap.ts
+++ b/src/connectors/uniswap/router-routes/quoteSwap.ts
@@ -28,13 +28,26 @@ async function quoteSwap(
   const ethereum = await Ethereum.getInstance(network);
   const uniswap = await Uniswap.getInstance(network);
 
+  // Convert native token (ETH) to WETH for quote purposes
+  // Native tokens aren't in the token list, but WETH has equivalent value
+  const nativeSymbol = ethereum.nativeTokenSymbol.toUpperCase();
+  const actualBaseToken = baseToken.toUpperCase() === nativeSymbol ? 'WETH' : baseToken;
+  const actualQuoteToken = quoteToken.toUpperCase() === nativeSymbol ? 'WETH' : quoteToken;
+
+  if (actualBaseToken !== baseToken || actualQuoteToken !== quoteToken) {
+    logger.info(
+      `[quoteSwap] Converted native token: ${baseToken}/${quoteToken} -> ${actualBaseToken}/${actualQuoteToken}`,
+    );
+  }
+
   // Resolve token symbols/addresses to token objects from local token list
-  const baseTokenInfo = await ethereum.getToken(baseToken);
-  const quoteTokenInfo = await ethereum.getToken(quoteToken);
+  const baseTokenInfo = await ethereum.getToken(actualBaseToken);
+  const quoteTokenInfo = await ethereum.getToken(actualQuoteToken);
 
   if (!baseTokenInfo || !quoteTokenInfo) {
-    logger.error(`[quoteSwap] Token not found: ${!baseTokenInfo ? baseToken : quoteToken}`);
-    throw httpErrors.notFound(sanitizeErrorMessage('Token not found: {}', !baseTokenInfo ? baseToken : quoteToken));
+    const missingToken = !baseTokenInfo ? actualBaseToken : actualQuoteToken;
+    logger.error(`[quoteSwap] Token not found: ${missingToken}`);
+    throw httpErrors.notFound(sanitizeErrorMessage('Token not found: {}', missingToken));
   }
 
   logger.debug(`[quoteSwap] Base token: ${baseTokenInfo.symbol} (${baseTokenInfo.address})`);
diff --git a/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts b/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts
index 3b2ae2dfc7..d4e3f198f8 100644
--- a/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts
+++ b/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts
@@ -81,6 +81,7 @@ describe('GET /quote-swap', () => {
     mockEthereum = {
       provider: mockProvider,
       chainId: 1,
+      nativeTokenSymbol: 'ETH',
       getToken: jest.fn().mockImplementation((symbol: string) => {
         const tokens: any = {
           WETH: mockWETH,
@@ -307,4 +308,116 @@ describe('GET /quote-swap', () => {
 
     expect(response.statusCode).toBe(500);
   });
+
+  describe('native token (ETH) to WETH conversion', () => {
+    it('should convert ETH baseToken to WETH and return valid quote', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'ETH',
+          quoteToken: 'USDC',
+          amount: '1',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      // Should use WETH address even though ETH was requested
+      expect(body).toHaveProperty('tokenIn', mockWETH.address);
+      expect(body).toHaveProperty('tokenOut', mockUSDC.address);
+      expect(body).toHaveProperty('amountIn', 1);
+      expect(body).toHaveProperty('amountOut');
+      expect(body.amountOut).toBeGreaterThan(0);
+    });
+
+    it('should convert ETH quoteToken to WETH and return valid quote', async () => {
+      // Update mock for ETH as quote token - SELL USDC for ETH
+      mockGetAlphaRouterQuote.mockResolvedValue({
+        route: { trade: { priceImpact: { toSignificant: () => '0.3' } } },
+        inputAmount: '3000',
+        outputAmount: '1',
+        priceImpact: 0.3,
+        routeString: 'USDC -> WETH',
+        gasEstimate: '300000',
+        gasEstimateUSD: '5.00',
+        methodParameters: {
+          calldata: '0x1234567890',
+          value: '0x0',
+          to: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+        },
+      });
+
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'USDC',
+          quoteToken: 'ETH',
+          amount: '3000',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      // Should use WETH address even though ETH was requested as quote
+      // SELL side: input=base (USDC), output=quote (ETH->WETH)
+      expect(body).toHaveProperty('tokenIn', mockUSDC.address);
+      expect(body).toHaveProperty('tokenOut', mockWETH.address);
+    });
+
+    it('should handle lowercase eth token symbol', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'eth',
+          quoteToken: 'USDC',
+          amount: '1',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      // Should convert lowercase 'eth' to WETH
+      expect(body).toHaveProperty('tokenIn', mockWETH.address);
+    });
+
+    it('should handle mixed case Eth token symbol', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'Eth',
+          quoteToken: 'USDC',
+          amount: '1',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      // Should convert mixed case 'Eth' to WETH
+      expect(body).toHaveProperty('tokenIn', mockWETH.address);
+    });
+  });
 });

From 42c55f8dd8d185a9315e3b7aca53c678dbef669e Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 16:18:32 -0700
Subject: [PATCH 16/37] chore: update @uniswap/smart-order-router to 4.31.10

Fixes "SwapRouter.swapERC20CallParameters is not a function" error
that occurred due to version mismatch between smart-order-router and
universal-router-sdk.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 package.json   |  2 +-
 pnpm-lock.yaml | 94 +++++++++++++++++++++++++-------------------------
 2 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/package.json b/package.json
index 8e322ebcaa..14bbbd6457 100644
--- a/package.json
+++ b/package.json
@@ -82,7 +82,7 @@
     "@uniswap/router-sdk": "^2.0.4",
     "@uniswap/sdk": "3.0.3",
     "@uniswap/sdk-core": "^5.9.0",
-    "@uniswap/smart-order-router": "^4.22.38",
+    "@uniswap/smart-order-router": "^4.31.10",
     "@uniswap/universal-router-sdk": "^4.19.6",
     "@uniswap/v2-sdk": "^4.15.2",
     "@uniswap/v3-core": "^1.0.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 87e684adf6..1c137c1107 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -152,8 +152,8 @@ importers:
         specifier: ^5.9.0
         version: 5.9.0
       '@uniswap/smart-order-router':
-        specifier: ^4.22.38
-        version: 4.22.38(bufferutil@4.0.9)(encoding@0.1.13)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(jsbi@3.2.5)(utf-8-validate@5.0.10)
+        specifier: ^4.31.10
+        version: 4.31.10(bufferutil@4.0.9)(encoding@0.1.13)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(jsbi@3.2.5)(utf-8-validate@5.0.10)
       '@uniswap/universal-router-sdk':
         specifier: ^4.19.6
         version: 4.19.6(bufferutil@4.0.9)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)
@@ -2702,19 +2702,19 @@ packages:
   '@uniswap/router-sdk@2.0.4':
     resolution: {integrity: sha512-MxCtD+g+2pzzd9rZ6HKTdv1ZK2mLjREoDRNAp9+F961zCCVhgJr9L1/6Hour27/xxCyljwmG83Zn1cSS054giw==}
 
-  '@uniswap/router-sdk@2.2.0':
-    resolution: {integrity: sha512-9xWepoISYXYyp9w2C1svegXsjqY0zO/qcheH1fizgHRJUJ3GQ5IbewOd9E6M0pTPlYOsIigOLIFXRCTDIbzu3w==}
+  '@uniswap/router-sdk@2.4.0':
+    resolution: {integrity: sha512-dfMJ/zRnZ+RqanKTUrKR129Z8It8MPFM2Fhtaop6+Vk7BURY8kiyPi/GIUnPmk7H0WSWhdaB+R7zJZR8wuhqlg==}
 
   '@uniswap/sdk-core@5.9.0':
     resolution: {integrity: sha512-OME7WR6+5QwQs45A2079r+/FS0zU944+JCQwUX9GyIriCxqw2pGu4F9IEqmlwD+zSIMml0+MJnJJ47pFgSyWDw==}
     engines: {node: '>=10'}
 
-  '@uniswap/sdk-core@7.7.2':
-    resolution: {integrity: sha512-0KqXw+y0opBo6eoPAEoLHEkNpOu0NG9gEk7GAYIGok+SHX89WlykWsRYeJKTg9tOwhLpcG9oHg8xZgQ390iOrA==}
+  '@uniswap/sdk-core@7.10.1':
+    resolution: {integrity: sha512-MOhGAjGMqrd95p+te6tBK8pHgHCVMRTs5imqZk2aTqLoKgu6KzEGllifHb70ME6I4Q2p9eIPpX3xjfh4MKFT2w==}
     engines: {node: '>=10'}
 
-  '@uniswap/sdk-core@7.9.0':
-    resolution: {integrity: sha512-HHUFNK3LMi4KMQCAiHkdUyL62g/nrZLvNT44CY8RN4p8kWO6XYWzqdQt6OcjCsIbhMZ/Ifhe6Py5oOoccg/jUQ==}
+  '@uniswap/sdk-core@7.7.2':
+    resolution: {integrity: sha512-0KqXw+y0opBo6eoPAEoLHEkNpOu0NG9gEk7GAYIGok+SHX89WlykWsRYeJKTg9tOwhLpcG9oHg8xZgQ390iOrA==}
     engines: {node: '>=10'}
 
   '@uniswap/sdk@3.0.3':
@@ -2727,8 +2727,8 @@ packages:
       '@ethersproject/providers': ^5.0.0-beta
       '@ethersproject/solidity': ^5.0.0-beta
 
-  '@uniswap/smart-order-router@4.22.38':
-    resolution: {integrity: sha512-30l2ei0ZmdxOvwx5h0POT99R/GYxPrvTUb5sb+tiZ66Bv9w/AI8qL1YH0utTo9PGFFwu0FkLusTVAVdckN4rDw==}
+  '@uniswap/smart-order-router@4.31.10':
+    resolution: {integrity: sha512-Bmg46KXDSfE1AAf1tPg+vDzMngVoGfzdohekhjJ1hIQG13tXcjEykqapQy+CrJUqXLL3lQvZj2uVEKfzCNH74Q==}
     engines: {node: '>=10'}
     peerDependencies:
       jsbi: ^3.2.0
@@ -2745,8 +2745,8 @@ packages:
     resolution: {integrity: sha512-vBtHv4OzEn6Spkl1UgN/0TqO354w7RUdsE1uwAdqz2zfxhV48GOlKJWpe7LiI2ZukL/BMubLewtwC4q/RfjjJQ==}
     engines: {node: '>=14'}
 
-  '@uniswap/universal-router-sdk@4.23.0':
-    resolution: {integrity: sha512-lSWXMoH4fMGHG1s00mR0ivIuBgdW/mR/Y+CuIpxOSDxgwtP86/7JHPfPWcH7EVU5dstSIyzprUwZ/a8v7vlaGg==}
+  '@uniswap/universal-router-sdk@4.30.0':
+    resolution: {integrity: sha512-yO34+VMtqGScCxym0x9C3nTCk5sLef/dkOj5dvnLEs21fXp7k3Y54ih6zCWh2BqJnWcD8/tQdME1jTTy9RsZYA==}
     engines: {node: '>=14'}
 
   '@uniswap/universal-router@1.6.0':
@@ -2769,8 +2769,8 @@ packages:
     resolution: {integrity: sha512-EtROgWTdhHzw4EUj7SdK9wjppOG7psJ16c656cRuv69nWbD9QyDL2shVcQccEiY7ak9WlJ+bIv/VldybXYBDuw==}
     engines: {node: '>=10'}
 
-  '@uniswap/v2-sdk@4.16.0':
-    resolution: {integrity: sha512-USMm2qz1xhEX8R0dhd0mHzf6pz5aCLjbtud1ZyUBk+gshhUCFp6NW9UovH0L5hqrH03rTvmqQdfhHMW5m+Sosg==}
+  '@uniswap/v2-sdk@4.17.0':
+    resolution: {integrity: sha512-JyXFOB4tyk9qk2kps9VA1VgXB9DBK6jbmElTsaMpDThVutDbEzE7nJMas6/TaBREBkitBk0EhAfs0aG1z2egPA==}
     engines: {node: '>=10'}
 
   '@uniswap/v3-core@1.0.0':
@@ -2789,8 +2789,8 @@ packages:
     resolution: {integrity: sha512-0oiyJNGjUVbc958uZmAr+m4XBCjV7PfMs/OUeBv+XDl33MEYF/eH86oBhvqGDM8S/cYaK55tCXzoWkmRUByrHg==}
     engines: {node: '>=10'}
 
-  '@uniswap/v3-sdk@3.26.0':
-    resolution: {integrity: sha512-bcoWNE7ntNNTHMOnDPscIqtIN67fUyrbBKr6eswI2gD2wm5b0YYFBDeh+Qc5Q3117o9i8S7QdftqrU8YSMQUfQ==}
+  '@uniswap/v3-sdk@3.27.0':
+    resolution: {integrity: sha512-BRgb9nWuxptXJmuQrax9XyqcuOMEuWsUjDSyus0UvOavzijbOu8jh3DWptg/15D7oL67Xmz5zvQaSPbLIL1cpA==}
     engines: {node: '>=10'}
 
   '@uniswap/v3-staker@1.0.0':
@@ -2802,8 +2802,8 @@ packages:
     resolution: {integrity: sha512-so3c/CmaRmRSvgKFyrUWy6DCSogyzyVaoYCec/TJ4k2hXlJ8MK4vumcuxtmRr1oMnZ5KmaCPBS12Knb4FC3nsw==}
     engines: {node: '>=14'}
 
-  '@uniswap/v4-sdk@1.23.0':
-    resolution: {integrity: sha512-WpnkNacNTe/qL4kj3DVC2nHaivUeuzYsWIvon+olAWYZyy+Frsnzfon/ZlznDifMPoV+im+MqYFsNQke4Vz3LA==}
+  '@uniswap/v4-sdk@1.27.0':
+    resolution: {integrity: sha512-htQFiON12RR4BipyVdzr4XklYjy756bqruBLA8b4n9Wn7QAWemYrDGbnCvmk1xvzvtc4t9WggDlbRjZ5ON34+g==}
     engines: {node: '>=14'}
 
   '@unrs/resolver-binding-android-arm-eabi@1.9.2':
@@ -4592,7 +4592,7 @@ packages:
 
   glob@6.0.4:
     resolution: {integrity: sha512-MKZeRNyYZAVVVG1oZeLaWie1uweH40m9AZwIwxyPbTSX4hHrVYSzLg0Ro5Z5R7XKkIX+Cc6oD1rqeDJnwsB8/A==}
-    deprecated: Glob versions prior to v9 are no longer supported
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
@@ -4601,7 +4601,7 @@ packages:
   glob@8.1.0:
     resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==}
     engines: {node: '>=12'}
-    deprecated: Glob versions prior to v9 are no longer supported
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   globals@11.12.0:
     resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
@@ -11332,14 +11332,14 @@ snapshots:
     transitivePeerDependencies:
       - hardhat
 
-  '@uniswap/router-sdk@2.2.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))':
+  '@uniswap/router-sdk@2.4.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))':
     dependencies:
       '@ethersproject/abi': 5.8.0
-      '@uniswap/sdk-core': 7.9.0
+      '@uniswap/sdk-core': 7.10.1
       '@uniswap/swap-router-contracts': 1.3.1(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
-      '@uniswap/v2-sdk': 4.16.0
-      '@uniswap/v3-sdk': 3.26.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
-      '@uniswap/v4-sdk': 1.23.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/v2-sdk': 4.17.0
+      '@uniswap/v3-sdk': 3.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/v4-sdk': 1.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
     transitivePeerDependencies:
       - hardhat
 
@@ -11355,7 +11355,7 @@ snapshots:
       tiny-invariant: 1.3.3
       toformat: 2.0.0
 
-  '@uniswap/sdk-core@7.7.2':
+  '@uniswap/sdk-core@7.10.1':
     dependencies:
       '@ethersproject/address': 5.7.0
       '@ethersproject/bytes': 5.8.0
@@ -11367,7 +11367,7 @@ snapshots:
       tiny-invariant: 1.3.3
       toformat: 2.0.0
 
-  '@uniswap/sdk-core@7.9.0':
+  '@uniswap/sdk-core@7.7.2':
     dependencies:
       '@ethersproject/address': 5.7.0
       '@ethersproject/bytes': 5.8.0
@@ -11394,21 +11394,21 @@ snapshots:
       tiny-warning: 1.0.3
       toformat: 2.0.0
 
-  '@uniswap/smart-order-router@4.22.38(bufferutil@4.0.9)(encoding@0.1.13)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(jsbi@3.2.5)(utf-8-validate@5.0.10)':
+  '@uniswap/smart-order-router@4.31.10(bufferutil@4.0.9)(encoding@0.1.13)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(jsbi@3.2.5)(utf-8-validate@5.0.10)':
     dependencies:
       '@eth-optimism/sdk': 3.3.3(bufferutil@4.0.9)(encoding@0.1.13)(ethers@5.8.0(bufferutil@4.0.9)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)
       '@types/brotli': 1.3.4
       '@uniswap/default-token-list': 11.19.0
       '@uniswap/permit2-sdk': 1.3.1(bufferutil@4.0.9)(utf-8-validate@5.0.10)
-      '@uniswap/router-sdk': 2.2.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
-      '@uniswap/sdk-core': 7.9.0
+      '@uniswap/router-sdk': 2.4.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/sdk-core': 7.10.1
       '@uniswap/swap-router-contracts': 1.3.1(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
       '@uniswap/token-lists': 1.0.0-beta.34
       '@uniswap/universal-router': 1.6.0
-      '@uniswap/universal-router-sdk': 4.23.0(bufferutil@4.0.9)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)
-      '@uniswap/v2-sdk': 4.16.0
-      '@uniswap/v3-sdk': 3.26.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
-      '@uniswap/v4-sdk': 1.23.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/universal-router-sdk': 4.30.0(bufferutil@4.0.9)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)
+      '@uniswap/v2-sdk': 4.17.0
+      '@uniswap/v3-sdk': 3.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/v4-sdk': 1.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
       async-retry: 1.3.3
       await-timeout: 1.1.1
       axios: 1.12.0
@@ -11462,18 +11462,18 @@ snapshots:
       - hardhat
       - utf-8-validate
 
-  '@uniswap/universal-router-sdk@4.23.0(bufferutil@4.0.9)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)':
+  '@uniswap/universal-router-sdk@4.30.0(bufferutil@4.0.9)(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)':
     dependencies:
       '@openzeppelin/contracts': 4.9.6
       '@uniswap/permit2-sdk': 1.3.1(bufferutil@4.0.9)(utf-8-validate@5.0.10)
-      '@uniswap/router-sdk': 2.2.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
-      '@uniswap/sdk-core': 7.9.0
+      '@uniswap/router-sdk': 2.4.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/sdk-core': 7.10.1
       '@uniswap/universal-router': 2.1.0
       '@uniswap/v2-core': 1.0.1
-      '@uniswap/v2-sdk': 4.16.0
+      '@uniswap/v2-sdk': 4.17.0
       '@uniswap/v3-core': 1.0.0
-      '@uniswap/v3-sdk': 3.26.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
-      '@uniswap/v4-sdk': 1.23.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/v3-sdk': 3.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/v4-sdk': 1.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
       bignumber.js: 9.3.0
       ethers: 5.8.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
     transitivePeerDependencies:
@@ -11509,11 +11509,11 @@ snapshots:
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
-  '@uniswap/v2-sdk@4.16.0':
+  '@uniswap/v2-sdk@4.17.0':
     dependencies:
       '@ethersproject/address': 5.7.0
       '@ethersproject/solidity': 5.7.0
-      '@uniswap/sdk-core': 7.9.0
+      '@uniswap/sdk-core': 7.10.1
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
 
@@ -11542,11 +11542,11 @@ snapshots:
     transitivePeerDependencies:
       - hardhat
 
-  '@uniswap/v3-sdk@3.26.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))':
+  '@uniswap/v3-sdk@3.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))':
     dependencies:
       '@ethersproject/abi': 5.8.0
       '@ethersproject/solidity': 5.7.0
-      '@uniswap/sdk-core': 7.9.0
+      '@uniswap/sdk-core': 7.10.1
       '@uniswap/swap-router-contracts': 1.3.1(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
       '@uniswap/v3-periphery': 1.4.4
       '@uniswap/v3-staker': 1.0.0
@@ -11571,11 +11571,11 @@ snapshots:
     transitivePeerDependencies:
       - hardhat
 
-  '@uniswap/v4-sdk@1.23.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))':
+  '@uniswap/v4-sdk@1.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))':
     dependencies:
       '@ethersproject/solidity': 5.7.0
-      '@uniswap/sdk-core': 7.9.0
-      '@uniswap/v3-sdk': 3.26.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
+      '@uniswap/sdk-core': 7.10.1
+      '@uniswap/v3-sdk': 3.27.0(hardhat@2.24.0(bufferutil@4.0.9)(ts-node@10.9.2(@types/node@15.14.9)(typescript@5.8.3))(typescript@5.8.3)(utf-8-validate@5.0.10))
       tiny-invariant: 1.3.3
       tiny-warning: 1.0.3
     transitivePeerDependencies:

From 2bc7ece383d8b745414fba248f36784bb504b6a1 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 16:30:43 -0700
Subject: [PATCH 17/37] fix: return price=1 for same-token and native/wrapped
 token quotes

Handle edge cases where no swap is needed:
- Same token quotes (e.g., USDC/USDC) return price=1
- Native to wrapped token (e.g., ETH/WETH) return price=1
- Wrapped to native token (e.g., WETH/ETH) return price=1

This avoids unnecessary DEX router calls for equivalent tokens
and prevents errors when fetching prices for stablecoins against
themselves.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../uniswap/router-routes/quoteSwap.ts        | 18 ++++
 .../universal-router-quoteSwap.test.ts        | 97 +++++++++++++++++++
 2 files changed, 115 insertions(+)

diff --git a/src/connectors/uniswap/router-routes/quoteSwap.ts b/src/connectors/uniswap/router-routes/quoteSwap.ts
index 16777324ab..1284f10b85 100644
--- a/src/connectors/uniswap/router-routes/quoteSwap.ts
+++ b/src/connectors/uniswap/router-routes/quoteSwap.ts
@@ -40,6 +40,24 @@ async function quoteSwap(
     );
   }
 
+  // Handle same-token or equivalent-token quotes (return price=1)
+  // This covers: USDC/USDC, ETH/WETH, WETH/ETH, ETH/ETH (after conversion)
+  if (actualBaseToken.toUpperCase() === actualQuoteToken.toUpperCase()) {
+    logger.info(`[quoteSwap] Same/equivalent token quote: ${baseToken}/${quoteToken}, returning price=1`);
+    return {
+      quoteId: uuidv4(),
+      tokenIn: baseToken,
+      tokenOut: quoteToken,
+      amountIn: amount,
+      amountOut: amount,
+      price: 1,
+      priceImpactPct: 0,
+      minAmountOut: amount,
+      maxAmountIn: amount,
+      routePath: `${baseToken} -> ${quoteToken}`,
+    };
+  }
+
   // Resolve token symbols/addresses to token objects from local token list
   const baseTokenInfo = await ethereum.getToken(actualBaseToken);
   const quoteTokenInfo = await ethereum.getToken(actualQuoteToken);
diff --git a/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts b/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts
index d4e3f198f8..abcd862b36 100644
--- a/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts
+++ b/test/connectors/uniswap/router-routes/universal-router-quoteSwap.test.ts
@@ -420,4 +420,101 @@ describe('GET /quote-swap', () => {
       expect(body).toHaveProperty('tokenIn', mockWETH.address);
     });
   });
+
+  describe('same-token and equivalent-token quotes', () => {
+    it('should return price=1 for same token quote (USDC/USDC)', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'USDC',
+          quoteToken: 'USDC',
+          amount: '100',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      expect(body).toHaveProperty('price', 1);
+      expect(body).toHaveProperty('amountIn', 100);
+      expect(body).toHaveProperty('amountOut', 100);
+      expect(body).toHaveProperty('priceImpactPct', 0);
+    });
+
+    it('should return price=1 for ETH/WETH (native to wrapped)', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'ETH',
+          quoteToken: 'WETH',
+          amount: '1',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      expect(body).toHaveProperty('price', 1);
+      expect(body).toHaveProperty('amountIn', 1);
+      expect(body).toHaveProperty('amountOut', 1);
+      expect(body).toHaveProperty('priceImpactPct', 0);
+    });
+
+    it('should return price=1 for WETH/ETH (wrapped to native)', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'WETH',
+          quoteToken: 'ETH',
+          amount: '1',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      expect(body).toHaveProperty('price', 1);
+      expect(body).toHaveProperty('amountIn', 1);
+      expect(body).toHaveProperty('amountOut', 1);
+      expect(body).toHaveProperty('priceImpactPct', 0);
+    });
+
+    it('should return price=1 for ETH/ETH', async () => {
+      const response = await server.inject({
+        method: 'GET',
+        url: '/quote-swap',
+        query: {
+          network: 'mainnet',
+          walletAddress: '0x0000000000000000000000000000000000000001',
+          baseToken: 'ETH',
+          quoteToken: 'ETH',
+          amount: '1',
+          side: 'SELL',
+          slippagePct: '1',
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+
+      expect(body).toHaveProperty('price', 1);
+      expect(body).toHaveProperty('amountIn', 1);
+      expect(body).toHaveProperty('amountOut', 1);
+    });
+  });
 });

From 4633a594c195bee9fc59216245c61ff4f8c35d43 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 16:31:34 -0700
Subject: [PATCH 18/37] fix: exclude V4 protocol from AlphaRouter to fix Base
 network

V4 pool addresses are not configured for all chains (e.g., Base),
causing "Invariant failed: ADDRESSES" error. Restrict routing to
V2 and V3 protocols only.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/connectors/uniswap/alpha-router.ts | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/connectors/uniswap/alpha-router.ts b/src/connectors/uniswap/alpha-router.ts
index 209ec556c5..a822794408 100644
--- a/src/connectors/uniswap/alpha-router.ts
+++ b/src/connectors/uniswap/alpha-router.ts
@@ -1,4 +1,5 @@
 import { BaseProvider } from '@ethersproject/providers';
+import { Protocol } from '@uniswap/router-sdk';
 import { CurrencyAmount, Percent, Token, TradeType } from '@uniswap/sdk-core';
 import { AlphaRouter, SwapRoute, SwapType } from '@uniswap/smart-order-router';
 import { UniversalRouterVersion } from '@uniswap/universal-router-sdk';
@@ -88,13 +89,22 @@ export class AlphaRouterService {
     const quoteCurrency = tradeType === TradeType.EXACT_INPUT ? tokenOut : tokenIn;
     logger.debug(`[AlphaRouter] Quote currency: ${quoteCurrency.symbol} (${quoteCurrency.address})`);
 
-    const swapRoute = await this.router.route(amount, quoteCurrency, tradeType, {
-      type: SwapType.UNIVERSAL_ROUTER,
-      version: UniversalRouterVersion.V2_0,
-      slippageTolerance: options.slippageTolerance,
-      deadlineOrPreviousBlockhash: options.deadline,
-      recipient: options.recipient,
-    });
+    const swapRoute = await this.router.route(
+      amount,
+      quoteCurrency,
+      tradeType,
+      {
+        type: SwapType.UNIVERSAL_ROUTER,
+        version: UniversalRouterVersion.V2_0,
+        slippageTolerance: options.slippageTolerance,
+        deadlineOrPreviousBlockhash: options.deadline,
+        recipient: options.recipient,
+      },
+      {
+        // Exclude V4 protocol - not all chains have V4 pool addresses configured
+        protocols: [Protocol.V2, Protocol.V3],
+      },
+    );
 
     if (!swapRoute) {
       throw new Error(`No route found for ${tokenIn.symbol} -> ${tokenOut.symbol}`);

From 46a3bd978ada17e112b60eb70df5d1eecfa716e5 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 16:43:49 -0700
Subject: [PATCH 19/37] (chore) reduce eth token lists

---
 src/templates/tokens/ethereum/arbitrum.json | 21 -----------
 src/templates/tokens/ethereum/base.json     | 21 -----------
 src/templates/tokens/ethereum/bsc.json      | 14 -------
 src/templates/tokens/ethereum/celo.json     |  7 ----
 src/templates/tokens/ethereum/mainnet.json  | 42 ---------------------
 src/templates/tokens/ethereum/optimism.json | 28 --------------
 src/templates/tokens/ethereum/polygon.json  | 14 -------
 7 files changed, 147 deletions(-)

diff --git a/src/templates/tokens/ethereum/arbitrum.json b/src/templates/tokens/ethereum/arbitrum.json
index 1212205ce2..75015faa54 100644
--- a/src/templates/tokens/ethereum/arbitrum.json
+++ b/src/templates/tokens/ethereum/arbitrum.json
@@ -6,27 +6,6 @@
     "address": "0x912ce59144191c1204e64559fe8253a0e49e6548",
     "decimals": 18
   },
-  {
-    "chainId": 42161,
-    "name": "Balancer",
-    "symbol": "BAL",
-    "address": "0x040d1edc9569d4bab2d15287dc5a4f10f56a56b8",
-    "decimals": 18
-  },
-  {
-    "chainId": 42161,
-    "name": "Coinbase Wrapped BTC",
-    "symbol": "cbBTC",
-    "address": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
-    "decimals": 8
-  },
-  {
-    "chainId": 42161,
-    "name": "Curve DAO",
-    "symbol": "CRV",
-    "address": "0x11cdb42b0eb46d95f990bedd4695a6e3fa034978",
-    "decimals": 18
-  },
   {
     "chainId": 42161,
     "name": "Dai",
diff --git a/src/templates/tokens/ethereum/base.json b/src/templates/tokens/ethereum/base.json
index 6c44877f0b..5a2170fd24 100644
--- a/src/templates/tokens/ethereum/base.json
+++ b/src/templates/tokens/ethereum/base.json
@@ -1,11 +1,4 @@
 [
-  {
-    "chainId": 8453,
-    "name": "Aave",
-    "symbol": "aave",
-    "address": "0x63706e401c06ac8513145b7687a14804d17f814b",
-    "decimals": 18
-  },
   {
     "chainId": 8453,
     "name": "Coinbase Wrapped BTC",
@@ -20,13 +13,6 @@
     "address": "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
     "decimals": 18
   },
-  {
-    "chainId": 8453,
-    "name": "Chainlink",
-    "symbol": "link",
-    "address": "0x88fb150bdc53a65fe94dea0c9ba0a6daf8c6e196",
-    "decimals": 18
-  },
   {
     "chainId": 8453,
     "name": "USD Coin",
@@ -41,13 +27,6 @@
     "address": "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2",
     "decimals": 6
   },
-  {
-    "chainId": 8453,
-    "name": "Virtual Protocol",
-    "symbol": "VIRTUAL",
-    "address": "0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b",
-    "decimals": 18
-  },
   {
     "chainId": 8453,
     "name": "Wrapped Ether",
diff --git a/src/templates/tokens/ethereum/bsc.json b/src/templates/tokens/ethereum/bsc.json
index 4cd3f5e74e..6200207623 100644
--- a/src/templates/tokens/ethereum/bsc.json
+++ b/src/templates/tokens/ethereum/bsc.json
@@ -20,20 +20,6 @@
     "address": "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82",
     "decimals": 18
   },
-  {
-    "chainId": 56,
-    "name": "Binance Pegged DAI",
-    "symbol": "DAI",
-    "address": "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3",
-    "decimals": 18
-  },
-  {
-    "chainId": 56,
-    "name": "Binance Pegged ETH",
-    "symbol": "ETH",
-    "address": "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
-    "decimals": 18
-  },
   {
     "chainId": 56,
     "name": "Binance Pegged USD Coin",
diff --git a/src/templates/tokens/ethereum/celo.json b/src/templates/tokens/ethereum/celo.json
index 159566245e..b5031ccaf1 100644
--- a/src/templates/tokens/ethereum/celo.json
+++ b/src/templates/tokens/ethereum/celo.json
@@ -13,13 +13,6 @@
     "address": "0x97926a82930bb7B33178E3c2f4ED1BFDc91A9FBF",
     "decimals": 18
   },
-  {
-    "chainId": 42220,
-    "name": "Allbridge SOL",
-    "symbol": "SOL",
-    "address": "0x173234922eB27d5138c5e481be9dF5261fAeD450",
-    "decimals": 18
-  },
   {
     "chainId": 42220,
     "name": "USD Coin",
diff --git a/src/templates/tokens/ethereum/mainnet.json b/src/templates/tokens/ethereum/mainnet.json
index 560e47e7c9..f23b60f153 100644
--- a/src/templates/tokens/ethereum/mainnet.json
+++ b/src/templates/tokens/ethereum/mainnet.json
@@ -6,13 +6,6 @@
     "address": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
     "decimals": 18
   },
-  {
-    "chainId": 1,
-    "name": "Curve DAO",
-    "symbol": "CRV",
-    "address": "0xd533a949740bb3306d119cc777fa900ba034cd52",
-    "decimals": 18
-  },
   {
     "chainId": 1,
     "name": "Dai",
@@ -27,13 +20,6 @@
     "address": "0xe5097d9baeafb89f9bcb78c9290d545db5f9e9cb",
     "decimals": 18
   },
-  {
-    "chainId": 1,
-    "name": "Lido DAO",
-    "symbol": "LDO",
-    "address": "0x5a98fcbea516cf06857215779fd812ca3bef1b32",
-    "decimals": 18
-  },
   {
     "chainId": 1,
     "name": "Chainlink",
@@ -41,27 +27,6 @@
     "address": "0x514910771af9ca656af840dff83e8264ecf986ca",
     "decimals": 18
   },
-  {
-    "chainId": 1,
-    "name": "Pepe",
-    "symbol": "PEPE",
-    "address": "0x6982508145454ce325ddbe47a25d4ec3d2311933",
-    "decimals": 18
-  },
-  {
-    "chainId": 1,
-    "name": "Shiba Inu",
-    "symbol": "SHIB",
-    "address": "0x95ad61b0a150d79219dcf64e1e6cc01f0b64c4ce",
-    "decimals": 18
-  },
-  {
-    "chainId": 1,
-    "name": "Lido Staked Ether",
-    "symbol": "STETH",
-    "address": "0xae7ab96520de3a18e5e111b5eaab095312d7fe84",
-    "decimals": 18
-  },
   {
     "chainId": 1,
     "name": "Uniswap",
@@ -96,12 +61,5 @@
     "symbol": "WETH",
     "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
     "decimals": 18
-  },
-  {
-    "chainId": 1,
-    "name": "Wrapped stETH",
-    "symbol": "WSTETH",
-    "address": "0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
-    "decimals": 18
   }
 ]
diff --git a/src/templates/tokens/ethereum/optimism.json b/src/templates/tokens/ethereum/optimism.json
index f265afbb28..f0e0bedb03 100644
--- a/src/templates/tokens/ethereum/optimism.json
+++ b/src/templates/tokens/ethereum/optimism.json
@@ -1,11 +1,4 @@
 [
-  {
-    "chainId": 10,
-    "name": "Aave Token",
-    "symbol": "AAVE",
-    "address": "0x76FB31fb4af56892A25e32cFC43De717950c9278",
-    "decimals": 18
-  },
   {
     "chainId": 10,
     "name": "Dai Stablecoin",
@@ -13,20 +6,6 @@
     "address": "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
     "decimals": 18
   },
-  {
-    "chainId": 10,
-    "name": "Ethereum Name Service",
-    "symbol": "ENS",
-    "address": "0x65559aA14915a70190438eF90104769e5E890A00",
-    "decimals": 18
-  },
-  {
-    "chainId": 10,
-    "name": "Ether",
-    "symbol": "ETH",
-    "address": "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000",
-    "decimals": 18
-  },
   {
     "chainId": 10,
     "name": "Optimism",
@@ -61,12 +40,5 @@
     "symbol": "WETH",
     "address": "0x4200000000000000000000000000000000000006",
     "decimals": 18
-  },
-  {
-    "chainId": 10,
-    "name": "Wrapped liquid staked Ether 2.0",
-    "symbol": "wstETH",
-    "address": "0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb",
-    "decimals": 18
   }
 ]
diff --git a/src/templates/tokens/ethereum/polygon.json b/src/templates/tokens/ethereum/polygon.json
index 4c742a489c..7bd68f0820 100644
--- a/src/templates/tokens/ethereum/polygon.json
+++ b/src/templates/tokens/ethereum/polygon.json
@@ -1,18 +1,4 @@
 [
-  {
-    "chainId": 137,
-    "name": "Balancer",
-    "symbol": "BAL",
-    "address": "0x9a71012b13ca4d3d0cdc72a177df3ef03b0e76a3",
-    "decimals": 18
-  },
-  {
-    "chainId": 137,
-    "name": "Ether - PoS",
-    "symbol": "ETH",
-    "address": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-    "decimals": 18
-  },
   {
     "chainId": 137,
     "name": "USD Coin",

From deb3899637be6d86d11ab4100cca1d4c049b4d71 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 16:48:04 -0700
Subject: [PATCH 20/37] fix: handle same-token quotes in Jupiter router
 (Solana)

Return price=1 for:
- Same token quotes (e.g., USDC/USDC)
- Native/wrapped equivalents (SOL/WSOL, WSOL/SOL)

Prevents "Input and output mints are not allowed to be equal" error
from Jupiter API.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../jupiter/router-routes/quoteSwap.ts        | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/connectors/jupiter/router-routes/quoteSwap.ts b/src/connectors/jupiter/router-routes/quoteSwap.ts
index 681a813612..afafb99764 100644
--- a/src/connectors/jupiter/router-routes/quoteSwap.ts
+++ b/src/connectors/jupiter/router-routes/quoteSwap.ts
@@ -25,6 +25,29 @@ export async function quoteSwap(
   const solana = await Solana.getInstance(network);
   const jupiter = await Jupiter.getInstance(network);
 
+  // Normalize tokens - convert native SOL to WSOL for comparison
+  const nativeSymbol = solana.nativeTokenSymbol.toUpperCase();
+  const normalizedBase = baseToken.toUpperCase() === nativeSymbol ? 'WSOL' : baseToken.toUpperCase();
+  const normalizedQuote = quoteToken.toUpperCase() === nativeSymbol ? 'WSOL' : quoteToken.toUpperCase();
+
+  // Handle same-token or equivalent-token quotes (return price=1)
+  // This covers: USDC/USDC, SOL/WSOL, WSOL/SOL, SOL/SOL
+  if (normalizedBase === normalizedQuote) {
+    logger.info(`[quoteSwap] Same/equivalent token quote: ${baseToken}/${quoteToken}, returning price=1`);
+    return {
+      quoteId: uuidv4(),
+      tokenIn: baseToken,
+      tokenOut: quoteToken,
+      amountIn: amount,
+      amountOut: amount,
+      price: 1,
+      priceImpactPct: 0,
+      minAmountOut: amount,
+      maxAmountIn: amount,
+      routePath: `${baseToken} -> ${quoteToken}`,
+    };
+  }
+
   // Resolve token symbols to addresses
   const baseTokenInfo = await solana.getToken(baseToken);
   const quoteTokenInfo = await solana.getToken(quoteToken);

From d56a57d8215acb3fba279877b2ab9e335bed51bd Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 19:55:11 -0700
Subject: [PATCH 21/37] Revert "fix: handle same-token quotes in Jupiter router
 (Solana)"

This reverts commit deb3899637be6d86d11ab4100cca1d4c049b4d71.
---
 .../jupiter/router-routes/quoteSwap.ts        | 23 -------------------
 1 file changed, 23 deletions(-)

diff --git a/src/connectors/jupiter/router-routes/quoteSwap.ts b/src/connectors/jupiter/router-routes/quoteSwap.ts
index afafb99764..681a813612 100644
--- a/src/connectors/jupiter/router-routes/quoteSwap.ts
+++ b/src/connectors/jupiter/router-routes/quoteSwap.ts
@@ -25,29 +25,6 @@ export async function quoteSwap(
   const solana = await Solana.getInstance(network);
   const jupiter = await Jupiter.getInstance(network);
 
-  // Normalize tokens - convert native SOL to WSOL for comparison
-  const nativeSymbol = solana.nativeTokenSymbol.toUpperCase();
-  const normalizedBase = baseToken.toUpperCase() === nativeSymbol ? 'WSOL' : baseToken.toUpperCase();
-  const normalizedQuote = quoteToken.toUpperCase() === nativeSymbol ? 'WSOL' : quoteToken.toUpperCase();
-
-  // Handle same-token or equivalent-token quotes (return price=1)
-  // This covers: USDC/USDC, SOL/WSOL, WSOL/SOL, SOL/SOL
-  if (normalizedBase === normalizedQuote) {
-    logger.info(`[quoteSwap] Same/equivalent token quote: ${baseToken}/${quoteToken}, returning price=1`);
-    return {
-      quoteId: uuidv4(),
-      tokenIn: baseToken,
-      tokenOut: quoteToken,
-      amountIn: amount,
-      amountOut: amount,
-      price: 1,
-      priceImpactPct: 0,
-      minAmountOut: amount,
-      maxAmountIn: amount,
-      routePath: `${baseToken} -> ${quoteToken}`,
-    };
-  }
-
   // Resolve token symbols to addresses
   const baseTokenInfo = await solana.getToken(baseToken);
   const quoteTokenInfo = await solana.getToken(quoteToken);

From 9535b6500e45fc7a46ad80cf5a728e860ba1bad6 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Wed, 4 Feb 2026 19:58:47 -0700
Subject: [PATCH 22/37] fix: add missing getNamespace mock to config test

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 test/config/update-config-network-files.test.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/config/update-config-network-files.test.ts b/test/config/update-config-network-files.test.ts
index 4336101a0d..82d6766905 100644
--- a/test/config/update-config-network-files.test.ts
+++ b/test/config/update-config-network-files.test.ts
@@ -38,6 +38,7 @@ describe('updateConfig - Configuration updates', () => {
     mockConfigManager = {
       set: jest.fn(),
       get: jest.fn(),
+      getNamespace: jest.fn().mockReturnValue(null), // Return null so chain-level routing is skipped
     };
     (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue(mockConfigManager);
 

From 14173bcdcb8025043a2209d64925fc088f93c32c Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Thu, 5 Feb 2026 16:29:54 -0700
Subject: [PATCH 23/37] chore: increase base sol priority fee

---
 src/templates/chains/solana/mainnet-beta.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/templates/chains/solana/mainnet-beta.yml b/src/templates/chains/solana/mainnet-beta.yml
index e309a70b32..58a6f71d69 100644
--- a/src/templates/chains/solana/mainnet-beta.yml
+++ b/src/templates/chains/solana/mainnet-beta.yml
@@ -18,4 +18,4 @@ confirmRetryCount: 10
 
 # Minimum priority fee per compute unit in lamports
 # This sets the floor for priority fees to ensure transactions are processed (default: 0.1 lamports/CU)
-minPriorityFeePerCU: 0.01
+minPriorityFeePerCU: 0.1

From 5a55764672c6ec2363d9687fad0432d2f8ef78e4 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Fri, 6 Feb 2026 15:09:34 -0700
Subject: [PATCH 24/37] fix: process Ethereum token balances sequentially to
 prevent timeouts

Switch from parallel Promise.all to sequential for-loop when fetching
all token balances to avoid RPC rate limiting and timeout errors.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/ethereum/ethereum.ts | 37 ++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/src/chains/ethereum/ethereum.ts b/src/chains/ethereum/ethereum.ts
index 9e988e525b..03f8b04266 100644
--- a/src/chains/ethereum/ethereum.ts
+++ b/src/chains/ethereum/ethereum.ts
@@ -1080,6 +1080,7 @@ export class Ethereum {
 
   /**
    * Get balances for all tokens in the token list
+   * Processes tokens sequentially to prevent RPC timeouts
    */
   private async getAllTokenBalances(
     address: string,
@@ -1090,26 +1091,24 @@ export class Ethereum {
     const tokenList = await this.getTokenList();
     logger.info(`Checking balances for all ${tokenList.length} tokens in the token list`);
 
-    await Promise.all(
-      tokenList.map(async (token) => {
-        try {
-          const contract = this.getContract(token.address, this.provider);
-          const balance = isHardware
-            ? await this.getERC20BalanceByAddress(contract, address, token.decimals, 2000, token.symbol)
-            : await this.getERC20Balance(contract, wallet!, token.decimals, 2000, token.symbol);
-
-          const balanceNum = parseFloat(tokenValueToString(balance));
-
-          // Only add tokens with non-zero balances
-          if (balanceNum > 0) {
-            balances[token.symbol] = balanceNum;
-            logger.debug(`Found non-zero balance for ${token.symbol}: ${balanceNum}`);
-          }
-        } catch (err) {
-          logger.warn(`Error getting balance for ${token.symbol}: ${err.message}`);
+    for (const token of tokenList) {
+      try {
+        const contract = this.getContract(token.address, this.provider);
+        const balance = isHardware
+          ? await this.getERC20BalanceByAddress(contract, address, token.decimals, 5000, token.symbol)
+          : await this.getERC20Balance(contract, wallet!, token.decimals, 5000, token.symbol);
+
+        const balanceNum = parseFloat(tokenValueToString(balance));
+
+        // Only add tokens with non-zero balances
+        if (balanceNum > 0) {
+          balances[token.symbol] = balanceNum;
+          logger.debug(`Found non-zero balance for ${token.symbol}: ${balanceNum}`);
         }
-      }),
-    );
+      } catch (err) {
+        logger.warn(`Error getting balance for ${token.symbol}: ${err.message}`);
+      }
+    }
   }
 
   /**

From 5ca2052d80a36e61e60be8fcb1dd6080639fb538 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Fri, 6 Feb 2026 17:02:42 -0700
Subject: [PATCH 25/37] docs: add Privy server wallet integration design doc

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 privy-gateway-design.md | 697 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 697 insertions(+)
 create mode 100644 privy-gateway-design.md

diff --git a/privy-gateway-design.md b/privy-gateway-design.md
new file mode 100644
index 0000000000..853b23c266
--- /dev/null
+++ b/privy-gateway-design.md
@@ -0,0 +1,697 @@
+# Privy Server Wallet Integration for Hummingbot Gateway
+
+## Overview
+
+Add support for Privy server wallets to enable wallet-level transaction policies (allowlisted contracts, max amounts, time restrictions). Policies are managed in Privy Dashboard; Gateway just registers wallets and signs transactions.
+
+## Files to Create
+
+### 1. `src/wallet/privy/privy-client.ts`
+```typescript
+import { ConfigManagerV2 } from '../../services/config-manager-v2';
+import { logger } from '../../services/logger';
+
+interface PrivyRpcRequest {
+  method: string;
+  caip2: string;
+  params: Record<string, unknown>;
+}
+
+interface PrivyRpcResponse {
+  data: Record<string, unknown>;
+}
+
+export class PrivyClient {
+  private static _instance: PrivyClient;
+  private appId: string;
+  private appSecret: string;
+
+  private constructor() {
+    const config = ConfigManagerV2.getInstance();
+    this.appId = config.get('apiKeys.privyAppId');
+    this.appSecret = config.get('apiKeys.privyAppSecret');
+
+    if (!this.appId || !this.appSecret) {
+      throw new Error('Privy credentials must be configured in conf/apiKeys.yml (privyAppId, privyAppSecret)');
+    }
+  }
+
+  static getInstance(): PrivyClient {
+    if (!PrivyClient._instance) {
+      PrivyClient._instance = new PrivyClient();
+    }
+    return PrivyClient._instance;
+  }
+
+  private getAuthHeaders(): Record<string, string> {
+    const basicAuth = Buffer.from(`${this.appId}:${this.appSecret}`).toString('base64');
+    return {
+      'Content-Type': 'application/json',
+      'privy-app-id': this.appId,
+      'Authorization': `Basic ${basicAuth}`,
+    };
+  }
+
+  async rpc(walletId: string, request: PrivyRpcRequest): Promise<PrivyRpcResponse> {
+    const url = `https://api.privy.io/v1/wallets/${walletId}/rpc`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: this.getAuthHeaders(),
+      body: JSON.stringify(request),
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      logger.error(`Privy RPC error: ${response.status} ${body}`);
+      throw new Error(`Privy RPC failed: ${response.status} - ${body}`);
+    }
+
+    return response.json();
+  }
+
+  async getWallet(walletId: string): Promise<{ address: string; chainType: string }> {
+    const url = `https://api.privy.io/v1/wallets/${walletId}`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: this.getAuthHeaders(),
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Failed to get Privy wallet: ${response.status} - ${body}`);
+    }
+
+    const data = await response.json();
+    return { address: data.address, chainType: data.chain_type };
+  }
+}
+```
+
+### 2. `src/wallet/privy/privy-evm-signer.ts`
+```typescript
+import { Signer, providers, utils, BytesLike } from 'ethers';
+import { Deferrable } from 'ethers/lib/utils';
+import { PrivyClient } from './privy-client';
+import { logger } from '../../services/logger';
+
+export class PrivyEvmSigner extends Signer {
+  readonly provider: providers.Provider;
+  private privyClient: PrivyClient;
+  private walletId: string;
+  private _address: string;
+  private chainId: number;
+
+  constructor(
+    walletId: string,
+    address: string,
+    chainId: number,
+    provider: providers.Provider
+  ) {
+    super();
+    this.walletId = walletId;
+    this._address = utils.getAddress(address);
+    this.chainId = chainId;
+    this.provider = provider;
+    this.privyClient = PrivyClient.getInstance();
+  }
+
+  async getAddress(): Promise<string> {
+    return this._address;
+  }
+
+  async signTransaction(
+    transaction: Deferrable<providers.TransactionRequest>
+  ): Promise<string> {
+    const tx = await utils.resolveProperties(transaction);
+
+    const resp = await this.privyClient.rpc(this.walletId, {
+      method: 'eth_signTransaction',
+      caip2: `eip155:${this.chainId}`,
+      params: {
+        transaction: {
+          to: tx.to,
+          value: tx.value ? utils.hexlify(tx.value) : undefined,
+          data: tx.data ? utils.hexlify(tx.data) : undefined,
+          gasLimit: tx.gasLimit ? utils.hexlify(tx.gasLimit) : undefined,
+          maxFeePerGas: tx.maxFeePerGas ? utils.hexlify(tx.maxFeePerGas) : undefined,
+          maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? utils.hexlify(tx.maxPriorityFeePerGas) : undefined,
+          nonce: tx.nonce,
+          chain_id: this.chainId,
+        },
+      },
+    });
+
+    return resp.data.signedTransaction as string;
+  }
+
+  async sendTransaction(
+    transaction: Deferrable<providers.TransactionRequest>
+  ): Promise<providers.TransactionResponse> {
+    const tx = await utils.resolveProperties(transaction);
+
+    const resp = await this.privyClient.rpc(this.walletId, {
+      method: 'eth_sendTransaction',
+      caip2: `eip155:${this.chainId}`,
+      params: {
+        transaction: {
+          to: tx.to,
+          value: tx.value ? utils.hexlify(tx.value) : undefined,
+          data: tx.data ? utils.hexlify(tx.data) : undefined,
+          gasLimit: tx.gasLimit ? utils.hexlify(tx.gasLimit) : undefined,
+          maxFeePerGas: tx.maxFeePerGas ? utils.hexlify(tx.maxFeePerGas) : undefined,
+          maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? utils.hexlify(tx.maxPriorityFeePerGas) : undefined,
+          nonce: tx.nonce,
+          chain_id: this.chainId,
+        },
+      },
+    });
+
+    const hash = resp.data.hash as string;
+    logger.info(`Privy EVM tx sent: ${hash} on chain ${this.chainId}`);
+
+    return this.provider.getTransaction(hash);
+  }
+
+  async signMessage(message: string | BytesLike): Promise<string> {
+    const msgHex = typeof message === 'string'
+      ? utils.hexlify(utils.toUtf8Bytes(message))
+      : utils.hexlify(message);
+
+    const resp = await this.privyClient.rpc(this.walletId, {
+      method: 'personal_sign',
+      caip2: `eip155:${this.chainId}`,
+      params: { message: msgHex },
+    });
+
+    return resp.data.signature as string;
+  }
+
+  connect(provider: providers.Provider): PrivyEvmSigner {
+    return new PrivyEvmSigner(this.walletId, this._address, this.chainId, provider);
+  }
+}
+```
+
+### 3. `src/wallet/privy/privy-solana-signer.ts`
+```typescript
+import { VersionedTransaction, Transaction } from '@solana/web3.js';
+import { PrivyClient } from './privy-client';
+import { logger } from '../../services/logger';
+
+// CAIP-2 chain IDs for Solana networks
+const SOLANA_CAIP2: Record<string, string> = {
+  'mainnet-beta': 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+  'devnet': 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+};
+
+export class PrivySolanaSigner {
+  readonly publicKey: string;
+  private walletId: string;
+  private privyClient: PrivyClient;
+  private caip2: string;
+
+  constructor(walletId: string, publicKey: string, network: string = 'mainnet-beta') {
+    this.walletId = walletId;
+    this.publicKey = publicKey;
+    this.privyClient = PrivyClient.getInstance();
+    this.caip2 = SOLANA_CAIP2[network] || SOLANA_CAIP2['mainnet-beta'];
+  }
+
+  async signTransaction(
+    tx: VersionedTransaction | Transaction
+  ): Promise<VersionedTransaction> {
+    const serialized = Buffer.from(tx.serialize()).toString('base64');
+
+    const resp = await this.privyClient.rpc(this.walletId, {
+      method: 'signTransaction',
+      caip2: this.caip2,
+      params: {
+        transaction: serialized,
+        encoding: 'base64',
+      },
+    });
+
+    const signedBytes = Buffer.from(resp.data.signedTransaction as string, 'base64');
+    return VersionedTransaction.deserialize(signedBytes);
+  }
+
+  async signAndSendTransaction(
+    tx: VersionedTransaction | Transaction
+  ): Promise<string> {
+    const serialized = Buffer.from(tx.serialize()).toString('base64');
+
+    const resp = await this.privyClient.rpc(this.walletId, {
+      method: 'signAndSendTransaction',
+      caip2: this.caip2,
+      params: {
+        transaction: serialized,
+        encoding: 'base64',
+      },
+    });
+
+    const hash = resp.data.hash as string;
+    logger.info(`Privy Solana tx sent: ${hash}`);
+    return hash;
+  }
+}
+```
+
+---
+
+## Files to Modify
+
+### 4. `src/templates/apiKeys.yml`
+
+Add Privy credentials:
+```yaml
+# Privy - Server wallet provider with policy engine
+# Get your credentials from https://dashboard.privy.io
+privyAppId: ''
+privyAppSecret: ''
+```
+
+### 5. `src/templates/namespace/apiKeys-schema.json`
+
+Add Privy properties to the schema:
+```json
+"privyAppId": {
+  "type": "string",
+  "description": "Privy App ID for server wallets (https://dashboard.privy.io)"
+},
+"privyAppSecret": {
+  "type": "string",
+  "description": "Privy App Secret for server wallets"
+}
+```
+
+### 6. `src/wallet/utils.ts`
+
+Add these imports at the top:
+```typescript
+import fse from 'fs-extra';
+```
+
+Add these types and functions after existing hardware wallet functions:
+
+```typescript
+// ============ PRIVY WALLET FUNCTIONS ============
+
+export interface PrivyWalletData {
+  address: string;
+  privyWalletId: string;
+  addedAt: string;
+}
+
+export function getPrivyWalletPath(chain: string): string {
+  const safeChain = sanitizePathComponent(chain.toLowerCase());
+  return `${walletPath}/${safeChain}/privy-wallets.json`;
+}
+
+export async function getPrivyWallets(chain: string): Promise<PrivyWalletData[]> {
+  const filePath = getPrivyWalletPath(chain);
+
+  if (!(await fse.pathExists(filePath))) {
+    return [];
+  }
+
+  try {
+    const content = await fse.readFile(filePath, 'utf8');
+    const data = JSON.parse(content);
+    return data.wallets || [];
+  } catch (error) {
+    logger.error(`Failed to read privy wallets for ${chain}: ${error.message}`);
+    return [];
+  }
+}
+
+export async function savePrivyWallets(
+  chain: string,
+  wallets: PrivyWalletData[]
+): Promise<void> {
+  const filePath = getPrivyWalletPath(chain);
+  const dirPath = `${walletPath}/${sanitizePathComponent(chain.toLowerCase())}`;
+
+  await mkdirIfDoesNotExist(dirPath);
+  await fse.writeFile(filePath, JSON.stringify({ wallets }, null, 2));
+}
+
+export async function getPrivyWalletAddresses(chain: string): Promise<string[]> {
+  const wallets = await getPrivyWallets(chain);
+  return wallets.map((w) => w.address);
+}
+
+export async function isPrivyWallet(chain: string, address: string): Promise<boolean> {
+  const wallets = await getPrivyWallets(chain);
+  return wallets.some((w) => w.address.toLowerCase() === address.toLowerCase());
+}
+
+export async function getPrivyWalletByAddress(
+  chain: string,
+  address: string
+): Promise<PrivyWalletData | null> {
+  const wallets = await getPrivyWallets(chain);
+  return wallets.find((w) => w.address.toLowerCase() === address.toLowerCase()) || null;
+}
+```
+
+### 7. `src/chains/ethereum/ethereum.ts`
+
+Add import at the top:
+```typescript
+import { isPrivyWallet as checkIsPrivyWallet, getPrivyWalletByAddress } from '../../wallet/utils';
+import { PrivyEvmSigner } from '../../wallet/privy/privy-evm-signer';
+```
+
+Add these methods to the `Ethereum` class (after `isHardwareWallet` method):
+
+```typescript
+  /**
+   * Check if an address is a Privy wallet
+   */
+  public async isPrivyWallet(address: string): Promise<boolean> {
+    return await checkIsPrivyWallet('ethereum', address);
+  }
+
+  /**
+   * Get a Privy signer for an address
+   */
+  public async getPrivySigner(address: string): Promise<PrivyEvmSigner> {
+    const privyWallet = await getPrivyWalletByAddress('ethereum', address);
+    if (!privyWallet) {
+      throw new Error(`Privy wallet not found for address: ${address}`);
+    }
+    return new PrivyEvmSigner(
+      privyWallet.privyWalletId,
+      address,
+      this.chainId,
+      this.provider
+    );
+  }
+```
+
+### 8. `src/chains/solana/solana.ts`
+
+Add import at the top:
+```typescript
+import { isPrivyWallet as checkIsPrivyWallet, getPrivyWalletByAddress } from '../../wallet/utils';
+import { PrivySolanaSigner } from '../../wallet/privy/privy-solana-signer';
+```
+
+Add these methods to the `Solana` class (after `isHardwareWallet` method):
+
+```typescript
+  /**
+   * Check if an address is a Privy wallet
+   */
+  public async isPrivyWallet(address: string): Promise<boolean> {
+    return await checkIsPrivyWallet('solana', address);
+  }
+
+  /**
+   * Get a Privy signer for an address
+   */
+  public async getPrivySigner(address: string): Promise<PrivySolanaSigner> {
+    const privyWallet = await getPrivyWalletByAddress('solana', address);
+    if (!privyWallet) {
+      throw new Error(`Privy wallet not found for address: ${address}`);
+    }
+    return new PrivySolanaSigner(
+      privyWallet.privyWalletId,
+      address,
+      this.network
+    );
+  }
+```
+
+### 9. `src/wallet/wallet.routes.ts`
+
+Add imports at the top:
+```typescript
+import {
+  getPrivyWallets,
+  savePrivyWallets,
+  getPrivyWalletAddresses,
+  PrivyWalletData
+} from './utils';
+import { PrivyClient } from './privy/privy-client';
+```
+
+Add these route handlers:
+
+```typescript
+// Add Privy wallet
+fastify.post(
+  '/wallet/add-privy',
+  {
+    schema: {
+      description: 'Register a Privy server wallet',
+      tags: ['wallet'],
+      body: Type.Object({
+        chain: Type.String({ description: 'Chain name (ethereum or solana)' }),
+        privyWalletId: Type.String({ description: 'Privy wallet ID' }),
+      }),
+      response: {
+        200: Type.Object({
+          address: Type.String(),
+          chain: Type.String(),
+          type: Type.Literal('privy'),
+        }),
+      },
+    },
+  },
+  async (request) => {
+    const { chain, privyWalletId } = request.body as { chain: string; privyWalletId: string };
+
+    // Validate chain
+    const supportedChains = ['ethereum', 'solana'];
+    if (!supportedChains.includes(chain.toLowerCase())) {
+      throw fastify.httpErrors.badRequest(`Unsupported chain: ${chain}. Supported: ${supportedChains.join(', ')}`);
+    }
+
+    // Get wallet info from Privy
+    const privy = PrivyClient.getInstance();
+    const privyWallet = await privy.getWallet(privyWalletId);
+
+    // Validate chain type matches
+    const expectedChainType = chain.toLowerCase() === 'ethereum' ? 'ethereum' : 'solana';
+    if (privyWallet.chainType !== expectedChainType) {
+      throw fastify.httpErrors.badRequest(
+        `Wallet chain type mismatch: expected ${expectedChainType}, got ${privyWallet.chainType}`
+      );
+    }
+
+    // Check if already registered
+    const existingWallets = await getPrivyWallets(chain);
+    if (existingWallets.some((w) => w.address.toLowerCase() === privyWallet.address.toLowerCase())) {
+      throw fastify.httpErrors.badRequest(`Privy wallet already registered: ${privyWallet.address}`);
+    }
+
+    // Add wallet
+    const newWallet: PrivyWalletData = {
+      address: privyWallet.address,
+      privyWalletId: privyWalletId,
+      addedAt: new Date().toISOString(),
+    };
+    await savePrivyWallets(chain, [...existingWallets, newWallet]);
+
+    return {
+      address: privyWallet.address,
+      chain: chain.toLowerCase(),
+      type: 'privy' as const,
+    };
+  }
+);
+
+// Remove Privy wallet
+fastify.delete(
+  '/wallet/remove-privy',
+  {
+    schema: {
+      description: 'Unregister a Privy server wallet',
+      tags: ['wallet'],
+      body: Type.Object({
+        chain: Type.String({ description: 'Chain name (ethereum or solana)' }),
+        address: Type.String({ description: 'Wallet address to remove' }),
+      }),
+      response: {
+        200: Type.Object({
+          removed: Type.Boolean(),
+          address: Type.String(),
+        }),
+      },
+    },
+  },
+  async (request) => {
+    const { chain, address } = request.body as { chain: string; address: string };
+
+    const existingWallets = await getPrivyWallets(chain);
+    const filteredWallets = existingWallets.filter(
+      (w) => w.address.toLowerCase() !== address.toLowerCase()
+    );
+
+    if (filteredWallets.length === existingWallets.length) {
+      throw fastify.httpErrors.notFound(`Privy wallet not found: ${address}`);
+    }
+
+    await savePrivyWallets(chain, filteredWallets);
+
+    return { removed: true, address };
+  }
+);
+```
+
+Update the existing `GET /wallet` handler to include Privy wallets in the response. Find where `hardwareWalletAddresses` is added to the response and add:
+```typescript
+const privyAddresses = await getPrivyWalletAddresses(chain);
+// Add to response object:
+privyWalletAddresses: privyAddresses.length > 0 ? privyAddresses : undefined,
+```
+
+---
+
+## Connector Updates
+
+### Jupiter (example for Solana connectors)
+
+In `src/connectors/jupiter/router-routes/executeQuote.ts`, update the wallet handling:
+
+**Find this pattern:**
+```typescript
+const isHardwareWallet = await solana.isHardwareWallet(walletAddress);
+```
+
+**Add Privy check after it:**
+```typescript
+const isHardwareWallet = await solana.isHardwareWallet(walletAddress);
+const isPrivyWallet = await solana.isPrivyWallet(walletAddress);
+```
+
+**Update the branching logic:**
+```typescript
+if (isHardwareWallet) {
+  // existing hardware wallet code...
+} else if (isPrivyWallet) {
+  // Privy wallet: build unsigned transaction, sign with Privy
+  transaction = await jupiter.buildSwapTransactionForHardwareWallet(walletAddress, quote, maxLamports, priorityLevel);
+  const privySigner = await solana.getPrivySigner(walletAddress);
+  transaction = await privySigner.signTransaction(transaction);
+} else {
+  // existing local wallet code...
+}
+```
+
+Apply the same pattern to: Raydium, Meteora connectors.
+
+### EVM Connectors (Uniswap, 0x)
+
+For EVM connectors, add similar branching. In `executeQuote.ts` or equivalent:
+
+```typescript
+const isHardwareWallet = await ethereum.isHardwareWallet(walletAddress);
+const isPrivyWallet = await ethereum.isPrivyWallet(walletAddress);
+
+let wallet: Wallet | PrivyEvmSigner;
+if (isPrivyWallet) {
+  wallet = await ethereum.getPrivySigner(walletAddress);
+} else if (isHardwareWallet) {
+  // existing hardware wallet handling...
+} else {
+  wallet = await ethereum.getWallet(walletAddress);
+}
+```
+
+---
+
+## Implementation Checklist
+
+1. [ ] Add Privy credentials to `src/templates/apiKeys.yml`
+2. [ ] Add Privy properties to `src/templates/namespace/apiKeys-schema.json`
+3. [ ] Create `src/wallet/privy/` directory
+4. [ ] Create `src/wallet/privy/privy-client.ts`
+5. [ ] Create `src/wallet/privy/privy-evm-signer.ts`
+6. [ ] Create `src/wallet/privy/privy-solana-signer.ts`
+7. [ ] Add Privy wallet functions to `src/wallet/utils.ts`
+8. [ ] Add `isPrivyWallet()` and `getPrivySigner()` to `src/chains/ethereum/ethereum.ts`
+9. [ ] Add `isPrivyWallet()` and `getPrivySigner()` to `src/chains/solana/solana.ts`
+10. [ ] Add `/wallet/add-privy` and `/wallet/remove-privy` routes to `src/wallet/wallet.routes.ts`
+11. [ ] Update Jupiter connector with Privy support
+12. [ ] Update Raydium connector with Privy support
+13. [ ] Update Meteora connector with Privy support
+14. [ ] Update Uniswap connector with Privy support (if needed)
+15. [ ] Run `pnpm build` to verify no TypeScript errors
+16. [ ] Run `pnpm test` to verify existing tests pass
+17. [ ] Create unit tests for Privy client and signers
+
+---
+
+## Policy Configuration (Privy Dashboard)
+
+Policies are managed entirely in Privy Dashboard, not in Gateway. Example workflow:
+
+1. Go to Privy Dashboard → Policies
+2. Create a policy with rules (allowed contracts, max amounts, etc.)
+3. Create a server wallet and attach the policy
+4. Copy the wallet ID
+5. In Gateway: `POST /wallet/add-privy` with the wallet ID
+
+Example Ethereum policy for DEX trading:
+```json
+{
+  "version": "1.0",
+  "name": "Hummingbot DEX Trading",
+  "chain_type": "ethereum",
+  "rules": [
+    {
+      "name": "Allow Uniswap V3 Router",
+      "method": "eth_sendTransaction",
+      "conditions": [
+        { "field_source": "ethereum_transaction", "field": "to", "operator": "eq", "value": "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45" }
+      ],
+      "action": "ALLOW"
+    },
+    {
+      "name": "Max 1 ETH per transaction",
+      "method": "eth_sendTransaction",
+      "conditions": [
+        { "field_source": "ethereum_transaction", "field": "value", "operator": "lte", "value": "0xDE0B6B3A7640000" }
+      ],
+      "action": "ALLOW"
+    },
+    {
+      "name": "Deny everything else",
+      "method": "*",
+      "conditions": [],
+      "action": "DENY"
+    }
+  ]
+}
+```
+
+Example Solana policy:
+```json
+{
+  "version": "1.0",
+  "name": "Hummingbot Solana Trading",
+  "chain_type": "solana",
+  "rules": [
+    {
+      "name": "Allow Jupiter",
+      "method": "signAndSendTransaction",
+      "conditions": [
+        { "field_source": "solana_program_instruction", "field": "programId", "operator": "eq", "value": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4" }
+      ],
+      "action": "ALLOW"
+    },
+    {
+      "name": "Max 10 SOL per transaction",
+      "method": "signAndSendTransaction",
+      "conditions": [
+        { "field_source": "solana_system_instruction", "field": "lamports", "operator": "lte", "value": "10000000000" }
+      ],
+      "action": "ALLOW"
+    }
+  ]
+}
+```

From f6e06208dbfcd7f70030e3d79f705386da4f0bff Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Mon, 9 Feb 2026 11:42:55 -0800
Subject: [PATCH 26/37] feat(solana): improve priority fee estimation with
 configurable min/max clamping

- Add priorityFeeLevel as request parameter to /chains/solana/estimate-gas (default: High)
- Add maxPriorityFeePerCU config option to cap priority fees (default: 1.0 lamports/CU)
- Add getHeliusApiKey helper to extract API key from config or nodeURL
- Return priorityFeeLevel and priorityFeePerCUEstimate in response for debugging
- Add comprehensive tests for priority fee functionality

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/solana/routes/estimate-gas.ts      |  24 +-
 src/chains/solana/schemas.ts                  |   9 +
 src/chains/solana/solana-priority-fees.ts     | 176 ++++++---
 src/chains/solana/solana.config.ts            |   2 +
 src/chains/solana/solana.ts                   |  18 +-
 src/schemas/chain-schema.ts                   |   3 +
 src/templates/chains/solana/devnet.yml        |   4 +
 src/templates/chains/solana/mainnet-beta.yml  |   4 +
 .../namespace/solana-network-schema.json      |  11 +-
 .../solana/solana-priority-fees.test.ts       | 342 ++++++++++++++++++
 10 files changed, 535 insertions(+), 58 deletions(-)
 create mode 100644 test/chains/solana/solana-priority-fees.test.ts

diff --git a/src/chains/solana/routes/estimate-gas.ts b/src/chains/solana/routes/estimate-gas.ts
index 7e9049b0e5..6ed259d562 100644
--- a/src/chains/solana/routes/estimate-gas.ts
+++ b/src/chains/solana/routes/estimate-gas.ts
@@ -1,21 +1,22 @@
 import { FastifyPluginAsync } from 'fastify';
 
-import { EstimateGasRequestType, EstimateGasResponse, EstimateGasResponseSchema } from '../../../schemas/chain-schema';
+import { EstimateGasResponse, EstimateGasResponseSchema } from '../../../schemas/chain-schema';
 import { httpErrors } from '../../../services/error-handler';
 import { logger } from '../../../services/logger';
-import { SolanaEstimateGasRequest } from '../schemas';
+import { SolanaEstimateGasRequest, SolanaEstimateGasRequestType } from '../schemas';
 import { Solana } from '../solana';
 
-export async function estimateGasSolana(network: string): Promise<EstimateGasResponse> {
+export async function estimateGasSolana(network: string, priorityFeeLevel?: string): Promise<EstimateGasResponse> {
   try {
     const solana = await Solana.getInstance(network);
-    const priorityFeePerCUInLamports = await solana.estimateGasPrice();
+
+    const feeResult = await solana.estimateGasPriceDetailed(priorityFeeLevel as any);
 
     // Get default compute units from config (typically 200000)
     const defaultComputeUnits = solana.config.defaultComputeUnits;
 
     // Calculate total priority fee in lamports
-    const totalPriorityFeeInLamports = priorityFeePerCUInLamports * defaultComputeUnits;
+    const totalPriorityFeeInLamports = feeResult.feePerComputeUnit * defaultComputeUnits;
 
     // Add base fee (5000 lamports per signature)
     const baseFeeInLamports = 5000;
@@ -25,12 +26,14 @@ export async function estimateGasSolana(network: string): Promise<EstimateGasRes
     const totalFeeInSol = totalFeeInLamports / 1e9;
 
     return {
-      feePerComputeUnit: priorityFeePerCUInLamports,
+      feePerComputeUnit: feeResult.feePerComputeUnit,
       denomination: 'lamports',
       computeUnits: defaultComputeUnits,
       feeAsset: solana.nativeTokenSymbol,
       fee: totalFeeInSol,
       timestamp: Date.now(),
+      priorityFeeLevel: feeResult.priorityFeeLevel,
+      priorityFeePerCUEstimate: feeResult.priorityFeePerCUEstimate ?? undefined,
     };
   } catch (error) {
     logger.error(`Error estimating gas for network ${network}: ${error.message}`);
@@ -72,13 +75,14 @@ export async function estimateGasSolana(network: string): Promise<EstimateGasRes
 
 export const estimateGasRoute: FastifyPluginAsync = async (fastify) => {
   fastify.get<{
-    Querystring: EstimateGasRequestType;
+    Querystring: SolanaEstimateGasRequestType;
     Reply: EstimateGasResponse;
   }>(
     '/estimate-gas',
     {
       schema: {
-        description: 'Estimate gas prices for Solana transactions',
+        description:
+          'Estimate priority fees for Solana transactions. Optionally pass addresses (program IDs, pools) for Helius-specific fee estimation.',
         tags: ['/chain/solana'],
         querystring: SolanaEstimateGasRequest,
         response: {
@@ -87,8 +91,8 @@ export const estimateGasRoute: FastifyPluginAsync = async (fastify) => {
       },
     },
     async (request) => {
-      const { network } = request.query;
-      return await estimateGasSolana(network);
+      const { network, priorityFeeLevel } = request.query;
+      return await estimateGasSolana(network, priorityFeeLevel);
     },
   );
 };
diff --git a/src/chains/solana/schemas.ts b/src/chains/solana/schemas.ts
index 1f6e530a7c..b48d963214 100644
--- a/src/chains/solana/schemas.ts
+++ b/src/chains/solana/schemas.ts
@@ -49,8 +49,17 @@ export const SolanaBalanceRequest = Type.Object({
 // Estimate gas request schema
 export const SolanaEstimateGasRequest = Type.Object({
   network: SolanaNetworkParameter,
+  priorityFeeLevel: Type.Optional(
+    Type.String({
+      description: 'Helius priority fee level for transaction processing',
+      enum: ['Min', 'Low', 'Medium', 'High', 'VeryHigh', 'UnsafeMax'],
+      default: 'High',
+    }),
+  ),
 });
 
+export type SolanaEstimateGasRequestType = Static<typeof SolanaEstimateGasRequest>;
+
 // Poll request schema
 export const SolanaPollRequest = Type.Object({
   network: SolanaNetworkParameter,
diff --git a/src/chains/solana/solana-priority-fees.ts b/src/chains/solana/solana-priority-fees.ts
index b2b03254b2..502513a607 100644
--- a/src/chains/solana/solana-priority-fees.ts
+++ b/src/chains/solana/solana-priority-fees.ts
@@ -2,44 +2,118 @@ import { logger } from '../../services/logger';
 
 import { SolanaNetworkConfig } from './solana.config';
 
+/**
+ * Helius priority fee levels for transaction processing
+ * Must match Helius API casing: Min, Low, Medium, High, VeryHigh, UnsafeMax
+ * @see https://docs.helius.dev/solana-apis/priority-fee-api
+ */
+export type PriorityFeeLevel = 'Min' | 'Low' | 'Medium' | 'High' | 'VeryHigh' | 'UnsafeMax';
+
+/**
+ * Detailed result from priority fee estimation
+ */
+export interface PriorityFeeResult {
+  /** Final fee per compute unit in lamports (after minimum enforcement) */
+  feePerComputeUnit: number;
+  /** Priority level used for the estimate */
+  priorityFeeLevel: PriorityFeeLevel;
+  /** Raw Helius estimate in lamports/CU (before minimum enforcement), null if Helius not used */
+  priorityFeePerCUEstimate: number | null;
+}
+
+/**
+ * Extract Helius API key from various sources
+ * @param nodeURL The node URL from config
+ * @returns API key if found, null otherwise
+ */
+export async function getHeliusApiKey(nodeURL?: string): Promise<string | null> {
+  // First try apiKeys.helius from config
+  const { ConfigManagerV2 } = await import('../../services/config-manager-v2');
+  const configManager = ConfigManagerV2.getInstance();
+  const configApiKey = configManager.get('apiKeys.helius') || '';
+
+  if (configApiKey && configApiKey.trim() !== '' && !configApiKey.includes('YOUR_')) {
+    return configApiKey;
+  }
+
+  // If not found, try to extract from nodeURL if it's a Helius URL
+  if (nodeURL && nodeURL.includes('helius')) {
+    try {
+      const url = new URL(nodeURL);
+      // Check for api-key query parameter (e.g., https://mainnet.helius-rpc.com/?api-key=xxx)
+      const apiKeyParam = url.searchParams.get('api-key');
+      if (apiKeyParam && apiKeyParam.trim() !== '' && !apiKeyParam.includes('YOUR_')) {
+        return apiKeyParam;
+      }
+    } catch {
+      // Invalid URL, ignore
+    }
+  }
+
+  return null;
+}
+
 /**
  * Priority fee estimation using Helius getPriorityFeeEstimate RPC method
  */
 export class SolanaPriorityFees {
-  private static lastPriorityFeeEstimate: {
-    [network: string]: {
-      timestamp: number;
-      fee: number;
-    };
-  } = {};
-  private static readonly PRIORITY_FEE_CACHE_MS = 10000; // 10 second cache
+  // Default accounts used when no specific accounts are provided
+  private static readonly DEFAULT_ACCOUNT_KEYS = [
+    'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', // Token Program
+    'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL', // Associated Token Program
+  ];
 
   /**
    * Estimates priority fees using Helius getPriorityFeeEstimate RPC method
+   * @param config Network configuration containing minPriorityFeePerCU and maxPriorityFeePerCU
+   * @param _network Network name (unused, kept for compatibility)
+   * @param priorityLevel Priority fee level (defaults to High)
+   * @returns Final fee per compute unit in lamports
    */
-  public static async estimatePriorityFee(config: SolanaNetworkConfig, network: string): Promise<number> {
-    // Check cache first (per-network)
-    const cachedEstimate = SolanaPriorityFees.lastPriorityFeeEstimate[network];
-    if (cachedEstimate && Date.now() - cachedEstimate.timestamp < SolanaPriorityFees.PRIORITY_FEE_CACHE_MS) {
-      logger.debug(`Using cached priority fee for ${network}: ${cachedEstimate.fee.toFixed(4)} lamports/CU`);
-      return cachedEstimate.fee;
-    }
+  public static async estimatePriorityFee(
+    config: SolanaNetworkConfig,
+    _network: string,
+    priorityLevel?: PriorityFeeLevel,
+  ): Promise<number> {
+    const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(config, _network, priorityLevel);
+    return result.feePerComputeUnit;
+  }
+
+  /**
+   * Estimates priority fees with detailed results including raw Helius estimate
+   * @param config Network configuration containing minPriorityFeePerCU and maxPriorityFeePerCU
+   * @param _network Network name (unused, kept for compatibility)
+   * @param priorityLevel Priority fee level (defaults to High)
+   * @returns Detailed fee estimation result
+   */
+  public static async estimatePriorityFeeDetailed(
+    config: SolanaNetworkConfig,
+    _network: string,
+    priorityLevel?: PriorityFeeLevel,
+  ): Promise<PriorityFeeResult> {
+    const accountKeys = SolanaPriorityFees.DEFAULT_ACCOUNT_KEYS;
+    const level: PriorityFeeLevel = priorityLevel || 'High';
+    const minimumFee = config.minPriorityFeePerCU || 0.1;
+    const maximumFee = config.maxPriorityFeePerCU || 1.0;
 
     try {
-      // Try to get Helius API key from apiKeys config
-      const { ConfigManagerV2 } = await import('../../services/config-manager-v2');
-      const configManager = ConfigManagerV2.getInstance();
-      const apiKey = configManager.get('apiKeys.helius') || '';
-
-      if (!apiKey || apiKey.trim() === '' || apiKey.includes('YOUR_')) {
-        const minimumFee = config.minPriorityFeePerCU || 0.1;
-        logger.info(`No valid Helius API key, using minimum fee: ${minimumFee.toFixed(4)} lamports/CU`);
-        return minimumFee;
+      // Get Helius API key from config or nodeURL
+      const apiKey = await getHeliusApiKey(config.nodeURL);
+
+      if (!apiKey) {
+        logger.info(`[${level}] No Helius API key found, using minimum fee: ${minimumFee.toFixed(4)} lamports/CU`);
+        return {
+          feePerComputeUnit: minimumFee,
+          priorityFeeLevel: level,
+          priorityFeePerCUEstimate: null,
+        };
       }
 
       // Construct the request URL
       const requestUrl = `https://mainnet.helius-rpc.com/?api-key=${apiKey}`;
 
+      logger.debug(`[${level}] Fetching priority fee estimate with ${accountKeys.length} account keys`);
+
       const response = await fetch(requestUrl, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -47,8 +121,8 @@ export class SolanaPriorityFees {
           method: 'getPriorityFeeEstimate',
           params: [
             {
-              accountKeys: ['11111111111111111111111111111112'], // System Program
-              options: { recommended: true },
+              accountKeys,
+              options: { priorityLevel: level },
             },
           ],
           id: 1,
@@ -57,45 +131,61 @@ export class SolanaPriorityFees {
       });
 
       if (!response.ok) {
-        logger.error(`Failed to fetch priority fee estimate: ${response.status}`);
-        return config.minPriorityFeePerCU || 0.1;
+        logger.error(`[${level}] Failed to fetch priority fee estimate: ${response.status}`);
+        return {
+          feePerComputeUnit: minimumFee,
+          priorityFeeLevel: level,
+          priorityFeePerCUEstimate: null,
+        };
       }
 
       const data = await response.json();
 
       if (data.error) {
-        logger.error(`Priority fee estimate RPC error: ${JSON.stringify(data.error)}`);
-        return config.minPriorityFeePerCU || 0.1;
+        logger.error(`[${level}] Priority fee estimate RPC error: ${JSON.stringify(data.error)}`);
+        return {
+          feePerComputeUnit: minimumFee,
+          priorityFeeLevel: level,
+          priorityFeePerCUEstimate: null,
+        };
       }
 
       const priorityFeeEstimate = data.result?.priorityFeeEstimate;
 
       if (typeof priorityFeeEstimate !== 'number') {
-        logger.warn('Invalid priority fee estimate response, using minimum fee');
-        return config.minPriorityFeePerCU || 0.1;
+        logger.warn(`[${level}] Invalid priority fee estimate response, using minimum fee`);
+        return {
+          feePerComputeUnit: minimumFee,
+          priorityFeeLevel: level,
+          priorityFeePerCUEstimate: null,
+        };
       }
 
       // Convert from micro-lamports to lamports per compute unit
       const priorityFeeLamports = priorityFeeEstimate / 1_000_000;
 
-      // Ensure fee is not below minimum
-      const minimumFee = config.minPriorityFeePerCU || 0.1;
-      const finalFee = Math.max(priorityFeeLamports, minimumFee);
+      // Clamp fee between minimum and maximum
+      const finalFee = Math.min(Math.max(priorityFeeLamports, minimumFee), maximumFee);
+
+      const clampInfo =
+        priorityFeeLamports < minimumFee ? 'min enforced' : priorityFeeLamports > maximumFee ? 'max enforced' : 'ok';
 
       logger.info(
-        `Priority fee estimate: ${priorityFeeLamports.toFixed(4)} lamports/CU -> using ${finalFee.toFixed(4)} lamports/CU (${finalFee === minimumFee ? 'minimum enforced' : 'recommended'})`,
+        `[${level}] Priority fee: ${priorityFeeLamports.toFixed(6)} -> ${finalFee.toFixed(6)} lamports/CU (${clampInfo})`,
       );
 
-      // Cache the result (per-network)
-      SolanaPriorityFees.lastPriorityFeeEstimate[network] = {
-        timestamp: Date.now(),
-        fee: finalFee,
+      return {
+        feePerComputeUnit: finalFee,
+        priorityFeeLevel: level,
+        priorityFeePerCUEstimate: priorityFeeLamports,
       };
-
-      return finalFee;
     } catch (error: any) {
-      logger.error(`Failed to fetch priority fee estimate: ${error.message}, using minimum fee`);
-      return config.minPriorityFeePerCU || 0.1;
+      logger.error(`[${level}] Failed to fetch priority fee estimate: ${error.message}, using minimum fee`);
+      return {
+        feePerComputeUnit: minimumFee,
+        priorityFeeLevel: level,
+        priorityFeePerCUEstimate: null,
+      };
     }
   }
 }
diff --git a/src/chains/solana/solana.config.ts b/src/chains/solana/solana.config.ts
index 01746d3184..bbf2c9c6ab 100644
--- a/src/chains/solana/solana.config.ts
+++ b/src/chains/solana/solana.config.ts
@@ -12,6 +12,7 @@ export interface SolanaNetworkConfig {
   confirmRetryInterval: number;
   confirmRetryCount: number;
   minPriorityFeePerCU: number;
+  maxPriorityFeePerCU?: number;
 }
 
 export interface SolanaChainConfig {
@@ -36,6 +37,7 @@ export function getSolanaNetworkConfig(network: string): SolanaNetworkConfig {
     confirmRetryInterval: ConfigManagerV2.getInstance().get(namespaceId + '.confirmRetryInterval'),
     confirmRetryCount: ConfigManagerV2.getInstance().get(namespaceId + '.confirmRetryCount'),
     minPriorityFeePerCU: ConfigManagerV2.getInstance().get(namespaceId + '.minPriorityFeePerCU'),
+    maxPriorityFeePerCU: ConfigManagerV2.getInstance().get(namespaceId + '.maxPriorityFeePerCU'),
   };
 }
 
diff --git a/src/chains/solana/solana.ts b/src/chains/solana/solana.ts
index 5ad6e71089..bfb8296a9b 100644
--- a/src/chains/solana/solana.ts
+++ b/src/chains/solana/solana.ts
@@ -42,7 +42,7 @@ import { logger, redactUrl } from '../../services/logger';
 import { TokenService } from '../../services/token-service';
 import { getSafeWalletFilePath, isHardwareWallet as isHardwareWalletUtil } from '../../wallet/utils';
 
-import { SolanaPriorityFees } from './solana-priority-fees';
+import { PriorityFeeLevel, PriorityFeeResult, SolanaPriorityFees } from './solana-priority-fees';
 import { SolanaNetworkConfig, getSolanaNetworkConfig, getSolanaChainConfig } from './solana.config';
 
 // Constants used for fee calculations
@@ -1136,8 +1136,20 @@ export class Solana {
     };
   }
 
-  async estimateGasPrice(): Promise<number> {
-    return await SolanaPriorityFees.estimatePriorityFee(this.config, this.network);
+  /**
+   * Estimate priority fee per compute unit
+   * @param priorityLevel Priority fee level (defaults to High)
+   */
+  async estimateGasPrice(priorityLevel?: PriorityFeeLevel): Promise<number> {
+    return await SolanaPriorityFees.estimatePriorityFee(this.config, this.network, priorityLevel);
+  }
+
+  /**
+   * Estimate priority fee with detailed results including raw Helius estimate
+   * @param priorityLevel Priority fee level (defaults to High)
+   */
+  async estimateGasPriceDetailed(priorityLevel?: PriorityFeeLevel): Promise<PriorityFeeResult> {
+    return await SolanaPriorityFees.estimatePriorityFeeDetailed(this.config, this.network, priorityLevel);
   }
 
   public async confirmTransaction(
diff --git a/src/schemas/chain-schema.ts b/src/schemas/chain-schema.ts
index 1321418fe3..961fe17070 100644
--- a/src/schemas/chain-schema.ts
+++ b/src/schemas/chain-schema.ts
@@ -26,6 +26,9 @@ export const EstimateGasResponseSchema = Type.Object(
     gasType: Type.Optional(Type.String()), // Gas type: "legacy" or "eip1559"
     maxFeePerGas: Type.Optional(Type.Number()), // EIP-1559: Maximum fee per gas in gwei
     maxPriorityFeePerGas: Type.Optional(Type.Number()), // EIP-1559: Maximum priority fee per gas in gwei
+    // Solana Helius-specific fields
+    priorityFeeLevel: Type.Optional(Type.String()), // Helius priority level used: Min, Low, Medium, High, VeryHigh, UnsafeMax
+    priorityFeePerCUEstimate: Type.Optional(Type.Number()), // Raw Helius estimate in lamports/CU (before minimum enforcement)
   },
   { $id: 'EstimateGasResponse' },
 );
diff --git a/src/templates/chains/solana/devnet.yml b/src/templates/chains/solana/devnet.yml
index fc749431e5..5ab2c38ef3 100644
--- a/src/templates/chains/solana/devnet.yml
+++ b/src/templates/chains/solana/devnet.yml
@@ -19,3 +19,7 @@ confirmRetryCount: 10
 # Minimum priority fee per compute unit in lamports
 # This sets the floor for priority fees to ensure transactions are processed (default: 0.1 lamports/CU)
 minPriorityFeePerCU: 0.01
+
+# Maximum priority fee per compute unit in lamports
+# This sets the ceiling for priority fees to prevent overpaying (default: 1.0 lamports/CU)
+maxPriorityFeePerCU: 1.0
diff --git a/src/templates/chains/solana/mainnet-beta.yml b/src/templates/chains/solana/mainnet-beta.yml
index 58a6f71d69..c9ced8f15f 100644
--- a/src/templates/chains/solana/mainnet-beta.yml
+++ b/src/templates/chains/solana/mainnet-beta.yml
@@ -19,3 +19,7 @@ confirmRetryCount: 10
 # Minimum priority fee per compute unit in lamports
 # This sets the floor for priority fees to ensure transactions are processed (default: 0.1 lamports/CU)
 minPriorityFeePerCU: 0.1
+
+# Maximum priority fee per compute unit in lamports
+# This sets the ceiling for priority fees to prevent overpaying (default: 1.0 lamports/CU)
+maxPriorityFeePerCU: 1.0
diff --git a/src/templates/namespace/solana-network-schema.json b/src/templates/namespace/solana-network-schema.json
index 277337dfae..56181984a6 100644
--- a/src/templates/namespace/solana-network-schema.json
+++ b/src/templates/namespace/solana-network-schema.json
@@ -20,8 +20,15 @@
     "defaultComputeUnits": { "type": "number" },
     "confirmRetryInterval": { "type": "number" },
     "confirmRetryCount": { "type": "number" },
-    "minPriorityFeePerCU": { "type": "number" }
+    "minPriorityFeePerCU": {
+      "type": "number",
+      "description": "Minimum priority fee per compute unit in lamports (floor for fee estimation)"
+    },
+    "maxPriorityFeePerCU": {
+      "type": "number",
+      "description": "Maximum priority fee per compute unit in lamports (ceiling for fee estimation)"
+    }
   },
   "required": ["chainID", "nodeURL", "nativeCurrencySymbol", "geckoId"],
-  "additionalProperties": false
+  "additionalProperties": true
 }
diff --git a/test/chains/solana/solana-priority-fees.test.ts b/test/chains/solana/solana-priority-fees.test.ts
new file mode 100644
index 0000000000..0a663d2b43
--- /dev/null
+++ b/test/chains/solana/solana-priority-fees.test.ts
@@ -0,0 +1,342 @@
+import { getHeliusApiKey, PriorityFeeLevel, SolanaPriorityFees } from '../../../src/chains/solana/solana-priority-fees';
+import { SolanaNetworkConfig } from '../../../src/chains/solana/solana.config';
+
+// Mock the config manager
+jest.mock('../../../src/services/config-manager-v2', () => ({
+  ConfigManagerV2: {
+    getInstance: jest.fn(() => ({
+      get: jest.fn(),
+    })),
+  },
+}));
+
+// Mock fetch for Helius API calls
+global.fetch = jest.fn() as jest.MockedFunction<typeof fetch>;
+
+describe('Solana Priority Fees', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getHeliusApiKey', () => {
+    it('returns API key from apiKeys.helius config when available', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('config-api-key-123');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await getHeliusApiKey();
+
+      expect(result).toBe('config-api-key-123');
+      expect(mockGet).toHaveBeenCalledWith('apiKeys.helius');
+    });
+
+    it('extracts API key from Helius nodeURL when config key not available', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const nodeURL = 'https://mainnet.helius-rpc.com/?api-key=url-api-key-456';
+      const result = await getHeliusApiKey(nodeURL);
+
+      expect(result).toBe('url-api-key-456');
+    });
+
+    it('returns null when no API key found in config or URL', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await getHeliusApiKey('https://api.mainnet-beta.solana.com');
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null for non-Helius URL without config key', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await getHeliusApiKey('https://some-other-rpc.com/?api-key=some-key');
+
+      expect(result).toBeNull();
+    });
+
+    it('ignores placeholder API keys (YOUR_*)', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('YOUR_HELIUS_API_KEY');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await getHeliusApiKey();
+
+      expect(result).toBeNull();
+    });
+
+    it('prefers config API key over URL when both available', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('config-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const nodeURL = 'https://mainnet.helius-rpc.com/?api-key=url-key';
+      const result = await getHeliusApiKey(nodeURL);
+
+      expect(result).toBe('config-key');
+    });
+
+    it('handles invalid URL gracefully', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await getHeliusApiKey('not-a-valid-url');
+
+      expect(result).toBeNull();
+    });
+
+    it('extracts API key from helius-rpc.com URL', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const nodeURL = 'https://devnet.helius-rpc.com/?api-key=devnet-key-789';
+      const result = await getHeliusApiKey(nodeURL);
+
+      expect(result).toBe('devnet-key-789');
+    });
+  });
+
+  describe('SolanaPriorityFees.estimatePriorityFeeDetailed', () => {
+    const mockConfig: SolanaNetworkConfig = {
+      chainID: 101,
+      nodeURL: 'https://mainnet.helius-rpc.com/?api-key=test-key',
+      nativeCurrencySymbol: 'SOL',
+      geckoId: 'solana',
+      defaultComputeUnits: 200000,
+      confirmRetryInterval: 1,
+      confirmRetryCount: 10,
+      minPriorityFeePerCU: 0.1,
+      maxPriorityFeePerCU: 1.0,
+    };
+
+    it('returns minimum fee when no Helius API key available', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const configWithoutHelius = {
+        ...mockConfig,
+        nodeURL: 'https://api.mainnet-beta.solana.com',
+      };
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(configWithoutHelius, 'mainnet-beta');
+
+      expect(result.feePerComputeUnit).toBe(0.1);
+      expect(result.priorityFeeLevel).toBe('High');
+      expect(result.priorityFeePerCUEstimate).toBeNull();
+    });
+
+    it('uses High as default priority level', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(
+        { ...mockConfig, nodeURL: 'https://api.solana.com' },
+        'mainnet-beta',
+      );
+
+      expect(result.priorityFeeLevel).toBe('High');
+    });
+
+    it('respects provided priority level', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(
+        { ...mockConfig, nodeURL: 'https://api.solana.com' },
+        'mainnet-beta',
+        'VeryHigh',
+      );
+
+      expect(result.priorityFeeLevel).toBe('VeryHigh');
+    });
+
+    it('clamps fee to minimum when Helius returns lower value', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      // Mock Helius returning 0 (Min level often returns 0)
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          result: { priorityFeeEstimate: 0 }, // 0 micro-lamports
+        }),
+      });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', 'Min');
+
+      expect(result.feePerComputeUnit).toBe(0.1); // Clamped to minimum
+      expect(result.priorityFeePerCUEstimate).toBe(0); // Raw estimate was 0
+    });
+
+    it('clamps fee to maximum when Helius returns higher value', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      // Mock Helius returning very high fee (5 lamports/CU = 5,000,000 micro-lamports)
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          result: { priorityFeeEstimate: 5000000 },
+        }),
+      });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', 'VeryHigh');
+
+      expect(result.feePerComputeUnit).toBe(1.0); // Clamped to maximum
+      expect(result.priorityFeePerCUEstimate).toBe(5); // Raw estimate was 5 lamports/CU
+    });
+
+    it('returns unclamped fee when within min/max bounds', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      // Mock Helius returning 0.5 lamports/CU = 500,000 micro-lamports
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          result: { priorityFeeEstimate: 500000 },
+        }),
+      });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', 'High');
+
+      expect(result.feePerComputeUnit).toBe(0.5);
+      expect(result.priorityFeePerCUEstimate).toBe(0.5);
+    });
+
+    it('handles Helius API error gracefully', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+      });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+
+      expect(result.feePerComputeUnit).toBe(0.1); // Falls back to minimum
+      expect(result.priorityFeePerCUEstimate).toBeNull();
+    });
+
+    it('handles Helius RPC error response', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          error: { code: -32600, message: 'Invalid request' },
+        }),
+      });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+
+      expect(result.feePerComputeUnit).toBe(0.1);
+      expect(result.priorityFeePerCUEstimate).toBeNull();
+    });
+
+    it('handles network fetch error', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      (global.fetch as jest.Mock).mockRejectedValueOnce(new Error('Network error'));
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+
+      expect(result.feePerComputeUnit).toBe(0.1);
+      expect(result.priorityFeePerCUEstimate).toBeNull();
+    });
+
+    it('uses default min/max when not specified in config', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const configWithoutMinMax: SolanaNetworkConfig = {
+        chainID: 101,
+        nodeURL: 'https://api.solana.com',
+        nativeCurrencySymbol: 'SOL',
+        geckoId: 'solana',
+        defaultComputeUnits: 200000,
+        confirmRetryInterval: 1,
+        confirmRetryCount: 10,
+        minPriorityFeePerCU: 0, // Will default to 0.1
+        maxPriorityFeePerCU: undefined, // Will default to 1.0
+      };
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(configWithoutMinMax, 'mainnet-beta');
+
+      // Should use default minimum of 0.1
+      expect(result.feePerComputeUnit).toBe(0.1);
+    });
+  });
+
+  describe('SolanaPriorityFees.estimatePriorityFee', () => {
+    it('returns only the fee value (not full result object)', async () => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const mockConfig: SolanaNetworkConfig = {
+        chainID: 101,
+        nodeURL: 'https://api.solana.com',
+        nativeCurrencySymbol: 'SOL',
+        geckoId: 'solana',
+        defaultComputeUnits: 200000,
+        confirmRetryInterval: 1,
+        confirmRetryCount: 10,
+        minPriorityFeePerCU: 0.1,
+        maxPriorityFeePerCU: 1.0,
+      };
+
+      const result = await SolanaPriorityFees.estimatePriorityFee(mockConfig, 'mainnet-beta');
+
+      expect(typeof result).toBe('number');
+      expect(result).toBe(0.1);
+    });
+  });
+
+  describe('Priority fee levels', () => {
+    const levels: PriorityFeeLevel[] = ['Min', 'Low', 'Medium', 'High', 'VeryHigh', 'UnsafeMax'];
+
+    it.each(levels)('accepts %s as valid priority level', async (level) => {
+      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
+      const mockGet = jest.fn().mockReturnValue('');
+      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
+
+      const mockConfig: SolanaNetworkConfig = {
+        chainID: 101,
+        nodeURL: 'https://api.solana.com',
+        nativeCurrencySymbol: 'SOL',
+        geckoId: 'solana',
+        defaultComputeUnits: 200000,
+        confirmRetryInterval: 1,
+        confirmRetryCount: 10,
+        minPriorityFeePerCU: 0.1,
+        maxPriorityFeePerCU: 1.0,
+      };
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', level);
+
+      expect(result.priorityFeeLevel).toBe(level);
+    });
+  });
+});

From 0ed3845c15b41df5e02191eb87c1d2bddc9a5594 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 10 Feb 2026 18:24:30 -0800
Subject: [PATCH 27/37] fix(solana): use config timeout for WebSocket
 transaction confirmation

Use confirmRetryInterval * confirmRetryCount for WebSocket timeout
instead of hardcoded 60 seconds, matching REST polling behavior.
Default: 1s * 10 = 10 seconds.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/solana/solana.ts | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/chains/solana/solana.ts b/src/chains/solana/solana.ts
index bfb8296a9b..6832fca67f 100644
--- a/src/chains/solana/solana.ts
+++ b/src/chains/solana/solana.ts
@@ -42,7 +42,7 @@ import { logger, redactUrl } from '../../services/logger';
 import { TokenService } from '../../services/token-service';
 import { getSafeWalletFilePath, isHardwareWallet as isHardwareWalletUtil } from '../../wallet/utils';
 
-import { PriorityFeeLevel, PriorityFeeResult, SolanaPriorityFees } from './solana-priority-fees';
+import { PriorityFeeResult, SolanaPriorityFees } from './solana-priority-fees';
 import { SolanaNetworkConfig, getSolanaNetworkConfig, getSolanaChainConfig } from './solana.config';
 
 // Constants used for fee calculations
@@ -1138,18 +1138,18 @@ export class Solana {
 
   /**
    * Estimate priority fee per compute unit
-   * @param priorityLevel Priority fee level (defaults to High)
+   * Uses config's priorityFeeLevel and caches result for 10 seconds
    */
-  async estimateGasPrice(priorityLevel?: PriorityFeeLevel): Promise<number> {
-    return await SolanaPriorityFees.estimatePriorityFee(this.config, this.network, priorityLevel);
+  async estimateGasPrice(): Promise<number> {
+    return await SolanaPriorityFees.estimatePriorityFee(this.config, this.network);
   }
 
   /**
    * Estimate priority fee with detailed results including raw Helius estimate
-   * @param priorityLevel Priority fee level (defaults to High)
+   * Uses config's priorityFeeLevel and caches result for 10 seconds
    */
-  async estimateGasPriceDetailed(priorityLevel?: PriorityFeeLevel): Promise<PriorityFeeResult> {
-    return await SolanaPriorityFees.estimatePriorityFeeDetailed(this.config, this.network, priorityLevel);
+  async estimateGasPriceDetailed(): Promise<PriorityFeeResult> {
+    return await SolanaPriorityFees.estimatePriorityFeeDetailed(this.config, this.network);
   }
 
   public async confirmTransaction(
@@ -1522,15 +1522,23 @@ export class Solana {
     }
 
     try {
-      logger.info(`🚀 Sent transaction ${signature}, monitoring via WebSocket...`);
-      const confirmationResult = await this.rpcProviderService.monitorTransaction(signature, 60000);
+      // Use same timeout as REST polling: confirmRetryInterval * confirmRetryCount
+      const timeout = this.config.confirmRetryInterval * this.config.confirmRetryCount * 1000;
+      logger.info(`Monitoring transaction ${signature} via WebSocket (timeout: ${timeout / 1000}s)`);
+      const confirmationResult = await this.rpcProviderService.monitorTransaction(signature, timeout);
 
       if (confirmationResult.confirmed) {
         logger.info(`✅ Transaction ${signature} confirmed via WebSocket`);
-        const txData = await this.connection.getTransaction(signature, {
-          commitment: 'confirmed',
-          maxSupportedTransactionVersion: 0,
-        });
+        // Retry getTransaction a few times - tx might not be indexed yet
+        let txData = null;
+        for (let i = 0; i < 5; i++) {
+          txData = await this.connection.getTransaction(signature, {
+            commitment: 'confirmed',
+            maxSupportedTransactionVersion: 0,
+          });
+          if (txData) break;
+          await new Promise((r) => setTimeout(r, 500));
+        }
         return { confirmed: true, txData };
       } else {
         logger.warn(`❌ Transaction ${signature} not confirmed via WebSocket within timeout`);

From de6d529b600026806620499212dc2ed1e46f80e2 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 10 Feb 2026 18:29:24 -0800
Subject: [PATCH 28/37] chore: remove Privy design doc (not part of this PR)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 privy-gateway-design.md | 697 ----------------------------------------
 1 file changed, 697 deletions(-)
 delete mode 100644 privy-gateway-design.md

diff --git a/privy-gateway-design.md b/privy-gateway-design.md
deleted file mode 100644
index 853b23c266..0000000000
--- a/privy-gateway-design.md
+++ /dev/null
@@ -1,697 +0,0 @@
-# Privy Server Wallet Integration for Hummingbot Gateway
-
-## Overview
-
-Add support for Privy server wallets to enable wallet-level transaction policies (allowlisted contracts, max amounts, time restrictions). Policies are managed in Privy Dashboard; Gateway just registers wallets and signs transactions.
-
-## Files to Create
-
-### 1. `src/wallet/privy/privy-client.ts`
-```typescript
-import { ConfigManagerV2 } from '../../services/config-manager-v2';
-import { logger } from '../../services/logger';
-
-interface PrivyRpcRequest {
-  method: string;
-  caip2: string;
-  params: Record<string, unknown>;
-}
-
-interface PrivyRpcResponse {
-  data: Record<string, unknown>;
-}
-
-export class PrivyClient {
-  private static _instance: PrivyClient;
-  private appId: string;
-  private appSecret: string;
-
-  private constructor() {
-    const config = ConfigManagerV2.getInstance();
-    this.appId = config.get('apiKeys.privyAppId');
-    this.appSecret = config.get('apiKeys.privyAppSecret');
-
-    if (!this.appId || !this.appSecret) {
-      throw new Error('Privy credentials must be configured in conf/apiKeys.yml (privyAppId, privyAppSecret)');
-    }
-  }
-
-  static getInstance(): PrivyClient {
-    if (!PrivyClient._instance) {
-      PrivyClient._instance = new PrivyClient();
-    }
-    return PrivyClient._instance;
-  }
-
-  private getAuthHeaders(): Record<string, string> {
-    const basicAuth = Buffer.from(`${this.appId}:${this.appSecret}`).toString('base64');
-    return {
-      'Content-Type': 'application/json',
-      'privy-app-id': this.appId,
-      'Authorization': `Basic ${basicAuth}`,
-    };
-  }
-
-  async rpc(walletId: string, request: PrivyRpcRequest): Promise<PrivyRpcResponse> {
-    const url = `https://api.privy.io/v1/wallets/${walletId}/rpc`;
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: this.getAuthHeaders(),
-      body: JSON.stringify(request),
-    });
-
-    if (!response.ok) {
-      const body = await response.text();
-      logger.error(`Privy RPC error: ${response.status} ${body}`);
-      throw new Error(`Privy RPC failed: ${response.status} - ${body}`);
-    }
-
-    return response.json();
-  }
-
-  async getWallet(walletId: string): Promise<{ address: string; chainType: string }> {
-    const url = `https://api.privy.io/v1/wallets/${walletId}`;
-
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: this.getAuthHeaders(),
-    });
-
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Failed to get Privy wallet: ${response.status} - ${body}`);
-    }
-
-    const data = await response.json();
-    return { address: data.address, chainType: data.chain_type };
-  }
-}
-```
-
-### 2. `src/wallet/privy/privy-evm-signer.ts`
-```typescript
-import { Signer, providers, utils, BytesLike } from 'ethers';
-import { Deferrable } from 'ethers/lib/utils';
-import { PrivyClient } from './privy-client';
-import { logger } from '../../services/logger';
-
-export class PrivyEvmSigner extends Signer {
-  readonly provider: providers.Provider;
-  private privyClient: PrivyClient;
-  private walletId: string;
-  private _address: string;
-  private chainId: number;
-
-  constructor(
-    walletId: string,
-    address: string,
-    chainId: number,
-    provider: providers.Provider
-  ) {
-    super();
-    this.walletId = walletId;
-    this._address = utils.getAddress(address);
-    this.chainId = chainId;
-    this.provider = provider;
-    this.privyClient = PrivyClient.getInstance();
-  }
-
-  async getAddress(): Promise<string> {
-    return this._address;
-  }
-
-  async signTransaction(
-    transaction: Deferrable<providers.TransactionRequest>
-  ): Promise<string> {
-    const tx = await utils.resolveProperties(transaction);
-
-    const resp = await this.privyClient.rpc(this.walletId, {
-      method: 'eth_signTransaction',
-      caip2: `eip155:${this.chainId}`,
-      params: {
-        transaction: {
-          to: tx.to,
-          value: tx.value ? utils.hexlify(tx.value) : undefined,
-          data: tx.data ? utils.hexlify(tx.data) : undefined,
-          gasLimit: tx.gasLimit ? utils.hexlify(tx.gasLimit) : undefined,
-          maxFeePerGas: tx.maxFeePerGas ? utils.hexlify(tx.maxFeePerGas) : undefined,
-          maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? utils.hexlify(tx.maxPriorityFeePerGas) : undefined,
-          nonce: tx.nonce,
-          chain_id: this.chainId,
-        },
-      },
-    });
-
-    return resp.data.signedTransaction as string;
-  }
-
-  async sendTransaction(
-    transaction: Deferrable<providers.TransactionRequest>
-  ): Promise<providers.TransactionResponse> {
-    const tx = await utils.resolveProperties(transaction);
-
-    const resp = await this.privyClient.rpc(this.walletId, {
-      method: 'eth_sendTransaction',
-      caip2: `eip155:${this.chainId}`,
-      params: {
-        transaction: {
-          to: tx.to,
-          value: tx.value ? utils.hexlify(tx.value) : undefined,
-          data: tx.data ? utils.hexlify(tx.data) : undefined,
-          gasLimit: tx.gasLimit ? utils.hexlify(tx.gasLimit) : undefined,
-          maxFeePerGas: tx.maxFeePerGas ? utils.hexlify(tx.maxFeePerGas) : undefined,
-          maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? utils.hexlify(tx.maxPriorityFeePerGas) : undefined,
-          nonce: tx.nonce,
-          chain_id: this.chainId,
-        },
-      },
-    });
-
-    const hash = resp.data.hash as string;
-    logger.info(`Privy EVM tx sent: ${hash} on chain ${this.chainId}`);
-
-    return this.provider.getTransaction(hash);
-  }
-
-  async signMessage(message: string | BytesLike): Promise<string> {
-    const msgHex = typeof message === 'string'
-      ? utils.hexlify(utils.toUtf8Bytes(message))
-      : utils.hexlify(message);
-
-    const resp = await this.privyClient.rpc(this.walletId, {
-      method: 'personal_sign',
-      caip2: `eip155:${this.chainId}`,
-      params: { message: msgHex },
-    });
-
-    return resp.data.signature as string;
-  }
-
-  connect(provider: providers.Provider): PrivyEvmSigner {
-    return new PrivyEvmSigner(this.walletId, this._address, this.chainId, provider);
-  }
-}
-```
-
-### 3. `src/wallet/privy/privy-solana-signer.ts`
-```typescript
-import { VersionedTransaction, Transaction } from '@solana/web3.js';
-import { PrivyClient } from './privy-client';
-import { logger } from '../../services/logger';
-
-// CAIP-2 chain IDs for Solana networks
-const SOLANA_CAIP2: Record<string, string> = {
-  'mainnet-beta': 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-  'devnet': 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
-};
-
-export class PrivySolanaSigner {
-  readonly publicKey: string;
-  private walletId: string;
-  private privyClient: PrivyClient;
-  private caip2: string;
-
-  constructor(walletId: string, publicKey: string, network: string = 'mainnet-beta') {
-    this.walletId = walletId;
-    this.publicKey = publicKey;
-    this.privyClient = PrivyClient.getInstance();
-    this.caip2 = SOLANA_CAIP2[network] || SOLANA_CAIP2['mainnet-beta'];
-  }
-
-  async signTransaction(
-    tx: VersionedTransaction | Transaction
-  ): Promise<VersionedTransaction> {
-    const serialized = Buffer.from(tx.serialize()).toString('base64');
-
-    const resp = await this.privyClient.rpc(this.walletId, {
-      method: 'signTransaction',
-      caip2: this.caip2,
-      params: {
-        transaction: serialized,
-        encoding: 'base64',
-      },
-    });
-
-    const signedBytes = Buffer.from(resp.data.signedTransaction as string, 'base64');
-    return VersionedTransaction.deserialize(signedBytes);
-  }
-
-  async signAndSendTransaction(
-    tx: VersionedTransaction | Transaction
-  ): Promise<string> {
-    const serialized = Buffer.from(tx.serialize()).toString('base64');
-
-    const resp = await this.privyClient.rpc(this.walletId, {
-      method: 'signAndSendTransaction',
-      caip2: this.caip2,
-      params: {
-        transaction: serialized,
-        encoding: 'base64',
-      },
-    });
-
-    const hash = resp.data.hash as string;
-    logger.info(`Privy Solana tx sent: ${hash}`);
-    return hash;
-  }
-}
-```
-
----
-
-## Files to Modify
-
-### 4. `src/templates/apiKeys.yml`
-
-Add Privy credentials:
-```yaml
-# Privy - Server wallet provider with policy engine
-# Get your credentials from https://dashboard.privy.io
-privyAppId: ''
-privyAppSecret: ''
-```
-
-### 5. `src/templates/namespace/apiKeys-schema.json`
-
-Add Privy properties to the schema:
-```json
-"privyAppId": {
-  "type": "string",
-  "description": "Privy App ID for server wallets (https://dashboard.privy.io)"
-},
-"privyAppSecret": {
-  "type": "string",
-  "description": "Privy App Secret for server wallets"
-}
-```
-
-### 6. `src/wallet/utils.ts`
-
-Add these imports at the top:
-```typescript
-import fse from 'fs-extra';
-```
-
-Add these types and functions after existing hardware wallet functions:
-
-```typescript
-// ============ PRIVY WALLET FUNCTIONS ============
-
-export interface PrivyWalletData {
-  address: string;
-  privyWalletId: string;
-  addedAt: string;
-}
-
-export function getPrivyWalletPath(chain: string): string {
-  const safeChain = sanitizePathComponent(chain.toLowerCase());
-  return `${walletPath}/${safeChain}/privy-wallets.json`;
-}
-
-export async function getPrivyWallets(chain: string): Promise<PrivyWalletData[]> {
-  const filePath = getPrivyWalletPath(chain);
-
-  if (!(await fse.pathExists(filePath))) {
-    return [];
-  }
-
-  try {
-    const content = await fse.readFile(filePath, 'utf8');
-    const data = JSON.parse(content);
-    return data.wallets || [];
-  } catch (error) {
-    logger.error(`Failed to read privy wallets for ${chain}: ${error.message}`);
-    return [];
-  }
-}
-
-export async function savePrivyWallets(
-  chain: string,
-  wallets: PrivyWalletData[]
-): Promise<void> {
-  const filePath = getPrivyWalletPath(chain);
-  const dirPath = `${walletPath}/${sanitizePathComponent(chain.toLowerCase())}`;
-
-  await mkdirIfDoesNotExist(dirPath);
-  await fse.writeFile(filePath, JSON.stringify({ wallets }, null, 2));
-}
-
-export async function getPrivyWalletAddresses(chain: string): Promise<string[]> {
-  const wallets = await getPrivyWallets(chain);
-  return wallets.map((w) => w.address);
-}
-
-export async function isPrivyWallet(chain: string, address: string): Promise<boolean> {
-  const wallets = await getPrivyWallets(chain);
-  return wallets.some((w) => w.address.toLowerCase() === address.toLowerCase());
-}
-
-export async function getPrivyWalletByAddress(
-  chain: string,
-  address: string
-): Promise<PrivyWalletData | null> {
-  const wallets = await getPrivyWallets(chain);
-  return wallets.find((w) => w.address.toLowerCase() === address.toLowerCase()) || null;
-}
-```
-
-### 7. `src/chains/ethereum/ethereum.ts`
-
-Add import at the top:
-```typescript
-import { isPrivyWallet as checkIsPrivyWallet, getPrivyWalletByAddress } from '../../wallet/utils';
-import { PrivyEvmSigner } from '../../wallet/privy/privy-evm-signer';
-```
-
-Add these methods to the `Ethereum` class (after `isHardwareWallet` method):
-
-```typescript
-  /**
-   * Check if an address is a Privy wallet
-   */
-  public async isPrivyWallet(address: string): Promise<boolean> {
-    return await checkIsPrivyWallet('ethereum', address);
-  }
-
-  /**
-   * Get a Privy signer for an address
-   */
-  public async getPrivySigner(address: string): Promise<PrivyEvmSigner> {
-    const privyWallet = await getPrivyWalletByAddress('ethereum', address);
-    if (!privyWallet) {
-      throw new Error(`Privy wallet not found for address: ${address}`);
-    }
-    return new PrivyEvmSigner(
-      privyWallet.privyWalletId,
-      address,
-      this.chainId,
-      this.provider
-    );
-  }
-```
-
-### 8. `src/chains/solana/solana.ts`
-
-Add import at the top:
-```typescript
-import { isPrivyWallet as checkIsPrivyWallet, getPrivyWalletByAddress } from '../../wallet/utils';
-import { PrivySolanaSigner } from '../../wallet/privy/privy-solana-signer';
-```
-
-Add these methods to the `Solana` class (after `isHardwareWallet` method):
-
-```typescript
-  /**
-   * Check if an address is a Privy wallet
-   */
-  public async isPrivyWallet(address: string): Promise<boolean> {
-    return await checkIsPrivyWallet('solana', address);
-  }
-
-  /**
-   * Get a Privy signer for an address
-   */
-  public async getPrivySigner(address: string): Promise<PrivySolanaSigner> {
-    const privyWallet = await getPrivyWalletByAddress('solana', address);
-    if (!privyWallet) {
-      throw new Error(`Privy wallet not found for address: ${address}`);
-    }
-    return new PrivySolanaSigner(
-      privyWallet.privyWalletId,
-      address,
-      this.network
-    );
-  }
-```
-
-### 9. `src/wallet/wallet.routes.ts`
-
-Add imports at the top:
-```typescript
-import {
-  getPrivyWallets,
-  savePrivyWallets,
-  getPrivyWalletAddresses,
-  PrivyWalletData
-} from './utils';
-import { PrivyClient } from './privy/privy-client';
-```
-
-Add these route handlers:
-
-```typescript
-// Add Privy wallet
-fastify.post(
-  '/wallet/add-privy',
-  {
-    schema: {
-      description: 'Register a Privy server wallet',
-      tags: ['wallet'],
-      body: Type.Object({
-        chain: Type.String({ description: 'Chain name (ethereum or solana)' }),
-        privyWalletId: Type.String({ description: 'Privy wallet ID' }),
-      }),
-      response: {
-        200: Type.Object({
-          address: Type.String(),
-          chain: Type.String(),
-          type: Type.Literal('privy'),
-        }),
-      },
-    },
-  },
-  async (request) => {
-    const { chain, privyWalletId } = request.body as { chain: string; privyWalletId: string };
-
-    // Validate chain
-    const supportedChains = ['ethereum', 'solana'];
-    if (!supportedChains.includes(chain.toLowerCase())) {
-      throw fastify.httpErrors.badRequest(`Unsupported chain: ${chain}. Supported: ${supportedChains.join(', ')}`);
-    }
-
-    // Get wallet info from Privy
-    const privy = PrivyClient.getInstance();
-    const privyWallet = await privy.getWallet(privyWalletId);
-
-    // Validate chain type matches
-    const expectedChainType = chain.toLowerCase() === 'ethereum' ? 'ethereum' : 'solana';
-    if (privyWallet.chainType !== expectedChainType) {
-      throw fastify.httpErrors.badRequest(
-        `Wallet chain type mismatch: expected ${expectedChainType}, got ${privyWallet.chainType}`
-      );
-    }
-
-    // Check if already registered
-    const existingWallets = await getPrivyWallets(chain);
-    if (existingWallets.some((w) => w.address.toLowerCase() === privyWallet.address.toLowerCase())) {
-      throw fastify.httpErrors.badRequest(`Privy wallet already registered: ${privyWallet.address}`);
-    }
-
-    // Add wallet
-    const newWallet: PrivyWalletData = {
-      address: privyWallet.address,
-      privyWalletId: privyWalletId,
-      addedAt: new Date().toISOString(),
-    };
-    await savePrivyWallets(chain, [...existingWallets, newWallet]);
-
-    return {
-      address: privyWallet.address,
-      chain: chain.toLowerCase(),
-      type: 'privy' as const,
-    };
-  }
-);
-
-// Remove Privy wallet
-fastify.delete(
-  '/wallet/remove-privy',
-  {
-    schema: {
-      description: 'Unregister a Privy server wallet',
-      tags: ['wallet'],
-      body: Type.Object({
-        chain: Type.String({ description: 'Chain name (ethereum or solana)' }),
-        address: Type.String({ description: 'Wallet address to remove' }),
-      }),
-      response: {
-        200: Type.Object({
-          removed: Type.Boolean(),
-          address: Type.String(),
-        }),
-      },
-    },
-  },
-  async (request) => {
-    const { chain, address } = request.body as { chain: string; address: string };
-
-    const existingWallets = await getPrivyWallets(chain);
-    const filteredWallets = existingWallets.filter(
-      (w) => w.address.toLowerCase() !== address.toLowerCase()
-    );
-
-    if (filteredWallets.length === existingWallets.length) {
-      throw fastify.httpErrors.notFound(`Privy wallet not found: ${address}`);
-    }
-
-    await savePrivyWallets(chain, filteredWallets);
-
-    return { removed: true, address };
-  }
-);
-```
-
-Update the existing `GET /wallet` handler to include Privy wallets in the response. Find where `hardwareWalletAddresses` is added to the response and add:
-```typescript
-const privyAddresses = await getPrivyWalletAddresses(chain);
-// Add to response object:
-privyWalletAddresses: privyAddresses.length > 0 ? privyAddresses : undefined,
-```
-
----
-
-## Connector Updates
-
-### Jupiter (example for Solana connectors)
-
-In `src/connectors/jupiter/router-routes/executeQuote.ts`, update the wallet handling:
-
-**Find this pattern:**
-```typescript
-const isHardwareWallet = await solana.isHardwareWallet(walletAddress);
-```
-
-**Add Privy check after it:**
-```typescript
-const isHardwareWallet = await solana.isHardwareWallet(walletAddress);
-const isPrivyWallet = await solana.isPrivyWallet(walletAddress);
-```
-
-**Update the branching logic:**
-```typescript
-if (isHardwareWallet) {
-  // existing hardware wallet code...
-} else if (isPrivyWallet) {
-  // Privy wallet: build unsigned transaction, sign with Privy
-  transaction = await jupiter.buildSwapTransactionForHardwareWallet(walletAddress, quote, maxLamports, priorityLevel);
-  const privySigner = await solana.getPrivySigner(walletAddress);
-  transaction = await privySigner.signTransaction(transaction);
-} else {
-  // existing local wallet code...
-}
-```
-
-Apply the same pattern to: Raydium, Meteora connectors.
-
-### EVM Connectors (Uniswap, 0x)
-
-For EVM connectors, add similar branching. In `executeQuote.ts` or equivalent:
-
-```typescript
-const isHardwareWallet = await ethereum.isHardwareWallet(walletAddress);
-const isPrivyWallet = await ethereum.isPrivyWallet(walletAddress);
-
-let wallet: Wallet | PrivyEvmSigner;
-if (isPrivyWallet) {
-  wallet = await ethereum.getPrivySigner(walletAddress);
-} else if (isHardwareWallet) {
-  // existing hardware wallet handling...
-} else {
-  wallet = await ethereum.getWallet(walletAddress);
-}
-```
-
----
-
-## Implementation Checklist
-
-1. [ ] Add Privy credentials to `src/templates/apiKeys.yml`
-2. [ ] Add Privy properties to `src/templates/namespace/apiKeys-schema.json`
-3. [ ] Create `src/wallet/privy/` directory
-4. [ ] Create `src/wallet/privy/privy-client.ts`
-5. [ ] Create `src/wallet/privy/privy-evm-signer.ts`
-6. [ ] Create `src/wallet/privy/privy-solana-signer.ts`
-7. [ ] Add Privy wallet functions to `src/wallet/utils.ts`
-8. [ ] Add `isPrivyWallet()` and `getPrivySigner()` to `src/chains/ethereum/ethereum.ts`
-9. [ ] Add `isPrivyWallet()` and `getPrivySigner()` to `src/chains/solana/solana.ts`
-10. [ ] Add `/wallet/add-privy` and `/wallet/remove-privy` routes to `src/wallet/wallet.routes.ts`
-11. [ ] Update Jupiter connector with Privy support
-12. [ ] Update Raydium connector with Privy support
-13. [ ] Update Meteora connector with Privy support
-14. [ ] Update Uniswap connector with Privy support (if needed)
-15. [ ] Run `pnpm build` to verify no TypeScript errors
-16. [ ] Run `pnpm test` to verify existing tests pass
-17. [ ] Create unit tests for Privy client and signers
-
----
-
-## Policy Configuration (Privy Dashboard)
-
-Policies are managed entirely in Privy Dashboard, not in Gateway. Example workflow:
-
-1. Go to Privy Dashboard → Policies
-2. Create a policy with rules (allowed contracts, max amounts, etc.)
-3. Create a server wallet and attach the policy
-4. Copy the wallet ID
-5. In Gateway: `POST /wallet/add-privy` with the wallet ID
-
-Example Ethereum policy for DEX trading:
-```json
-{
-  "version": "1.0",
-  "name": "Hummingbot DEX Trading",
-  "chain_type": "ethereum",
-  "rules": [
-    {
-      "name": "Allow Uniswap V3 Router",
-      "method": "eth_sendTransaction",
-      "conditions": [
-        { "field_source": "ethereum_transaction", "field": "to", "operator": "eq", "value": "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45" }
-      ],
-      "action": "ALLOW"
-    },
-    {
-      "name": "Max 1 ETH per transaction",
-      "method": "eth_sendTransaction",
-      "conditions": [
-        { "field_source": "ethereum_transaction", "field": "value", "operator": "lte", "value": "0xDE0B6B3A7640000" }
-      ],
-      "action": "ALLOW"
-    },
-    {
-      "name": "Deny everything else",
-      "method": "*",
-      "conditions": [],
-      "action": "DENY"
-    }
-  ]
-}
-```
-
-Example Solana policy:
-```json
-{
-  "version": "1.0",
-  "name": "Hummingbot Solana Trading",
-  "chain_type": "solana",
-  "rules": [
-    {
-      "name": "Allow Jupiter",
-      "method": "signAndSendTransaction",
-      "conditions": [
-        { "field_source": "solana_program_instruction", "field": "programId", "operator": "eq", "value": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4" }
-      ],
-      "action": "ALLOW"
-    },
-    {
-      "name": "Max 10 SOL per transaction",
-      "method": "signAndSendTransaction",
-      "conditions": [
-        { "field_source": "solana_system_instruction", "field": "lamports", "operator": "lte", "value": "10000000000" }
-      ],
-      "action": "ALLOW"
-    }
-  ]
-}
-```

From 723dfeb3a5b6a8983bcf666a534e9c6c3cb00d0f Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 10 Feb 2026 18:38:17 -0800
Subject: [PATCH 29/37] feat(solana): add caching to priority fee estimation

- Add 10-second cache for priority fee estimates to reduce RPC calls
- Return detailed fee result including priorityFeeLevel and raw estimate
- Update estimate-gas route to use new estimateGasPriceDetailed method
- Update tests to match new API and fix URL pattern assertions

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/solana/routes/estimate-gas.ts      |   8 +-
 src/chains/solana/schemas.ts                  |   7 -
 src/chains/solana/solana-priority-fees.ts     | 112 ++++++++---
 src/chains/solana/solana.config.ts            |   2 +
 src/templates/chains/solana/devnet.yml        |   4 +
 src/templates/chains/solana/mainnet-beta.yml  |   4 +
 .../namespace/solana-network-schema.json      |   6 +
 .../chains/solana/routes/estimate-gas.test.ts |  44 ++++-
 .../solana/solana-priority-fees.test.ts       | 186 ++++++++++--------
 test/rpc/rpc-provider-simple.test.ts          |   3 +-
 10 files changed, 240 insertions(+), 136 deletions(-)

diff --git a/src/chains/solana/routes/estimate-gas.ts b/src/chains/solana/routes/estimate-gas.ts
index 6ed259d562..fc678ebfd6 100644
--- a/src/chains/solana/routes/estimate-gas.ts
+++ b/src/chains/solana/routes/estimate-gas.ts
@@ -6,11 +6,11 @@ import { logger } from '../../../services/logger';
 import { SolanaEstimateGasRequest, SolanaEstimateGasRequestType } from '../schemas';
 import { Solana } from '../solana';
 
-export async function estimateGasSolana(network: string, priorityFeeLevel?: string): Promise<EstimateGasResponse> {
+export async function estimateGasSolana(network: string): Promise<EstimateGasResponse> {
   try {
     const solana = await Solana.getInstance(network);
 
-    const feeResult = await solana.estimateGasPriceDetailed(priorityFeeLevel as any);
+    const feeResult = await solana.estimateGasPriceDetailed();
 
     // Get default compute units from config (typically 200000)
     const defaultComputeUnits = solana.config.defaultComputeUnits;
@@ -91,8 +91,8 @@ export const estimateGasRoute: FastifyPluginAsync = async (fastify) => {
       },
     },
     async (request) => {
-      const { network, priorityFeeLevel } = request.query;
-      return await estimateGasSolana(network, priorityFeeLevel);
+      const { network } = request.query;
+      return await estimateGasSolana(network);
     },
   );
 };
diff --git a/src/chains/solana/schemas.ts b/src/chains/solana/schemas.ts
index b48d963214..51c9e5b9c2 100644
--- a/src/chains/solana/schemas.ts
+++ b/src/chains/solana/schemas.ts
@@ -49,13 +49,6 @@ export const SolanaBalanceRequest = Type.Object({
 // Estimate gas request schema
 export const SolanaEstimateGasRequest = Type.Object({
   network: SolanaNetworkParameter,
-  priorityFeeLevel: Type.Optional(
-    Type.String({
-      description: 'Helius priority fee level for transaction processing',
-      enum: ['Min', 'Low', 'Medium', 'High', 'VeryHigh', 'UnsafeMax'],
-      default: 'High',
-    }),
-  ),
 });
 
 export type SolanaEstimateGasRequestType = Static<typeof SolanaEstimateGasRequest>;
diff --git a/src/chains/solana/solana-priority-fees.ts b/src/chains/solana/solana-priority-fees.ts
index 502513a607..41701f916b 100644
--- a/src/chains/solana/solana-priority-fees.ts
+++ b/src/chains/solana/solana-priority-fees.ts
@@ -13,14 +13,22 @@ export type PriorityFeeLevel = 'Min' | 'Low' | 'Medium' | 'High' | 'VeryHigh' |
  * Detailed result from priority fee estimation
  */
 export interface PriorityFeeResult {
-  /** Final fee per compute unit in lamports (after minimum enforcement) */
+  /** Final fee per compute unit in lamports (after min/max clamping) */
   feePerComputeUnit: number;
   /** Priority level used for the estimate */
   priorityFeeLevel: PriorityFeeLevel;
-  /** Raw Helius estimate in lamports/CU (before minimum enforcement), null if Helius not used */
+  /** Raw Helius estimate in lamports/CU (before clamping), null if Helius not used */
   priorityFeePerCUEstimate: number | null;
 }
 
+/**
+ * Cached priority fee result
+ */
+interface CachedFeeResult {
+  result: PriorityFeeResult;
+  timestamp: number;
+}
+
 /**
  * Extract Helius API key from various sources
  * @param nodeURL The node URL from config
@@ -55,8 +63,15 @@ export async function getHeliusApiKey(nodeURL?: string): Promise<string | null>
 
 /**
  * Priority fee estimation using Helius getPriorityFeeEstimate RPC method
+ * Results are cached for 10 seconds per network
  */
 export class SolanaPriorityFees {
+  // Cache TTL in milliseconds (10 seconds)
+  private static readonly CACHE_TTL_MS = 10_000;
+
+  // Cache keyed by network name
+  private static cache: Map<string, CachedFeeResult> = new Map();
+
   // Default accounts used when no specific accounts are provided
   private static readonly DEFAULT_ACCOUNT_KEYS = [
     'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', // Token Program
@@ -64,35 +79,57 @@ export class SolanaPriorityFees {
   ];
 
   /**
-   * Estimates priority fees using Helius getPriorityFeeEstimate RPC method
-   * @param config Network configuration containing minPriorityFeePerCU and maxPriorityFeePerCU
-   * @param _network Network name (unused, kept for compatibility)
-   * @param priorityLevel Priority fee level (defaults to High)
+   * Get cached result if valid
+   */
+  private static getCached(network: string): PriorityFeeResult | null {
+    const cached = SolanaPriorityFees.cache.get(network);
+    if (cached && Date.now() - cached.timestamp < SolanaPriorityFees.CACHE_TTL_MS) {
+      logger.debug(`[${network}] Using cached priority fee estimate`);
+      return cached.result;
+    }
+    return null;
+  }
+
+  /**
+   * Store result in cache
+   */
+  private static setCache(network: string, result: PriorityFeeResult): void {
+    SolanaPriorityFees.cache.set(network, {
+      result,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Estimates priority fees using Helius or returns config default
+   * Results are cached for 10 seconds
+   * @param config Network configuration
+   * @param network Network name for caching
    * @returns Final fee per compute unit in lamports
    */
-  public static async estimatePriorityFee(
-    config: SolanaNetworkConfig,
-    _network: string,
-    priorityLevel?: PriorityFeeLevel,
-  ): Promise<number> {
-    const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(config, _network, priorityLevel);
+  public static async estimatePriorityFee(config: SolanaNetworkConfig, network: string): Promise<number> {
+    const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(config, network);
     return result.feePerComputeUnit;
   }
 
   /**
-   * Estimates priority fees with detailed results including raw Helius estimate
-   * @param config Network configuration containing minPriorityFeePerCU and maxPriorityFeePerCU
-   * @param _network Network name (unused, kept for compatibility)
-   * @param priorityLevel Priority fee level (defaults to High)
+   * Estimates priority fees with detailed results
+   * Results are cached for 10 seconds
+   * @param config Network configuration
+   * @param network Network name for caching
    * @returns Detailed fee estimation result
    */
   public static async estimatePriorityFeeDetailed(
     config: SolanaNetworkConfig,
-    _network: string,
-    priorityLevel?: PriorityFeeLevel,
+    network: string,
   ): Promise<PriorityFeeResult> {
-    const accountKeys = SolanaPriorityFees.DEFAULT_ACCOUNT_KEYS;
-    const level: PriorityFeeLevel = priorityLevel || 'High';
+    // Check cache first
+    const cached = SolanaPriorityFees.getCached(network);
+    if (cached) {
+      return cached;
+    }
+
+    const level: PriorityFeeLevel = (config.priorityFeeLevel as PriorityFeeLevel) || 'High';
     const minimumFee = config.minPriorityFeePerCU || 0.1;
     const maximumFee = config.maxPriorityFeePerCU || 1.0;
 
@@ -102,17 +139,19 @@ export class SolanaPriorityFees {
 
       if (!apiKey) {
         logger.info(`[${level}] No Helius API key found, using minimum fee: ${minimumFee.toFixed(4)} lamports/CU`);
-        return {
+        const result: PriorityFeeResult = {
           feePerComputeUnit: minimumFee,
           priorityFeeLevel: level,
           priorityFeePerCUEstimate: null,
         };
+        SolanaPriorityFees.setCache(network, result);
+        return result;
       }
 
       // Construct the request URL
       const requestUrl = `https://mainnet.helius-rpc.com/?api-key=${apiKey}`;
 
-      logger.debug(`[${level}] Fetching priority fee estimate with ${accountKeys.length} account keys`);
+      logger.debug(`[${level}] Fetching priority fee estimate from Helius`);
 
       const response = await fetch(requestUrl, {
         method: 'POST',
@@ -121,7 +160,7 @@ export class SolanaPriorityFees {
           method: 'getPriorityFeeEstimate',
           params: [
             {
-              accountKeys,
+              accountKeys: SolanaPriorityFees.DEFAULT_ACCOUNT_KEYS,
               options: { priorityLevel: level },
             },
           ],
@@ -132,33 +171,39 @@ export class SolanaPriorityFees {
 
       if (!response.ok) {
         logger.error(`[${level}] Failed to fetch priority fee estimate: ${response.status}`);
-        return {
+        const result: PriorityFeeResult = {
           feePerComputeUnit: minimumFee,
           priorityFeeLevel: level,
           priorityFeePerCUEstimate: null,
         };
+        SolanaPriorityFees.setCache(network, result);
+        return result;
       }
 
       const data = await response.json();
 
       if (data.error) {
         logger.error(`[${level}] Priority fee estimate RPC error: ${JSON.stringify(data.error)}`);
-        return {
+        const result: PriorityFeeResult = {
           feePerComputeUnit: minimumFee,
           priorityFeeLevel: level,
           priorityFeePerCUEstimate: null,
         };
+        SolanaPriorityFees.setCache(network, result);
+        return result;
       }
 
       const priorityFeeEstimate = data.result?.priorityFeeEstimate;
 
       if (typeof priorityFeeEstimate !== 'number') {
         logger.warn(`[${level}] Invalid priority fee estimate response, using minimum fee`);
-        return {
+        const result: PriorityFeeResult = {
           feePerComputeUnit: minimumFee,
           priorityFeeLevel: level,
           priorityFeePerCUEstimate: null,
         };
+        SolanaPriorityFees.setCache(network, result);
+        return result;
       }
 
       // Convert from micro-lamports to lamports per compute unit
@@ -174,18 +219,29 @@ export class SolanaPriorityFees {
         `[${level}] Priority fee: ${priorityFeeLamports.toFixed(6)} -> ${finalFee.toFixed(6)} lamports/CU (${clampInfo})`,
       );
 
-      return {
+      const result: PriorityFeeResult = {
         feePerComputeUnit: finalFee,
         priorityFeeLevel: level,
         priorityFeePerCUEstimate: priorityFeeLamports,
       };
+      SolanaPriorityFees.setCache(network, result);
+      return result;
     } catch (error: any) {
       logger.error(`[${level}] Failed to fetch priority fee estimate: ${error.message}, using minimum fee`);
-      return {
+      const result: PriorityFeeResult = {
         feePerComputeUnit: minimumFee,
         priorityFeeLevel: level,
         priorityFeePerCUEstimate: null,
       };
+      SolanaPriorityFees.setCache(network, result);
+      return result;
     }
   }
+
+  /**
+   * Clear the cache (useful for testing)
+   */
+  public static clearCache(): void {
+    SolanaPriorityFees.cache.clear();
+  }
 }
diff --git a/src/chains/solana/solana.config.ts b/src/chains/solana/solana.config.ts
index bbf2c9c6ab..77c622b797 100644
--- a/src/chains/solana/solana.config.ts
+++ b/src/chains/solana/solana.config.ts
@@ -13,6 +13,7 @@ export interface SolanaNetworkConfig {
   confirmRetryCount: number;
   minPriorityFeePerCU: number;
   maxPriorityFeePerCU?: number;
+  priorityFeeLevel?: string;
 }
 
 export interface SolanaChainConfig {
@@ -38,6 +39,7 @@ export function getSolanaNetworkConfig(network: string): SolanaNetworkConfig {
     confirmRetryCount: ConfigManagerV2.getInstance().get(namespaceId + '.confirmRetryCount'),
     minPriorityFeePerCU: ConfigManagerV2.getInstance().get(namespaceId + '.minPriorityFeePerCU'),
     maxPriorityFeePerCU: ConfigManagerV2.getInstance().get(namespaceId + '.maxPriorityFeePerCU'),
+    priorityFeeLevel: ConfigManagerV2.getInstance().get(namespaceId + '.priorityFeeLevel'),
   };
 }
 
diff --git a/src/templates/chains/solana/devnet.yml b/src/templates/chains/solana/devnet.yml
index 5ab2c38ef3..1b55ca6cc0 100644
--- a/src/templates/chains/solana/devnet.yml
+++ b/src/templates/chains/solana/devnet.yml
@@ -23,3 +23,7 @@ minPriorityFeePerCU: 0.01
 # Maximum priority fee per compute unit in lamports
 # This sets the ceiling for priority fees to prevent overpaying (default: 1.0 lamports/CU)
 maxPriorityFeePerCU: 1.0
+
+# Helius priority fee level for fee estimation
+# Options: Min, Low, Medium, High, VeryHigh, UnsafeMax (default: High)
+priorityFeeLevel: High
diff --git a/src/templates/chains/solana/mainnet-beta.yml b/src/templates/chains/solana/mainnet-beta.yml
index c9ced8f15f..36d8eeb36e 100644
--- a/src/templates/chains/solana/mainnet-beta.yml
+++ b/src/templates/chains/solana/mainnet-beta.yml
@@ -23,3 +23,7 @@ minPriorityFeePerCU: 0.1
 # Maximum priority fee per compute unit in lamports
 # This sets the ceiling for priority fees to prevent overpaying (default: 1.0 lamports/CU)
 maxPriorityFeePerCU: 1.0
+
+# Helius priority fee level for fee estimation
+# Options: Min, Low, Medium, High, VeryHigh, UnsafeMax (default: High)
+priorityFeeLevel: High
diff --git a/src/templates/namespace/solana-network-schema.json b/src/templates/namespace/solana-network-schema.json
index 56181984a6..613f9a2f2a 100644
--- a/src/templates/namespace/solana-network-schema.json
+++ b/src/templates/namespace/solana-network-schema.json
@@ -27,6 +27,12 @@
     "maxPriorityFeePerCU": {
       "type": "number",
       "description": "Maximum priority fee per compute unit in lamports (ceiling for fee estimation)"
+    },
+    "priorityFeeLevel": {
+      "type": "string",
+      "description": "Helius priority fee level for fee estimation (default: High)",
+      "enum": ["Min", "Low", "Medium", "High", "VeryHigh", "UnsafeMax"],
+      "default": "High"
     }
   },
   "required": ["chainID", "nodeURL", "nativeCurrencySymbol", "geckoId"],
diff --git a/test/chains/solana/routes/estimate-gas.test.ts b/test/chains/solana/routes/estimate-gas.test.ts
index 0bb5ff612f..ac439e37f1 100644
--- a/test/chains/solana/routes/estimate-gas.test.ts
+++ b/test/chains/solana/routes/estimate-gas.test.ts
@@ -29,7 +29,7 @@ describe('Solana Estimate Gas Route', () => {
 
   describe('GET /chains/solana/estimate-gas', () => {
     const mockInstance = {
-      estimateGasPrice: jest.fn(),
+      estimateGasPriceDetailed: jest.fn(),
       config: {
         minPriorityFeePerCU: 0.5,
         defaultComputeUnits: 200000,
@@ -42,7 +42,11 @@ describe('Solana Estimate Gas Route', () => {
     });
 
     it('should return priority fee successfully from live estimation', async () => {
-      mockInstance.estimateGasPrice.mockResolvedValue(2.5);
+      mockInstance.estimateGasPriceDetailed.mockResolvedValue({
+        feePerComputeUnit: 2.5,
+        priorityFeeLevel: 'High',
+        priorityFeePerCUEstimate: 2.5,
+      });
 
       const response = await fastify.inject({
         method: 'GET',
@@ -62,12 +66,12 @@ describe('Solana Estimate Gas Route', () => {
       });
 
       expect(mockSolana.getInstance).toHaveBeenCalledWith('mainnet-beta');
-      expect(mockInstance.estimateGasPrice).toHaveBeenCalled();
+      expect(mockInstance.estimateGasPriceDetailed).toHaveBeenCalled();
     });
 
     it('should return minPriorityFeePerCU when priority fee estimation fails but instance is available', async () => {
       // First call for priority fee estimation fails
-      mockInstance.estimateGasPrice.mockRejectedValueOnce(new Error('RPC node unavailable'));
+      mockInstance.estimateGasPriceDetailed.mockRejectedValueOnce(new Error('RPC node unavailable'));
 
       // Second getInstance call for fallback succeeds
       mockSolana.getInstance
@@ -97,7 +101,7 @@ describe('Solana Estimate Gas Route', () => {
 
     it('should use default minPriorityFeePerCU when config value is undefined', async () => {
       const instanceWithoutMinFee = {
-        estimateGasPrice: jest.fn().mockRejectedValue(new Error('RPC unavailable')),
+        estimateGasPriceDetailed: jest.fn().mockRejectedValue(new Error('RPC unavailable')),
         config: {
           defaultComputeUnits: 200000,
         }, // No minPriorityFeePerCU defined
@@ -131,7 +135,11 @@ describe('Solana Estimate Gas Route', () => {
 
       for (const network of networks) {
         jest.clearAllMocks(); // Clear mocks between iterations
-        mockInstance.estimateGasPrice.mockResolvedValue(1.25);
+        mockInstance.estimateGasPriceDetailed.mockResolvedValue({
+          feePerComputeUnit: 1.25,
+          priorityFeeLevel: 'High',
+          priorityFeePerCUEstimate: 1.25,
+        });
         mockSolana.getInstance.mockResolvedValue(mockInstance as any);
 
         const response = await fastify.inject({
@@ -156,7 +164,11 @@ describe('Solana Estimate Gas Route', () => {
     });
 
     it('should return consistent response format', async () => {
-      mockInstance.estimateGasPrice.mockResolvedValue(3.75);
+      mockInstance.estimateGasPriceDetailed.mockResolvedValue({
+        feePerComputeUnit: 3.75,
+        priorityFeeLevel: 'High',
+        priorityFeePerCUEstimate: 3.75,
+      });
 
       const response = await fastify.inject({
         method: 'GET',
@@ -177,7 +189,11 @@ describe('Solana Estimate Gas Route', () => {
     });
 
     it('should handle missing network parameter by using default', async () => {
-      mockInstance.estimateGasPrice.mockResolvedValue(1.5);
+      mockInstance.estimateGasPriceDetailed.mockResolvedValue({
+        feePerComputeUnit: 1.5,
+        priorityFeeLevel: 'High',
+        priorityFeePerCUEstimate: 1.5,
+      });
 
       const response = await fastify.inject({
         method: 'GET',
@@ -199,7 +215,11 @@ describe('Solana Estimate Gas Route', () => {
 
     it('should handle high priority fees correctly', async () => {
       // Test with a high priority fee to ensure no rounding issues
-      mockInstance.estimateGasPrice.mockResolvedValue(100.123456);
+      mockInstance.estimateGasPriceDetailed.mockResolvedValue({
+        feePerComputeUnit: 100.123456,
+        priorityFeeLevel: 'High',
+        priorityFeePerCUEstimate: 100.123456,
+      });
 
       const response = await fastify.inject({
         method: 'GET',
@@ -221,7 +241,11 @@ describe('Solana Estimate Gas Route', () => {
 
     it('should handle zero priority fees by returning configured minimum', async () => {
       // When live estimation returns 0, it should fallback gracefully
-      mockInstance.estimateGasPrice.mockResolvedValue(0);
+      mockInstance.estimateGasPriceDetailed.mockResolvedValue({
+        feePerComputeUnit: 0,
+        priorityFeeLevel: 'High',
+        priorityFeePerCUEstimate: 0,
+      });
 
       const response = await fastify.inject({
         method: 'GET',
diff --git a/test/chains/solana/solana-priority-fees.test.ts b/test/chains/solana/solana-priority-fees.test.ts
index 0a663d2b43..2448c1a47e 100644
--- a/test/chains/solana/solana-priority-fees.test.ts
+++ b/test/chains/solana/solana-priority-fees.test.ts
@@ -16,6 +16,7 @@ global.fetch = jest.fn() as jest.MockedFunction<typeof fetch>;
 describe('Solana Priority Fees', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    SolanaPriorityFees.clearCache();
   });
 
   describe('getHeliusApiKey', () => {
@@ -91,17 +92,6 @@ describe('Solana Priority Fees', () => {
 
       expect(result).toBeNull();
     });
-
-    it('extracts API key from helius-rpc.com URL', async () => {
-      const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
-      const mockGet = jest.fn().mockReturnValue('');
-      (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
-
-      const nodeURL = 'https://devnet.helius-rpc.com/?api-key=devnet-key-789';
-      const result = await getHeliusApiKey(nodeURL);
-
-      expect(result).toBe('devnet-key-789');
-    });
   });
 
   describe('SolanaPriorityFees.estimatePriorityFeeDetailed', () => {
@@ -115,6 +105,7 @@ describe('Solana Priority Fees', () => {
       confirmRetryCount: 10,
       minPriorityFeePerCU: 0.1,
       maxPriorityFeePerCU: 1.0,
+      priorityFeeLevel: 'High',
     };
 
     it('returns minimum fee when no Helius API key available', async () => {
@@ -134,31 +125,36 @@ describe('Solana Priority Fees', () => {
       expect(result.priorityFeePerCUEstimate).toBeNull();
     });
 
-    it('uses High as default priority level', async () => {
+    it('uses priorityFeeLevel from config', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
       const mockGet = jest.fn().mockReturnValue('');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(
-        { ...mockConfig, nodeURL: 'https://api.solana.com' },
-        'mainnet-beta',
-      );
+      const configWithVeryHigh = {
+        ...mockConfig,
+        nodeURL: 'https://api.solana.com',
+        priorityFeeLevel: 'VeryHigh',
+      };
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(configWithVeryHigh, 'mainnet-beta');
 
-      expect(result.priorityFeeLevel).toBe('High');
+      expect(result.priorityFeeLevel).toBe('VeryHigh');
     });
 
-    it('respects provided priority level', async () => {
+    it('defaults to High when priorityFeeLevel not in config', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
       const mockGet = jest.fn().mockReturnValue('');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(
-        { ...mockConfig, nodeURL: 'https://api.solana.com' },
-        'mainnet-beta',
-        'VeryHigh',
-      );
+      const configWithoutLevel = {
+        ...mockConfig,
+        nodeURL: 'https://api.solana.com',
+        priorityFeeLevel: undefined,
+      };
 
-      expect(result.priorityFeeLevel).toBe('VeryHigh');
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(configWithoutLevel, 'mainnet-beta');
+
+      expect(result.priorityFeeLevel).toBe('High');
     });
 
     it('clamps fee to minimum when Helius returns lower value', async () => {
@@ -166,18 +162,19 @@ describe('Solana Priority Fees', () => {
       const mockGet = jest.fn().mockReturnValue('test-api-key');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      // Mock Helius returning 0 (Min level often returns 0)
+      // Mock Helius returning 0
       (global.fetch as jest.Mock).mockResolvedValueOnce({
         ok: true,
         json: async () => ({
-          result: { priorityFeeEstimate: 0 }, // 0 micro-lamports
+          result: { priorityFeeEstimate: 0 },
         }),
       });
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', 'Min');
+      const configWithMin = { ...mockConfig, priorityFeeLevel: 'Min' };
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(configWithMin, 'mainnet-beta');
 
       expect(result.feePerComputeUnit).toBe(0.1); // Clamped to minimum
-      expect(result.priorityFeePerCUEstimate).toBe(0); // Raw estimate was 0
+      expect(result.priorityFeePerCUEstimate).toBe(0);
     });
 
     it('clamps fee to maximum when Helius returns higher value', async () => {
@@ -185,7 +182,7 @@ describe('Solana Priority Fees', () => {
       const mockGet = jest.fn().mockReturnValue('test-api-key');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      // Mock Helius returning very high fee (5 lamports/CU = 5,000,000 micro-lamports)
+      // Mock Helius returning 5 lamports/CU
       (global.fetch as jest.Mock).mockResolvedValueOnce({
         ok: true,
         json: async () => ({
@@ -193,10 +190,10 @@ describe('Solana Priority Fees', () => {
         }),
       });
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', 'VeryHigh');
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
 
       expect(result.feePerComputeUnit).toBe(1.0); // Clamped to maximum
-      expect(result.priorityFeePerCUEstimate).toBe(5); // Raw estimate was 5 lamports/CU
+      expect(result.priorityFeePerCUEstimate).toBe(5);
     });
 
     it('returns unclamped fee when within min/max bounds', async () => {
@@ -204,7 +201,7 @@ describe('Solana Priority Fees', () => {
       const mockGet = jest.fn().mockReturnValue('test-api-key');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      // Mock Helius returning 0.5 lamports/CU = 500,000 micro-lamports
+      // Mock Helius returning 0.5 lamports/CU
       (global.fetch as jest.Mock).mockResolvedValueOnce({
         ok: true,
         json: async () => ({
@@ -212,7 +209,7 @@ describe('Solana Priority Fees', () => {
         }),
       });
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', 'High');
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
 
       expect(result.feePerComputeUnit).toBe(0.5);
       expect(result.priorityFeePerCUEstimate).toBe(0.5);
@@ -230,94 +227,109 @@ describe('Solana Priority Fees', () => {
 
       const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
 
-      expect(result.feePerComputeUnit).toBe(0.1); // Falls back to minimum
+      expect(result.feePerComputeUnit).toBe(0.1);
       expect(result.priorityFeePerCUEstimate).toBeNull();
     });
 
-    it('handles Helius RPC error response', async () => {
+    it('handles network fetch error', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
       const mockGet = jest.fn().mockReturnValue('test-api-key');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      (global.fetch as jest.Mock).mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          error: { code: -32600, message: 'Invalid request' },
-        }),
-      });
+      (global.fetch as jest.Mock).mockRejectedValueOnce(new Error('Network error'));
 
       const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
 
       expect(result.feePerComputeUnit).toBe(0.1);
       expect(result.priorityFeePerCUEstimate).toBeNull();
     });
+  });
 
-    it('handles network fetch error', async () => {
+  describe('Caching', () => {
+    const mockConfig: SolanaNetworkConfig = {
+      chainID: 101,
+      nodeURL: 'https://api.solana.com',
+      nativeCurrencySymbol: 'SOL',
+      geckoId: 'solana',
+      defaultComputeUnits: 200000,
+      confirmRetryInterval: 1,
+      confirmRetryCount: 10,
+      minPriorityFeePerCU: 0.1,
+      maxPriorityFeePerCU: 1.0,
+      priorityFeeLevel: 'High',
+    };
+
+    it('caches result and returns cached value on subsequent calls', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
       const mockGet = jest.fn().mockReturnValue('test-api-key');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      (global.fetch as jest.Mock).mockRejectedValueOnce(new Error('Network error'));
+      // First call - fetch from Helius
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          result: { priorityFeeEstimate: 500000 },
+        }),
+      });
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+      const result1 = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+      expect(result1.feePerComputeUnit).toBe(0.5);
+      expect(global.fetch).toHaveBeenCalledTimes(1);
 
-      expect(result.feePerComputeUnit).toBe(0.1);
-      expect(result.priorityFeePerCUEstimate).toBeNull();
+      // Second call - should use cache, not fetch again
+      const result2 = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+      expect(result2.feePerComputeUnit).toBe(0.5);
+      expect(global.fetch).toHaveBeenCalledTimes(1); // Still only 1 call
     });
 
-    it('uses default min/max when not specified in config', async () => {
+    it('uses separate cache entries per network', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
       const mockGet = jest.fn().mockReturnValue('');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      const configWithoutMinMax: SolanaNetworkConfig = {
-        chainID: 101,
-        nodeURL: 'https://api.solana.com',
-        nativeCurrencySymbol: 'SOL',
-        geckoId: 'solana',
-        defaultComputeUnits: 200000,
-        confirmRetryInterval: 1,
-        confirmRetryCount: 10,
-        minPriorityFeePerCU: 0, // Will default to 0.1
-        maxPriorityFeePerCU: undefined, // Will default to 1.0
-      };
+      const result1 = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+      const result2 = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'devnet');
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(configWithoutMinMax, 'mainnet-beta');
-
-      // Should use default minimum of 0.1
-      expect(result.feePerComputeUnit).toBe(0.1);
+      // Both should return minimum fee (no Helius key)
+      expect(result1.feePerComputeUnit).toBe(0.1);
+      expect(result2.feePerComputeUnit).toBe(0.1);
     });
-  });
 
-  describe('SolanaPriorityFees.estimatePriorityFee', () => {
-    it('returns only the fee value (not full result object)', async () => {
+    it('clearCache removes all cached entries', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
-      const mockGet = jest.fn().mockReturnValue('');
+      const mockGet = jest.fn().mockReturnValue('test-api-key');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
 
-      const mockConfig: SolanaNetworkConfig = {
-        chainID: 101,
-        nodeURL: 'https://api.solana.com',
-        nativeCurrencySymbol: 'SOL',
-        geckoId: 'solana',
-        defaultComputeUnits: 200000,
-        confirmRetryInterval: 1,
-        confirmRetryCount: 10,
-        minPriorityFeePerCU: 0.1,
-        maxPriorityFeePerCU: 1.0,
-      };
+      // First call
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          result: { priorityFeeEstimate: 500000 },
+        }),
+      });
 
-      const result = await SolanaPriorityFees.estimatePriorityFee(mockConfig, 'mainnet-beta');
+      await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+      expect(global.fetch).toHaveBeenCalledTimes(1);
 
-      expect(typeof result).toBe('number');
-      expect(result).toBe(0.1);
+      // Clear cache
+      SolanaPriorityFees.clearCache();
+
+      // Next call should fetch again
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          result: { priorityFeeEstimate: 600000 },
+        }),
+      });
+
+      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta');
+      expect(global.fetch).toHaveBeenCalledTimes(2);
+      expect(result.feePerComputeUnit).toBe(0.6);
     });
   });
 
-  describe('Priority fee levels', () => {
-    const levels: PriorityFeeLevel[] = ['Min', 'Low', 'Medium', 'High', 'VeryHigh', 'UnsafeMax'];
-
-    it.each(levels)('accepts %s as valid priority level', async (level) => {
+  describe('SolanaPriorityFees.estimatePriorityFee', () => {
+    it('returns only the fee value (not full result object)', async () => {
       const { ConfigManagerV2 } = await import('../../../src/services/config-manager-v2');
       const mockGet = jest.fn().mockReturnValue('');
       (ConfigManagerV2.getInstance as jest.Mock).mockReturnValue({ get: mockGet });
@@ -332,11 +344,13 @@ describe('Solana Priority Fees', () => {
         confirmRetryCount: 10,
         minPriorityFeePerCU: 0.1,
         maxPriorityFeePerCU: 1.0,
+        priorityFeeLevel: 'High',
       };
 
-      const result = await SolanaPriorityFees.estimatePriorityFeeDetailed(mockConfig, 'mainnet-beta', level);
+      const result = await SolanaPriorityFees.estimatePriorityFee(mockConfig, 'mainnet-beta');
 
-      expect(result.priorityFeeLevel).toBe(level);
+      expect(typeof result).toBe('number');
+      expect(result).toBe(0.1);
     });
   });
 });
diff --git a/test/rpc/rpc-provider-simple.test.ts b/test/rpc/rpc-provider-simple.test.ts
index 21a4ad42fc..b951462bc8 100644
--- a/test/rpc/rpc-provider-simple.test.ts
+++ b/test/rpc/rpc-provider-simple.test.ts
@@ -36,7 +36,8 @@ describe('Solana RPC Provider Configuration Tests', () => {
       const mainnetConfig = getSolanaNetworkConfig('mainnet-beta');
 
       expect(devnetConfig.nodeURL).toContain('devnet');
-      expect(mainnetConfig.nodeURL).toContain('mainnet-beta');
+      // Mainnet URL can be standard Solana RPC or Helius (which uses 'mainnet' without '-beta')
+      expect(mainnetConfig.nodeURL).toMatch(/mainnet|helius/);
 
       expect(devnetConfig.nativeCurrencySymbol).toBe('SOL');
       expect(mainnetConfig.nativeCurrencySymbol).toBe('SOL');

From a86c92b74de5248597497821d5b43b98ae22fe62 Mon Sep 17 00:00:00 2001
From: Wojak <machinelearningguys@gmail.com>
Date: Wed, 11 Feb 2026 14:15:20 +0700
Subject: [PATCH 30/37] fix(orca): use Token-2022 positions for full rent
 recovery on close

Switch from Metaplex-based openPositionWithMetadataIx to Token-2022
openPositionWithTokenExtensionsIx so position mint accounts have
MintCloseAuthority and can be fully closed, recovering all rent.

Changes:
- openPosition: use Token-2022 instructions and derive ATA with
  TOKEN_2022_PROGRAM_ID; calculate rent via direct getBalance queries
  on the 3 position accounts (mint, PDA, ATA)
- executeSwap: use swapV2Ix for Token-2022 token compatibility
- closePosition: calculate rent refund via direct getBalance queries
  before close TX; use collectFeesQuote for fee amounts instead of
  unreliable wallet SOL change extraction

Fixes #584
---
 .../orca/clmm-routes/closePosition.ts         | 71 ++++++++-----------
 .../orca/clmm-routes/executeSwap.ts           | 23 +++++-
 .../orca/clmm-routes/openPosition.ts          | 38 +++++++---
 .../orca/clmm-routes/executeSwap.test.ts      |  5 +-
 .../orca/clmm-routes/openPosition.test.ts     |  9 ++-
 5 files changed, 91 insertions(+), 55 deletions(-)

diff --git a/src/connectors/orca/clmm-routes/closePosition.ts b/src/connectors/orca/clmm-routes/closePosition.ts
index fc9ae42dbb..96f9f957e3 100644
--- a/src/connectors/orca/clmm-routes/closePosition.ts
+++ b/src/connectors/orca/clmm-routes/closePosition.ts
@@ -236,7 +236,9 @@ export async function closePosition(
       }),
     );
 
-    // Note: We'll extract actual fee amounts from balance changes after transaction
+    // Use collectQuote for fee amounts (derived from on-chain position data)
+    baseFeeAmountCollected = Number(collectQuote.feeOwedA) / Math.pow(10, mintA.decimals);
+    quoteFeeAmountCollected = Number(collectQuote.feeOwedB) / Math.pow(10, mintB.decimals);
   }
 
   // Step 4: Auto-unwrap WSOL to native SOL after receiving all tokens
@@ -281,52 +283,37 @@ export async function closePosition(
     }),
   );
 
+  // Calculate rent refund by querying position account balances BEFORE the TX.
+  // These accounts will be closed by the transaction, so we must read them now.
+  // This is more accurate than deriving from wallet SOL changes, which can be
+  // skewed by ephemeral wSOL wrapper create/close cycles within the same TX.
+  const LAMPORT_TO_SOL = 1e-9;
+  const positionMintPubkey = position.getData().positionMint;
+  const positionTokenAccount = getAssociatedTokenAddressSync(
+    positionMintPubkey,
+    client.getContext().wallet.publicKey,
+    undefined,
+    isToken2022 ? TOKEN_2022_PROGRAM_ID : undefined,
+  );
+  const [positionMintBalance, positionDataBalance, positionAtaBalance] = await Promise.all([
+    solana.connection.getBalance(positionMintPubkey),
+    solana.connection.getBalance(positionPubkey),
+    solana.connection.getBalance(positionTokenAccount),
+  ]);
+  const positionRentRefunded = (positionMintBalance + positionDataBalance + positionAtaBalance) * LAMPORT_TO_SOL;
+
+  logger.info(
+    `Position rent refund: mint=${positionMintBalance}, data=${positionDataBalance}, ata=${positionAtaBalance}, total=${positionRentRefunded} SOL`,
+  );
+
   // Build, simulate, and send transaction
   const txPayload = await builder.build();
   await solana.simulateWithErrorHandling(txPayload.transaction);
   const { signature, fee } = await solana.sendAndConfirmTransaction(txPayload.transaction, [wallet]);
 
-  // Extract actual amounts from balance changes (more accurate than quotes)
-  const tokenAAddress = whirlpool.getTokenAInfo().address.toString();
-  const tokenBAddress = whirlpool.getTokenBInfo().address.toString();
-  const tokenA = await solana.getToken(tokenAAddress);
-  const tokenB = await solana.getToken(tokenBAddress);
-
-  const { balanceChanges } = await solana.extractBalanceChangesAndFee(
-    signature,
-    client.getContext().wallet.publicKey.toString(),
-    [tokenAAddress, tokenBAddress],
-  );
-
-  // Total balance changes (positive values = received)
-  const totalBaseChange = Math.abs(balanceChanges[0]);
-  const totalQuoteChange = Math.abs(balanceChanges[1]);
-
-  // If we removed liquidity, use the quote estimates as basis
-  // Otherwise, all balance change is from fees
-  if (hasLiquidity) {
-    // We have estimates from decreaseQuote, but actual amounts might differ slightly
-    // Use the estimates as reference, but ensure fees aren't negative
-    baseFeeAmountCollected = Math.max(0, totalBaseChange - baseTokenAmountRemoved);
-    quoteFeeAmountCollected = Math.max(0, totalQuoteChange - quoteTokenAmountRemoved);
-
-    // If fees would be negative, it means the estimate was slightly high
-    // Adjust the liquidity removed to match actual total
-    if (totalBaseChange < baseTokenAmountRemoved) {
-      baseTokenAmountRemoved = totalBaseChange;
-      baseFeeAmountCollected = 0;
-    }
-    if (totalQuoteChange < quoteTokenAmountRemoved) {
-      quoteTokenAmountRemoved = totalQuoteChange;
-      quoteFeeAmountCollected = 0;
-    }
-  } else {
-    // No liquidity removed, all balance change is fees
-    baseFeeAmountCollected = totalBaseChange;
-    quoteFeeAmountCollected = totalQuoteChange;
-  }
-
-  const positionRentRefunded = 0.00203928;
+  // Token amounts are already set from quotes:
+  // - baseTokenAmountRemoved / quoteTokenAmountRemoved from decreaseQuote (Step 2)
+  // - baseFeeAmountCollected / quoteFeeAmountCollected from collectQuote (Step 3)
 
   return {
     signature,
diff --git a/src/connectors/orca/clmm-routes/executeSwap.ts b/src/connectors/orca/clmm-routes/executeSwap.ts
index 71b83992e0..72986f02a9 100644
--- a/src/connectors/orca/clmm-routes/executeSwap.ts
+++ b/src/connectors/orca/clmm-routes/executeSwap.ts
@@ -7,6 +7,7 @@ import {
   swapQuoteByOutputToken,
   IGNORE_CACHE,
   SwapQuote,
+  TokenExtensionUtil,
 } from '@orca-so/whirlpools-sdk';
 import { getAssociatedTokenAddressSync } from '@solana/spl-token';
 import { PublicKey } from '@solana/web3.js';
@@ -187,16 +188,34 @@ export async function executeSwap(
   // Get oracle PDA
   const oraclePda = PDAUtil.getOracle(ORCA_WHIRLPOOL_PROGRAM_ID, whirlpoolPubkey);
 
-  // Add swap instruction
+  // Add swap V2 instruction (supports Token-2022 tokens)
   builder.addInstruction(
-    WhirlpoolIx.swapIx(client.getContext().program, {
+    WhirlpoolIx.swapV2Ix(client.getContext().program, {
       ...quote,
       whirlpool: whirlpoolPubkey,
       tokenAuthority: client.getContext().wallet.publicKey,
+      tokenMintA: whirlpool.getTokenAInfo().address,
+      tokenMintB: whirlpool.getTokenBInfo().address,
       tokenOwnerAccountA,
       tokenVaultA: whirlpool.getTokenVaultAInfo().address,
       tokenOwnerAccountB,
       tokenVaultB: whirlpool.getTokenVaultBInfo().address,
+      tokenProgramA: mintA.tokenProgram,
+      tokenProgramB: mintB.tokenProgram,
+      tokenTransferHookAccountsA: await TokenExtensionUtil.getExtraAccountMetasForTransferHook(
+        client.getContext().connection,
+        mintA,
+        tokenOwnerAccountA,
+        whirlpool.getTokenVaultAInfo().address,
+        client.getContext().wallet.publicKey,
+      ),
+      tokenTransferHookAccountsB: await TokenExtensionUtil.getExtraAccountMetasForTransferHook(
+        client.getContext().connection,
+        mintB,
+        tokenOwnerAccountB,
+        whirlpool.getTokenVaultBInfo().address,
+        client.getContext().wallet.publicKey,
+      ),
       oracle: oraclePda.publicKey,
     }),
   );
diff --git a/src/connectors/orca/clmm-routes/openPosition.ts b/src/connectors/orca/clmm-routes/openPosition.ts
index df3e208c48..ca382a33b0 100644
--- a/src/connectors/orca/clmm-routes/openPosition.ts
+++ b/src/connectors/orca/clmm-routes/openPosition.ts
@@ -12,7 +12,7 @@ import {
   IGNORE_CACHE,
 } from '@orca-so/whirlpools-sdk';
 import { Static } from '@sinclair/typebox';
-import { getAssociatedTokenAddressSync } from '@solana/spl-token';
+import { TOKEN_2022_PROGRAM_ID, getAssociatedTokenAddressSync } from '@solana/spl-token';
 import { Keypair, PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Decimal } from 'decimal.js';
@@ -135,6 +135,8 @@ async function addLiquidityInstructions(
       positionTokenAccount: getAssociatedTokenAddressSync(
         positionMintKeypair.publicKey,
         client.getContext().wallet.publicKey,
+        undefined,
+        TOKEN_2022_PROGRAM_ID,
       ),
       tokenMintA: whirlpool.getTokenAInfo().address,
       tokenMintB: whirlpool.getTokenBInfo().address,
@@ -361,23 +363,24 @@ export async function openPosition(
   const positionMintKeypair = Keypair.generate();
   const positionPda = PDAUtil.getPosition(ORCA_WHIRLPOOL_PROGRAM_ID, positionMintKeypair.publicKey);
 
-  // Always use TOKEN_PROGRAM with metadata (standard Orca positions)
-  // Position NFT token program is independent of pool's token programs
-  const metadataPda = PDAUtil.getPositionMetadata(positionMintKeypair.publicKey);
+  // Use Token-2022 position mint (embeds metadata in the mint account itself)
+  // This ensures all rent is fully refundable on close (fixes #584)
   builder.addInstruction(
-    WhirlpoolIx.openPositionWithMetadataIx(client.getContext().program, {
+    WhirlpoolIx.openPositionWithTokenExtensionsIx(client.getContext().program, {
       funder: client.getContext().wallet.publicKey,
       whirlpool: whirlpoolPubkey,
       tickLowerIndex: lowerTickIndex,
       tickUpperIndex: upperTickIndex,
       owner: client.getContext().wallet.publicKey,
-      positionMintAddress: positionMintKeypair.publicKey,
+      positionMint: positionMintKeypair.publicKey,
       positionPda,
       positionTokenAccount: getAssociatedTokenAddressSync(
         positionMintKeypair.publicKey,
         client.getContext().wallet.publicKey,
+        undefined,
+        TOKEN_2022_PROGRAM_ID,
       ),
-      metadataPda,
+      withTokenMetadataExtension: true,
     }),
   );
 
@@ -446,7 +449,26 @@ export async function openPosition(
     positionMintKeypair,
   ]);
 
-  const positionRent = 0.00203928; // Standard position account rent
+  // Calculate rent by querying the actual SOL balances of position accounts.
+  // This is more accurate than deriving from wallet SOL changes, which can be
+  // skewed by ephemeral wSOL wrapper create/close cycles within the same TX.
+  const LAMPORT_TO_SOL = 1e-9;
+  const positionTokenAccount = getAssociatedTokenAddressSync(
+    positionMintKeypair.publicKey,
+    client.getContext().wallet.publicKey,
+    undefined,
+    TOKEN_2022_PROGRAM_ID,
+  );
+  const [positionMintBalance, positionDataBalance, positionAtaBalance] = await Promise.all([
+    solana.connection.getBalance(positionMintKeypair.publicKey),
+    solana.connection.getBalance(positionPda.publicKey),
+    solana.connection.getBalance(positionTokenAccount),
+  ]);
+  const positionRent = (positionMintBalance + positionDataBalance + positionAtaBalance) * LAMPORT_TO_SOL;
+
+  logger.info(
+    `Position rent: mint=${positionMintBalance}, data=${positionDataBalance}, ata=${positionAtaBalance}, total=${positionRent} SOL`,
+  );
 
   if (shouldAddLiquidity) {
     logger.info(
diff --git a/test/connectors/orca/clmm-routes/executeSwap.test.ts b/test/connectors/orca/clmm-routes/executeSwap.test.ts
index a1d93f8cad..5362f778a5 100644
--- a/test/connectors/orca/clmm-routes/executeSwap.test.ts
+++ b/test/connectors/orca/clmm-routes/executeSwap.test.ts
@@ -18,12 +18,15 @@ jest.mock('@orca-so/whirlpools-sdk', () => ({
     getOracle: jest.fn().mockReturnValue({ publicKey: 'oracle-pubkey' }),
   },
   WhirlpoolIx: {
-    swapIx: jest.fn().mockReturnValue({
+    swapV2Ix: jest.fn().mockReturnValue({
       instructions: [],
       cleanupInstructions: [],
       signers: [],
     }),
   },
+  TokenExtensionUtil: {
+    getExtraAccountMetasForTransferHook: jest.fn().mockResolvedValue([]),
+  },
   IGNORE_CACHE: true,
 }));
 jest.mock('@orca-so/common-sdk', () => ({
diff --git a/test/connectors/orca/clmm-routes/openPosition.test.ts b/test/connectors/orca/clmm-routes/openPosition.test.ts
index 0de1c4e317..8794c2e3d1 100644
--- a/test/connectors/orca/clmm-routes/openPosition.test.ts
+++ b/test/connectors/orca/clmm-routes/openPosition.test.ts
@@ -19,12 +19,12 @@ jest.mock('@orca-so/whirlpools-sdk', () => ({
     priceToTickIndex: jest.fn().mockReturnValue(-28800),
   },
   WhirlpoolIx: {
-    openPositionIx: jest.fn().mockReturnValue({
+    openPositionWithTokenExtensionsIx: jest.fn().mockReturnValue({
       instructions: [],
       cleanupInstructions: [],
       signers: [],
     }),
-    increaseLiquidityIx: jest.fn().mockReturnValue({
+    increaseLiquidityV2Ix: jest.fn().mockReturnValue({
       instructions: [],
       cleanupInstructions: [],
       signers: [],
@@ -42,8 +42,10 @@ jest.mock('@orca-so/whirlpools-sdk', () => ({
   }),
   TokenExtensionUtil: {
     isV2IxRequiredPool: jest.fn().mockReturnValue(false),
+    buildTokenExtensionContext: jest.fn().mockResolvedValue({}),
   },
   ORCA_WHIRLPOOL_PROGRAM_ID: 'whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc',
+  IGNORE_CACHE: true,
 }));
 jest.mock('@orca-so/common-sdk', () => ({
   Percentage: {
@@ -103,6 +105,9 @@ describe('POST /open-position', () => {
         signature: 'test-signature',
         fee: 0.000005,
       }),
+      connection: {
+        getBalance: jest.fn().mockResolvedValue(2039280), // ~0.00204 SOL rent per account
+      },
     };
     (Solana.getInstance as jest.Mock).mockResolvedValue(mockSolana);
 

From 68a78145742d9db98bcd43ca51f83ceff77f355a Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Thu, 12 Feb 2026 09:13:13 -0800
Subject: [PATCH 31/37] fix: use on-chain data for real-time Orca pool price

The Orca API can return stale price data. This change fetches the
whirlpool data directly from the blockchain and calculates the price
from sqrtPrice for accurate real-time pricing.

- Fetch on-chain whirlpool data using getWhirlpool()
- Calculate price from sqrtPrice using PriceMath.sqrtPriceX64ToPrice()
- Fetch vault balances for accurate token amounts
- Keep API data for analytics fields (tvlUsdc, yieldOverTvl)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/connectors/orca/clmm-routes/poolInfo.ts | 58 +++++++++++++++++++--
 1 file changed, 55 insertions(+), 3 deletions(-)

diff --git a/src/connectors/orca/clmm-routes/poolInfo.ts b/src/connectors/orca/clmm-routes/poolInfo.ts
index 8a82306cbd..078c2d3e74 100644
--- a/src/connectors/orca/clmm-routes/poolInfo.ts
+++ b/src/connectors/orca/clmm-routes/poolInfo.ts
@@ -1,5 +1,9 @@
+import { PriceMath } from '@orca-so/whirlpools-sdk';
+import { getMint } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
 import { FastifyPluginAsync, FastifyInstance } from 'fastify';
 
+import { Solana } from '../../../chains/solana/solana';
 import { GetPoolInfoRequestType, PoolInfo } from '../../../schemas/clmm-schema';
 import { logger } from '../../../services/logger';
 import { Orca } from '../orca';
@@ -19,12 +23,60 @@ export async function getPoolInfo(
     throw fastify.httpErrors.badRequest('Pool address is required');
   }
 
-  // Fetch pool info directly from RPC
-  const poolInfo = (await orca.getPoolInfo(poolAddress)) as OrcaPoolInfo;
-  if (!poolInfo) {
+  // Fetch on-chain whirlpool data for real-time price AND API data for analytics fields
+  const [whirlpool, apiPoolInfo] = await Promise.all([
+    orca.getWhirlpool(poolAddress),
+    orca.getPoolInfo(poolAddress), // API data for tvlUsdc, yieldOverTvl, etc.
+  ]);
+
+  if (!whirlpool) {
     throw fastify.httpErrors.notFound(`Pool not found: ${poolAddress}`);
   }
 
+  // Get Solana connection for token info
+  const solana = await Solana.getInstance(network);
+
+  // Fetch token mint info for decimals
+  const [mintA, mintB] = await Promise.all([
+    getMint(solana.connection, new PublicKey(whirlpool.tokenMintA)),
+    getMint(solana.connection, new PublicKey(whirlpool.tokenMintB)),
+  ]);
+
+  // Calculate price from on-chain sqrtPrice (real-time)
+  const price = PriceMath.sqrtPriceX64ToPrice(whirlpool.sqrtPrice, mintA.decimals, mintB.decimals);
+
+  // Fetch vault balances for token amounts
+  const [vaultA, vaultB] = await Promise.all([
+    solana.connection.getTokenAccountBalance(new PublicKey(whirlpool.tokenVaultA)),
+    solana.connection.getTokenAccountBalance(new PublicKey(whirlpool.tokenVaultB)),
+  ]);
+
+  // Fee rate is stored in hundredths of basis points (e.g., 400 = 0.04%)
+  const feePct = Number(whirlpool.feeRate) / 10000;
+
+  // Protocol fee rate is stored in hundredths of basis points
+  const protocolFeeRate = Number(whirlpool.protocolFeeRate) / 10000;
+
+  // Build pool info: use on-chain data for price/ticks, API data for analytics
+  const poolInfo: OrcaPoolInfo = {
+    address: poolAddress,
+    baseTokenAddress: whirlpool.tokenMintA.toString(),
+    quoteTokenAddress: whirlpool.tokenMintB.toString(),
+    binStep: whirlpool.tickSpacing,
+    feePct,
+    price: price.toNumber(), // Real-time from on-chain sqrtPrice
+    baseTokenAmount: Number(vaultA.value.amount) / Math.pow(10, mintA.decimals),
+    quoteTokenAmount: Number(vaultB.value.amount) / Math.pow(10, mintB.decimals),
+    activeBinId: whirlpool.tickCurrentIndex, // Real-time from on-chain
+    // Orca-specific fields
+    liquidity: whirlpool.liquidity.toString(),
+    sqrtPrice: whirlpool.sqrtPrice.toString(), // Real-time from on-chain
+    // Analytics fields from API (not available on-chain)
+    tvlUsdc: apiPoolInfo?.tvlUsdc ?? 0,
+    protocolFeeRate,
+    yieldOverTvl: apiPoolInfo?.yieldOverTvl ?? 0,
+  };
+
   return poolInfo;
 }
 

From 6b45f1a65960bf991cfa08b6e20ca345f3b51666 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Thu, 12 Feb 2026 09:21:54 -0800
Subject: [PATCH 32/37] fix: update poolInfo tests for on-chain data fetching

Update tests to mock new dependencies:
- Mock Solana.getInstance for connection access
- Mock getMint from @solana/spl-token for decimal info
- Mock PriceMath.sqrtPriceX64ToPrice for price calculation
- Mock getWhirlpool for on-chain pool data
- Use valid Solana base58 addresses for vault mocks
- Add proper beforeEach reset for mock isolation

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../orca/clmm-routes/poolInfo.test.ts         | 73 ++++++++++++++++---
 1 file changed, 64 insertions(+), 9 deletions(-)

diff --git a/test/connectors/orca/clmm-routes/poolInfo.test.ts b/test/connectors/orca/clmm-routes/poolInfo.test.ts
index 55c82108dd..e3090e1d10 100644
--- a/test/connectors/orca/clmm-routes/poolInfo.test.ts
+++ b/test/connectors/orca/clmm-routes/poolInfo.test.ts
@@ -1,7 +1,21 @@
+import BN from 'bn.js';
+
+import { Solana } from '../../../../src/chains/solana/solana';
 import { Orca } from '../../../../src/connectors/orca/orca';
 import { fastifyWithTypeProvider } from '../../../utils/testUtils';
 
 jest.mock('../../../../src/connectors/orca/orca');
+jest.mock('../../../../src/chains/solana/solana');
+jest.mock('@solana/spl-token', () => ({
+  getMint: jest.fn(),
+}));
+jest.mock('@orca-so/whirlpools-sdk', () => ({
+  PriceMath: {
+    sqrtPriceX64ToPrice: jest.fn().mockReturnValue({
+      toNumber: () => 200.5,
+    }),
+  },
+}));
 
 const buildApp = async () => {
   const server = fastifyWithTypeProvider();
@@ -12,7 +26,24 @@ const buildApp = async () => {
 };
 
 const mockPoolAddress = 'Czfq3xZZDmsdGdUyrNLtRhGc47cXcZtLG4crryfu44zE';
-const mockPoolInfo = {
+
+// Mock whirlpool data (on-chain)
+// Use valid Solana base58 addresses (no 0, O, I, l characters)
+const mockWhirlpool = {
+  tokenMintA: 'So11111111111111111111111111111111111111112',
+  tokenMintB: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  tokenVaultA: '7jaiZR5Sk8hdYN9MxTpczTcwbWpb5WEoxSANuUwveuat',
+  tokenVaultB: '3YQm7ujtXWJU2e9jhp2QGHpnn1ShXn12QjvzMvDgabpX',
+  tickSpacing: 64,
+  feeRate: 400, // 0.04%
+  protocolFeeRate: 100, // 0.01%
+  tickCurrentIndex: -28800,
+  liquidity: new BN('1000000000'),
+  sqrtPrice: new BN('123456789'),
+};
+
+// Mock API pool info (for analytics fields)
+const mockApiPoolInfo = {
   address: mockPoolAddress,
   baseTokenAddress: 'So11111111111111111111111111111111111111112',
   quoteTokenAddress: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
@@ -31,15 +62,42 @@ const mockPoolInfo = {
 
 describe('GET /pool-info', () => {
   let app: any;
+  let getMintMock: jest.Mock;
 
   beforeAll(async () => {
+    // Import getMint mock
+    const splToken = await import('@solana/spl-token');
+    getMintMock = splToken.getMint as jest.Mock;
+
     app = await buildApp();
+  });
 
-    // Mock Orca.getInstance
+  beforeEach(() => {
+    // Reset mocks before each test
+    jest.clearAllMocks();
+
+    // Mock Orca.getInstance with both getWhirlpool and getPoolInfo
     const mockOrca = {
-      getPoolInfo: jest.fn().mockResolvedValue(mockPoolInfo),
+      getWhirlpool: jest.fn().mockResolvedValue(mockWhirlpool),
+      getPoolInfo: jest.fn().mockResolvedValue(mockApiPoolInfo),
     };
     (Orca.getInstance as jest.Mock).mockResolvedValue(mockOrca);
+
+    // Mock Solana.getInstance
+    const mockConnection = {
+      getTokenAccountBalance: jest.fn().mockResolvedValue({
+        value: { amount: '1000000000000' }, // 1000 tokens with 9 decimals
+      }),
+    };
+    const mockSolana = {
+      connection: mockConnection,
+    };
+    (Solana.getInstance as jest.Mock).mockResolvedValue(mockSolana);
+
+    // Mock getMint
+    getMintMock.mockResolvedValue({
+      decimals: 9,
+    });
   });
 
   afterAll(async () => {
@@ -102,6 +160,7 @@ describe('GET /pool-info', () => {
 
   it('should handle when pool not found', async () => {
     const mockOrca = {
+      getWhirlpool: jest.fn().mockResolvedValue(null),
       getPoolInfo: jest.fn().mockResolvedValue(null),
     };
     (Orca.getInstance as jest.Mock).mockResolvedValue(mockOrca);
@@ -121,7 +180,8 @@ describe('GET /pool-info', () => {
 
   it('should handle errors from Orca connector', async () => {
     const mockOrca = {
-      getPoolInfo: jest.fn().mockRejectedValue(new Error('Failed to fetch pool')),
+      getWhirlpool: jest.fn().mockRejectedValue(new Error('Failed to fetch pool')),
+      getPoolInfo: jest.fn().mockResolvedValue(mockApiPoolInfo),
     };
     (Orca.getInstance as jest.Mock).mockResolvedValue(mockOrca);
 
@@ -138,11 +198,6 @@ describe('GET /pool-info', () => {
   });
 
   it('should use default network if not provided', async () => {
-    const mockOrca = {
-      getPoolInfo: jest.fn().mockResolvedValue(mockPoolInfo),
-    };
-    (Orca.getInstance as jest.Mock).mockResolvedValue(mockOrca);
-
     const response = await app.inject({
       method: 'GET',
       url: '/pool-info',

From 582249414f075f7329c0d09eff192c4139895c52 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Thu, 12 Feb 2026 23:59:28 -0800
Subject: [PATCH 33/37] fix: add retry logic for fetching transaction data
 after confirmation

- Add _fetchTransactionWithRetry method with configurable retries
- Use retry logic in WebSocket and polling confirmation flows
- Use configurable timeout for WebSocket monitoring
- Apply retry to extractBalanceChangesAndFee for reliability

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/chains/solana/solana.ts | 53 ++++++++++++++++++++++++++-----------
 1 file changed, 38 insertions(+), 15 deletions(-)

diff --git a/src/chains/solana/solana.ts b/src/chains/solana/solana.ts
index 576ac5a4d1..cde0919023 100644
--- a/src/chains/solana/solana.ts
+++ b/src/chains/solana/solana.ts
@@ -1498,6 +1498,33 @@ export class Solana {
     return this._sendAndConfirmRawTransaction(serializedTx);
   }
 
+  /**
+   * Fetch transaction data with retry - data may not be immediately available after confirmation
+   */
+  private async _fetchTransactionWithRetry(
+    signature: string,
+    maxRetries: number = 5,
+    retryDelayMs: number = 500,
+    useParsed: boolean = false,
+  ): Promise<any> {
+    for (let i = 0; i < maxRetries; i++) {
+      const txData = useParsed
+        ? await this.connection.getParsedTransaction(signature, {
+            maxSupportedTransactionVersion: 0,
+          })
+        : await this.connection.getTransaction(signature, {
+            commitment: 'confirmed',
+            maxSupportedTransactionVersion: 0,
+          });
+      if (txData) return txData;
+      if (i < maxRetries - 1) {
+        logger.info(`Transaction ${signature} data not yet available, retry ${i + 1}/${maxRetries}...`);
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
+    }
+    return null;
+  }
+
   /**
    * Confirm transaction via WebSocket monitoring
    */
@@ -1507,15 +1534,16 @@ export class Solana {
     }
 
     try {
-      logger.info(`🚀 Sent transaction ${signature}, monitoring via WebSocket...`);
-      const confirmationResult = await this.rpcProviderService.monitorTransaction(signature, 60000);
+      const wsTimeout = this.config.confirmRetryInterval * this.config.confirmRetryCount * 1000;
+      logger.info(`🚀 Sent transaction ${signature}, monitoring via WebSocket (${wsTimeout / 1000}s timeout)...`);
+      const confirmationResult = await this.rpcProviderService.monitorTransaction(signature, wsTimeout);
 
       if (confirmationResult.confirmed) {
         logger.info(`✅ Transaction ${signature} confirmed via WebSocket`);
-        const txData = await this.connection.getTransaction(signature, {
-          commitment: 'confirmed',
-          maxSupportedTransactionVersion: 0,
-        });
+        const txData = await this._fetchTransactionWithRetry(signature);
+        if (!txData) {
+          logger.warn(`Transaction ${signature} confirmed but data not available`);
+        }
         return { confirmed: true, txData };
       } else {
         logger.warn(`❌ Transaction ${signature} not confirmed via WebSocket within timeout`);
@@ -1553,10 +1581,7 @@ export class Solana {
 
           if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized') {
             logger.info(`✅ Transaction ${signature} confirmed after ${attempts} attempts`);
-            const txData = await this.connection.getTransaction(signature, {
-              commitment: 'confirmed',
-              maxSupportedTransactionVersion: 0,
-            });
+            const txData = await this._fetchTransactionWithRetry(signature);
             return { confirmed: true, txData };
           }
         }
@@ -1653,13 +1678,11 @@ export class Solana {
     balanceChanges: number[];
     fee: number;
   }> {
-    // Fetch transaction details
-    const txDetails = await this.connection.getParsedTransaction(signature, {
-      maxSupportedTransactionVersion: 0,
-    });
+    // Fetch transaction details with retry (data may not be immediately available after confirmation)
+    const txDetails = await this._fetchTransactionWithRetry(signature, 5, 500, true);
 
     if (!txDetails) {
-      throw new Error(`Transaction ${signature} not found`);
+      throw new Error(`Transaction ${signature} not found after retries`);
     }
 
     // Calculate fee including priority fee using the same method as getFee

From a4069980717024b021847d5b3056edf0dcddc97d Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Thu, 19 Feb 2026 09:57:32 -0800
Subject: [PATCH 34/37] fix: support Token2022 tokens in Orca pool-info

Replace getMint from @solana/spl-token with fetchAllMint from
@solana-program/token-2022 to support both standard SPL Token and
Token2022 (Token Extensions) programs.

This fixes TokenInvalidAccountOwnerError when querying pools with
Token2022 tokens like PYUSD.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/connectors/orca/clmm-routes/poolInfo.ts   | 15 ++-
 .../orca/clmm-routes/poolInfo.test.ts         | 91 +++++++++++++++++--
 2 files changed, 87 insertions(+), 19 deletions(-)

diff --git a/src/connectors/orca/clmm-routes/poolInfo.ts b/src/connectors/orca/clmm-routes/poolInfo.ts
index 078c2d3e74..a84623aee5 100644
--- a/src/connectors/orca/clmm-routes/poolInfo.ts
+++ b/src/connectors/orca/clmm-routes/poolInfo.ts
@@ -1,6 +1,6 @@
 import { PriceMath } from '@orca-so/whirlpools-sdk';
-import { getMint } from '@solana/spl-token';
 import { PublicKey } from '@solana/web3.js';
+import { fetchAllMint } from '@solana-program/token-2022';
 import { FastifyPluginAsync, FastifyInstance } from 'fastify';
 
 import { Solana } from '../../../chains/solana/solana';
@@ -36,14 +36,11 @@ export async function getPoolInfo(
   // Get Solana connection for token info
   const solana = await Solana.getInstance(network);
 
-  // Fetch token mint info for decimals
-  const [mintA, mintB] = await Promise.all([
-    getMint(solana.connection, new PublicKey(whirlpool.tokenMintA)),
-    getMint(solana.connection, new PublicKey(whirlpool.tokenMintB)),
-  ]);
+  // Fetch token mint info for decimals (supports both Token and Token2022)
+  const [mintA, mintB] = await fetchAllMint(orca.solanaKitRpc, [whirlpool.tokenMintA, whirlpool.tokenMintB]);
 
   // Calculate price from on-chain sqrtPrice (real-time)
-  const price = PriceMath.sqrtPriceX64ToPrice(whirlpool.sqrtPrice, mintA.decimals, mintB.decimals);
+  const price = PriceMath.sqrtPriceX64ToPrice(whirlpool.sqrtPrice, mintA.data.decimals, mintB.data.decimals);
 
   // Fetch vault balances for token amounts
   const [vaultA, vaultB] = await Promise.all([
@@ -65,8 +62,8 @@ export async function getPoolInfo(
     binStep: whirlpool.tickSpacing,
     feePct,
     price: price.toNumber(), // Real-time from on-chain sqrtPrice
-    baseTokenAmount: Number(vaultA.value.amount) / Math.pow(10, mintA.decimals),
-    quoteTokenAmount: Number(vaultB.value.amount) / Math.pow(10, mintB.decimals),
+    baseTokenAmount: Number(vaultA.value.amount) / Math.pow(10, mintA.data.decimals),
+    quoteTokenAmount: Number(vaultB.value.amount) / Math.pow(10, mintB.data.decimals),
     activeBinId: whirlpool.tickCurrentIndex, // Real-time from on-chain
     // Orca-specific fields
     liquidity: whirlpool.liquidity.toString(),
diff --git a/test/connectors/orca/clmm-routes/poolInfo.test.ts b/test/connectors/orca/clmm-routes/poolInfo.test.ts
index e3090e1d10..2854d78ba6 100644
--- a/test/connectors/orca/clmm-routes/poolInfo.test.ts
+++ b/test/connectors/orca/clmm-routes/poolInfo.test.ts
@@ -6,8 +6,8 @@ import { fastifyWithTypeProvider } from '../../../utils/testUtils';
 
 jest.mock('../../../../src/connectors/orca/orca');
 jest.mock('../../../../src/chains/solana/solana');
-jest.mock('@solana/spl-token', () => ({
-  getMint: jest.fn(),
+jest.mock('@solana-program/token-2022', () => ({
+  fetchAllMint: jest.fn(),
 }));
 jest.mock('@orca-so/whirlpools-sdk', () => ({
   PriceMath: {
@@ -62,12 +62,12 @@ const mockApiPoolInfo = {
 
 describe('GET /pool-info', () => {
   let app: any;
-  let getMintMock: jest.Mock;
+  let fetchAllMintMock: jest.Mock;
 
   beforeAll(async () => {
-    // Import getMint mock
-    const splToken = await import('@solana/spl-token');
-    getMintMock = splToken.getMint as jest.Mock;
+    // Import fetchAllMint mock
+    const token2022 = await import('@solana-program/token-2022');
+    fetchAllMintMock = token2022.fetchAllMint as jest.Mock;
 
     app = await buildApp();
   });
@@ -80,6 +80,7 @@ describe('GET /pool-info', () => {
     const mockOrca = {
       getWhirlpool: jest.fn().mockResolvedValue(mockWhirlpool),
       getPoolInfo: jest.fn().mockResolvedValue(mockApiPoolInfo),
+      solanaKitRpc: {}, // Mock RPC
     };
     (Orca.getInstance as jest.Mock).mockResolvedValue(mockOrca);
 
@@ -94,10 +95,11 @@ describe('GET /pool-info', () => {
     };
     (Solana.getInstance as jest.Mock).mockResolvedValue(mockSolana);
 
-    // Mock getMint
-    getMintMock.mockResolvedValue({
-      decimals: 9,
-    });
+    // Mock fetchAllMint - returns array of mint data with .data.decimals structure
+    fetchAllMintMock.mockResolvedValue([
+      { data: { decimals: 9 } }, // mintA
+      { data: { decimals: 9 } }, // mintB
+    ]);
   });
 
   afterAll(async () => {
@@ -224,4 +226,73 @@ describe('GET /pool-info', () => {
 
     expect(response.statusCode).toBe(503);
   });
+
+  it('should handle Token2022 tokens like PYUSD', async () => {
+    // PYUSD is a Token2022 token - the fix uses fetchAllMint which supports both Token and Token2022
+    const pyusdPoolAddress = '9tXiuRRw7kbejLhZXtxDxYs2REe43uH2e7k1kocgdM9B';
+    const pyusdMint = '2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo';
+    const usdcMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
+
+    // Mock whirlpool data with PYUSD (Token2022) and USDC (Token) pair
+    const mockPyusdWhirlpool = {
+      tokenMintA: pyusdMint,
+      tokenMintB: usdcMint,
+      tokenVaultA: '7jaiZR5Sk8hdYN9MxTpczTcwbWpb5WEoxSANuUwveuat',
+      tokenVaultB: '3YQm7ujtXWJU2e9jhp2QGHpnn1ShXn12QjvzMvDgabpX',
+      tickSpacing: 1,
+      feeRate: 100, // 0.01%
+      protocolFeeRate: 1300, // 0.13%
+      tickCurrentIndex: 0,
+      liquidity: new BN('43569222763129181'),
+      sqrtPrice: new BN('18447148653206777165'),
+    };
+
+    const mockPyusdApiPoolInfo = {
+      address: pyusdPoolAddress,
+      baseTokenAddress: pyusdMint,
+      quoteTokenAddress: usdcMint,
+      binStep: 1,
+      feePct: 0.01,
+      price: 1.0,
+      baseTokenAmount: 16826537.332925,
+      quoteTokenAmount: 14220697.597852,
+      activeBinId: 0,
+      liquidity: '43569222763129181',
+      sqrtPrice: '18447148653206777165',
+      tvlUsdc: 31045721.31,
+      protocolFeeRate: 0.13,
+      yieldOverTvl: 0.00000817197170889726,
+    };
+
+    const mockOrca = {
+      getWhirlpool: jest.fn().mockResolvedValue(mockPyusdWhirlpool),
+      getPoolInfo: jest.fn().mockResolvedValue(mockPyusdApiPoolInfo),
+      solanaKitRpc: {},
+    };
+    (Orca.getInstance as jest.Mock).mockResolvedValue(mockOrca);
+
+    // fetchAllMint handles both Token and Token2022 programs
+    // PYUSD has 6 decimals, USDC has 6 decimals
+    fetchAllMintMock.mockResolvedValue([
+      { data: { decimals: 6 } }, // PYUSD (Token2022)
+      { data: { decimals: 6 } }, // USDC (Token)
+    ]);
+
+    const response = await app.inject({
+      method: 'GET',
+      url: '/pool-info',
+      query: {
+        network: 'mainnet-beta',
+        poolAddress: pyusdPoolAddress,
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+    const body = JSON.parse(response.body);
+    expect(body).toHaveProperty('address', pyusdPoolAddress);
+    expect(body).toHaveProperty('baseTokenAddress', pyusdMint);
+    expect(body).toHaveProperty('quoteTokenAddress', usdcMint);
+    expect(body).toHaveProperty('feePct', 0.01);
+    expect(body).toHaveProperty('binStep', 1);
+  });
 });

From e9b15fb86e6e1c10860bf67b954bcc16d9f11987 Mon Sep 17 00:00:00 2001
From: Michael Feng <mifeng@gmail.com>
Date: Tue, 24 Feb 2026 10:01:59 -0800
Subject: [PATCH 35/37] fix: extract positionRent from transaction account
 balances for Meteora CLMM

Previously, rent was calculated by subtracting the requested liquidity amount
from the wallet's SOL balance change, which was incorrect. Now we extract
the actual rent from the position account's balance in the transaction:
- openPosition: uses position account's postBalance (newly created = rent)
- closePosition: uses position account's preBalance (before closing = refunded rent)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../meteora/clmm-routes/closePosition.ts      | 42 +++++++++---------
 .../meteora/clmm-routes/openPosition.ts       | 44 +++++++++----------
 2 files changed, 42 insertions(+), 44 deletions(-)

diff --git a/src/connectors/meteora/clmm-routes/closePosition.ts b/src/connectors/meteora/clmm-routes/closePosition.ts
index 03baa27e99..f1c7925038 100644
--- a/src/connectors/meteora/clmm-routes/closePosition.ts
+++ b/src/connectors/meteora/clmm-routes/closePosition.ts
@@ -1,13 +1,10 @@
 import { BN } from '@coral-xyz/anchor';
 import { Static } from '@sinclair/typebox';
+import { PublicKey } from '@solana/web3.js';
 import { FastifyPluginAsync } from 'fastify';
 
 import { Solana } from '../../../chains/solana/solana';
-import {
-  ClosePositionResponse,
-  ClosePositionRequestType,
-  ClosePositionResponseType,
-} from '../../../schemas/clmm-schema';
+import { ClosePositionResponse, ClosePositionResponseType } from '../../../schemas/clmm-schema';
 import { httpErrors } from '../../../services/error-handler';
 import { logger } from '../../../services/logger';
 import { Meteora } from '../meteora';
@@ -98,6 +95,19 @@ export async function closePosition(
     if (confirmed && txData) {
       logger.info(`Position ${positionAddress} closed successfully with signature: ${signature}`);
 
+      // Extract position rent refunded from the position account's preBalance
+      // When closing, the position account's lamports (rent) are returned to the wallet
+      const positionPubkey = new PublicKey(positionAddress);
+      const accountKeys = txData.transaction.message.getAccountKeys().staticAccountKeys;
+      const preBalances = txData.meta?.preBalances || [];
+
+      let positionRentRefunded = 0;
+      const positionAccountIndex = accountKeys.findIndex((key) => key.equals(positionPubkey));
+      if (positionAccountIndex !== -1) {
+        // Position account's balance before closing IS the rent that gets refunded
+        positionRentRefunded = preBalances[positionAccountIndex] / 1e9; // Convert lamports to SOL
+      }
+
       // Track wallet's balance changes for the tokens
       const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
         dlmmPool.tokenX.publicKey.toBase58(),
@@ -108,26 +118,16 @@ export async function closePosition(
       let totalTokenXReceived = Math.abs(balanceChanges[0]);
       let totalTokenYReceived = Math.abs(balanceChanges[1]);
 
-      // When SOL is base/quote, wallet receives: liquidity + fees + rent refund - tx fee
-      // We need to separate rent refund from the token amounts
-      let positionRentRefunded = 0;
+      // When SOL is base/quote, wallet balance change includes: liquidity + fees + rent refund - tx fee
+      // We need to subtract rent refund to get actual token amounts
       if (tokenXSymbol === 'SOL') {
-        // SOL is base token
-        // Total SOL received = liquidity + fees + rent - tx fee
-        // We know fees from positionInfo, so:
-        // rent = total received + tx fee - liquidity - fees
-        // But we don't know liquidity separately, so use positionInfo.baseTokenAmount
-        const expectedLiquidity = positionInfo.baseTokenAmount;
-        positionRentRefunded = totalTokenXReceived + totalFee - expectedLiquidity - baseFeeAmount;
-        if (positionRentRefunded < 0) positionRentRefunded = 0;
-        // Adjust to exclude rent refund from token received
+        // SOL is base token - subtract rent refund and add back tx fee
         totalTokenXReceived = totalTokenXReceived - positionRentRefunded + totalFee;
+        if (totalTokenXReceived < 0) totalTokenXReceived = 0;
       } else if (tokenYSymbol === 'SOL') {
-        // SOL is quote token
-        const expectedLiquidity = positionInfo.quoteTokenAmount;
-        positionRentRefunded = totalTokenYReceived + totalFee - expectedLiquidity - quoteFeeAmount;
-        if (positionRentRefunded < 0) positionRentRefunded = 0;
+        // SOL is quote token - subtract rent refund and add back tx fee
         totalTokenYReceived = totalTokenYReceived - positionRentRefunded + totalFee;
+        if (totalTokenYReceived < 0) totalTokenYReceived = 0;
       }
 
       // Separate fees from liquidity amounts
diff --git a/src/connectors/meteora/clmm-routes/openPosition.ts b/src/connectors/meteora/clmm-routes/openPosition.ts
index eccbf80cc1..f73f27edef 100644
--- a/src/connectors/meteora/clmm-routes/openPosition.ts
+++ b/src/connectors/meteora/clmm-routes/openPosition.ts
@@ -1,6 +1,6 @@
 import { DecimalUtil } from '@orca-so/common-sdk';
 import { Static } from '@sinclair/typebox';
-import { Keypair, PublicKey, Transaction } from '@solana/web3.js';
+import { Keypair, PublicKey } from '@solana/web3.js';
 import { BN } from 'bn.js';
 import { Decimal } from 'decimal.js';
 import { FastifyPluginAsync } from 'fastify';
@@ -16,16 +16,10 @@ import { MeteoraClmmOpenPositionRequest } from '../schemas';
 // Using Fastify's native error handling
 
 // Define error messages
-const INVALID_SOLANA_ADDRESS_MESSAGE = (address: string) => `Invalid Solana address: ${address}`;
 const POOL_NOT_FOUND_MESSAGE = (poolAddress: string) => `Pool not found: ${poolAddress}`;
 const MISSING_AMOUNTS_MESSAGE = 'Missing amounts for position creation';
-const INSUFFICIENT_BALANCE_MESSAGE = (token: string, required: string, actual: string) =>
-  `Insufficient balance for ${token}. Required: ${required}, Available: ${actual}`;
 const OPEN_POSITION_ERROR_MESSAGE = (error: any) => `Failed to open position: ${error.message || error}`;
 
-const SOL_POSITION_RENT = 0.05; // SOL amount required for position rent
-const SOL_TRANSACTION_BUFFER = 0.01; // Additional SOL buffer for transaction costs
-
 export async function openPosition(
   network: string,
   walletAddress: string,
@@ -174,6 +168,19 @@ export async function openPosition(
   const confirmed = txData !== null;
 
   if (confirmed && txData) {
+    // Extract position rent from the position account's SOL balance
+    // The position account is newly created, so its postBalance IS the rent
+    const positionPubkey = newImbalancePosition.publicKey;
+    const accountKeys = txData.transaction.message.getAccountKeys().staticAccountKeys;
+    const postBalances = txData.meta?.postBalances || [];
+
+    let positionRent = 0;
+    const positionAccountIndex = accountKeys.findIndex((key) => key.equals(positionPubkey));
+    if (positionAccountIndex !== -1) {
+      // Position account's balance after tx is the rent (it was 0 before creation)
+      positionRent = postBalances[positionAccountIndex] / 1e9; // Convert lamports to SOL
+    }
+
     // Track wallet's balance changes for the tokens
     const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
       dlmmPool.tokenX.publicKey.toBase58(),
@@ -184,25 +191,16 @@ export async function openPosition(
     let baseAmountAdded = Math.abs(balanceChanges[0]);
     let quoteAmountAdded = Math.abs(balanceChanges[1]);
 
-    // Calculate position rent for new positions
     // When SOL is base/quote, wallet balance change includes: liquidity + rent + fee
-    // We need to separate rent from liquidity
-    let positionRent = 0;
+    // We need to subtract rent to get actual liquidity added
     if (tokenXSymbol === 'SOL') {
-      // SOL is base token - subtract fee and rent from balance change
-      // Rent = total spent - fee - actual liquidity (what user requested)
-      const totalSOLSpent = baseAmountAdded;
-      const requestedLiquidity = baseTokenAmount || 0;
-      positionRent = totalSOLSpent - txFee - requestedLiquidity;
-      if (positionRent < 0) positionRent = 0;
-      baseAmountAdded = requestedLiquidity;
+      // SOL is base token - subtract rent from balance change to get actual liquidity
+      baseAmountAdded = baseAmountAdded - positionRent - txFee;
+      if (baseAmountAdded < 0) baseAmountAdded = 0;
     } else if (tokenYSymbol === 'SOL') {
-      // SOL is quote token
-      const totalSOLSpent = quoteAmountAdded;
-      const requestedLiquidity = quoteTokenAmount || 0;
-      positionRent = totalSOLSpent - txFee - requestedLiquidity;
-      if (positionRent < 0) positionRent = 0;
-      quoteAmountAdded = requestedLiquidity;
+      // SOL is quote token - subtract rent from balance change to get actual liquidity
+      quoteAmountAdded = quoteAmountAdded - positionRent - txFee;
+      if (quoteAmountAdded < 0) quoteAmountAdded = 0;
     }
 
     logger.info(

From 415a5a498a15c26959a98bb0f6b665a918c7dc7e Mon Sep 17 00:00:00 2001
From: Wojak <machinelearningguys@gmail.com>
Date: Wed, 25 Feb 2026 17:50:55 +0700
Subject: [PATCH 36/37] fix getting rent value

---
 .../orca/clmm-routes/closePosition.ts         | 134 +++++++++++-------
 .../orca/clmm-routes/openPosition.ts          | 112 ++++++++++++---
 .../orca/clmm-routes/openPosition.test.ts     |  18 ++-
 3 files changed, 185 insertions(+), 79 deletions(-)

diff --git a/src/connectors/orca/clmm-routes/closePosition.ts b/src/connectors/orca/clmm-routes/closePosition.ts
index 96f9f957e3..c9ff3817f8 100644
--- a/src/connectors/orca/clmm-routes/closePosition.ts
+++ b/src/connectors/orca/clmm-routes/closePosition.ts
@@ -1,8 +1,6 @@
 import { Percentage, TransactionBuilder } from '@orca-so/common-sdk';
 import {
-  TickArrayUtil,
   WhirlpoolIx,
-  collectFeesQuote,
   decreaseLiquidityQuoteByLiquidityWithParams,
   TokenExtensionUtil,
   IGNORE_CACHE,
@@ -176,30 +174,10 @@ export async function closePosition(
   }
 
   // Step 3: Collect fees if there are fees owed or if we just removed liquidity
+  // Note: Fee amounts are derived from actual TX balance changes after execution,
+  // not from collectFeesQuote() which reads stale position data before
+  // updateFeesAndRewards executes on-chain.
   if (hasFees || hasLiquidity) {
-    const { lower, upper } = getTickArrayPubkeys(position.getData(), whirlpool.getData(), whirlpoolPubkey);
-    const lowerTickArray = await client.getFetcher().getTickArray(lower);
-    const upperTickArray = await client.getFetcher().getTickArray(upper);
-    if (!lowerTickArray || !upperTickArray) {
-      throw httpErrors.notFound('Tick array not found');
-    }
-
-    const collectQuote = collectFeesQuote({
-      position: position.getData(),
-      tickLower: TickArrayUtil.getTickFromArray(
-        lowerTickArray,
-        position.getData().tickLowerIndex,
-        whirlpool.getData().tickSpacing,
-      ),
-      tickUpper: TickArrayUtil.getTickFromArray(
-        upperTickArray,
-        position.getData().tickUpperIndex,
-        whirlpool.getData().tickSpacing,
-      ),
-      whirlpool: whirlpool.getData(),
-      tokenExtensionCtx: await TokenExtensionUtil.buildTokenExtensionContext(client.getFetcher(), whirlpool.getData()),
-    });
-
     builder.addInstruction(
       WhirlpoolIx.collectFeesV2Ix(client.getContext().program, {
         position: positionPubkey,
@@ -235,10 +213,6 @@ export async function closePosition(
         ),
       }),
     );
-
-    // Use collectQuote for fee amounts (derived from on-chain position data)
-    baseFeeAmountCollected = Number(collectQuote.feeOwedA) / Math.pow(10, mintA.decimals);
-    quoteFeeAmountCollected = Number(collectQuote.feeOwedB) / Math.pow(10, mintB.decimals);
   }
 
   // Step 4: Auto-unwrap WSOL to native SOL after receiving all tokens
@@ -283,37 +257,87 @@ export async function closePosition(
     }),
   );
 
-  // Calculate rent refund by querying position account balances BEFORE the TX.
-  // These accounts will be closed by the transaction, so we must read them now.
-  // This is more accurate than deriving from wallet SOL changes, which can be
-  // skewed by ephemeral wSOL wrapper create/close cycles within the same TX.
-  const LAMPORT_TO_SOL = 1e-9;
-  const positionMintPubkey = position.getData().positionMint;
-  const positionTokenAccount = getAssociatedTokenAddressSync(
-    positionMintPubkey,
-    client.getContext().wallet.publicKey,
-    undefined,
-    isToken2022 ? TOKEN_2022_PROGRAM_ID : undefined,
-  );
-  const [positionMintBalance, positionDataBalance, positionAtaBalance] = await Promise.all([
-    solana.connection.getBalance(positionMintPubkey),
-    solana.connection.getBalance(positionPubkey),
-    solana.connection.getBalance(positionTokenAccount),
-  ]);
-  const positionRentRefunded = (positionMintBalance + positionDataBalance + positionAtaBalance) * LAMPORT_TO_SOL;
-
-  logger.info(
-    `Position rent refund: mint=${positionMintBalance}, data=${positionDataBalance}, ata=${positionAtaBalance}, total=${positionRentRefunded} SOL`,
-  );
-
   // Build, simulate, and send transaction
   const txPayload = await builder.build();
   await solana.simulateWithErrorHandling(txPayload.transaction);
   const { signature, fee } = await solana.sendAndConfirmTransaction(txPayload.transaction, [wallet]);
 
-  // Token amounts are already set from quotes:
-  // - baseTokenAmountRemoved / quoteTokenAmountRemoved from decreaseQuote (Step 2)
-  // - baseFeeAmountCollected / quoteFeeAmountCollected from collectQuote (Step 3)
+  // Extract rent refund and actual token amounts from the confirmed transaction.
+  // Position accounts (mint, PDA, ATA) are closed by the TX, so their preBalance = rent refunded.
+  // Tick arrays are NOT closed (shared resources), so they are not included here.
+  const txData = await solana.connection.getTransaction(signature, {
+    commitment: 'confirmed',
+    maxSupportedTransactionVersion: 0,
+  });
+
+  let positionRentRefunded = 0;
+
+  if (txData) {
+    const accountKeys = txData.transaction.message.getAccountKeys().staticAccountKeys;
+    const preBalances = txData.meta?.preBalances || [];
+    const postBalances = txData.meta?.postBalances || [];
+
+    // Position accounts whose rent gets refunded on close
+    const positionMintPubkey = position.getData().positionMint;
+    const positionTokenAccount = getAssociatedTokenAddressSync(
+      positionMintPubkey,
+      client.getContext().wallet.publicKey,
+      undefined,
+      isToken2022 ? TOKEN_2022_PROGRAM_ID : undefined,
+    );
+    const rentAccounts: PublicKey[] = [positionMintPubkey, positionPubkey, positionTokenAccount];
+
+    let totalRentLamports = 0;
+    for (const pubkey of rentAccounts) {
+      const idx = accountKeys.findIndex((key) => key.equals(pubkey));
+      if (idx !== -1 && postBalances[idx] === 0 && preBalances[idx] > 0) {
+        totalRentLamports += preBalances[idx];
+        logger.info(`Rent refunded from ${pubkey.toString()}: ${preBalances[idx]} lamports`);
+      }
+    }
+    positionRentRefunded = totalRentLamports / 1e9;
+
+    // Derive actual token amounts from TX balance changes
+    const tokenMintA = whirlpool.getTokenAInfo().address.toString();
+    const tokenMintB = whirlpool.getTokenBInfo().address.toString();
+
+    const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
+      tokenMintA,
+      tokenMintB,
+    ]);
+
+    // Balance changes are positive (tokens entering wallet)
+    let totalBaseReceived = Math.abs(balanceChanges[0]);
+    let totalQuoteReceived = Math.abs(balanceChanges[1]);
+
+    // When SOL is one of the tokens, wallet balance change includes:
+    // liquidity + fees + rent refund - tx fee
+    // Subtract rent refund and add back tx fee to isolate actual token amounts
+    const SOL_NATIVE_MINT = 'So11111111111111111111111111111111111111112';
+    if (tokenMintA === SOL_NATIVE_MINT) {
+      totalBaseReceived = totalBaseReceived - positionRentRefunded + fee;
+      if (totalBaseReceived < 0) totalBaseReceived = 0;
+    } else if (tokenMintB === SOL_NATIVE_MINT) {
+      totalQuoteReceived = totalQuoteReceived - positionRentRefunded + fee;
+      if (totalQuoteReceived < 0) totalQuoteReceived = 0;
+    }
+
+    // Separate fees from liquidity amounts:
+    // totalReceived = liquidityRemoved + feesCollected
+    // feesCollected = totalReceived - liquidityRemoved (from decreaseQuote estimate)
+    baseFeeAmountCollected = Math.max(0, totalBaseReceived - baseTokenAmountRemoved);
+    quoteFeeAmountCollected = Math.max(0, totalQuoteReceived - quoteTokenAmountRemoved);
+
+    // Update removed amounts to actuals (totalReceived - fees)
+    baseTokenAmountRemoved = totalBaseReceived - baseFeeAmountCollected;
+    quoteTokenAmountRemoved = totalQuoteReceived - quoteFeeAmountCollected;
+  }
+
+  logger.info(
+    `Position closed: removed=${baseTokenAmountRemoved.toFixed(6)} tokenA + ${quoteTokenAmountRemoved.toFixed(6)} tokenB, ` +
+      `fees=${baseFeeAmountCollected.toFixed(6)} tokenA + ${quoteFeeAmountCollected.toFixed(6)} tokenB, ` +
+      `rent refunded=${positionRentRefunded.toFixed(6)} SOL`,
+  );
 
   return {
     signature,
diff --git a/src/connectors/orca/clmm-routes/openPosition.ts b/src/connectors/orca/clmm-routes/openPosition.ts
index ca382a33b0..005650ebe6 100644
--- a/src/connectors/orca/clmm-routes/openPosition.ts
+++ b/src/connectors/orca/clmm-routes/openPosition.ts
@@ -27,7 +27,9 @@ import { getTickArrayPubkeys, handleWsolAta } from '../orca.utils';
 import { OrcaClmmOpenPositionRequest } from '../schemas';
 
 /**
- * Initialize tick arrays if they don't exist
+ * Initialize tick arrays if they don't exist.
+ * Returns the pubkeys of any newly-created tick arrays so their rent
+ * can be included in the total position rent calculation.
  */
 async function initializeTickArrays(
   builder: TransactionBuilder,
@@ -36,9 +38,11 @@ async function initializeTickArrays(
   whirlpoolPubkey: PublicKey,
   lowerTickIndex: number,
   upperTickIndex: number,
-): Promise<void> {
+): Promise<PublicKey[]> {
   await whirlpool.refreshData();
 
+  const newTickArrayPubkeys: PublicKey[] = [];
+
   const lowerTickArrayPda = PDAUtil.getTickArrayFromTickIndex(
     lowerTickIndex,
     whirlpool.getData().tickSpacing,
@@ -64,6 +68,7 @@ async function initializeTickArrays(
         tickArrayPda: lowerTickArrayPda,
       }),
     );
+    newTickArrayPubkeys.push(lowerTickArrayPda.publicKey);
   }
 
   if (!upperTickArray && !upperTickArrayPda.publicKey.equals(lowerTickArrayPda.publicKey)) {
@@ -75,7 +80,10 @@ async function initializeTickArrays(
         tickArrayPda: upperTickArrayPda,
       }),
     );
+    newTickArrayPubkeys.push(upperTickArrayPda.publicKey);
   }
+
+  return newTickArrayPubkeys;
 }
 
 /**
@@ -216,8 +224,15 @@ export async function openPosition(
   // Build transaction
   const builder = new TransactionBuilder(client.getContext().connection, client.getContext().wallet);
 
-  // Initialize tick arrays if needed
-  await initializeTickArrays(builder, client, whirlpool, whirlpoolPubkey, lowerTickIndex, upperTickIndex);
+  // Initialize tick arrays if needed (returns pubkeys of newly-created arrays for rent tracking)
+  const newTickArrayPubkeys = await initializeTickArrays(
+    builder,
+    client,
+    whirlpool,
+    whirlpoolPubkey,
+    lowerTickIndex,
+    upperTickIndex,
+  );
 
   // If we're adding liquidity, prepare WSOL wrapping FIRST (before opening position)
   let baseTokenAmountAdded = 0;
@@ -449,26 +464,77 @@ export async function openPosition(
     positionMintKeypair,
   ]);
 
-  // Calculate rent by querying the actual SOL balances of position accounts.
-  // This is more accurate than deriving from wallet SOL changes, which can be
-  // skewed by ephemeral wSOL wrapper create/close cycles within the same TX.
-  const LAMPORT_TO_SOL = 1e-9;
-  const positionTokenAccount = getAssociatedTokenAddressSync(
-    positionMintKeypair.publicKey,
-    client.getContext().wallet.publicKey,
-    undefined,
-    TOKEN_2022_PROGRAM_ID,
-  );
-  const [positionMintBalance, positionDataBalance, positionAtaBalance] = await Promise.all([
-    solana.connection.getBalance(positionMintKeypair.publicKey),
-    solana.connection.getBalance(positionPda.publicKey),
-    solana.connection.getBalance(positionTokenAccount),
-  ]);
-  const positionRent = (positionMintBalance + positionDataBalance + positionAtaBalance) * LAMPORT_TO_SOL;
+  // Extract position rent from the confirmed transaction's postBalances.
+  // Newly-created accounts have preBalance=0, so their postBalance IS the rent.
+  // This captures ALL rent including tick arrays (~0.013 SOL each) that were
+  // previously missed when only querying 3 position accounts.
+  const txData = await solana.connection.getTransaction(signature, {
+    commitment: 'confirmed',
+    maxSupportedTransactionVersion: 0,
+  });
+
+  let positionRent = 0;
+
+  if (txData) {
+    const accountKeys = txData.transaction.message.getAccountKeys().staticAccountKeys;
+    const preBalances = txData.meta?.preBalances || [];
+    const postBalances = txData.meta?.postBalances || [];
+
+    // All accounts whose rent should be tracked: position mint, PDA, ATA, + tick arrays
+    const positionTokenAccount = getAssociatedTokenAddressSync(
+      positionMintKeypair.publicKey,
+      client.getContext().wallet.publicKey,
+      undefined,
+      TOKEN_2022_PROGRAM_ID,
+    );
+    const rentAccounts: PublicKey[] = [
+      positionMintKeypair.publicKey,
+      positionPda.publicKey,
+      positionTokenAccount,
+      ...newTickArrayPubkeys,
+    ];
+
+    let totalRentLamports = 0;
+    for (const pubkey of rentAccounts) {
+      const idx = accountKeys.findIndex((key) => key.equals(pubkey));
+      if (idx !== -1 && preBalances[idx] === 0 && postBalances[idx] > 0) {
+        totalRentLamports += postBalances[idx];
+        logger.info(`Rent for ${pubkey.toString()}: ${postBalances[idx]} lamports`);
+      }
+    }
+    positionRent = totalRentLamports / 1e9;
+
+    // Use actual balance changes from the TX for token amounts when liquidity was added
+    if (shouldAddLiquidity) {
+      const tokenMintA = whirlpool.getTokenAInfo().address.toString();
+      const tokenMintB = whirlpool.getTokenBInfo().address.toString();
+
+      const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
+        tokenMintA,
+        tokenMintB,
+      ]);
+
+      // Balance changes are negative (tokens leaving wallet)
+      let actualBaseAdded = Math.abs(balanceChanges[0]);
+      let actualQuoteAdded = Math.abs(balanceChanges[1]);
+
+      // When SOL is one of the tokens, wallet balance change includes: liquidity + rent + fee
+      // Subtract rent and fee to get actual liquidity added
+      const SOL_NATIVE_MINT = 'So11111111111111111111111111111111111111112';
+      if (tokenMintA === SOL_NATIVE_MINT) {
+        actualBaseAdded = actualBaseAdded - positionRent - fee;
+        if (actualBaseAdded < 0) actualBaseAdded = 0;
+      } else if (tokenMintB === SOL_NATIVE_MINT) {
+        actualQuoteAdded = actualQuoteAdded - positionRent - fee;
+        if (actualQuoteAdded < 0) actualQuoteAdded = 0;
+      }
 
-  logger.info(
-    `Position rent: mint=${positionMintBalance}, data=${positionDataBalance}, ata=${positionAtaBalance}, total=${positionRent} SOL`,
-  );
+      baseTokenAmountAdded = actualBaseAdded;
+      quoteTokenAmountAdded = actualQuoteAdded;
+    }
+  }
+
+  logger.info(`Position rent: ${positionRent} SOL (${newTickArrayPubkeys.length} new tick arrays)`);
 
   if (shouldAddLiquidity) {
     logger.info(
diff --git a/test/connectors/orca/clmm-routes/openPosition.test.ts b/test/connectors/orca/clmm-routes/openPosition.test.ts
index 8794c2e3d1..82117e0827 100644
--- a/test/connectors/orca/clmm-routes/openPosition.test.ts
+++ b/test/connectors/orca/clmm-routes/openPosition.test.ts
@@ -105,8 +105,24 @@ describe('POST /open-position', () => {
         signature: 'test-signature',
         fee: 0.000005,
       }),
+      extractBalanceChangesAndFee: jest.fn().mockResolvedValue({
+        balanceChanges: [-1.0, -200.0],
+        fee: 0.000005,
+      }),
       connection: {
-        getBalance: jest.fn().mockResolvedValue(2039280), // ~0.00204 SOL rent per account
+        getTransaction: jest.fn().mockResolvedValue({
+          transaction: {
+            message: {
+              getAccountKeys: () => ({
+                staticAccountKeys: [],
+              }),
+            },
+          },
+          meta: {
+            preBalances: [],
+            postBalances: [],
+          },
+        }),
       },
     };
     (Solana.getInstance as jest.Mock).mockResolvedValue(mockSolana);

From b8e33c40e232a39a5a2e4b72a0b4d144003f0f46 Mon Sep 17 00:00:00 2001
From: Wojak <machinelearningguys@gmail.com>
Date: Fri, 27 Feb 2026 14:32:42 +0700
Subject: [PATCH 37/37] fix earned fee not returned correctly

---
 .../orca/clmm-routes/closePosition.ts         |  72 ++++-----
 .../orca/clmm-routes/openPosition.ts          |  37 ++---
 src/connectors/orca/orca.utils.ts             | 150 +++++++++++++++++-
 3 files changed, 199 insertions(+), 60 deletions(-)

diff --git a/src/connectors/orca/clmm-routes/closePosition.ts b/src/connectors/orca/clmm-routes/closePosition.ts
index c9ff3817f8..879c873f2a 100644
--- a/src/connectors/orca/clmm-routes/closePosition.ts
+++ b/src/connectors/orca/clmm-routes/closePosition.ts
@@ -1,5 +1,6 @@
 import { Percentage, TransactionBuilder } from '@orca-so/common-sdk';
 import {
+  ORCA_WHIRLPOOL_PROGRAM_ID,
   WhirlpoolIx,
   decreaseLiquidityQuoteByLiquidityWithParams,
   TokenExtensionUtil,
@@ -16,7 +17,7 @@ import { ClosePositionResponse, ClosePositionResponseType } from '../../../schem
 import { httpErrors } from '../../../services/error-handler';
 import { logger } from '../../../services/logger';
 import { Orca } from '../orca';
-import { getTickArrayPubkeys, handleWsolAta } from '../orca.utils';
+import { extractInnerTransferAmounts, getTickArrayPubkeys, handleWsolAta } from '../orca.utils';
 import { OrcaClmmClosePositionRequest } from '../schemas';
 
 export async function closePosition(
@@ -169,14 +170,14 @@ export async function closePosition(
       }),
     );
 
-    baseTokenAmountRemoved = Number(decreaseQuote.tokenEstA) / Math.pow(10, mintA.decimals);
-    quoteTokenAmountRemoved = Number(decreaseQuote.tokenEstB) / Math.pow(10, mintB.decimals);
+    // Note: baseTokenAmountRemoved/quoteTokenAmountRemoved are set from actual
+    // TX inner instruction transfers after execution, not from the estimate here.
   }
 
   // Step 3: Collect fees if there are fees owed or if we just removed liquidity
-  // Note: Fee amounts are derived from actual TX balance changes after execution,
-  // not from collectFeesQuote() which reads stale position data before
-  // updateFeesAndRewards executes on-chain.
+  // Note: Fee amounts are derived from inner instruction transfers after execution,
+  // which gives us exact amounts from the collectFees instruction separately
+  // from the decreaseLiquidity instruction.
   if (hasFees || hasLiquidity) {
     builder.addInstruction(
       WhirlpoolIx.collectFeesV2Ix(client.getContext().program, {
@@ -297,40 +298,39 @@ export async function closePosition(
     }
     positionRentRefunded = totalRentLamports / 1e9;
 
-    // Derive actual token amounts from TX balance changes
+    // Extract exact transfer amounts per Whirlpool instruction from inner instructions.
+    // The close TX has Whirlpool instructions in order:
+    //   updateFeesAndRewards (no transfers) → decreaseLiquidity (transfers) → collectFees (transfers) → closePosition (no transfers)
+    // extractInnerTransferAmounts returns only groups that have transfers, so:
+    //   transferGroups[0] = decreaseLiquidity amounts, transferGroups[1] = collectFees amounts
     const tokenMintA = whirlpool.getTokenAInfo().address.toString();
     const tokenMintB = whirlpool.getTokenBInfo().address.toString();
 
-    const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
-      tokenMintA,
-      tokenMintB,
-    ]);
-
-    // Balance changes are positive (tokens entering wallet)
-    let totalBaseReceived = Math.abs(balanceChanges[0]);
-    let totalQuoteReceived = Math.abs(balanceChanges[1]);
-
-    // When SOL is one of the tokens, wallet balance change includes:
-    // liquidity + fees + rent refund - tx fee
-    // Subtract rent refund and add back tx fee to isolate actual token amounts
-    const SOL_NATIVE_MINT = 'So11111111111111111111111111111111111111112';
-    if (tokenMintA === SOL_NATIVE_MINT) {
-      totalBaseReceived = totalBaseReceived - positionRentRefunded + fee;
-      if (totalBaseReceived < 0) totalBaseReceived = 0;
-    } else if (tokenMintB === SOL_NATIVE_MINT) {
-      totalQuoteReceived = totalQuoteReceived - positionRentRefunded + fee;
-      if (totalQuoteReceived < 0) totalQuoteReceived = 0;
-    }
-
-    // Separate fees from liquidity amounts:
-    // totalReceived = liquidityRemoved + feesCollected
-    // feesCollected = totalReceived - liquidityRemoved (from decreaseQuote estimate)
-    baseFeeAmountCollected = Math.max(0, totalBaseReceived - baseTokenAmountRemoved);
-    quoteFeeAmountCollected = Math.max(0, totalQuoteReceived - quoteTokenAmountRemoved);
+    const { transferGroups } = await extractInnerTransferAmounts(
+      solana.connection,
+      signature,
+      ORCA_WHIRLPOOL_PROGRAM_ID.toString(),
+      [tokenMintA, tokenMintB],
+    );
 
-    // Update removed amounts to actuals (totalReceived - fees)
-    baseTokenAmountRemoved = totalBaseReceived - baseFeeAmountCollected;
-    quoteTokenAmountRemoved = totalQuoteReceived - quoteFeeAmountCollected;
+    if (transferGroups.length >= 2) {
+      // First transfer group: decreaseLiquidity (liquidity removed)
+      baseTokenAmountRemoved = transferGroups[0][0];
+      quoteTokenAmountRemoved = transferGroups[0][1];
+      // Second transfer group: collectFees (fees collected)
+      baseFeeAmountCollected = transferGroups[1][0];
+      quoteFeeAmountCollected = transferGroups[1][1];
+    } else if (transferGroups.length === 1) {
+      // Only one group with transfers — could be just decreaseLiquidity or just collectFees
+      if (hasLiquidity) {
+        baseTokenAmountRemoved = transferGroups[0][0];
+        quoteTokenAmountRemoved = transferGroups[0][1];
+      } else {
+        baseFeeAmountCollected = transferGroups[0][0];
+        quoteFeeAmountCollected = transferGroups[0][1];
+      }
+    }
+    // If transferGroups is empty, position had no liquidity and no fees — values stay at 0
   }
 
   logger.info(
diff --git a/src/connectors/orca/clmm-routes/openPosition.ts b/src/connectors/orca/clmm-routes/openPosition.ts
index 005650ebe6..b4678918af 100644
--- a/src/connectors/orca/clmm-routes/openPosition.ts
+++ b/src/connectors/orca/clmm-routes/openPosition.ts
@@ -23,7 +23,7 @@ import { OpenPositionResponse, OpenPositionResponseType } from '../../../schemas
 import { httpErrors } from '../../../services/error-handler';
 import { logger } from '../../../services/logger';
 import { Orca } from '../orca';
-import { getTickArrayPubkeys, handleWsolAta } from '../orca.utils';
+import { extractInnerTransferAmounts, getTickArrayPubkeys, handleWsolAta } from '../orca.utils';
 import { OrcaClmmOpenPositionRequest } from '../schemas';
 
 /**
@@ -504,33 +504,24 @@ export async function openPosition(
     }
     positionRent = totalRentLamports / 1e9;
 
-    // Use actual balance changes from the TX for token amounts when liquidity was added
+    // Extract actual token amounts from the increaseLiquidity instruction's inner transfers.
+    // This avoids the SOL adjustment complexity (rent, fee) needed with aggregate balance changes.
     if (shouldAddLiquidity) {
       const tokenMintA = whirlpool.getTokenAInfo().address.toString();
       const tokenMintB = whirlpool.getTokenBInfo().address.toString();
 
-      const { balanceChanges } = await solana.extractBalanceChangesAndFee(signature, wallet.publicKey.toBase58(), [
-        tokenMintA,
-        tokenMintB,
-      ]);
-
-      // Balance changes are negative (tokens leaving wallet)
-      let actualBaseAdded = Math.abs(balanceChanges[0]);
-      let actualQuoteAdded = Math.abs(balanceChanges[1]);
-
-      // When SOL is one of the tokens, wallet balance change includes: liquidity + rent + fee
-      // Subtract rent and fee to get actual liquidity added
-      const SOL_NATIVE_MINT = 'So11111111111111111111111111111111111111112';
-      if (tokenMintA === SOL_NATIVE_MINT) {
-        actualBaseAdded = actualBaseAdded - positionRent - fee;
-        if (actualBaseAdded < 0) actualBaseAdded = 0;
-      } else if (tokenMintB === SOL_NATIVE_MINT) {
-        actualQuoteAdded = actualQuoteAdded - positionRent - fee;
-        if (actualQuoteAdded < 0) actualQuoteAdded = 0;
+      const { transferGroups } = await extractInnerTransferAmounts(
+        solana.connection,
+        signature,
+        ORCA_WHIRLPOOL_PROGRAM_ID.toString(),
+        [tokenMintA, tokenMintB],
+      );
+
+      // For open position, the only Whirlpool instruction with transfers is increaseLiquidity
+      if (transferGroups.length >= 1) {
+        baseTokenAmountAdded = transferGroups[0][0];
+        quoteTokenAmountAdded = transferGroups[0][1];
       }
-
-      baseTokenAmountAdded = actualBaseAdded;
-      quoteTokenAmountAdded = actualQuoteAdded;
     }
   }
 
diff --git a/src/connectors/orca/orca.utils.ts b/src/connectors/orca/orca.utils.ts
index 546f19347c..33578590f1 100644
--- a/src/connectors/orca/orca.utils.ts
+++ b/src/connectors/orca/orca.utils.ts
@@ -32,7 +32,7 @@ import type {
 } from '@solana/kit';
 import { address } from '@solana/kit';
 import { NATIVE_MINT, createAssociatedTokenAccountIdempotentInstruction } from '@solana/spl-token';
-import { PublicKey } from '@solana/web3.js';
+import { Connection, PublicKey } from '@solana/web3.js';
 import { fetchAllMint, Mint } from '@solana-program/token-2022';
 import BN from 'bn.js';
 
@@ -149,6 +149,154 @@ export async function getPositionDetails(client: WhirlpoolClient, positionAddres
   };
 }
 
+/**
+ * Extracts SPL token transfer amounts from the inner instructions of a confirmed
+ * Solana transaction, grouped by the top-level instruction they belong to.
+ *
+ * This uses `getParsedTransaction` to get pre-decoded SPL token transfer
+ * instructions, then filters for inner instructions belonging to the specified
+ * program (e.g. ORCA_WHIRLPOOL_PROGRAM_ID). Only groups that contain actual
+ * transfers are returned, preserving execution order.
+ *
+ * For a close-position TX the Whirlpool instructions are:
+ *   updateFeesAndRewards (no transfers) → decreaseLiquidity (transfers) → collectFees (transfers) → closePosition (no transfers)
+ * So transferGroups[0] = decreaseLiquidity amounts, transferGroups[1] = collectFees amounts.
+ *
+ * For an open-position TX with liquidity, only increaseLiquidity has transfers,
+ * so transferGroups[0] = amounts deposited.
+ *
+ * @param connection - Solana web3 Connection object
+ * @param signature - Transaction signature
+ * @param programId - Program ID string to filter top-level instructions by
+ * @param tokenMints - Array of token mint addresses; returned amounts are ordered to match this array
+ * @param maxRetries - Number of retry attempts if the transaction isn't available yet (default 5)
+ * @param retryDelayMs - Delay between retries in milliseconds (default 2000)
+ * @returns Object with transferGroups: number[][] — each group is an array of amounts per token mint in human-readable units
+ */
+export async function extractInnerTransferAmounts(
+  connection: Connection,
+  signature: string,
+  programId: string,
+  tokenMints: string[],
+  maxRetries: number = 5,
+  retryDelayMs: number = 2000,
+): Promise<{ transferGroups: number[][] }> {
+  // Retry loop — the parsed transaction may not be immediately available after confirmation
+  let parsedTx: any = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    parsedTx = await connection.getParsedTransaction(signature, {
+      commitment: 'confirmed',
+      maxSupportedTransactionVersion: 0,
+    });
+    if (parsedTx) break;
+    logger.info(`Waiting for parsed transaction (attempt ${attempt + 1}/${maxRetries})...`);
+    await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+  }
+
+  if (!parsedTx) {
+    logger.warn(`Could not fetch parsed transaction for ${signature} after ${maxRetries} attempts`);
+    return { transferGroups: [] };
+  }
+
+  const innerInstructions = parsedTx.meta?.innerInstructions || [];
+  const tokenBalances = [...(parsedTx.meta?.preTokenBalances || []), ...(parsedTx.meta?.postTokenBalances || [])];
+
+  // Build a map from account address → mint address using token balances
+  const accountKeys = parsedTx.transaction.message.accountKeys;
+  const accountToMint: Record<string, string> = {};
+  for (const tb of tokenBalances) {
+    const accountAddress = accountKeys[tb.accountIndex]?.pubkey?.toString();
+    if (accountAddress && tb.mint) {
+      accountToMint[accountAddress] = tb.mint;
+    }
+  }
+
+  // Build a map from account address → decimals
+  const accountToDecimals: Record<string, number> = {};
+  for (const tb of tokenBalances) {
+    const accountAddress = accountKeys[tb.accountIndex]?.pubkey?.toString();
+    if (accountAddress && tb.uiTokenAmount?.decimals !== undefined) {
+      accountToDecimals[accountAddress] = tb.uiTokenAmount.decimals;
+    }
+  }
+
+  // Also build a mint → decimals map for transferChecked
+  const mintToDecimals: Record<string, number> = {};
+  for (const tb of tokenBalances) {
+    if (tb.mint && tb.uiTokenAmount?.decimals !== undefined) {
+      mintToDecimals[tb.mint] = tb.uiTokenAmount.decimals;
+    }
+  }
+
+  // Find top-level instruction indices that match the target programId
+  const topLevelInstructions = parsedTx.transaction.message.instructions;
+  const targetIndices: number[] = [];
+  for (let i = 0; i < topLevelInstructions.length; i++) {
+    const ix = topLevelInstructions[i];
+    const ixProgramId = ix.programId?.toString();
+    if (ixProgramId === programId) {
+      targetIndices.push(i);
+    }
+  }
+
+  const transferGroups: number[][] = [];
+
+  for (const targetIdx of targetIndices) {
+    // Find the inner instructions block for this top-level instruction index
+    const innerBlock = innerInstructions.find((block: any) => block.index === targetIdx);
+    if (!innerBlock || !innerBlock.instructions) continue;
+
+    // Accumulate transfer amounts per mint for this instruction group
+    const mintAmounts: Record<string, number> = {};
+    for (const mint of tokenMints) {
+      mintAmounts[mint] = 0;
+    }
+
+    let hasTransfers = false;
+
+    for (const innerIx of innerBlock.instructions) {
+      const parsed = innerIx.parsed;
+      if (!parsed) continue;
+
+      let mint: string | undefined;
+      let rawAmount: string | undefined;
+      let decimals: number | undefined;
+
+      if (parsed.type === 'transferChecked' && parsed.info) {
+        // transferChecked includes mint and tokenAmount directly
+        mint = parsed.info.mint;
+        rawAmount = parsed.info.tokenAmount?.amount;
+        decimals = parsed.info.tokenAmount?.decimals;
+      } else if (parsed.type === 'transfer' && parsed.info) {
+        // Plain transfer doesn't include mint — resolve from source or destination account
+        rawAmount = parsed.info.amount;
+        const source = parsed.info.source;
+        const destination = parsed.info.destination;
+        mint = accountToMint[source] || accountToMint[destination];
+        decimals = accountToDecimals[source] || accountToDecimals[destination];
+      }
+
+      if (!mint || !rawAmount) continue;
+      if (!tokenMints.includes(mint)) continue;
+      if (decimals === undefined) {
+        decimals = mintToDecimals[mint] || 0;
+      }
+
+      const humanAmount = Number(rawAmount) / Math.pow(10, decimals);
+      mintAmounts[mint] += humanAmount;
+      hasTransfers = true;
+    }
+
+    if (hasTransfers) {
+      // Return amounts in the same order as the tokenMints array
+      const group = tokenMints.map((mint) => mintAmounts[mint] || 0);
+      transferGroups.push(group);
+    }
+  }
+
+  return { transferGroups };
+}
+
 /**
  * Retrieves the current transfer fee configuration for a given token mint based on the current epoch.
  *