@pioneer-platform/pioneer-history 0.2.0

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc -p .

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# @pioneer-platform/pioneer-history
+
+## 0.2.0
+
+### Minor Changes
+
+- chore: feat(pioneer-sdk): Add transaction history integration
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/eth-network@8.30.0
+  - @pioneer-platform/utxo-network@8.27.0
+
+## 0.1.0
+
+### Minor Changes
+
+- feat(pioneer-sdk): Add transaction history integration
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/eth-network@8.29.0
+  - @pioneer-platform/utxo-network@8.26.0

package/lib/index.d.ts

@@ -0,0 +1,53 @@
+export declare const UTXO_SUPPORT: string[];
+export declare const TENDERMINT_SUPPORT: string[];
+export declare const OTHER_SUPPORT: string[];
+export declare const SUPPORTED_CAIPS: {
+    UTXO: string[];
+    TENDERMINT: string[];
+    EIP155: string[];
+    OTHER: string[];
+};
+export interface HistoryQuery {
+    caip: string;
+    pubkey: string;
+}
+export interface HistoryOptions {
+    limit?: number;
+    offset?: number;
+    page?: number;
+    dateRange?: {
+        from?: string;
+        to?: string;
+    };
+}
+export interface Transaction {
+    txid: string;
+    caip: string;
+    networkId: string;
+    direction: 'sent' | 'received' | 'self';
+    type: 'transfer' | 'token_transfer' | 'swap' | 'stake' | 'unstake' | 'reward' | 'contract';
+    status: 'confirmed' | 'pending' | 'failed';
+    blockHeight?: number;
+    timestamp: number;
+    confirmations?: number;
+    from: string[];
+    to: string[];
+    value: string;
+    fee?: string;
+    memo?: string;
+    raw?: any;
+}
+export * from './schemas/history-response';
+export declare class History {
+    private blockchains;
+    private nodes;
+    private networks;
+    constructor(config: any);
+    init(): Promise<boolean>;
+    classifyCaip(caip: string): Promise<string>;
+    private normalizeUtxoTransactions;
+    private normalizeEvmTransactions;
+    private normalizeTendermintTransactions;
+    private normalizeRippleTransactions;
+    getHistory(query: HistoryQuery | HistoryQuery[], options?: HistoryOptions): Promise<any>;
+}

package/lib/index.js

