@hyperbridge/sdk 1.8.6 → 1.9.0

package/dist/node/index.js

@@ -556,10 +556,9 @@ 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",
-  PARTIAL_FILL_EXHAUSTED: "PARTIAL_FILL_EXHAUSTED",
+  EXPIRED: "EXPIRED",
   FAILED: "FAILED"
 });
 
@@ -3787,6 +3786,9 @@ var chainConfigs = {
       UniversalRouter: "0x66a9893cc07d91d95644aedd05d03f95e1dba8af",
       UniswapV3Quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
       UniswapV4Quoter: "0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203",
+      UniswapV4PositionManager: "0xbd216513d74c8cf14cf4747e6aaa6420ff64ee9e",
+      UniswapV4PoolManager: "0x000000000004444c5dc75cB358380D2e3dE08A90",
+      UniswapV4StateView: "0x7ffe42c4a5deea5b0fec41c94c136cf115597227",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
@@ -3839,6 +3841,9 @@ var chainConfigs = {
       UniversalRouter: "0xd9C500DfF816a1Da21A48A732d3498Bf09dc9AEB",
       UniswapV3Quoter: "0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997",
       UniswapV4Quoter: "0xd0737C9762912dD34c3271197E362Aa736Df0926",
+      UniswapV4PositionManager: "0x7a4a5c919ae2541aed11041a1aeee68f1287f95b",
+      UniswapV4PoolManager: "0x28e2ea090877bf75740558f6bfb36a5ffee9e9df",
+      UniswapV4StateView: "0xd13dd3d6e93f276fafc9db9e6bb47c1180aee0c4",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
@@ -3893,6 +3898,9 @@ var chainConfigs = {
       UniversalRouter: "0xa51afafe0263b40edaef0df8781ea9aa03e381a3",
       UniswapV3Quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
       UniswapV4Quoter: "0x3972c00f7ed4885e145823eb7c655375d275a1c5",
+      UniswapV4PositionManager: "0xd88f38f930b7952f2db2432cb002e7abbf3dd869",
+      UniswapV4PoolManager: "0x360e68faccca8ca495c1b759fd9eee466db9fb32",
+      UniswapV4StateView: "0x76fd297e2d437cd7f76d50f01afe6160f86e9990",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
@@ -3949,7 +3957,11 @@ var chainConfigs = {
       UniswapV4Quoter: "0x0d5e0f971ed27fbff6c2837bf31316121532048d",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+      AerodromeRouter: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+      UniswapV4PositionManager: "0x7c5f5a4bbd8fd63184577525326123b519429bdc",
+      UniswapV4PoolManager: "0x498581ff718922c3f8e6a244956af099b2652b2b",
+      UniswapV4StateView: "0xa3c0c9b65bad0b08107aa264b0f3db444b867a71"
       // Usdt0Oft: Not available on Base
     },
     rpcEnvKey: "BASE_MAINNET",
@@ -4001,6 +4013,9 @@ var chainConfigs = {
       UniversalRouter: "0x1095692a6237d83c6a72f3f5efedb9a670c49223",
       UniswapV3Quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
       UniswapV4Quoter: "0xb3d5c3dfc3a7aebff71895a7191796bffc2c81b9",
+      UniswapV4PositionManager: "0x1ec2ebf4f37e7363fdfe3551602425af0b3ceef9",
+      UniswapV4PoolManager: "0x67366782805870060151383f4bbff9dab53e5cd6",
+      UniswapV4StateView: "0x5ea1bd7974c8a611cbab0bdcafcb1d9cc9b3ba5a",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
@@ -4045,6 +4060,9 @@ var chainConfigs = {
       UniversalRouter: "0xef740bf23acae26f6492b10de645d6b98dc8eaf3",
       UniswapV3Quoter: "0x385a5cf5f83e99f7bb2852b6a19c3538b9fa7658",
       UniswapV4Quoter: "0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203",
+      UniswapV4PositionManager: "0x4529a01c7a0410167c5740c487a8de60232617bf",
+      UniswapV4PoolManager: "0x1f98400000000000000000000000000000000004",
+      UniswapV4StateView: "0x86e8631a016f9068c3f085faf484ee3f5fdee8f2",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
@@ -4150,7 +4168,9 @@ var chainConfigs = {
       UniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
       Calldispatcher: "0xC71251c8b3e7B02697A84363Eef6DcE8DfBdF333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+      UniswapV4PositionManager: "0x3c3ea4b57a46241e54610e5f022e5c45859a1017",
+      UniswapV4PoolManager: "0x9a13f98cb987694c9f086b1f5eb990eea8264ec3"
     },
     defaultRpcUrl: "https://mainnet.optimism.io",
     consensusStateId: "ETH0",
@@ -4206,7 +4226,9 @@ var chainConfigs = {
     addresses: {
       TokenGateway: "0xCe304770236f39F9911BfCC51afBdfF3b8635718",
       Host: "0x7F0165140D0f3251c8f6465e94E9d12C7FD40711",
-      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+      UniswapV4PositionManager: "0x1b35d13a2e2528f192637f14b05f0dc0e7deb566",
+      UniswapV4PoolManager: "0x360e68faccca8ca495c1b759fd9eee466db9fb32"
     },
     defaultRpcUrl: "https://rpc.soneium.org",
     consensusStateId: "ETH0",
@@ -4400,6 +4422,9 @@ var ChainConfigService = class {
   getUniswapRouterV2Address(chain) {
     return this.getConfig(chain)?.addresses.UniswapRouter02 ?? "0x";
   }
+  getAerodromeRouterAddress(chain) {
+    return this.getConfig(chain)?.addresses.AerodromeRouter ?? "0x";
+  }
   getUniswapV2FactoryAddress(chain) {
     return this.getConfig(chain)?.addresses.UniswapV2Factory ?? "0x";
   }
@@ -4415,6 +4440,15 @@ var ChainConfigService = class {
   getUniswapV4QuoterAddress(chain) {
     return this.getConfig(chain)?.addresses.UniswapV4Quoter ?? "0x";
   }
+  getUniswapV4PositionManagerAddress(chain) {
+    return this.getConfig(chain)?.addresses.UniswapV4PositionManager ?? "0x";
+  }
+  getUniswapV4PoolManagerAddress(chain) {
+    return this.getConfig(chain)?.addresses.UniswapV4PoolManager ?? "0x";
+  }
+  getUniswapV4StateViewAddress(chain) {
+    return this.getConfig(chain)?.addresses.UniswapV4StateView ?? "0x";
+  }
   getPermit2Address(chain) {
     return this.getConfig(chain)?.addresses.Permit2 ?? "0x";
   }
@@ -5498,6 +5532,7 @@ var EvmChain = class _EvmChain {
     });
     this.chainConfigService = new ChainConfigService();
   }
+  params;
   publicClient;
   chainConfigService;
   /**
@@ -6098,6 +6133,7 @@ var HttpRpcClient = class {
   constructor(url) {
     this.url = url;
   }
+  url;
   /**
    * Make an RPC call over HTTP
    * @param method - The RPC method name
@@ -6135,6 +6171,7 @@ var SubstrateChain = class _SubstrateChain {
     const httpUrl = replaceWebsocketWithHttp(url);
     this.rpcClient = new HttpRpcClient(httpUrl);
   }
+  params;
   /*
    * api: The Polkadot API instance for the Substrate chain.
    */
@@ -6652,6 +6689,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;
   /**
@@ -6929,6 +6969,7 @@ var TronChain = class _TronChain {
     this.evm = evm;
     this.tronWebInstance = new TronWeb({ fullHost: params.rpcUrl });
   }
+  params;
   evm;
   tronWebInstance;
   /**
@@ -7469,6 +7510,7 @@ var SubstrateHttpRpc = class {
   constructor(url) {
     this.url = url;
   }
+  url;
   async call(method, params = []) {
     const body = JSON.stringify({
       jsonrpc: "2.0",
@@ -7513,6 +7555,7 @@ var PolkadotHubChain = class _PolkadotHubChain {
     this.evm = evm;
     this.substrateRpc = new SubstrateHttpRpc(replaceWebsocketWithHttp(params.substrateRpcUrl));
   }
+  params;
   evm;
   substrateRpc;
   static fromParams(params) {
@@ -12571,7 +12614,9 @@ var BundlerMethod = {
   /** Estimates gas limits for a UserOperation before submission. */
   ETH_ESTIMATE_USER_OPERATION_GAS: "eth_estimateUserOperationGas",
   /** Pimlico-specific method to fetch recommended EIP-1559 gas prices for UserOperations. */
-  PIMLICO_GET_USER_OPERATION_GAS_PRICE: "pimlico_getUserOperationGasPrice"
+  PIMLICO_GET_USER_OPERATION_GAS_PRICE: "pimlico_getUserOperationGasPrice",
+  /** Alchemy (Rundler) method to fetch recommended priority fee for UserOperations. */
+  RUNDLER_MAX_PRIORITY_FEE_PER_GAS: "rundler_maxPriorityFeePerGas"
 };
 
 // src/protocols/intents/CryptoUtils.ts
@@ -12592,6 +12637,7 @@ var CryptoUtils = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   /**
    * Computes an EIP-712 domain separator for a given contract.
    *
@@ -15127,6 +15173,7 @@ var OrderPlacer = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   /**
    * Bidirectional async generator that orchestrates order placement.
    *
@@ -15204,66 +15251,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` | `PARTIAL_FILL_EXHAUSTED`)
-   *
-   * **Error statuses:** `FAILED` (fatal, no fills) or `PARTIAL_FILL_EXHAUSTED`
-   * (deadline reached or no new bids after at least one partial fill).
-   *
-   * @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 blockTimeSeconds = client.chain?.blockTime ?? 2;
+    while (true) {
+      const currentBlock = await client.getBlockNumber();
+      if (currentBlock >= deadline) break;
+      const blocksRemaining = Number(deadline - currentBlock);
+      const sleepMs = blocksRemaining * blockTimeSeconds * 1e3;
+      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);
@@ -15273,83 +15294,210 @@ 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, minBids = 1, 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,
+      minBids,
+      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,
+      minBids,
+      pollIntervalMs,
+      solver,
+      usedUserOps,
+      userOpHashKey,
+      targetAssets
+    } = params;
+    let { totalFilledAssets, remainingAssets } = params;
+    const solverLockStartTime = Date.now();
+    yield { status: "AWAITING_BIDS", commitment, totalFilledAssets, remainingAssets };
     try {
       while (true) {
-        const currentBlock = await this.ctx.dest.client.getBlockNumber();
-        if (currentBlock >= order.deadline) {
-          const isPartiallyFilled = totalFilledAssets.some((a) => a.amount > 0n);
-          const deadlineError = `Order deadline reached (block ${currentBlock} >= ${order.deadline})`;
-          if (isPartiallyFilled) {
-            yield {
-              status: "PARTIAL_FILL_EXHAUSTED",
-              commitment,
-              totalFilledAssets,
-              remainingAssets,
-              error: deadlineError
-            };
-          } else {
-            yield { status: "FAILED", commitment, 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 isPartiallyFilled = totalFilledAssets.some((a) => a.amount > 0n);
-          const solverClause = solver && !solverLockExpired ? ` for requested solver ${solver.address}` : "";
-          const noBidsError = isPartiallyFilled ? `No new bids${solverClause} after partial fill` : `No new bids${solverClause} available within ${bidTimeoutMs}ms timeout`;
-          if (isPartiallyFilled) {
-            yield {
-              status: "PARTIAL_FILL_EXHAUSTED",
-              commitment,
-              totalFilledAssets,
-              remainingAssets,
-              error: noBidsError
-            };
-          } else {
-            yield { status: "FAILED", commitment, error: noBidsError };
-          }
-          return;
+        if (freshBids.length < minBids) {
+          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",
@@ -15358,76 +15506,29 @@ var OrderExecutor = class {
             remainingAssets,
             error: `Failed to select bid and submit: ${err instanceof Error ? err.message : String(err)}`
           };
-          return;
+          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) {
@@ -15447,6 +15548,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
@@ -15916,6 +16018,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.
@@ -17995,6 +18099,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
@@ -18029,11 +18135,13 @@ var GasEstimator = class {
     const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(destStateMachineId);
     const chainId = BigInt(Number.parseInt(destStateMachineId.split("-")[1]));
     const totalEthValue = order.output.assets.filter((output) => bytes32ToBytes20(output.token) === ADDRESS_ZERO2).reduce((sum, output) => sum + output.amount, 0n);
-    const [sourceFeeToken, destFeeToken, gasPrice] = await Promise.all([
+    const [sourceFeeToken, destFeeToken, gasPrice, latestBlock] = await Promise.all([
       getFeeToken(this.ctx, this.ctx.source.config.stateMachineId, this.ctx.source),
       getFeeToken(this.ctx, this.ctx.dest.config.stateMachineId, this.ctx.dest),
-      this.ctx.dest.client.getGasPrice()
+      this.ctx.dest.client.getGasPrice(),
+      this.ctx.dest.client.getBlock({ blockTag: "latest" })
     ]);
+    const baseFeePerGas = latestBlock.baseFeePerGas ?? gasPrice;
     const feeTokenAsBytes32 = bytes20ToBytes32(destFeeToken.address);
     const assetsForOverrides = [...order.output.assets];
     if (!assetsForOverrides.some((asset) => asset.token.toLowerCase() === feeTokenAsBytes32.toLowerCase())) {
@@ -18081,6 +18189,7 @@ var GasEstimator = class {
     if (this.ctx.bundlerUrl) {
       try {
         const callData = this.crypto.encodeERC7821Execute([
+          ...params.prependCalls ?? [],
           { target: intentGatewayV2Address, value: totalNativeValue, data: fillOrderCalldata }
         ]);
         const accountGasLimits = this.crypto.packGasLimits(100000n, callGasLimit);
@@ -18122,7 +18231,9 @@ var GasEstimator = class {
           sessionSignature
         ]);
         const bundlerUserOp = this.crypto.prepareBundlerCall(preliminaryUserOp);
-        const isPimlico = this.ctx.bundlerUrl.toLowerCase().includes("pimlico.io");
+        const bundlerUrlLower = this.ctx.bundlerUrl.toLowerCase();
+        const isPimlico = bundlerUrlLower.includes("pimlico.io");
+        const isAlchemy = bundlerUrlLower.includes("alchemy.com");
         const bundlerRequests = [
           {
             method: BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
@@ -18135,14 +18246,24 @@ var GasEstimator = class {
             params: []
           });
         }
+        if (isAlchemy) {
+          bundlerRequests.push({
+            method: BundlerMethod.RUNDLER_MAX_PRIORITY_FEE_PER_GAS,
+            params: []
+          });
+        }
         let gasEstimate;
         let pimlicoGasPrices = null;
+        let alchemyMaxPriorityFee = null;
         try {
           const batchResults = await this.crypto.sendBundlerBatch(bundlerRequests);
           gasEstimate = batchResults[0];
           if (isPimlico && batchResults.length > 1) {
             pimlicoGasPrices = batchResults[1];
           }
+          if (isAlchemy && batchResults.length > 1) {
+            alchemyMaxPriorityFee = batchResults[1];
+          }
         } catch {
           gasEstimate = await this.crypto.sendBundler(
             BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
@@ -18161,6 +18282,14 @@ var GasEstimator = class {
             maxPriorityFeePerGas = pimMaxPriorityFeePerGas + pimMaxPriorityFeePerGas * BigInt(priorityFeeBumpPercent) / 100n;
           }
         }
+        if (alchemyMaxPriorityFee) {
+          const rundlerPriorityFee = BigInt(alchemyMaxPriorityFee);
+          const isArbitrum = chainId === 42161n;
+          const alchemyPrioBump = isArbitrum ? 0n : 25n;
+          maxPriorityFeePerGas = rundlerPriorityFee + rundlerPriorityFee * alchemyPrioBump / 100n;
+          const bufferedBaseFee = baseFeePerGas + baseFeePerGas * 50n / 100n;
+          maxFeePerGas = bufferedBaseFee + maxPriorityFeePerGas;
+        }
       } catch (e) {
         console.warn("Bundler gas estimation failed, using fallback values:", e);
       }
@@ -18393,6 +18522,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.
    *
@@ -18574,7 +18704,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
@@ -18585,7 +18715,6 @@ var IntentGateway = class _IntentGateway {
    *   - `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).
    *   - `pollIntervalMs` — interval between bid-polling attempts.
    * @yields {@link IntentOrderStatusUpdate} at each lifecycle stage.
    * @throws If the `placeOrder` generator behaves unexpectedly, or if gas
@@ -18618,11 +18747,10 @@ 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
     })) {
@@ -18630,6 +18758,52 @@ var IntentGateway = class _IntentGateway {
     }
     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,
+      minBids: options?.minBids,
+      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.