Add all 4 transaction IDs for EVM Chain Swaps (#122)

* Add all 4 transaction IDs for EVM Chain Swaps (#121)

Integrate Ponder-Claim database to fetch claim TX hashes:
- Add Ponder PostgreSQL connection pool and configuration
- Extend SwapDto with preimageHash, preimage, version, chain IDs
- Add sourceClaimTxId and destClaimTxId fields from Ponder-Claim DB
- Create chain ID mapping utility for symbol-to-chainId resolution
- Query lockups table by preimageHash to match claim TXs to swaps

* Fix Ponder SQL query to use snake_case column names

Ponder generates PostgreSQL tables with snake_case column names:
- preimageHash → preimage_hash
- chainId → chain_id
- claimTxHash → claim_tx_hash

Also remove unused duplicate method and consolidate into single
fetchClaimTxsFromPonder() method.

* Fix preimageHash format mismatch between Boltz and Ponder

Boltz stores preimageHash WITHOUT 0x prefix (64 hex chars)
Ponder stores preimageHash WITH 0x prefix (from Ethereum events)

Normalize all hashes to 0x prefix before querying Ponder and
when looking up in the claimTxMap.

* Fix destChainId example in DTO (4114 is mainnet, not 5115)

Author: TaprootFreak

.env.example

@@ -18,3 +18,17 @@ DEBUG_API_URL=
 # Azure Application Insights (for log-debug.sh)
 AZURE_APP_INSIGHTS_APP_ID=
 AZURE_APP_INSIGHTS_API_KEY=
+
+# Boltz PostgreSQL (for swap statistics)
+BOLTZ_PG_HOST=
+BOLTZ_PG_PORT=5432
+BOLTZ_PG_DATABASE=
+BOLTZ_PG_USER=
+BOLTZ_PG_PASSWORD=
+
+# Ponder-Claim PostgreSQL (for claim transaction hashes)
+PONDER_PG_HOST=
+PONDER_PG_PORT=5432
+PONDER_PG_DATABASE=
+PONDER_PG_USER=
+PONDER_PG_PASSWORD=

src/config/config.ts

@@ -193,6 +193,14 @@ export class Configuration {
     password: process.env.BOLTZ_PG_PASSWORD ?? '',
   };
 
+  ponderPostgres = {
+    host: process.env.PONDER_PG_HOST ?? '',
+    port: parseInt(process.env.PONDER_PG_PORT ?? '5432'),
+    database: process.env.PONDER_PG_DATABASE ?? '',
+    user: process.env.PONDER_PG_USER ?? '',
+    password: process.env.PONDER_PG_PASSWORD ?? '',
+  };
+
   request = {
     knownIps: process.env.REQUEST_KNOWN_IPS?.split(',') ?? [],
     limitCheck: process.env.REQUEST_LIMIT_CHECK === 'true',

src/subdomains/support/constants/chain-ids.ts

@@ -0,0 +1,65 @@
+/**
+ * Chain ID constants for EVM networks
+ */
+export const CHAIN_IDS = {
+  // Mainnets
+  ETHEREUM: 1,
+  POLYGON: 137,
+  CITREA: 4114,
+
+  // Testnets
+  CITREA_TESTNET: 5115,
+  POLYGON_AMOY: 80002,
+} as const;
+
+/**
+ * Maps currency symbols to their respective chain IDs.
+ * Used to determine which chain a swap leg is on.
+ */
+export const SYMBOL_TO_CHAIN_ID: Record<string, number> = {
+  // Polygon
+  USDT_POLYGON: CHAIN_IDS.POLYGON,
+  USDC_POLYGON: CHAIN_IDS.POLYGON,
+
+  // Ethereum
+  USDT_ETH: CHAIN_IDS.ETHEREUM,
+  USDC_ETH: CHAIN_IDS.ETHEREUM,
+  ETH: CHAIN_IDS.ETHEREUM,
+
+  // Citrea Mainnet
+  JUSD: CHAIN_IDS.CITREA,
+  cBTC: CHAIN_IDS.CITREA,
+
+  // Citrea Testnet (fallback for testnet symbols)
+  JUSD_CITREA: CHAIN_IDS.CITREA,
+};
+
+/**
+ * Get chain ID for a currency symbol.
+ * Returns undefined if symbol is not an EVM currency (e.g., Lightning).
+ */
+export function getChainIdForSymbol(symbol: string): number | undefined {
+  // Direct lookup
+  if (SYMBOL_TO_CHAIN_ID[symbol]) {
+    return SYMBOL_TO_CHAIN_ID[symbol];
+  }
+
+  // Try uppercase
+  const upperSymbol = symbol.toUpperCase();
+  if (SYMBOL_TO_CHAIN_ID[upperSymbol]) {
+    return SYMBOL_TO_CHAIN_ID[upperSymbol];
+  }
+
+  // Check for known prefixes/patterns
+  if (symbol.includes('POLYGON') || symbol.includes('_POLYGON')) {
+    return CHAIN_IDS.POLYGON;
+  }
+  if (symbol.includes('ETH') && !symbol.includes('_')) {
+    return CHAIN_IDS.ETHEREUM;
+  }
+  if (symbol.includes('CITREA') || symbol === 'JUSD' || symbol === 'cBTC') {
+    return CHAIN_IDS.CITREA;
+  }
+
+  return undefined;
+}

src/subdomains/support/dto/swap-stats.dto.ts

@@ -69,9 +69,23 @@ export class SwapDto {
   @ApiProperty()
   updatedAt: string;
 
+  // Crypto details
+  @ApiPropertyOptional({ description: 'Preimage hash (links swap across chains)' })
+  preimageHash?: string;
+
+  @ApiPropertyOptional({ description: 'Preimage (revealed after claim)' })
+  preimage?: string;
+
+  @ApiPropertyOptional({ description: 'Swap version' })
+  version?: number;
+
+  // Source chain details
   @ApiProperty()
   sourceSymbol: string;
 
+  @ApiPropertyOptional({ description: 'Source chain ID (e.g., 137 for Polygon)' })
+  sourceChainId?: number;
+
   @ApiPropertyOptional()
   sourceAddress?: string;
 
@@ -81,12 +95,19 @@ export class SwapDto {
   @ApiPropertyOptional()
   sourceAmount?: string;
 
-  @ApiPropertyOptional()
+  @ApiPropertyOptional({ description: 'User lockup TX on source chain' })
   sourceTxId?: string;
 
+  @ApiPropertyOptional({ description: 'Boltz claim TX on source chain (from ponder-claim)' })
+  sourceClaimTxId?: string;
+
+  // Destination chain details
   @ApiProperty()
   destSymbol: string;
 
+  @ApiPropertyOptional({ description: 'Destination chain ID (e.g., 4114 for Citrea)' })
+  destChainId?: number;
+
   @ApiPropertyOptional()
   destAddress?: string;
 
@@ -96,8 +117,11 @@ export class SwapDto {
   @ApiPropertyOptional()
   destAmount?: string;
 
-  @ApiPropertyOptional()
+  @ApiPropertyOptional({ description: 'Boltz lockup TX on destination chain' })
   destTxId?: string;
+
+  @ApiPropertyOptional({ description: 'User claim TX on destination chain (from ponder-claim)' })
+  destClaimTxId?: string;
 }
 
 export class SwapStatsResponseDto {

src/subdomains/support/services/support.service.ts

@@ -10,12 +10,20 @@ import { DebugLogQueryTemplates, MssqlDebugConfig } from '../dto/debug.config';
 import { LogQueryDto, LogQueryResult } from '../dto/log-query.dto';
 import { SqlQueryValidator } from './sql-query-validator';
 import { SwapDto, SwapStatsQueryDto, SwapStatsResponseDto, SwapStatusFilter, SwapType } from '../dto/swap-stats.dto';
+import { getChainIdForSymbol } from '../constants/chain-ids';
+
+interface PonderLockup {
+  preimage_hash: string;
+  chain_id: number;
+  claim_tx_hash: string | null;
+}
 
 @Injectable()
 export class SupportService implements OnModuleDestroy {
   private readonly logger = new LightningLogger(SupportService);
   private readonly sqlValidator = new SqlQueryValidator();
   private boltzPool: Pool | null = null;
+  private ponderPool: Pool | null = null;
 
   constructor(
     private readonly dataSource: DataSource,
@@ -26,6 +34,9 @@ export class SupportService implements OnModuleDestroy {
     if (this.boltzPool) {
       await this.boltzPool.end();
     }
+    if (this.ponderPool) {
+      await this.ponderPool.end();
+    }
   }
 
   private getBoltzPool(): Pool {
@@ -48,6 +59,27 @@ export class SupportService implements OnModuleDestroy {
     return this.boltzPool;
   }
 
+  private getPonderPool(): Pool | null {
+    if (!this.ponderPool) {
+      const pgConfig = Config.ponderPostgres;
+      if (!pgConfig.host || !pgConfig.database) {
+        // Ponder is optional - return null if not configured
+        return null;
+      }
+      this.ponderPool = new Pool({
+        host: pgConfig.host,
+        port: pgConfig.port,
+        database: pgConfig.database,
+        user: pgConfig.user,
+        password: pgConfig.password,
+        max: 5,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 10000,
+      });
+    }
+    return this.ponderPool;
+  }
+
   async getRawData(query: DbQueryDto): Promise<any> {
     const request = this.dataSource
       .createQueryBuilder()
@@ -199,6 +231,48 @@ export class SupportService implements OnModuleDestroy {
     return str.charAt(0).toLowerCase() + str.slice(1).split('_').join('.');
   }
 
+  /**
+   * Fetches claim TX hashes with chain IDs from Ponder-Claim database.
+   * Returns a map of preimageHash -> array of { chainId, claimTxHash }
+   *
+   * Note: Ponder generates PostgreSQL tables with snake_case column names.
+   */
+  private async fetchClaimTxsFromPonder(
+    preimageHashes: string[],
+  ): Promise<Map<string, Array<{ chainId: number; claimTxHash: string }>>> {
+    const result = new Map<string, Array<{ chainId: number; claimTxHash: string }>>();
+
+    if (preimageHashes.length === 0) {
+      return result;
+    }
+
+    const ponderPool = this.getPonderPool();
+    if (!ponderPool) {
+      return result;
+    }
+
+    try {
+      const { rows } = await ponderPool.query<PonderLockup>(
+        `SELECT preimage_hash, chain_id, claim_tx_hash
+         FROM lockups
+         WHERE preimage_hash = ANY($1) AND claim_tx_hash IS NOT NULL`,
+        [preimageHashes],
+      );
+
+      for (const row of rows) {
+        if (!row.claim_tx_hash) continue;
+
+        const existing = result.get(row.preimage_hash) || [];
+        existing.push({ chainId: row.chain_id, claimTxHash: row.claim_tx_hash });
+        result.set(row.preimage_hash, existing);
+      }
+    } catch (e) {
+      this.logger.warn(`Failed to fetch claim TXs from Ponder: ${e.message}`);
+    }
+
+    return result;
+  }
+
   // *** PUBLIC SWAP STATS *** //
 
   async getSwapStats(query: SwapStatsQueryDto): Promise<SwapStatsResponseDto> {
@@ -256,9 +330,10 @@ export class SupportService implements OnModuleDestroy {
   }
 
   private async fetchChainSwaps(pool: Pool, query: SwapStatsQueryDto): Promise<SwapDto[]> {
-    // Fetch chain swaps with their data
+    // Fetch chain swaps with their data (including preimageHash and preimage for claim TX lookup)
     const chainSwapsResult = await pool.query(`
-      SELECT cs.*,
+      SELECT cs.id, cs.pair, cs."orderSide", cs.status, cs."failureReason", cs.fee,
+             cs.referral, cs."createdAt", cs."updatedAt", cs."preimageHash", cs.preimage, cs.version,
              sd_base.symbol as base_symbol, sd_base."lockupAddress" as base_lockup,
              sd_base."claimAddress" as base_claim, sd_base."expectedAmount" as base_expected,
              sd_base.amount as base_amount, sd_base."transactionId" as base_tx,
@@ -274,8 +349,18 @@ export class SupportService implements OnModuleDestroy {
       LIMIT 1000
     `);
 
+    // Extract preimageHashes for claim TX lookup
+    // Boltz stores without 0x prefix, Ponder stores with 0x prefix
+    const preimageHashes = chainSwapsResult.rows
+      .map((row) => row.preimageHash as string)
+      .filter((hash): hash is string => !!hash)
+      .map((hash) => (hash.startsWith('0x') ? hash : `0x${hash}`));
+
+    // Fetch claim TXs from Ponder-Claim DB
+    const claimTxMap = await this.fetchClaimTxsFromPonder(preimageHashes);
+
     return chainSwapsResult.rows
-      .map((row) => this.mapChainSwap(row))
+      .map((row) => this.mapChainSwap(row, claimTxMap))
       .filter((swap) => this.matchesFilter(swap, query));
   }
 
@@ -307,12 +392,42 @@ export class SupportService implements OnModuleDestroy {
       .filter((swap) => this.matchesFilter(swap, query));
   }
 
-  private mapChainSwap(row: Record<string, unknown>): SwapDto {
+  private mapChainSwap(
+    row: Record<string, unknown>,
+    claimTxMap?: Map<string, Array<{ chainId: number; claimTxHash: string }>>,
+  ): SwapDto {
     const pair = row.pair as string;
     const [base, quote] = pair.split('/');
     const orderSide = row.orderSide as number;
     const direction = orderSide === 1 ? `${base} -> ${quote}` : `${quote} -> ${base}`;
 
+    // Determine source and destination symbols
+    const sourceSymbol = orderSide === 1 ? base : quote;
+    const destSymbol = orderSide === 1 ? quote : base;
+
+    // Get chain IDs for source and destination
+    const sourceChainId = getChainIdForSymbol(sourceSymbol);
+    const destChainId = getChainIdForSymbol(destSymbol);
+
+    // Look up claim TXs from Ponder data
+    let sourceClaimTxId: string | undefined;
+    let destClaimTxId: string | undefined;
+
+    const preimageHash = row.preimageHash as string;
+    if (preimageHash && claimTxMap) {
+      // Normalize to 0x prefix for lookup (Ponder stores with 0x, Boltz without)
+      const normalizedHash = preimageHash.startsWith('0x') ? preimageHash : `0x${preimageHash}`;
+      const claimTxs = claimTxMap.get(normalizedHash) || [];
+
+      for (const claimTx of claimTxs) {
+        if (sourceChainId && claimTx.chainId === sourceChainId) {
+          sourceClaimTxId = claimTx.claimTxHash;
+        } else if (destChainId && claimTx.chainId === destChainId) {
+          destClaimTxId = claimTx.claimTxHash;
+        }
+      }
+    }
+
     return {
       type: 'Chain Swap',
       id: row.id as string,
@@ -324,16 +439,26 @@ export class SupportService implements OnModuleDestroy {
       referral: (row.referral as string) || undefined,
       createdAt: this.toIsoString(row.createdAt),
       updatedAt: this.toIsoString(row.updatedAt),
-      sourceSymbol: orderSide === 1 ? base : quote,
+      // Crypto details
+      preimageHash: preimageHash || undefined,
+      preimage: (row.preimage as string) || undefined,
+      version: row.version as number | undefined,
+      // Source chain
+      sourceSymbol,
+      sourceChainId,
       sourceAddress: (orderSide === 1 ? row.base_lockup : row.quote_lockup) as string,
       sourceExpectedAmount: (orderSide === 1 ? row.base_expected : row.quote_expected) as string,
       sourceAmount: (orderSide === 1 ? row.base_amount : row.quote_amount) as string,
       sourceTxId: (orderSide === 1 ? row.base_tx : row.quote_tx) as string,
-      destSymbol: orderSide === 1 ? quote : base,
-      destAddress: ((orderSide === 1 ? row.quote_claim || row.quote_lockup : row.base_claim || row.base_lockup) as string),
+      sourceClaimTxId,
+      // Destination chain
+      destSymbol,
+      destChainId,
+      destAddress: (orderSide === 1 ? row.quote_claim || row.quote_lockup : row.base_claim || row.base_lockup) as string,
       destExpectedAmount: (orderSide === 1 ? row.quote_expected : row.base_expected) as string,
       destAmount: (orderSide === 1 ? row.quote_amount : row.base_amount) as string,
       destTxId: (orderSide === 1 ? row.quote_tx : row.base_tx) as string,
+      destClaimTxId,
     };
   }