@hyperbridge/sdk 1.8.8 → 1.9.1

package/dist/browser/index.js

@@ -606,7 +606,6 @@ var IntentOrderStatus = Object.freeze({
   AWAITING_BIDS: "AWAITING_BIDS",
   BIDS_RECEIVED: "BIDS_RECEIVED",
   BID_SELECTED: "BID_SELECTED",
-  USEROP_SUBMITTED: "USEROP_SUBMITTED",
   FILLED: "FILLED",
   PARTIAL_FILL: "PARTIAL_FILL",
   EXPIRED: "EXPIRED",
@@ -5583,6 +5582,7 @@ var EvmChain = class _EvmChain {
     });
     this.chainConfigService = new ChainConfigService();
   }
+  params;
   publicClient;
   chainConfigService;
   /**
@@ -6183,6 +6183,7 @@ var HttpRpcClient = class {
   constructor(url) {
     this.url = url;
   }
+  url;
   /**
    * Make an RPC call over HTTP
    * @param method - The RPC method name
@@ -6220,6 +6221,7 @@ var SubstrateChain = class _SubstrateChain {
     const httpUrl = replaceWebsocketWithHttp(url);
     this.rpcClient = new HttpRpcClient(httpUrl);
   }
+  params;
   /*
    * api: The Polkadot API instance for the Substrate chain.
    */
@@ -6737,6 +6739,9 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     this.substratePrivateKey = substratePrivateKey;
     this.ownsConnection = ownsConnection;
   }
+  api;
+  substratePrivateKey;
+  ownsConnection;
   /** Cached result of whether the node exposes intents_* RPC methods */
   hasIntentsRpc = null;
   /**
@@ -7014,6 +7019,7 @@ var TronChain = class _TronChain {
     this.evm = evm;
     this.tronWebInstance = new TronWeb({ fullHost: params.rpcUrl });
   }
+  params;
   evm;
   tronWebInstance;
   /**
@@ -7554,6 +7560,7 @@ var SubstrateHttpRpc = class {
   constructor(url) {
     this.url = url;
   }
+  url;
   async call(method, params = []) {
     const body = JSON.stringify({
       jsonrpc: "2.0",
@@ -7598,6 +7605,7 @@ var PolkadotHubChain = class _PolkadotHubChain {
     this.evm = evm;
     this.substrateRpc = new SubstrateHttpRpc(replaceWebsocketWithHttp(params.substrateRpcUrl));
   }
+  params;
   evm;
   substrateRpc;
   static fromParams(params) {
@@ -12689,6 +12697,7 @@ var CryptoUtils = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   /**
    * Computes an EIP-712 domain separator for a given contract.
    *
@@ -15224,6 +15233,7 @@ var OrderPlacer = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   /**
    * Bidirectional async generator that orchestrates order placement.
    *
@@ -15301,67 +15311,40 @@ var OrderPlacer = class {
     return { order, receipt };
   }
 };
-
-// src/protocols/intents/OrderExecutor.ts
 var USED_USEROPS_STORAGE_KEY = (commitment) => `used-userops:${commitment.toLowerCase()}`;
 var OrderExecutor = class {
-  /**
-   * @param ctx - Shared IntentsV2 context providing the destination chain
-   *   client, coprocessor, bundler URL, and storage adapters.
-   * @param bidManager - Handles bid validation, sorting, simulation, and
-   *   UserOperation submission.
-   * @param crypto - Crypto utilities used to compute UserOperation hashes for
-   *   deduplication.
-   */
   constructor(ctx, bidManager, crypto) {
     this.ctx = ctx;
     this.bidManager = bidManager;
     this.crypto = crypto;
   }
+  ctx;
+  bidManager;
+  crypto;
   /**
-   * Async generator that executes an intent order by polling for bids and
-   * submitting UserOperations until the order is filled, partially exhausted,
-   * or an unrecoverable error occurs.
-   *
-   * **Status progression (cross-chain orders):**
-   * `AWAITING_BIDS` → `BIDS_RECEIVED` → `BID_SELECTED` → `USEROP_SUBMITTED`
-   * then terminates (settlement is confirmed off-chain via Hyperbridge).
-   *
-   * **Status progression (same-chain orders):**
-   * `AWAITING_BIDS` → `BIDS_RECEIVED` → `BID_SELECTED` → `USEROP_SUBMITTED`
-   * → (`FILLED` | `PARTIAL_FILL`)* → (`FILLED` | `EXPIRED`)
-   *
-   * **Error statuses:** `FAILED` (retryable error during bid selection/submission,
-   * triggers automatic retry) or `EXPIRED` (deadline reached or no new bids —
-   * terminal, no further retries).
-   *
-   * @param options - Execution parameters including the placed order, its
-   *   session private key, bid collection settings, and poll interval.
-   * @yields {@link IntentOrderStatusUpdate} objects describing each stage.
-   * @throws Never throws directly; all errors are reported as `FAILED` yields.
+   * Sleeps until the order's block deadline is reached, then yields EXPIRED.
+   * Uses the chain's block time to calculate the sleep duration.
    */
