class SequentialTxQueue {
  private queue = [];
  private processing = false;

  enqueue(txFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ txFn, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.processing || this.queue.length === 0) return;
    this.processing = true;
    const { txFn, resolve, reject } = this.queue.shift();
    try {
      const hash = await txFn();
      resolve(hash);
    } catch (error) {
      reject(error);
    } finally {
      this.processing = false;
      this.processQueue();
    }
  }
}

class WalletPool {
  private wallets = [];

  async acquire() {
    const available = this.wallets.find(w => !w.busy);
    if (available) {
      available.busy = true;
      return available;
    }
    return new Promise(resolve => this.waitQueue.push({ resolve }));
  }

  async release(instance) {
    await this.waitForWalletSync(instance.wallet);
    instance.busy = false;
  }
}

async function submitWithRetry(wallet, buildTx, config = { maxRetries: 3 }) {
  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
    try {
      await wallet.waitForSync();
      const recipe = await buildTx();
      const proven = await wallet.proveTransaction(recipe);
      return await wallet.submitTransaction(proven);
    } catch (error) {
      if (!isUtxoError(error) || attempt === config.maxRetries) throw error;
      await sleep(Math.min(1000 * 2**attempt, 10000));
    }
  }
}