@openzeppelin/relayer-plugin-channels 0.18.0 → 0.19.0

package/dist/plugin/constants.d.ts

@@ -24,12 +24,14 @@ export declare const CONFIG: {
 };
 export declare const POOL: {
     readonly CLAIM_LOCK_TTL_SECONDS: 3;
-    readonly ACQUIRE_MAX_SPINS: 30;
-    readonly ACQUIRE_RETRY_MIN_MS: 10;
-    readonly ACQUIRE_RETRY_MAX_MS: 30;
+    readonly ACQUIRE_MAX_SPINS: 12;
+    readonly ACQUIRE_BASE_DELAY_MS: 25;
+    readonly ACQUIRE_MAX_DELAY_MS: 500;
+    readonly MAX_CLAIMS_PER_SPIN: 3;
     readonly CHANNEL_COOLDOWN_MS: 6000;
-    readonly LRU_MAP_TTL_SECONDS: 86400;
+    readonly LRU_KEY_TTL_SECONDS: 86400;
 };
+export declare const RELAYER_INFO_CACHE_TTL_SECONDS = 1800;
 export declare const TIME: {
     readonly MAX_TIME_BOUND_OFFSET_SECONDS: 60;
 };

package/dist/plugin/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/plugin/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,eAAO,MAAM,WAAW;;;;;;;;;;CAUd,CAAC;AAGX,eAAO,MAAM,MAAM;;;;;;;CAOT,CAAC;AAGX,eAAO,MAAM,IAAI;;;;;;;CAYP,CAAC;AAGX,eAAO,MAAM,IAAI;;CAEP,CAAC;AAGX,eAAO,MAAM,UAAU;;;;;;IAMrB,uLAAuL;;CAE/K,CAAC;AAGX,eAAO,MAAM,OAAO;;;CAGV,CAAC;AAGX,eAAO,MAAM,OAAO;;;CAGV,CAAC;AAEX,eAAO,MAAM,GAAG;;CAGN,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/plugin/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,eAAO,MAAM,WAAW;;;;;;;;;;CAUd,CAAC;AAGX,eAAO,MAAM,MAAM;;;;;;;CAOT,CAAC;AAGX,eAAO,MAAM,IAAI;;;;;;;;CAcP,CAAC;AAGX,eAAO,MAAM,8BAA8B,OAAQ,CAAC;AAGpD,eAAO,MAAM,IAAI;;CAEP,CAAC;AAGX,eAAO,MAAM,UAAU;;;;;;IAMrB,uLAAuL;;CAE/K,CAAC;AAGX,eAAO,MAAM,OAAO;;;CAGV,CAAC;AAGX,eAAO,MAAM,OAAO;;;CAGV,CAAC;AAEX,eAAO,MAAM,GAAG;;CAGN,CAAC"}

package/dist/plugin/constants.js

@@ -5,7 +5,7 @@
  * Centralized constants for the channel accounts plugin.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FEE = exports.POLLING = exports.TIMEOUT = exports.SIMULATION = exports.TIME = exports.POOL = exports.CONFIG = exports.HTTP_STATUS = void 0;
