@hyperbridge/sdk 2.2.0 → 2.2.3

package/dist/node/index.cjs

@@ -2579,7 +2579,7 @@ var chainConfigs = {
       USDT: { balanceSlot: 151, allowanceSlot: 152 }
     },
     addresses: {
-      IntentGateway: "0xFbF50B2b32768127603cC9eF4b871574b881b8eD",
+      IntentGateway: "0xE13fB34CAe12505ae51BaC8C405AF8EB27AC8058",
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
       Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
       UniswapRouter02: "0x9639379819420704457B07A0C33B678D9E0F8Df0",
@@ -2589,7 +2589,7 @@ var chainConfigs = {
       UniswapV3Quoter: "0x0000000000000000000000000000000000000000",
       UniswapV4Quoter: "0x0000000000000000000000000000000000000000",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-      SolverAccount: "0xCDFcFeD7A14154846808FddC8Ba971A2f8a830a3"
+      SolverAccount: "0x0b5cfBc16ef60AD6930ba5A90Bb09475B7BF3815"
     },
     rpcEnvKey: "BSC_CHAPEL",
     defaultRpcUrl: "https://bnb-testnet.api.onfinality.io/public",
@@ -2696,8 +2696,8 @@ var chainConfigs = {
       DAI: { balanceSlot: 0, allowanceSlot: 0 }
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
@@ -2751,8 +2751,8 @@ var chainConfigs = {
       DAI: { balanceSlot: 0, allowanceSlot: 0 }
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x10ED43C718714eb63d5aA57B78B54704E256024E",
@@ -2807,8 +2807,8 @@ var chainConfigs = {
       DAI: { balanceSlot: 0, allowanceSlot: 0 }
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -2864,8 +2864,8 @@ var chainConfigs = {
       DAI: { balanceSlot: 0, allowanceSlot: 0 }
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -2889,6 +2889,7 @@ var chainConfigs = {
     consensusStateId: "ETH0",
     coingeckoId: "base",
     layerZeroEid: 30184,
+    uniswapV4Pools: [{ tokens: ["USDC", "cNGN"], fee: 1500, tickSpacing: 30 }],
     popularTokens: [
       "0x4200000000000000000000000000000000000006",
       "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
@@ -2922,8 +2923,8 @@ var chainConfigs = {
       DAI: { balanceSlot: 0, allowanceSlot: 0 }
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0xd2f9496824951D5237cC71245D659E48d0d5f9E8",
@@ -2993,7 +2994,7 @@ var chainConfigs = {
       //wmatic, change it to wpol
       DAI: "0x0000000000000000000000000000000000000000",
       USDC: "0x693b854d6965ffeaae21c74049dea644b56fcacb",
-      USDT: "0x693b854d6965ffeaae21c74049dea644b56fcacb"
+      USDT: "0x0000000000000000000000000000000000000000"
     },
     tokenDecimals: {
       USDC: 18,
@@ -3004,13 +3005,13 @@ var chainConfigs = {
       USDC: { balanceSlot: 1, allowanceSlot: 2 }
     },
     addresses: {
-      IntentGateway: "0xFbF50B2b32768127603cC9eF4b871574b881b8eD",
+      IntentGateway: "0xE13fB34CAe12505ae51BaC8C405AF8EB27AC8058",
       TokenGateway: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
       Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
       Calldispatcher: "0x876F1891982E260026630c233A4897160A281Fb8",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-      SolverAccount: "0xCDFcFeD7A14154846808FddC8Ba971A2f8a830a3"
+      SolverAccount: "0x0b5cfBc16ef60AD6930ba5A90Bb09475B7BF3815"
     },
     rpcEnvKey: "POLYGON_AMOY",
     defaultRpcUrl: "https://rpc-amoy.polygon.technology",
@@ -3033,8 +3034,8 @@ var chainConfigs = {
       USDT: 6
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
@@ -3068,8 +3069,8 @@ var chainConfigs = {
       USDT: 6
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0xB2e26652e4BAd1e56055A051f922E06760cA0BFE",
@@ -3223,8 +3224,8 @@ var chainConfigs = {
       USDT: 6
     },
     addresses: {
-      IntentGateway: "0x16F9E57f735bBfF9f6c4E5276330f9c437d0e9E0",
-      SolverAccount: "0xB92A51A609e85f8316004a6da9feaB4421c01b43",
+      IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
+      SolverAccount: "0x975e80B476cB1d4Cd06c292ce36898f2bE4159ea",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       Calldispatcher: "0xE2C7e576E26E0bE7aC97c6fE925bcDAbD87c4bEd"
     },
@@ -5102,6 +5103,9 @@ var ChainConfigService = class {
   getDaiAsset(chain) {
     return this.getConfig(chain)?.assets?.DAI ?? "0x";
   }
+  getAssetAddress(chain, symbol) {
+    return this.getConfig(chain)?.assets?.[symbol];
+  }
   getUsdtAsset(chain) {
     return this.getConfig(chain)?.assets?.USDT ?? "0x";
   }
@@ -5170,6 +5174,9 @@ var ChainConfigService = class {
   getUniswapV4StateViewAddress(chain) {
     return this.getConfig(chain)?.addresses.UniswapV4StateView ?? "0x";
   }
+  getUniswapV4PoolConfigs(chain) {
+    return this.getConfig(chain)?.uniswapV4Pools ?? [];
+  }
   getPermit2Address(chain) {
     return this.getConfig(chain)?.addresses.Permit2 ?? "0x";
   }
@@ -5180,7 +5187,7 @@ var ChainConfigService = class {
     return this.getConfig(chain)?.coingeckoId;
   }
   getEtherscanApiKey() {
-    return typeof process !== "undefined" ? process?.env?.ETHERSCAN_API_KEY : void 0;
+    return typeof process !== "undefined" ? process.env?.ETHERSCAN_API_KEY : void 0;
   }
   getCalldispatcherAddress(chain) {
     return this.getConfig(chain)?.addresses.Calldispatcher ?? "0x";
@@ -9549,7 +9556,28 @@ function adjustDecimals(feeInFeeToken, fromDecimals, toDecimals) {
   }
 }
 var USE_ETHERSCAN_CHAINS = /* @__PURE__ */ new Set(["EVM-137", "EVM-56", "EVM-1"]);
-var TESTNET_CHAINS = /* @__PURE__ */ new Set(["EVM-10200", "EVM-97"]);
+var TESTNET_CHAINS = /* @__PURE__ */ new Set([
+  "EVM-97",
+  // BSC Chapel
+  "EVM-10200",
+  // Gnosis Chiado
+  "EVM-11155111",
+  // Sepolia
+  "EVM-421614",
+  // Arbitrum Sepolia
+  "EVM-84532",
+  // Base Sepolia
+  "EVM-11155420",
+  // Optimism Sepolia
+  "EVM-80002",
+  // Polygon Amoy
+  "EVM-420420417",
+  // Polkadot Asset Hub Paseo
+  "EVM-3448148188",
+  // Tron Nile
+  "EVM-688689"
+  // Pharos Atlantic
+]);
 function collectCallInputsByAddress(call, targetContractAddress, acc) {
   const normalizedTarget = targetContractAddress.toLowerCase();
   if (call.calls && Array.isArray(call.calls)) {
@@ -9864,6 +9892,48 @@ var GetRequestClient = class {
   async buildFinalized(request, hyperbridgeDelivered, response) {
     const sourceChain = this.ctx.config.source;
     const hyperbridge = this.ctx.config.hyperbridge;
+    const { config } = hyperbridge;
+    const finality = await this.queries.queryStateMachineUpdateByHeight({
+      statemachineId: config.stateMachineId,
+      height: hyperbridgeDelivered.metadata.blockNumber,
+      chain: config.stateMachineId
+    });
+    if (finality) {
+      const proof = await hyperbridge.queryProof(
+        { Responses: [response.commitment] },
+        request.source,
+        BigInt(finality.height)
+      );
+      const calldata = sourceChain.encode({
+        kind: "GetResponse",
+        proof: {
+          stateMachine: config.stateMachineId,
+          consensusStateId: config.consensusStateId,
+          proof,
+          height: BigInt(finality.height)
+        },
+        responses: [
+          {
+            get: request,
+            values: request.keys.map((key, index) => ({
+              key,
+              value: response.values[index] || "0x"
+            }))
+          }
+        ],
+        signer: viem.pad("0x")
+      });
+      return {
+        status: RequestStatus.HYPERBRIDGE_FINALIZED,
+        metadata: {
+          blockHash: finality.blockHash,
+          blockNumber: finality.height,
+          transactionHash: finality.transactionHash,
+          timestamp: finality.timestamp,
+          calldata
+        }
+      };
+    }
     if (sourceChain instanceof EvmChain) {
       const hyperbridgeSubstrate = hyperbridge;
       const currentEpoch = await sourceChain.currentEpoch();
@@ -9872,18 +9942,18 @@ var GetRequestClient = class {
         currentEpoch
       );
       if (!consensusResult) return void 0;
-      const proof2 = await hyperbridge.queryProof(
+      const proof = await hyperbridge.queryProof(
         { Responses: [response.commitment] },
         request.source,
         consensusResult.provenHeight
       );
-      const calldata2 = sourceChain.encode({
+      const calldata = sourceChain.encode({
         kind: "BatchConsensusAndGetResponse",
         consensusProofs: consensusResult.proofs,
         proof: {
-          stateMachine: this.ctx.config.hyperbridge.config.stateMachineId,
-          consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
-          proof: proof2,
+          stateMachine: config.stateMachineId,
+          consensusStateId: config.consensusStateId,
+          proof,
           height: consensusResult.provenHeight
         },
         responses: [
@@ -9905,50 +9975,11 @@ var GetRequestClient = class {
           transactionHash: hyperbridgeDelivered.metadata.transactionHash,
           // @ts-ignore
           timestamp: hyperbridgeDelivered.metadata.timestamp,
-          calldata: calldata2
+          calldata
         }
       };
     }
-    const hyperbridgeFinality = await this.queries.queryStateMachineUpdateByHeight({
-      statemachineId: this.ctx.config.hyperbridge.config.stateMachineId,
-      height: hyperbridgeDelivered.metadata.blockNumber,
-      chain: request.source
-    });
-    if (!hyperbridgeFinality) return void 0;
-    const proof = await hyperbridge.queryProof(
-      { Responses: [response.commitment] },
-      request.source,
-      BigInt(hyperbridgeFinality.height)
-    );
-    const calldata = sourceChain.encode({
-      kind: "GetResponse",
-      proof: {
-        stateMachine: this.ctx.config.hyperbridge.config.stateMachineId,
-        consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
-        proof,
-        height: BigInt(hyperbridgeFinality.height)
-      },
-      responses: [
-        {
-          get: request,
-          values: request.keys.map((key, index) => ({
-            key,
-            value: response.values[index] || "0x"
-          }))
-        }
-      ],
-      signer: viem.pad("0x")
-    });
-    return {
-      status: RequestStatus.HYPERBRIDGE_FINALIZED,
-      metadata: {
-        blockHash: hyperbridgeFinality.blockHash,
-        blockNumber: hyperbridgeFinality.height,
-        transactionHash: hyperbridgeFinality.transactionHash,
-        timestamp: hyperbridgeFinality.timestamp,
-        calldata
-      }
-    };
+    return void 0;
   }
   /**
    * Streaming helper: waits (via `waitOrAbort`) for the consensus proof or
@@ -9963,7 +9994,12 @@ var GetRequestClient = class {
     const hyperbridge = this.ctx.config.hyperbridge;
     const stateMachineId = this.ctx.config.hyperbridge.config.stateMachineId;
     const neededHeight = BigInt(request.statuses[hyperbridgeDeliveredIndex].metadata.blockNumber);
-    if (sourceChain instanceof EvmChain) {
+    let finality = await this.queries.queryStateMachineUpdateByHeight({
+      statemachineId: stateMachineId,
+      height: Number(neededHeight),
+      chain: stateMachineId
+    });
+    if (!finality && sourceChain instanceof EvmChain) {
       const hyperbridgeSubstrate = hyperbridge;
       const currentEpoch = await sourceChain.currentEpoch();
       const consensusResult = await waitOrAbort(this.ctx, {
@@ -10007,18 +10043,20 @@ var GetRequestClient = class {
         }
       };
     }
-    const hyperbridgeFinalized = await waitOrAbort(this.ctx, {
-      signal,
-      promise: () => this.queries.queryStateMachineUpdateByHeight({
-        statemachineId: stateMachineId,
-        height: Number(neededHeight),
-        chain: request.source
-      })
-    });
+    if (!finality) {
+      finality = await waitOrAbort(this.ctx, {
+        signal,
+        promise: () => this.queries.queryStateMachineUpdateByHeight({
+          statemachineId: stateMachineId,
+          height: Number(neededHeight),
+          chain: stateMachineId
+        })
+      });
+    }
     const proof = await hyperbridge.queryProof(
       { Responses: [response?.commitment] },
       request.source,
-      BigInt(hyperbridgeFinalized.height)
+      BigInt(finality.height)
     );
     const calldata = sourceChain.encode({
       kind: "GetResponse",
@@ -10026,7 +10064,7 @@ var GetRequestClient = class {
         stateMachine: stateMachineId,
         consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
         proof,
-        height: BigInt(hyperbridgeFinalized.height)
+        height: BigInt(finality.height)
       },
       responses: [
         {
@@ -10042,10 +10080,10 @@ var GetRequestClient = class {
     return {
       status: RequestStatus.HYPERBRIDGE_FINALIZED,
       metadata: {
-        blockHash: hyperbridgeFinalized.blockHash,
-        blockNumber: hyperbridgeFinalized.height,
-        transactionHash: hyperbridgeFinalized.transactionHash,
-        timestamp: hyperbridgeFinalized.timestamp,
+        blockHash: finality.blockHash,
+        blockNumber: finality.height,
+        transactionHash: finality.transactionHash,
+        timestamp: finality.timestamp,
         calldata
       }
     };
@@ -10234,26 +10272,27 @@ var PostRequestClient = class {
    * accompanying timeout-proof calldata.
    */
   async addTimeoutFinalityEvents(request) {
-    const destChain = this.ctx.config.dest;
-    const hyperbridge = this.ctx.config.hyperbridge;
     const events = [];
-    const commitment = postRequestCommitment(request).commitment;
-    const receipt = await destChain.queryRequestReceipt(commitment);
-    const destTimestamp = await destChain.timestamp();
     const commit = (req) => {
       this.logger.trace(`Added ${events.length} timeout events`, events);
       request.statuses = [...req.statuses, ...events];
       return request;
     };
     if (request.timeoutTimestamp === 0n) return commit(request);
+    if (request.statuses.some(
+      (item) => item.status === RequestStatus.DESTINATION || item.status === TimeoutStatus.TIMED_OUT
+    ))
+      return commit(request);
+    const destChain = this.ctx.config.dest;
+    const hyperbridge = this.ctx.config.hyperbridge;
+    const commitment = postRequestCommitment(request).commitment;
+    const receipt = await destChain.queryRequestReceipt(commitment);
+    const destTimestamp = await destChain.timestamp();
     if (receipt || request.timeoutTimestamp > destTimestamp) return commit(request);
-    const is_finished = request.statuses.find((item) => item.status === RequestStatus.DESTINATION);
-    if (!is_finished) {
-      events.push({
-        status: TimeoutStatus.PENDING_TIMEOUT,
-        metadata: { blockHash: "0x", blockNumber: 0, transactionHash: "0x" }
-      });
-    }
+    events.push({
+      status: TimeoutStatus.PENDING_TIMEOUT,
+      metadata: { blockHash: "0x", blockNumber: 0, transactionHash: "0x" }
+    });
     const delivered = request.statuses.find((item) => item.status === RequestStatus.HYPERBRIDGE_DELIVERED);
     let hyperbridgeFinalized;
     if (!delivered) {
@@ -10544,6 +10583,40 @@ var PostRequestClient = class {
   async buildFinalized(request, hyperbridgeDelivered) {
     const destChain = this.ctx.config.dest;
     const hyperbridge = this.ctx.config.hyperbridge;
+    const { config } = hyperbridge;
+    const finality = await this.queries.queryStateMachineUpdateByHeight({
+      statemachineId: config.stateMachineId,
+      height: hyperbridgeDelivered.metadata.blockNumber,
+      chain: config.stateMachineId
+    });
+    if (finality) {
+      const proof = await hyperbridge.queryProof(
+        { Requests: [postRequestCommitment(request).commitment] },
+        request.dest,
+        BigInt(finality.height)
+      );
+      const calldata = destChain.encode({
+        kind: "PostRequest",
+        proof: {
+          stateMachine: config.stateMachineId,
+          consensusStateId: config.consensusStateId,
+          proof,
+          height: BigInt(finality.height)
+        },
+        requests: [request],
+        signer: viem.pad("0x")
+      });
+      return {
+        status: RequestStatus.HYPERBRIDGE_FINALIZED,
+        metadata: {
+          blockHash: finality.blockHash,
+          blockNumber: finality.height,
+          transactionHash: finality.transactionHash,
+          timestamp: finality.timestamp,
+          calldata
+        }
+      };
+    }
     if (destChain instanceof EvmChain) {
       const hyperbridgeSubstrate = hyperbridge;
       const currentEpoch = await destChain.currentEpoch();
@@ -10552,18 +10625,18 @@ var PostRequestClient = class {
         currentEpoch
       );
       if (!consensusResult) return void 0;
-      const proof2 = await hyperbridge.queryProof(
+      const proof = await hyperbridge.queryProof(
         { Requests: [postRequestCommitment(request).commitment] },
         request.dest,
         consensusResult.provenHeight
       );
-      const calldata2 = destChain.encode({
+      const calldata = destChain.encode({
         kind: "BatchConsensusAndPostRequest",
         consensusProofs: consensusResult.proofs,
         proof: {
-          stateMachine: this.ctx.config.hyperbridge.config.stateMachineId,
-          consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
-          proof: proof2,
+          stateMachine: config.stateMachineId,
+          consensusStateId: config.consensusStateId,
+          proof,
           height: consensusResult.provenHeight
         },
         requests: [request],
@@ -10577,42 +10650,11 @@ var PostRequestClient = class {
           transactionHash: hyperbridgeDelivered.metadata.transactionHash,
           // @ts-ignore
           timestamp: hyperbridgeDelivered.metadata.timestamp,
-          calldata: calldata2
+          calldata
         }
       };
     }
-    const hyperbridgeFinality = await this.queries.queryStateMachineUpdateByHeight({
-      statemachineId: this.ctx.config.hyperbridge.config.stateMachineId,
-      height: hyperbridgeDelivered.metadata.blockNumber,
-      chain: request.dest
-    });
-    if (!hyperbridgeFinality) return void 0;
-    const proof = await hyperbridge.queryProof(
-      { Requests: [postRequestCommitment(request).commitment] },
-      request.dest,
-      BigInt(hyperbridgeFinality.height)
-    );
-    const calldata = destChain.encode({
-      kind: "PostRequest",
-      proof: {
-        stateMachine: this.ctx.config.hyperbridge.config.stateMachineId,
-        consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
-        proof,
-        height: BigInt(hyperbridgeFinality.height)
-      },
-      requests: [request],
-      signer: viem.pad("0x")
-    });
-    return {
-      status: RequestStatus.HYPERBRIDGE_FINALIZED,
-      metadata: {
-        blockHash: hyperbridgeFinality.blockHash,
-        blockNumber: hyperbridgeFinality.height,
-        transactionHash: hyperbridgeFinality.transactionHash,
-        timestamp: hyperbridgeFinality.timestamp,
-        calldata
-      }
-    };
+    return void 0;
   }
   /**
    * Streaming helper: waits for the consensus proof, fetches the messaging
@@ -10626,14 +10668,19 @@ var PostRequestClient = class {
     const stateMachineId = this.ctx.config.hyperbridge.config.stateMachineId;
     const neededHeight = BigInt(request.statuses[hyperbridgeDeliveredIndex].metadata.blockNumber);
     this.logger.trace(`[streamFinalized] neededHeight=${neededHeight}`);
-    if (destChain instanceof EvmChain) {
+    const commitment = postRequestCommitment(request).commitment;
+    let finality = await this.queries.queryStateMachineUpdateByHeight({
+      statemachineId: stateMachineId,
+      height: Number(neededHeight),
+      chain: stateMachineId
+    });
+    if (!finality && destChain instanceof EvmChain) {
       const hyperbridgeSubstrate = hyperbridge;
       const currentEpoch = await destChain.currentEpoch();
       const consensusResult = await waitOrAbort(this.ctx, {
         signal,
         promise: () => hyperbridgeSubstrate.queryConsensusProofs(neededHeight, currentEpoch)
       });
-      const commitment = postRequestCommitment(request).commitment;
       this.logger.trace(
         `[streamFinalized] consensusProofs found (${consensusResult.proofs.length} proofs), provenHeight=${consensusResult.provenHeight}, commitment=${commitment}, dest=${request.dest}`
       );
@@ -10665,45 +10712,45 @@ var PostRequestClient = class {
         }
       };
     }
-    const hyperbridgeFinalized = await waitOrAbort(this.ctx, {
-      signal,
-      promise: () => this.queries.queryStateMachineUpdateByHeight({
-        statemachineId: stateMachineId,
-        height: Number(neededHeight),
-        chain: request.dest
-      })
-    });
+    if (!finality) {
+      finality = await waitOrAbort(this.ctx, {
+        signal,
+        promise: () => this.queries.queryStateMachineUpdateByHeight({
+          statemachineId: stateMachineId,
+          height: Number(neededHeight),
+          chain: stateMachineId
+        })
+      });
+    }
     const proof = await this.fetchProofWithRetry(
       signal,
-      () => hyperbridge.queryProof(
-        { Requests: [postRequestCommitment(request).commitment] },
-        request.dest,
-        BigInt(hyperbridgeFinalized.height)
-      )
+      () => hyperbridge.queryProof({ Requests: [commitment] }, request.dest, BigInt(finality.height))
     );
+    if (!(destChain instanceof EvmChain)) {
+      const { stateId } = parseStateMachineId(stateMachineId);
+      await waitForChallengePeriod(destChain, {
+        height: BigInt(finality.height),
+        id: { stateId, consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId }
+      });
+    }
     const calldata = destChain.encode({
       kind: "PostRequest",
       proof: {
         stateMachine: stateMachineId,
         consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
         proof,
-        height: BigInt(hyperbridgeFinalized.height)
+        height: BigInt(finality.height)
       },
       requests: [request],
       signer: viem.pad("0x")
     });
-    const { stateId } = parseStateMachineId(stateMachineId);
-    await waitForChallengePeriod(destChain, {
-      height: BigInt(hyperbridgeFinalized.height),
-      id: { stateId, consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId }
-    });
     return {
       status: RequestStatus.HYPERBRIDGE_FINALIZED,
       metadata: {
-        blockHash: hyperbridgeFinalized.blockHash,
-        blockNumber: hyperbridgeFinalized.height,
-        transactionHash: hyperbridgeFinalized.transactionHash,
-        timestamp: hyperbridgeFinalized.timestamp,
+        blockHash: finality.blockHash,
+        blockNumber: finality.height,
+        transactionHash: finality.transactionHash,
+        timestamp: finality.timestamp,
         calldata
       }
     };
@@ -14626,6 +14673,7 @@ function orderCommitment(order) {
   return viem.keccak256(encoded);
 }
 async function convertGasToFeeToken(ctx, gasEstimate, gasEstimateIn, evmChainID, gasPriceOverride) {
+  if (TESTNET_CHAINS.has(evmChainID)) return 1n;
   const chain = ctx[gasEstimateIn];
   const client = chain.client;
   const gasPrice = gasPriceOverride ?? await retryPromise(() => client.getGasPrice(), {
@@ -14660,6 +14708,7 @@ async function convertGasToFeeToken(ctx, gasEstimate, gasEstimateIn, evmChainID,
   }
 }
 async function convertFeeTokenToWei(ctx, feeTokenAmount, feeTokenIn, evmChainID) {
+  if (TESTNET_CHAINS.has(evmChainID)) return 1n;
   const chain = ctx[feeTokenIn];
   const client = chain.client;
   const wethAddr = chain.configService.getWrappedNativeAssetWithDecimals(evmChainID).asset;
@@ -14775,16 +14824,16 @@ var OrderPlacer = class {
     return { order, receipt };
   }
 };
+
+// src/protocols/intents/OrderExecutor.ts
 var USED_USEROPS_STORAGE_KEY = (commitment) => `used-userops:${commitment.toLowerCase()}`;
 var OrderExecutor = class {
-  constructor(ctx, bidManager, crypto) {
+  constructor(ctx, bidManager) {
     this.ctx = ctx;
     this.bidManager = bidManager;
-    this.crypto = crypto;
   }
   ctx;
   bidManager;
-  crypto;
   /**
    * Sleeps until the order's block deadline is reached, then yields EXPIRED.
    * Uses the chain's block time to calculate the sleep duration.
@@ -14855,17 +14904,6 @@ var OrderExecutor = class {
     }
     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
@@ -14933,7 +14971,15 @@ var OrderExecutor = class {
   }
   /**
    * Executes an intent order by racing bid polling against the order's
-   * block deadline. Yields status updates at each lifecycle stage.
+   * block deadline. Yields status updates at each lifecycle stage and hands
+   * bid selection to the consumer.
+   *
+   * This is a **bidirectional** generator: when it yields `BIDS_RECEIVED`, the
+   * consumer picks a bid, calls `bid.execute()`, and feeds the resulting
+   * {@link SelectBidResult} back via `gen.next(result)`. The generator then
+   * records the dedup entry, emits `BID_SELECTED`, tracks the fill, and either
+   * terminates or continues polling for the remaining amount. Feeding back
+   * `undefined` (no bid executed this round) causes it to keep polling.
    *
    * **Same-chain:** `AWAITING_BIDS` → `BIDS_RECEIVED` → `BID_SELECTED`
    *   → (`FILLED` | `PARTIAL_FILL`)* → (`FILLED` | `EXPIRED`)
@@ -14944,7 +14990,6 @@ var OrderExecutor = class {
   async *executeOrder(options) {
     const { order, sessionPrivateKey, auctionTimeMs, pollIntervalMs = DEFAULT_POLL_INTERVAL, solver } = options;
     const commitment = order.id;
-    order.source === order.destination;
     if (!this.ctx.intentsCoprocessor) {
       yield { status: "FAILED", error: "IntentsCoprocessor required for order execution" };
       return;
@@ -14972,11 +15017,24 @@ var OrderExecutor = class {
       remainingAssets
     });
     const deadlineTimeout = this.deadlineStream(order.deadline, commitment);
-    const combined = mergeRace__default.default(deadlineTimeout, executionStream);
+    const deadlinePromise = deadlineTimeout.next();
     try {
-      for await (const update of combined) {
-        yield update;
-        if (update.status === "EXPIRED" || update.status === "FILLED") return;
+      let input;
+      while (true) {
+        const winner = input !== void 0 ? { from: "exec", r: await executionStream.next(input) } : await Promise.race([
+          executionStream.next(void 0).then((r) => ({ from: "exec", r })),
+          deadlinePromise.then((r) => ({ from: "deadline", r }))
+        ]);
+        input = void 0;
+        if (winner.from === "deadline") {
+          if (!winner.r.done && winner.r.value) yield winner.r.value;
+          return;
+        }
+        const { value, done } = winner.r;
+        if (done) return;
+        const fed = yield value;
+        if (value.status === "BIDS_RECEIVED") input = fed;
+        if (value.status === "EXPIRED" || value.status === "FILLED") return;
       }
     } finally {
       console.log(`[OrderExecutor] Tearing down streams for commitment=${commitment}`);
@@ -14985,9 +15043,16 @@ var OrderExecutor = class {
     }
   }
   /**
-   * 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.
+   * Core execution loop that polls for bids and tracks fill progress. Builds
+   * first-class {@link Bid} objects from the raw filler bids and yields them to
+   * the consumer, which picks one, calls `bid.execute()`, and feeds the result
+   * back via `gen.next(result)`. The loop then records the dedup entry, emits
+   * `BID_SELECTED`, processes the fill, and continues polling for the remaining
+   * amount on partial fills.
+   *
+   * Bidirectional: the value passed to `.next()` after a `BIDS_RECEIVED` yield is
+   * the {@link SelectBidResult} from the executed bid (or `undefined` to skip the
+   * round and keep polling).
    */
   async *executionStream(params) {
     const {
@@ -15002,12 +15067,7 @@ var OrderExecutor = class {
       targetAssets
     } = params;
     let { totalFilledAssets, remainingAssets } = params;
-    const MAX_BID_ATTEMPTS = 2;
-    const bidFailCounts = /* @__PURE__ */ new Map();
-    const isFreshBid = (bid) => {
-      const key = userOpHashKey(bid.userOp);
-      return !usedUserOps.has(key) && (bidFailCounts.get(key) ?? 0) < MAX_BID_ATTEMPTS;
-    };
+    const isFreshBid = (bid) => !usedUserOps.has(userOpHashKey(bid.userOp));
     const solverLockStartTime = Date.now();
     yield { status: "AWAITING_BIDS", commitment, totalFilledAssets, remainingAssets };
     try {
@@ -15016,13 +15076,13 @@ var OrderExecutor = class {
       while (Date.now() < auctionEnd) {
         try {
           const bids = await this.fetchBids({ commitment, solver, solverLockStartTime });
-          const freshBids = bids.filter((bid) => !usedUserOps.has(userOpHashKey(bid.userOp)));
-          const newBids = freshBids.filter((bid) => !auctionSeenBids.has(userOpHashKey(bid.userOp)));
-          if (newBids.length > 0) {
-            for (const bid of newBids) {
-              auctionSeenBids.add(userOpHashKey(bid.userOp));
-            }
-            yield { status: "NEW_BID", commitment, bidCount: freshBids.length, bids: freshBids };
+          const newBids = bids.filter(
+            (bid) => isFreshBid(bid) && !auctionSeenBids.has(userOpHashKey(bid.userOp))
+          );
+          for (const fillerBid of newBids) {
+            auctionSeenBids.add(userOpHashKey(fillerBid.userOp));
+            const [bid] = this.bidManager.buildBids(order, [fillerBid], sessionPrivateKey);
+            if (bid) yield { status: "NEW_BID", commitment, bid };
           }
         } catch {
         }
@@ -15034,8 +15094,8 @@ var OrderExecutor = class {
       while (true) {
         let freshBids;
         try {
-          const bids = await this.fetchBids({ commitment, solver, solverLockStartTime });
-          freshBids = bids.filter(isFreshBid);
+          const bids2 = await this.fetchBids({ commitment, solver, solverLockStartTime });
+          freshBids = bids2.filter(isFreshBid);
         } catch {
           await sleep(pollIntervalMs);
           continue;
@@ -15044,56 +15104,33 @@ var OrderExecutor = class {
           await sleep(pollIntervalMs);
           continue;
         }
-        yield { status: "BIDS_RECEIVED", commitment, bidCount: freshBids.length, bids: freshBids };
-        let submitResult;
-        try {
-          submitResult = await this.submitBid({
-            order,
-            freshBids,
-            sessionPrivateKey,
-            commitment,
-            usedUserOps,
-            userOpHashKey
-          });
-        } catch (err) {
-          yield {
-            status: "FAILED",
-            commitment,
-            totalFilledAssets,
-            remainingAssets,
-            error: `Failed to select bid and submit: ${err instanceof Error ? err.message : String(err)}`
-          };
-          try {
-            const sorted = await this.bidManager.validateAndSortBids(freshBids, order);
-            if (sorted.length > 0) {
-              const key = userOpHashKey(sorted[0].bid.userOp);
-              bidFailCounts.set(key, (bidFailCounts.get(key) ?? 0) + 1);
-            }
-          } catch {
-          }
+        const bids = this.bidManager.buildBids(order, freshBids, sessionPrivateKey);
+        if (bids.length === 0) {
+          await sleep(pollIntervalMs);
+          continue;
+        }
+        const result = yield { status: "BIDS_RECEIVED", commitment, bidCount: bids.length, bids };
+        if (!result) {
           await sleep(pollIntervalMs);
           continue;
         }
+        usedUserOps.add(userOpHashKey(result.userOp));
+        await this.persistUsedUserOps(commitment, usedUserOps);
         yield {
           status: "BID_SELECTED",
           commitment,
-          selectedSolver: submitResult.solverAddress,
-          userOpHash: submitResult.userOpHash,
-          userOp: submitResult.userOp,
-          transactionHash: submitResult.txnHash
+          selectedSolver: result.solverAddress,
+          userOpHash: result.userOpHash,
+          userOp: result.userOp,
+          transactionHash: result.txnHash
         };
-        const fill = this.processFillResult(
-          submitResult,
-          commitment,
-          targetAssets,
-          totalFilledAssets,
-          remainingAssets
-        );
+        const fill = this.processFillResult(result, commitment, targetAssets, totalFilledAssets, remainingAssets);
         totalFilledAssets = fill.totalFilledAssets;
         remainingAssets = fill.remainingAssets;
         if (fill.update) {
           yield fill.update;
         }
+        if (fill.done) return;
       }
     } catch (err) {
       yield {
@@ -15568,183 +15605,148 @@ var OrderCanceller = class {
     return feeInDestFeeToken * 1005n / 1000n;
   }
 };
-var BidManager = class {
-  /**
-   * @param ctx - Shared IntentsV2 context providing the destination chain
-   *   client, coprocessor, bundler URL, and session-key storage.
-   * @param crypto - Crypto utilities used for gas packing, UserOp hashing,
-   *   EIP-712 signing, and bundler calls.
-   */
-  constructor(ctx, crypto) {
-    this.ctx = ctx;
-    this.crypto = crypto;
-  }
+var BidImpl = class {
+  solverAddress;
+  outputs;
+  relayerFee;
+  nativeDispatchFee;
+  userOp;
   ctx;
   crypto;
-  /**
-   * Constructs a signed `PackedUserOperation` that a solver can submit to the
-   * Hyperbridge coprocessor as a bid to fill an order.
-   *
-   * The solver's signature covers a hash that binds the UserOperation to the
-   * order commitment and the session key address, so the IntentGatewayV2
-   * contract can verify the solver's intent on-chain.
-   *
-   * @param options - Parameters describing the solver account, gas limits, fee
-   *   market values, and pre-built `callData` for the fill operation.
-   * @returns A `PackedUserOperation` with the solver's signature prepended
-   *   with the order commitment.
-   */
-  async prepareSubmitBid(options) {
-    const {
-      order,
-      solverAccount,
-      solverSigner,
-      nonce,
-      entryPointAddress,
-      callGasLimit,
-      verificationGasLimit,
-      preVerificationGas,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      callData,
-      paymasterAndData = "0x"
-    } = options;
-    const chainId = BigInt(
+  order;
+  fillOptions;
+  priceOutputs;
+  sessionPrivateKey;
+  intentGatewayV2Address;
+  domainSeparator;
+  /** Cached session-key signature over the `SelectSolver` message. */
+  cachedSignature;
+  constructor(params) {
+    this.ctx = params.ctx;
+    this.crypto = params.crypto;
+    this.order = params.order;
+    this.fillOptions = params.fillOptions;
+    this.priceOutputs = params.priceOutputs;
+    this.sessionPrivateKey = params.sessionPrivateKey;
+    this.solverAddress = params.fillerBid.userOp.sender;
+    this.outputs = params.fillOptions.outputs;
+    this.relayerFee = params.fillOptions.relayerFee;
+    this.nativeDispatchFee = params.fillOptions.nativeDispatchFee;
+    this.userOp = params.fillerBid.userOp;
+    this.intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(
+      normalizeStateMachineId(this.order.destination)
+    );
+    this.domainSeparator = CryptoUtils.getDomainSeparator(
+      "IntentGateway",
+      "2",
+      this.chainId(),
+      this.intentGatewayV2Address
+    );
+  }
+  /** Resolves the destination chain id from the client or the state-machine id. */
+  chainId() {
+    return BigInt(
       this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
     );
-    const accountGasLimits = CryptoUtils.packGasLimits(verificationGasLimit, callGasLimit);
-    const gasFees = CryptoUtils.packGasFees(maxPriorityFeePerGas, maxFeePerGas);
-    const userOp = {
-      sender: solverAccount,
-      nonce,
-      initCode: "0x",
-      callData,
-      accountGasLimits,
-      preVerificationGas,
-      gasFees,
-      paymasterAndData,
-      signature: "0x"
-    };
-    const userOpHash = CryptoUtils.computeUserOpHash(userOp, entryPointAddress, chainId);
-    const sessionKey = order.session;
-    const messageHash = viem.keccak256(viem.concat([userOpHash, order.id, sessionKey]));
-    const solverSignature = await solverSigner.signMessage(messageHash, Number(chainId));
-    const signature = viem.concat([order.id, solverSignature]);
-    return { ...userOp, signature };
   }
   /**
-   * Selects the best available bid, simulates it on-chain, signs the
-   * solver-selection EIP-712 message with the session key, and submits the
-   * UserOperation to the bundler.
-   *
-   * **Selection algorithm:**
-   * 1. Decodes `fillOrder` calldata from each bid's `callData`.
-   * 2. Sorts bids by output value (single-output: amount; all-stables: normalised
-   *    USD; mixed: DEX-quoted USD; fallback: raw amount).
-   * 3. Iterates sorted bids, simulating each with `eth_call` until one passes.
-   * 4. Appends the session-key's `SelectSolver` signature to the solver's
-   *    existing signature and submits via `eth_sendUserOperation`.
-   * 5. For same-chain orders, waits for the transaction receipt and reads
-   *    `OrderFilled` / `PartialFill` events to determine fill status.
+   * Resolves the session key, signs the `SelectSolver` message for this bid's
+   * solver, and caches the signature. Signs at most once per bid.
    *
-   * @param order - The placed order for which to select a bid.
-   * @param bids - Raw bids fetched from the Hyperbridge coprocessor.
-   * @param sessionPrivateKey - Optional override; if omitted, the key is
-   *   looked up from `sessionKeyStorage` using `order.session`.
-   * @returns A {@link SelectBidResult} containing the submitted UserOperation,
-   *   its hash, the winning solver address, transaction hash, and fill status.
-   * @throws If the session key is not found, no valid bids exist, all
-   *   simulations fail, or the bundler rejects the UserOperation.
+   * @throws If the session key is missing or signing fails.
    */
-  async selectBid(order, bids, sessionPrivateKey) {
-    const commitment = order.id;
-    const sessionKeyAddress = order.session;
-    console.log(`[BidManager] selectBid called for commitment=${commitment}, received ${bids.length} bid(s)`);
-    const sessionKeyData = sessionPrivateKey ? { privateKey: sessionPrivateKey } : await this.ctx.sessionKeyStorage.getSessionKeyByAddress(sessionKeyAddress);
+  async signSelection() {
+    if (this.cachedSignature) return this.cachedSignature;
+    const commitment = this.order.id;
+    const sessionKeyAddress = this.order.session;
+    const sessionKeyData = this.sessionPrivateKey ? { privateKey: this.sessionPrivateKey } : await this.ctx.sessionKeyStorage.getSessionKeyByAddress(sessionKeyAddress);
     if (!sessionKeyData) {
       throw new Error("SessionKey not found for commitment: " + commitment);
     }
-    if (!this.ctx.bundlerUrl) {
-      throw new Error("Bundler URL not configured");
+    const signature = await CryptoUtils.signSolverSelection(
+      commitment,
+      this.solverAddress,
+      this.domainSeparator,
+      sessionKeyData.privateKey
+    );
+    if (!signature) {
+      throw new Error("Failed to sign solver selection");
     }
-    if (!this.ctx.intentsCoprocessor) {
-      throw new Error("IntentsCoprocessor required");
-    }
-    const sortedBids = await this.validateAndSortBids(bids, order);
-    console.log(`[BidManager] ${sortedBids.length}/${bids.length} bid(s) passed validation and sorting`);
-    if (sortedBids.length === 0) {
-      throw new Error("No valid bids found");
-    }
-    const intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(
-      normalizeStateMachineId(order.destination)
-    );
-    const domainSeparator = CryptoUtils.getDomainSeparator(
-      "IntentGateway",
-      "2",
-      BigInt(
-        this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
-      ),
-      intentGatewayV2Address
+    this.cachedSignature = signature;
+    return signature;
+  }
+  /**
+   * Simulates this bid on-chain by batching the `select` and `fillOrder` calls
+   * via `eth_call` from the solver's account, using the IntentGatewayV2 ERC-7821
+   * batch-execute pattern.
+   *
+   * The native value forwarded to the simulation is the sum of any native-token
+   * (`address(0)`) output amounts plus the Hyperbridge dispatch fee.
+   *
+   * @throws If the `eth_call` simulation reverts or errors.
+   */
+  async simulate() {
+    const signature = await this.signSelection();
+    const selectOptions = {
+      commitment: this.order.id,
+      solver: this.solverAddress,
+      signature
+    };
+    const nativeOutputs = this.fillOptions.outputs.reduce(
+      (acc, o) => bytes32ToBytes20(o.token) === ADDRESS_ZERO2 ? acc + o.amount : acc,
+      0n
     );
-    let selectedBid = null;
-    let sessionSignature = null;
-    console.log(`[BidManager] Simulating ${sortedBids.length} sorted bid(s) to find a valid one`);
-    for (let idx = 0; idx < sortedBids.length; idx++) {
-      const bidWithOptions = sortedBids[idx];
-      const solverAddress2 = bidWithOptions.bid.userOp.sender;
-      console.log(`[BidManager] Simulating bid ${idx + 1}/${sortedBids.length} from solver=${solverAddress2}`);
-      const signature = await CryptoUtils.signSolverSelection(
-        commitment,
-        solverAddress2,
-        domainSeparator,
-        sessionKeyData.privateKey
-      );
-      if (!signature) {
-        console.warn(`[BidManager] Bid ${idx + 1}: failed to sign solver selection, skipping`);
-        continue;
-      }
-      const selectOptions = {
-        commitment,
-        solver: solverAddress2,
-        signature
-      };
-      try {
-        await this.simulate(bidWithOptions.bid, bidWithOptions.options, selectOptions, intentGatewayV2Address);
-        console.log(`[BidManager] Bid ${idx + 1} from solver=${solverAddress2}: simulation PASSED`);
-        selectedBid = bidWithOptions;
-        sessionSignature = signature;
-        break;
-      } catch (err) {
-        console.warn(
-          `[BidManager] Bid ${idx + 1} from solver=${solverAddress2}: simulation FAILED: ${err instanceof Error ? err.message : String(err)}`
-        );
-        continue;
-      }
+    const simulationValue = nativeOutputs + this.fillOptions.nativeDispatchFee;
+    const selectCalldata = viem.encodeFunctionData({
+      abi: ABI3,
+      functionName: "select",
+      args: [selectOptions]
+    });
+    const calls = [
+      { target: this.intentGatewayV2Address, value: 0n, data: selectCalldata },
+      { target: this.solverAddress, value: simulationValue, data: this.userOp.callData }
+    ];
+    const batchedCalldata = this.crypto.encodeERC7821Execute(calls);
+    try {
+      await this.ctx.dest.client.call({
+        account: this.solverAddress,
+        to: this.solverAddress,
+        data: batchedCalldata,
+        value: simulationValue
+      });
+    } catch (e) {
+      throw new Error(`Simulation failed: ${e instanceof Error ? e.message : String(e)}`);
     }
-    if (!selectedBid || !sessionSignature) {
-      console.error(`[BidManager] All ${sortedBids.length} bid(s) failed simulation for commitment=${commitment}`);
-      throw new Error("No bids passed simulation");
+  }
+  /**
+   * Signs the `SelectSolver` message with the session key, appends it to the
+   * solver's existing UserOp signature, and submits the UserOperation to the
+   * bundler. For same-chain orders, waits for the receipt and reads
+   * `OrderFilled` / `PartialFill` logs to determine fill status.
+   *
+   * @returns A {@link SelectBidResult} with the submitted UserOperation, its hash,
+   *   the solver address, transaction hash, and fill status.
+   * @throws If the bundler is not configured, the session key is missing, or the
+   *   bundler rejects the UserOperation.
+   */
+  async execute() {
+    const commitment = this.order.id;
+    if (!this.ctx.bundlerUrl) {
+      throw new Error("Bundler URL not configured");
     }
-    const solverAddress = selectedBid.bid.userOp.sender;
-    const finalSignature = viem.concat([
-      selectedBid.bid.userOp.signature,
-      sessionSignature
-    ]);
+    const sessionSignature = await this.signSelection();
+    const finalSignature = viem.concat([this.userOp.signature, sessionSignature]);
     const signedUserOp = {
-      ...selectedBid.bid.userOp,
+      ...this.userOp,
       signature: finalSignature
     };
     const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(
-      normalizeStateMachineId(order.destination)
+      normalizeStateMachineId(this.order.destination)
     );
-    BigInt(
-      this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
-    );
-    const bundlerResult = await this.crypto.sendBundler(BundlerMethod.ETH_SEND_USER_OPERATION, [
+    const userOpHash = await this.crypto.sendBundler(BundlerMethod.ETH_SEND_USER_OPERATION, [
       CryptoUtils.prepareBundlerCall(signedUserOp),
       entryPointAddress
     ]);
-    const userOpHash = bundlerResult;
     let txnHash;
     let fillStatus;
     let filledAssets;
@@ -15760,7 +15762,7 @@ var BidManager = class {
         { maxRetries: 5, backoffMs: 2e3, logMessage: "Fetching user operation receipt" }
       );
       txnHash = receipt.receipt.transactionHash;
-      if (order.source === order.destination) {
+      if (this.order.source === this.order.destination) {
         try {
           const chainReceipt = await this.ctx.dest.client.waitForTransactionReceipt({
             hash: txnHash,
@@ -15789,12 +15791,12 @@ var BidManager = class {
         }
       }
     } catch (err) {
-      throw new Error(`Failed to select bid: ${err instanceof Error ? err.message : String(err)}`);
+      throw new Error(`Failed to execute bid: ${err instanceof Error ? err.message : String(err)}`);
     }
     return {
       userOp: signedUserOp,
       userOpHash,
-      solverAddress,
+      solverAddress: this.solverAddress,
       commitment,
       txnHash,
       fillStatus,
@@ -15802,7 +15804,177 @@ var BidManager = class {
     };
   }
   /**
-   * Validates and sorts a list of raw bids for the given order.
+   * Prices this bid's outputs in USD using the destination chain's DEX-quote
+   * helpers. Returns `null` when any output token cannot be priced.
+   */
+  async outputUsdValue() {
+    return this.priceOutputs(this.outputs);
+  }
+};
+var BidManager = class {
+  /**
+   * @param ctx - Shared IntentsV2 context providing the destination chain
+   *   client, coprocessor, bundler URL, and session-key storage.
+   * @param crypto - Crypto utilities used for gas packing, UserOp hashing,
+   *   EIP-712 signing, and bundler calls.
+   */
+  constructor(ctx, crypto) {
+    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.
+   *
+   * The solver's signature covers a hash that binds the UserOperation to the
+   * order commitment and the session key address, so the IntentGatewayV2
+   * contract can verify the solver's intent on-chain.
+   *
+   * @param options - Parameters describing the solver account, gas limits, fee
+   *   market values, and pre-built `callData` for the fill operation.
+   * @returns A `PackedUserOperation` with the solver's signature prepended
+   *   with the order commitment.
+   */
+  async prepareSubmitBid(options) {
+    const {
+      order,
+      solverAccount,
+      solverSigner,
+      nonce,
+      entryPointAddress,
+      callGasLimit,
+      verificationGasLimit,
+      preVerificationGas,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      callData,
+      paymasterAndData = "0x"
+    } = options;
+    const chainId = BigInt(
+      this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
+    );
+    const accountGasLimits = CryptoUtils.packGasLimits(verificationGasLimit, callGasLimit);
+    const gasFees = CryptoUtils.packGasFees(maxPriorityFeePerGas, maxFeePerGas);
+    const userOp = {
+      sender: solverAccount,
+      nonce,
+      initCode: "0x",
+      callData,
+      accountGasLimits,
+      preVerificationGas,
+      gasFees,
+      paymasterAndData,
+      signature: "0x"
+    };
+    const userOpHash = CryptoUtils.computeUserOpHash(userOp, entryPointAddress, chainId);
+    const sessionKey = order.session;
+    const messageHash = viem.keccak256(viem.concat([userOpHash, order.id, sessionKey]));
+    const solverSignature = await solverSigner.signMessage(messageHash, Number(chainId));
+    const signature = viem.concat([order.id, solverSignature]);
+    return { ...userOp, signature };
+  }
+  /**
+   * Decodes raw filler bids into first-class {@link Bid} objects.
+   *
+   * Each bid's `fillOrder` fill-options are decoded from its ERC-7821 calldata;
+   * bids whose calldata cannot be decoded into a valid `fillOrder` call are
+   * silently dropped with a warning. The returned `Bid` instances are ready to
+   * be ranked, simulated, and executed by the consumer.
+   *
+   * @param order - The placed order the bids are competing to fill.
+   * @param bids - Raw filler bids fetched from the coprocessor.
+   * @param sessionPrivateKey - Optional session-key override; looked up from
+   *   storage by `order.session` if omitted.
+   * @returns Array of executable `Bid` objects (one per successfully decoded bid).
+   */
+  buildBids(order, bids, sessionPrivateKey) {
+    const chainId = this.ctx.dest.config.stateMachineId;
+    const priceOutputs = (outputs) => this.computeOutputsUsdValue(outputs, chainId);
+    const result = [];
+    for (const fillerBid of bids) {
+      const fillOptions = this.decodeBidFillOptions(fillerBid);
+      if (!fillOptions) {
+        console.warn(`[BidManager] Failed to decode fillOptions from bid by solver=${fillerBid.userOp.sender}`);
+        continue;
+      }
+      result.push(
+        new BidImpl({
+          ctx: this.ctx,
+          crypto: this.crypto,
+          order,
+          fillerBid,
+          fillOptions,
+          priceOutputs,
+          sessionPrivateKey
+        })
+      );
+    }
+    console.log(`[BidManager] Built ${result.length}/${bids.length} bid(s) successfully`);
+    return result;
+  }
+  /**
+   * Decodes raw filler bids, sorts them, simulates each until one passes, signs
+   * the `SelectSolver` message, and submits — all with no per-bid input from the
+   * caller.
+   *
+   * Equivalent to `selectAndExecuteBest(order, buildBids(order, bids, key))`.
+   *
+   * @param order - The placed order to fill.
+   * @param bids - Raw filler bids fetched from the coprocessor.
+   * @param sessionPrivateKey - Optional session-key override; looked up from
+   *   storage by `order.session` if omitted.
+   * @returns A {@link SelectBidResult} for the executed bid.
+   */
+  async selectBid(order, bids, sessionPrivateKey) {
+    return this.selectAndExecuteBest(order, this.buildBids(order, bids, sessionPrivateKey));
+  }
+  /**
+   * Autopilot bid selection: sorts the given bids by output value, simulates
+   * each in order until one passes, then executes that bid. For consumers that
+   * do not need custom selection logic.
+   *
+   * @param order - The placed order to fill.
+   * @param bids - Candidate bids (from {@link buildBids}).
+   * @returns A {@link SelectBidResult} for the executed bid.
+   * @throws If no valid bids exist, all simulations fail, or the bundler rejects
+   *   the UserOperation.
+   */
+  async selectAndExecuteBest(order, bids) {
+    const commitment = order.id;
+    console.log(`[BidManager] selectAndExecuteBest called for commitment=${commitment}, ${bids.length} bid(s)`);
+    if (!this.ctx.bundlerUrl) {
+      throw new Error("Bundler URL not configured");
+    }
+    if (!this.ctx.intentsCoprocessor) {
+      throw new Error("IntentsCoprocessor required");
+    }
+    const sortedBids = await this.sortBids(order, bids);
+    console.log(`[BidManager] ${sortedBids.length}/${bids.length} bid(s) passed validation and sorting`);
+    if (sortedBids.length === 0) {
+      throw new Error("No valid bids found");
+    }
+    console.log(`[BidManager] Simulating ${sortedBids.length} sorted bid(s) to find a valid one`);
+    for (let idx = 0; idx < sortedBids.length; idx++) {
+      const bid = sortedBids[idx];
+      console.log(`[BidManager] Simulating bid ${idx + 1}/${sortedBids.length} from solver=${bid.solverAddress}`);
+      try {
+        await bid.simulate();
+      } catch (err) {
+        console.warn(
+          `[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: simulation FAILED: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+      console.log(`[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: simulation PASSED`);
+      return bid.execute();
+    }
+    console.error(`[BidManager] All ${sortedBids.length} bid(s) failed simulation for commitment=${commitment}`);
+    throw new Error("No bids passed simulation");
+  }
+  /**
+   * Sorts a list of bids for the given order by output value.
    *
    * Delegates to one of three strategies based on the order's output token
    * composition:
@@ -15811,47 +15983,26 @@ var BidManager = class {
    * - Mixed outputs: sort by DEX-quoted USD value descending, with a raw-amount
    *   fallback if pricing fails.
    *
-   * @param bids - Raw filler bids from the coprocessor.
+   * Bids that cannot satisfy the order's token set are dropped.
+   *
    * @param order - The placed order whose output spec drives sorting logic.
-   * @returns Sorted array of `{ bid, options }` pairs ready for simulation.
+   * @param bids - Executable bids to sort (from {@link buildBids}).
+   * @returns Sorted array of `Bid` objects ready for simulation.
    */
-  async validateAndSortBids(bids, order) {
+  async sortBids(order, bids) {
     const outputs = order.output.assets;
-    const decodedBids = this.decodeBids(bids);
     if (outputs.length <= 1) {
       console.log(`[BidManager] Using single-output sorting (1 output asset)`);
-      return this.sortSingleOutput(decodedBids, outputs[0]);
+      return this.sortSingleOutput(bids, outputs[0]);
     }
     const chainId = this.ctx.dest.config.stateMachineId;
     const allStables = outputs.every((o) => this.isStableToken(bytes32ToBytes20(o.token), chainId));
     if (allStables) {
       console.log(`[BidManager] Using all-stables sorting (${outputs.length} stable output assets)`);
-      return this.sortAllStables(decodedBids, outputs, chainId);
+      return this.sortAllStables(bids, outputs, chainId);
     }
     console.log(`[BidManager] Using mixed-output sorting (${outputs.length} output assets, some non-stable)`);
-    return this.sortMixedOutputs(decodedBids, outputs, chainId);
-  }
-  /**
-   * Decodes the `fillOrder` fill-options from each bid's ERC-7821 calldata.
-   *
-   * Bids whose calldata cannot be decoded or do not contain a valid
-   * `fillOrder` call are silently dropped with a warning.
-   *
-   * @param bids - Raw bids to decode.
-   * @returns Array of successfully decoded `{ bid, options }` pairs.
-   */
-  decodeBids(bids) {
-    const result = [];
-    for (const bid of bids) {
-      const fillOptions = this.decodeBidFillOptions(bid);
-      if (fillOptions) {
-        result.push({ bid, options: fillOptions });
-      } else {
-        console.warn(`[BidManager] Failed to decode fillOptions from bid by solver=${bid.userOp.sender}`);
-      }
-    }
-    console.log(`[BidManager] Decoded ${result.length}/${bids.length} bid(s) successfully`);
-    return result;
+    return this.sortMixedOutputs(bids, outputs, chainId);
   }
   /**
    * Extracts the `FillOptions` struct from a single bid's ERC-7821
@@ -15884,149 +16035,103 @@ var BidManager = class {
     }
     return null;
   }
-  /**
-   * Simulates a bid on-chain by batching the `select` and `fillOrder` calls
-   * via `eth_call` from the solver's account, using the IntentGatewayV2
-   * ERC-7821 batch-execute pattern.
-   *
-   * The native value forwarded to the simulation is computed from the fill options:
-   * sum of any native-token (address(0)) output amounts plus the dispatch fee.
-   *
-   * @param bid - The filler bid to simulate.
-   * @param fillOptions - Decoded fill options from the bid's calldata.
-   * @param selectOptions - The signed solver-selection parameters.
-   * @param intentGatewayV2Address - Address of the IntentGatewayV2 contract on the destination chain.
-   * @throws If the `eth_call` simulation reverts or errors.
-   */
-  async simulate(bid, fillOptions, selectOptions, intentGatewayV2Address) {
-    const solverAddress = bid.userOp.sender;
-    const nativeOutputs = fillOptions.outputs.reduce(
-      (acc, o) => bytes32ToBytes20(o.token) === ADDRESS_ZERO2 ? acc + o.amount : acc,
-      0n
-    );
-    const simulationValue = nativeOutputs + fillOptions.nativeDispatchFee;
-    const selectCalldata = viem.encodeFunctionData({
-      abi: ABI3,
-      functionName: "select",
-      args: [selectOptions]
-    });
-    const calls = [
-      { target: intentGatewayV2Address, value: 0n, data: selectCalldata },
-      { target: solverAddress, value: simulationValue, data: bid.userOp.callData }
-    ];
-    const batchedCalldata = this.crypto.encodeERC7821Execute(calls);
-    try {
-      await this.ctx.dest.client.call({
-        account: solverAddress,
-        to: solverAddress,
-        data: batchedCalldata,
-        value: simulationValue
-      });
-    } catch (e) {
-      throw new Error(`Simulation failed: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
   /**
    * Case A: single output token.
    * Filter bids by token match only, sort descending by amount.
    * Partial fill bids are allowed — the contract determines fill status.
    */
-  sortSingleOutput(decodedBids, requiredAsset) {
+  sortSingleOutput(bids, requiredAsset) {
     const requiredAmount = new Decimal2__default.default(requiredAsset.amount.toString());
     console.log(
       `[BidManager] sortSingleOutput: required token=${requiredAsset.token}, amount=${requiredAmount.toString()}`
     );
     const validBids = [];
-    for (const { bid, options } of decodedBids) {
-      const bidOutput = options.outputs[0];
+    for (const bid of bids) {
+      const bidOutput = bid.outputs[0];
       const bidAmount = new Decimal2__default.default(bidOutput.amount.toString());
       if (bidOutput.token.toLowerCase() !== requiredAsset.token.toLowerCase()) {
         console.warn(
-          `[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: token mismatch (bid=${bidOutput.token}, required=${requiredAsset.token})`
+          `[BidManager] Bid from solver=${bid.solverAddress} REJECTED: token mismatch (bid=${bidOutput.token}, required=${requiredAsset.token})`
         );
         continue;
       }
       if (bidAmount.lt(requiredAmount)) {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender}: partial fill candidate (bid=${bidAmount.toString()}, required=${requiredAmount.toString()}, covers=${bidAmount.div(requiredAmount).mul(100).toFixed(2)}%)`
+          `[BidManager] Bid from solver=${bid.solverAddress}: partial fill candidate (bid=${bidAmount.toString()}, required=${requiredAmount.toString()}, covers=${bidAmount.div(requiredAmount).mul(100).toFixed(2)}%)`
         );
       } else {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED: amount=${bidAmount.toString()} (surplus=${bidAmount.minus(requiredAmount).toString()})`
+          `[BidManager] Bid from solver=${bid.solverAddress} ACCEPTED: amount=${bidAmount.toString()} (surplus=${bidAmount.minus(requiredAmount).toString()})`
         );
       }
-      validBids.push({ bid, options, amount: bidOutput.amount });
+      validBids.push({ bid, amount: bidOutput.amount });
     }
     validBids.sort((a, b) => {
       const aAmt = new Decimal2__default.default(a.amount.toString());
       const bAmt = new Decimal2__default.default(b.amount.toString());
       return bAmt.comparedTo(aAmt);
     });
-    return validBids.map(({ amount: _, ...rest }) => rest);
+    return validBids.map(({ bid }) => bid);
   }
   /**
    * Case B: all outputs are USDC/USDT.
    * Sum normalised USD values (treating each stable as $1) and sort descending.
    * Partial fill bids are allowed.
    */
-  sortAllStables(decodedBids, orderOutputs, chainId) {
+  sortAllStables(bids, orderOutputs, chainId) {
     const requiredUsd = this.computeStablesUsdValue(orderOutputs, chainId);
     console.log(`[BidManager] sortAllStables: required USD value=${requiredUsd.toString()}`);
     const validBids = [];
-    for (const { bid, options } of decodedBids) {
-      const bidUsd = this.computeStablesUsdValue(options.outputs, chainId);
+    for (const bid of bids) {
+      const bidUsd = this.computeStablesUsdValue(bid.outputs, chainId);
       if (bidUsd === null) {
-        console.warn(`[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: unable to compute USD value`);
+        console.warn(`[BidManager] Bid from solver=${bid.solverAddress} REJECTED: unable to compute USD value`);
         continue;
       }
       if (bidUsd.lt(requiredUsd)) {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender}: partial fill candidate (bid=${bidUsd.toString()}, required=${requiredUsd.toString()}, covers=${bidUsd.div(requiredUsd).mul(100).toFixed(2)}%)`
+          `[BidManager] Bid from solver=${bid.solverAddress}: partial fill candidate (bid=${bidUsd.toString()}, required=${requiredUsd.toString()}, covers=${bidUsd.div(requiredUsd).mul(100).toFixed(2)}%)`
         );
       } else {
-        console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED: USD value=${bidUsd.toString()}`
-        );
+        console.log(`[BidManager] Bid from solver=${bid.solverAddress} ACCEPTED: USD value=${bidUsd.toString()}`);
       }
-      validBids.push({ bid, options, usdValue: bidUsd });
+      validBids.push({ bid, usdValue: bidUsd });
     }
     validBids.sort((a, b) => b.usdValue.comparedTo(a.usdValue));
-    return validBids.map(({ usdValue: _, ...rest }) => rest);
+    return validBids.map(({ bid }) => bid);
   }
   /**
    * Case C: mixed output tokens (at least one non-stable).
    * Price every token via on-chain DEX quotes, fall back to raw amounts
    * if pricing is unavailable. Partial fill bids are allowed.
    */
-  async sortMixedOutputs(decodedBids, orderOutputs, chainId) {
+  async sortMixedOutputs(bids, orderOutputs, chainId) {
     const requiredUsd = await this.computeOutputsUsdValue(orderOutputs, chainId);
     if (requiredUsd === null) {
       console.warn("[BidManager] sortMixedOutputs: output tokens unpriceable, falling back to raw-amount sort");
-      return this.sortByRawAmountFallback(decodedBids, orderOutputs);
+      return this.sortByRawAmountFallback(bids, orderOutputs);
     }
     console.log(`[BidManager] sortMixedOutputs: required USD value=${requiredUsd.toString()}`);
     const validBids = [];
-    for (const { bid, options } of decodedBids) {
-      const bidUsd = await this.computeOutputsUsdValue(options.outputs, chainId);
+    for (const bid of bids) {
+      const bidUsd = await this.computeOutputsUsdValue(bid.outputs, chainId);
       if (bidUsd === null) {
-        console.warn(
-          `[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: unable to price mixed outputs`
-        );
+        console.warn(`[BidManager] Bid from solver=${bid.solverAddress} REJECTED: unable to price mixed outputs`);
         continue;
       }
       if (bidUsd.lt(requiredUsd)) {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender}: partial fill candidate (bid=${bidUsd.toString()}, required=${requiredUsd.toString()}, covers=${bidUsd.div(requiredUsd).mul(100).toFixed(2)}%)`
+          `[BidManager] Bid from solver=${bid.solverAddress}: partial fill candidate (bid=${bidUsd.toString()}, required=${requiredUsd.toString()}, covers=${bidUsd.div(requiredUsd).mul(100).toFixed(2)}%)`
         );
       } else {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED: mixed USD value=${bidUsd.toString()}`
+          `[BidManager] Bid from solver=${bid.solverAddress} ACCEPTED: mixed USD value=${bidUsd.toString()}`
         );
       }
-      validBids.push({ bid, options, usdValue: bidUsd });
+      validBids.push({ bid, usdValue: bidUsd });
     }
     validBids.sort((a, b) => b.usdValue.comparedTo(a.usdValue));
-    return validBids.map(({ usdValue: _, ...rest }) => rest);
+    return validBids.map(({ bid }) => bid);
   }
   /**
    * Fallback when DEX pricing is unavailable.
@@ -16034,17 +16139,17 @@ var BidManager = class {
    * Bids offering less than required for a token are allowed (partial fill).
    * Sorted by total offered amount descending.
    */
-  sortByRawAmountFallback(decodedBids, orderOutputs) {
+  sortByRawAmountFallback(bids, orderOutputs) {
     console.log(
-      `[BidManager] sortByRawAmountFallback: checking ${decodedBids.length} bid(s) against ${orderOutputs.length} required output(s)`
+      `[BidManager] sortByRawAmountFallback: checking ${bids.length} bid(s) against ${orderOutputs.length} required output(s)`
     );
     const validBids = [];
-    for (const { bid, options } of decodedBids) {
+    for (const bid of bids) {
       let valid = true;
       let totalOffered = new Decimal2__default.default(0);
       let rejectReason = "";
       for (const required of orderOutputs) {
-        const matching = options.outputs.find((o) => o.token.toLowerCase() === required.token.toLowerCase());
+        const matching = bid.outputs.find((o) => o.token.toLowerCase() === required.token.toLowerCase());
         if (!matching) {
           valid = false;
           rejectReason = `missing output token=${required.token}`;
@@ -16053,7 +16158,7 @@ var BidManager = class {
         totalOffered = totalOffered.plus(new Decimal2__default.default(matching.amount.toString()));
       }
       if (!valid) {
-        console.warn(`[BidManager] Bid from solver=${bid.userOp.sender} REJECTED (fallback): ${rejectReason}`);
+        console.warn(`[BidManager] Bid from solver=${bid.solverAddress} REJECTED (fallback): ${rejectReason}`);
         continue;
       }
       const totalRequired = orderOutputs.reduce(
@@ -16062,17 +16167,17 @@ var BidManager = class {
       );
       if (totalOffered.lt(totalRequired)) {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender}: partial fill candidate (fallback) (offered=${totalOffered.toString()}, required=${totalRequired.toString()}, covers=${totalOffered.div(totalRequired).mul(100).toFixed(2)}%)`
+          `[BidManager] Bid from solver=${bid.solverAddress}: partial fill candidate (fallback) (offered=${totalOffered.toString()}, required=${totalRequired.toString()}, covers=${totalOffered.div(totalRequired).mul(100).toFixed(2)}%)`
         );
       } else {
         console.log(
-          `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED (fallback): totalOffered=${totalOffered.toString()}`
+          `[BidManager] Bid from solver=${bid.solverAddress} ACCEPTED (fallback): totalOffered=${totalOffered.toString()}`
         );
       }
-      validBids.push({ bid, options, totalOffered });
+      validBids.push({ bid, totalOffered });
     }
     validBids.sort((a, b) => b.totalOffered.comparedTo(a.totalOffered));
-    return validBids.map(({ totalOffered: _, ...rest }) => rest);
+    return validBids.map(({ bid }) => bid);
   }
   // ── Token classification helpers ──────────────────────────────────
   /**
@@ -16681,6 +16786,262 @@ var OrderStatusChecker = class {
   }
 };
 
+// src/protocols/intents/quote/types.ts
+var UnsupportedIntentQuoteStrategyError = class extends Error {
+  constructor(strategy) {
+    super(`Unsupported intent quote strategy: ${strategy}`);
+    this.name = "UnsupportedIntentQuoteStrategyError";
+  }
+};
+var UnsupportedIntentQuotePairError = class extends Error {
+  constructor(params) {
+    super(
+      `No Uniswap v4 pool config found for ${params.tokenIn.symbol ?? params.tokenIn.address} -> ${params.tokenOut.symbol ?? params.tokenOut.address} on ${params.source} -> ${params.destination}`
+    );
+    this.name = "UnsupportedIntentQuotePairError";
+  }
+};
+
+// src/protocols/intents/quote/uniswapV4.ts
+var UNISWAP_INTENT_QUOTE_CHAIN = "EVM-8453" /* BASE_MAINNET */;
+var BPS_DENOMINATOR = 10000n;
+var UniswapV4IntentQuoteStrategy = class {
+  constructor(chainConfigService) {
+    this.chainConfigService = chainConfigService;
+  }
+  chainConfigService;
+  baseQuoteClient;
+  async quote(params, source, destination) {
+    this.validateQuoteParams(params);
+    const protocolFeeBps = await this.readProtocolFeeBps(source.client, source.stateMachineId);
+    const quoteClient = this.resolveQuoteClient(source, destination);
+    const poolConfig = this.resolvePoolConfig(params, source.stateMachineId, UNISWAP_INTENT_QUOTE_CHAIN);
+    return params.amountIn !== void 0 ? this.quoteExactInput({ params, client: quoteClient, protocolFeeBps, poolConfig }) : this.quoteExactOutput({ params, client: quoteClient, protocolFeeBps, poolConfig });
+  }
+  resolveQuoteClient(source, destination) {
+    if (source.stateMachineId === UNISWAP_INTENT_QUOTE_CHAIN) return source.client;
+    if (destination.stateMachineId === UNISWAP_INTENT_QUOTE_CHAIN) return destination.client;
+    if (this.baseQuoteClient) return this.baseQuoteClient;
+    const rpcUrl = this.chainConfigService.getRpcUrl(UNISWAP_INTENT_QUOTE_CHAIN);
+    if (!rpcUrl) throw new Error(`RPC URL is not configured for ${UNISWAP_INTENT_QUOTE_CHAIN}`);
+    const baseQuoteClient = viem.createPublicClient({
+      chain: chains$1.base,
+      transport: viem.http(rpcUrl)
+    });
+    this.baseQuoteClient = baseQuoteClient;
+    return baseQuoteClient;
+  }
+  validateQuoteParams(params) {
+    const hasAmountIn = params.amountIn !== void 0;
+    const hasAmountOut = params.amountOut !== void 0;
+    if (hasAmountIn === hasAmountOut) throw new Error("Provide exactly one of amountIn or amountOut");
+    if (hasAmountIn && params.amountIn <= 0n) throw new Error("amountIn must be greater than zero");
+    if (hasAmountOut && params.amountOut <= 0n) throw new Error("amountOut must be greater than zero");
+    if (params.tokenIn.address.toLowerCase() === params.tokenOut.address.toLowerCase()) {
+      throw new Error("tokenIn and tokenOut cannot be the same");
+    }
+  }
+  async readProtocolFeeBps(client, chain) {
+    const gatewayAddress = this.chainConfigService.getIntentGatewayAddress(chain);
+    if (!gatewayAddress || gatewayAddress === "0x" || gatewayAddress === viem.zeroAddress) {
+      throw new Error(`IntentGatewayV2 is not configured for chain ${chain}`);
+    }
+    const gatewayParams = await client.readContract({
+      address: gatewayAddress,
+      abi: IntentGatewayV2_default.ABI,
+      functionName: "params"
+    });
+    if (isGatewayParamsTuple(gatewayParams)) return BigInt(gatewayParams[4]);
+    return BigInt(gatewayParams.protocolFeeBps ?? 0);
+  }
+  resolvePoolConfig(params, source, destination) {
+    const override = params.uniswapV4?.poolKey;
+    if (override) {
+      const poolKey = normalizePoolKey(override);
+      const tokenInForQuote = viem.getAddress(override.currencyIn ?? params.tokenIn.address);
+      if (tokenInForQuote !== poolKey.currency0 && tokenInForQuote !== poolKey.currency1) {
+        throw new Error(
+          `Input currency ${tokenInForQuote} is not part of the override pool (${poolKey.currency0}, ${poolKey.currency1}). For cross-chain quotes pass uniswapV4.poolKey.currencyIn with the Base-side input currency address.`
+        );
+      }
+      return {
+        poolKey,
+        quoterAddress: this.resolveQuoterAddress(destination, override.quoterAddress),
+        tokenInForQuote
+      };
+    }
+    const poolConfig = this.resolveConfiguredPool(params, destination);
+    if (poolConfig) return poolConfig;
+    throw new UnsupportedIntentQuotePairError({
+      source,
+      destination,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut
+    });
+  }
+  resolveConfiguredPool(params, chain) {
+    for (const pool of this.chainConfigService.getUniswapV4PoolConfigs(chain)) {
+      const resolvedPool = this.resolveConfiguredPoolTokens(chain, pool);
+      if (!resolvedPool) continue;
+      const tokenInForQuote = matchPoolToken(params.tokenIn, resolvedPool);
+      const tokenOutForQuote = matchPoolToken(params.tokenOut, resolvedPool);
+      if (!tokenInForQuote || !tokenOutForQuote || tokenInForQuote.symbol === tokenOutForQuote.symbol) continue;
+      const { currency0, currency1 } = sortCurrencies(resolvedPool[0].address, resolvedPool[1].address);
+      return {
+        poolKey: {
+          currency0,
+          currency1,
+          fee: pool.fee,
+          tickSpacing: pool.tickSpacing,
+          hooks: viem.getAddress(pool.hooks ?? viem.zeroAddress)
+        },
+        quoterAddress: this.resolveQuoterAddress(chain),
+        tokenInForQuote: tokenInForQuote.address
+      };
+    }
+    return null;
+  }
+  resolveQuoterAddress(chain, override) {
+    const address = override ?? this.chainConfigService.getUniswapV4QuoterAddress(chain);
+    if (!address || address === "0x" || address === viem.zeroAddress) {
+      throw new Error(`Uniswap V4 quoter is not configured for chain ${chain}`);
+    }
+    return viem.getAddress(address);
+  }
+  resolveConfiguredPoolTokens(chain, pool) {
+    const first = this.resolveConfiguredPoolToken(chain, pool.tokens[0]);
+    const second = this.resolveConfiguredPoolToken(chain, pool.tokens[1]);
+    return first && second ? [first, second] : null;
+  }
+  resolveConfiguredPoolToken(chain, symbol) {
+    const address = this.chainConfigService.getAssetAddress(chain, symbol);
+    if (!address || address === "0x") return null;
+    return { symbol, address: viem.getAddress(address) };
+  }
+  async quoteExactInput(args) {
+    const amountIn = args.params.amountIn;
+    const swapAmountIn = deductProtocolFee(amountIn, args.protocolFeeBps);
+    const amountOut = await this.readV4QuoteExactInput(args.client, args.poolConfig, swapAmountIn);
+    return {
+      strategy: "uniswap_v4",
+      tradeType: "EXACT_INPUT",
+      amountIn,
+      amountOut,
+      quoteMetadata: {
+        quoteChain: UNISWAP_INTENT_QUOTE_CHAIN,
+        poolKey: args.poolConfig.poolKey,
+        quoterAddress: args.poolConfig.quoterAddress,
+        protocolFeeBps: args.protocolFeeBps
+      }
+    };
+  }
+  async quoteExactOutput(args) {
+    const amountOut = args.params.amountOut;
+    const swapAmountIn = await this.readV4QuoteExactOutput(args.client, args.poolConfig, amountOut);
+    const amountIn = grossUpForProtocolFee(swapAmountIn, args.protocolFeeBps);
+    return {
+      strategy: "uniswap_v4",
+      tradeType: "EXACT_OUTPUT",
+      amountIn,
+      amountOut,
+      quoteMetadata: {
+        quoteChain: UNISWAP_INTENT_QUOTE_CHAIN,
+        poolKey: args.poolConfig.poolKey,
+        quoterAddress: args.poolConfig.quoterAddress,
+        protocolFeeBps: args.protocolFeeBps
+      }
+    };
+  }
+  async readV4QuoteExactInput(client, poolConfig, amountIn) {
+    const data = viem.encodeFunctionData({
+      abi: UNISWAP_V4_QUOTER_ABI,
+      functionName: "quoteExactInputSingle",
+      args: [
+        {
+          poolKey: poolConfig.poolKey,
+          zeroForOne: getZeroForOne(poolConfig.tokenInForQuote, poolConfig.poolKey),
+          exactAmount: amountIn,
+          hookData: "0x"
+        }
+      ]
+    });
+    const response = await client.call({ to: poolConfig.quoterAddress, data });
+    if (!response.data || response.data === "0x") {
+      throw new Error(`Uniswap V4 quoter at ${poolConfig.quoterAddress} returned no data`);
+    }
+    const [amountOut] = viem.decodeFunctionResult({
+      abi: UNISWAP_V4_QUOTER_ABI,
+      functionName: "quoteExactInputSingle",
+      data: response.data
+    });
+    return amountOut;
+  }
+  async readV4QuoteExactOutput(client, poolConfig, amountOut) {
+    const data = viem.encodeFunctionData({
+      abi: UNISWAP_V4_QUOTER_ABI,
+      functionName: "quoteExactOutputSingle",
+      args: [
+        {
+          poolKey: poolConfig.poolKey,
+          zeroForOne: getZeroForOne(poolConfig.tokenInForQuote, poolConfig.poolKey),
+          exactAmount: amountOut,
+          hookData: "0x"
+        }
+      ]
+    });
+    const response = await client.call({ to: poolConfig.quoterAddress, data });
+    if (!response.data || response.data === "0x") {
+      throw new Error(`Uniswap V4 quoter at ${poolConfig.quoterAddress} returned no data`);
+    }
+    const [amountIn] = viem.decodeFunctionResult({
+      abi: UNISWAP_V4_QUOTER_ABI,
+      functionName: "quoteExactOutputSingle",
+      data: response.data
+    });
+    return amountIn;
+  }
+};
+function normalizePoolKey(poolKey) {
+  return {
+    currency0: viem.getAddress(poolKey.currency0),
+    currency1: viem.getAddress(poolKey.currency1),
+    fee: poolKey.fee,
+    tickSpacing: poolKey.tickSpacing,
+    hooks: viem.getAddress(poolKey.hooks)
+  };
+}
+function sortCurrencies(tokenIn, tokenOut) {
+  const input = viem.getAddress(tokenIn);
+  const output = viem.getAddress(tokenOut);
+  return BigInt(input) < BigInt(output) ? { currency0: input, currency1: output } : { currency0: output, currency1: input };
+}
+function matchPoolToken(token, poolTokens) {
+  const tokenAddress = token.address.toLowerCase();
+  const addressMatch = poolTokens.find((poolToken) => poolToken.address.toLowerCase() === tokenAddress);
+  if (addressMatch) return addressMatch;
+  const tokenSymbol = token.symbol?.toUpperCase();
+  if (!tokenSymbol) return null;
+  return poolTokens.find((poolToken) => poolToken.symbol.toUpperCase() === tokenSymbol) ?? null;
+}
+function getZeroForOne(tokenIn, poolKey) {
+  return viem.getAddress(tokenIn).toLowerCase() === viem.getAddress(poolKey.currency0).toLowerCase();
+}
+function isGatewayParamsTuple(value) {
+  return Array.isArray(value);
+}
+function deductProtocolFee(amount, protocolFeeBps) {
+  if (protocolFeeBps <= 0n) return amount;
+  const fee = amount * protocolFeeBps / BPS_DENOMINATOR;
+  return amount - fee;
+}
+function grossUpForProtocolFee(netAmount, protocolFeeBps) {
+  if (protocolFeeBps <= 0n) return netAmount;
+  return divCeil(netAmount * BPS_DENOMINATOR, BPS_DENOMINATOR - protocolFeeBps);
+}
+function divCeil(numerator, denominator) {
+  return (numerator + denominator - 1n) / denominator;
+}
+
 // src/protocols/intents/IntentGateway.ts
 var IntentGateway = class _IntentGateway {
   /** EVM chain on which orders are placed and escrowed. */
@@ -16707,6 +17068,8 @@ var IntentGateway = class _IntentGateway {
   bidManager;
   /** Estimates gas costs for filling an order and converts them to fee-token amounts. */
   gasEstimator;
+  /** Quote strategies for pricing orders before placement, keyed by strategy name. */
+  quoteStrategies;
   /**
    * Private constructor — use {@link IntentGateway.create} instead.
    *
@@ -16744,12 +17107,15 @@ var IntentGateway = class _IntentGateway {
     const bidManager = new BidManager(this.ctx, crypto);
     const gasEstimator = new GasEstimator(this.ctx, crypto);
     this.orderPlacer = new OrderPlacer(this.ctx);
-    this.orderExecutor = new OrderExecutor(this.ctx, bidManager, crypto);
+    this.orderExecutor = new OrderExecutor(this.ctx, bidManager);
     this.orderCanceller = new OrderCanceller(this.ctx);
     this.orderStatusChecker = new OrderStatusChecker(this.ctx);
     this.bidManager = bidManager;
     this.gasEstimator = gasEstimator;
     this._crypto = crypto;
+    this.quoteStrategies = {
+      uniswap_v4: new UniswapV4IntentQuoteStrategy(dest.configService)
+    };
   }
   /**
    * Creates an initialized IntentGateway instance.
@@ -16794,6 +17160,33 @@ var IntentGateway = class _IntentGateway {
       }
     }
   }
+  /**
+   * Quotes an intent between this gateway's source and destination chains.
+   *
+   * `strategy` defaults to `uniswap_v4`, currently the only supported
+   * strategy. Provide exactly one of `amountIn` or `amountOut`.
+   *
+   * The Uniswap quote strategy always prices against the configured Base
+   * pool, regardless of this gateway's destination chain. Returned
+   * `amountIn`/`amountOut` already account for the gateway's protocol fee
+   * (`quoteMetadata.protocolFeeBps`), which the gateway deducts from order
+   * inputs; apply only your own slippage tolerance before placing the order.
+   *
+   * @param params - Token pair, amount, and optional strategy/pool overrides.
+   * @returns The quoted amounts plus strategy-specific metadata.
+   * @throws {UnsupportedIntentQuoteStrategyError} For unknown strategies.
+   * @throws {UnsupportedIntentQuotePairError} When no pool is configured for the pair.
+   */
+  async quoteIntent(params) {
+    const strategy = params.strategy ?? "uniswap_v4";
+    const handler = this.quoteStrategies[strategy];
+    if (!handler) throw new UnsupportedIntentQuoteStrategyError(strategy);
+    return handler.quote(
+      { ...params, strategy },
+      { stateMachineId: this.source.config.stateMachineId, client: this.source.client },
+      { stateMachineId: this.dest.config.stateMachineId, client: this.dest.client }
+    );
+  }
   /**
    * Bidirectional async generator that orchestrates the full order lifecycle:
    * placement, fee estimation, bid collection, and execution.
@@ -16848,17 +17241,38 @@ 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.executeOrder({
-      order: finalizedOrder,
-      sessionPrivateKey,
-      auctionTimeMs: options.auctionTimeMs,
-      pollIntervalMs: options.pollIntervalMs,
-      solver: options.solver
-    })) {
-      yield status;
-    }
+    yield* this.driveExecution(
+      this.orderExecutor.executeOrder({
+        order: finalizedOrder,
+        sessionPrivateKey,
+        auctionTimeMs: options.auctionTimeMs,
+        pollIntervalMs: options.pollIntervalMs,
+        solver: options.solver
+      })
+    );
     return;
   }
+  /**
+   * Forwards updates from the executor's bidirectional generator to the caller,
+   * threading the {@link SelectBidResult} the caller feeds back after a
+   * `BIDS_RECEIVED` yield into the executor's `.next()`. Other yields expect no
+   * feedback. This is what lets the consumer own `bid.execute()` while the
+   * executor keeps tracking fills and continuing the auction.
+   */
+  async *driveExecution(execGen) {
+    try {
+      let input;
+      while (true) {
+        const { value, done } = await execGen.next(input);
+        input = void 0;
+        if (done) break;
+        const fed = yield value;
+        if (value.status === "BIDS_RECEIVED") input = fed;
+      }
+    } finally {
+      await execGen.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).
@@ -16895,14 +17309,99 @@ var IntentGateway = class _IntentGateway {
    */
   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;
+    yield* this.driveExecution(
+      this.orderExecutor.executeOrder({
+        order,
+        sessionPrivateKey: options.sessionPrivateKey,
+        auctionTimeMs: options.auctionTimeMs,
+        pollIntervalMs: options.pollIntervalMs,
+        solver: options.solver
+      })
+    );
+  }
+  /**
+   * Batteries-included variant of {@link execute}: places the order and then
+   * auto-selects the best bid each round via {@link selectAndExecuteBest}, with
+   * no bid-selection input from the caller.
+   *
+   * The caller still signs the placement transaction: this generator yields
+   * `AWAITING_PLACE_ORDER` and the caller must hand the signed tx back via
+   * `gen.next(signedTx)` exactly as with {@link execute}. Every other stage
+   * (`BIDS_RECEIVED`, `BID_SELECTED`, `FILLED`, …) is handled automatically and
+   * surfaced for observation, so the rest of the loop needs no feedback.
+   *
+   * @param order - The order to place and execute.
+   * @param graffiti - Optional orderflow-attribution tag.
+   * @param options - Same tuning parameters as {@link execute}.
+   * @yields {@link IntentOrderStatusUpdate} at each lifecycle stage.
+   */
+  async *executeBest(order, graffiti = DEFAULT_GRAFFITI, options) {
+    const gen = this.execute(order, graffiti, options);
+    try {
+      let input;
+      while (true) {
+        const { value, done } = await gen.next(input);
+        input = void 0;
+        if (done) break;
+        if (value.status === "BIDS_RECEIVED") {
+          yield value;
+          input = await this.autoSelect(order, value.bids);
+        } else if (value.status === "AWAITING_PLACE_ORDER") {
+          input = yield value;
+        } else {
+          yield value;
+        }
+      }
+    } finally {
+      await gen.return();
+    }
+  }
+  /**
+   * Batteries-included variant of {@link resume}: auto-selects the best bid each
+   * round via {@link selectAndExecuteBest}, with no bid-selection input from the
+   * caller. A plain `for await` loop is sufficient — there is no placement step.
+   *
+   * @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.
+   */
+  async *resumeBest(order, options) {
+    const gen = this.resume(order, options);
+    try {
+      let input;
+      while (true) {
+        const { value, done } = await gen.next(input);
+        input = void 0;
+        if (done) break;
+        yield value;
+        if (value.status === "BIDS_RECEIVED") {
+          input = await this.autoSelect(order, value.bids);
+        }
+      }
+    } finally {
+      await gen.return();
+    }
+  }
+  /**
+   * Auto-select wrapper used by {@link executeBest} / {@link resumeBest}.
+   *
+   * Runs {@link selectAndExecuteBest} and returns the {@link SelectBidResult} to
+   * feed back to the executor. If selection fails this round — all bids fail
+   * simulation, no valid bids, or the bundler rejects the UserOp — it swallows
+   * the error and returns `undefined`, which tells the executor to keep polling
+   * for fresh bids until the deadline rather than aborting the order. Swallowing
+   * the error here (rather than letting it propagate) also keeps the executor's
+   * `finally` teardown intact, since nothing throws across the suspended
+   * generators.
+   */
+  async autoSelect(order, bids) {
+    try {
+      return await this.selectAndExecuteBest(order, bids);
+    } catch (err) {
+      console.warn(
+        `[IntentGateway] autoSelect: bid selection failed this round, continuing to poll: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return void 0;
     }
   }
   /**
@@ -16958,10 +17457,52 @@ var IntentGateway = class _IntentGateway {
     return this.bidManager.prepareSubmitBid(options);
   }
   /**
-   * Selects the best available bid, simulates it, and submits the UserOperation
-   * to the bundler.
+   * Decodes raw filler bids into first-class {@link Bid} objects that can be
+   * ranked, simulated, and executed by the consumer.
+   *
+   * Delegates to {@link BidManager.buildBids}.
+   *
+   * @param order - The placed order the bids are competing to fill.
+   * @param bids - Raw filler bids fetched from the coprocessor.
+   * @param sessionPrivateKey - Optional session key override; looked up from
+   *   storage by `order.session` if omitted.
+   * @returns Array of executable {@link Bid} objects.
+   */
+  buildBids(order, bids, sessionPrivateKey) {
+    return this.bidManager.buildBids(order, bids, sessionPrivateKey);
+  }
+  /**
+   * Sorts bids by output value using the same strategy the autopilot uses.
+   *
+   * Delegates to {@link BidManager.sortBids}.
+   *
+   * @param order - The placed order whose output spec drives sorting.
+   * @param bids - Bids to sort (from {@link buildBids}).
+   * @returns Sorted array of {@link Bid} objects.
+   */
+  async sortBids(order, bids) {
+    return this.bidManager.sortBids(order, bids);
+  }
+  /**
+   * Autopilot bid selection: sorts the given bids, simulates each until one
+   * passes, then executes it.
+   *
+   * Delegates to {@link BidManager.selectAndExecuteBest}.
+   *
+   * @param order - The placed order to fill.
+   * @param bids - Candidate bids (from {@link buildBids}).
+   * @returns A {@link SelectBidResult} with the submitted UserOperation, hashes,
+   *   and fill status.
+   */
+  async selectAndExecuteBest(order, bids) {
+    return this.bidManager.selectAndExecuteBest(order, bids);
+  }
+  /**
+   * Decodes, sorts, simulates, signs, and submits the best of the given raw
+   * filler bids with no per-bid input from the caller.
    *
-   * Delegates to {@link BidManager.selectBid}.
+   * Delegates to {@link BidManager.selectBid}. Prefer {@link buildBids} +
+   * {@link selectAndExecuteBest} (or {@link executeBest}) for new code.
    *
    * @param order - The placed order to fill.
    * @param bids - Raw filler bids fetched from the coprocessor.
@@ -17881,7 +18422,7 @@ var HyperFungibleTokenABI = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -17932,7 +18473,7 @@ var HyperFungibleTokenABI = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -17983,7 +18524,7 @@ var HyperFungibleTokenABI = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -19002,7 +19543,7 @@ var WrappedHyperFungibleTokenABI = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -19053,7 +19594,7 @@ var WrappedHyperFungibleTokenABI = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -19104,7 +19645,7 @@ var WrappedHyperFungibleTokenABI = [
         internalType: "uint256"
       }
     ],
-    stateMutability: "view"
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
@@ -19646,13 +20187,13 @@ var HyperFungibleToken = class {
     };
     let totalNativeCost = 0n;
     try {
-      totalNativeCost = await this.source.client.readContract({
+      const { result } = await this.source.client.simulateContract({
         address: params.token,
         abi: HyperFungibleTokenABI,
         functionName: "quote",
         args: [sendParams]
       });
-      totalNativeCost = totalNativeCost * 101n / 100n;
+      totalNativeCost = result * 101n / 100n;
     } catch {
     }
     return {
@@ -21606,6 +22147,8 @@ exports.TimeoutStatus = TimeoutStatus;
 exports.TokenGateway = TokenGateway;
 exports.TronChain = TronChain;
 exports.USE_ETHERSCAN_CHAINS = USE_ETHERSCAN_CHAINS;
+exports.UnsupportedIntentQuotePairError = UnsupportedIntentQuotePairError;
+exports.UnsupportedIntentQuoteStrategyError = UnsupportedIntentQuoteStrategyError;
 exports.WrappedHyperFungibleTokenABI = WrappedHyperFungibleTokenABI;
 exports.__test = __test;
 exports.adjustDecimals = adjustDecimals;