@pioneer-platform/pioneer-history 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @pioneer-platform/pioneer-history
 
+## 0.4.0
+
+### Minor Changes
+
+- chore: feat(pioneer-sdk): Add ERC-20/BEP-20 token table to portfolio dashboard
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/cosmos-network@8.27.0
+  - @pioneer-platform/eth-network@8.31.0
+  - @pioneer-platform/utxo-network@8.28.0
+
+## 0.3.0
+
+### Minor Changes
+
+- feat(pioneer-sdk): Add ERC-20/BEP-20 token table to portfolio dashboard
+
 ## 0.2.0
 
 ### Minor Changes

package/lib/index.d.ts

@@ -42,6 +42,8 @@ export declare class History {
     private blockchains;
     private nodes;
     private networks;
+    private swapDetector;
+    private pendingSwapsService;
     constructor(config: any);
     init(): Promise<boolean>;
     classifyCaip(caip: string): Promise<string>;

package/lib/index.js

@@ -71,6 +71,8 @@ exports.History = exports.SUPPORTED_CAIPS = exports.OTHER_SUPPORT = exports.TEND
 var TAG = " | pioneer-history | ";
 var log = require('@pioneer-platform/loggerdog')();
 var caipToNetworkId = require('@pioneer-platform/pioneer-caip').caipToNetworkId;
+// Swap detection
+var swap_detector_1 = require("./services/swap-detector");
 // CAIP support constants (reuse from pioneer-balance)
 exports.UTXO_SUPPORT = [
     'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC
@@ -99,9 +101,19 @@ exports.SUPPORTED_CAIPS = {
 __exportStar(require("./schemas/history-response"), exports);
 var History = /** @class */ (function () {
     function History(config) {
+        this.swapDetector = null;
         log.debug(TAG, "🏗️ History constructor called");
         this.blockchains = config.wss || [];
         this.nodes = config.nodes || [];
+        this.pendingSwapsService = config.pendingSwapsService || null;
+        // Initialize swap detector with pendingSwapsService (enables Layer 1 DB lookup)
+        this.swapDetector = new swap_detector_1.SwapDetector(this.pendingSwapsService, log);
+        if (this.pendingSwapsService) {
+            log.info(TAG, "✅ SwapDetector initialized with DB service (Layer 1 enabled)");
+        }
+        else {
+            log.warn(TAG, "⚠️  SwapDetector initialized without DB service (Layer 1 disabled - only memo/contract detection active)");
+        }
         // CRITICAL: Use globally initialized networks if available (server environment)
         var globalNetworks = global.pioneerNetworks;
         if (globalNetworks) {
@@ -373,9 +385,9 @@ var History = /** @class */ (function () {
     };
     History.prototype.getHistory = function (query, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var tag, queries, results, _i, queries_1, q, networkId, type, asset, pubkey, _a, networkIdToSymbol, coin, rawTxs, rawTxs, rawTxs, rawTxs, error_1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var tag, queries, results, _i, queries_1, q, networkId, type, asset, pubkey, _a, networkIdToSymbol, coin, rawTxs, rawTxs, rawTxs, rawTxs, error_1, allTransactions, _b, results_1, result, swapMetadata, _c, results_2, result, _d, _e, tx, metadata, error_2;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         tag = TAG + " | getHistory | ";
                         log.debug(tag, "🔍 HISTORY QUERY START");
@@ -383,7 +395,7 @@ var History = /** @class */ (function () {
                         log.debug(tag, "Processing ".concat(queries.length, " ").concat(queries.length === 1 ? 'query' : 'queries'));
                         results = [];
                         _i = 0, queries_1 = queries;
-                        _b.label = 1;
+                        _f.label = 1;
                     case 1:
                         if (!(_i < queries_1.length)) return [3 /*break*/, 30];
                         q = queries_1[_i];
@@ -396,13 +408,13 @@ var History = /** @class */ (function () {
                         networkId = caipToNetworkId(q.caip);
                         return [4 /*yield*/, this.classifyCaip(q.caip)];
                     case 2:
-                        type = _b.sent();
+                        type = _f.sent();
                         log.debug(tag, "🎯 Classified CAIP type:", type);
                         asset = { caip: q.caip };
                         pubkey = { pubkey: q.pubkey };
-                        _b.label = 3;
+                        _f.label = 3;
                     case 3:
-                        _b.trys.push([3, 28, , 29]);
+                        _f.trys.push([3, 28, , 29]);
                         _a = type;
                         switch (_a) {
                             case 'UTXO': return [3 /*break*/, 4];
@@ -428,7 +440,7 @@ var History = /** @class */ (function () {
                         log.debug(tag, 'Fetching UTXO transactions for', coin);
                         return [4 /*yield*/, this.networks.networks.utxo.txsByXpub(coin, pubkey.pubkey)];
                     case 5:
-                        rawTxs = _b.sent();
+                        rawTxs = _f.sent();
                         log.debug(tag, "Received ".concat((rawTxs === null || rawTxs === void 0 ? void 0 : rawTxs.length) || 0, " UTXO transactions"));
                         asset.transactions = this.normalizeUtxoTransactions(rawTxs || [], pubkey.pubkey, q.caip);
                         results.push(asset);
@@ -438,14 +450,14 @@ var History = /** @class */ (function () {
                         if (!this.networks.networks.ethereum.getTransactionsByNetwork) return [3 /*break*/, 8];
                         return [4 /*yield*/, this.networks.networks.ethereum.getTransactionsByNetwork(networkId, pubkey.pubkey, options)];
                     case 7:
-                        rawTxs = _b.sent();
+                        rawTxs = _f.sent();
                         log.debug(tag, "Received ".concat((rawTxs === null || rawTxs === void 0 ? void 0 : rawTxs.length) || 0, " EVM transactions"));
                         asset.transactions = this.normalizeEvmTransactions(rawTxs || [], pubkey.pubkey, q.caip);
                         return [3 /*break*/, 9];
                     case 8:
                         log.warn(tag, 'EVM transaction history not available - method not found');
                         asset.transactions = [];
-                        _b.label = 9;
+                        _f.label = 9;
                     case 9:
                         results.push(asset);
                         return [3 /*break*/, 27];
@@ -456,32 +468,32 @@ var History = /** @class */ (function () {
                         if (!this.networks.networks.mayachain.getTransactions) return [3 /*break*/, 12];
                         return [4 /*yield*/, this.networks.networks.mayachain.getTransactions(pubkey.pubkey)];
                     case 11:
-                        rawTxs = _b.sent();
-                        _b.label = 12;
+                        rawTxs = _f.sent();
+                        _f.label = 12;
                     case 12: return [3 /*break*/, 21];
                     case 13:
                         if (!q.caip.startsWith('cosmos:osmosis-1')) return [3 /*break*/, 16];
                         if (!this.networks.networks.osmosis.getTransactions) return [3 /*break*/, 15];
                         return [4 /*yield*/, this.networks.networks.osmosis.getTransactions(pubkey.pubkey)];
                     case 14:
-                        rawTxs = _b.sent();
-                        _b.label = 15;
+                        rawTxs = _f.sent();
+                        _f.label = 15;
                     case 15: return [3 /*break*/, 21];
                     case 16:
                         if (!q.caip.startsWith('cosmos:thorchain-mainnet-v1')) return [3 /*break*/, 19];
                         if (!this.networks.networks.thorchain.getTransactions) return [3 /*break*/, 18];
                         return [4 /*yield*/, this.networks.networks.thorchain.getTransactions(pubkey.pubkey)];
                     case 17:
-                        rawTxs = _b.sent();
-                        _b.label = 18;
+                        rawTxs = _f.sent();
+                        _f.label = 18;
                     case 18: return [3 /*break*/, 21];
                     case 19:
                         if (!q.caip.startsWith('cosmos:cosmoshub-4')) return [3 /*break*/, 21];
                         if (!this.networks.networks.cosmos.getTransactions) return [3 /*break*/, 21];
                         return [4 /*yield*/, this.networks.networks.cosmos.getTransactions(pubkey.pubkey)];
                     case 20:
-                        rawTxs = _b.sent();
-                        _b.label = 21;
+                        rawTxs = _f.sent();
+                        _f.label = 21;
                     case 21:
                         log.debug(tag, "Received ".concat((rawTxs === null || rawTxs === void 0 ? void 0 : rawTxs.length) || 0, " Tendermint transactions"));
                         asset.transactions = this.normalizeTendermintTransactions(rawTxs || [], pubkey.pubkey, q.caip);
@@ -493,21 +505,21 @@ var History = /** @class */ (function () {
                         if (!this.networks.networks.ripple.getTransactions) return [3 /*break*/, 24];
                         return [4 /*yield*/, this.networks.networks.ripple.getTransactions(pubkey.pubkey)];
                     case 23:
-                        rawTxs = _b.sent();
+                        rawTxs = _f.sent();
                         log.debug(tag, "Received ".concat((rawTxs === null || rawTxs === void 0 ? void 0 : rawTxs.length) || 0, " Ripple transactions"));
                         asset.transactions = this.normalizeRippleTransactions(rawTxs || [], pubkey.pubkey, q.caip);
                         return [3 /*break*/, 25];
                     case 24:
                         log.warn(tag, 'Ripple transaction history not available');
                         asset.transactions = [];
-                        _b.label = 25;
+                        _f.label = 25;
                     case 25:
                         results.push(asset);
                         return [3 /*break*/, 27];
                     case 26: throw new Error("FAIL FAST: Unsupported chain type: ".concat(type));
                     case 27: return [3 /*break*/, 29];
                     case 28:
-                        error_1 = _b.sent();
+                        error_1 = _f.sent();
                         log.error(tag, "Error fetching history for ".concat(q.caip, ":"), error_1);
                         // Add empty result so batch processing continues
                         asset.transactions = [];
@@ -518,6 +530,43 @@ var History = /** @class */ (function () {
                         _i++;
                         return [3 /*break*/, 1];
                     case 30:
+                        if (!(this.swapDetector && results.length > 0)) return [3 /*break*/, 35];
+                        _f.label = 31;
+                    case 31:
+                        _f.trys.push([31, 34, , 35]);
+                        allTransactions = [];
+                        for (_b = 0, results_1 = results; _b < results_1.length; _b++) {
+                            result = results_1[_b];
+                            if (result.transactions && Array.isArray(result.transactions)) {
+                                allTransactions.push.apply(allTransactions, result.transactions);
+                            }
+                        }
+                        if (!(allTransactions.length > 0)) return [3 /*break*/, 33];
+                        log.debug(tag, "Running swap detection on ".concat(allTransactions.length, " transactions"));
+                        return [4 /*yield*/, this.swapDetector.detectSwaps(allTransactions)];
+                    case 32:
+                        swapMetadata = _f.sent();
+                        // Enrich each transaction with swap metadata
+                        for (_c = 0, results_2 = results; _c < results_2.length; _c++) {
+                            result = results_2[_c];
+                            if (result.transactions && Array.isArray(result.transactions)) {
+                                for (_d = 0, _e = result.transactions; _d < _e.length; _d++) {
+                                    tx = _e[_d];
+                                    metadata = swapMetadata.get(tx.txid);
+                                    if (metadata && metadata.isSwap) {
+                                        tx.swapMetadata = metadata;
+                                    }
+                                }
+                            }
+                        }
+                        log.debug(tag, "Enriched ".concat(swapMetadata.size, " swap transactions"));
+                        _f.label = 33;
+                    case 33: return [3 /*break*/, 35];
+                    case 34:
+                        error_2 = _f.sent();
+                        log.error(tag, 'Swap detection failed (non-critical):', error_2.message);
+                        return [3 /*break*/, 35];
+                    case 35:
                         log.debug(tag, "✅ HISTORY QUERY COMPLETE");
                         // Return single result if single query, array if batch
                         return [2 /*return*/, Array.isArray(query) ? results : results[0]];

package/lib/schemas/history-response.d.ts

@@ -1,4 +1,29 @@
 import { z } from 'zod';
+/**
+ * Swap metadata schema
+ */
+export declare const SwapMetadataSchema: z.ZodObject<{
+    isSwap: z.ZodBoolean;
+    swapId: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        PENDING: "PENDING";
+        CONFIRMING: "CONFIRMING";
+        COMPLETED: "COMPLETED";
+        FAILED: "FAILED";
+        REFUNDED: "REFUNDED";
+    }>>;
+    fromAsset: z.ZodOptional<z.ZodString>;
+    toAsset: z.ZodOptional<z.ZodString>;
+    fromAmount: z.ZodOptional<z.ZodString>;
+    toAmount: z.ZodOptional<z.ZodString>;
+    destinationAddress: z.ZodOptional<z.ZodString>;
+    minimumReceived: z.ZodOptional<z.ZodString>;
+    userMessage: z.ZodOptional<z.ZodString>;
+    estimatedCompletionTime: z.ZodOptional<z.ZodNumber>;
+    inboundTxHash: z.ZodOptional<z.ZodString>;
+    outboundTxHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * Transaction schema for API responses
  */
@@ -34,6 +59,28 @@ export declare const TransactionSchema: z.ZodObject<{
     fee: z.ZodOptional<z.ZodString>;
     memo: z.ZodOptional<z.ZodString>;
     raw: z.ZodOptional<z.ZodAny>;
+    swapMetadata: z.ZodOptional<z.ZodObject<{
+        isSwap: z.ZodBoolean;
+        swapId: z.ZodOptional<z.ZodString>;
+        protocol: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<{
+            PENDING: "PENDING";
+            CONFIRMING: "CONFIRMING";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+            REFUNDED: "REFUNDED";
+        }>>;
+        fromAsset: z.ZodOptional<z.ZodString>;
+        toAsset: z.ZodOptional<z.ZodString>;
+        fromAmount: z.ZodOptional<z.ZodString>;
+        toAmount: z.ZodOptional<z.ZodString>;
+        destinationAddress: z.ZodOptional<z.ZodString>;
+        minimumReceived: z.ZodOptional<z.ZodString>;
+        userMessage: z.ZodOptional<z.ZodString>;
+        estimatedCompletionTime: z.ZodOptional<z.ZodNumber>;
+        inboundTxHash: z.ZodOptional<z.ZodString>;
+        outboundTxHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Individual history result schema
@@ -73,6 +120,28 @@ export declare const HistoryResultSchema: z.ZodObject<{
         fee: z.ZodOptional<z.ZodString>;
         memo: z.ZodOptional<z.ZodString>;
         raw: z.ZodOptional<z.ZodAny>;
+        swapMetadata: z.ZodOptional<z.ZodObject<{
+            isSwap: z.ZodBoolean;
+            swapId: z.ZodOptional<z.ZodString>;
+            protocol: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodEnum<{
+                PENDING: "PENDING";
+                CONFIRMING: "CONFIRMING";
+                COMPLETED: "COMPLETED";
+                FAILED: "FAILED";
+                REFUNDED: "REFUNDED";
+            }>>;
+            fromAsset: z.ZodOptional<z.ZodString>;
+            toAsset: z.ZodOptional<z.ZodString>;
+            fromAmount: z.ZodOptional<z.ZodString>;
+            toAmount: z.ZodOptional<z.ZodString>;
+            destinationAddress: z.ZodOptional<z.ZodString>;
+            minimumReceived: z.ZodOptional<z.ZodString>;
+            userMessage: z.ZodOptional<z.ZodString>;
+            estimatedCompletionTime: z.ZodOptional<z.ZodNumber>;
+            inboundTxHash: z.ZodOptional<z.ZodString>;
+            outboundTxHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     fetchedAt: z.ZodNumber;
     fetchedAtISO: z.ZodString;
@@ -120,6 +189,28 @@ export declare const TransactionHistoryResponseSchema: z.ZodObject<{
             fee: z.ZodOptional<z.ZodString>;
             memo: z.ZodOptional<z.ZodString>;
             raw: z.ZodOptional<z.ZodAny>;
+            swapMetadata: z.ZodOptional<z.ZodObject<{
+                isSwap: z.ZodBoolean;
+                swapId: z.ZodOptional<z.ZodString>;
+                protocol: z.ZodOptional<z.ZodString>;
+                status: z.ZodOptional<z.ZodEnum<{
+                    PENDING: "PENDING";
+                    CONFIRMING: "CONFIRMING";
+                    COMPLETED: "COMPLETED";
+                    FAILED: "FAILED";
+                    REFUNDED: "REFUNDED";
+                }>>;
+                fromAsset: z.ZodOptional<z.ZodString>;
+                toAsset: z.ZodOptional<z.ZodString>;
+                fromAmount: z.ZodOptional<z.ZodString>;
+                toAmount: z.ZodOptional<z.ZodString>;
+                destinationAddress: z.ZodOptional<z.ZodString>;
+                minimumReceived: z.ZodOptional<z.ZodString>;
+                userMessage: z.ZodOptional<z.ZodString>;
+                estimatedCompletionTime: z.ZodOptional<z.ZodNumber>;
+                inboundTxHash: z.ZodOptional<z.ZodString>;
+                outboundTxHash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         fetchedAt: z.ZodNumber;
         fetchedAtISO: z.ZodString;

package/lib/schemas/history-response.js

@@ -1,7 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionHistoryResponseSchema = exports.HistoryResultSchema = exports.TransactionSchema = void 0;
+exports.TransactionHistoryResponseSchema = exports.HistoryResultSchema = exports.TransactionSchema = exports.SwapMetadataSchema = void 0;
 var zod_1 = require("zod");
+/**
+ * Swap metadata schema
+ */
+exports.SwapMetadataSchema = zod_1.z.object({
+    isSwap: zod_1.z.boolean(),
+    swapId: zod_1.z.string().optional(),
+    protocol: zod_1.z.string().optional(),
+    status: zod_1.z.enum(['PENDING', 'CONFIRMING', 'COMPLETED', 'FAILED', 'REFUNDED']).optional(),
+    fromAsset: zod_1.z.string().optional(),
+    toAsset: zod_1.z.string().optional(),
+    fromAmount: zod_1.z.string().optional(),
+    toAmount: zod_1.z.string().optional(),
+    destinationAddress: zod_1.z.string().optional(),
+    minimumReceived: zod_1.z.string().optional(),
+    userMessage: zod_1.z.string().optional(),
+    estimatedCompletionTime: zod_1.z.number().optional(),
+    inboundTxHash: zod_1.z.string().optional(),
+    outboundTxHash: zod_1.z.string().optional(),
+});
 /**
  * Transaction schema for API responses
  */
@@ -21,6 +40,7 @@ exports.TransactionSchema = zod_1.z.object({
     fee: zod_1.z.string().optional(),
     memo: zod_1.z.string().optional(),
     raw: zod_1.z.any().optional(),
+    swapMetadata: exports.SwapMetadataSchema.optional(),
 });
 /**
  * Individual history result schema

package/lib/services/swap-detector.d.ts

@@ -0,0 +1,54 @@
+import type { Transaction } from '../index';
+/**
+ * Swap metadata attached to transactions
+ */
+export interface SwapMetadata {
+    isSwap: boolean;
+    swapId?: string;
+    protocol?: string;
+    status?: 'PENDING' | 'CONFIRMING' | 'COMPLETED' | 'FAILED' | 'REFUNDED';
+    fromAsset?: string;
+    toAsset?: string;
+    fromAmount?: string;
+    toAmount?: string;
+    destinationAddress?: string;
+    minimumReceived?: string;
+    inboundTxHash?: string;
+    outboundTxHash?: string;
+    userMessage?: string;
+    estimatedCompletionTime?: number;
+}
+/**
+ * Detect if transaction is a swap and enrich with metadata
+ */
+export declare class SwapDetector {
+    private pendingSwapsService;
+    private log;
+    constructor(pendingSwapsService: any, log: any);
+    /**
+     * Detect swaps in batch of transactions
+     */
+    detectSwaps(transactions: Transaction[]): Promise<Map<string, SwapMetadata>>;
+    /**
+     * Parse Thorchain/Maya memo format using pioneer-coins parseMemo
+     * Handles both verbose (SWAP:asset:address) and shorthand (=:asset:address) formats
+     */
+    private parseMemo;
+    /**
+     * Detect DEX contract addresses
+     */
+    private detectDexContract;
+    /**
+     * Generate user-friendly status message
+     */
+    private generateUserMessage;
+    /**
+     * Estimate completion time based on swap status
+     */
+    private estimateCompletionTime;
+    /**
+     * Query Midgard API for outbound transaction hash
+     * Queries both THORChain and Maya Midgard endpoints
+     */
+    private queryMidgardForOutbound;
+}

package/lib/services/swap-detector.js

@@ -0,0 +1,353 @@
+"use strict";
+/*
+    Swap Detection Service
+
+    Multi-layered detection strategy for identifying swap transactions:
+    1. Pending Swaps DB Lookup (PRIMARY - highest accuracy)
+    2. Memo Parsing (FALLBACK - Thorchain/Maya format detection)
+    3. Contract Address Detection (EVM ONLY - DEX router matching)
+*/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapDetector = void 0;
+var TAG = ' | swap-detector | ';
+/**
+ * Detect if transaction is a swap and enrich with metadata
+ */
+var SwapDetector = /** @class */ (function () {
+    function SwapDetector(pendingSwapsService, log) {
+        this.pendingSwapsService = pendingSwapsService;
+        this.log = log;
+    }
+    /**
+     * Detect swaps in batch of transactions
+     */
+    SwapDetector.prototype.detectSwaps = function (transactions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tag, swapMetadata, txids, pendingSwaps, _i, pendingSwaps_1, swap, metadata, error_1, _a, transactions_1, tx, memoMetadata, swapsNeedingOutbound, outboundPromises, _b, transactions_2, tx, contractMetadata;
+            var _this = this;
+            var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+            return __generator(this, function (_s) {
+                switch (_s.label) {
+                    case 0:
+                        tag = TAG + ' | detectSwaps | ';
+                        swapMetadata = new Map();
+                        txids = transactions.map(function (tx) { return tx.txid; });
+                        if (!this.pendingSwapsService) return [3 /*break*/, 4];
+                        _s.label = 1;
+                    case 1:
+                        _s.trys.push([1, 3, , 4]);
+                        console.log(tag, "\uD83D\uDD0D Running swap detection on ".concat(txids.length, " transactions"));
+                        return [4 /*yield*/, this.pendingSwapsService.findByTxids(txids)];
+                    case 2:
+                        pendingSwaps = _s.sent();
+                        console.log(tag, "\u2705 DB lookup found ".concat(pendingSwaps.length, " swaps"));
+                        for (_i = 0, pendingSwaps_1 = pendingSwaps; _i < pendingSwaps_1.length; _i++) {
+                            swap = pendingSwaps_1[_i];
+                            metadata = {
+                                isSwap: true,
+                                swapId: ((_c = swap._id) === null || _c === void 0 ? void 0 : _c.toString()) || swap._id,
+                                protocol: swap.integration,
+                                status: swap.status.toUpperCase(),
+                                // Use CAIPs directly - more exact than symbols
+                                fromAsset: ((_d = swap.sellAsset) === null || _d === void 0 ? void 0 : _d.caip) || ((_e = swap.sellAsset) === null || _e === void 0 ? void 0 : _e.symbol),
+                                toAsset: ((_f = swap.buyAsset) === null || _f === void 0 ? void 0 : _f.caip) || ((_g = swap.buyAsset) === null || _g === void 0 ? void 0 : _g.symbol),
+                                fromAmount: (_h = swap.sellAsset) === null || _h === void 0 ? void 0 : _h.amount,
+                                toAmount: ((_j = swap.buyAsset) === null || _j === void 0 ? void 0 : _j.amount) || ((_k = swap.quote) === null || _k === void 0 ? void 0 : _k.expectedAmountOut),
+                                destinationAddress: (_l = swap.buyAsset) === null || _l === void 0 ? void 0 : _l.address,
+                                minimumReceived: (_m = swap.quote) === null || _m === void 0 ? void 0 : _m.minimumAmountOut,
+                                userMessage: this.generateUserMessage(swap),
+                                estimatedCompletionTime: this.estimateCompletionTime(swap),
+                                inboundTxHash: ((_o = swap.thorchainData) === null || _o === void 0 ? void 0 : _o.inboundTxHash) || swap.txHash,
+                                outboundTxHash: (_p = swap.thorchainData) === null || _p === void 0 ? void 0 : _p.outboundTxHash
+                            };
+                            // Map swap to all related transaction hashes
+                            // Inbound transaction
+                            if (swap.txHash) {
+                                swapMetadata.set(swap.txHash, metadata);
+                            }
+                            // Thorchain inbound (if different)
+                            if (((_q = swap.thorchainData) === null || _q === void 0 ? void 0 : _q.inboundTxHash) && swap.thorchainData.inboundTxHash !== swap.txHash) {
+                                swapMetadata.set(swap.thorchainData.inboundTxHash, metadata);
+                            }
+                            // Thorchain outbound
+                            if ((_r = swap.thorchainData) === null || _r === void 0 ? void 0 : _r.outboundTxHash) {
+                                swapMetadata.set(swap.thorchainData.outboundTxHash, metadata);
+                            }
+                        }
+                        this.log.info(tag, "DB lookup found ".concat(pendingSwaps.length, " swaps"));
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _s.sent();
+                        this.log.error(tag, 'DB lookup failed (non-critical):', error_1.message);
+                        return [3 /*break*/, 4];
+                    case 4:
+                        // Layer 2: Memo Parsing (FALLBACK for Thorchain/Maya)
+                        for (_a = 0, transactions_1 = transactions; _a < transactions_1.length; _a++) {
+                            tx = transactions_1[_a];
+                            // Skip if already detected from DB
+                            if (swapMetadata.has(tx.txid))
+                                continue;
+                            if (tx.memo) {
+                                memoMetadata = this.parseMemo(tx.memo);
+                                if (memoMetadata.isSwap) {
+                                    // Set inbound txHash
+                                    memoMetadata.inboundTxHash = tx.txid;
+                                    swapMetadata.set(tx.txid, memoMetadata);
+                                }
+                            }
+                        }
+                        // Layer 2.5: Recursive Outbound Lookup for Memo-Detected Swaps
+                        // Query Midgard for outbound transactions for all memo-detected swaps
+                        console.log(tag, "\uD83D\uDD0D Running recursive outbound lookup for ".concat(swapMetadata.size, " detected swaps"));
+                        swapsNeedingOutbound = Array.from(swapMetadata.entries()).filter(function (_a) {
+                            var txid = _a[0], metadata = _a[1];
+                            return metadata.isSwap && !metadata.outboundTxHash;
+                        });
+                        if (!(swapsNeedingOutbound.length > 0)) return [3 /*break*/, 6];
+                        console.log(tag, "\uD83D\uDCE1 Querying Midgard for ".concat(swapsNeedingOutbound.length, " swaps"));
+                        outboundPromises = swapsNeedingOutbound.map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                            var outboundTxHash, error_2;
+                            var txid = _b[0], metadata = _b[1];
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        _c.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, this.queryMidgardForOutbound(txid)];
+                                    case 1:
+                                        outboundTxHash = _c.sent();
+                                        if (outboundTxHash) {
+                                            console.log(tag, "\u2705 Found outbound tx for ".concat(txid.substring(0, 10), "...: ").concat(outboundTxHash.substring(0, 10), "..."));
+                                            // Update metadata with outbound txHash
+                                            metadata.outboundTxHash = outboundTxHash;
+                                            metadata.status = 'COMPLETED';
+                                            metadata.userMessage = 'Swap completed successfully';
+                                        }
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        error_2 = _c.sent();
+                                        console.log(tag, "\u26A0\uFE0F  Midgard lookup failed for ".concat(txid.substring(0, 10), "...: ").concat(error_2.message));
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, Promise.all(outboundPromises)];
+                    case 5:
+                        _s.sent();
+                        console.log(tag, "\u2705 Recursive outbound lookup complete");
+                        _s.label = 6;
+                    case 6:
+                        // Layer 3: Contract Address Detection (EVM ONLY)
+                        for (_b = 0, transactions_2 = transactions; _b < transactions_2.length; _b++) {
+                            tx = transactions_2[_b];
+                            // Skip if already detected
+                            if (swapMetadata.has(tx.txid))
+                                continue;
+                            // Only for EVM chains
+                            if (tx.networkId && tx.networkId.startsWith('eip155:')) {
+                                contractMetadata = this.detectDexContract(tx);
+                                if (contractMetadata.isSwap) {
+                                    swapMetadata.set(tx.txid, contractMetadata);
+                                }
+                            }
+                        }
+                        console.log(tag, "\u2705 Total swaps detected: ".concat(swapMetadata.size));
+                        this.log.info(tag, "Total swaps detected: ".concat(swapMetadata.size));
+                        return [2 /*return*/, swapMetadata];
+                }
+            });
+        });
+    };
+    /**
+     * Parse Thorchain/Maya memo format using pioneer-coins parseMemo
+     * Handles both verbose (SWAP:asset:address) and shorthand (=:asset:address) formats
+     */
+    SwapDetector.prototype.parseMemo = function (memo) {
+        // TODO: Use parseMemo from @pioneer-platform/pioneer-coins instead of custom implementation
+        // For now, keep basic pattern matching until we can import it properly
+        // Try verbose format: SWAP:asset:address
+        var verbosePattern = /^SWAP:([^:]+):([^:]+)(?::(\d+))?/i;
+        var match = memo.match(verbosePattern);
+        // Try shorthand format: =:asset:address
+        if (!match) {
+            var shorthandPattern = /^=:([^:]+):([^:]+)(?::(\d+))?/;
+            match = memo.match(shorthandPattern);
+        }
+        if (match) {
+            // Return raw asset code/CAIP - let display layer handle conversion
+            var toAsset = match[1]; // Could be 'e', 'ETH', or full CAIP
+            return {
+                isSwap: true,
+                protocol: 'thorchain',
+                toAsset: toAsset, // Return raw value
+                destinationAddress: match[2],
+                minimumReceived: match[3],
+                userMessage: 'Swap detected from transaction memo'
+            };
+        }
+        return { isSwap: false };
+    };
+    /**
+     * Detect DEX contract addresses
+     */
+    SwapDetector.prototype.detectDexContract = function (tx) {
+        var _a;
+        var knownDexContracts = [
+            '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D'.toLowerCase(), // Uniswap V2 Router
+            '0xE592427A0AEce92De3Edee1F18E0157C05861564'.toLowerCase(), // Uniswap V3 Router
+            '0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146'.toLowerCase(), // Thorchain Router
+        ];
+        var toAddress = (_a = tx.to[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (toAddress && knownDexContracts.includes(toAddress)) {
+            return {
+                isSwap: true,
+                protocol: 'uniswap', // Simplified - would need more logic
+                userMessage: 'DEX swap detected'
+            };
+        }
+        return { isSwap: false };
+    };
+    /**
+     * Generate user-friendly status message
+     */
+    SwapDetector.prototype.generateUserMessage = function (swap) {
+        switch (swap.status) {
+            case 'PENDING':
+                return "Swap pending - waiting for network confirmations";
+            case 'CONFIRMING':
+                var confirmations = swap.confirmations || 0;
+                var required = swap.requiredConfirmations || 6;
+                return "Confirming swap (".concat(confirmations, "/").concat(required, " confirmations)");
+            case 'COMPLETED':
+                return "Swap completed successfully";
+            case 'FAILED':
+                return "Swap failed - funds may be refunded";
+            case 'REFUNDED':
+                return "Swap refunded to your wallet";
+            default:
+                return 'Swap status unknown';
+        }
+    };
+    /**
+     * Estimate completion time based on swap status
+     */
+    SwapDetector.prototype.estimateCompletionTime = function (swap) {
+        if (swap.status === 'COMPLETED' || swap.status === 'FAILED') {
+            return undefined; // Already finished
+        }
+        // Rough estimates (would be more sophisticated in production)
+        var now = Date.now();
+        var avgBlockTime = 12000; // 12 seconds for Ethereum
+        var remainingConfirmations = (swap.requiredConfirmations || 6) - (swap.confirmations || 0);
+        return now + (remainingConfirmations * avgBlockTime);
+    };
+    /**
+     * Query Midgard API for outbound transaction hash
+     * Queries both THORChain and Maya Midgard endpoints
+     */
+    SwapDetector.prototype.queryMidgardForOutbound = function (inboundTxHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tag, thorUrl, response, data, action, outboundTxid, thorError_1, mayaUrl, response, data, action, outboundTxid, mayaError_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tag = TAG + ' | queryMidgardForOutbound | ';
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        thorUrl = "https://midgard.ninerealms.com/v2/actions?txid=".concat(inboundTxHash);
+                        console.log(tag, "Querying THORChain Midgard: ".concat(thorUrl));
+                        return [4 /*yield*/, fetch(thorUrl)];
+                    case 2:
+                        response = _a.sent();
+                        if (!response.ok) return [3 /*break*/, 4];
+                        return [4 /*yield*/, response.json()];
+                    case 3:
+                        data = _a.sent();
+                        if (data.actions && data.actions.length > 0) {
+                            action = data.actions[0];
+                            // Check for outbound transaction
+                            if (action.out && action.out.length > 0 && action.out[0].txID) {
+                                outboundTxid = action.out[0].txID;
+                                console.log(tag, "\u2705 Found outbound from THORChain: ".concat(outboundTxid));
+                                return [2 /*return*/, outboundTxid];
+                            }
+                        }
+                        _a.label = 4;
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        thorError_1 = _a.sent();
+                        console.log(tag, "THORChain Midgard failed: ".concat(thorError_1.message));
+                        return [3 /*break*/, 6];
+                    case 6:
+                        _a.trys.push([6, 10, , 11]);
+                        mayaUrl = "https://midgard.mayachain.info/v2/actions?txid=".concat(inboundTxHash);
+                        console.log(tag, "Querying Maya Midgard: ".concat(mayaUrl));
+                        return [4 /*yield*/, fetch(mayaUrl)];
+                    case 7:
+                        response = _a.sent();
+                        if (!response.ok) return [3 /*break*/, 9];
+                        return [4 /*yield*/, response.json()];
+                    case 8:
+                        data = _a.sent();
+                        if (data.actions && data.actions.length > 0) {
+                            action = data.actions[0];
+                            // Check for outbound transaction
+                            if (action.out && action.out.length > 0 && action.out[0].txID) {
+                                outboundTxid = action.out[0].txID;
+                                console.log(tag, "\u2705 Found outbound from Maya: ".concat(outboundTxid));
+                                return [2 /*return*/, outboundTxid];
+                            }
+                        }
+                        _a.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        mayaError_1 = _a.sent();
+                        console.log(tag, "Maya Midgard failed: ".concat(mayaError_1.message));
+                        return [3 /*break*/, 11];
+                    case 11:
+                        console.log(tag, "No outbound tx found for ".concat(inboundTxHash));
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    return SwapDetector;
+}());
+exports.SwapDetector = SwapDetector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-history",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Transaction history aggregation across all blockchain networks",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",