@@ -0,0 +1,530 @@
+"use strict";
+/*
+
+    Pioneer History Module
+
+    Query transaction history on any network
+
+    pioneer-network map
+
+    utxo,
+    ethereum,
+    ripple,
+    cosmos,
+    thorchain,
+    osmosis,
+    mayachain
+
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.History = exports.SUPPORTED_CAIPS = exports.OTHER_SUPPORT = exports.TENDERMINT_SUPPORT = exports.UTXO_SUPPORT = void 0;
+var TAG = " | pioneer-history | ";
+var log = require('@pioneer-platform/loggerdog')();
+var caipToNetworkId = require('@pioneer-platform/pioneer-caip').caipToNetworkId;
+// CAIP support constants (reuse from pioneer-balance)
+exports.UTXO_SUPPORT = [
+    'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC
+    'bip122:000000000000000000651ef99cb9fcbe/slip44:145', // BCH
+    'bip122:000007d91d1254d60e2dd1ae58038307/slip44:5', // DASH
+    'bip122:00000000001a91e3dace36e2be3bf030/slip44:3', // DOGE
+    'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2', // LTC
+    'bip122:4da631f2ac1bed857bd968c67c913978/slip44:20', // DGB
+    'bip122:00040fe8ec8471911baa1db1266ea15d/slip44:133', // ZEC
+];
+exports.TENDERMINT_SUPPORT = [
+    'cosmos:mayachain-mainnet-v1/slip44:931',
+    'cosmos:mayachain-mainnet-v1/denom:maya',
+    'cosmos:osmosis-1/slip44:118',
+    'cosmos:cosmoshub-4/slip44:118',
+    'cosmos:thorchain-mainnet-v1/slip44:931',
+];
+exports.OTHER_SUPPORT = ['ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144'];
+exports.SUPPORTED_CAIPS = {
+    UTXO: exports.UTXO_SUPPORT,
+    TENDERMINT: exports.TENDERMINT_SUPPORT,
+    EIP155: ['eip155:*'],
+    OTHER: exports.OTHER_SUPPORT,
+};
+// Export schemas
+__exportStar(require("./schemas/history-response"), exports);
+var History = /** @class */ (function () {
+    function History(config) {
+        log.debug(TAG, "🏗️ History constructor called");
+        this.blockchains = config.wss || [];
+        this.nodes = config.nodes || [];
+        // CRITICAL: Use globally initialized networks if available (server environment)
+        var globalNetworks = global.pioneerNetworks;
+        if (globalNetworks) {
+            log.debug(TAG, "✅ Using globally initialized networks from pioneer-network");
+            log.debug(TAG, "   Available networks:", Object.keys(globalNetworks));
+            this.networks = { networks: globalNetworks };
+        }
+        else {
+            log.debug(TAG, "⚠️  No global networks found - creating local instances (backward compatibility mode)");
+            // Fallback: Import individual network modules
+            var utxo = require('@pioneer-platform/utxo-network');
+            var ethereum = require('@pioneer-platform/eth-network');
+            var ripple = require('@pioneer-platform/ripple-network');
+            var cosmos = require('@pioneer-platform/cosmos-network');
+            var thorchain = require('@pioneer-platform/thor-network');
+            var osmosis = require('@pioneer-platform/osmosis-network');
+            var mayachain = require('@pioneer-platform/maya-network');
+            this.networks = {
+                networks: {
+                    utxo: utxo,
+                    ethereum: ethereum,
+                    ripple: ripple,
+                    cosmos: cosmos,
+                    thorchain: thorchain,
+                    osmosis: osmosis,
+                    mayachain: mayachain,
+                }
+            };
+        }
+        log.debug(TAG, "✅ History constructor complete");
+        this.init = this.init.bind(this);
+        this.getHistory = this.getHistory.bind(this);
+        this.classifyCaip = this.classifyCaip.bind(this);
+    }
+    History.prototype.init = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var tag, globalNetworks, networkChecks, _i, networkChecks_1, check, isOnline, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tag = TAG + " | init | ";
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 11, , 12]);
+                        globalNetworks = global.pioneerNetworks;
+                        if (!globalNetworks) return [3 /*break*/, 2];
+                        // CRITICAL: If using globally initialized networks, skip re-initialization
+                        log.debug(tag, "✅ Using pre-initialized global networks - skipping network init");
+                        log.debug(tag, "   Verifying network online status:");
+                        networkChecks = [
+                            { name: 'utxo', module: this.networks.networks.utxo },
+                            { name: 'ethereum', module: this.networks.networks.ethereum },
+                            { name: 'ripple', module: this.networks.networks.ripple },
+                            { name: 'cosmos', module: this.networks.networks.cosmos },
+                            { name: 'thorchain', module: this.networks.networks.thorchain },
+                            { name: 'osmosis', module: this.networks.networks.osmosis },
+                            { name: 'mayachain', module: this.networks.networks.mayachain },
+                        ];
+                        for (_i = 0, networkChecks_1 = networkChecks; _i < networkChecks_1.length; _i++) {
+                            check = networkChecks_1[_i];
+                            isOnline = check.module.isOnline ? check.module.isOnline() : true;
+                            log.debug(tag, "   ".concat(check.name, ": ").concat(isOnline ? '✅ online' : '❌ offline'));
+                            if (!isOnline) {
+                                log.warn(tag, "\u26A0\uFE0F  WARNING: ".concat(check.name, " network is not online - history fetches may fail"));
+                            }
+                        }
+                        return [3 /*break*/, 10];
+                    case 2:
+                        // Fallback: Initialize local network instances
+                        log.debug(tag, "⚠️  Initializing local network instances (backward compatibility)");
+                        return [4 /*yield*/, this.networks.networks.utxo.init()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.networks.networks.ethereum.init()];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, this.networks.networks.ripple.init()];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, this.networks.networks.cosmos.init()];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, this.networks.networks.thorchain.init()];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, this.networks.networks.osmosis.init()];
+                    case 8:
+                        _a.sent();
+                        return [4 /*yield*/, this.networks.networks.mayachain.init()];
+                    case 9:
+                        _a.sent();
+                        _a.label = 10;
+                    case 10: return [2 /*return*/, true];
+                    case 11:
+                        e_1 = _a.sent();
+                        console.error(tag, e_1);
+                        throw e_1;
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    History.prototype.classifyCaip = function (caip) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // Use startsWith for chains where CAIP format might vary
+                if (caip.startsWith('bip122:'))
+                    return [2 /*return*/, 'UTXO'];
+                if (caip.startsWith('cosmos:'))
+                    return [2 /*return*/, 'TENDERMINT'];
+                if (caip.startsWith('eip155'))
+                    return [2 /*return*/, 'EIP155'];
+                if (caip.startsWith('ripple:'))
+                    return [2 /*return*/, 'OTHER'];
+                // Fallback to exact match for OTHER category
+                if (exports.SUPPORTED_CAIPS.OTHER.includes(caip))
+                    return [2 /*return*/, 'OTHER'];
+                throw new Error("FAIL FAST: Unsupported CAIP: ".concat(caip, " - Add support for this chain or fix CAIP format"));
+            });
+        });
+    };
+    History.prototype.normalizeUtxoTransactions = function (rawTxs, userXpub, caip) {
+        var tag = TAG + " | normalizeUtxoTransactions | ";
+        if (!Array.isArray(rawTxs)) {
+            log.warn(tag, "rawTxs is not an array, returning empty array");
+            return [];
+        }
+        return rawTxs.map(function (tx) {
+            var _a, _b, _c, _d;
+            // Determine direction based on isOwn flags
+            var hasOwnInput = (_a = tx.vin) === null || _a === void 0 ? void 0 : _a.some(function (input) { return input.isOwn; });
+            var hasOwnOutput = (_b = tx.vout) === null || _b === void 0 ? void 0 : _b.some(function (output) { return output.isOwn; });
+            var direction;
+            if (hasOwnInput && hasOwnOutput) {
+                direction = 'self';
+            }
+            else if (hasOwnInput) {
+                direction = 'sent';
+            }
+            else {
+                direction = 'received';
+            }
+            return {
+                txid: tx.txid,
+                caip: caip,
+                networkId: caipToNetworkId(caip),
+                direction: direction,
+                type: 'transfer',
+                status: tx.confirmations > 0 ? 'confirmed' : 'pending',
+                blockHeight: tx.blockHeight,
+                timestamp: tx.blockTime,
+                confirmations: tx.confirmations,
+                from: ((_c = tx.vin) === null || _c === void 0 ? void 0 : _c.flatMap(function (i) { return i.addresses || []; })) || [],
+                to: ((_d = tx.vout) === null || _d === void 0 ? void 0 : _d.flatMap(function (o) { return o.addresses || []; })) || [],
+                value: tx.value || '0',
+                fee: tx.fees,
+                memo: undefined,
+                raw: tx
+            };
+        });
+    };
+    History.prototype.normalizeEvmTransactions = function (rawTxs, userAddress, caip) {
+        var tag = TAG + " | normalizeEvmTransactions | ";
+        if (!Array.isArray(rawTxs)) {
+            log.warn(tag, "rawTxs is not an array, returning empty array");
+            return [];
+        }
+        return rawTxs.map(function (tx) {
+            var _a;
+            var direction = ((_a = tx.from) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === userAddress.toLowerCase()
+                ? 'sent'
+                : 'received';
+            // Parse timestamp - handle both ISO string and Unix timestamp formats
+            var timestamp;
+            if (tx.timestamp) {
+                if (typeof tx.timestamp === 'string') {
+                    // ISO string format from eth-network - convert to Unix timestamp
+                    timestamp = Math.floor(new Date(tx.timestamp).getTime() / 1000);
+                }
+                else {
+                    // Already a Unix timestamp number
+                    timestamp = parseInt(tx.timestamp);
+                }
+            }
+            else if (tx.timeStamp) {
+                timestamp = parseInt(tx.timeStamp);
+            }
+            else {
+                timestamp = Math.floor(Date.now() / 1000);
+            }
+            return {
+                txid: tx.hash || tx.txid,
+                caip: caip,
+                networkId: caipToNetworkId(caip),
+                direction: direction,
+                type: tx.contractAddress ? 'token_transfer' : 'transfer',
+                status: tx.status === 'success' || tx.status === '1' ? 'confirmed' : 'failed',
+                blockHeight: tx.blockNumber ? parseInt(tx.blockNumber) : undefined,
+                timestamp: timestamp,
+                confirmations: tx.confirmations,
+                from: tx.from ? [tx.from] : [],
+                to: tx.to ? [tx.to] : [],
+                value: tx.value || '0',
+                fee: tx.gasUsed && tx.gasPrice
+                    ? (BigInt(tx.gasUsed) * BigInt(tx.gasPrice)).toString()
+                    : undefined,
+                memo: undefined,
+                raw: tx
+            };
+        });
+    };
+    History.prototype.normalizeTendermintTransactions = function (rawTxs, userAddress, caip) {
+        var tag = TAG + " | normalizeTendermintTransactions | ";
+        if (!Array.isArray(rawTxs)) {
+            log.warn(tag, "rawTxs is not an array, returning empty array");
+            return [];
+        }
+        return rawTxs.map(function (tx) {
+            var _a, _b;
+            return ({
+                txid: tx.txid || tx.txhash || tx.hash,
+                caip: caip,
+                networkId: caipToNetworkId(caip),
+                direction: 'received', // TODO: Determine from messages
+                type: tx.type || 'transfer',
+                status: tx.status === 'success' || tx.code === 0 ? 'confirmed' : 'failed',
+                blockHeight: tx.height || tx.blockHeight,
+                timestamp: tx.timestamp ? (typeof tx.timestamp === 'string' ? new Date(tx.timestamp).getTime() / 1000 : tx.timestamp) : Date.now() / 1000,
+                confirmations: undefined,
+                from: [], // TODO: Extract from messages
+                to: [], // TODO: Extract from messages
+                value: '0', // TODO: Extract from messages
+                fee: undefined,
+                memo: tx.memo || ((_b = (_a = tx.tx) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.memo),
+                raw: tx
+            });
+        });
+    };
+    History.prototype.normalizeRippleTransactions = function (rawTxs, userAddress, caip) {
+        var tag = TAG + " | normalizeRippleTransactions | ";
+        if (!Array.isArray(rawTxs)) {
+            log.warn(tag, "rawTxs is not an array, returning empty array");
+            return [];
+        }
+        return rawTxs.map(function (tx) {
+            var _a, _b;
+            var txData = tx.tx || tx;
+            var direction = ((_a = txData.Account) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === userAddress.toLowerCase()
+                ? 'sent'
+                : 'received';
+            return {
+                txid: txData.hash || tx.hash,
+                caip: caip,
+                networkId: caipToNetworkId(caip),
+                direction: direction,
+                type: 'transfer',
+                status: tx.validated || ((_b = tx.meta) === null || _b === void 0 ? void 0 : _b.TransactionResult) === 'tesSUCCESS' ? 'confirmed' : 'pending',
+                blockHeight: tx.ledger_index || tx.ledgerIndex,
+                timestamp: txData.date ? txData.date + 946684800 : Date.now() / 1000, // Ripple epoch offset
+                confirmations: tx.validated ? 1 : 0,
+                from: txData.Account ? [txData.Account] : [],
+                to: txData.Destination ? [txData.Destination] : [],
+                value: txData.Amount || '0',
+                fee: txData.Fee,
+                memo: txData.Memos ? JSON.stringify(txData.Memos) : undefined,
+                raw: tx
+            };
+        });
+    };
+    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) {
+                    case 0:
+                        tag = TAG + " | getHistory | ";
+                        log.debug(tag, "🔍 HISTORY QUERY START");
+                        queries = Array.isArray(query) ? query : [query];
+                        log.debug(tag, "Processing ".concat(queries.length, " ").concat(queries.length === 1 ? 'query' : 'queries'));
+                        results = [];
+                        _i = 0, queries_1 = queries;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < queries_1.length)) return [3 /*break*/, 30];
+                        q = queries_1[_i];
+                        // Input validation - FAIL FAST
+                        if (!q.caip)
+                            throw new Error("caip required!");
+                        if (!q.pubkey)
+                            throw new Error("pubkey required!");
+                        log.debug(tag, "Query:", { caip: q.caip, pubkey: q.pubkey.substring(0, 20) + '...' });
+                        networkId = caipToNetworkId(q.caip);
+                        return [4 /*yield*/, this.classifyCaip(q.caip)];
+                    case 2:
+                        type = _b.sent();
+                        log.debug(tag, "🎯 Classified CAIP type:", type);
+                        asset = { caip: q.caip };
+                        pubkey = { pubkey: q.pubkey };
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 28, , 29]);
+                        _a = type;
+                        switch (_a) {
+                            case 'UTXO': return [3 /*break*/, 4];
+                            case 'EIP155': return [3 /*break*/, 6];
+                            case 'TENDERMINT': return [3 /*break*/, 10];
+                            case 'OTHER': return [3 /*break*/, 22];
+                        }
+                        return [3 /*break*/, 26];
+                    case 4:
+                        networkIdToSymbol = {
+                            'bip122:000000000019d6689c085ae165831e93': 'BTC',
+                            'bip122:000000000000000000651ef99cb9fcbe': 'BCH',
+                            'bip122:000007d91d1254d60e2dd1ae58038307': 'DASH',
+                            'bip122:00000000001a91e3dace36e2be3bf030': 'DOGE',
+                            'bip122:12a765e31ffd4059bada1e25190f6e98': 'LTC',
+                            'bip122:4da631f2ac1bed857bd968c67c913978': 'DGB',
+                            'bip122:00040fe8ec8471911baa1db1266ea15d': 'ZEC',
+                        };
+                        coin = networkIdToSymbol[networkId];
+                        if (!coin) {
+                            throw new Error("Unsupported UTXO network ID: ".concat(networkId));
+                        }
+                        log.debug(tag, 'Fetching UTXO transactions for', coin);
+                        return [4 /*yield*/, this.networks.networks.utxo.txsByXpub(coin, pubkey.pubkey)];
+                    case 5:
+                        rawTxs = _b.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);
+                        return [3 /*break*/, 27];
+                    case 6:
+                        log.debug(tag, 'Fetching EVM transactions for networkId:', networkId);
+                        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();
+                        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;
+                    case 9:
+                        results.push(asset);
+                        return [3 /*break*/, 27];
+                    case 10:
+                        log.debug(tag, 'Fetching Tendermint transactions for', q.caip);
+                        rawTxs = [];
+                        if (!q.caip.startsWith('cosmos:mayachain-mainnet-v1')) return [3 /*break*/, 13];
+                        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;
+                    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;
+                    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;
+                    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;
+                    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);
+                        results.push(asset);
+                        return [3 /*break*/, 27];
+                    case 22:
+                        if (!(q.caip === 'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144')) return [3 /*break*/, 25];
+                        log.debug(tag, 'Fetching Ripple transactions');
+                        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();
+                        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;
+                    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();
+                        log.error(tag, "Error fetching history for ".concat(q.caip, ":"), error_1);
+                        // Add empty result so batch processing continues
+                        asset.transactions = [];
+                        asset.error = error_1.message;
+                        results.push(asset);
+                        return [3 /*break*/, 29];
+                    case 29:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 30:
+                        log.debug(tag, "✅ HISTORY QUERY COMPLETE");
+                        // Return single result if single query, array if batch
+                        return [2 /*return*/, Array.isArray(query) ? results : results[0]];
+                }
+            });
+        });
+    };
+    return History;
+}());
+exports.History = History;

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

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+/**
+ * Transaction schema for API responses
+ */
+export declare const TransactionSchema: z.ZodObject<{
+    txid: z.ZodString;
+    caip: z.ZodString;
+    networkId: z.ZodString;
+    direction: z.ZodEnum<{
+        sent: "sent";
+        received: "received";
+        self: "self";
+    }>;
+    type: z.ZodEnum<{
+        transfer: "transfer";
+        token_transfer: "token_transfer";
+        swap: "swap";
+        stake: "stake";
+        unstake: "unstake";
+        reward: "reward";
+        contract: "contract";
+    }>;
+    status: z.ZodEnum<{
+        confirmed: "confirmed";
+        pending: "pending";
+        failed: "failed";
+    }>;
+    blockHeight: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+    confirmations: z.ZodOptional<z.ZodNumber>;
+    from: z.ZodArray<z.ZodString>;
+    to: z.ZodArray<z.ZodString>;
+    value: z.ZodString;
+    fee: z.ZodOptional<z.ZodString>;
+    memo: z.ZodOptional<z.ZodString>;
+    raw: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * Individual history result schema
+ */
+export declare const HistoryResultSchema: z.ZodObject<{
+    caip: z.ZodString;
+    pubkey: z.ZodString;
+    transactions: z.ZodArray<z.ZodObject<{
+        txid: z.ZodString;
+        caip: z.ZodString;
+        networkId: z.ZodString;
+        direction: z.ZodEnum<{
+            sent: "sent";
+            received: "received";
+            self: "self";
+        }>;
+        type: z.ZodEnum<{
+            transfer: "transfer";
+            token_transfer: "token_transfer";
+            swap: "swap";
+            stake: "stake";
+            unstake: "unstake";
+            reward: "reward";
+            contract: "contract";
+        }>;
+        status: z.ZodEnum<{
+            confirmed: "confirmed";
+            pending: "pending";
+            failed: "failed";
+        }>;
+        blockHeight: z.ZodOptional<z.ZodNumber>;
+        timestamp: z.ZodNumber;
+        confirmations: z.ZodOptional<z.ZodNumber>;
+        from: z.ZodArray<z.ZodString>;
+        to: z.ZodArray<z.ZodString>;
+        value: z.ZodString;
+        fee: z.ZodOptional<z.ZodString>;
+        memo: z.ZodOptional<z.ZodString>;
+        raw: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>>;
+    fetchedAt: z.ZodNumber;
+    fetchedAtISO: z.ZodString;
+    page: z.ZodNumber;
+    cached: z.ZodBoolean;
+    fresh: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * GetTransactionHistory API response schema
+ */
+export declare const TransactionHistoryResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    histories: z.ZodArray<z.ZodObject<{
+        caip: z.ZodString;
+        pubkey: z.ZodString;
+        transactions: z.ZodArray<z.ZodObject<{
+            txid: z.ZodString;
+            caip: z.ZodString;
+            networkId: z.ZodString;
+            direction: z.ZodEnum<{
+                sent: "sent";
+                received: "received";
+                self: "self";
+            }>;
+            type: z.ZodEnum<{
+                transfer: "transfer";
+                token_transfer: "token_transfer";
+                swap: "swap";
+                stake: "stake";
+                unstake: "unstake";
+                reward: "reward";
+                contract: "contract";
+            }>;
+            status: z.ZodEnum<{
+                confirmed: "confirmed";
+                pending: "pending";
+                failed: "failed";
+            }>;
+            blockHeight: z.ZodOptional<z.ZodNumber>;
+            timestamp: z.ZodNumber;
+            confirmations: z.ZodOptional<z.ZodNumber>;
+            from: z.ZodArray<z.ZodString>;
+            to: z.ZodArray<z.ZodString>;
+            value: z.ZodString;
+            fee: z.ZodOptional<z.ZodString>;
+            memo: z.ZodOptional<z.ZodString>;
+            raw: z.ZodOptional<z.ZodAny>;
+        }, z.core.$strip>>;
+        fetchedAt: z.ZodNumber;
+        fetchedAtISO: z.ZodString;
+        page: z.ZodNumber;
+        cached: z.ZodBoolean;
+        fresh: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Transaction = z.infer<typeof TransactionSchema>;
+export type HistoryResult = z.infer<typeof HistoryResultSchema>;
+export type TransactionHistoryResponse = z.infer<typeof TransactionHistoryResponseSchema>;

package/lib/schemas/history-response.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionHistoryResponseSchema = exports.HistoryResultSchema = exports.TransactionSchema = void 0;
+var zod_1 = require("zod");
+/**
+ * Transaction schema for API responses
+ */
+exports.TransactionSchema = zod_1.z.object({
+    txid: zod_1.z.string().min(1),
+    caip: zod_1.z.string().min(1),
+    networkId: zod_1.z.string().min(1),
+    direction: zod_1.z.enum(['sent', 'received', 'self']),
+    type: zod_1.z.enum(['transfer', 'token_transfer', 'swap', 'stake', 'unstake', 'reward', 'contract']),
+    status: zod_1.z.enum(['confirmed', 'pending', 'failed']),
+    blockHeight: zod_1.z.number().int().optional(),
+    timestamp: zod_1.z.number().positive(),
+    confirmations: zod_1.z.number().int().nonnegative().optional(),
+    from: zod_1.z.array(zod_1.z.string()),
+    to: zod_1.z.array(zod_1.z.string()),
+    value: zod_1.z.string(),
+    fee: zod_1.z.string().optional(),
+    memo: zod_1.z.string().optional(),
+    raw: zod_1.z.any().optional(),
+});
+/**
+ * Individual history result schema
+ */
+exports.HistoryResultSchema = zod_1.z.object({
+    caip: zod_1.z.string(),
+    pubkey: zod_1.z.string(),
+    transactions: zod_1.z.array(exports.TransactionSchema),
+    fetchedAt: zod_1.z.number(),
+    fetchedAtISO: zod_1.z.string(),
+    page: zod_1.z.number(),
+    cached: zod_1.z.boolean(),
+    fresh: zod_1.z.boolean(),
+});
+/**
+ * GetTransactionHistory API response schema
+ */
+exports.TransactionHistoryResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    histories: zod_1.z.array(exports.HistoryResultSchema),
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pioneer-platform/pioneer-history",
+  "version": "0.2.0",
+  "description": "Transaction history aggregation across all blockchain networks",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "npm": "pnpm i",
+    "test": "pnpm run build && node __tests__/test-module.js",
+    "lint": "prettier --write '**/**/*.ts'",
+    "dev": "pnpm run build && pnpm run test",
+    "build": "tsc -p .",
+    "build:watch": "pnpm run build && onchange 'src/**/*.ts' -- pnpm run build",
+    "prepublish": "pnpm run build",
+    "refresh": "rm -rf ./node_modules ./package-lock.json && pnpm install"
+  },
+  "dependencies": {
+    "@pioneer-platform/loggerdog": "workspace:*",
+    "@pioneer-platform/utxo-network": "workspace:*",
+    "@pioneer-platform/eth-network": "workspace:*",
+    "@pioneer-platform/cosmos-network": "workspace:*",
+    "@pioneer-platform/osmosis-network": "workspace:*",
+    "@pioneer-platform/thor-network": "workspace:*",
+    "@pioneer-platform/maya-network": "workspace:*",
+    "@pioneer-platform/ripple-network": "workspace:*",
+    "@pioneer-platform/solana-network": "workspace:*",
+    "@pioneer-platform/tron-network": "workspace:*",
+    "@pioneer-platform/ton-network": "workspace:*"
+  },
+  "devDependencies": {
+    "dotenv": "^16.0.0",
+    "typescript": "^5.0.0"
+  }
+}