+exports.FEE = exports.POLLING = exports.TIMEOUT = exports.SIMULATION = exports.TIME = exports.RELAYER_INFO_CACHE_TTL_SECONDS = exports.POOL = exports.CONFIG = exports.HTTP_STATUS = void 0;
 // HTTP Status Codes
 exports.HTTP_STATUS = {
     BAD_REQUEST: 400,
@@ -32,15 +32,19 @@ exports.POOL = {
     // Per-channel claim lock TTL — must exceed worst-case callback latency
     // to prevent TTL expiry allowing a second worker into the same claim section
     CLAIM_LOCK_TTL_SECONDS: 3,
-    // Retry policy when all candidates busy
-    ACQUIRE_MAX_SPINS: 30,
-    ACQUIRE_RETRY_MIN_MS: 10,
-    ACQUIRE_RETRY_MAX_MS: 30,
+    // Retry policy: exponential backoff with full jitter
+    ACQUIRE_MAX_SPINS: 12,
+    ACQUIRE_BASE_DELAY_MS: 25,
+    ACQUIRE_MAX_DELAY_MS: 500,
+    // Max claim-lock attempts per spin (batch size)
+    MAX_CLAIMS_PER_SPIN: 3,
     // Hard-block cooldown for uncertain-outcome channels (~1 Stellar ledger with margin)
     CHANNEL_COOLDOWN_MS: 6000,
-    // Housekeeping TTL for the single LRU map document
-    LRU_MAP_TTL_SECONDS: 86400,
+    // Housekeeping TTL for per-channel LRU keys
+    LRU_KEY_TTL_SECONDS: 86400,
 };
+// Relayer info cache — address and network_type are effectively immutable
+exports.RELAYER_INFO_CACHE_TTL_SECONDS = 1800; // 30 minutes
 // Time Constants
 exports.TIME = {
     MAX_TIME_BOUND_OFFSET_SECONDS: 60,

package/dist/plugin/handler.d.ts

@@ -5,7 +5,20 @@
  * Orchestrates the transaction processing pipeline using channel accounts with fee bumping.
  */
 import { PluginContext } from '@openzeppelin/relayer-sdk';
+import type { Relayer } from '@openzeppelin/relayer-sdk';
 import { Transaction, xdr } from '@stellar/stellar-sdk';
+/** Subset of relayer metadata used by the plugin (address + network_type). */
+type CachedRelayerInfo = {
+    address: string;
+    network_type: string;
+};
+/** @internal Exported for test isolation only. */
+export declare function clearRelayerInfoCache(): void;
+/**
+ * Return cached relayer info or fetch from the API and cache the result.
+ * Returns null if the relayer has no address (misconfigured).
+ */
+export declare function getCachedRelayerInfo(network: string, relayerId: string, relayer: Relayer): Promise<CachedRelayerInfo | null>;
 /**
  * Extracts func and auth from an unsigned Soroban transaction.
  * Returns null if the transaction is not a single invokeHostFunction operation.
@@ -18,4 +31,5 @@ export declare function extractFuncAuthFromUnsignedXdr(tx: Transaction): {
  * Main plugin handler exported for OpenZeppelin Relayer
  */
 export declare function handler(context: PluginContext): Promise<any>;
+export {};
 //# sourceMappingURL=handler.d.ts.map

package/dist/plugin/handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/plugin/handler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAC;AASvE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AA2BxD;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,WAAW,GACd;IAAE,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC,yBAAyB,EAAE,CAAA;CAAE,GAAG,IAAI,CAkB1E;AAyTD;;GAEG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAElE"}
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/plugin/handler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAA4B,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAQnF,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAOxD,8EAA8E;AAC9E,KAAK,iBAAiB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAUnE,kDAAkD;AAClD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAanC;AAsBD;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,WAAW,GACd;IAAE,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC,yBAAyB,EAAE,CAAA;CAAE,GAAG,IAAI,CAkB1E;AAyTD;;GAEG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAElE"}

package/dist/plugin/handler.js

@@ -6,6 +6,8 @@
  * Orchestrates the transaction processing pipeline using channel accounts with fee bumping.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearRelayerInfoCache = clearRelayerInfoCache;
+exports.getCachedRelayerInfo = getCachedRelayerInfo;
 exports.extractFuncAuthFromUnsignedXdr = extractFuncAuthFromUnsignedXdr;
 exports.handler = handler;
 const relayer_sdk_1 = require("@openzeppelin/relayer-sdk");
@@ -21,6 +23,35 @@ const fee_1 = require("./fee");
 const tx_1 = require("./tx");
 const fee_tracking_1 = require("./fee-tracking");
 const sequence_1 = require("./sequence");
+/**
+ * In-memory cache for relayer info. Avoids a remote API call (getRelayer → HTTP GET)
+ * on every request while a channel lock is held. Keyed by `${network}:${relayerId}`.
+ * Entries expire after RELAYER_INFO_CACHE_TTL_SECONDS; stale entries are evicted on miss.
+ */
+const relayerInfoCache = new Map();
+/** @internal Exported for test isolation only. */
+function clearRelayerInfoCache() {
+    relayerInfoCache.clear();
+}
+/**
+ * Return cached relayer info or fetch from the API and cache the result.
+ * Returns null if the relayer has no address (misconfigured).
+ */
+async function getCachedRelayerInfo(network, relayerId, relayer) {
+    const cacheKey = `${network}:${relayerId}`;
+    const cached = relayerInfoCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.info;
+    // Evict stale entry so it doesn't linger in memory
+    if (cached)
+        relayerInfoCache.delete(cacheKey);
+    const info = await relayer.getRelayer();
+    if (!info?.address)
+        return null;
+    const entry = { address: info.address, network_type: info.network_type };
+    relayerInfoCache.set(cacheKey, { info: entry, expiresAt: Date.now() + constants_1.RELAYER_INFO_CACHE_TTL_SECONDS * 1000 });
+    return entry;
+}
 function getApiKey(headers, headerName) {
     const values = headers[headerName];
     return values?.[0]?.trim() || undefined;
@@ -94,7 +125,7 @@ async function handleFuncAuthSubmit(func, auth, ctx, skipWait) {
     try {
         poolLock = await ctx.pool.acquire(ctx.acquireOptions);
         const channelRelayer = ctx.api.useRelayer(poolLock.relayerId);
-        const channelInfo = await channelRelayer.getRelayer();
+        const channelInfo = await getCachedRelayerInfo(ctx.network, poolLock.relayerId, channelRelayer);
         console.log(`[channels] Acquired channel: ${poolLock.relayerId}`);
         if (!channelInfo || !channelInfo.address) {
             throw (0, relayer_sdk_1.pluginError)('Channel relayer not found', {
@@ -224,7 +255,7 @@ async function channelAccounts(context) {
             hash: stellar.hash ?? null,
         };
     }
-    const fundInfo = await fundRelayer.getRelayer();
+    const fundInfo = await getCachedRelayerInfo(config.network, fundRelayerId, fundRelayer);
     if (!fundInfo || !fundInfo.address) {
         throw (0, relayer_sdk_1.pluginError)('Fund relayer not found', {
             code: 'RELAYER_UNAVAILABLE',

package/dist/plugin/pool.d.ts

@@ -5,6 +5,7 @@
  * - Membership comes from KV: <network>:channel:relayer-ids
  * - Per-relayer locks with tokens: <network>:channel:in-use:<relayerId>
  * - Uses per-channel claim locks to make acquire safe across workers.
+ * - LRU ordering via per-channel keys: <network>:channel:lru:<relayerId>
  */
 import { PluginKVStore } from '@openzeppelin/relayer-sdk';
 export type PoolLock = {
@@ -23,8 +24,8 @@ export declare class ChannelPool {
     constructor(network: 'testnet' | 'mainnet', kv: PluginKVStore, lockTtlSeconds: number);
     /** Acquire a relayerId with a token lock */
     acquire(options: AcquireOptions): Promise<PoolLock>;
-    /** Read phase + claim phase (no global mutex) */
-    private tryAcquire;
+    /** Try to claim one channel from a batch of candidates */
+    private tryClaimBatch;
     /** Attempt to claim a single channel under its per-channel lock */
     private tryClaimChannel;
     /** Extend the lock TTL if we still own it (e.g. after WAIT_TIMEOUT) */
@@ -34,11 +35,13 @@ export declare class ChannelPool {
     /** Release with cooldown: keeps lock alive with short TTL to hard-block the channel. */
     releaseWithCooldown(lock: PoolLock, cooldownMs?: 6000): Promise<void>;
     private membershipKey;
-    private lockKeyPrefix;
     private lockKey;
     private claimKey;
-    private lruMapKey;
-    private updateLruMap;
+    private lruKey;
+    /** Read per-channel LRU timestamps in parallel (partial failures keep successful reads) */
+    private readLruMap;
+    /** Fire-and-forget LRU timestamp update for a single channel */
+    private updateLru;
     private getRelayerIdsFromKV;
     private getPoolCapacityDetails;
 }

package/dist/plugin/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/plugin/pool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAC;AAIvE,MAAM,MAAM,QAAQ,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAUF,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAgB;gBAEvB,OAAO,EAAE,SAAS,GAAG,SAAS,EAAE,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM;IAMrF,4CAA4C;IACtC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuBzD,iDAAiD;YACnC,UAAU;IAqDxB,mEAAmE;YACrD,eAAe;IAsB7B,uEAAuE;IACjE,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBhE,oCAAoC;IAC9B,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5C,wFAAwF;IAClF,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,OAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAa/F,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,SAAS;YAIH,YAAY;YAWZ,mBAAmB;YAYnB,sBAAsB;CAUrC"}
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/plugin/pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAC;AAIvE,MAAM,MAAM,QAAQ,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAUF,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAgB;gBAEvB,OAAO,EAAE,SAAS,GAAG,SAAS,EAAE,EAAE,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM;IAMrF,4CAA4C;IACtC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC;IA8DzD,0DAA0D;YAC5C,aAAa;IAQ3B,mEAAmE;YACrD,eAAe;IAuB7B,uEAAuE;IACjE,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBhE,oCAAoC;IAC9B,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5C,wFAAwF;IAClF,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,OAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAa/F,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,MAAM;IAId,2FAA2F;YAC7E,UAAU;IASxB,gEAAgE;IAChE,OAAO,CAAC,SAAS;YAMH,mBAAmB;YAYnB,sBAAsB;CAUrC"}

package/dist/plugin/pool.js

@@ -6,6 +6,7 @@
  * - Membership comes from KV: <network>:channel:relayer-ids
  * - Per-relayer locks with tokens: <network>:channel:in-use:<relayerId>
  * - Uses per-channel claim locks to make acquire safe across workers.
+ * - LRU ordering via per-channel keys: <network>:channel:lru:<relayerId>
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -24,12 +25,46 @@ class ChannelPool {
     /** Acquire a relayerId with a token lock */
     async acquire(options) {
         const maxSpins = constants_1.POOL.ACQUIRE_MAX_SPINS;
+        // --- Read state ONCE for the entire retry loop ---
+        let ids = await this.getRelayerIdsFromKV();
+        if (ids.length === 0) {
+            throw (0, relayer_sdk_1.pluginError)('No channel accounts configured. Use the management API to set channel accounts.', {
+                code: 'NO_CHANNELS_CONFIGURED',
+                status: constants_1.HTTP_STATUS.SERVICE_UNAVAILABLE,
+            });
+        }
+        if (options.contractId && options.limitedContracts.has(options.contractId)) {
+            ids = filterChannelsForLimitedContract(ids, options.capacityRatio);
+        }
+        // Shuffle all candidates; batch size scales so every spin covers an
+        // equal slice of the pool, guaranteeing full coverage across all spins.
+        const candidates = ids.slice();
+        shuffle(candidates);
+        // Read LRU for a small prefix only (capped at maxSpins * POOL.MAX_CLAIMS_PER_SPIN) to guide initial ordering.
+        // The rest stay in random shuffled order — no extra Redis reads.
+        const lruSampleSize = Math.min(candidates.length, maxSpins * constants_1.POOL.MAX_CLAIMS_PER_SPIN);
+        const lruMap = await this.readLruMap(candidates.slice(0, lruSampleSize));
+        const prefix = candidates.slice(0, lruSampleSize);
+        prefix.sort((a, b) => (lruMap[a] ?? 0) - (lruMap[b] ?? 0));
+        for (let j = 0; j < prefix.length; j++)
+            candidates[j] = prefix[j];
+        // Batch size: cover the full pool across maxSpins iterations
+        const batchSize = Math.max(constants_1.POOL.MAX_CLAIMS_PER_SPIN, Math.ceil(candidates.length / maxSpins));
+        let offset = 0;
         for (let i = 0; i < maxSpins; i++) {
-            const result = await this.tryAcquire(options);
+            if (offset >= candidates.length) {
+                // Full sweep done — reshuffle for next sweep
+                offset = 0;
+                shuffle(candidates);
+            }
+            const batch = candidates.slice(offset, offset + batchSize);
+            offset += batchSize;
+            const result = await this.tryClaimBatch(batch);
             if (result)
                 return result;
-            const jitter = constants_1.POOL.ACQUIRE_RETRY_MIN_MS +
-                Math.floor(Math.random() * (constants_1.POOL.ACQUIRE_RETRY_MAX_MS - constants_1.POOL.ACQUIRE_RETRY_MIN_MS + 1));
+            // Exponential backoff with full jitter
+            const baseDelay = Math.min(constants_1.POOL.ACQUIRE_MAX_DELAY_MS, constants_1.POOL.ACQUIRE_BASE_DELAY_MS * Math.pow(2, i));
+            const jitter = Math.floor(Math.random() * baseDelay);
             await sleep(jitter);
         }
         const diagnostics = await this.getPoolCapacityDetails(options, maxSpins);
@@ -40,50 +75,9 @@ class ChannelPool {
             details: diagnostics,
         });
     }
-    /** Read phase + claim phase (no global mutex) */
-    async tryAcquire(options) {
-        // --- READ PHASE (no lock) ---
-        let ids = await this.getRelayerIdsFromKV();
-        if (ids.length === 0) {
-            throw (0, relayer_sdk_1.pluginError)('No channel accounts configured. Use the management API to set channel accounts.', {
-                code: 'NO_CHANNELS_CONFIGURED',
-                status: constants_1.HTTP_STATUS.SERVICE_UNAVAILABLE,
-            });
-        }
-        if (options.contractId && options.limitedContracts.has(options.contractId)) {
-            ids = filterChannelsForLimitedContract(ids, options.capacityRatio);
-        }
-        const lockPrefix = this.lockKeyPrefix();
-        let lruMap = {};
-        try {
-            lruMap = (await this.kv.get(this.lruMapKey())) ?? {};
-        }
-        catch (err) {
-            console.warn('[channels] LRU map read failed, using empty ordering map', err);
-        }
-        let lockedSet;
-        try {
-            const lockedKeys = await this.kv.listKeys(`${lockPrefix}*`);
-            lockedSet = new Set(lockedKeys.map((k) => k.slice(lockPrefix.length)));
-        }
-        catch (err) {
-            // Fallback: if listKeys fails, degrade to O(N) per-channel exists checks.
-            // This is expensive with many channels — log so persistent failures are observable.
-            console.warn('[channels] listKeys failed, falling back to per-channel exists checks', err);
-            const results = await Promise.all(ids.map((id) => this.kv.exists(this.lockKey(id))));
-            lockedSet = new Set(ids.filter((_, i) => results[i]));
-        }
-        const unlocked = ids.filter((id) => !lockedSet.has(id));
-        if (unlocked.length === 0)
-            return null;
-        // Sort by LRU ascending — oldest channel is always first (deterministic).
-        // Shuffle-then-stable-sort: tie-break among equal timestamps is random,
-        // spreading contention when multiple channels share the same LRU value.
-        shuffle(unlocked);
-        unlocked.sort((a, b) => (lruMap[a] ?? 0) - (lruMap[b] ?? 0));
-        const candidates = unlocked;
-        // --- CLAIM PHASE (per-channel lock) ---
-        for (const candidate of candidates) {
+    /** Try to claim one channel from a batch of candidates */
+    async tryClaimBatch(batch) {
+        for (const candidate of batch) {
             const result = await this.tryClaimChannel(candidate);
             if (result)
                 return result;
@@ -98,7 +92,8 @@ class ChannelPool {
                 return null;
             const token = randomToken();
             await this.kv.set(this.lockKey(relayerId), { token, lockedAt: new Date().toISOString() }, { ttlSec: this.channelLockTtlSec });
-            await this.updateLruMap(relayerId);
+            // Fire-and-forget: LRU is best-effort, don't hold the claim lock for it
+            this.updateLru(relayerId);
             return { relayerId, token };
         }, { ttlSec: constants_1.POOL.CLAIM_LOCK_TTL_SECONDS, onBusy: 'skip' });
     }
@@ -145,28 +140,29 @@ class ChannelPool {
     membershipKey() {
         return `${this.network}:channel:relayer-ids`;
     }
-    lockKeyPrefix() {
-        return `${this.network}:channel:in-use:`;
-    }
     lockKey(relayerId) {
-        return `${this.lockKeyPrefix()}${relayerId}`;
+        return `${this.network}:channel:in-use:${relayerId}`;
     }
     claimKey(relayerId) {
         return `${this.network}:channel:claim:${relayerId}`;
     }
-    lruMapKey() {
-        return `${this.network}:channel:lru-map`;
+    lruKey(relayerId) {
+        return `${this.network}:channel:lru:${relayerId}`;
     }
-    async updateLruMap(relayerId) {
-        try {
-            const lruMap = (await this.kv.get(this.lruMapKey())) ?? {};
-            lruMap[relayerId] = Date.now();
-            await this.kv.set(this.lruMapKey(), lruMap, { ttlSec: constants_1.POOL.LRU_MAP_TTL_SECONDS });
-        }
-        catch (err) {
-            console.debug('[channels] failed to update LRU map', err);
-            // Best-effort: stale LRU map only affects ordering, not correctness
-        }
+    /** Read per-channel LRU timestamps in parallel (partial failures keep successful reads) */
+    async readLruMap(ids) {
+        const lruMap = {};
+        const results = await Promise.allSettled(ids.map((id) => this.kv.get(this.lruKey(id))));
+        results.forEach((r, i) => {
+            lruMap[ids[i]] = r.status === 'fulfilled' ? (r.value?.ts ?? 0) : 0;
+        });
+        return lruMap;
+    }
+    /** Fire-and-forget LRU timestamp update for a single channel */
+    updateLru(relayerId) {
+        this.kv.set(this.lruKey(relayerId), { ts: Date.now() }, { ttlSec: constants_1.POOL.LRU_KEY_TTL_SECONDS }).catch((err) => {
+            console.debug('[channels] failed to update LRU key', err);
+        });
     }
     async getRelayerIdsFromKV() {
         try {
@@ -232,8 +228,9 @@ function simpleHash(str) {
  */
 function filterChannelsForLimitedContract(ids, ratio) {
     const k = Math.max(1, Math.floor(ratio * ids.length));
+    const hashes = new Map(ids.map((id) => [id, simpleHash(id)]));
     return ids
         .slice()
-        .sort((a, b) => simpleHash(a) - simpleHash(b) || a.localeCompare(b))
+        .sort((a, b) => hashes.get(a) - hashes.get(b) || a.localeCompare(b))
         .slice(0, k);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/relayer-plugin-channels",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "OpenZeppelin Relayer Plugin for Stellar Channel Accounts",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",