-  async *executeIntentOrder(options) {
-    const {
-      order,
-      sessionPrivateKey,
-      minBids = 1,
-      bidTimeoutMs = 6e4,
-      pollIntervalMs = DEFAULT_POLL_INTERVAL,
-      solver
-    } = options;
-    const commitment = order.id;
-    const isSameChain = order.source === order.destination;
-    if (!this.ctx.intentsCoprocessor) {
-      yield { status: "FAILED", error: "IntentsCoprocessor required for order execution" };
-      return;
-    }
-    if (!this.ctx.bundlerUrl) {
-      yield { status: "FAILED", error: "Bundler URL not configured" };
-      return;
+  async *deadlineStream(deadline, commitment) {
+    const client = this.ctx.dest.client;
+    const blockTimeMs = client.chain?.blockTime ?? 2e3;
+    while (true) {
+      const currentBlock = await client.getBlockNumber();
+      if (currentBlock >= deadline) break;
+      const blocksRemaining = Number(deadline - currentBlock);
+      const sleepMs = blocksRemaining * blockTimeMs;
+      await sleep(sleepMs);
     }
+    yield {
+      status: "EXPIRED",
+      commitment,
+      error: "Order deadline reached"
+    };
+  }
+  /** Loads the persisted deduplication set of already-submitted UserOp hashes for a given order commitment. */
+  async loadUsedUserOps(commitment) {
     const usedUserOps = /* @__PURE__ */ new Set();
-    const storageKey = USED_USEROPS_STORAGE_KEY(commitment);
-    const persisted = await this.ctx.usedUserOpsStorage.getItem(storageKey);
+    const persisted = await this.ctx.usedUserOpsStorage.getItem(USED_USEROPS_STORAGE_KEY(commitment));
     if (persisted) {
       try {
         const parsed = JSON.parse(persisted);
@@ -15371,74 +15354,214 @@ var OrderExecutor = class {
       } catch {
       }
     }
-    const persistUsedUserOps = async () => {
-      await this.ctx.usedUserOpsStorage.setItem(storageKey, JSON.stringify([...usedUserOps]));
-    };
+    return usedUserOps;
+  }
+  /** Persists the deduplication set of UserOp hashes to storage. */
+  async persistUsedUserOps(commitment, usedUserOps) {
+    await this.ctx.usedUserOpsStorage.setItem(
+      USED_USEROPS_STORAGE_KEY(commitment),
+      JSON.stringify([...usedUserOps])
+    );
+  }
+  /**
+   * Creates a closure that computes the deduplication hash key for a
+   * UserOperation, pre-bound to the order's destination chain and entry point.
+   */
+  createUserOpHasher(order) {
     const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(hexToString(order.destination));
     const chainId = BigInt(
       this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
     );
-    const userOpHashKey = (userOp) => this.crypto.computeUserOpHash(userOp, entryPointAddress, chainId);
+    return (userOp) => this.crypto.computeUserOpHash(userOp, entryPointAddress, chainId);
+  }
+  /**
+   * Fetches bids from the coprocessor for a given order commitment.
+   * If a preferred solver is configured and the solver lock has not expired,
+   * only bids from that solver are returned.
+   */
+  async fetchBids(params) {
+    const { commitment, solver, solverLockStartTime } = params;
+    const fetchedBids = await this.ctx.intentsCoprocessor.getBidsForOrder(commitment);
+    if (solver) {
+      const { address, timeoutMs } = solver;
+      const solverLockActive = Date.now() - solverLockStartTime < timeoutMs;
+      return solverLockActive ? fetchedBids.filter((bid) => bid.userOp.sender.toLowerCase() === address.toLowerCase()) : fetchedBids;
+    }
+    return fetchedBids;
+  }
+  /**
+   * Selects the best bid from the provided candidates, submits the
+   * UserOperation, and persists the dedup entry to prevent resubmission.
+   */
+  async submitBid(params) {
+    const { order, freshBids, sessionPrivateKey, commitment, usedUserOps, userOpHashKey } = params;
+    const result = await this.bidManager.selectBid(order, freshBids, sessionPrivateKey);
+    usedUserOps.add(userOpHashKey(result.userOp));
+    await this.persistUsedUserOps(commitment, usedUserOps);
+    return result;
+  }
+  /**
+   * Processes a fill result and returns updated fill accumulators,
+   * the status update to yield (if any), and whether the order is
+   * fully satisfied.
+   */
+  processFillResult(result, commitment, targetAssets, totalFilledAssets, remainingAssets) {
+    if (result.fillStatus === "full") {
+      totalFilledAssets = targetAssets.map((a) => ({ token: a.token, amount: a.amount }));
+      remainingAssets = targetAssets.map((a) => ({ token: a.token, amount: 0n }));
+      return {
+        update: {
+          status: "FILLED",
+          commitment,
+          userOpHash: result.userOpHash,
+          selectedSolver: result.solverAddress,
+          transactionHash: result.txnHash,
+          totalFilledAssets,
+          remainingAssets
+        },
+        done: true,
+        totalFilledAssets,
+        remainingAssets
+      };
+    }
+    if (result.fillStatus === "partial") {
+      const filledAssets = result.filledAssets ?? [];
+      totalFilledAssets = totalFilledAssets.map((a) => {
+        const filled = filledAssets.find((f) => f.token === a.token);
+        return filled ? { token: a.token, amount: a.amount + filled.amount } : { ...a };
+      });
+      remainingAssets = targetAssets.map((target) => {
+        const filled = totalFilledAssets.find((a) => a.token === target.token);
+        const filledAmt = filled?.amount ?? 0n;
+        return {
+          token: target.token,
+          amount: filledAmt >= target.amount ? 0n : target.amount - filledAmt
+        };
+      });
+      const fullyFilled = remainingAssets.every((a) => a.amount === 0n);
+      return {
+        update: fullyFilled ? {
+          status: "FILLED",
+          commitment,
+          userOpHash: result.userOpHash,
+          selectedSolver: result.solverAddress,
+          transactionHash: result.txnHash,
+          totalFilledAssets,
+          remainingAssets
+        } : {
+          status: "PARTIAL_FILL",
+          commitment,
+          userOpHash: result.userOpHash,
+          selectedSolver: result.solverAddress,
+          transactionHash: result.txnHash,
+          filledAssets,
+          totalFilledAssets,
+          remainingAssets
+        },
+        done: fullyFilled,
+        totalFilledAssets,
+        remainingAssets
+      };
+    }
+    return { update: null, done: false, totalFilledAssets, remainingAssets };
+  }
+  /**
+   * Executes an intent order by racing bid polling against the order's
+   * block deadline. Yields status updates at each lifecycle stage.
+   *
+   * **Same-chain:** `AWAITING_BIDS` → `BIDS_RECEIVED` → `BID_SELECTED`
+   *   → (`FILLED` | `PARTIAL_FILL`)* → (`FILLED` | `EXPIRED`)
+   *
+   * **Cross-chain:** `AWAITING_BIDS` → `BIDS_RECEIVED` → `BID_SELECTED`
+   *   (terminates — settlement is confirmed async via Hyperbridge)
+   */
+  async *executeOrder(options) {
+    const { order, sessionPrivateKey, auctionTimeMs, pollIntervalMs = DEFAULT_POLL_INTERVAL, solver } = options;
+    const commitment = order.id;
+    const isSameChain = order.source === order.destination;
+    if (!this.ctx.intentsCoprocessor) {
+      yield { status: "FAILED", error: "IntentsCoprocessor required for order execution" };
+      return;
+    }
+    if (!this.ctx.bundlerUrl) {
+      yield { status: "FAILED", error: "Bundler URL not configured" };
+      return;
+    }
+    const usedUserOps = await this.loadUsedUserOps(commitment);
+    const userOpHashKey = this.createUserOpHasher(order);
     const targetAssets = order.output.assets.map((a) => ({ token: a.token, amount: a.amount }));
     let totalFilledAssets = order.output.assets.map((a) => ({ token: a.token, amount: 0n }));
     let remainingAssets = order.output.assets.map((a) => ({ token: a.token, amount: a.amount }));
+    const executionStream = this.executionStream({
+      order,
+      sessionPrivateKey,
+      commitment,
+      auctionTimeMs,
+      pollIntervalMs,
+      solver,
+      usedUserOps,
+      userOpHashKey,
+      targetAssets,
+      totalFilledAssets,
+      remainingAssets
+    });
+    const deadlineTimeout = this.deadlineStream(order.deadline, commitment);
+    const combined = mergeRace(deadlineTimeout, executionStream);
+    for await (const update of combined) {
+      yield update;
+      if (update.status === "EXPIRED" || update.status === "FILLED") return;
+      if (update.status === "BID_SELECTED" && !isSameChain) return;
+    }
+  }
+  /**
+   * Core execution loop that polls for bids, submits UserOperations,
+   * and tracks fill progress. Yields between each poll iteration so
+   * that `mergeRace` can interleave the deadline stream.
+   */
+  async *executionStream(params) {
+    const {
+      order,
+      sessionPrivateKey,
+      commitment,
+      auctionTimeMs,
+      pollIntervalMs,
+      solver,
+      usedUserOps,
+      userOpHashKey,
+      targetAssets
+    } = params;
+    let { totalFilledAssets, remainingAssets } = params;
+    const solverLockStartTime = Date.now();
+    yield { status: "AWAITING_BIDS", commitment, totalFilledAssets, remainingAssets };
     try {
+      const auctionEnd = Date.now() + auctionTimeMs;
+      while (Date.now() < auctionEnd) {
+        await sleep(Math.min(pollIntervalMs, auctionEnd - Date.now()));
+      }
       while (true) {
-        const currentBlock = await this.ctx.dest.client.getBlockNumber();
-        if (currentBlock >= order.deadline) {
-          const deadlineError = `Order deadline reached (block ${currentBlock} >= ${order.deadline})`;
-          yield {
-            status: "EXPIRED",
-            commitment,
-            totalFilledAssets,
-            remainingAssets,
-            error: deadlineError
-          };
-          return;
-        }
-        yield { status: "AWAITING_BIDS", commitment, totalFilledAssets, remainingAssets };
-        const startTime = Date.now();
-        let bids = [];
-        let solverLockExpired = false;
-        while (Date.now() - startTime < bidTimeoutMs) {
-          try {
-            const fetchedBids = await this.ctx.intentsCoprocessor.getBidsForOrder(commitment);
-            if (solver) {
-              const { address, timeoutMs } = solver;
-              const solverLockActive = Date.now() - startTime < timeoutMs;
-              if (!solverLockActive) solverLockExpired = true;
-              bids = solverLockActive ? fetchedBids.filter((bid) => bid.userOp.sender.toLowerCase() === address.toLowerCase()) : fetchedBids;
-            } else {
-              bids = fetchedBids;
-            }
-            if (bids.length >= minBids) {
-              break;
-            }
-          } catch {
-          }
+        let freshBids;
+        try {
+          const bids = await this.fetchBids({ commitment, solver, solverLockStartTime });
+          freshBids = bids.filter((bid) => !usedUserOps.has(userOpHashKey(bid.userOp)));
+        } catch {
           await sleep(pollIntervalMs);
+          continue;
         }
-        const freshBids = bids.filter((bid) => {
-          const key = userOpHashKey(bid.userOp);
-          return !usedUserOps.has(key);
-        });
         if (freshBids.length === 0) {
-          const solverClause = solver && !solverLockExpired ? ` for requested solver ${solver.address}` : "";
-          const isPartiallyFilled = totalFilledAssets.some((a) => a.amount > 0n);
-          const noBidsError = isPartiallyFilled ? `No new bids${solverClause} after partial fill` : `No new bids${solverClause} available within ${bidTimeoutMs}ms timeout`;
-          yield {
-            status: "EXPIRED",
-            commitment,
-            totalFilledAssets,
-            remainingAssets,
-            error: noBidsError
-          };
-          return;
+          await sleep(pollIntervalMs);
+          continue;
         }
         yield { status: "BIDS_RECEIVED", commitment, bidCount: freshBids.length, bids: freshBids };
-        let result;
+        let submitResult;
         try {
-          result = await this.bidManager.selectBid(order, freshBids, sessionPrivateKey);
+          submitResult = await this.submitBid({
+            order,
+            freshBids,
+            sessionPrivateKey,
+            commitment,
+            usedUserOps,
+            userOpHashKey
+          });
         } catch (err) {
           yield {
             status: "FAILED",
@@ -15450,77 +15573,26 @@ var OrderExecutor = class {
           await sleep(pollIntervalMs);
           continue;
         }
-        const usedKey = userOpHashKey(result.userOp);
-        usedUserOps.add(usedKey);
-        await persistUsedUserOps();
         yield {
           status: "BID_SELECTED",
           commitment,
-          selectedSolver: result.solverAddress,
-          userOpHash: result.userOpHash,
-          userOp: result.userOp
+          selectedSolver: submitResult.solverAddress,
+          userOpHash: submitResult.userOpHash,
+          userOp: submitResult.userOp,
+          transactionHash: submitResult.txnHash
         };
-        yield {
-          status: "USEROP_SUBMITTED",
+        const fill = this.processFillResult(
+          submitResult,
           commitment,
-          userOpHash: result.userOpHash,
-          selectedSolver: result.solverAddress,
-          transactionHash: result.txnHash
-        };
-        if (!isSameChain) {
-          return;
-        }
-        if (result.fillStatus === "full") {
-          totalFilledAssets = targetAssets.map((a) => ({ token: a.token, amount: a.amount }));
-          remainingAssets = targetAssets.map((a) => ({ token: a.token, amount: 0n }));
-          yield {
-            status: "FILLED",
-            commitment,
-            userOpHash: result.userOpHash,
-            selectedSolver: result.solverAddress,
-            transactionHash: result.txnHash,
-            totalFilledAssets,
-            remainingAssets
-          };
-          return;
-        }
-        if (result.fillStatus === "partial") {
-          const filledAssets = result.filledAssets ?? [];
-          for (const filled of filledAssets) {
-            const entry = totalFilledAssets.find((a) => a.token === filled.token);
-            if (entry) entry.amount += filled.amount;
-          }
-          remainingAssets = targetAssets.map((target) => {
-            const filled = totalFilledAssets.find((a) => a.token === target.token);
-            const filledAmt = filled?.amount ?? 0n;
-            return {
-              token: target.token,
-              amount: filledAmt >= target.amount ? 0n : target.amount - filledAmt
-            };
-          });
-          const fullyFilled = remainingAssets.every((a) => a.amount === 0n);
-          if (fullyFilled) {
-            yield {
-              status: "FILLED",
-              commitment,
-              userOpHash: result.userOpHash,
-              selectedSolver: result.solverAddress,
-              transactionHash: result.txnHash,
-              totalFilledAssets,
-              remainingAssets
-            };
-            return;
-          }
-          yield {
-            status: "PARTIAL_FILL",
-            commitment,
-            userOpHash: result.userOpHash,
-            selectedSolver: result.solverAddress,
-            transactionHash: result.txnHash,
-            filledAssets,
-            totalFilledAssets,
-            remainingAssets
-          };
+          targetAssets,
+          totalFilledAssets,
+          remainingAssets
+        );
+        totalFilledAssets = fill.totalFilledAssets;
+        remainingAssets = fill.remainingAssets;
+        if (fill.update) {
+          yield fill.update;
+          if (fill.done) return;
         }
       }
     } catch (err) {
@@ -15540,6 +15612,7 @@ var OrderCanceller = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   /**
    * Returns both the native token cost and the relayer fee for cancelling an
    * order. Frontends can use `relayerFee` to approve the ERC-20 spend before
@@ -16009,6 +16082,8 @@ var BidManager = class {
     this.ctx = ctx;
     this.crypto = crypto;
   }
+  ctx;
+  crypto;
   /**
    * Constructs a signed `PackedUserOperation` that a solver can submit to the
    * Hyperbridge coprocessor as a bid to fill an order.
@@ -18088,6 +18163,8 @@ var GasEstimator = class {
     this.ctx = ctx;
     this.crypto = crypto;
   }
+  ctx;
+  crypto;
   /**
    * Estimates the gas cost for a solver to fill the given order and returns
    * a structured estimate with individual gas components and total costs in
@@ -18509,6 +18586,7 @@ var OrderStatusChecker = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   /**
    * Checks if a V2 order has been filled by reading the commitment storage slot on the destination chain.
    *
@@ -18690,7 +18768,7 @@ var IntentGateway = class _IntentGateway {
    *    The caller must sign the transaction and pass it back via `gen.next(signedTx)`.
    * 3. Yields `ORDER_PLACED` with the finalised order and transaction hash once
    *    the `OrderPlaced` event is confirmed.
-   * 4. Delegates to {@link OrderExecutor.executeIntentOrder} and forwards all
+   * 4. Delegates to {@link OrderExecutor.executeOrder} and forwards all
    *    subsequent status updates until the order is filled, exhausted, or fails.
    *
    * @param order - The order to place and execute. `order.fees` may be 0; it
@@ -18700,8 +18778,7 @@ var IntentGateway = class _IntentGateway {
    * @param options - Optional tuning parameters:
    *   - `maxPriorityFeePerGasBumpPercent` — bump % for the priority fee estimate (default 8).
    *   - `maxFeePerGasBumpPercent` — bump % for the max fee estimate (default 10).
-   *   - `minBids` — minimum bids to collect before selecting (default 1).
-   *   - `bidTimeoutMs` — how long to poll for bids before giving up (default 60 000 ms).
+   *   - `auctionTimeMs` — duration in ms to collect bids before selecting the best one.
    *   - `pollIntervalMs` — interval between bid-polling attempts.
    * @yields {@link IntentOrderStatusUpdate} at each lifecycle stage.
    * @throws If the `placeOrder` generator behaves unexpectedly, or if gas
@@ -18734,18 +18811,63 @@ var IntentGateway = class _IntentGateway {
     }
     const { order: finalizedOrder, receipt: placementReceipt } = placeOrderSecond.value;
     yield { status: "ORDER_PLACED", order: finalizedOrder, receipt: placementReceipt };
-    for await (const status of this.orderExecutor.executeIntentOrder({
+    for await (const status of this.orderExecutor.executeOrder({
       order: finalizedOrder,
       sessionPrivateKey,
-      minBids: options?.minBids,
-      bidTimeoutMs: options?.bidTimeoutMs,
-      pollIntervalMs: options?.pollIntervalMs,
-      solver: options?.solver
+      auctionTimeMs: options.auctionTimeMs,
+      pollIntervalMs: options.pollIntervalMs,
+      solver: options.solver
     })) {
       yield status;
     }
     return;
   }
+  /**
+   * Validates that an order has the minimum fields required for post-placement
+   * resume (i.e. it was previously placed and has an on-chain identity).
+   *
+   * @throws If `order.id` or `order.session` is missing or zero-valued.
+   */
+  assertOrderCanResume(order) {
+    if (!order.id) {
+      throw new Error("Cannot resume execution without order.id");
+    }
+    if (!order.session || order.session === ADDRESS_ZERO2) {
+      throw new Error("Cannot resume execution without order.session");
+    }
+  }
+  /**
+   * Resumes execution of a previously placed order.
+   *
+   * Use this method after an app restart or crash to pick up where
+   * {@link execute} left off. The order must already be placed on-chain
+   * (i.e. it must have a valid `id` and `session`).
+   *
+   * Internally delegates to {@link OrderExecutor.executeOrder} and
+   * yields the same status updates as the execution phase of {@link execute}:
+   * `AWAITING_BIDS`, `BIDS_RECEIVED`, `BID_SELECTED`,
+   * `FILLED`, `PARTIAL_FILL`, `EXPIRED`, or `FAILED`.
+   *
+   * Callers may check {@link isOrderFilled} or {@link isOrderRefunded} before
+   * calling this method to avoid resuming an already-terminal order.
+   *
+   * @param order - A previously placed order with a valid `id` and `session`.
+   * @param options - Optional tuning parameters for bid collection and execution.
+   * @yields {@link IntentOrderStatusUpdate} at each execution stage.
+   * @throws If the order is missing required fields for resumption.
+   */
+  async *resume(order, options) {
+    this.assertOrderCanResume(order);
+    for await (const status of this.orderExecutor.executeOrder({
+      order,
+      sessionPrivateKey: options.sessionPrivateKey,
+      auctionTimeMs: options.auctionTimeMs,
+      pollIntervalMs: options.pollIntervalMs,
+      solver: options.solver
+    })) {
+      yield status;
+    }
+  }
   /**
    * Returns both the native token cost and the relayer fee for cancelling an
    * order. Use `relayerFee` to approve the ERC-20 spend before submitting.