@pioneer-platform/pioneer-cache 1.0.2 → 1.0.4

package/.turbo/turbo-build.log

@@ -1,2 +1 @@
-
-$ tsc
+$ tsc

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @pioneer-platform/pioneer-cache
 
+## 1.0.4
+
+### Patch Changes
+
+- cache work
+- Updated dependencies
+  - @pioneer-platform/redis-queue@8.11.2
+
+## 1.0.3
+
+### Patch Changes
+
+- cache work
+- Updated dependencies
+  - @pioneer-platform/redis-queue@8.11.1
+
 ## 1.0.2
 
 ### Patch Changes

package/dist/core/base-cache.js

@@ -151,9 +151,11 @@ class BaseCache {
         const t0 = Date.now();
         try {
             // Redis timeout for cache reads
-            // Increased from 100ms to 2000ms - 100ms was too aggressive and caused false cache misses
-            // Increased from 2000ms to 10000ms - IPv4/IPv6 DNS resolution can cause delays
-            const timeoutMs = 10000;
+            // PERFORMANCE: Generous timeout for connection pool under concurrent load
+            // - 1000ms accommodates worst-case scenarios with connection pool
+            // - Prevents false cache misses while still failing reasonably fast
+            // - Redis itself averages <1ms, but ioredis queuing can add latency
+            const timeoutMs = 1000;
             const cached = await Promise.race([
                 this.redis.get(key),
                 new Promise((resolve) => setTimeout(() => {
@@ -256,20 +258,34 @@ class BaseCache {
                 }
                 return;
             }
-            const job = {
-                type: `REFRESH_${this.config.name.toUpperCase()}`,
-                key: this.buildKey(params),
-                params,
-                priority,
-                retryCount: 0,
-                timestamp: Date.now()
-            };
-            // Queue job async (don't wait)
+            const key = this.buildKey(params);
+            // RATE LIMITING: Prevent duplicate refresh jobs within time window
+            // Use Redis SET NX EX for atomic rate limiting
+            const rateLimitKey = `refresh_lock:${key}`;
+            const rateLimitWindow = 5000; // 5 seconds - don't queue same refresh more than once per 5s
+            // Queue job async (don't wait) with rate limiting
             setImmediate(async () => {
                 try {
+                    // Try to acquire rate limit lock (atomic operation)
+                    const acquired = await this.redis.set(rateLimitKey, '1', 'PX', rateLimitWindow, // Expire in milliseconds
+                    'NX' // Only set if not exists
+                    );
+                    if (!acquired) {
+                        // Rate limit hit - job already queued recently
+                        log.debug(tag, `⏱️ Rate limit: Skip queuing ${key} (already queued in last ${rateLimitWindow}ms)`);
+                        return;
+                    }
+                    const job = {
+                        type: `REFRESH_${this.config.name.toUpperCase()}`,
+                        key,
+                        params,
+                        priority,
+                        retryCount: 0,
+                        timestamp: Date.now()
+                    };
                     await this.redisQueue.createWork(this.config.queueName, job);
                     if (this.config.logRefreshJobs) {
-                        log.debug(tag, `Queued refresh job: ${job.key} (priority: ${priority})`);
+                        log.debug(tag, `✅ Queued refresh job: ${job.key} (priority: ${priority})`);
                     }
                 }
                 catch (error) {

package/dist/core/cache-manager.d.ts

@@ -8,6 +8,7 @@ import type { HealthCheckResult } from '../types';
  */
 export interface CacheManagerConfig {
     redis: any;
+    redisQueue?: any;
     balanceModule?: any;
     markets?: any;
     enableBalanceCache?: boolean;
@@ -21,6 +22,7 @@ export interface CacheManagerConfig {
  */
 export declare class CacheManager {
     private redis;
+    private redisQueue;
     private balanceCache?;
     private priceCache?;
     private portfolioCache?;

package/dist/core/cache-manager.js

@@ -21,6 +21,7 @@ class CacheManager {
     constructor(config) {
         this.workers = [];
         this.redis = config.redis;
+        this.redisQueue = config.redisQueue || config.redis; // Fallback to main redis if not provided
         // Initialize Balance Cache
         if (config.enableBalanceCache !== false && config.balanceModule) {
             this.balanceCache = new balance_cache_1.BalanceCache(this.redis, config.balanceModule);
@@ -69,7 +70,8 @@ class CacheManager {
             }
             // Start unified worker if we have any caches with queues
             if (cacheRegistry.size > 0) {
-                const worker = await (0, refresh_worker_1.startUnifiedWorker)(this.redis, cacheRegistry, 'cache-refresh', // Unified queue name
+                const worker = await (0, refresh_worker_1.startUnifiedWorker)(this.redisQueue, // Use dedicated queue client for blocking operations
+                cacheRegistry, 'cache-refresh', // Unified queue name
                 {
                     maxRetries: 3,
                     retryDelay: 5000,

package/dist/stores/balance-cache.d.ts

@@ -21,7 +21,12 @@ export declare class BalanceCache extends BaseCache<BalanceData> {
     constructor(redis: any, balanceModule: any, config?: Partial<CacheConfig>);
     /**
      * Build Redis key for balance data
-     * Format: balance_v2:caip:pubkey
+     * Format: balance_v2:caip:hashedPubkey
+     *
+     * PRIVACY: Uses SHA-256 hash of pubkey/xpub instead of plaintext
+     * - One-way: cannot recover pubkey from hash
+     * - Deterministic: same pubkey always produces same key
+     * - Fast: ~0.02ms per hash
      */
     protected buildKey(params: Record<string, any>): string;
     /**

package/dist/stores/balance-cache.js

@@ -5,10 +5,42 @@
     Extends BaseCache with balance-specific logic.
     All common logic is inherited from BaseCache.
 */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BalanceCache = void 0;
 const base_cache_1 = require("../core/base-cache");
+const crypto_1 = __importDefault(require("crypto"));
 const log = require('@pioneer-platform/loggerdog')();
+/**
+ * Hash pubkey/xpub for privacy-protecting cache keys
+ * Uses SHA-256 for fast, deterministic, one-way hashing
+ */
+function hashPubkey(pubkey, salt = '') {
+    // Detect if this is an xpub (don't lowercase) or regular address (lowercase)
+    const isXpub = pubkey.match(/^[xyz]pub[1-9A-HJ-NP-Za-km-z]{100,}/);
+    const normalized = isXpub ? pubkey.trim() : pubkey.trim().toLowerCase();
+    const hash = crypto_1.default.createHash('sha256');
+    hash.update(normalized);
+    if (salt)
+        hash.update(salt);
+    // Return first 128 bits (32 hex chars) for shorter Redis keys
+    return hash.digest('hex').substring(0, 32);
+}
+/**
+ * Sanitize pubkey for safe logging
+ */
+function sanitizePubkey(pubkey) {
+    if (!pubkey || pubkey.length < 12)
+        return '[invalid]';
+    // Check if xpub (show first 8, last 8)
+    if (pubkey.match(/^[xyz]pub/)) {
+        return `${pubkey.substring(0, 8)}...${pubkey.substring(pubkey.length - 8)}`;
+    }
+    // Regular address (show first 6, last 4)
+    return `${pubkey.substring(0, 6)}...${pubkey.substring(pubkey.length - 4)}`;
+}
 /**
  * BalanceCache - Caches blockchain balance data
  */
@@ -42,7 +74,12 @@ class BalanceCache extends base_cache_1.BaseCache {
     }
     /**
      * Build Redis key for balance data
-     * Format: balance_v2:caip:pubkey
+     * Format: balance_v2:caip:hashedPubkey
+     *
+     * PRIVACY: Uses SHA-256 hash of pubkey/xpub instead of plaintext
+     * - One-way: cannot recover pubkey from hash
+     * - Deterministic: same pubkey always produces same key
+     * - Fast: ~0.02ms per hash
      */
     buildKey(params) {
         const { caip, pubkey } = params;
@@ -50,9 +87,9 @@ class BalanceCache extends base_cache_1.BaseCache {
             throw new Error('BalanceCache.buildKey: caip and pubkey required');
         }
         const normalizedCaip = caip.toLowerCase();
-        // Don't lowercase pubkeys - xpub/ypub/zpub are case-sensitive base58
-        const normalizedPubkey = pubkey;
-        return `${this.config.keyPrefix}${normalizedCaip}:${normalizedPubkey}`;
+        // Hash pubkey for privacy protection
+        const hashedPubkey = hashPubkey(pubkey, caip);
+        return `${this.config.keyPrefix}${normalizedCaip}:${hashedPubkey}`;
     }
     /**
      * Fetch balance from blockchain via balance module
@@ -61,12 +98,14 @@ class BalanceCache extends base_cache_1.BaseCache {
         const tag = this.TAG + 'fetchFromSource | ';
         try {
             const { caip, pubkey } = params;
-            // Fetch balance using balance module
+            // Log sanitized pubkey for debugging
+            log.debug(tag, `Fetching balance for ${caip}/${sanitizePubkey(pubkey)}`);
+            // Fetch balance using balance module (still uses real pubkey)
             const asset = { caip };
             const owner = { pubkey };
             const balanceInfo = await this.balanceModule.getBalance(asset, owner);
             if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${pubkey.substring(0, 10)}...`);
+                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
                 return {
                     caip,
                     pubkey,

package/dist/stores/price-cache.d.ts

@@ -22,6 +22,7 @@ export declare class PriceCache extends BaseCache<PriceData> {
     /**
      * Fetch price from markets API using CAIP-first approach
      * FIX #7: Graceful handling of zero prices to prevent cache disruption
+     * FIX #8: Cache zero prices for unpriceable tokens to prevent infinite retry loops
      */
     protected fetchFromSource(params: Record<string, any>): Promise<PriceData>;
     /**

package/dist/stores/price-cache.js

@@ -55,6 +55,7 @@ class PriceCache extends base_cache_1.BaseCache {
     /**
      * Fetch price from markets API using CAIP-first approach
      * FIX #7: Graceful handling of zero prices to prevent cache disruption
+     * FIX #8: Cache zero prices for unpriceable tokens to prevent infinite retry loops
      */
     async fetchFromSource(params) {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -63,32 +64,36 @@ class PriceCache extends base_cache_1.BaseCache {
             // Use CAIP-first API (no symbol conversion needed!)
             // This directly queries the markets module with CAIP identifiers
             const price = await this.markets.getAssetPriceByCaip(caip);
-            // FIX #7: Gracefully handle zero prices without throwing
-            // This prevents disrupting batch operations during API rate limits
-            if (isNaN(price) || price <= 0) {
-                log.warn(tag, `Price fetch returned $${price} for ${caip} (likely API timeout or rate limit) - returning stale cache if available`);
+            // FIX #8: Accept zero prices - they are VALID for unpriceable tokens
+            // Zero means "this token has no market value and we should stop trying to price it"
+            // Changed from: price <= 0 to: price < 0
+            if (isNaN(price) || price < 0) {
+                log.warn(tag, `Price fetch returned invalid price $${price} for ${caip} - returning stale cache if available`);
                 // Try to get stale cached value instead of failing
                 const key = this.buildKey(params);
                 const cachedValue = await this.getCached(key);
-                if (cachedValue && cachedValue.value.price > 0) {
+                if (cachedValue && cachedValue.value.price >= 0) {
                     log.info(tag, `Returning stale cached price for ${caip}: $${cachedValue.value.price}`);
                     return cachedValue.value;
                 }
                 // Try legacy cache as fallback
                 const legacyValue = await this.getLegacyCached(params);
-                if (legacyValue && legacyValue.price > 0) {
+                if (legacyValue && legacyValue.price >= 0) {
                     log.info(tag, `Returning legacy cached price for ${caip}: $${legacyValue.price}`);
                     return legacyValue;
                 }
-                // Last resort: return zero price but don't cache it
-                log.warn(tag, `No cached price available for ${caip}, returning zero`);
+                // Last resort: throw error for truly invalid prices
+                log.warn(tag, `No cached price available for ${caip}, invalid price: $${price}`);
                 throw new Error(`No valid price available for ${caip}`);
             }
             log.debug(tag, `Fetched price for ${caip}: $${price}`);
+            // FIX #8: Mark zero prices with special source to indicate they are unpriceable tokens
+            // This allows us to track and monitor unpriceable token caching
+            const source = price === 0 ? 'unpriceable' : 'markets-caip';
             return {
                 caip,
                 price,
-                source: 'markets-caip'
+                source
             };
         }
         catch (error) {

package/dist/workers/refresh-worker.d.ts

@@ -35,6 +35,7 @@ export declare class RefreshWorker {
     stop(): Promise<void>;
     /**
      * Poll for next job from the queue
+     * FIX #3: Atomic flag check and job processing to prevent race conditions
      */
     private poll;
     /**

package/dist/workers/refresh-worker.js

@@ -72,6 +72,7 @@ class RefreshWorker {
     }
     /**
      * Poll for next job from the queue
+     * FIX #3: Atomic flag check and job processing to prevent race conditions
      */
     async poll() {
         const tag = TAG + 'poll | ';
@@ -79,6 +80,7 @@ class RefreshWorker {
             return;
         }
         try {
+            // FIX #3: Atomic check-and-set to prevent race conditions
             // Don't poll if already processing
             if (this.isProcessing) {
                 this.schedulePoll();
@@ -87,14 +89,20 @@ class RefreshWorker {
             // Get next job from queue
             const work = await this.redisQueue.getWork(this.config.queueName, 1);
             if (work) {
+                // Set processing flag BEFORE processing to prevent double execution
                 this.isProcessing = true;
-                await this.processJob(work);
-                this.isProcessing = false;
+                try {
+                    await this.processJob(work);
+                }
+                finally {
+                    // Always clear flag, even if processJob throws
+                    this.isProcessing = false;
+                }
             }
         }
         catch (error) {
             log.error(tag, 'Error in poll loop:', error.message);
-            this.isProcessing = false;
+            // Flag already cleared in inner finally block
         }
         finally {
             // Schedule next poll
@@ -138,7 +146,18 @@ class RefreshWorker {
         catch (error) {
             const processingTime = Date.now() - startTime;
             log.error(tag, `❌ Failed to process ${job.type} after ${processingTime}ms:`, error);
-            // Retry logic
+            // FIX #1: Detect permanent failures (don't retry unpriceable tokens)
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const isPermanentFailure = (errorMsg.includes('No valid price available') ||
+                errorMsg.includes('unpriceable') ||
+                errorMsg.includes('not found') ||
+                errorMsg.includes('404'));
+            if (isPermanentFailure) {
+                log.warn(tag, `Permanent failure detected for ${job.type}, will not retry: ${errorMsg}`);
+                // Don't retry - job complete (failed permanently)
+                return;
+            }
+            // Retry logic (only for transient failures)
             if ((job.retryCount || 0) < this.config.maxRetries) {
                 const newRetryCount = (job.retryCount || 0) + 1;
                 log.info(tag, `Retrying job (attempt ${newRetryCount}/${this.config.maxRetries})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,9 +20,9 @@
   "author": "Pioneer Platform",
   "license": "MIT",
   "dependencies": {
-    "@pioneer-platform/loggerdog": "^8.0.0",
-    "@pioneer-platform/redis-queue": "^8.0.0",
-    "@pioneer-platform/default-redis": "^8.0.0"
+    "@pioneer-platform/loggerdog": "^8.11.0",
+    "@pioneer-platform/redis-queue": "^8.11.2",
+    "@pioneer-platform/default-redis": "^8.11.7"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/core/base-cache.ts

@@ -185,9 +185,11 @@ export abstract class BaseCache<T> {
 
         try {
             // Redis timeout for cache reads
-            // Increased from 100ms to 2000ms - 100ms was too aggressive and caused false cache misses
-            // Increased from 2000ms to 10000ms - IPv4/IPv6 DNS resolution can cause delays
-            const timeoutMs = 10000;
+            // PERFORMANCE: Generous timeout for connection pool under concurrent load
+            // - 1000ms accommodates worst-case scenarios with connection pool
+            // - Prevents false cache misses while still failing reasonably fast
+            // - Redis itself averages <1ms, but ioredis queuing can add latency
+            const timeoutMs = 1000;
             const cached = await Promise.race([
                 this.redis.get(key),
                 new Promise<null>((resolve) => setTimeout(() => {
@@ -306,22 +308,43 @@ export abstract class BaseCache<T> {
                 return;
             }
 
-            const job: RefreshJob = {
-                type: `REFRESH_${this.config.name.toUpperCase()}`,
-                key: this.buildKey(params),
-                params,
-                priority,
-                retryCount: 0,
-                timestamp: Date.now()
-            };
+            const key = this.buildKey(params);
 
-            // Queue job async (don't wait)
+            // RATE LIMITING: Prevent duplicate refresh jobs within time window
+            // Use Redis SET NX EX for atomic rate limiting
+            const rateLimitKey = `refresh_lock:${key}`;
+            const rateLimitWindow = 5000; // 5 seconds - don't queue same refresh more than once per 5s
+
+            // Queue job async (don't wait) with rate limiting
             setImmediate(async () => {
                 try {
+                    // Try to acquire rate limit lock (atomic operation)
+                    const acquired = await this.redis.set(
+                        rateLimitKey,
+                        '1',
+                        'PX', rateLimitWindow,  // Expire in milliseconds
+                        'NX'  // Only set if not exists
+                    );
+
+                    if (!acquired) {
+                        // Rate limit hit - job already queued recently
+                        log.debug(tag, `⏱️ Rate limit: Skip queuing ${key} (already queued in last ${rateLimitWindow}ms)`);
+                        return;
+                    }
+
+                    const job: RefreshJob = {
+                        type: `REFRESH_${this.config.name.toUpperCase()}`,
+                        key,
+                        params,
+                        priority,
+                        retryCount: 0,
+                        timestamp: Date.now()
+                    };
+
                     await this.redisQueue.createWork(this.config.queueName, job);
 
                     if (this.config.logRefreshJobs) {
-                        log.debug(tag, `Queued refresh job: ${job.key} (priority: ${priority})`);
+                        log.debug(tag, `✅ Queued refresh job: ${job.key} (priority: ${priority})`);
                     }
 
                 } catch (error) {

package/src/core/cache-manager.ts

@@ -21,6 +21,7 @@ const TAG = ' | CacheManager | ';
  */
 export interface CacheManagerConfig {
     redis: any;
+    redisQueue?: any;                      // Dedicated Redis client for blocking queue operations (brpop, etc.)
     balanceModule?: any;                   // Optional: if not provided, balance cache won't be initialized
     markets?: any;                         // Optional: if not provided, price cache won't be initialized
     enableBalanceCache?: boolean;
@@ -35,6 +36,7 @@ export interface CacheManagerConfig {
  */
 export class CacheManager {
     private redis: any;
+    private redisQueue: any;  // Dedicated client for blocking operations
     private balanceCache?: BalanceCache;
     private priceCache?: PriceCache;
     private portfolioCache?: PortfolioCache;
@@ -43,6 +45,7 @@ export class CacheManager {
 
     constructor(config: CacheManagerConfig) {
         this.redis = config.redis;
+        this.redisQueue = config.redisQueue || config.redis;  // Fallback to main redis if not provided
 
         // Initialize Balance Cache
         if (config.enableBalanceCache !== false && config.balanceModule) {
@@ -105,7 +108,7 @@ export class CacheManager {
             // Start unified worker if we have any caches with queues
             if (cacheRegistry.size > 0) {
                 const worker = await startUnifiedWorker(
-                    this.redis,
+                    this.redisQueue,                // Use dedicated queue client for blocking operations
                     cacheRegistry,
                     'cache-refresh',                // Unified queue name
                     {

package/src/stores/balance-cache.ts

@@ -7,9 +7,42 @@
 
 import { BaseCache } from '../core/base-cache';
 import type { CacheConfig } from '../types';
+import crypto from 'crypto';
 
 const log = require('@pioneer-platform/loggerdog')();
 
+/**
+ * Hash pubkey/xpub for privacy-protecting cache keys
+ * Uses SHA-256 for fast, deterministic, one-way hashing
+ */
+function hashPubkey(pubkey: string, salt: string = ''): string {
+    // Detect if this is an xpub (don't lowercase) or regular address (lowercase)
+    const isXpub = pubkey.match(/^[xyz]pub[1-9A-HJ-NP-Za-km-z]{100,}/);
+    const normalized = isXpub ? pubkey.trim() : pubkey.trim().toLowerCase();
+
+    const hash = crypto.createHash('sha256');
+    hash.update(normalized);
+    if (salt) hash.update(salt);
+
+    // Return first 128 bits (32 hex chars) for shorter Redis keys
+    return hash.digest('hex').substring(0, 32);
+}
+
+/**
+ * Sanitize pubkey for safe logging
+ */
+function sanitizePubkey(pubkey: string): string {
+    if (!pubkey || pubkey.length < 12) return '[invalid]';
+
+    // Check if xpub (show first 8, last 8)
+    if (pubkey.match(/^[xyz]pub/)) {
+        return `${pubkey.substring(0, 8)}...${pubkey.substring(pubkey.length - 8)}`;
+    }
+
+    // Regular address (show first 6, last 4)
+    return `${pubkey.substring(0, 6)}...${pubkey.substring(pubkey.length - 4)}`;
+}
+
 /**
  * Balance data structure
  */
@@ -61,7 +94,12 @@ export class BalanceCache extends BaseCache<BalanceData> {
 
     /**
      * Build Redis key for balance data
-     * Format: balance_v2:caip:pubkey
+     * Format: balance_v2:caip:hashedPubkey
+     *
+     * PRIVACY: Uses SHA-256 hash of pubkey/xpub instead of plaintext
+     * - One-way: cannot recover pubkey from hash
+     * - Deterministic: same pubkey always produces same key
+     * - Fast: ~0.02ms per hash
      */
     protected buildKey(params: Record<string, any>): string {
         const { caip, pubkey } = params;
@@ -70,10 +108,11 @@ export class BalanceCache extends BaseCache<BalanceData> {
         }
 
         const normalizedCaip = caip.toLowerCase();
-        // Don't lowercase pubkeys - xpub/ypub/zpub are case-sensitive base58
-        const normalizedPubkey = pubkey;
 
-        return `${this.config.keyPrefix}${normalizedCaip}:${normalizedPubkey}`;
+        // Hash pubkey for privacy protection
+        const hashedPubkey = hashPubkey(pubkey, caip);
+
+        return `${this.config.keyPrefix}${normalizedCaip}:${hashedPubkey}`;
     }
 
     /**
@@ -85,13 +124,16 @@ export class BalanceCache extends BaseCache<BalanceData> {
         try {
             const { caip, pubkey } = params;
 
-            // Fetch balance using balance module
+            // Log sanitized pubkey for debugging
+            log.debug(tag, `Fetching balance for ${caip}/${sanitizePubkey(pubkey)}`);
+
+            // Fetch balance using balance module (still uses real pubkey)
             const asset = { caip };
             const owner = { pubkey };
             const balanceInfo = await this.balanceModule.getBalance(asset, owner);
 
             if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${pubkey.substring(0, 10)}...`);
+                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
                 return {
                     caip,
                     pubkey,

package/src/stores/price-cache.ts

@@ -71,6 +71,7 @@ export class PriceCache extends BaseCache<PriceData> {
     /**
      * Fetch price from markets API using CAIP-first approach
      * FIX #7: Graceful handling of zero prices to prevent cache disruption
+     * FIX #8: Cache zero prices for unpriceable tokens to prevent infinite retry loops
      */
     protected async fetchFromSource(params: Record<string, any>): Promise<PriceData> {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -82,38 +83,43 @@ export class PriceCache extends BaseCache<PriceData> {
             // This directly queries the markets module with CAIP identifiers
             const price = await this.markets.getAssetPriceByCaip(caip);
 
-            // FIX #7: Gracefully handle zero prices without throwing
-            // This prevents disrupting batch operations during API rate limits
-            if (isNaN(price) || price <= 0) {
-                log.warn(tag, `Price fetch returned $${price} for ${caip} (likely API timeout or rate limit) - returning stale cache if available`);
+            // FIX #8: Accept zero prices - they are VALID for unpriceable tokens
+            // Zero means "this token has no market value and we should stop trying to price it"
+            // Changed from: price <= 0 to: price < 0
+            if (isNaN(price) || price < 0) {
+                log.warn(tag, `Price fetch returned invalid price $${price} for ${caip} - returning stale cache if available`);
 
                 // Try to get stale cached value instead of failing
                 const key = this.buildKey(params);
                 const cachedValue = await this.getCached(key);
 
-                if (cachedValue && cachedValue.value.price > 0) {
+                if (cachedValue && cachedValue.value.price >= 0) {
                     log.info(tag, `Returning stale cached price for ${caip}: $${cachedValue.value.price}`);
                     return cachedValue.value;
                 }
 
                 // Try legacy cache as fallback
                 const legacyValue = await this.getLegacyCached(params);
-                if (legacyValue && legacyValue.price > 0) {
+                if (legacyValue && legacyValue.price >= 0) {
                     log.info(tag, `Returning legacy cached price for ${caip}: $${legacyValue.price}`);
                     return legacyValue;
                 }
 
-                // Last resort: return zero price but don't cache it
-                log.warn(tag, `No cached price available for ${caip}, returning zero`);
+                // Last resort: throw error for truly invalid prices
+                log.warn(tag, `No cached price available for ${caip}, invalid price: $${price}`);
                 throw new Error(`No valid price available for ${caip}`);
             }
 
             log.debug(tag, `Fetched price for ${caip}: $${price}`);
 
+            // FIX #8: Mark zero prices with special source to indicate they are unpriceable tokens
+            // This allows us to track and monitor unpriceable token caching
+            const source = price === 0 ? 'unpriceable' : 'markets-caip';
+
             return {
                 caip,
                 price,
-                source: 'markets-caip'
+                source
             };
 
         } catch (error) {

package/src/workers/refresh-worker.ts

@@ -100,6 +100,7 @@ export class RefreshWorker {
 
     /**
      * Poll for next job from the queue
+     * FIX #3: Atomic flag check and job processing to prevent race conditions
      */
     private async poll(): Promise<void> {
         const tag = TAG + 'poll | ';
@@ -109,6 +110,7 @@ export class RefreshWorker {
         }
 
         try {
+            // FIX #3: Atomic check-and-set to prevent race conditions
             // Don't poll if already processing
             if (this.isProcessing) {
                 this.schedulePoll();
@@ -119,14 +121,19 @@ export class RefreshWorker {
             const work = await this.redisQueue.getWork(this.config.queueName, 1);
 
             if (work) {
+                // Set processing flag BEFORE processing to prevent double execution
                 this.isProcessing = true;
-                await this.processJob(work);
-                this.isProcessing = false;
+                try {
+                    await this.processJob(work);
+                } finally {
+                    // Always clear flag, even if processJob throws
+                    this.isProcessing = false;
+                }
             }
 
         } catch (error: any) {
             log.error(tag, 'Error in poll loop:', error.message);
-            this.isProcessing = false;
+            // Flag already cleared in inner finally block
         } finally {
             // Schedule next poll
             this.schedulePoll();
@@ -180,7 +187,22 @@ export class RefreshWorker {
             const processingTime = Date.now() - startTime;
             log.error(tag, `❌ Failed to process ${job.type} after ${processingTime}ms:`, error);
 
-            // Retry logic
+            // FIX #1: Detect permanent failures (don't retry unpriceable tokens)
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const isPermanentFailure = (
+                errorMsg.includes('No valid price available') ||
+                errorMsg.includes('unpriceable') ||
+                errorMsg.includes('not found') ||
+                errorMsg.includes('404')
+            );
+
+            if (isPermanentFailure) {
+                log.warn(tag, `Permanent failure detected for ${job.type}, will not retry: ${errorMsg}`);
+                // Don't retry - job complete (failed permanently)
+                return;
+            }
+
+            // Retry logic (only for transient failures)
             if ((job.retryCount || 0) < this.config.maxRetries) {
                 const newRetryCount = (job.retryCount || 0) + 1;
                 log.info(tag, `Retrying job (attempt ${newRetryCount}/${this.config.maxRetries})`);