@openzeppelin/relayer-plugin-channels 0.2.0

package/dist/pool.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * pool.ts
+ *
+ * KV-backed, stateless channel pool.
+ * - Membership comes from KV: <network>:channel:relayer-ids
+ * - Per-relayer locks with tokens: <network>:channel:in-use:<relayerId>
+ * - Uses a short global mutex to make acquire atomic across workers.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelPool = void 0;
+const relayer_sdk_1 = require("@openzeppelin/relayer-sdk");
+const crypto_1 = __importDefault(require("crypto"));
+const config_1 = require("./config");
+const constants_1 = require("./constants");
+class ChannelPool {
+    constructor(network, kv) {
+        this.network = network;
+        this.kv = kv;
+        this.globalLockKey = `${this.network}:channel-pool-lock`;
+        this.channelLockTtlSec = (0, config_1.getLockTtlSeconds)();
+        this.mutexTtlSec = constants_1.POOL.MUTEX_TTL_SECONDS;
+    }
+    /** Acquire a relayerId with a token lock */
+    async acquire() {
+        const maxSpins = constants_1.POOL.MUTEX_MAX_SPINS;
+        for (let i = 0; i < maxSpins; i++) {
+            const r = await this.withGlobalMutex(() => this.tryLockAnyRelayer());
+            if (r === null) {
+                const jitter = constants_1.POOL.MUTEX_RETRY_MIN_MS +
+                    Math.floor(Math.random() *
+                        (constants_1.POOL.MUTEX_RETRY_MAX_MS - constants_1.POOL.MUTEX_RETRY_MIN_MS + 1));
+                await sleep(jitter);
+                continue;
+            }
+            return r;
+        }
+        throw (0, relayer_sdk_1.pluginError)("Too many transactions queued. Please try again later", {
+            code: "POOL_CAPACITY",
+            status: constants_1.HTTP_STATUS.SERVICE_UNAVAILABLE,
+        });
+    }
+    // Run a function under the short-lived global mutex; returns null if busy
+    async withGlobalMutex(fn) {
+        const r = (await this.kv.withLock(this.globalLockKey, fn, {
+            ttlSec: this.mutexTtlSec,
+            onBusy: "skip",
+        }));
+        return r;
+    }
+    // Inside the mutex: pick an available relayer and set its channel lock
+    async tryLockAnyRelayer() {
+        const 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,
+            });
+        }
+        shuffle(ids);
+        for (const relayerId of ids) {
+            const key = this.lockKey(relayerId);
+            const exists = await this.kv.exists(key);
+            if (exists)
+                continue;
+            const token = randomToken();
+            const entry = { token, lockedAt: new Date().toISOString() };
+            await this.kv.set(key, entry, { ttlSec: this.channelLockTtlSec });
+            return { relayerId, token };
+        }
+        return null;
+    }
+    /** Release the lock if we own it */
+    async release(lock) {
+        try {
+            const key = this.lockKey(lock.relayerId);
+            const current = await this.kv.get(key);
+            if (current?.token === lock.token) {
+                await this.kv.del(key);
+            }
+        }
+        catch {
+            // ignore release errors
+        }
+    }
+    membershipKey() {
+        return `${this.network}:channel:relayer-ids`;
+    }
+    lockKey(relayerId) {
+        return `${this.network}:channel:in-use:${relayerId}`;
+    }
+    async getRelayerIdsFromKV() {
+        try {
+            const doc = await this.kv.get(this.membershipKey());
+            if (!doc || !Array.isArray(doc.relayerIds))
+                return [];
+            // Normalize and unique
+            const set = new Set(doc.relayerIds.map(normalizeId));
+            return Array.from(set.values());
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.ChannelPool = ChannelPool;
+function shuffle(arr) {
+    for (let i = arr.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+}
+function randomToken() {
+    try {
+        return crypto_1.default.randomBytes(16).toString("hex");
+    }
+    catch {
+        return (Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2));
+    }
+}
+function normalizeId(id) {
+    return String(id).trim().toLowerCase();
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/simulation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * simulation.ts
+ *
+ * Build and simulate a Soroban transaction using a channel account as the source
+ * and the fund account as the operation source. Returns an unsigned inner
+ * transaction with sorobanData and correct fee set to the resource fee.
+ */
+import { SorobanRpc, Transaction, xdr } from "@stellar/stellar-sdk";
+export interface ChannelAccount {
+    address: string;
+    sequence: string;
+}
+export declare function simulateAndBuildWithChannel(func: xdr.HostFunction, auth: xdr.SorobanAuthorizationEntry[] | undefined, channel: ChannelAccount, _fundAddress: string, rpc: SorobanRpc.Server, networkPassphrase: string): Promise<Transaction>;
+//# sourceMappingURL=simulation.d.ts.map

package/dist/simulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation.d.ts","sourceRoot":"","sources":["../src/simulation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAGL,UAAU,EACV,WAAW,EAEX,GAAG,EACJ,MAAM,sBAAsB,CAAC;AAI9B,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,GAAG,CAAC,YAAY,EACtB,IAAI,EAAE,GAAG,CAAC,yBAAyB,EAAE,GAAG,SAAS,EACjD,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,UAAU,CAAC,MAAM,EACtB,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC,WAAW,CAAC,CA8CtB"}

package/dist/simulation.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * simulation.ts
+ *
+ * Build and simulate a Soroban transaction using a channel account as the source
+ * and the fund account as the operation source. Returns an unsigned inner
+ * transaction with sorobanData and correct fee set to the resource fee.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateAndBuildWithChannel = simulateAndBuildWithChannel;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const relayer_sdk_1 = require("@openzeppelin/relayer-sdk");
+const constants_1 = require("./constants");
+async function simulateAndBuildWithChannel(func, auth, channel, _fundAddress, rpc, networkPassphrase) {
+    const now = Math.floor(Date.now() / 1000);
+    console.debug(`[channels] Building tx: channel=${channel.address}, seq=${channel.sequence}, auth_count=${auth?.length ?? 0}`);
+    // Build inner transaction (source = channel, op source = fund)
+    const transaction = new stellar_sdk_1.TransactionBuilder(new stellar_sdk_1.Account(channel.address, channel.sequence), {
+        fee: constants_1.SIMULATION.DEFAULT_FEE,
+        networkPassphrase,
+        timebounds: {
+            minTime: constants_1.SIMULATION.MIN_TIME_BOUND,
+            maxTime: now + constants_1.SIMULATION.MAX_TIME_BOUND_OFFSET_SECONDS,
+        },
+    })
+        .addOperation(stellar_sdk_1.Operation.invokeHostFunction({
+        func,
+        auth,
+        // No explicit source: default to transaction source (channel account)
+    }))
+        .build();
+    // Prepare transaction (attaches sorobanData/resources, preserves provided auth)
+    try {
+        const prepared = await rpc.prepareTransaction(transaction);
+        const resourceFee = prepared
+            .toEnvelope()
+            .v1()
+            .tx()
+            .ext()
+            .sorobanData()
+            ?.resourceFee();
+        console.debug(`[channels] Simulation complete: resourceFee=${resourceFee}`);
+        return prepared;
+    }
+    catch (e) {
+        throw (0, relayer_sdk_1.pluginError)("Simulation failed", {
+            code: "SIMULATION_FAILED",
+            status: constants_1.HTTP_STATUS.BAD_REQUEST,
+            details: { error: e instanceof Error ? e.message : String(e) },
+        });
+    }
+}

package/dist/submit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * submit.ts
+ *
+ * Signing and submission logic for channel account transactions.
+ */
+import { Transaction } from "@stellar/stellar-sdk";
+import { Relayer, PluginAPI } from "@openzeppelin/relayer-sdk";
+import { ChannelAccountsResponse } from "./types";
+/**
+ * Sign transaction with both channel and fund relayers
+ * - First sign with channel account
+ * - Then sign with fund account
+ * - Both signatures are added to the transaction
+ */
+export declare function signWithChannelAndFund(transaction: Transaction, channelRelayer: Relayer, _fundRelayer: Relayer, channelAddress: string, _fundAddress: string, networkPassphrase: string): Promise<Transaction>;
+/**
+ * Submit transaction with fee bump and wait for confirmation
+ */
+export declare function submitWithFeeBumpAndWait(fundRelayer: Relayer, signedXdr: string, network: "testnet" | "mainnet", maxFee: number, api: PluginAPI): Promise<ChannelAccountsResponse>;
+//# sourceMappingURL=submit.d.ts.map

package/dist/submit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit.d.ts","sourceRoot":"","sources":["../src/submit.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAEL,OAAO,EAGP,SAAS,EACV,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,OAAO,EACvB,YAAY,EAAE,OAAO,EACrB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC,WAAW,CAAC,CA2BtB;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,GAAG,SAAS,EAC9B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,uBAAuB,CAAC,CAwDlC"}

package/dist/submit.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * submit.ts
+ *
+ * Signing and submission logic for channel account transactions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signWithChannelAndFund = signWithChannelAndFund;
+exports.submitWithFeeBumpAndWait = submitWithFeeBumpAndWait;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const relayer_sdk_1 = require("@openzeppelin/relayer-sdk");
+const constants_1 = require("./constants");
+/**
+ * Sign transaction with both channel and fund relayers
+ * - First sign with channel account
+ * - Then sign with fund account
+ * - Both signatures are added to the transaction
+ */
+async function signWithChannelAndFund(transaction, channelRelayer, _fundRelayer, channelAddress, _fundAddress, networkPassphrase) {
+    const txXdr = transaction.toXDR();
+    console.debug(`[channels] Signing transaction with channel (${channelAddress})`);
+    // Get signatures from both accounts sequentially
+    // Channel signs first
+    const channelSignResult = await channelRelayer.signTransaction({
+        unsigned_xdr: txXdr,
+    });
+    if (!isSignTransactionResponseStellar(channelSignResult)) {
+        throw (0, relayer_sdk_1.pluginError)("Invalid channel signature response", {
+            code: "INVALID_SIGNATURE",
+            status: constants_1.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+        });
+    }
+    // Add both signatures to the transaction
+    const signedTx = new stellar_sdk_1.Transaction(txXdr, networkPassphrase);
+    signedTx.addSignature(channelAddress, channelSignResult.signature);
+    console.debug(`[channels] Transaction signed: ${signedTx.signatures.length} signature(s) added`);
+    return signedTx;
+}
+/**
+ * Submit transaction with fee bump and wait for confirmation
+ */
+async function submitWithFeeBumpAndWait(fundRelayer, signedXdr, network, maxFee, api) {
+    // Submit with fee bump
+    console.debug(`[channels] Sending fee bump tx: network=${network}, maxFee=${maxFee}, xdr_len=${signedXdr.length}`);
+    const payload = {
+        network,
+        transaction_xdr: signedXdr,
+        fee_bump: true,
+        max_fee: maxFee,
+    };
+    console.debug(`[channels] Relayer payload: ${JSON.stringify(payload)}`);
+    const submission = await fundRelayer.sendTransaction(payload);
+    // Wait for confirmation
+    try {
+        const final = (await api.transactionWait(submission, {
+            interval: 500,
+            timeout: 25000,
+        }));
+        // Check if transaction actually succeeded
+        if (final.status === "failed") {
+            throw (0, relayer_sdk_1.pluginError)(final.status_reason || "Transaction failed", {
+                code: "ONCHAIN_FAILED",
+                status: constants_1.HTTP_STATUS.BAD_REQUEST,
+                details: {
+                    status: String(final.status),
+                    reason: final.status_reason ?? null,
+                    id: final.id,
+                    hash: final.hash ?? null,
+                },
+            });
+        }
+        return {
+            transactionId: final.id,
+            status: final.status,
+            hash: final.hash ?? null,
+        };
+    }
+    catch (error) {
+        // If it's already a pluginError with ONCHAIN_FAILED, rethrow it
+        if (error.code === "ONCHAIN_FAILED") {
+            throw error;
+        }
+        // Otherwise, it's a timeout
+        throw (0, relayer_sdk_1.pluginError)("Transaction wait timeout. It may still submit.", {
+            code: "WAIT_TIMEOUT",
+            status: constants_1.HTTP_STATUS.GATEWAY_TIMEOUT,
+            details: {
+                id: submission.id,
+                hash: submission.hash ?? null,
+            },
+        });
+    }
+}
+/**
+ * Type guard for SignTransactionResponseStellar
+ */
+function isSignTransactionResponseStellar(data) {
+    return (data !== null &&
+        typeof data === "object" &&
+        "signature" in data &&
+        "signedXdr" in data);
+}

package/dist/test/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/test/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../../src/test/config.test.ts"],"names":[],"mappings":""}

package/dist/test/config.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const config_1 = require("../config");
+const env = process.env;
+(0, vitest_1.describe)("config", () => {
+    (0, vitest_1.beforeEach)(() => {
+        process.env = { ...env };
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.env = env;
+    });
+    (0, vitest_1.test)("loadConfig reads required env", () => {
+        process.env.STELLAR_NETWORK = "testnet";
+        process.env.SOROBAN_RPC_URL = "http://localhost:9999";
+        process.env.FUND_RELAYER_ID = "fund-relayer";
+        const cfg = (0, config_1.loadConfig)();
+        (0, vitest_1.expect)(cfg.network).toBe("testnet");
+        (0, vitest_1.expect)(cfg.rpcUrl).toBe("http://localhost:9999");
+        (0, vitest_1.expect)(cfg.fundRelayerId).toBe("fund-relayer");
+    });
+    (0, vitest_1.test)("network passphrase", () => {
+        (0, vitest_1.expect)((0, config_1.getNetworkPassphrase)("testnet")).toBe(stellar_sdk_1.Networks.TESTNET);
+        (0, vitest_1.expect)((0, config_1.getNetworkPassphrase)("mainnet")).toBe(stellar_sdk_1.Networks.PUBLIC);
+    });
+    (0, vitest_1.test)("lock ttl bounds", () => {
+        delete process.env.LOCK_TTL_SECONDS;
+        (0, vitest_1.expect)((0, config_1.getLockTtlSeconds)()).toBe(30);
+        process.env.LOCK_TTL_SECONDS = "5";
+        (0, vitest_1.expect)((0, config_1.getLockTtlSeconds)()).toBe(30);
+        process.env.LOCK_TTL_SECONDS = "10";
+        (0, vitest_1.expect)((0, config_1.getLockTtlSeconds)()).toBe(10);
+        process.env.LOCK_TTL_SECONDS = "29";
+        (0, vitest_1.expect)((0, config_1.getLockTtlSeconds)()).toBe(29);
+    });
+    (0, vitest_1.test)("max fee env", () => {
+        delete process.env.MAX_FEE;
+        (0, vitest_1.expect)(typeof (0, config_1.getMaxFee)()).toBe("number");
+        process.env.MAX_FEE = "12345";
+        (0, vitest_1.expect)((0, config_1.getMaxFee)()).toBe(12345);
+    });
+});

package/dist/test/fee.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fee.test.d.ts.map

package/dist/test/fee.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee.test.d.ts","sourceRoot":"","sources":["../../src/test/fee.test.ts"],"names":[],"mappings":""}

package/dist/test/fee.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fee_1 = require("../fee");
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+(0, vitest_1.describe)("fee", () => {
+    const passphrase = stellar_sdk_1.Networks.TESTNET;
+    function buildSimpleTx() {
+        const acc = new stellar_sdk_1.Account("GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF", "1");
+        return new stellar_sdk_1.TransactionBuilder(acc, {
+            fee: "100",
+            networkPassphrase: passphrase,
+        })
+            .setTimeout(30)
+            .build();
+    }
+    (0, vitest_1.test)("non-soroban uses offset + base", () => {
+        const orig = Math.random;
+        Math.random = () => 0; // pick min base fee
+        const tx = buildSimpleTx();
+        const fee = (0, fee_1.calculateMaxFee)(tx);
+        (0, vitest_1.expect)(typeof fee).toBe("number");
+        (0, vitest_1.expect)(fee).toBeGreaterThan(0);
+        Math.random = orig;
+    });
+    (0, vitest_1.test)("clamps to MAX_FEE when set", () => {
+        const tx = buildSimpleTx();
+        const old = process.env.MAX_FEE;
+        process.env.MAX_FEE = "1000";
+        const fee = (0, fee_1.calculateMaxFee)(tx);
+        (0, vitest_1.expect)(fee).toBeLessThanOrEqual(1000);
+        process.env.MAX_FEE = old;
+    });
+});

package/dist/test/helpers/fakeKV.d.ts

@@ -0,0 +1,17 @@
+import type { PluginKVStore } from "@openzeppelin/relayer-sdk";
+export declare class FakeKV implements PluginKVStore {
+    private store;
+    get<T = any>(key: string): Promise<T | null>;
+    set(key: string, value: any, opts?: {
+        ttlSec?: number;
+    }): Promise<boolean>;
+    del(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    withLock<T>(key: string, fn: () => Promise<T>, opts?: {
+        ttlSec?: number;
+        onBusy?: "throw" | "skip";
+    }): Promise<T | null>;
+    listKeys(_pattern?: string): Promise<string[]>;
+    clear(): Promise<number>;
+}
+//# sourceMappingURL=fakeKV.d.ts.map

package/dist/test/helpers/fakeKV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeKV.d.ts","sourceRoot":"","sources":["../../../src/test/helpers/fakeKV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI/D,qBAAa,MAAO,YAAW,aAAa;IAC1C,OAAO,CAAC,KAAK,CAA4B;IAEnC,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAW5C,GAAG,CACP,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,GAAG,EACV,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GACzB,OAAO,CAAC,OAAO,CAAC;IASb,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKrC,QAAQ,CAAC,CAAC,EACd,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAE,GACpD,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAgBd,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAI9C,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAK/B"}

package/dist/test/helpers/fakeKV.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeKV = void 0;
+class FakeKV {
+    constructor() {
+        this.store = new Map();
+    }
+    async get(key) {
+        const now = Date.now();
+        const e = this.store.get(key);
+        if (!e)
+            return null;
+        if (e.expiresAt && e.expiresAt <= now) {
+            this.store.delete(key);
+            return null;
+        }
+        return e.value;
+    }
+    async set(key, value, opts) {
+        const entry = { value };
+        if (opts?.ttlSec && opts.ttlSec > 0) {
+            entry.expiresAt = Date.now() + opts.ttlSec * 1000;
+        }
+        this.store.set(key, entry);
+        return true;
+    }
+    async del(key) {
+        return this.store.delete(key);
+    }
+    async exists(key) {
+        const v = await this.get(key);
+        return v !== null && v !== undefined;
+    }
+    async withLock(key, fn, opts) {
+        // Simple, non-reentrant lock for testing; not robust
+        if (await this.exists(key)) {
+            if (opts?.onBusy === "skip")
+                return null;
+            throw new Error("lock busy");
+        }
+        // Respect requested TTL to better emulate production behavior
+        const ttl = opts?.ttlSec && opts.ttlSec > 0 ? opts.ttlSec : 1;
+        await this.set(key, { token: "lock" }, { ttlSec: ttl });
+        try {
+            return await fn();
+        }
+        finally {
+            await this.del(key);
+        }
+    }
+    async listKeys(_pattern) {
+        return Array.from(this.store.keys());
+    }
+    async clear() {
+        const n = this.store.size;
+        this.store.clear();
+        return n;
+    }
+}
+exports.FakeKV = FakeKV;

package/dist/test/management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=management.test.d.ts.map

package/dist/test/management.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"management.test.d.ts","sourceRoot":"","sources":["../../src/test/management.test.ts"],"names":[],"mappings":""}

package/dist/test/management.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const management_1 = require("../management");
+const fakeKV_1 = require("./helpers/fakeKV");
+(0, vitest_1.describe)("management", () => {
+    const OLD_ENV = process.env;
+    (0, vitest_1.beforeEach)(() => {
+        process.env = { ...OLD_ENV };
+        process.env.PLUGIN_ADMIN_SECRET = "test";
+        process.env.STELLAR_NETWORK = "testnet";
+        process.env.SOROBAN_RPC_URL = "http://localhost:9999";
+        process.env.FUND_RELAYER_ID = "fund";
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.env = OLD_ENV;
+    });
+    (0, vitest_1.test)("isManagementRequest detects shape", () => {
+        (0, vitest_1.expect)((0, management_1.isManagementRequest)({ management: {} })).toBe(true);
+        (0, vitest_1.expect)((0, management_1.isManagementRequest)({})).toBe(false);
+    });
+    (0, vitest_1.test)("list and set channel accounts", async () => {
+        const kv = new fakeKV_1.FakeKV();
+        const ctx = {
+            kv,
+            params: {
+                management: { adminSecret: "test", action: "listChannelAccounts" },
+            },
+        };
+        const list1 = await (0, management_1.handleManagement)(ctx);
+        (0, vitest_1.expect)(Array.isArray(list1.relayerIds)).toBe(true);
+        const ctxSet = {
+            kv,
+            params: {
+                management: {
+                    adminSecret: "test",
+                    action: "setChannelAccounts",
+                    relayerIds: ["A", "B"],
+                },
+            },
+        };
+        const set = await (0, management_1.handleManagement)(ctxSet);
+        (0, vitest_1.expect)(set.ok).toBe(true);
+        (0, vitest_1.expect)(set.appliedRelayerIds).toEqual(["a", "b"]);
+        const list2 = await (0, management_1.handleManagement)(ctx);
+        (0, vitest_1.expect)(list2.relayerIds).toEqual(["a", "b"]);
+    });
+    (0, vitest_1.test)("locked conflict on removal", async () => {
+        const kv = new fakeKV_1.FakeKV();
+        // Seed list
+        await kv.set("testnet:channel:relayer-ids", { relayerIds: ["a", "b"] });
+        // Simulate lock on 'b'
+        await kv.set("testnet:channel:in-use:b", { token: "t" });
+        const ctx = {
+            kv,
+            params: {
+                management: {
+                    adminSecret: "test",
+                    action: "setChannelAccounts",
+                    relayerIds: ["a"],
+                },
+            },
+        };
+        await (0, vitest_1.expect)((0, management_1.handleManagement)(ctx)).rejects.toThrow("Locked relayer IDs cannot be removed");
+    });
+});

package/dist/test/pool.busy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pool.busy.test.d.ts.map

package/dist/test/pool.busy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.busy.test.d.ts","sourceRoot":"","sources":["../../src/test/pool.busy.test.ts"],"names":[],"mappings":""}

package/dist/test/pool.busy.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const pool_1 = require("../pool");
+const fakeKV_1 = require("./helpers/fakeKV");
+(0, vitest_1.describe)("ChannelPool busy mutex", () => {
+    (0, vitest_1.test)("acquire retries when global mutex is busy, then succeeds", async () => {
+        const kv = new fakeKV_1.FakeKV();
+        const pool = new pool_1.ChannelPool("testnet", kv);
+        // Configure a single relayer
+        await kv.set("testnet:channel:relayer-ids", { relayerIds: ["p1"] });
+        // Simulate busy global mutex briefly, then release
+        const globalKey = "testnet:channel-pool-lock";
+        await kv.set(globalKey, { token: "busy" });
+        setTimeout(() => {
+            void kv.del(globalKey);
+        }, 50);
+        const lock = await pool.acquire();
+        (0, vitest_1.expect)(lock.relayerId).toBe("p1");
+        // Release for cleanliness
+        await pool.release(lock);
+    });
+});

package/dist/test/pool.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pool.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pool.test.d.ts","sourceRoot":"","sources":["../../src/test/pool.test.ts"],"names":[],"mappings":""}

package/dist/test/pool.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const pool_1 = require("../pool");
+const fakeKV_1 = require("./helpers/fakeKV");
+(0, vitest_1.describe)("ChannelPool", () => {
+    (0, vitest_1.test)("acquire distributes and release removes lock", async () => {
+        const kv = new fakeKV_1.FakeKV();
+        const pool = new pool_1.ChannelPool("testnet", kv);
+        await kv.set("testnet:channel:relayer-ids", { relayerIds: ["p1", "p2"] });
+        const l1 = await pool.acquire();
+        const l2 = await pool.acquire();
+        (0, vitest_1.expect)(["p1", "p2"]).toContain(l1.relayerId);
+        (0, vitest_1.expect)(["p1", "p2"]).toContain(l2.relayerId);
+        (0, vitest_1.expect)(l1.relayerId).not.toEqual(l2.relayerId);
+        // Next acquire should fail (both locked)
+        await (0, vitest_1.expect)(pool.acquire()).rejects.toThrow("Too many transactions queued");
+        // Release one and ensure lock key gone
+        await pool.release(l1);
+        const stillLocked = await kv.exists(`testnet:channel:in-use:${l1.relayerId}`);
+        (0, vitest_1.expect)(stillLocked).toBe(false);
+    });
+    (0, vitest_1.test)("acquire fails on empty membership", async () => {
+        const kv = new fakeKV_1.FakeKV();
+        const pool = new pool_1.ChannelPool("testnet", kv);
+        await kv.set("testnet:channel:relayer-ids", { relayerIds: [] });
+        await (0, vitest_1.expect)(pool.acquire()).rejects.toThrow("No channel accounts configured");
+    });
+});

package/dist/test/tx.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tx.test.d.ts.map

package/dist/test/tx.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx.test.d.ts","sourceRoot":"","sources":["../../src/test/tx.test.ts"],"names":[],"mappings":""}