@hyperbridge/sdk 2.8.13 → 2.8.17

package/dist/node/index.cjs

@@ -6,14 +6,14 @@ var util$1 = require('util');
 var consola = require('consola');
 var viem = require('viem');
 var chains$1 = require('viem/chains');
-var tronweb = require('tronweb');
+var utilCrypto = require('@polkadot/util-crypto');
 var lodashEs = require('lodash-es');
 var tsPattern = require('ts-pattern');
 var api = require('@polkadot/api');
 var scaleTs = require('scale-ts');
-var utilCrypto = require('@polkadot/util-crypto');
 var util = require('@polkadot/util');
 var PQueue = require('p-queue');
+var tronweb = require('tronweb');
 var stdEnv = require('std-env');
 var mergeRace = require('@async-generator/merge-race');
 var graphqlRequest = require('graphql-request');
@@ -280,6 +280,7 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
   OrderStatus2["FILLED"] = "FILLED";
   OrderStatus2["REDEEMED"] = "REDEEMED";
   OrderStatus2["REFUNDED"] = "REFUNDED";
+  OrderStatus2["CANCELLED"] = "CANCELLED";
   return OrderStatus2;
 })(OrderStatus || {});
 var TeleportStatus = /* @__PURE__ */ ((TeleportStatus2) => {
@@ -294,6 +295,8 @@ var RequestKind = /* @__PURE__ */ ((RequestKind2) => {
   RequestKind2[RequestKind2["UpdateParams"] = 2] = "UpdateParams";
   RequestKind2[RequestKind2["SweepDust"] = 3] = "SweepDust";
   RequestKind2[RequestKind2["RefundEscrow"] = 4] = "RefundEscrow";
+  RequestKind2[RequestKind2["Execute"] = 5] = "Execute";
+  RequestKind2[RequestKind2["RedeemEscrowPartial"] = 6] = "RedeemEscrowPartial";
   return RequestKind2;
 })(RequestKind || {});
 var IntentOrderStatus = Object.freeze({
@@ -306,6 +309,7 @@ var IntentOrderStatus = Object.freeze({
   BID_SELECTED: "BID_SELECTED",
   FILLED: "FILLED",
   PARTIAL_FILL: "PARTIAL_FILL",
+  CANCELLED: "CANCELLED",
   EXPIRED: "EXPIRED",
   FAILED: "FAILED"
 });
@@ -2488,7 +2492,12 @@ var ABI2 = [
 ];
 var handlerV2_default = { ABI: ABI2 };
 function tronAddress(base58) {
-  return `0x${tronweb.TronWeb.address.toHex(base58).slice(2)}`;
+  const decoded = utilCrypto.base58Decode(base58);
+  if (decoded.length !== 25 || decoded[0] !== 65) {
+    throw new Error(`Not a Tron base58 address: ${base58}`);
+  }
+  const hex = Array.from(decoded.slice(1, 21), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `0x${hex}`;
 }
 var Chains = /* @__PURE__ */ ((Chains2) => {
   Chains2["BSC_CHAPEL"] = "EVM-97";
@@ -2575,11 +2584,13 @@ var chainConfigs = {
       WETH: "0xae13d989dac2f0debff460ac112a837c89baa7cd",
       DAI: "0x1938165569a5463327fb206be06d8d9253aa06b7",
       USDC: "0xA801da100bF16D07F668F4A49E1f71fc54D05177",
-      USDT: "0xc043f483373072f7f27420d6e7d7ad269c018e18"
+      USDT: "0xc043f483373072f7f27420d6e7d7ad269c018e18",
+      cNGN: "0x2bbbd701cfc25d37f18127e51df0933566d5778a"
     },
     tokenDecimals: {
       USDC: 18,
-      USDT: 18
+      USDT: 18,
+      cNGN: 6
     },
     tokenStorageSlots: {
       USDC: { balanceSlot: 1, allowanceSlot: 2 },
@@ -2596,7 +2607,7 @@ var chainConfigs = {
       UniswapV3Quoter: "0x0000000000000000000000000000000000000000",
       UniswapV4Quoter: "0x0000000000000000000000000000000000000000",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-      SolverAccount: "0x110C7E1814c923127469Ca8939a12dAa70B96a17"
+      SolverAccount: "0x153DB990FE3b761B54ad71D0f1A0987dF11740DB"
     },
     rpcEnvKey: "BSC_CHAPEL",
     defaultRpcUrl: "https://bnb-testnet.api.onfinality.io/public",
@@ -2722,7 +2733,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
@@ -2789,7 +2800,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x10ED43C718714eb63d5aA57B78B54704E256024E",
@@ -2850,7 +2861,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -2924,7 +2935,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -2949,7 +2960,6 @@ var chainConfigs = {
     consensusStateId: "ETH0",
     coingeckoId: "base",
     layerZeroEid: 30184,
-    uniswapV4Pools: [{ tokens: ["USDC", "cNGN"], fee: 1500, tickSpacing: 30 }],
     erc4626Vaults: [
       { label: "Aave stataUSDC", address: "0xC768c589647798a6EE01A91FdE98EF2ed046DBD6", asset: "USDC" },
       { label: "Yield Bearing cNGN", address: "0xa82A3531021317240Fb32E67f9c7bC091F737D3b", asset: "cNGN" }
@@ -2999,7 +3009,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0xd2f9496824951D5237cC71245D659E48d0d5f9E8",
@@ -3074,11 +3084,13 @@ var chainConfigs = {
       //wmatic, change it to wpol
       DAI: "0x0000000000000000000000000000000000000000",
       USDC: "0xBE97E73126D66188d72fbF99029126D0340a7f18",
-      USDT: "0x0000000000000000000000000000000000000000"
+      USDT: "0x0000000000000000000000000000000000000000",
+      cNGN: "0xe4ff5d2ae65c10f530c000215029919961e8a758"
     },
     tokenDecimals: {
       USDC: 18,
-      USDT: 18
+      USDT: 18,
+      cNGN: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 0, allowanceSlot: 1 },
@@ -3091,7 +3103,7 @@ var chainConfigs = {
       Calldispatcher: "0x876F1891982E260026630c233A4897160A281Fb8",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-      SolverAccount: "0x110C7E1814c923127469Ca8939a12dAa70B96a17"
+      SolverAccount: "0x153DB990FE3b761B54ad71D0f1A0987dF11740DB"
     },
     rpcEnvKey: "POLYGON_AMOY",
     defaultRpcUrl: "https://rpc-amoy.polygon.technology",
@@ -3115,7 +3127,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
@@ -3150,7 +3162,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0xB2e26652e4BAd1e56055A051f922E06760cA0BFE",
@@ -3306,7 +3318,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x7cb55539d1144F62422099c3FA3405092022c88C",
+      SolverAccount: "0xd5535d4DeB17F050e52B6efda2fDe00435f39279",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       Calldispatcher: "0xE2C7e576E26E0bE7aC97c6fE925bcDAbD87c4bEd"
     },
@@ -3353,7 +3365,12 @@ var ABI3 = [
     type: "constructor",
     inputs: [
       {
-        name: "owner",
+        name: "intrinsic",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "extrinsic",
         type: "address",
         internalType: "address"
       }
@@ -3452,8 +3469,8 @@ var ABI3 = [
       },
       {
         name: "",
-        type: "address",
-        internalType: "address"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     outputs: [
@@ -3467,20 +3484,31 @@ var ABI3 = [
   },
   {
     type: "function",
-    name: "_owner",
-    inputs: [],
+    name: "_partialFills",
+    inputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
     outputs: [
       {
         name: "",
-        type: "address",
-        internalType: "address"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "_partialFills",
+    name: "_protocolFees",
     inputs: [
       {
         name: "",
@@ -3489,19 +3517,31 @@ var ABI3 = [
       },
       {
         name: "",
-        type: "bytes32",
-        internalType: "bytes32"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     outputs: [
       {
-        name: "",
+        name: "amount",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "committed",
         type: "uint256",
         internalType: "uint256"
       }
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "acceptOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
   {
     type: "function",
     name: "calculateCommitmentSlotHash",
@@ -3711,6 +3751,19 @@ var ABI3 = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "extrinsicModule",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "fillOrder",
@@ -3873,6 +3926,23 @@ var ABI3 = [
                 internalType: "uint256"
               }
             ]
+          },
+          {
+            name: "inputs",
+            type: "tuple[]",
+            internalType: "struct TokenInfo[]",
+            components: [
+              {
+                name: "token",
+                type: "bytes32",
+                internalType: "bytes32"
+              },
+              {
+                name: "amount",
+                type: "uint256",
+                internalType: "uint256"
+              }
+            ]
           }
         ]
       }
@@ -3898,51 +3968,63 @@ var ABI3 = [
     name: "initialize",
     inputs: [
       {
-        name: "p",
+        name: "init",
         type: "tuple",
-        internalType: "struct Params",
+        internalType: "struct InitParams",
         components: [
           {
-            name: "host",
-            type: "address",
-            internalType: "address"
-          },
-          {
-            name: "dispatcher",
-            type: "address",
-            internalType: "address"
-          },
-          {
-            name: "solverSelection",
-            type: "bool",
-            internalType: "bool"
+            name: "params",
+            type: "tuple",
+            internalType: "struct Params",
+            components: [
+              {
+                name: "host",
+                type: "address",
+                internalType: "address"
+              },
+              {
+                name: "dispatcher",
+                type: "address",
+                internalType: "address"
+              },
+              {
+                name: "solverSelection",
+                type: "bool",
+                internalType: "bool"
+              },
+              {
+                name: "surplusShareBps",
+                type: "uint256",
+                internalType: "uint256"
+              },
+              {
+                name: "protocolFeeBps",
+                type: "uint256",
+                internalType: "uint256"
+              },
+              {
+                name: "priceOracle",
+                type: "address",
+                internalType: "address"
+              }
+            ]
           },
           {
-            name: "surplusShareBps",
-            type: "uint256",
-            internalType: "uint256"
+            name: "peerChains",
+            type: "bytes[]",
+            internalType: "bytes[]"
           },
           {
-            name: "protocolFeeBps",
-            type: "uint256",
-            internalType: "uint256"
+            name: "relayer",
+            type: "address",
+            internalType: "address"
           },
           {
-            name: "priceOracle",
+            name: "owner",
             type: "address",
             internalType: "address"
           }
         ]
-      },
-      {
-        name: "peerChains",
-        type: "bytes[]",
-        internalType: "bytes[]"
-      },
-      {
-        name: "relayer",
-        type: "address",
-        internalType: "address"
       }
     ],
     outputs: [],
@@ -3967,12 +4049,25 @@ var ABI3 = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "intrinsicModule",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "migrate",
     inputs: [
       {
-        name: "relayer",
+        name: "owner_",
         type: "address",
         internalType: "address"
       }
@@ -4047,7 +4142,7 @@ var ABI3 = [
     name: "onGetResponse",
     inputs: [
       {
-        name: "incoming",
+        name: "",
         type: "tuple",
         internalType: "struct IncomingGetResponse",
         components: [
@@ -4262,6 +4357,19 @@ var ABI3 = [
     outputs: [],
     stateMutability: "nonpayable"
   },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "params",
@@ -4307,6 +4415,39 @@ var ABI3 = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "pause",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingOwner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "placeOrder",
@@ -4562,6 +4703,13 @@ var ABI3 = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
   {
     type: "function",
     name: "select",
@@ -4600,10 +4748,10 @@ var ABI3 = [
   },
   {
     type: "function",
-    name: "setRelayer",
+    name: "transferOwnership",
     inputs: [
       {
-        name: "relayer",
+        name: "newOwner",
         type: "address",
         internalType: "address"
       }
@@ -4613,19 +4761,8 @@ var ABI3 = [
   },
   {
     type: "function",
-    name: "upgradeToAndCall",
-    inputs: [
-      {
-        name: "newImplementation",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "data",
-        type: "bytes",
-        internalType: "bytes"
-      }
-    ],
+    name: "unpause",
+    inputs: [],
     outputs: [],
     stateMutability: "nonpayable"
   },
@@ -4771,6 +4908,12 @@ var ABI3 = [
         indexed: true,
         internalType: "bytes32"
       },
+      {
+        name: "solver",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
       {
         name: "tokens",
         type: "tuple[]",
@@ -5008,37 +5151,75 @@ var ABI3 = [
   },
   {
     type: "event",
-    name: "ParamsUpdated",
+    name: "OwnershipTransferStarted",
     inputs: [
       {
-        name: "previous",
-        type: "tuple",
-        indexed: false,
-        internalType: "struct Params",
-        components: [
-          {
-            name: "host",
-            type: "address",
-            internalType: "address"
-          },
-          {
-            name: "dispatcher",
-            type: "address",
-            internalType: "address"
-          },
-          {
-            name: "solverSelection",
-            type: "bool",
-            internalType: "bool"
-          },
-          {
-            name: "surplusShareBps",
-            type: "uint256",
-            internalType: "uint256"
-          },
-          {
-            name: "protocolFeeBps",
-            type: "uint256",
+        name: "previousOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      {
+        name: "previousOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "newOwner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ParamsUpdated",
+    inputs: [
+      {
+        name: "previous",
+        type: "tuple",
+        indexed: false,
+        internalType: "struct Params",
+        components: [
+          {
+            name: "host",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "dispatcher",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "solverSelection",
+            type: "bool",
+            internalType: "bool"
+          },
+          {
+            name: "surplusShareBps",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "protocolFeeBps",
+            type: "uint256",
             internalType: "uint256"
           },
           {
@@ -5146,46 +5327,73 @@ var ABI3 = [
   },
   {
     type: "event",
-    name: "RelayerUpdated",
+    name: "Paused",
     inputs: [
       {
-        name: "previous",
+        name: "account",
         type: "address",
         indexed: false,
         internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ProtocolFeeRefunded",
+    inputs: [
+      {
+        name: "commitment",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
       },
       {
-        name: "current",
+        name: "token",
         type: "address",
-        indexed: false,
+        indexed: true,
         internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
       }
     ],
     anonymous: false
   },
   {
     type: "event",
-    name: "Upgraded",
+    name: "RelayerUpdated",
     inputs: [
       {
-        name: "implementation",
+        name: "previous",
         type: "address",
-        indexed: true,
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "current",
+        type: "address",
+        indexed: false,
         internalType: "address"
       }
     ],
     anonymous: false
   },
   {
-    type: "error",
-    name: "AddressEmptyCode",
+    type: "event",
+    name: "Unpaused",
     inputs: [
       {
-        name: "target",
+        name: "account",
         type: "address",
+        indexed: false,
         internalType: "address"
       }
-    ]
+    ],
+    anonymous: false
   },
   {
     type: "error",
@@ -5221,28 +5429,17 @@ var ABI3 = [
   },
   {
     type: "error",
-    name: "ERC1967InvalidImplementation",
-    inputs: [
-      {
-        name: "implementation",
-        type: "address",
-        internalType: "address"
-      }
-    ]
-  },
-  {
-    type: "error",
-    name: "ERC1967NonPayable",
+    name: "EnforcedPause",
     inputs: []
   },
   {
     type: "error",
-    name: "Expired",
+    name: "ExpectedPause",
     inputs: []
   },
   {
     type: "error",
-    name: "FailedCall",
+    name: "Expired",
     inputs: []
   },
   {
@@ -5285,11 +5482,43 @@ var ABI3 = [
     name: "NotInitializing",
     inputs: []
   },
+  {
+    type: "error",
+    name: "OwnableInvalidOwner",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "OwnableUnauthorizedAccount",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
   {
     type: "error",
     name: "PartialFillNotAllowed",
     inputs: []
   },
+  {
+    type: "error",
+    name: "RateBelowOrder",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "RateFillTooSmall",
+    inputs: []
+  },
   {
     type: "error",
     name: "ReentrancyGuardReentrantCall",
@@ -5517,9 +5746,6 @@ 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";
   }
@@ -8256,9 +8482,7 @@ Failed HTTP Request: ${JSON.stringify(
 };
 
 // src/chains/intentsCoprocessor.ts
-var SYSTEM_EVENTS_KEY = util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a("System", 128), utilCrypto.xxhashAsU8a("Events", 128)));
 var OFFCHAIN_BID_PREFIX = new TextEncoder().encode("intents::bid::");
-var OFFCHAIN_PHANTOM_PREFIX = new TextEncoder().encode("intents::phantom::order::");
 var HYPERBRIDGE_TYPES_BUNDLE = {
   spec: {
     nexus: { hasher: utilCrypto.keccakAsU8a },
@@ -8268,11 +8492,7 @@ var HYPERBRIDGE_TYPES_BUNDLE = {
 var BASE_TIP = 1000000000n;
 var HTTP_CONNECT_TIMEOUT_MS = 2e4;
 var INCLUSION_TIMEOUT_MS = 2e4;
-var PHANTOM_POLL_INTERVAL_MS = 15e3;
-var GARGANTUA_PHANTOM_POLL_INTERVAL_MS = 6e3;
 var DEFAULT_RPC_MAX_RPS = 8;
-var DEFAULT_MAX_BLOCKS_PER_POLL = 10;
-var MAX_RATE_LIMIT_BACKOFF_TICKS = 8;
 var rpcLimiters = /* @__PURE__ */ new Map();
 function limiterFor(httpUrl) {
   const key = new URL(httpUrl).origin;
@@ -8288,45 +8508,6 @@ function configuredRpcMaxRps() {
   const parsed = raw === void 0 ? Number.NaN : Number(raw);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_RPC_MAX_RPS;
 }
-function isRateLimited(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return message.includes("[429]") || /too many requests/i.test(message);
-}
-function isMethodUnavailable(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  const code = err?.code;
-  return code === -32601 || /method not found|unsafe to be called externally/i.test(message);
-}
-var EventDecodeError = class extends Error {
-};
-function phantomOrdersFrom(records) {
-  if (records == null || typeof records[Symbol.iterator] !== "function") {
-    throw new EventDecodeError(`Expected a decoded event vector, got ${typeof records}`);
-  }
-  const orders = [];
-  for (const record of records) {
-    if (typeof record !== "object" || record === null || !("event" in record)) {
-      throw new EventDecodeError(
-        "system.events did not decode to event records \u2014 the storage entry's metadata was probably not carried through, leaving the value as raw bytes"
-      );
-    }
-    const { event } = record;
-    if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
-    const [commitment, chain, createdAt, legs] = event.data;
-    orders.push({
-      commitment: commitment.toHex(),
-      chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
-      createdAt: createdAt.toNumber(),
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      legs: legs.map((leg) => ({
-        tokenA: leg.tokenA.toHex(),
-        tokenB: leg.tokenB.toHex(),
-        standardAmount: BigInt(leg.standardAmount.toString())
-      }))
-    });
-  }
-  return orders;
-}
 function rejectAfter(ms, message) {
   return new Promise((_resolve, reject) => {
     const timer = setTimeout(() => reject(new Error(message)), ms);
@@ -8398,19 +8579,16 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   ownsConnection;
   /** Cached result of whether the node exposes intents_* RPC methods */
   hasIntentsRpc = null;
-  /** The pallet's phantom timings, read once. Cleared on failure so the read retries. */
-  phantomTimingsRead = null;
   /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
   httpApi = null;
-  /** Last runtime version read from the node, for {@link confirmedRuntimeVersion} to compare against. */
-  lastRuntimeVersion;
-  /** Set once the node refuses `state_queryStorage`, so the poll stops asking for it. */
-  rangeQueryUnavailable = false;
   // Serialises every extrinsic submission on this instance's substrate account. All submit/retract
-  // methods funnel through signAndSendExtrinsic, each using the API's auto-nonce; fired in parallel
-  // (bids for orders on different chains, or several phantom orders in one interval) they would grab
-  // the same nonce and all but one would fail. Concurrency 1 sequences them.
+  // methods funnel through signAndSendExtrinsic; fired in parallel (bids for orders on different
+  // chains, or several bids on one order) they would grab the same nonce and all but one would
+  // fail. Concurrency 1 sequences them, and {@link nextNonce} keeps consecutive submissions off
+  // each other's nonce even while the first is still in the pool.
   submissionQueue = new PQueue__default.default({ concurrency: 1 });
+  /** The highest nonce this instance has put into the pool, so the next submission clears it. */
+  lastPooledNonce;
   /**
    * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
    * This creates and manages its own API connection.
@@ -8472,10 +8650,10 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * The HTTP api is always created here, so it is always ours to close.
    */
   async disconnect() {
-    const http4 = this.httpApi;
+    const http3 = this.httpApi;
     this.httpApi = null;
-    if (http4) {
-      await http4.then((api) => api.disconnect()).catch(() => {
+    if (http3) {
+      await http3.then((api) => api.disconnect()).catch(() => {
       });
     }
     if (this.ownsConnection) {
@@ -8489,9 +8667,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    *
    * The connection attempt is bounded on both sides. `isReadyOrError` rejects on a failed
    * handshake, where plain `isReady` would simply never resolve, and the timeout covers an
-   * endpoint that accepts the request and then goes quiet. An unbounded wait here would hang the
-   * poll tick awaiting it, which is precisely the silent stall that polling exists to avoid. A
-   * failed attempt is not cached, so the next call tries again.
+   * endpoint that accepts the request and then goes quiet, so a caller awaiting it never hangs
+   * silently. A failed attempt is not cached, so the next call tries again.
    */
   async http() {
     if (!this.httpApi) {
@@ -8500,11 +8677,9 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         // Response cache off (third argument, capacity 0). polkadot-js caches every request that
         // names a block hash — `chain_getHeader(hash)`, `state_getRuntimeVersion(hash)`, storage
         // reads at a hash — by storing the request promise itself, a rejected one included, for a
-        // 30s TTL that every hit refreshes. The phantom poll retries the block it failed on with
-        // identical parameters every tick, so one reset connection became the same rejection
-        // replayed from memory on every tick, faster than the TTL could lapse, and the node never
-        // saw a second request. The cache bought nothing here anyway: the poll reads each block
-        // once, and `api.at(hash)` reuses registries at the api layer regardless.
+        // 30s TTL that every hit refreshes. A caller retrying a failed read with identical
+        // parameters would get the same rejection replayed from memory for as long as it kept
+        // retrying inside the TTL, and the node would never see a second request.
         // Concurrent calls are coalesced into one JSON-RPC batch request, and every request
         // to this endpoint is paced by a bucket shared with any other coprocessor in this
         // process pointed at the same host — the limit is the server's, and it counts
@@ -8579,7 +8754,12 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
           return { success: false, error: err instanceof Error ? err.message : String(err) };
         }
       }
-      return await this.sendExtrinsicWithRetries(build(this.api), maxRetries, timeoutMs);
+      return await this.sendExtrinsicWithRetries(
+        build(this.api),
+        maxRetries,
+        timeoutMs,
+        await this.nextNonce(this.api)
+      );
     });
     return result ?? { success: false, error: "Submission queue returned no result" };
   }
@@ -8598,7 +8778,10 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async sendViaHttp(api, build) {
     try {
-      const hash = await build(api).signAndSend(this.getKeyPair(), { tip: BASE_TIP });
+      const nonce = await this.nextNonce(api);
+      const options = nonce === void 0 ? { tip: BASE_TIP } : { tip: BASE_TIP, nonce };
+      const hash = await build(api).signAndSend(this.getKeyPair(), options);
+      if (nonce !== void 0) this.lastPooledNonce = nonce;
       return { success: false, pending: true, extrinsicHash: hash.toHex() };
     } catch (err) {
       return this.classifySubmissionError(err instanceof Error ? err : new Error(String(err)));
@@ -8611,7 +8794,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * Two kinds of failure are retried, and the difference is the nonce.
    *
    * An attempt that verifiably went nowhere (rejected before the pool, dropped, invalid) leaves
-   * the account nonce free, so the next attempt simply re-signs with the auto-nonce.
+   * the account nonce free, so the next attempt simply re-signs with the pool-aware nonce.
    *
    * An attempt that reached the pool and was still there when the watch timed out (`stalled`) is
    * retried as a *replacement*: the same nonce it was signed with, and double the tip. Substrate's
@@ -8630,16 +8813,19 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * copy is in flight and its outcome is unknown here, so the `pending` result goes back to the
    * caller to confirm later.
    */
-  async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
+  async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs, initialNonce) {
     const keyPair = this.getKeyPair();
     let attempt = 0;
-    let nonce;
+    let nonce = initialNonce;
     let stalled;
     while (attempt < maxRetries) {
       const currentTip = BASE_TIP * BigInt(2 ** attempt);
       attempt++;
       try {
         const result = await this.sendWithTimeout(extrinsic, keyPair, currentTip, timeoutMs, nonce);
+        if (nonce !== void 0 && (result.success || result.pending || result.stalled)) {
+          this.lastPooledNonce = Math.max(nonce, this.lastPooledNonce ?? nonce);
+        }
         if (result.success || result.error?.includes("Dispatch error")) {
           return result;
         }
@@ -8699,6 +8885,35 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * replacement rather than a second extrinsic queued behind the first. Left undefined on the
    * first attempt, where the api's auto-nonce is correct.
    */
+  /**
+   * The nonce the next submission signs with, or undefined when the node cannot be asked.
+   *
+   * Submissions are serialised, but a watch gives up while its extrinsic is still in the pool
+   * (`stalled`, reported as `pending`), and a pooled extrinsic does not advance the account's
+   * on-chain nonce. An extrinsic signed against on-chain state would then take the nonce of the
+   * one ahead of it and bounce off it (1013/1014) instead of queueing behind it.
+   *
+   * `system_accountNextIndex` is the only pool-aware source here. `signAndSend`'s own `nonce: -1`
+   * is not: on a runtime carrying `AccountNonceApi`, which Hyperbridge does, polkadot-js reads the
+   * nonce through that runtime call and never sees the pool.
+   *
+   * The RPC covers the ready queue, so anything of this instance's that has left it — retried,
+   * queued as future, or simply not counted yet — is covered by `lastPooledNonce` instead, which
+   * is the highest nonce this instance has put into the pool. The two are combined rather than
+   * trusted separately, so a burst never reuses a nonce and a restart still picks up the chain's.
+   */
+  async nextNonce(api) {
+    try {
+      const accountNextIndex = api.rpc?.system?.accountNextIndex;
+      if (!accountNextIndex) return void 0;
+      const next = await accountNextIndex(this.getKeyPair().address);
+      const fromPool = Number(next.toString());
+      if (!Number.isFinite(fromPool)) return void 0;
+      return this.lastPooledNonce === void 0 ? fromPool : Math.max(fromPool, this.lastPooledNonce + 1);
+    } catch {
+      return void 0;
+    }
+  }
   async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs, nonce) {
     return new Promise((resolve) => {
       let resolved = false;
@@ -8741,25 +8956,10 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         } else if (result.status.isInBlock || result.status.isFinalized) {
           resolved = true;
           clearTimeout(timeoutId);
-          const interrupted = result.events.find(
-            ({ event }) => event.section === "utility" && event.method === "BatchInterrupted"
-          );
-          if (interrupted) {
-            const [indexCodec, dispatchError] = interrupted.event.data;
-            if (Number(indexCodec.toString()) === 0) {
-              resolve({
-                success: false,
-                error: `Dispatch error: ${this.describeDispatchError(dispatchError)}`
-              });
-              return;
-            }
-          }
           resolve({
             success: true,
             blockHash: (result.status.isInBlock ? result.status.asInBlock : result.status.asFinalized).toHex(),
-            extrinsicHash: extrinsic.hash.toHex(),
-            // Carried so a batch caller can attribute each item's outcome.
-            events: result.events
+            extrinsicHash: extrinsic.hash.toHex()
           });
         }
       }).then((unsub) => {
@@ -8780,13 +8980,19 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   /**
    * Submits a bid to Hyperbridge's pallet-intents
    *
+   * A filler can hold several bids on one order, one per price it offers, and `bid` tells them
+   * apart: submitting again under an identifier the filler already holds replaces that bid alone.
+   * By convention it is `keccak256` of the UserOp's `callData`, which is also what gives each bid
+   * its own nonce key on the `SolverAccount` (see `CryptoUtils.bidId`).
+   *
    * @param commitment - The order commitment hash (bytes32)
    * @param userOp - The encoded PackedUserOperation as hex string
+   * @param bid - Identifies this bid among the filler's bids on the order (bytes32)
    * @returns BidSubmissionResult with success status and block/extrinsic hash
    */
-  async submitBid(commitment, userOp) {
+  async submitBid(commitment, userOp, bid) {
     try {
-      return await this.signAndSendExtrinsic((api) => api.tx.intentsCoprocessor.placeBid(commitment, userOp));
+      return await this.signAndSendExtrinsic((api) => api.tx.intentsCoprocessor.placeBid(commitment, bid, userOp));
     } catch (error) {
       return {
         success: false,
@@ -8800,46 +9006,12 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * Use this to remove unused quotes and claim back deposited BRIDGE tokens.
    *
    * @param commitment - The order commitment hash (bytes32)
+   * @param bid - Which of the filler's bids on the order to retract (bytes32)
    * @returns BidSubmissionResult with success status and block/extrinsic hash
    */
-  async retractBid(commitment) {
-    try {
-      return await this.signAndSendExtrinsic((api) => api.tx.intentsCoprocessor.retractBid(commitment));
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Places a new bid and retracts a previous one in a single transaction via utility.batch.
-   *
-   * The new bid is the primary operation, so `placeBid` MUST run first. `utility.batch` is
-   * non-atomic: a failing call interrupts the batch (via a BatchInterrupted event) without
-   * reverting the calls that already succeeded. Placing first guarantees the new bid lands even
-   * when the retraction then fails — which it routinely does, because a previous commitment's bid
-   * may already be gone (or was itself never placed), making `retractBid` return `BidNotFound`.
-   *
-   * Ordering retraction first (the previous behaviour) caused a self-sustaining cascade: a
-   * `BidNotFound` on the leading retract skipped the trailing `placeBid`, so the current bid never
-   * landed, so the *next* interval's retract of that never-placed commitment also failed, and so
-   * on — silently, because the batch extrinsic itself reports success. The deposit reclaim is
-   * best-effort; landing the bid is not.
-   *
-   * @param retractCommitment - The order commitment of the bid to retract (bytes32)
-   * @param bidCommitment - The order commitment of the new bid (bytes32)
-   * @param userOp - The encoded PackedUserOperation as hex string
-   * @returns BidSubmissionResult with success status and block/extrinsic hash
-   */
-  async submitBidWithRetraction(retractCommitment, bidCommitment, userOp) {
+  async retractBid(commitment, bid) {
     try {
-      return await this.signAndSendExtrinsic(
-        (api) => api.tx.utility.batch([
-          api.tx.intentsCoprocessor.placeBid(bidCommitment, userOp),
-          api.tx.intentsCoprocessor.retractBid(retractCommitment)
-        ])
-      );
+      return await this.signAndSendExtrinsic((api) => api.tx.intentsCoprocessor.retractBid(commitment, bid));
     } catch (error) {
       return {
         success: false,
@@ -8847,89 +9019,6 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       };
     }
   }
-  /**
-   * Places every phantom bid of one interval in a single extrinsic, retracting each chain's
-   * previous bid alongside it.
-   *
-   * The pallet registers one phantom order per configured chain in the same block, so this is the
-   * whole interval's set. Submitting them one at a time costs a block per chain: submissions are
-   * serialised on the account nonce and each waits for inclusion, so the last chain's bid is many
-   * blocks behind the first, against a bid window measured in tens of blocks. Batched, every bid
-   * lands in the same block.
-   *
-   * Uses `utility.force_batch`, not `utility.batch`. `batch` stops at the first failing call, so
-   * one rejected bid — a closed window, a duplicate, an insufficient deposit — would silently
-   * drop every bid after it. `force_batch` runs them all and reports each outcome. It needs no
-   * special origin: any signed account may call it, exactly like `batch`.
-   *
-   * @param bids - The bids to place; an empty list is a no-op
-   * @returns Per-bid outcomes, in the order given
-   */
-  async submitPhantomBids(bids) {
-    if (bids.length === 0) return { bids: [] };
-    const placeIndexByBid = [];
-    let callCount = 0;
-    for (const bid of bids) {
-      placeIndexByBid.push(callCount);
-      callCount += bid.retractCommitment ? 2 : 1;
-    }
-    const outcome = await this.signAndSendExtrinsic(
-      (api) => api.tx.utility.forceBatch(
-        bids.flatMap((bid) => {
-          const calls = [api.tx.intentsCoprocessor.placeBid(bid.commitment, bid.userOp)];
-          if (bid.retractCommitment) {
-            calls.push(api.tx.intentsCoprocessor.retractBid(bid.retractCommitment));
-          }
-          return calls;
-        })
-      )
-    );
-    if (!outcome.success) {
-      return {
-        bids: bids.map((bid) => ({ commitment: bid.commitment, success: false, error: outcome.error })),
-        pending: outcome.pending,
-        extrinsicHash: outcome.extrinsicHash,
-        error: outcome.error
-      };
-    }
-    const items = this.readForceBatchItems(outcome.events ?? [], callCount);
-    return {
-      bids: bids.map((bid, index) => {
-        const error = items.errors[placeIndexByBid[index]];
-        return { commitment: bid.commitment, success: !error, error };
-      }),
-      blockHash: outcome.blockHash,
-      extrinsicHash: outcome.extrinsicHash,
-      error: items.error
-    };
-  }
-  /**
-   * Reads one outcome per call out of a force_batch's events.
-   *
-   * `ItemFailed` carries no index — pallet-utility emits exactly one `ItemCompleted` or
-   * `ItemFailed` per call, in call order, so the k-th item event belongs to call k.
-   *
-   * A count that does not match the calls submitted means the events are not the ones assumed
-   * here, and every attribution after the discrepancy would be off by one. The bids are then
-   * reported as placed: a bid wrongly recorded as landed is retracted next interval and the
-   * retraction harmlessly fails with `BidNotFound`, whereas one wrongly recorded as failed is
-   * never retracted at all and leaves its deposit reserved.
-   */
-  readForceBatchItems(events, callCount) {
-    const errors = [];
-    for (const { event } of events) {
-      if (event.section !== "utility") continue;
-      if (event.method === "ItemCompleted") errors.push(void 0);
-      else if (event.method === "ItemFailed") errors.push(this.describeDispatchError(event.data[0]));
-    }
-    if (errors.length !== callCount) {
-      return {
-        errors: new Array(callCount).fill(void 0),
-        error: `force_batch reported ${errors.length} item events for ${callCount} calls; outcomes not attributed`
-      };
-    }
-    return { errors };
-  }
   /** Renders a DispatchError as `pallet::Error`, falling back to its raw form. */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   describeDispatchError(dispatchError) {
@@ -8948,10 +9037,11 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async getBidStorageEntries(commitment) {
     const api = await this.http();
-    const entries = await api.query.intentsCoprocessor.bids.entries(commitment);
+    const entries = await api.query.intentsCoprocessor.orderBids.entries(commitment);
     return entries.map(([storageKey, depositValue]) => ({
       commitment,
       filler: storageKey.args[1].toString(),
+      bid: storageKey.args[2].toHex(),
       deposit: BigInt(depositValue.toString())
     }));
   }
@@ -8983,7 +9073,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     return result.map((entry) => {
       const userOp = decodeUserOpScale(entry.user_op);
       const filler = new api.Keyring({ type: "sr25519" }).encodeAddress(util.hexToU8a(entry.filler));
-      return { filler, userOp, deposit: 0n };
+      return { filler, bid: entry.bid, userOp, deposit: 0n };
     });
   }
   /**
@@ -8992,19 +9082,20 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async getBidsViaStorage(commitment) {
     const api = await this.http();
-    const entries = await api.query.intentsCoprocessor.bids.entries(commitment);
+    const entries = await api.query.intentsCoprocessor.orderBids.entries(commitment);
     if (entries.length === 0) return [];
     const bidPromises = entries.map(async ([storageKey, depositValue]) => {
       try {
         const filler = storageKey.args[1].toString();
+        const bid = storageKey.args[2].toHex();
         const deposit = BigInt(depositValue.toString());
-        const offchainKey = this.buildOffchainBidKey(commitment, filler);
+        const offchainKey = this.buildOffchainBidKey(commitment, filler, bid);
         const offchainKeyHex = util.u8aToHex(offchainKey);
         const offchainResult = await api.rpc.offchain.localStorageGet("PERSISTENT", offchainKeyHex);
         if (!offchainResult || offchainResult.isNone) return null;
         const bidData = offchainResult.unwrap().toHex();
         const decoded = this.decodeBid(bidData);
-        return { filler: decoded.filler, userOp: decoded.userOp, deposit };
+        return { filler: decoded.filler, bid, userOp: decoded.userOp, deposit };
       } catch {
         return null;
       }
@@ -9020,418 +9111,38 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     const userOp = decodeUserOpScale(userOpHex);
     return { filler, userOp };
   }
-  /** Builds offchain storage key: "intents::bid::" + commitment + filler */
-  buildOffchainBidKey(commitment, filler) {
-    return util.u8aConcat(OFFCHAIN_BID_PREFIX, util.hexToU8a(commitment), utilCrypto.decodeAddress(filler));
+  /** Builds offchain storage key: "intents::bid::" + commitment + filler + bid */
+  buildOffchainBidKey(commitment, filler, bid) {
+    return util.u8aConcat(OFFCHAIN_BID_PREFIX, util.hexToU8a(commitment), utilCrypto.decodeAddress(filler), util.hexToU8a(bid));
   }
-  /**
-   * Fetches the ABI-encoded phantom order from offchain storage and decodes it
-   * into an `Order` object. The pallet writes the order bytes under the key
-   * `intents::phantom::order::<commitment>` when it calls `on_initialize`.
-   *
-   * Returns `null` if the key is absent (e.g. the node is not an offchain worker
-   * or the commitment has expired and been cleared).
-   */
-  async fetchPhantomOrder(commitment) {
-    const key = util.u8aConcat(OFFCHAIN_PHANTOM_PREFIX, util.hexToU8a(commitment));
-    const api = await this.http();
-    const result = await api.rpc.offchain.localStorageGet("PERSISTENT", util.u8aToHex(key));
-    if (!result || result.isNone) return null;
-    const rawHex = result.unwrap().toHex();
-    if (rawHex === "0x" || rawHex === "0x00") return null;
-    const placeOrderAbi = IntentGatewayV2_default.ABI.find((item) => item.type === "function" && item.name === "placeOrder");
-    const orderType = placeOrderAbi?.inputs?.[0];
-    if (!orderType) return null;
-    const [decoded] = viem.decodeAbiParameters([orderType], rawHex);
-    const d = decoded;
-    const textDecoder = new TextDecoder();
-    return {
-      id: commitment,
-      user: d.user,
-      source: textDecoder.decode(viem.hexToBytes(d.source)),
-      destination: textDecoder.decode(viem.hexToBytes(d.destination)),
-      deadline: d.deadline,
-      nonce: d.nonce,
-      fees: d.fees,
-      session: d.session,
-      predispatch: {
-        assets: d.predispatch.assets.map((a) => ({
-          token: a.token,
-          amount: a.amount
-        })),
-        call: d.predispatch.call
-      },
-      inputs: d.inputs.map((i) => ({
-        token: i.token,
-        amount: i.amount
-      })),
-      output: {
-        beneficiary: d.output.beneficiary,
-        assets: d.output.assets.map((a) => ({
-          token: a.token,
-          amount: a.amount
-        })),
-        call: d.output.call
-      }
-    };
+};
+var TronChain = class _TronChain {
+  constructor(params, evm) {
+    this.params = params;
+    this.evm = evm;
+    this.tronWebInstance = new tronweb.TronWeb({ fullHost: params.rpcUrl });
   }
+  params;
+  evm;
+  tronWebInstance;
   /**
-   * Reads the PhantomOrderRegistered events emitted in a single block.
+   * Creates a `TronChain` instance from a fully-specified config object.
    *
-   * Costs two RPCs per block when `knownVersion` is supplied and four without it, which is why the
-   * poll goes to the trouble of establishing one. `api.at(hash)` has to work out which metadata to
-   * decode the block against, and with nothing to go on it fetches the header and then the runtime
-   * version at its parent — every block, forever. Its cheaper paths are a registry already pinned
-   * to this exact hash (only ever the previous block's) or one matching a version the caller
-   * names, so naming the version is the only way out. See `getBlockRegistry` in
-   * `@polkadot/api/base/Init`; the `getUpgradeVersion` shortcut that would otherwise skip the
-   * lookup only covers chains hardcoded in `@polkadot/types-known`, which Hyperbridge is not.
+   * This is the only public way to construct a `TronChain` — the constructor is private.
    *
-   * @param knownVersion - the runtime version this block is known to run, if the caller has
-   *   established one. Passing a version the block does not actually run decodes it against the
-   *   wrong metadata, so this is for callers that have checked, not a place to pass a guess.
+   * @param params - Tron chain configuration
+   * @returns A `TronChain` instance
    */
-  async getPhantomOrdersInBlock(blockNumber, knownVersion) {
-    const api = await this.http();
-    const blockHash = await api.rpc.chain.getBlockHash(blockNumber);
-    return await this.getPhantomOrdersAtHash(blockHash.toHex(), knownVersion);
+  static async fromParams(params) {
+    const evm = await EvmChain.create(params.rpcUrl, params.bundlerUrl);
+    return new _TronChain(params, evm);
   }
-  /**
-   * The same read, for a caller that already holds the block's hash.
-   *
-   * Split out so the poll can fetch a whole range's hashes in one concurrent wave — which the
-   * provider coalesces into a single batched request — and then read each block's events knowing
-   * its hash. `chain_getBlockHash` is the half of the pair that parallelises safely: it takes no
-   * historic block hash, so it never triggers polkadot-js's per-hash registry resolution, and
-   * concurrent calls cannot race each other's registry state.
-   */
-  async getPhantomOrdersAtHash(blockHash, knownVersion) {
-    const api = await this.http();
-    const apiAt = await api.at(blockHash, knownVersion);
-    return phantomOrdersFrom(await apiAt.query.system.events());
-  }
-  /**
-   * Every block's phantom orders across a whole range, in one `state_queryStorage` call.
-   *
-   * This is the cheap path: the request cost of a scan stops depending on how many blocks it
-   * covers. The events key is the only key queried, and both bounds are block hashes the caller
-   * already holds.
-   *
-   * Two properties of the RPC shape the result.
-   *
-   * It returns *diffs*: `query_storage_unfiltered` in `sc-rpc` pushes a change set for a block only
-   * when the value differs from the previous block in the range (`has_changed`, and the set is
-   * dropped when empty), so a block whose events encode byte-for-byte identically to its
-   * predecessor's is simply absent. That happens on a quiet chain, where consecutive blocks carry
-   * nothing but the timestamp inherent's `ExtrinsicSuccess`. It is safe here because an absent
-   * block provably carries no phantom orders: a `PhantomOrderRegistered` commitment is derived from
-   * the block number (`phantom_order_commitment`), so a block that registered orders can never
-   * encode identically to any other block. Absent therefore means "same as the previous block",
-   * and the previous block having orders would contradict that.
-   *
-   * And it is gated by `--rpc-methods` (`check_if_safe` in `sc-rpc`), which answers a denied call
-   * with `Method not found`. The node this reads from must already run unsafe RPC to serve
-   * `offchain_localStorageGet` for the orders themselves, so this is normally available; the poll
-   * falls back to reading block by block when it is not.
-   *
-   * @returns one entry per block the node reported a change for, in ascending block order.
-   */
-  async getPhantomOrdersInRange(fromBlockHash, toBlockHash) {
-    const api = await this.http();
-    const changeSets = await api.rpc.state.queryStorage.raw(
-      [SYSTEM_EVENTS_KEY],
-      fromBlockHash,
-      toBlockHash
-    );
-    return changeSets.map((changeSet) => {
-      const value = changeSet?.changes?.find(([key]) => key === SYSTEM_EVENTS_KEY)?.[1];
-      if (!value) return [];
-      return phantomOrdersFrom(api.registry.createType("Vec<EventRecord>", value));
-    });
-  }
-  /**
-   * Polls for newly registered phantom orders, invoking the callback once per block that carries
-   * any, with all of that block's orders.
-   *
-   * Per block rather than per order because that is how the pallet writes them: one order per
-   * configured chain, all registered in the same `on_initialize`. Delivering them together lets a
-   * caller bid on the whole interval in one extrinsic (see {@link submitPhantomBids}) instead of
-   * one per chain.
-   *
-   * Each tick reads the current head and scans every block between the last one processed and that
-   * head, so the block cursor — not the connection — determines what has been seen. This replaced a
-   * system.events subscription, which was only as reliable as its socket: polkadot-js reconnects
-   * the transport but does not reliably re-establish storage subscriptions, and anything emitted
-   * while disconnected was lost silently. With a bid window measured in a handful of blocks, that
-   * meant silently missed bids.
-   *
-   * Scanning a block range is gap-free rather than merely self-healing: an outage delays orders but
-   * cannot drop them, because the cursor only advances past a block whose events were actually
-   * read. Recovery replays the backlog.
-   *
-   * Every read here goes over HTTP, never the websocket. Polling is a sequence of independent
-   * one-shot requests with no state to lose between them, which is exactly what a stateless
-   * transport does well: a request either answers or fails loudly on this tick, instead of a
-   * socket that looks alive while delivering nothing. It also means a websocket outage does not
-   * pause phantom bidding at all — the two transports fail independently.
-   *
-   * What the cadence does *not* describe is the request rate, which is what rate limiters police.
-   * A tick costs four requests whatever the range covers — the head, the runtime version, the two
-   * bounding block hashes as one batched request, and one `state_queryStorage` for every block's
-   * events — and they go out back-to-back, so an interval well under any per-second limit could
-   * still arrive as a burst over it. Three things keep that in bounds: the provider coalesces
-   * concurrent calls into one request and paces requests through the endpoint's token bucket (see
-   * `http`), and `maxBlocksPerPoll` bounds the range. A 429 that gets through anyway backs the
-   * poll off for a doubling number of ticks, so a limiter that is already shedding load is not
-   * handed the next window's budget in rejections too.
-   *
-   * Where the node will not serve `state_queryStorage` the poll reads block by block instead, at
-   * three requests plus one per block; see {@link scanRangeAtOnce}.
-   *
-   * Returns a function that stops polling.
-   */
-  pollPhantomOrders(callback, options = {}) {
-    const {
-      intervalMs,
-      maxBlocksPerPoll = DEFAULT_MAX_BLOCKS_PER_POLL,
-      onError,
-      onSkip
-    } = options;
-    let cursor = null;
-    let inFlight = false;
-    let stopped = false;
-    let backoffTicks = 0;
-    let backoffLength = 0;
-    const tick = async () => {
-      if (inFlight || stopped) return;
-      if (backoffTicks > 0) {
-        backoffTicks -= 1;
-        return;
-      }
-      inFlight = true;
-      try {
-        const api = await this.http();
-        const head = (await api.rpc.chain.getHeader()).number.toNumber();
-        if (cursor === null) {
-          cursor = Math.max(head - 1, -1);
-        } else {
-          const { bidWindowBlocks, intervalBlocks } = await this.phantomTimings();
-          if (head - cursor > bidWindowBlocks + Math.max(intervalBlocks, bidWindowBlocks)) {
-            const from = cursor + 1;
-            cursor = Math.max(head - 1 - bidWindowBlocks, -1);
-            onSkip?.({ from, to: cursor, head });
-          }
-        }
-        if (head <= cursor) return;
-        const knownVersion = await this.confirmedRuntimeVersion();
-        const to = Math.min(head, cursor + maxBlocksPerPoll);
-        const ranged = await this.scanRangeAtOnce(api, cursor + 1, to, knownVersion, onError);
-        if (ranged) {
-          for (const orders of ranged) {
-            if (stopped) return;
-            if (orders.length > 0) callback(orders);
-          }
-          cursor = to;
-          backoffLength = 0;
-          return;
-        }
-        const numbers = [];
-        for (let blockNumber = cursor + 1; blockNumber <= to; blockNumber++) numbers.push(blockNumber);
-        const hashes = await Promise.allSettled(
-          numbers.map((blockNumber) => api.rpc.chain.getBlockHash(blockNumber))
-        );
-        for (let index = 0; index < numbers.length; index++) {
-          if (stopped) return;
-          const hash = hashes[index];
-          if (hash.status === "rejected") throw hash.reason;
-          const orders = await this.getPhantomOrdersAtHash(hash.value.toHex(), knownVersion);
-          if (orders.length > 0) callback(orders);
-          cursor = numbers[index];
-        }
-        backoffLength = 0;
-      } catch (err) {
-        if (isRateLimited(err)) {
-          backoffLength = Math.min(backoffLength === 0 ? 1 : backoffLength * 2, MAX_RATE_LIMIT_BACKOFF_TICKS);
-          backoffTicks = backoffLength;
-        }
-        onError?.(err);
-      } finally {
-        inFlight = false;
-      }
-    };
-    void tick();
-    let timer = null;
-    const startTimer = (ms) => {
-      if (stopped) return;
-      timer = setInterval(() => void tick(), ms);
-    };
-    if (intervalMs !== void 0) startTimer(intervalMs);
-    else void this.phantomPollIntervalMs().then(startTimer);
-    return () => {
-      stopped = true;
-      if (timer) clearInterval(timer);
-    };
-  }
-  /**
-   * The Hyperbridge head, over HTTP like every other read here.
-   *
-   * Exposed for callers that have to know how old something is: a phantom order carries the block
-   * it was registered at, and only against the head does that become "still biddable" or "long
-   * expired".
-   */
-  async latestBlockNumber() {
-    const api = await this.http();
-    return (await api.rpc.chain.getHeader()).number.toNumber();
-  }
-  /**
-   * The pallet's phantom timings, read from chain state.
-   *
-   * Both are governance-settable and neither is derivable: on Nexus today the window is 15 while
-   * the runtime constant behind it is 25, so anything hard-coded is wrong in one direction or the
-   * other — too tight and live orders are dropped, too loose and bids are sent into a closed
-   * window for the pallet to reject.
-   *
-   * Read once per instance and cached, because a governance change to either is rare and a read
-   * per poll tick would be a request per tick forever. The cost is that a change is picked up on
-   * the next restart rather than immediately. A failed read is not cached, so it retries.
-   */
-  async phantomTimings() {
-    if (!this.phantomTimingsRead) {
-      this.phantomTimingsRead = this.readPhantomTimings().catch((err) => {
-        this.phantomTimingsRead = null;
-        throw err;
-      });
-    }
-    return this.phantomTimingsRead;
-  }
-  async readPhantomTimings() {
-    const api = await this.http();
-    const [window, interval] = await Promise.all([
-      api.query.intentsCoprocessor.phantomBidWindow(),
-      api.query.intentsCoprocessor.phantomOrderInterval()
-    ]);
-    const stored = Number(window.toString());
-    return {
-      bidWindowBlocks: stored === 0 ? Number(api.consts.intentsCoprocessor.phantomOrderBidWindowBlocks.toString()) : stored,
-      intervalBlocks: Number(interval.toString())
-    };
-  }
-  /**
-   * A whole range of blocks in one `state_queryStorage` call, or `null` when that is not available
-   * and the caller should read block by block.
-   *
-   * Two conditions have to hold, and both are about decoding rather than the range itself.
-   *
-   * The version must be confirmed for this tick — an upgrade inside the range means blocks decode
-   * against different metadata, and one call cannot do that.
-   *
-   * And that confirmed version must still be the one the api's own registry was built for.
-   * `state_queryStorage` declares no historic block hash, so rpc-core skips its registry swap and
-   * decodes the reply against the default registry — fixed at connect, with no
-   * `subscribeRuntimeVersion` on an HTTP api to refresh it. After an upgrade the two diverge, and
-   * the per-block path takes over for good: `api.at(hash, version)` resolves, and builds, the right
-   * registry. That costs a restart to get the cheap path back, which is the correct direction to
-   * fail in.
-   */
-  async scanRangeAtOnce(api, from, to, knownVersion, onError) {
-    if (this.rangeQueryUnavailable || !knownVersion) return null;
-    const registryVersion = api.runtimeVersion?.specVersion;
-    if (!registryVersion || !knownVersion.specVersion.eq(registryVersion)) return null;
-    const [fromHash, toHash] = from === to ? await Promise.all([api.rpc.chain.getBlockHash(from)]).then(([only]) => [only, only]) : await Promise.all([api.rpc.chain.getBlockHash(from), api.rpc.chain.getBlockHash(to)]);
-    try {
-      return await this.getPhantomOrdersInRange(fromHash.toHex(), toHash.toHex());
-    } catch (err) {
-      if (isMethodUnavailable(err)) {
-        this.rangeQueryUnavailable = true;
-        return null;
-      }
-      if (err instanceof EventDecodeError) {
-        this.rangeQueryUnavailable = true;
-        onError?.(err);
-        return null;
-      }
-      throw err;
-    }
-  }
-  /**
-   * The runtime version this tick's blocks may be decoded against, or `undefined` when that cannot
-   * be established and each block must resolve its own.
-   *
-   * Naming a version to `api.at` is what removes two of the four RPCs a block scan costs, and it
-   * is only sound while the version is actually the block's. Getting that wrong is not a loud
-   * failure: events decoded against the wrong metadata come back as a shape the scan does not
-   * recognise, so the block reads as carrying no phantom orders and the cursor advances past it —
-   * exactly the silent miss the block cursor exists to rule out.
-   *
-   * So the version is read fresh each tick and only used when it matches the previous reading.
-   * `specVersion` only ever increases, and this read happens *after* the head read, so two equal
-   * readings mean no upgrade landed anywhere in between — and therefore none in the range about to
-   * be scanned. A reading that differs means an upgrade landed inside the range: that tick falls
-   * back to per-block resolution, which is exact, and the version is used from the next tick on
-   * once it has been seen twice.
-   *
-   * The gap this leaves is a backlog reaching back past an upgrade, whose oldest blocks predate
-   * even the previous reading. Recovering from an outage that long means those bid windows closed
-   * many upgrades ago, so nothing is lost that was still winnable.
-   *
-   * A version that cannot be read at all yields `undefined` rather than an error: the scan is
-   * about to make the same request against the same endpoint and is the better place to report it.
-   */
-  async confirmedRuntimeVersion() {
-    let api;
-    let current;
-    try {
-      api = await this.http();
-      current = await api.rpc.state.getRuntimeVersion();
-    } catch {
-      return void 0;
-    }
-    const previous = this.lastRuntimeVersion ?? api.runtimeVersion;
-    this.lastRuntimeVersion = current;
-    if (!previous?.specVersion || !previous?.specName) return void 0;
-    return current.specVersion.eq(previous.specVersion) && current.specName.eq(previous.specName) ? current : void 0;
-  }
-  /**
-   * The poll cadence for the runtime this instance is connected to: Gargantua polls every block,
-   * everything else every 15s. Falls back to the slower cadence if the runtime cannot be read,
-   * since an unreachable node is the poll's problem to report, not the cadence lookup's.
-   */
-  async phantomPollIntervalMs() {
-    try {
-      const specName = (await this.http()).runtimeVersion.specName.toString();
-      return specName === "gargantua" ? GARGANTUA_PHANTOM_POLL_INTERVAL_MS : PHANTOM_POLL_INTERVAL_MS;
-    } catch {
-      return PHANTOM_POLL_INTERVAL_MS;
-    }
-  }
-};
-var TronChain = class _TronChain {
-  constructor(params, evm) {
-    this.params = params;
-    this.evm = evm;
-    this.tronWebInstance = new tronweb.TronWeb({ fullHost: params.rpcUrl });
-  }
-  params;
-  evm;
-  tronWebInstance;
-  /**
-   * Creates a `TronChain` instance from a fully-specified config object.
-   *
-   * This is the only public way to construct a `TronChain` — the constructor is private.
-   *
-   * @param params - Tron chain configuration
-   * @returns A `TronChain` instance
-   */
-  static async fromParams(params) {
-    const evm = await EvmChain.create(params.rpcUrl, params.bundlerUrl);
-    return new _TronChain(params, evm);
-  }
-  // -------------------------------------------------------------------------
-  // Public accessors
-  // -------------------------------------------------------------------------
-  /** Underlying viem public client (delegated from the internal EvmChain) */
-  get client() {
-    return this.evm.client;
+  // -------------------------------------------------------------------------
+  // Public accessors
+  // -------------------------------------------------------------------------
+  /** Underlying viem public client (delegated from the internal EvmChain) */
+  get client() {
+    return this.evm.client;
   }
   /** Host contract address for this chain (delegated from the internal EvmChain) */
   get host() {
@@ -10487,8 +10198,8 @@ var PharosChain = class _PharosChain {
 };
 async function generateRootWithProof(postRequest, treeSize) {
   const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
-  const { commitment: hash, encodePacked: encodePacked4 } = postRequestCommitment(postRequest);
-  const result = JSON.parse(generate_root_with_proof2(viem.hexToBytes(encodePacked4), treeSize));
+  const { commitment: hash, encodePacked: encodePacked5 } = postRequestCommitment(postRequest);
+  const result = JSON.parse(generate_root_with_proof2(viem.hexToBytes(encodePacked5), treeSize));
   const { root, proof, mmr_size, keccak_hash_calldata } = result;
   if (keccak_hash_calldata !== hash) {
     console.log("keccak_hash", keccak_hash_calldata);
@@ -10705,7 +10416,8 @@ async function retryPromise(operation, retryConfig) {
       return await operation();
     } catch (error) {
       if (shouldRetry && !shouldRetry(error)) throw error;
-      logger.trace(`Retrying(${i}) > ${logMessage}`);
+      const detail = error instanceof Error ? error.message.split("\n")[0] : String(error);
+      logger.trace(`Retrying(${i}) > ${logMessage}: ${detail.slice(0, 200)}`);
       lastError = error;
       if (i === retryConfig.maxRetries - 1) break;
       await new Promise((resolve) => setTimeout(resolve, retryConfig.backoffMs * 2 ** i));
@@ -12751,92 +12463,6 @@ query OrderStatus($commitment: String!) {
     }
   }
 }`;
-var LATEST_PHANTOM_ORDER_PRICE_SNAPSHOT = `
-query LatestPhantomOrderPriceSnapshot($tokenA: String!, $tokenB: String!) {
-  phantomOrderPriceSnapshots(
-    filter: {
-      and: [
-        { tokenA: { equalTo: $tokenA } }
-        { tokenB: { equalTo: $tokenB } }
-        { medianPrice: { isNull: false } }
-      ]
-    }
-    orderBy: BLOCK_NUMBER_DESC
-    first: 1
-  ) {
-    nodes {
-      commitment
-      tokenA
-      tokenB
-      standardAmount
-      blockNumber
-      medianPrice
-      lowestPrice
-      highestPrice
-      bidCount
-      snapshotTime
-    }
-  }
-}`;
-var AVAILABLE_LIQUIDITY = `
-query AvailableLiquidity(
-  $poolId: String!
-  $sourceChain: String!
-  $destinationChain: String!
-  $direction: String!
-) {
-  poolChainLiquidities(
-    filter: {
-      and: [
-        { poolId: { equalToInsensitive: $poolId } }
-        { chain: { equalTo: $destinationChain } }
-        { direction: { equalTo: $direction } }
-      ]
-    }
-    first: 1
-  ) {
-    nodes {
-      depth
-      bidCount
-      unrestrictedDepth
-      unrestrictedBidCount
-      lastUpdatedAt
-    }
-  }
-  poolRoutes(
-    filter: {
-      and: [
-        { poolId: { equalToInsensitive: $poolId } }
-        { sourceChain: { equalTo: $sourceChain } }
-        { chain: { equalTo: $destinationChain } }
-        { direction: { equalTo: $direction } }
-      ]
-    }
-    first: 1
-  ) {
-    nodes {
-      depth
-      bidCount
-      lastUpdatedAt
-    }
-  }
-}`;
-var BUY_AND_SELL_RATES = `
-query GetLiquidityPoolRate($poolId: String!) {
-  liquidityPools(
-    first: 1
-    filter: { id: { equalToInsensitive: $poolId } }
-  ) {
-    nodes {
-      id
-      token0Symbol
-      token1Symbol
-      sellRate
-      buyRate
-      lastUpdatedAt
-    }
-  }
-}`;
 var TOKEN_GATEWAY_ASSET_TELEPORTED_STATUS = `
 query TokenGatewayAssetTeleportedStatus($commitment: String!) {
   tokenGatewayAssetTeleportedV2s(
@@ -12898,29 +12524,6 @@ async function queryAssetTeleported(params) {
 function queryGetRequest(params) {
   return _queryGetRequestInternal(params);
 }
-async function _queryLatestPhantomOrderPriceSnapshot(params) {
-  const response = await params.queryClient.request(
-    LATEST_PHANTOM_ORDER_PRICE_SNAPSHOT,
-    {
-      tokenA: params.tokenA.toLowerCase(),
-      tokenB: params.tokenB.toLowerCase()
-    }
-  );
-  const snapshot = response.phantomOrderPriceSnapshots.nodes[0];
-  if (!snapshot?.medianPrice) return;
-  return {
-    commitment: snapshot.commitment,
-    tokenA: snapshot.tokenA,
-    tokenB: snapshot.tokenB,
-    standardAmount: BigInt(snapshot.standardAmount),
-    blockNumber: BigInt(snapshot.blockNumber),
-    medianPrice: BigInt(snapshot.medianPrice),
-    lowestPrice: snapshot.lowestPrice === null ? void 0 : BigInt(snapshot.lowestPrice),
-    highestPrice: snapshot.highestPrice === null ? void 0 : BigInt(snapshot.highestPrice),
-    bidCount: snapshot.bidCount,
-    snapshotTime: new Date(snapshot.snapshotTime)
-  };
-}
 async function _queryTokenGatewayAssetTeleportedInternal(params) {
   const { commitmentHash, queryClient: client, logger = DEFAULT_LOGGER } = params;
   const response = await retryPromise(
@@ -16194,18 +15797,39 @@ var CryptoUtils = class _CryptoUtils {
   }
   /**
    * Derives the ERC-4337 nonce key that binds a bid UserOperation to its
-   * order and session key: the lower 192 bits of
-   * `keccak256(commitment ‖ sessionKey)`. `SolverAccount` rejects bid
-   * operations whose nonce key differs — this is what lets the solver sign
-   * the plain userOpHash while staying committed to the order and to the
-   * session key it bid against.
+   * order, session key and calldata: the lower 192 bits of
+   * `keccak256(commitment ‖ sessionKey ‖ keccak256(callData))`. `SolverAccount`
+   * rejects bid operations whose nonce key differs — this is what lets the
+   * solver sign the plain userOpHash while staying committed to the order and
+   * to the session key it bid against.
+   *
+   * The calldata gives every bid its own key. A solver bidding several prices
+   * on one order signs one op per price, and each is sequence 0 of its own key,
+   * so they execute independently rather than in a sequence where one bid that
+   * is never selected blocks the rest.
    *
    * @param commitment - The order commitment (`order.id`).
    * @param sessionKey - The order's session key address (`order.session`).
+   * @param callData - The UserOperation's `callData`.
    * @returns The 192-bit nonce key as a bigint (pass to `EntryPoint.getNonce`).
    */
-  static bidNonceKey(commitment, sessionKey) {
-    return BigInt(viem.keccak256(viem.encodePacked(["bytes32", "address"], [commitment, sessionKey]))) & (1n << 192n) - 1n;
+  static bidNonceKey(commitment, sessionKey, callData) {
+    return BigInt(
+      viem.keccak256(
+        viem.encodePacked(["bytes32", "address", "bytes32"], [commitment, sessionKey, viem.keccak256(callData)])
+      )
+    ) & (1n << 192n) - 1n;
+  }
+  /**
+   * The identifier Hyperbridge files a bid under: `keccak256` of the UserOp's
+   * `callData`. It is the same hash {@link bidNonceKey} takes, so a bid's
+   * identifier and its nonce key both follow from the op itself, and one
+   * solver's bids on one order are kept apart for the same reason on both sides.
+   *
+   * @param callData - The UserOperation's `callData`.
+   */
+  static bidId(callData) {
+    return viem.keccak256(callData);
   }
   /**
    * Builds the EIP-712 typed-data payload whose digest is the EntryPoint v0.8
@@ -16764,9 +16388,98 @@ var OrderPlacer = class {
     return { order: finalizedOrder, receipt };
   }
 };
+var TOKEN_KEYED_GATEWAY_ABI = viem.parseAbi([
+  "function _orders(bytes32 commitment, address token) view returns (uint256)",
+  "function _partialFills(bytes32 commitment, bytes32 token) view returns (uint256)"
+]);
+var keyingByClient = /* @__PURE__ */ new WeakMap();
+async function readLegEscrow(client, gateway, commitment, index, token) {
+  return readKeyed(
+    client,
+    gateway,
+    (keying) => keying === "leg" ? client.readContract({
+      address: gateway,
+      abi: ABI3,
+      functionName: "_orders",
+      args: [commitment, BigInt(index)]
+    }) : client.readContract({
+      address: gateway,
+      abi: TOKEN_KEYED_GATEWAY_ABI,
+      functionName: "_orders",
+      args: [commitment, bytes32ToBytes20(token)]
+    })
+  );
+}
+async function readLegPartialFill(client, gateway, commitment, index, token) {
+  return readKeyed(
+    client,
+    gateway,
+    (keying) => keying === "leg" ? client.readContract({
+      address: gateway,
+      abi: ABI3,
+      functionName: "_partialFills",
+      args: [commitment, BigInt(index)]
+    }) : client.readContract({
+      address: gateway,
+      abi: TOKEN_KEYED_GATEWAY_ABI,
+      functionName: "_partialFills",
+      args: [commitment, token]
+    })
+  );
+}
+async function readKeyed(client, gateway, read) {
+  let known = keyingByClient.get(client);
+  if (!known) {
+    known = /* @__PURE__ */ new Map();
+    keyingByClient.set(client, known);
+  }
+  const key = gateway.toLowerCase();
+  const first = known.get(key) ?? "leg";
+  try {
+    const value = await read(first);
+    known.set(key, first);
+    return value;
+  } catch (error) {
+    if (!isRevert(error)) throw error;
+    const second = first === "leg" ? "token" : "leg";
+    try {
+      const value = await read(second);
+      known.set(key, second);
+      return value;
+    } catch (secondError) {
+      throw isRevert(secondError) ? error : secondError;
+    }
+  }
+}
+function isRevert(error) {
+  let current = error;
+  while (current && typeof current === "object") {
+    const item = current;
+    if (item.name === "ContractFunctionZeroDataError") return true;
+    if (item.code === 3) return true;
+    if (!item.cause || typeof item.cause !== "object") {
+      return /^(?:execution reverted\b|VM Exception while processing transaction:\s*revert\b|function selector was not recognized\b)/i.test(
+        item.message ?? ""
+      );
+    }
+    current = item.cause;
+  }
+  return false;
+}
+var PARTIAL_FILLS_SLOT = 11n;
+function partialFillSlot(commitment, index) {
+  const inner = viem.keccak256(viem.encodePacked(["bytes32", "uint256"], [commitment, PARTIAL_FILLS_SLOT]));
+  return viem.keccak256(viem.encodePacked(["uint256", "bytes32"], [BigInt(index), inner]));
+}
 
 // src/protocols/intents/OrderExecutor.ts
 var USED_USEROPS_STORAGE_KEY = (commitment) => `used-userops:${commitment.toLowerCase()}`;
+function remainingAfter(targets, filled) {
+  return targets.map((target, index) => {
+    const credited = filled[index]?.amount ?? 0n;
+    return { token: target.token, amount: credited >= target.amount ? 0n : target.amount - credited };
+  });
+}
 var OrderExecutor = class {
   constructor(ctx, bidManager) {
     this.ctx = ctx;
@@ -16816,6 +16529,38 @@ var OrderExecutor = class {
       JSON.stringify([...usedUserOps])
     );
   }
+  /**
+   * Reads the order's state on its destination chain into `totalFilledAssets`: the output credited
+   * per leg from `_partialFills`, never below what is already counted, so a lagging RPC node cannot
+   * take back a fill this executor has seen. Other solvers can fill the order too, so the chain, not
+   * this executor's own fills, says how much is left.
+   *
+   * Returns the terminal update once `_filled` is set: `FILLED` when every leg is complete,
+   * `CANCELLED` otherwise. `_filled` is read first because progress cannot change after it is set,
+   * so a finalized order is never paired with progress from before its last fill.
+   */
+  async syncWithDestination(order, commitment, targetAssets, totalFilledAssets) {
+    const client = this.ctx.dest.client;
+    const gateway = this.ctx.dest.configService.getIntentGatewayAddress(normalizeStateMachineId(order.destination));
+    const finalizer = await client.readContract({
+      address: gateway,
+      abi: ABI3,
+      functionName: "_filled",
+      args: [commitment]
+    });
+    const filled = await Promise.all(
+      order.output.assets.map(async (asset, index) => {
+        const credited = await readLegPartialFill(client, gateway, commitment, index, asset.token);
+        const counted = totalFilledAssets[index]?.amount ?? 0n;
+        return { token: asset.token, amount: credited > counted ? credited : counted };
+      })
+    );
+    const remainingAssets = remainingAfter(targetAssets, filled);
+    if (/^0x0{40}$/i.test(finalizer)) return { totalFilledAssets: filled, remainingAssets };
+    const progress = { commitment, totalFilledAssets: filled, remainingAssets };
+    const final = remainingAssets.every((asset) => asset.amount === 0n) ? { status: "FILLED", selectedSolver: finalizer, ...progress } : { status: "CANCELLED", ...progress };
+    return { totalFilledAssets: filled, remainingAssets, final };
+  }
   /**
    * Creates a closure that computes the deduplication hash key for a
    * UserOperation, pre-bound to the order's destination chain and entry point.
@@ -16874,12 +16619,12 @@ var OrderExecutor = class {
     }
     if (result.fillStatus === "partial") {
       const filledAssets = result.filledAssets ?? [];
-      totalFilledAssets = totalFilledAssets.map((a) => {
-        const filled = filledAssets.find((f) => f.token === a.token);
+      totalFilledAssets = totalFilledAssets.map((a, index) => {
+        const filled = filledAssets[index];
         return filled ? { token: a.token, amount: a.amount + filled.amount } : { ...a };
       });
-      remainingAssets = targetAssets.map((target) => {
-        const filled = totalFilledAssets.find((a) => a.token === target.token);
+      remainingAssets = targetAssets.map((target, index) => {
+        const filled = totalFilledAssets[index];
         const filledAmt = filled?.amount ?? 0n;
         return {
           token: target.token,
@@ -16945,8 +16690,27 @@ var OrderExecutor = class {
     const usedUserOps = await this.loadUsedUserOps(commitment);
     const userOpHashKey = this.createUserOpHasher(order);
     const targetAssets = order.output.assets.map((a) => ({ token: a.token, amount: a.amount }));
-    let totalFilledAssets = order.output.assets.map((a) => ({ token: a.token, amount: 0n }));
-    let remainingAssets = order.output.assets.map((a) => ({ token: a.token, amount: a.amount }));
+    let initial;
+    try {
+      initial = await this.syncWithDestination(
+        order,
+        commitment,
+        targetAssets,
+        order.output.assets.map((a) => ({ token: a.token, amount: 0n }))
+      );
+    } catch (err) {
+      yield {
+        status: "FAILED",
+        commitment,
+        error: `Could not read the order on its destination chain: ${err instanceof Error ? err.message : String(err)}`
+      };
+      return;
+    }
+    if (initial.final) {
+      yield initial.final;
+      return;
+    }
+    const { totalFilledAssets, remainingAssets } = initial;
     const executionStream = this.executionStream({
       order,
       sessionPrivateKey,
@@ -16978,7 +16742,7 @@ var OrderExecutor = class {
         if (done) return;
         const fed = yield value;
         if (value.status === "BIDS_RECEIVED") input = fed;
-        if (value.status === "EXPIRED" || value.status === "FILLED") return;
+        if (value.status === "EXPIRED" || value.status === "FILLED" || value.status === "CANCELLED") return;
       }
     } finally {
       console.log(`[OrderExecutor] Tearing down streams for commitment=${commitment}`);
@@ -17037,18 +16801,29 @@ var OrderExecutor = class {
       }
       while (true) {
         let freshBids;
+        let final;
         try {
-          const bids2 = await this.fetchBids({ commitment, solver, solverLockStartTime });
-          freshBids = bids2.filter(isFreshBid);
+          ;
+          ({ totalFilledAssets, remainingAssets, final } = await this.syncWithDestination(
+            order,
+            commitment,
+            targetAssets,
+            totalFilledAssets
+          ));
+          freshBids = final ? [] : (await this.fetchBids({ commitment, solver, solverLockStartTime })).filter(isFreshBid);
         } catch {
           await sleep(pollIntervalMs);
           continue;
         }
+        if (final) {
+          yield final;
+          return;
+        }
         if (freshBids.length === 0) {
           await sleep(pollIntervalMs);
           continue;
         }
-        const bids = this.bidManager.buildBids(order, freshBids, sessionPrivateKey);
+        const bids = this.bidManager.buildBids(order, freshBids, sessionPrivateKey).filter((bid) => servesOpenLeg(bid, remainingAssets));
         if (bids.length === 0) {
           await sleep(pollIntervalMs);
           continue;
@@ -17091,6 +16866,10 @@ var OrderExecutor = class {
     }
   }
 };
+function servesOpenLeg(bid, remainingAssets) {
+  if (bid.outputs.length !== remainingAssets.length) return true;
+  return bid.outputs.some((output, leg) => output.amount > 0n && remainingAssets[leg].amount > 0n);
+}
 var OrderCanceller = class _OrderCanceller {
   /**
    * @param ctx - Shared IntentsV2 context providing the source and destination
@@ -17129,8 +16908,9 @@ var OrderCanceller = class _OrderCanceller {
   /**
    * Quotes the native token cost of a source-initiated cross-chain cancellation.
    *
-   * Constructs a mock ISMP GET request for the destination commitment slot and
-   * calls `quoteNative` on the source host to obtain the dispatch fee.
+   * Constructs the ISMP GET request the source gateway will dispatch, one
+   * `_partialFills` key per leg, and calls `quoteNative` on the source host to
+   * obtain the dispatch fee.
    * Returns 0 for same-chain orders (no ISMP call needed).
    *
    * @param order - The order to quote.
@@ -17144,21 +16924,16 @@ var OrderCanceller = class _OrderCanceller {
     }
     const height = order.deadline + 1n;
     const destIntentGateway = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachine);
-    const slotHash = await this.ctx.dest.client.readContract({
-      abi: ABI3,
-      address: destIntentGateway,
-      functionName: "calculateCommitmentSlotHash",
-      args: [order.id]
-    });
-    const key = viem.concatHex([destIntentGateway, slotHash]);
-    const context = encodeWithdrawalRequest(order, order.user);
+    const commitment = this.orderId(order);
+    const keys = order.inputs.map((_, index) => viem.concatHex([destIntentGateway, partialFillSlot(commitment, index)]));
+    const context = cancelFromSourceContext(order, commitment);
     const getRequest = {
       source: sourceStateMachine,
       dest: destStateMachine,
       from: this.ctx.source.configService.getIntentGatewayAddress(destStateMachine),
       nonce: await this.ctx.source.getHostNonce(),
       height,
-      keys: [key],
+      keys,
       timeoutTimestamp: 0n,
       context
     };
@@ -17183,10 +16958,13 @@ var OrderCanceller = class _OrderCanceller {
    *
    * @param order - The order to cancel.
    * @param indexerClient - Indexer client used to stream ISMP request status
-   *   updates and query state-machine heights.
-   * @param options - Choose the initiation side. Defaults to source-side cancellation.
+   *   updates and query state-machine heights. The direct same-chain route does
+   *   not access it.
+   * @param options - Choose the initiation side. Defaults to source-side
+   *   cancellation. Same-chain orders always use the direct local route.
    * @yields {@link CancelEvent} objects describing each stage of the
-   *   cancellation lifecycle.
+   *   cancellation lifecycle. The caller signs or broadcasts the yielded
+   *   transaction, so its signer may differ from `order.user` after expiry.
    */
   async *cancelOrder(order, indexerClient, options = {}) {
     const sourceStateMachine = normalizeStateMachineId(order.source);
@@ -17220,9 +16998,12 @@ var OrderCanceller = class _OrderCanceller {
    * Async generator that cancels an order by initiating the cancel from the
    * source chain.
    *
-   * **Same-chain path:** encodes a direct `cancelOrder` call, yields
-   * `AWAITING_CANCEL_TRANSACTION`, broadcasts the signed transaction, and
-   * yields `CANCELLATION_COMPLETE` after confirming the `EscrowRefunded` event.
+   * **Same-chain path:** encodes a direct `cancelOrder` call with zero cancel
+   * options, yields `AWAITING_CANCEL_TRANSACTION`, accepts either a signed raw
+   * transaction or an already-broadcast hash, and yields `CANCELLATION_COMPLETE`
+   * after confirming the `EscrowRefunded` event. The contract authorizes the
+   * order user through the deadline and any caller strictly after it; the SDK
+   * preserves `order.user` in calldata so a third party cannot redirect escrow.
    *
    * **Cross-chain path:**
    * 1. Fetches (or resumes from cache) a destination finalization proof.
@@ -17532,9 +17313,9 @@ var OrderCanceller = class _OrderCanceller {
     }
   }
   /**
-   * Polls for a finalized destination-chain state proof that demonstrates
-   * the order commitment slot is unset (i.e. the order was not filled before
-   * the deadline).
+   * Polls for a finalized destination-chain state proof of every leg's
+   * `_partialFills` slot, i.e. how much of the order was filled before the
+   * deadline.
    *
    * Waits until the latest Hyperbridge-tracked state-machine height exceeds
    * `order.deadline` (or the last failed probe height) before attempting to
@@ -17563,14 +17344,9 @@ var OrderCanceller = class _OrderCanceller {
         const intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(
           this.ctx.dest.config.stateMachineId
         );
-        const orderId = this.orderId(order);
-        const slotHash = await this.ctx.dest.client.readContract({
-          abi: ABI3,
-          address: intentGatewayV2Address,
-          functionName: "calculateCommitmentSlotHash",
-          args: [orderId]
-        });
-        const proofHex = await this.ctx.dest.queryStateProof(latestHeight, [slotHash], intentGatewayV2Address);
+        const commitment = this.orderId(order);
+        const slots = order.inputs.map((_, index) => partialFillSlot(commitment, index));
+        const proofHex = await this.ctx.dest.queryStateProof(latestHeight, slots, intentGatewayV2Address);
         const proof = {
           consensusStateId: this.ctx.dest.config.consensusStateId,
           height: latestHeight,
@@ -17768,118 +17544,135 @@ var OrderCanceller = class _OrderCanceller {
     return feeInDestFeeToken * 1005n / 1000n;
   }
 };
-var FILL_ORDER_V1_ABI = [
-  {
-    type: "function",
-    name: "fillOrder",
-    stateMutability: "payable",
-    outputs: [],
-    inputs: [
-      ABI3.find((e) => e.type === "function" && e.name === "fillOrder").inputs[0],
+function cancelFromSourceContext(order, commitment) {
+  return viem.encodeAbiParameters(
+    [
+      { type: "bytes32" },
+      { type: "bytes32" },
       {
-        name: "options",
-        type: "tuple",
-        internalType: "struct FillOptions",
+        type: "tuple[]",
         components: [
-          { name: "relayerFee", type: "uint256", internalType: "uint256" },
-          { name: "nativeDispatchFee", type: "uint256", internalType: "uint256" },
-          {
-            name: "outputs",
-            type: "tuple[]",
-            internalType: "struct TokenInfo[]",
-            components: [
-              { name: "token", type: "bytes32", internalType: "bytes32" },
-              { name: "amount", type: "uint256", internalType: "uint256" }
-            ]
-          }
+          { name: "token", type: "bytes32" },
+          { name: "amount", type: "uint256" }
         ]
-      }
+      },
+      { type: "uint256[]" }
+    ],
+    [
+      commitment,
+      bytes20ToBytes32(order.user),
+      order.inputs.map((input) => ({ token: normalizeAddressForEvmBytes32(input.token), amount: input.amount })),
+      order.output.assets.map((asset) => asset.amount)
     ]
+  );
+}
+var FILL_ORDER_SELECTOR = "0x68ddf058";
+var SUPPORTED_INTENTS_VERSION = 3n;
+var CONTRACT_VERSION_ABI = [
+  {
+    type: "function",
+    name: "version",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint64" }]
   }
 ];
-var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
-var LEGACY_FILL_OPTIONS_IMPLEMENTATIONS = /* @__PURE__ */ new Set([
-  // The pre-validUntil IntentGatewayV2 implementation. One entry covers every chain: the
-  // protocol contracts are CREATE2-deployed, so this is the implementation address on all
-  // of them (confirmed with the maintainers).
-  "0x976b268b06f545c4a2bf44866aa2465bd8b3c67d"
-]);
-var CHAINS_WITHOUT_VALID_UNTIL = /* @__PURE__ */ new Set([
-  97,
-  // BNB testnet
-  10200,
-  // Gnosis Chiado
-  80002,
-  // Polygon Amoy
-  84532,
-  // Base Sepolia
-  421614,
-  // Arbitrum Sepolia
-  688689,
-  // Pharos testnet
-  11155111,
-  // Sepolia
-  11155420,
-  // Optimism Sepolia
-  420420417
-  // Polkadot Hub Paseo
-]);
-var knownV2Gateways = /* @__PURE__ */ new Set();
-function resetFillOptionsVersionCache() {
-  knownV2Gateways.clear();
+async function readContractVersion(client, address) {
+  try {
+    return await client.readContract({ address, abi: CONTRACT_VERSION_ABI, functionName: "version" });
+  } catch (error) {
+    if (isRevert(error)) return void 0;
+    throw error;
+  }
 }
-async function resolveImplementation(client, gateway) {
-  const slot = await client.getStorageAt({ address: gateway, slot: ERC1967_IMPLEMENTATION_SLOT });
-  if (!slot || slot.length < 66) return gateway;
-  const addr = `0x${slot.slice(-40)}`;
-  return /^0x0{40}$/.test(addr) ? gateway : addr;
+async function supportsRateFills(client, gateway) {
+  return await readContractVersion(client, gateway) === SUPPORTED_INTENTS_VERSION;
 }
-async function getFillOptionsVersion(client, gateway) {
-  const chainId = client.chain?.id;
-  if (chainId !== void 0 && CHAINS_WITHOUT_VALID_UNTIL.has(chainId)) return 1;
-  const key = gateway.toLowerCase();
-  if (knownV2Gateways.has(key)) return 2;
-  const implementation = await resolveImplementation(client, gateway);
-  if (LEGACY_FILL_OPTIONS_IMPLEMENTATIONS.has(implementation.toLowerCase())) return 1;
-  knownV2Gateways.add(key);
-  return 2;
+async function assertGatewayRelease(client, gateway) {
+  const version = await readContractVersion(client, gateway);
+  if (version === SUPPORTED_INTENTS_VERSION) return;
+  throw new Error(
+    version === void 0 ? `IntentGateway ${gateway} reports no version(); this SDK requires release ${SUPPORTED_INTENTS_VERSION}` : `IntentGateway ${gateway} reports release ${String(version)}; this SDK requires release ${SUPPORTED_INTENTS_VERSION}`
+  );
 }
-function encodeFillOrder(order, options, version) {
-  if (version === 2) {
-    return viem.encodeFunctionData({
-      abi: ABI3,
-      functionName: "fillOrder",
-      args: [order, options]
-    });
-  }
-  const { relayerFee, nativeDispatchFee, outputs } = options;
-  return viem.encodeFunctionData({
-    abi: FILL_ORDER_V1_ABI,
-    functionName: "fillOrder",
-    args: [order, { relayerFee, nativeDispatchFee, outputs }]
-  });
+var CANONICAL_EVM_TOKEN = /^0x0{24}[0-9a-fA-F]{40}$/;
+function isCanonicalEvmToken(token) {
+  return CANONICAL_EVM_TOKEN.test(token);
+}
+function validateFillQuotes(order, options) {
+  const count = order.output.assets.length;
+  if (!count || !Array.isArray(options.inputs) || options.inputs.length !== count || options.outputs.length !== count || order.inputs.length !== count) {
+    throw new Error("Fill inputs and outputs must quote every order leg");
+  }
+  for (let i = 0; i < count; i++) {
+    const input = options.inputs[i];
+    const output = options.outputs[i];
+    if (input.token.toLowerCase() !== order.inputs[i].token.toLowerCase() || output.token.toLowerCase() !== order.output.assets[i].token.toLowerCase() || !isCanonicalEvmToken(input.token) || !isCanonicalEvmToken(output.token)) {
+      throw new Error("Fill quote tokens must match their order legs");
+    }
+    if (input.amount === 0n !== (output.amount === 0n)) {
+      throw new Error("Fill quote input and output must both be zero or positive");
+    }
+  }
+}
+function encodeFillOrder(order, options) {
+  validateFillQuotes(order, options);
+  return viem.encodeFunctionData({
+    abi: ABI3,
+    functionName: "fillOrder",
+    args: [order, options]
+  });
 }
 function decodeFillOrder(data) {
   try {
     const decoded = viem.decodeFunctionData({ abi: ABI3, data });
-    if (decoded.functionName === "fillOrder" && decoded.args && decoded.args.length >= 2) {
-      return { order: decoded.args[0], options: decoded.args[1] };
-    }
+    if (decoded.functionName !== "fillOrder" || !decoded.args || decoded.args.length < 2) return null;
+    const order = decoded.args[0];
+    const options = decoded.args[1];
+    validateFillQuotes(order, options);
+    return { order, options };
   } catch {
+    return null;
   }
-  try {
-    const decoded = viem.decodeFunctionData({ abi: FILL_ORDER_V1_ABI, data });
-    if (decoded.functionName === "fillOrder" && decoded.args && decoded.args.length >= 2) {
-      const legacy = decoded.args[1];
-      return { order: decoded.args[0], options: { ...legacy, validUntil: 0n } };
-    }
-  } catch {
+}
+var ENTRY_POINT_EVENT_ABI = [
+  { type: "event", name: "BeforeExecution", inputs: [] },
+  {
+    type: "event",
+    name: "UserOperationEvent",
+    inputs: [
+      { name: "userOpHash", type: "bytes32", indexed: true },
+      { name: "sender", type: "address", indexed: true },
+      { name: "paymaster", type: "address", indexed: true },
+      { name: "nonce", type: "uint256", indexed: false },
+      { name: "success", type: "bool", indexed: false },
+      { name: "actualGasCost", type: "uint256", indexed: false },
+      { name: "actualGasUsed", type: "uint256", indexed: false }
+    ]
   }
-  return null;
+];
+function userOperationLogs(logs, entryPoint, userOpHash) {
+  const [beforeExecution, userOperationEvent] = ENTRY_POINT_EVENT_ABI.map((event) => viem.toEventSelector(event));
+  const isBoundary = (log) => log.address.toLowerCase() === entryPoint.toLowerCase() && (log.topics[0] === beforeExecution || log.topics[0] === userOperationEvent);
+  const end = logs.findIndex(
+    (log) => isBoundary(log) && log.topics[0] === userOperationEvent && log.topics[1]?.toLowerCase() === userOpHash.toLowerCase()
+  );
+  if (end === -1) throw new Error(`UserOperation ${userOpHash} is not in the transaction`);
+  const { args } = viem.decodeEventLog({
+    abi: ENTRY_POINT_EVENT_ABI,
+    eventName: "UserOperationEvent",
+    data: logs[end].data,
+    topics: logs[end].topics
+  });
+  if (!args.success) throw new Error(`UserOperation ${userOpHash} reverted`);
+  let start = end - 1;
+  while (start >= 0 && !isBoundary(logs[start])) start--;
+  return logs.slice(start + 1, end);
 }
 var BidImpl = class {
   solverAddress;
   outputs;
+  inputs;
   relayerFee;
   nativeDispatchFee;
   userOp;
@@ -17902,6 +17695,7 @@ var BidImpl = class {
     this.sessionPrivateKey = params.sessionPrivateKey;
     this.solverAddress = params.fillerBid.userOp.sender;
     this.outputs = params.fillOptions.outputs;
+    this.inputs = params.fillOptions.inputs;
     this.relayerFee = params.fillOptions.relayerFee;
     this.nativeDispatchFee = params.fillOptions.nativeDispatchFee;
     this.userOp = params.fillerBid.userOp;
@@ -18034,31 +17828,28 @@ var BidImpl = class {
         { maxRetries: 5, backoffMs: 2e3, logMessage: "Fetching user operation receipt" }
       );
       txnHash = receipt.receipt.transactionHash;
-      try {
-        const chainReceipt = await this.ctx.dest.client.waitForTransactionReceipt({
-          hash: txnHash,
-          confirmations: 1
-        });
-        const events = viem.parseEventLogs({
-          abi: ABI3,
-          logs: chainReceipt.logs,
-          eventName: ["OrderFilled", "PartialFill"]
-        });
-        const matched = events.find((e) => {
-          if (e.eventName === "OrderFilled")
-            return e.args.commitment.toLowerCase() === commitment.toLowerCase();
-          if (e.eventName === "PartialFill")
-            return e.args.commitment.toLowerCase() === commitment.toLowerCase();
-          return false;
-        });
-        if (matched?.eventName === "OrderFilled") {
-          fillStatus = "full";
-        } else if (matched?.eventName === "PartialFill") {
-          fillStatus = "partial";
-          filledAssets = matched.args.outputs ?? [];
-        }
-      } catch {
-        throw new Error("Failed to determine fill status from logs");
+      const chainReceipt = await this.ctx.dest.client.waitForTransactionReceipt({
+        hash: txnHash,
+        confirmations: 1
+      });
+      const gateway = this.ctx.dest.configService.getIntentGatewayAddress(
+        normalizeStateMachineId(this.order.destination)
+      );
+      const fills = viem.parseEventLogs({
+        abi: ABI3,
+        logs: userOperationLogs(chainReceipt.logs, entryPointAddress, userOpHash),
+        eventName: ["OrderFilled", "PartialFill"]
+      }).filter(
+        (event) => event.address.toLowerCase() === gateway.toLowerCase() && event.args.commitment.toLowerCase() === commitment.toLowerCase()
+      );
+      if (fills.some((event) => event.eventName === "OrderFilled")) {
+        fillStatus = "full";
+      } else if (fills.length > 0) {
+        fillStatus = "partial";
+        filledAssets = fills[0].args.outputs.map(({ token }, index) => ({
+          token,
+          amount: fills.reduce((sum, event) => sum + (event.args.outputs[index]?.amount ?? 0n), 0n)
+        }));
       }
     } catch (err) {
       throw new Error(`Failed to execute bid: ${err instanceof Error ? err.message : String(err)}`);
@@ -18125,6 +17916,20 @@ var BidManager = class {
       callData,
       paymasterAndData = "0x"
     } = options;
+    const fills = (this.crypto.decodeERC7821Execute(callData) ?? []).filter(
+      (call) => call.data.slice(0, 10).toLowerCase() === FILL_ORDER_SELECTOR
+    );
+    if (fills.length === 0) throw new Error("Bid calldata carries no fillOrder call");
+    for (const call of fills) {
+      if (!decodeFillOrder(call.data)) {
+        throw new Error("Malformed fill quote; every leg requires inputs and outputs");
+      }
+    }
+    const chain = normalizeStateMachineId(order.destination);
+    const gateway = this.ctx.dest.configService.getIntentGatewayAddress(chain);
+    if (!await supportsRateFills(this.ctx.dest.client, gateway)) {
+      throw new Error("Fills are not supported by the destination gateway");
+    }
     const chainId = BigInt(
       this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
     );
@@ -18142,10 +17947,10 @@ var BidManager = class {
       signature: "0x"
     };
     const nonceKey = BigInt(nonce) >> 64n;
-    const expectedKey = CryptoUtils.bidNonceKey(order.id, order.session);
+    const expectedKey = CryptoUtils.bidNonceKey(order.id, order.session, callData);
     if (nonceKey !== expectedKey) {
       console.warn(
-        `[BidManager] bid nonce key does not bind the order commitment and session key; on-chain validation will fail (order=${order.id})`
+        `[BidManager] bid nonce key does not bind the order commitment, session key and calldata; on-chain validation will fail (order=${order.id})`
       );
     }
     const solverSignature = await solverSigner.signTypedData(
@@ -18210,7 +18015,7 @@ var BidManager = class {
     return this.selectAndExecuteBest(order, this.buildBids(order, bids, sessionPrivateKey));
   }
   /**
-   * Autopilot bid selection: sorts the given bids by output value, simulates
+   * Autopilot bid selection: sorts the given bids by rate, simulates
    * each in order and attempts execution. Any bid that fails simulation or
    * execution is skipped once so the next ranked bid can be attempted in the
    * same round. For consumers that do not need custom selection logic.
@@ -18265,35 +18070,58 @@ var BidManager = class {
     throw new Error("No bids passed simulation and execution");
   }
   /**
-   * Sorts a list of bids for the given order by output value.
+   * Sorts bids by rate, best to worst, independently of how much each one fills.
    *
-   * Delegates to one of three strategies based on the order's output token
-   * composition:
-   * - Single output token: sort by offered amount descending.
-   * - All stable outputs (USDC/USDT): sort by normalised USD value descending.
-   * - Mixed outputs: sort by DEX-quoted USD value descending, with a raw-amount
-   *   fallback if pricing fails.
+   * A leg's rate is what the bid pays out for what it takes: `output / input` for
+   * that leg. Every leg of an order trades the same pair, so a bid's rate is its
+   * total output over its total input across the legs it quotes. Rates are
+   * compared exactly, by cross-multiplication; equal rates keep arrival order.
    *
-   * Bids that cannot satisfy the order's token set are dropped.
+   * A bid is dropped when it does not quote the order's legs one for one, names
+   * another token on a leg, quotes an input without an output (or the reverse),
+   * quotes no leg at all, or quotes a leg below the rate the order requires.
    *
-   * @param order - The placed order whose output spec drives sorting logic.
+   * @param order - The placed order the bids compete to fill.
    * @param bids - Executable bids to sort (from {@link buildBids}).
-   * @returns Sorted array of `Bid` objects ready for simulation.
+   * @returns The valid bids, best rate first, ready for simulation.
    */
   async sortBids(order, bids) {
-    const outputs = order.output.assets;
-    if (outputs.length <= 1) {
-      console.log(`[BidManager] Using single-output sorting (1 output asset)`);
-      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(bids, outputs, chainId);
+    const legs = order.inputs.length;
+    const ranked = [];
+    for (const [index, bid] of bids.entries()) {
+      if (bid.inputs.length !== legs || bid.outputs.length !== legs || order.output.assets.length !== legs) {
+        console.warn(`[BidManager] Bid from solver=${bid.solverAddress} REJECTED: does not quote the order's legs`);
+        continue;
+      }
+      let input = 0n;
+      let output = 0n;
+      let reason = "";
+      for (let leg = 0; leg < legs && !reason; leg++) {
+        const take = bid.inputs[leg];
+        const pay = bid.outputs[leg];
+        const escrow = order.inputs[leg];
+        const required = order.output.assets[leg];
+        if (take.token.toLowerCase() !== escrow.token.toLowerCase()) reason = `input token mismatch on leg ${leg}`;
+        else if (pay.token.toLowerCase() !== required.token.toLowerCase()) reason = `output token mismatch on leg ${leg}`;
+        else if (take.amount < 0n || pay.amount < 0n || take.amount === 0n !== (pay.amount === 0n))
+          reason = `no valid quote on leg ${leg}`;
+        else if (pay.amount * escrow.amount < take.amount * required.amount) reason = `rate below the order on leg ${leg}`;
+        input += take.amount;
+        output += pay.amount;
+      }
+      if (!reason && input === 0n) reason = "quotes no leg";
+      if (reason) {
+        console.warn(`[BidManager] Bid from solver=${bid.solverAddress} REJECTED: ${reason}`);
+        continue;
+      }
+      ranked.push({ bid, input, output, index });
     }
-    console.log(`[BidManager] Using mixed-output sorting (${outputs.length} output assets, some non-stable)`);
-    return this.sortMixedOutputs(bids, outputs, chainId);
+    ranked.sort((a, b) => {
+      const left = a.output * b.input;
+      const right = b.output * a.input;
+      return left === right ? a.index - b.index : left > right ? -1 : 1;
+    });
+    return ranked.map(({ bid }) => bid);
   }
   /**
    * Extracts the `FillOptions` struct from a single bid's ERC-7821
@@ -18316,150 +18144,6 @@ var BidManager = class {
     }
     return null;
   }
-  /**
-   * 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(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 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.solverAddress} REJECTED: token mismatch (bid=${bidOutput.token}, required=${requiredAsset.token})`
-        );
-        continue;
-      }
-      if (bidAmount.lt(requiredAmount)) {
-        console.log(
-          `[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.solverAddress} ACCEPTED: amount=${bidAmount.toString()} (surplus=${bidAmount.minus(requiredAmount).toString()})`
-        );
-      }
-      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(({ 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(bids, orderOutputs, chainId) {
-    const requiredUsd = this.computeStablesUsdValue(orderOutputs, chainId);
-    console.log(`[BidManager] sortAllStables: required USD value=${requiredUsd.toString()}`);
-    const validBids = [];
-    for (const bid of bids) {
-      const bidUsd = this.computeStablesUsdValue(bid.outputs, chainId);
-      if (bidUsd === null) {
-        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.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.solverAddress} ACCEPTED: USD value=${bidUsd.toString()}`);
-      }
-      validBids.push({ bid, usdValue: bidUsd });
-    }
-    validBids.sort((a, b) => b.usdValue.comparedTo(a.usdValue));
-    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(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(bids, orderOutputs);
-    }
-    console.log(`[BidManager] sortMixedOutputs: required USD value=${requiredUsd.toString()}`);
-    const validBids = [];
-    for (const bid of bids) {
-      const bidUsd = await this.computeOutputsUsdValue(bid.outputs, chainId);
-      if (bidUsd === null) {
-        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.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.solverAddress} ACCEPTED: mixed USD value=${bidUsd.toString()}`
-        );
-      }
-      validBids.push({ bid, usdValue: bidUsd });
-    }
-    validBids.sort((a, b) => b.usdValue.comparedTo(a.usdValue));
-    return validBids.map(({ bid }) => bid);
-  }
-  /**
-   * Fallback when DEX pricing is unavailable.
-   * Computes total spread per bid. Bids missing a required token are rejected.
-   * Bids offering less than required for a token are allowed (partial fill).
-   * Sorted by total offered amount descending.
-   */
-  sortByRawAmountFallback(bids, orderOutputs) {
-    console.log(
-      `[BidManager] sortByRawAmountFallback: checking ${bids.length} bid(s) against ${orderOutputs.length} required output(s)`
-    );
-    const validBids = [];
-    for (const bid of bids) {
-      let valid = true;
-      let totalOffered = new Decimal2__default.default(0);
-      let rejectReason = "";
-      for (const required of orderOutputs) {
-        const matching = bid.outputs.find((o) => o.token.toLowerCase() === required.token.toLowerCase());
-        if (!matching) {
-          valid = false;
-          rejectReason = `missing output token=${required.token}`;
-          break;
-        }
-        totalOffered = totalOffered.plus(new Decimal2__default.default(matching.amount.toString()));
-      }
-      if (!valid) {
-        console.warn(`[BidManager] Bid from solver=${bid.solverAddress} REJECTED (fallback): ${rejectReason}`);
-        continue;
-      }
-      const totalRequired = orderOutputs.reduce(
-        (acc, o) => acc.plus(new Decimal2__default.default(o.amount.toString())),
-        new Decimal2__default.default(0)
-      );
-      if (totalOffered.lt(totalRequired)) {
-        console.log(
-          `[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.solverAddress} ACCEPTED (fallback): totalOffered=${totalOffered.toString()}`
-        );
-      }
-      validBids.push({ bid, totalOffered });
-    }
-    validBids.sort((a, b) => b.totalOffered.comparedTo(a.totalOffered));
-    return validBids.map(({ bid }) => bid);
-  }
   // ── Token classification helpers ──────────────────────────────────
   /**
    * Returns `true` if `tokenAddr` is either USDC or USDT on the given chain.
@@ -18490,23 +18174,6 @@ var BidManager = class {
     return configService.getUsdtDecimals(chainId);
   }
   // ── Basket valuation helpers ──────────────────────────────────────
-  /**
-   * Sums the USD value of a basket of stable tokens (USDC/USDT only),
-   * normalising each amount by its decimal count and treating each token as $1.
-   *
-   * @param outputs - List of token/amount pairs where every token is a stable.
-   * @param chainId - State-machine ID used to look up decimals.
-   * @returns Total USD value as a `Decimal`.
-   */
-  computeStablesUsdValue(outputs, chainId) {
-    let total = new Decimal2__default.default(0);
-    for (const output of outputs) {
-      const tokenAddr = bytes32ToBytes20(output.token);
-      const decimals = this.getStableDecimals(tokenAddr, chainId);
-      total = total.plus(new Decimal2__default.default(output.amount.toString()).div(new Decimal2__default.default(10).pow(decimals)));
-    }
-    return total;
-  }
   /**
    * Prices every token in the basket via on-chain DEX quotes (token → USDC).
    * Stables are valued at $1. Non-stables are quoted through Uniswap
@@ -18521,6 +18188,7 @@ var BidManager = class {
     const { asset: wethAddr } = configService.getWrappedNativeAssetWithDecimals(chainId);
     let totalUsd = new Decimal2__default.default(0);
     for (const output of outputs) {
+      if (output.amount === 0n) continue;
       const tokenAddr = bytes32ToBytes20(output.token);
       if (this.isStableToken(tokenAddr, chainId)) {
         const decimals = this.getStableDecimals(tokenAddr, chainId);
@@ -18644,6 +18312,14 @@ var GasEstimator = class {
    */
   async estimateFillOrder(params, pricingOptions = {}) {
     const { order } = params;
+    if (params.outputs !== void 0 && params.inputs === void 0) {
+      throw new Error("Custom output quotes require explicit inputs");
+    }
+    const inputs = (params.inputs ?? order.inputs).map((input) => ({
+      ...input,
+      token: normalizeAddressForEvmBytes32(input.token)
+    }));
+    const quotedOutputs = params.outputs ?? order.output.assets;
     const orderFeeGasPriceBumpPercent = pricingOptions.orderFeeGasPriceBumpPercent ?? 0n;
     const solverPrivateKey = accounts.generatePrivateKey();
     const solverAccountAddress = accounts.privateKeyToAddress(solverPrivateKey);
@@ -18652,7 +18328,7 @@ var GasEstimator = class {
     const intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachineId);
     const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(destStateMachineId);
     const chainId = BigInt(Number.parseInt(destStateMachineId.split("-")[1]));
-    const totalEthValue = order.output.assets.filter((output) => bytes32ToBytes20(output.token) === ADDRESS_ZERO2).reduce((sum, output) => sum + output.amount, 0n);
+    const totalEthValue = quotedOutputs.filter((output) => bytes32ToBytes20(output.token) === ADDRESS_ZERO2).reduce((sum, output) => sum + output.amount, 0n);
     const [sourceFeeToken, destFeeToken, gasPrice, latestBlock] = await Promise.all([
       getFeeToken(this.ctx, this.ctx.source.config.stateMachineId, this.ctx.source),
       getFeeToken(this.ctx, this.ctx.dest.config.stateMachineId, this.ctx.dest),
@@ -18661,7 +18337,7 @@ var GasEstimator = class {
     ]);
     const baseFeePerGas = latestBlock.baseFeePerGas ?? gasPrice;
     const feeTokenAsBytes32 = bytes20ToBytes32(destFeeToken.address);
-    const assetsForOverrides = [...order.output.assets];
+    const assetsForOverrides = [...quotedOutputs];
     if (!assetsForOverrides.some((asset) => asset.token.toLowerCase() === feeTokenAsBytes32.toLowerCase())) {
       assetsForOverrides.push({ token: feeTokenAsBytes32, amount: 0n });
     }
@@ -18684,6 +18360,7 @@ var GasEstimator = class {
     ]);
     const { bundler: bundlerStateOverrides } = stateOverridesResult;
     const fillOptions = {
+      inputs,
       relayerFee: crossChainFees.postRequestFee,
       // Always dispatch with the fee token (see the method docs).
       nativeDispatchFee: 0n,
@@ -18691,7 +18368,7 @@ var GasEstimator = class {
       // bound here would only risk the estimate reverting on a slow bundler round trip.
       // The caller sets the real one on the options it actually signs.
       validUntil: 0n,
-      outputs: order.output.assets.map((asset) => ({
+      outputs: quotedOutputs.map((asset) => ({
         ...asset,
         token: normalizeAddressForEvmBytes32(asset.token)
       }))
@@ -18703,12 +18380,8 @@ var GasEstimator = class {
     let maxFeePerGas = gasPrice + gasPrice * BigInt(maxFeeBumpPercent) / 100n;
     const orderForEstimation = { ...order, session: solverAccountAddress };
     const commitment = orderCommitment(orderForEstimation);
-    const fillOptionsVersion = await getFillOptionsVersion(this.ctx.dest.client, intentGatewayV2Address);
-    const fillOrderCalldata = encodeFillOrder(
-      transformOrderForContract(orderForEstimation),
-      fillOptions,
-      fillOptionsVersion
-    );
+    await assertGatewayRelease(this.ctx.dest.client, intentGatewayV2Address);
+    const fillOrderCalldata = encodeFillOrder(transformOrderForContract(orderForEstimation), fillOptions);
     let callGasLimit = 500000n;
     let verificationGasLimit = 100000n;
     let preVerificationGas = 100000n;
@@ -18855,7 +18528,8 @@ var GasEstimator = class {
       totalGasCostWei,
       totalGasInFeeToken: totalGasInSourceFeeToken,
       relayerFeeInSourceFeeToken: crossChainFees.relayerFeeInSourceFeeToken,
-      fillOptions
+      fillOptions,
+      inputs
     };
   }
   /**
@@ -19018,35 +18692,47 @@ var OrderStatusChecker = class {
   }
   ctx;
   /**
-   * Checks if a V2 order has been filled by reading the commitment storage slot on the destination chain.
-   *
-   * Reads the storage slot returned by `calculateCommitmentSlotHash` on the IntentGatewayV2 contract.
-   * A non-zero value at that slot means the solver has called `fillOrder` and the order is complete
-   * from the user's perspective (the beneficiary has received their tokens).
+   * Whether the order is finalized on the destination chain, read from the gateway's `_filled`
+   * getter. It is set by the completing fill, and by a cancellation, which records the refund
+   * beneficiary there. A partially filled order reads false; see {@link getFillProgress}.
    *
    * @param order - The V2 order to check. `order.id` is used as the commitment; if not set it is computed.
-   * @returns True if the order has been filled on the destination chain, false otherwise.
    */
   async isOrderFilled(order) {
     const commitment = order.id ?? orderCommitment(order);
-    const destStateMachineId = viem.isHex(order.destination) ? viem.hexToString(order.destination) : order.destination;
-    const intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachineId);
-    const filledSlot = await this.ctx.dest.client.readContract({
+    const gateway = this.ctx.dest.configService.getIntentGatewayAddress(destinationStateMachine(order));
+    const finalizer = await this.ctx.dest.client.readContract({
       abi: ABI3,
-      address: intentGatewayV2Address,
-      functionName: "calculateCommitmentSlotHash",
+      address: gateway,
+      functionName: "_filled",
       args: [commitment]
     });
-    const filledStatus = await this.ctx.dest.client.getStorageAt({
-      address: intentGatewayV2Address,
-      slot: filledSlot
-    });
-    return filledStatus !== "0x0000000000000000000000000000000000000000000000000000000000000000";
+    return !/^0x0{40}$/i.test(finalizer);
+  }
+  /**
+   * Output credited to the order so far, one entry per leg, read from `_partialFills` on the
+   * destination chain. Several solvers can each fill a slice of a same-chain or cross-chain order,
+   * so this, not {@link isOrderFilled}, says how far along an open order is. Surplus paid above
+   * the order's rate is not counted.
+   *
+   * @param order - The V2 order to check. `order.id` is used as the commitment; if not set it is computed.
+   */
+  async getFillProgress(order) {
+    const commitment = order.id ?? orderCommitment(order);
+    const gateway = this.ctx.dest.configService.getIntentGatewayAddress(destinationStateMachine(order));
+    return Promise.all(
+      order.output.assets.map(async (asset, index) => ({
+        token: asset.token,
+        amount: await readLegPartialFill(this.ctx.dest.client, gateway, commitment, index, asset.token)
+      }))
+    );
   }
   /**
    * Checks if a V2 order has been refunded by reading the `_orders` mapping on the source chain.
    *
-   * Calls `_orders(commitment, tokenAddress)` for each input token. When the order is placed the
+   * Calls `_orders(commitment, index)` for each input: escrow is held per leg, keyed by the input's
+   * index, so inputs that repeat a token are read separately. A gateway not yet upgraded to per-leg
+   * escrow is read by token instead, see {@link readLegEscrow}. When the order is placed the
    * escrowed amounts are stored there. After a successful refund the contract zeroes them out.
    * An order is considered refunded when all escrowed input amounts have been returned (i.e. are 0).
    *
@@ -19058,14 +18744,14 @@ var OrderStatusChecker = class {
     const commitment = order.id ?? orderCommitment(order);
     const sourceStateMachineId = viem.isHex(order.source) ? viem.hexToString(order.source) : order.source;
     const intentGatewayV2Address = this.ctx.source.configService.getIntentGatewayAddress(sourceStateMachineId);
-    for (const input of order.inputs) {
-      const tokenAddress = bytes32ToBytes20(input.token);
-      const escrowedAmount = await this.ctx.source.client.readContract({
-        abi: ABI3,
-        address: intentGatewayV2Address,
-        functionName: "_orders",
-        args: [commitment, tokenAddress]
-      });
+    for (let index = 0; index < order.inputs.length; index++) {
+      const escrowedAmount = await readLegEscrow(
+        this.ctx.source.client,
+        intentGatewayV2Address,
+        commitment,
+        index,
+        order.inputs[index].token
+      );
       if (escrowedAmount !== 0n) {
         return false;
       }
@@ -19073,726 +18759,466 @@ var OrderStatusChecker = class {
     return true;
   }
 };
-
-// src/protocols/intents/liquidity-pool.ts
-function sortPoolSymbols(symbolA, symbolB) {
-  return symbolA.toLowerCase() <= symbolB.toLowerCase() ? [symbolA, symbolB] : [symbolB, symbolA];
+function destinationStateMachine(order) {
+  return viem.isHex(order.destination) ? viem.hexToString(order.destination) : order.destination;
 }
-function poolSlug(symbolA, symbolB) {
-  return sortPoolSymbols(symbolA, symbolB).join("-");
-}
-function resolveLiquidityPool(symbolA, symbolB) {
-  const [token0Symbol, token1Symbol] = sortPoolSymbols(symbolA, symbolB);
-  return {
-    poolId: `${token0Symbol}-${token1Symbol}`,
-    token0Symbol,
-    token1Symbol
-  };
+var ORDERBOOK_URLS = {
+  mainnet: "https://orderbook.hyperfx.finance/mainnet/graphql",
+  testnet: "https://orderbook.hyperfx.finance/testnet/graphql"
+};
+function orderbookUrlFor(stateMachineId) {
+  return TESTNET_CHAINS.has(stateMachineId) ? ORDERBOOK_URLS.testnet : ORDERBOOK_URLS.mainnet;
 }
-
-// src/protocols/intents/LiquidityEngine.ts
-var INDEXER_FIXED_POINT_DECIMALS = 18;
-var POOL_RATE_SCALE = 10n ** 18n;
-var SELL = "SELL";
-var BUY = "BUY";
-var USD_STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USDT"]);
-var LiquidityEngine = class {
-  constructor(queryClient) {
-    this.queryClient = queryClient;
-  }
-  queryClient;
+var ORDERBOOK_DECIMALS = 18;
+var ORDERBOOK_SCALE = 10n ** BigInt(ORDERBOOK_DECIMALS);
+var OrderbookRequestError = class extends Error {
+  constructor(message) {
+    super(`HyperFX orderbook request failed: ${message}`);
+    this.name = "OrderbookRequestError";
+  }
+};
+var RATE_FIELDS = "side fillChain rate depthIn depthOut backingLiquidity sourceChains orderCount solverCount";
+var TOP_OF_BOOK_QUERY = `
+query TopOfBook($tokenA: String!, $tokenB: String!, $fillChain: String!, $sourceChain: String!) {
+  books { id base quote }
+  aToB: bestRate(tokenIn: $tokenA, tokenOut: $tokenB, fillChain: $fillChain, sourceChain: $sourceChain) { ${RATE_FIELDS} }
+  bToA: bestRate(tokenIn: $tokenB, tokenOut: $tokenA, fillChain: $fillChain, sourceChain: $sourceChain) { ${RATE_FIELDS} }
+}`;
+var ROUTE_LIQUIDITY_QUERY = `
+query RouteLiquidity($route: RouteInput!) {
+  books { id base quote }
+  routeLiquidity(route: $route) {
+    route bestRate slippageBps depthIn depthOut availableLiquidity maxFillableIn orderCount solverCount
+  }
+}`;
+var QUOTE_QUERY = `
+query Quote($route: RouteInput!, $amountIn: BigInt!) {
+  quote(route: $route, amountIn: $amountIn) {
+    route side amountIn slippageBps fillable maxFillableIn
+    fills { advertisedSize orderRate amountIn amountOut }
+  }
+}`;
+var QUOTE_PESSIMISTIC_QUERY = `
+query QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {
+  quotePessimistic(route: $route, amountIn: $amountIn) {
+    route side amountIn amountOut rate priceBucket slippageBps fillable maxFillableIn
+  }
+}`;
+var ORDERBOOK_QUERIES = {
+  topOfBook: TOP_OF_BOOK_QUERY,
+  routeLiquidity: ROUTE_LIQUIDITY_QUERY,
+  quote: QUOTE_QUERY,
+  quotePessimistic: QUOTE_PESSIMISTIC_QUERY
+};
+var HyperFxOrderbook = class {
+  client;
+  /** @param urlOrClient - The orderbook's GraphQL URL, or a configured `graphql-request` client. */
+  constructor(urlOrClient = ORDERBOOK_URLS.mainnet) {
+    this.client = typeof urlOrClient === "string" ? new graphqlRequest.GraphQLClient(urlOrClient) : urlOrClient;
+  }
   /**
-   * Returns liquidity reachable from one source chain on one destination.
-   *
-   * The caller resolves chain-specific token addresses through chain
-   * configuration; this layer only maps those configured symbols onto the
-   * indexer's canonical pool and route fields.
-   *
-   * Destination, unrestricted, and explicit-route capacity are returned as
-   * separate values so callers can apply their own source-chain policy.
-   *
-   * @returns `undefined` only when the indexer has not published a destination
-   * pool sample yet.
-   */
-  async getAvailableLiquidity(params) {
-    const pool = resolveLiquidityPool(params.source.symbol, params.destination.symbol);
-    const direction = params.source.symbol.toLowerCase() === pool.token0Symbol.toLowerCase() ? SELL : BUY;
-    const variables = {
-      poolId: pool.poolId,
-      sourceChain: params.source.chain,
-      destinationChain: params.destination.chain,
-      direction
+   * The best bid and ask on `fillChain` for the pair `tokenA`/`tokenB`, counting
+   * only orders a swap from `sourceChain` can use.
+   */
+  async topOfBook(params) {
+    const data = await this.request(TOP_OF_BOOK_QUERY, params);
+    const book = findBook(data.books, params.tokenA, params.tokenB);
+    const rates = [data.aToB, data.bToA].filter((rate) => rate !== null).map(parseRate);
+    return {
+      book,
+      bid: rates.find((rate) => rate.side === "BID") ?? null,
+      ask: rates.find((rate) => rate.side === "ASK") ?? null
     };
-    const response = await this.queryClient.request(AVAILABLE_LIQUIDITY, variables);
-    if (!response?.poolChainLiquidities?.nodes || !response?.poolRoutes?.nodes) {
-      throw new InvalidLiquidityIndexerResponseError("liquidity connections are missing");
-    }
-    const chainLiquidity = response.poolChainLiquidities.nodes[0];
-    if (!chainLiquidity) return void 0;
-    const route = response.poolRoutes.nodes[0];
+  }
+  /** Total liquidity on a route, no amount required. */
+  async routeLiquidity(route) {
+    const { books, routeLiquidity: raw } = await this.request(ROUTE_LIQUIDITY_QUERY, { route });
+    const book = findBook(books, route.tokenIn, route.tokenOut);
     return {
-      sourceChain: params.source.chain,
-      destinationChain: params.destination.chain,
-      tokenAddress: normalizeEvmAddress(params.destination.address, "destination token"),
-      updatedAt: readIndexerDate(chainLiquidity.lastUpdatedAt, "destination lastUpdatedAt"),
-      destination: readLiquiditySlice(chainLiquidity.depth, chainLiquidity.bidCount, "destination"),
-      unrestricted: readLiquiditySlice(
-        chainLiquidity.unrestrictedDepth,
-        chainLiquidity.unrestrictedBidCount,
-        "unrestricted"
-      ),
-      explicitRoute: route ? {
-        ...readLiquiditySlice(route.depth, route.bidCount, "explicit route"),
-        updatedAt: readIndexerDate(route.lastUpdatedAt, "route lastUpdatedAt")
-      } : null
+      route: raw.route,
+      book,
+      side: sameSymbol(book.base, route.tokenIn) ? "BID" : "ASK",
+      bestRate: optionalBigInt(raw.bestRate),
+      slippageBps: raw.slippageBps,
+      depthIn: BigInt(raw.depthIn),
+      depthOut: BigInt(raw.depthOut),
+      availableLiquidity: BigInt(raw.availableLiquidity),
+      maxFillableIn: BigInt(raw.maxFillableIn),
+      orderCount: raw.orderCount,
+      solverCount: raw.solverCount
     };
   }
   /**
-   * Returns the indexed pool's aggregate buy and sell rates in less-valued
-   * quote-token units per one base token.
-   *
-   * The indexer depth-weights fresh per-chain samples into the pool rates. The
-   * source and destination chains remain part of the result because they define
-   * the cross-chain route whose configured token symbols were resolved.
-   */
-  async getBuyAndSellRates(params) {
-    const pool = resolveLiquidityPool(params.tokenInSymbol, params.tokenOutSymbol);
-    const response = await this.queryClient.request(BUY_AND_SELL_RATES, {
-      poolId: pool.poolId
+   * The optimistic quote for `amountIn` (1e18 tokenIn) on a route: the route's orders, best price
+   * first, each taking what it can at its own price. The fills' `amountOut`s sum to the output.
+   */
+  async quote(route, amountIn) {
+    const { quote: raw } = await this.request(QUOTE_QUERY, {
+      route,
+      amountIn: amountIn.toString()
     });
-    if (!response?.liquidityPools?.nodes) {
-      throw new InvalidLiquidityIndexerResponseError("liquidity pool connection is missing");
-    }
-    const indexedPool = response.liquidityPools.nodes[0];
-    if (!indexedPool) return void 0;
-    validateIndexedPool(indexedPool, pool);
-    const sell = readIndexedRate(indexedPool.sellRate, indexedPool.lastUpdatedAt, "pool sell rate");
-    const buy = readIndexedRate(indexedPool.buyRate, indexedPool.lastUpdatedAt, "pool buy rate");
-    const inputIsToken0 = params.tokenInSymbol.toLowerCase() === pool.token0Symbol.toLowerCase();
-    const direct = inputIsToken0 ? sell : buy;
-    const reverse = inputIsToken0 ? buy : sell;
-    if (!direct && !reverse) return void 0;
-    const quoteTokenSymbol = resolveQuoteTokenSymbol(
-      params.tokenInSymbol,
-      params.tokenOutSymbol,
-      direct?.scaledRate,
-      reverse?.scaledRate
+    return {
+      route: raw.route,
+      side: raw.side,
+      amountIn: BigInt(raw.amountIn),
+      slippageBps: raw.slippageBps,
+      fillable: raw.fillable,
+      maxFillableIn: BigInt(raw.maxFillableIn),
+      fills: raw.fills.map((fill) => ({
+        advertisedSize: BigInt(fill.advertisedSize),
+        orderRate: BigInt(fill.orderRate),
+        amountIn: BigInt(fill.amountIn),
+        amountOut: BigInt(fill.amountOut)
+      }))
+    };
+  }
+  /**
+   * The pessimistic quote for `amountIn` (1e18 tokenIn) on a route: one price, from the first level
+   * deep enough to fill the whole trade by itself, at which every order in it fills; the route's
+   * worst price when no one level can but its levels together can.
+   */
+  async quotePessimistic(route, amountIn) {
+    const { quotePessimistic: raw } = await this.request(
+      QUOTE_PESSIMISTIC_QUERY,
+      { route, amountIn: amountIn.toString() }
     );
-    const quoteIsTokenOut = quoteTokenSymbol === params.tokenOutSymbol;
-    const orientedBuy = quoteIsTokenOut ? direct : reverse;
-    const orientedSell = quoteIsTokenOut ? reverse : direct;
     return {
-      baseTokenSymbol: quoteIsTokenOut ? params.tokenInSymbol : params.tokenOutSymbol,
-      quoteTokenSymbol,
-      sourceChain: params.sourceChain,
-      destinationChain: params.destinationChain,
-      buyRate: orientedBuy ? viem.formatUnits(orientedBuy.scaledRate, INDEXER_FIXED_POINT_DECIMALS) : null,
-      sellRate: orientedSell ? viem.formatUnits(reciprocalRate(orientedSell.scaledRate, "sell rate"), INDEXER_FIXED_POINT_DECIMALS) : null,
-      buyRateUpdatedAt: orientedBuy?.updatedAt ?? null,
-      sellRateUpdatedAt: orientedSell?.updatedAt ?? null
+      route: raw.route,
+      side: raw.side,
+      amountIn: BigInt(raw.amountIn),
+      amountOut: BigInt(raw.amountOut),
+      rate: optionalBigInt(raw.rate),
+      priceBucket: optionalBigInt(raw.priceBucket),
+      slippageBps: raw.slippageBps,
+      fillable: raw.fillable,
+      maxFillableIn: BigInt(raw.maxFillableIn)
     };
   }
-};
-var InvalidLiquidityIndexerResponseError = class extends Error {
-  constructor(reason) {
-    super(`Invalid liquidity indexer response: ${reason}`);
-    this.name = "InvalidLiquidityIndexerResponseError";
+  async request(query, variables) {
+    try {
+      return await this.client.request(query, variables);
+    } catch (error) {
+      throw new OrderbookRequestError(describeError(error));
+    }
   }
 };
+function describeError(error) {
+  const graphqlErrors = error?.response?.errors;
+  if (graphqlErrors?.length) return graphqlErrors.map((e) => e.message).join("; ");
+  return error instanceof Error ? error.message : String(error);
+}
+function sameSymbol(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function findBook(books, tokenA, tokenB) {
+  const book = books.find(
+    (b) => sameSymbol(b.base, tokenA) && sameSymbol(b.quote, tokenB) || sameSymbol(b.base, tokenB) && sameSymbol(b.quote, tokenA)
+  );
+  if (!book) throw new OrderbookRequestError(`no book trades ${tokenA} for ${tokenB}`);
+  return book;
+}
+function optionalBigInt(value) {
+  return value === null ? null : BigInt(value);
+}
+function parseRate(raw) {
+  return {
+    side: raw.side,
+    fillChain: raw.fillChain,
+    rate: BigInt(raw.rate),
+    depthIn: BigInt(raw.depthIn),
+    depthOut: BigInt(raw.depthOut),
+    backingLiquidity: BigInt(raw.backingLiquidity),
+    sourceChains: raw.sourceChains,
+    orderCount: raw.orderCount,
+    solverCount: raw.solverCount
+  };
+}
+
+// src/protocols/intents/orderbook/types.ts
 var UnsupportedLiquidityAssetError = class extends Error {
   constructor(chain, asset) {
-    super(`No configured liquidity asset found for ${asset} on ${chain}`);
+    super(`No configured asset found for ${asset} on ${chain}`);
     this.name = "UnsupportedLiquidityAssetError";
   }
 };
 var UnsupportedLiquidityChainError = class extends Error {
   constructor(chainId) {
-    super(`No configured liquidity chain found for chain ID ${chainId}`);
+    super(`No configured chain found for chain ID ${chainId}`);
     this.name = "UnsupportedLiquidityChainError";
   }
 };
-function readLiquiditySlice(depth, providerCount, label) {
-  if (!Number.isSafeInteger(providerCount) || providerCount < 0) {
-    throw new InvalidLiquidityIndexerResponseError(`${label} provider count is invalid`);
-  }
-  return { totalLiquidity: formatIndexerAmount(depth, `${label} depth`), providerCount };
-}
-function formatIndexerAmount(value, label) {
-  try {
-    const amount = BigInt(value);
-    if (amount < 0n) throw new Error();
-    return viem.formatUnits(amount, INDEXER_FIXED_POINT_DECIMALS);
-  } catch {
-    throw new InvalidLiquidityIndexerResponseError(`${label} is not a non-negative integer`);
+var OrderbookQuoteNotConvergedError = class extends Error {
+  constructor(route, rounds, lastAmountIn) {
+    super(
+      `No input for ${route.tokenIn} -> ${route.tokenOut} on ${route.sourceChain} -> ${route.destinationChain} delivered the requested output within ${rounds} quotes; the last tried ${lastAmountIn} raw units`
+    );
+    this.route = route;
+    this.rounds = rounds;
+    this.lastAmountIn = lastAmountIn;
+    this.name = "OrderbookQuoteNotConvergedError";
+  }
+  route;
+  rounds;
+  lastAmountIn;
+};
+var InsufficientOrderbookLiquidityError = class extends Error {
+  constructor(route, maxFillableIn) {
+    super(
+      `The HyperFX orderbook cannot fill ${route.tokenIn} -> ${route.tokenOut} on ${route.sourceChain} -> ${route.destinationChain}; max fillable input is ${maxFillableIn} raw units`
+    );
+    this.route = route;
+    this.maxFillableIn = maxFillableIn;
+    this.name = "InsufficientOrderbookLiquidityError";
   }
-}
-function readIndexerDate(value, label) {
-  const date = new Date(dateStringtoTimestamp(value));
-  if (Number.isNaN(date.getTime())) throw new InvalidLiquidityIndexerResponseError(`${label} is invalid`);
-  return date;
-}
-function readIndexedRate(value, lastUpdatedAt, label) {
-  if (value === null) return void 0;
-  try {
-    const scaledRate = BigInt(value);
-    if (scaledRate <= 0n) throw new Error();
+  route;
+  maxFillableIn;
+};
+
+// src/protocols/intents/orderbook/market.ts
+var MAX_EXACT_OUTPUT_ROUNDS = 16;
+var OrderbookMarket = class {
+  constructor(configService, orderbook) {
+    this.configService = configService;
+    this.orderbook = orderbook;
+  }
+  configService;
+  orderbook;
+  async quoteIntent(params, sourceChain, destinationChain) {
+    const orderbook = this.orderbook();
+    if (!params.optimistic) {
+      const { quote: quote2, tokenIn: tokenIn2, tokenOut: tokenOut2 } = await this.priceIntent(
+        params,
+        sourceChain,
+        destinationChain,
+        (route, amountIn) => orderbook.quotePessimistic(route, amountIn),
+        levelQuoteTotals
+      );
+      return {
+        route: quote2.route,
+        side: quote2.side,
+        amountIn: fromOrderbookAmount(quote2.amountIn, tokenIn2.decimals),
+        amountOut: fromOrderbookAmount(quote2.amountOut, tokenOut2.decimals),
+        rate: quote2.rate,
+        priceBucket: quote2.priceBucket,
+        slippageBps: quote2.slippageBps,
+        fillable: quote2.fillable,
+        maxFillableIn: fromOrderbookAmount(quote2.maxFillableIn, tokenIn2.decimals)
+      };
+    }
+    const { quote, tokenIn, tokenOut } = await this.priceIntent(
+      params,
+      sourceChain,
+      destinationChain,
+      (route, amountIn) => orderbook.quote(route, amountIn),
+      swapQuoteTotals
+    );
     return {
-      scaledRate,
-      updatedAt: readIndexerDate(lastUpdatedAt, `${label} lastUpdatedAt`)
+      route: quote.route,
+      side: quote.side,
+      amountIn: fromOrderbookAmount(quote.amountIn, tokenIn.decimals),
+      slippageBps: quote.slippageBps,
+      fillable: quote.fillable,
+      maxFillableIn: fromOrderbookAmount(quote.maxFillableIn, tokenIn.decimals),
+      legs: quote.fills.map((fill) => ({
+        advertisedSize: fromOrderbookAmount(fill.advertisedSize, tokenOut.decimals),
+        orderRate: fill.orderRate,
+        amountIn: fromOrderbookAmount(fill.amountIn, tokenIn.decimals),
+        amountOut: fromOrderbookAmount(fill.amountOut, tokenOut.decimals)
+      }))
     };
-  } catch (error) {
-    if (error instanceof InvalidLiquidityIndexerResponseError) throw error;
-    throw new InvalidLiquidityIndexerResponseError(`${label} is not a positive integer`);
   }
-}
-function validateIndexedPool(indexedPool, expected) {
-  if (indexedPool.id.toLowerCase() !== expected.poolId.toLowerCase() || indexedPool.token0Symbol.toLowerCase() !== expected.token0Symbol.toLowerCase() || indexedPool.token1Symbol.toLowerCase() !== expected.token1Symbol.toLowerCase()) {
-    throw new InvalidLiquidityIndexerResponseError(`pool identity does not match ${expected.poolId}`);
+  /**
+   * The fillable quote for an exact input, or for the input found to deliver an
+   * exact output, with the assets it trades.
+   */
+  async priceIntent(params, sourceChain, destinationChain, price, totals) {
+    validateQuoteParams(params);
+    const tokenIn = this.assetByAddress(sourceChain, params.tokenIn);
+    const tokenOut = this.assetByAddress(destinationChain, params.tokenOut);
+    const route = toRoute(tokenIn, tokenOut);
+    if (params.amountIn !== void 0) {
+      const quote2 = await price(route, toOrderbookAmount(params.amountIn, tokenIn.decimals));
+      const { fillable, amountOut, maxFillableIn } = totals(quote2);
+      if (!fillable || fromOrderbookAmount(amountOut, tokenOut.decimals) === 0n) {
+        throw this.insufficient(route, maxFillableIn, tokenIn);
+      }
+      return { quote: quote2, tokenIn, tokenOut };
+    }
+    const targetOut = toOrderbookAmount(params.amountOut, tokenOut.decimals);
+    const quote = await this.quoteExactOutput(route, targetOut, tokenIn, price, totals);
+    return { quote, tokenIn, tokenOut };
+  }
+  async availableLiquidity(params, sourceChain, destinationChain) {
+    const tokenIn = this.assetByAddress(sourceChain, params.tokenIn);
+    const tokenOut = this.assetByAddress(destinationChain, params.tokenOut);
+    const liquidity = await this.orderbook().routeLiquidity(toRoute(tokenIn, tokenOut));
+    const [base3, quote] = liquidity.side === "BID" ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+    return {
+      sourceChain: tokenIn.chain,
+      destinationChain: tokenOut.chain,
+      tokenInSymbol: tokenIn.symbol,
+      tokenOutSymbol: tokenOut.symbol,
+      tokenAddress: tokenOut.address,
+      route: liquidity.route,
+      side: liquidity.side,
+      baseTokenSymbol: base3.symbol,
+      quoteTokenSymbol: quote.symbol,
+      bestRate: formatOptional(liquidity.bestRate),
+      availableLiquidity: format(liquidity.availableLiquidity),
+      depthIn: format(liquidity.depthIn),
+      depthOut: format(liquidity.depthOut),
+      maxFillableIn: format(liquidity.maxFillableIn),
+      orderCount: liquidity.orderCount,
+      solverCount: liquidity.solverCount
+    };
   }
-}
-function resolveQuoteTokenSymbol(tokenInSymbol, tokenOutSymbol, directRate, reverseRate) {
-  const inputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenInSymbol);
-  const outputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenOutSymbol);
-  if (inputIsUsdStable !== outputIsUsdStable) return inputIsUsdStable ? tokenOutSymbol : tokenInSymbol;
-  if (directRate !== void 0) return directRate >= POOL_RATE_SCALE ? tokenOutSymbol : tokenInSymbol;
-  if (reverseRate !== void 0) return reverseRate >= POOL_RATE_SCALE ? tokenInSymbol : tokenOutSymbol;
-  throw new InvalidLiquidityIndexerResponseError("cannot orient an empty rate pair");
-}
-function reciprocalRate(rate, label) {
-  const numerator = POOL_RATE_SCALE * POOL_RATE_SCALE;
-  const reciprocal = (numerator + rate - 1n) / rate;
-  if (reciprocal <= 0n) throw new InvalidLiquidityIndexerResponseError(`${label} reciprocal underflowed`);
-  return reciprocal;
-}
-
-// src/protocols/intents/quote/types.ts
-var UnsupportedIntentQuoteStrategyError = class extends Error {
-  constructor(strategy) {
-    super(`Unsupported intent quote strategy: ${strategy}`);
-    this.name = "UnsupportedIntentQuoteStrategyError";
+  async buyAndSellRates(params) {
+    const tokenIn = this.assetBySymbol(params.sourceChain, params.tokenInSymbol);
+    const tokenOut = this.assetBySymbol(params.destinationChain, params.tokenOutSymbol);
+    const { book, bid, ask } = await this.orderbook().topOfBook({
+      tokenA: tokenIn.symbol,
+      tokenB: tokenOut.symbol,
+      fillChain: tokenOut.chain,
+      sourceChain: tokenIn.chain
+    });
+    const bidRate = bid?.rate ?? null;
+    const askRate = ask?.rate ?? null;
+    const mid = bidRate !== null && askRate !== null ? (bidRate + askRate) / 2n : null;
+    const spread = bidRate !== null && askRate !== null && askRate >= bidRate ? askRate - bidRate : null;
+    return {
+      baseTokenSymbol: book.base,
+      quoteTokenSymbol: book.quote,
+      sourceChain: tokenIn.chain,
+      destinationChain: tokenOut.chain,
+      bid: formatOptional(bidRate),
+      ask: formatOptional(askRate),
+      mid: formatOptional(mid),
+      spread: formatOptional(spread),
+      spreadBps: spread !== null && mid ? Number(spread * 1000000n / mid) / 100 : null
+    };
   }
-};
-var UnsupportedIntentQuotePairError = class extends Error {
-  constructor(params) {
-    super(
-      `No ${params.quoteSource ?? "Uniswap v4 pool config"} found for ${params.tokenIn} -> ${params.tokenOut} on ${params.source} -> ${params.destination}`
+  /**
+   * The orderbook only quotes an input amount, so an output is priced by
+   * guessing the input from the best rate, then keeping the part of each quote
+   * filled better than its worst rate and re-pricing the rest of `targetOut` at
+   * the input-to-output ratio that part filled at, until a quote delivers it.
+   * That ratio is the orderbook's own, with the protocol fee already taken off.
+   */
+  async quoteExactOutput(route, targetOut, tokenIn, price, totals) {
+    const liquidity = await this.orderbook().routeLiquidity(route);
+    if (liquidity.bestRate === null) throw this.insufficient(route, 0n, tokenIn);
+    const inputUnit = toOrderbookAmount(1n, tokenIn.decimals);
+    let amountIn = roundUpTo(requiredInput(liquidity.side, targetOut, liquidity.bestRate), inputUnit);
+    let lastAmountIn = amountIn;
+    for (let round = 0; round < MAX_EXACT_OUTPUT_ROUNDS; round++) {
+      if (amountIn > liquidity.maxFillableIn) throw this.insufficient(route, liquidity.maxFillableIn, tokenIn);
+      const served = await price(route, amountIn);
+      const quote = totals(served);
+      if (quote.fillable && quote.amountOut >= targetOut) return served;
+      lastAmountIn = amountIn;
+      const betterIn = quote.amountIn - quote.worstIn;
+      const betterOut = quote.amountOut - quote.worstOut;
+      const next = quote.fillable && quote.worstOut > 0n ? betterIn + roundUpTo(divCeil((targetOut - betterOut) * quote.worstIn, quote.worstOut), inputUnit) : amountIn;
+      amountIn = next > amountIn ? next : amountIn + inputUnit;
+    }
+    throw new OrderbookQuoteNotConvergedError(
+      route,
+      MAX_EXACT_OUTPUT_ROUNDS,
+      fromOrderbookAmount(lastAmountIn, tokenIn.decimals)
     );
-    this.name = "UnsupportedIntentQuotePairError";
   }
-};
-var PhantomSnapshotUnavailableError = class extends Error {
-  constructor(tokenA, tokenB) {
-    super(`No Phantom order price snapshot found for ${tokenA} -> ${tokenB}`);
-    this.name = "PhantomSnapshotUnavailableError";
+  insufficient(route, maxFillableIn, tokenIn) {
+    return new InsufficientOrderbookLiquidityError(route, fromOrderbookAmount(maxFillableIn, tokenIn.decimals));
   }
-};
-var InvalidPhantomSnapshotError = class extends Error {
-  constructor(commitment, reason) {
-    super(`Invalid Phantom order price snapshot ${commitment}: ${reason}`);
-    this.name = "InvalidPhantomSnapshotError";
+  assetByAddress(chain, address) {
+    const resolvedChain = resolveChain(chain);
+    return withDecimals(
+      resolvedChain,
+      address,
+      this.configService.getAssetMetadataByAddress(resolvedChain, address)
+    );
   }
-};
-var IndexedRateUnavailableError = class extends Error {
-  constructor(params) {
-    const route = params.source && params.destination && params.tokenIn && params.tokenOut ? ` for ${params.tokenIn} -> ${params.tokenOut} on ${params.source} -> ${params.destination}` : "";
-    const side = params.side ? ` ${params.side}` : "";
-    super(`No indexed${side} rate available${route}`);
-    this.name = "IndexedRateUnavailableError";
+  assetBySymbol(chain, symbol) {
+    const resolvedChain = resolveChain(chain);
+    return withDecimals(resolvedChain, symbol, this.configService.getAssetMetadataBySymbol(resolvedChain, symbol));
   }
 };
-var InvalidIndexedRateError = class extends Error {
-  constructor(reason) {
-    super(`Invalid indexed intent rate: ${reason}`);
-    this.name = "InvalidIndexedRateError";
+function resolveChain(chain) {
+  const stateMachineId = getConfigByStateMachineId(chain)?.stateMachineId;
+  if (!stateMachineId) throw new UnsupportedLiquidityChainError(chain);
+  return stateMachineId;
+}
+function withDecimals(chain, asset, metadata) {
+  if (!metadata) throw new UnsupportedLiquidityAssetError(chain, asset);
+  const { decimals } = metadata;
+  if (decimals === void 0 || !Number.isSafeInteger(decimals) || decimals < 0 || decimals > ORDERBOOK_DECIMALS) {
+    throw new UnsupportedLiquidityAssetError(chain, `${metadata.symbol} (decimals are not configured)`);
   }
-};
-var BPS_DENOMINATOR = 10000n;
+  return { chain, symbol: metadata.symbol, address: metadata.address, decimals };
+}
 function 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 (params.amountIn !== void 0 && params.amountIn <= 0n) throw new Error("amountIn must be greater than zero");
   if (params.amountOut !== void 0 && params.amountOut <= 0n) throw new Error("amountOut must be greater than zero");
-  if (params.tokenIn.toLowerCase() === params.tokenOut.toLowerCase()) {
-    throw new Error("tokenIn and tokenOut cannot be the same");
-  }
 }
-async function readProtocolFeeBps(chainConfigService, source) {
-  const gatewayAddress = chainConfigService.getIntentGatewayAddress(source.stateMachineId);
-  if (!gatewayAddress || gatewayAddress === "0x" || gatewayAddress === viem.zeroAddress) {
-    throw new Error(`IntentGatewayV2 is not configured for chain ${source.stateMachineId}`);
-  }
-  const gatewayParams = await source.client.readContract({
-    address: gatewayAddress,
-    abi: IntentGatewayV2_default.ABI,
-    functionName: "params"
-  });
-  const protocolFeeBps = Array.isArray(gatewayParams) ? BigInt(gatewayParams[4]) : BigInt(gatewayParams.protocolFeeBps ?? 0);
-  if (protocolFeeBps < 0n || protocolFeeBps >= BPS_DENOMINATOR) {
-    throw new Error(`Invalid IntentGateway protocol fee: ${protocolFeeBps} bps`);
-  }
-  return protocolFeeBps;
-}
-function deductProtocolFee(amount, protocolFeeBps) {
-  if (protocolFeeBps <= 0n) return amount;
-  const fee = amount * protocolFeeBps / BPS_DENOMINATOR;
-  return amount - fee;
+function toRoute(tokenIn, tokenOut) {
+  return {
+    tokenIn: tokenIn.symbol,
+    tokenOut: tokenOut.symbol,
+    sourceChain: tokenIn.chain,
+    destinationChain: tokenOut.chain
+  };
 }
-function grossUpForProtocolFee(netAmount, protocolFeeBps) {
-  if (protocolFeeBps <= 0n) return netAmount;
-  if (protocolFeeBps >= BPS_DENOMINATOR) throw new Error("protocolFeeBps must be less than 10,000");
-  return divCeil(netAmount * BPS_DENOMINATOR, BPS_DENOMINATOR - protocolFeeBps);
+function requiredInput(side, amountOut, rate) {
+  return side === "BID" ? divCeil(amountOut * ORDERBOOK_SCALE, rate) : divCeil(amountOut * rate, ORDERBOOK_SCALE);
 }
-function divCeil(numerator, denominator) {
-  if (denominator <= 0n) throw new Error("denominator must be greater than zero");
-  return (numerator + denominator - 1n) / denominator;
+function swapQuoteTotals(quote) {
+  const worstFill = quote.fills.at(-1);
+  if (quote.fillable && !worstFill)
+    throw new OrderbookRequestError("the orderbook served a fillable quote with no fills");
+  return {
+    side: quote.side,
+    amountIn: quote.amountIn,
+    amountOut: quote.fills.reduce((total, fill) => total + fill.amountOut, 0n),
+    fillable: quote.fillable,
+    maxFillableIn: quote.maxFillableIn,
+    worstIn: worstFill?.amountIn ?? 0n,
+    worstOut: worstFill?.amountOut ?? 0n
+  };
 }
-
-// src/protocols/intents/quote/uniswapV4.ts
-var UNISWAP_INTENT_QUOTE_CHAIN = "EVM-8453" /* BASE_MAINNET */;
-var UniswapV4IntentQuoteStrategy = class {
-  constructor(chainConfigService) {
-    this.chainConfigService = chainConfigService;
-  }
-  chainConfigService;
-  baseQuoteClient;
-  async quote(params, source, destination) {
-    validateQuoteParams(params);
-    const protocolFeeBps = await readProtocolFeeBps(this.chainConfigService, source);
-    const quoteClient = this.resolveQuoteClient(source, destination);
-    const poolConfig = this.resolvePoolConfig(params, source.stateMachineId, destination.stateMachineId);
-    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;
-  }
-  resolvePoolConfig(params, source, destination) {
-    const override = params.uniswapV4?.poolKey;
-    if (override) {
-      const poolKey = normalizePoolKey(override);
-      const tokenInForQuote = viem.getAddress(override.currencyIn ?? params.tokenIn);
-      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(UNISWAP_INTENT_QUOTE_CHAIN, override.quoterAddress),
-        tokenInForQuote
-      };
-    }
-    const poolConfig = this.resolveConfiguredPool(params, source, destination, UNISWAP_INTENT_QUOTE_CHAIN);
-    if (poolConfig) return poolConfig;
-    throw new UnsupportedIntentQuotePairError({
-      source,
-      destination,
-      tokenIn: params.tokenIn,
-      tokenOut: params.tokenOut
-    });
-  }
-  resolveConfiguredPool(params, sourceChain, destinationChain, quoteChain) {
-    for (const pool of this.chainConfigService.getUniswapV4PoolConfigs(quoteChain)) {
-      const resolvedPool = this.resolveConfiguredPoolTokens(quoteChain, pool);
-      if (!resolvedPool) continue;
-      const tokenInForQuote = this.matchPoolToken(params.tokenIn, sourceChain, resolvedPool);
-      const tokenOutForQuote = this.matchPoolToken(params.tokenOut, destinationChain, 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(quoteChain),
-        tokenInForQuote: tokenInForQuote.address
-      };
-    }
-    return null;
+function levelQuoteTotals(quote) {
+  if (quote.fillable && quote.rate === null) {
+    throw new OrderbookRequestError("the orderbook served a fillable quote with no rate");
   }
-  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) };
-  }
-  matchPoolToken(tokenAddress, orderChain, poolTokens) {
-    const addressMatch = poolTokens.find(
-      (poolToken) => poolToken.address.toLowerCase() === tokenAddress.toLowerCase()
-    );
-    if (addressMatch) return addressMatch;
-    const metadata = this.chainConfigService.getAssetMetadataByAddress(orderChain, tokenAddress);
-    if (!metadata) return null;
-    return poolTokens.find((poolToken) => poolToken.symbol === metadata.symbol) ?? null;
-  }
-  async quoteExactInput(args) {
-    const amountIn = args.params.amountIn;
-    if (amountIn === void 0) throw new Error("amountIn is required for an exact-input quote");
-    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;
-    if (amountOut === void 0) throw new Error("amountOut is required for an exact-output quote");
-    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)
+    side: quote.side,
+    amountIn: quote.amountIn,
+    amountOut: quote.amountOut,
+    fillable: quote.fillable,
+    maxFillableIn: quote.maxFillableIn,
+    worstIn: quote.amountIn,
+    worstOut: quote.amountOut
   };
 }
-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 getZeroForOne(tokenIn, poolKey) {
-  return viem.getAddress(tokenIn).toLowerCase() === viem.getAddress(poolKey.currency0).toLowerCase();
-}
-
-// src/protocols/intents/quote/phantomSnapshot.ts
-var PHANTOM_INTENT_QUOTE_CHAIN = "EVM-8453" /* BASE_MAINNET */;
-var BASE_SNAPSHOT_ASSET_BY_ORDER_ASSET = {
-  USDC: "USDC",
-  USDT: "USDC",
-  cNGN: "cNGN"
-};
-var SUPPORTED_BASE_SNAPSHOT_PAIRS = /* @__PURE__ */ new Set(["USDC:cNGN", "cNGN:USDC"]);
-var PhantomSnapshotIntentQuoteStrategy = class {
-  constructor(chainConfigService, getQueryClient) {
-    this.chainConfigService = chainConfigService;
-    this.getQueryClient = getQueryClient;
-    this.pairResolver = new PhantomSnapshotPairResolver(chainConfigService);
-  }
-  chainConfigService;
-  getQueryClient;
-  pairResolver;
-  async quote(params, source, destination) {
-    validateQuoteParams(params);
-    const pair = this.pairResolver.resolve(params, source.stateMachineId, destination.stateMachineId);
-    if (!pair) {
-      throw new UnsupportedIntentQuotePairError({
-        source: source.stateMachineId,
-        destination: destination.stateMachineId,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        quoteSource: "Phantom snapshot pair"
-      });
-    }
-    const queryClient = this.getQueryClient();
-    const [protocolFeeBps, snapshot] = await Promise.all([
-      readProtocolFeeBps(this.chainConfigService, source),
-      _queryLatestPhantomOrderPriceSnapshot({
-        tokenA: pair.tokenA,
-        tokenB: pair.tokenB,
-        queryClient
-      })
-    ]);
-    if (!snapshot) throw new PhantomSnapshotUnavailableError(pair.tokenA, pair.tokenB);
-    this.validateSnapshot(snapshot);
-    return this.quoteSnapshot(params, protocolFeeBps, snapshot);
-  }
-  quoteSnapshot(params, protocolFeeBps, snapshot) {
-    if (params.amountIn !== void 0) {
-      const netAmountIn2 = deductProtocolFee(params.amountIn, protocolFeeBps);
-      const amountOut = netAmountIn2 * snapshot.medianPrice / snapshot.standardAmount;
-      if (amountOut <= 0n) {
-        throw new InvalidPhantomSnapshotError(snapshot.commitment, "quote rounds down to zero output");
-      }
-      return this.buildResult("EXACT_INPUT", params.amountIn, amountOut, protocolFeeBps, snapshot);
-    }
-    if (params.amountOut === void 0) throw new Error("Quote amount is missing after validation");
-    const netAmountIn = divCeil(params.amountOut * snapshot.standardAmount, snapshot.medianPrice);
-    const amountIn = grossUpForProtocolFee(netAmountIn, protocolFeeBps);
-    return this.buildResult("EXACT_OUTPUT", amountIn, params.amountOut, protocolFeeBps, snapshot);
-  }
-  buildResult(tradeType, amountIn, amountOut, protocolFeeBps, snapshot) {
-    return {
-      strategy: "phantom_snapshot",
-      tradeType,
-      amountIn,
-      amountOut,
-      quoteMetadata: {
-        quoteChain: PHANTOM_INTENT_QUOTE_CHAIN,
-        commitment: snapshot.commitment,
-        tokenA: snapshot.tokenA,
-        tokenB: snapshot.tokenB,
-        standardAmount: snapshot.standardAmount,
-        medianPrice: snapshot.medianPrice,
-        lowestPrice: snapshot.lowestPrice,
-        highestPrice: snapshot.highestPrice,
-        blockNumber: snapshot.blockNumber,
-        snapshotTime: snapshot.snapshotTime,
-        bidCount: snapshot.bidCount,
-        protocolFeeBps
-      }
-    };
-  }
-  validateSnapshot(snapshot) {
-    if (snapshot.standardAmount <= 0n) {
-      throw new InvalidPhantomSnapshotError(snapshot.commitment, "standardAmount must be greater than zero");
-    }
-    if (snapshot.medianPrice <= 0n) {
-      throw new InvalidPhantomSnapshotError(snapshot.commitment, "medianPrice must be greater than zero");
-    }
-    if (snapshot.bidCount <= 0) {
-      throw new InvalidPhantomSnapshotError(snapshot.commitment, "bidCount must be greater than zero");
-    }
-    if (Number.isNaN(snapshot.snapshotTime.getTime())) {
-      throw new InvalidPhantomSnapshotError(snapshot.commitment, "snapshotTime is invalid");
-    }
-  }
-};
-var PhantomSnapshotPairResolver = class {
-  constructor(chainConfigService) {
-    this.chainConfigService = chainConfigService;
-  }
-  chainConfigService;
-  resolve(params, sourceStateMachineId, destinationStateMachineId) {
-    const tokenIn = this.resolveBaseSnapshotToken(sourceStateMachineId, params.tokenIn);
-    const tokenOut = this.resolveBaseSnapshotToken(destinationStateMachineId, params.tokenOut);
-    if (!tokenIn || !tokenOut || !isSupportedSnapshotPair(tokenIn.symbol, tokenOut.symbol)) return;
-    return { tokenA: tokenIn.address, tokenB: tokenOut.address };
-  }
-  resolveBaseSnapshotToken(chain, tokenAddress) {
-    const orderAsset = this.chainConfigService.getAssetMetadataByAddress(chain, tokenAddress)?.symbol;
-    if (!orderAsset) return;
-    const snapshotAsset = BASE_SNAPSHOT_ASSET_BY_ORDER_ASSET[orderAsset];
-    if (!snapshotAsset) return;
-    const address = this.chainConfigService.getAssetAddress(PHANTOM_INTENT_QUOTE_CHAIN, snapshotAsset);
-    if (!isConfiguredAddress(address)) return;
-    return { symbol: snapshotAsset, address };
-  }
-};
-function isSupportedSnapshotPair(tokenA, tokenB) {
-  return SUPPORTED_BASE_SNAPSHOT_PAIRS.has(`${tokenA}:${tokenB}`);
+function toOrderbookAmount(amount, decimals) {
+  return amount * 10n ** BigInt(ORDERBOOK_DECIMALS - decimals);
 }
-function isConfiguredAddress(address) {
-  return Boolean(address && address !== "0x" && !/^0x0{40}$/i.test(address));
+function fromOrderbookAmount(amount, decimals) {
+  return amount / 10n ** BigInt(ORDERBOOK_DECIMALS - decimals);
 }
-var INDEXED_RATE_DECIMALS = 18;
-var INDEXED_RATE_SCALE = 10n ** BigInt(INDEXED_RATE_DECIMALS);
-var IndexedRateIntentQuoteStrategy = class {
-  constructor(chainConfigService, getQueryClient) {
-    this.chainConfigService = chainConfigService;
-    this.getQueryClient = getQueryClient;
-  }
-  chainConfigService;
-  getQueryClient;
-  async quote(params, source, destination) {
-    validateQuoteParams(params);
-    const sourceConfig = getConfigByStateMachineId(source.stateMachineId);
-    const destinationConfig = getConfigByStateMachineId(destination.stateMachineId);
-    if (!sourceConfig) throw new UnsupportedLiquidityChainError(source.stateMachineId);
-    if (!destinationConfig) throw new UnsupportedLiquidityChainError(destination.stateMachineId);
-    const tokenIn = this.resolveAsset(sourceConfig.stateMachineId, params.tokenIn);
-    const tokenOut = this.resolveAsset(destinationConfig.stateMachineId, params.tokenOut);
-    const [protocolFeeBps, rates] = await Promise.all([
-      readProtocolFeeBps(this.chainConfigService, source),
-      new LiquidityEngine(this.getQueryClient()).getBuyAndSellRates({
-        sourceChain: sourceConfig.stateMachineId,
-        destinationChain: destinationConfig.stateMachineId,
-        tokenInSymbol: tokenIn.symbol,
-        tokenOutSymbol: tokenOut.symbol
-      })
-    ]);
-    if (!rates) {
-      throw new IndexedRateUnavailableError({
-        source: sourceConfig.stateMachineId,
-        destination: destinationConfig.stateMachineId,
-        tokenIn: tokenIn.symbol,
-        tokenOut: tokenOut.symbol
-      });
-    }
-    const selectedRate = selectIndexedRate(rates, tokenIn.symbol, tokenOut.symbol);
-    return quoteWithIndexedRate(params, tokenIn, tokenOut, selectedRate, rates, protocolFeeBps);
-  }
-  resolveAsset(chain, address) {
-    const asset = this.chainConfigService.getAssetMetadataByAddress(chain, address);
-    if (!asset) throw new UnsupportedLiquidityAssetError(chain, address);
-    const { decimals } = asset;
-    if (decimals === void 0 || !Number.isSafeInteger(decimals) || decimals < 0) {
-      throw new InvalidIndexedRateError(`decimals are not configured for ${asset.symbol} on ${chain}`);
-    }
-    return { ...asset, decimals };
-  }
-};
-function selectIndexedRate(rates, tokenInSymbol, tokenOutSymbol) {
-  if (tokenInSymbol === rates.baseTokenSymbol && tokenOutSymbol === rates.quoteTokenSymbol) {
-    return readIndexedRate2(
-      "buy",
-      rates.buyRate,
-      rates.buyRateUpdatedAt,
-      rates,
-      tokenInSymbol,
-      tokenOutSymbol
-    );
-  }
-  if (tokenInSymbol === rates.quoteTokenSymbol && tokenOutSymbol === rates.baseTokenSymbol) {
-    return readIndexedRate2(
-      "sell",
-      rates.sellRate,
-      rates.sellRateUpdatedAt,
-      rates,
-      tokenInSymbol,
-      tokenOutSymbol
-    );
-  }
-  throw new InvalidIndexedRateError(
-    `indexed pair ${rates.baseTokenSymbol}/${rates.quoteTokenSymbol} does not match ${tokenInSymbol}/${tokenOutSymbol}`
-  );
+function roundUpTo(amount, unit) {
+  return divCeil(amount, unit) * unit;
 }
-function readIndexedRate2(side, rate, updatedAt, rates, tokenInSymbol, tokenOutSymbol) {
-  if (!rate || !updatedAt) {
-    throw new IndexedRateUnavailableError({
-      source: rates.sourceChain,
-      destination: rates.destinationChain,
-      tokenIn: tokenInSymbol,
-      tokenOut: tokenOutSymbol,
-      side
-    });
-  }
-  try {
-    const scaledRate = viem.parseUnits(rate, INDEXED_RATE_DECIMALS);
-    if (scaledRate <= 0n || Number.isNaN(updatedAt.getTime())) throw new Error();
-    return { side, rate, scaledRate, updatedAt };
-  } catch {
-    throw new InvalidIndexedRateError(`${side} rate or timestamp is invalid`);
-  }
+function divCeil(numerator, denominator) {
+  return (numerator + denominator - 1n) / denominator;
 }
-function quoteWithIndexedRate(params, tokenIn, tokenOut, selectedRate, rates, protocolFeeBps) {
-  const inputUnit = 10n ** BigInt(tokenIn.decimals);
-  const outputUnit = 10n ** BigInt(tokenOut.decimals);
-  if (params.amountIn !== void 0) {
-    const netAmountIn2 = deductProtocolFee(params.amountIn, protocolFeeBps);
-    const amountOut = selectedRate.side === "buy" ? netAmountIn2 * selectedRate.scaledRate * outputUnit / (inputUnit * INDEXED_RATE_SCALE) : netAmountIn2 * outputUnit * INDEXED_RATE_SCALE / (inputUnit * selectedRate.scaledRate);
-    if (amountOut <= 0n) throw new InvalidIndexedRateError("quote rounds down to zero output");
-    return buildResult("EXACT_INPUT", params.amountIn, amountOut, selectedRate, rates, protocolFeeBps);
-  }
-  if (params.amountOut === void 0) throw new Error("Quote amount is missing after validation");
-  const netAmountIn = selectedRate.side === "buy" ? divCeil(params.amountOut * inputUnit * INDEXED_RATE_SCALE, selectedRate.scaledRate * outputUnit) : divCeil(params.amountOut * inputUnit * selectedRate.scaledRate, outputUnit * INDEXED_RATE_SCALE);
-  const amountIn = grossUpForProtocolFee(netAmountIn, protocolFeeBps);
-  return buildResult("EXACT_OUTPUT", amountIn, params.amountOut, selectedRate, rates, protocolFeeBps);
+function format(amount) {
+  return viem.formatUnits(amount, ORDERBOOK_DECIMALS);
 }
-function buildResult(tradeType, amountIn, amountOut, selectedRate, rates, protocolFeeBps) {
-  return {
-    strategy: "indexed_rates",
-    tradeType,
-    amountIn,
-    amountOut,
-    quoteMetadata: {
-      sourceChain: rates.sourceChain,
-      destinationChain: rates.destinationChain,
-      baseTokenSymbol: rates.baseTokenSymbol,
-      quoteTokenSymbol: rates.quoteTokenSymbol,
-      rateSide: selectedRate.side,
-      rate: selectedRate.rate,
-      rateUpdatedAt: selectedRate.updatedAt,
-      protocolFeeBps
-    }
-  };
+function formatOptional(amount) {
+  return amount === null ? null : format(amount);
 }
 
 // src/protocols/intents/IntentGateway.ts
@@ -19833,8 +19259,10 @@ 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;
+  /** The HyperFX orderbook quotes, liquidity and rates are read from. */
+  orderbook;
+  /** Prices intents, liquidity and rates from {@link orderbook}. */
+  market;
   /**
    * Private constructor — use {@link IntentGateway.create} instead.
    *
@@ -19878,17 +19306,8 @@ var IntentGateway = class _IntentGateway {
     this.bidManager = bidManager;
     this.gasEstimator = gasEstimator;
     this._crypto = crypto;
-    this.quoteStrategies = {
-      indexed_rates: new IndexedRateIntentQuoteStrategy(
-        dest.configService,
-        () => this.requireIndexer().queryClient
-      ),
-      phantom_snapshot: new PhantomSnapshotIntentQuoteStrategy(
-        dest.configService,
-        () => this.requireIndexer().queryClient
-      ),
-      uniswap_v4: new UniswapV4IntentQuoteStrategy(dest.configService)
-    };
+    this.orderbook = new HyperFxOrderbook(orderbookUrlFor(dest.config.stateMachineId));
+    this.market = new OrderbookMarket(dest.configService, () => this.orderbook);
   }
   /**
    * Creates an initialized IntentGateway instance.
@@ -19934,89 +19353,50 @@ var IntentGateway = class _IntentGateway {
     }
   }
   /**
-   * Quotes an intent between this gateway's source and destination chains.
-   *
-   * Uses the indexer's latest aggregate directional pool rate by default. Pass
-   * `strategy: "phantom_snapshot"` or `strategy: "uniswap_v4"` only when
-   * explicitly requesting a legacy quote source. Provide exactly one of
-   * `amountIn` or `amountOut`.
-   *
-   * The gateway's source and destination chains resolve the configured order
-   * tokens; the indexer supplies the depth-weighted pool rate. Returned
-   * `amountIn`/`amountOut` already account for the gateway's protocol fee
-   * (`quoteMetadata.protocolFeeBps`), which the gateway deducts from order inputs.
+   * Points quotes, liquidity and rate reads at a HyperFX orderbook other than
+   * the destination chain's network deployment ({@link ORDERBOOK_URLS}).
+   * Returns `this` for chaining.
    *
-   * @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 the selected strategy does not support the pair.
-   * @throws {IndexedRateUnavailableError} When the requested direction has no indexed rate.
+   * @param orderbook - The orderbook's GraphQL URL, or a configured client.
    */
+  withOrderbook(orderbook) {
+    this.orderbook = typeof orderbook === "string" ? new HyperFxOrderbook(orderbook) : orderbook;
+    return this;
+  }
   async quoteIntent(params) {
-    const source = { stateMachineId: this.source.config.stateMachineId, client: this.source.client };
-    const destination = { stateMachineId: this.dest.config.stateMachineId, client: this.dest.client };
-    const strategy = params.strategy ?? "indexed_rates";
-    const handler = this.quoteStrategies[strategy];
-    if (!handler) throw new UnsupportedIntentQuoteStrategyError(strategy);
-    return handler.quote({ ...params, strategy }, source, destination);
+    return this.market.quoteIntent(params, this.source.config.stateMachineId, this.dest.config.stateMachineId);
   }
   /**
-   * Returns indexed destination liquidity and its source-routing slices.
+   * Returns the orderbook liquidity serving a swap of `tokenIn` on the source
+   * chain for `tokenOut` on the destination chain: the best rate, true and
+   * virtual depth, and the largest input the route can fill.
    *
-   * Destination, unrestricted, and explicit-route capacity come exclusively
-   * from the indexer's pair-centric liquidity entities. The SDK does not decide
-   * whether unrestricted bidders cover the source chain. Amounts reflect the
-   * latest rolling sample; they are not reservations or fill guarantees.
-   *
-   * Requires a prior call to {@link withQueryClient}.
+   * Amounts reflect the live book; they are not reservations or fill guarantees.
    */
   async queryAvailableLiquidity(params) {
-    const { queryClient } = this.requireIndexer();
-    const sourceStateMachineId = getConfigByStateMachineId(this.source.config.stateMachineId)?.stateMachineId;
-    const destinationStateMachineId = getConfigByStateMachineId(this.dest.config.stateMachineId)?.stateMachineId;
-    if (!sourceStateMachineId) throw new UnsupportedLiquidityChainError(this.source.config.stateMachineId);
-    if (!destinationStateMachineId) throw new UnsupportedLiquidityChainError(this.dest.config.stateMachineId);
-    const sourceToken = this.source.configService.getAssetMetadataByAddress(sourceStateMachineId, params.tokenIn);
-    const destinationToken = this.dest.configService.getAssetMetadataByAddress(
-      destinationStateMachineId,
-      params.tokenOut
+    return this.market.availableLiquidity(
+      params,
+      this.source.config.stateMachineId,
+      this.dest.config.stateMachineId
     );
-    if (!sourceToken) throw new UnsupportedLiquidityAssetError(sourceStateMachineId, params.tokenIn);
-    if (!destinationToken) throw new UnsupportedLiquidityAssetError(destinationStateMachineId, params.tokenOut);
-    return new LiquidityEngine(queryClient).getAvailableLiquidity({
-      source: {
-        chain: sourceStateMachineId,
-        ...sourceToken
-      },
-      destination: {
-        chain: destinationStateMachineId,
-        ...destinationToken
-      }
-    });
   }
   /**
-   * Returns aggregate indexed pool buy and sell rates in less-valued quote-token
-   * units without requiring token addresses. Symbols are matched
-   * case-insensitively; chain IDs resolve configured token deployments.
+   * Returns the orderbook's best bid and ask for a pair, with the mid and
+   * spread, in quote-token units per one base token. Only orders filled on the
+   * destination chain that accept swaps from the source chain are counted.
+   * Symbols are matched case-insensitively; chain IDs resolve configured token
+   * deployments.
    */
   async queryBuyAndSellRates(params) {
-    const { queryClient } = this.requireIndexer();
     const sourceChain = chainConfigs[params.sourceChainId]?.stateMachineId;
     const destinationChain = chainConfigs[params.destinationChainId]?.stateMachineId;
     if (!sourceChain) throw new UnsupportedLiquidityChainError(params.sourceChainId);
     if (!destinationChain) throw new UnsupportedLiquidityChainError(params.destinationChainId);
-    const sourceToken = this.source.configService.getAssetMetadataBySymbol(sourceChain, params.tokenInSymbol);
-    const destinationToken = this.dest.configService.getAssetMetadataBySymbol(
-      destinationChain,
-      params.tokenOutSymbol
-    );
-    if (!sourceToken) throw new UnsupportedLiquidityAssetError(sourceChain, params.tokenInSymbol);
-    if (!destinationToken) throw new UnsupportedLiquidityAssetError(destinationChain, params.tokenOutSymbol);
-    return new LiquidityEngine(queryClient).getBuyAndSellRates({
+    return this.market.buyAndSellRates({
       sourceChain,
       destinationChain,
-      tokenInSymbol: sourceToken.symbol,
-      tokenOutSymbol: destinationToken.symbol
+      tokenInSymbol: params.tokenInSymbol,
+      tokenOutSymbol: params.tokenOutSymbol
     });
   }
   /**
@@ -20267,6 +19647,8 @@ var IntentGateway = class _IntentGateway {
   /**
    * Returns both the native token cost and the relayer fee for cancelling an
    * order. Use `relayerFee` to approve the ERC-20 spend before submitting.
+   * Same-chain orders use the direct local route for either `from` option and
+   * return `{ nativeValue: 0n, relayerFee: 0n }`.
    *
    * Delegates to {@link OrderCanceller.quoteCancelOrder}.
    *
@@ -20290,9 +19672,17 @@ var IntentGateway = class _IntentGateway {
    *
    * Delegates to {@link OrderCanceller.cancelOrder}.
    *
+   * Same-chain orders always use the direct source-gateway route. The order
+   * user may call through the deadline; any account may call strictly after
+   * it, pays the transaction gas, and cannot change the refund beneficiary.
+   * The SDK yields unsigned transaction fields and accepts either the caller's
+   * signed raw transaction or its already-broadcast transaction hash.
+   *
    * @param order - The order to cancel.
-   * @param indexerClient - Indexer client used for ISMP request status streaming.
-   * @param options - Choose the initiation side. Defaults to source-side cancellation.
+   * @param indexerClient - Indexer client used for cross-chain ISMP request
+   *   status streaming; the same-chain route does not access it.
+   * @param options - Choose the cross-chain initiation side. Defaults to source;
+   *   ignored for routing when source and destination are the same chain.
    * @yields {@link CancelEvent} objects describing each cancellation stage.
    */
   async *cancelOrder(order, indexerClient, options = {}) {
@@ -20422,7 +19812,7 @@ var IntentGateway = class _IntentGateway {
     if (estimate.totalGasCostWei === 0n || estimate.totalGasInFeeToken === 0n) {
       throw new Error("Gas estimation failed");
     }
-    const fees = isSameChain ? estimate.totalGasInFeeToken * 2n : (estimate.totalGasInFeeToken + estimate.relayerFeeInSourceFeeToken) * 105n / 100n;
+    const fees = isSameChain ? estimate.totalGasInFeeToken * 2n : ((estimate.totalGasInFeeToken + estimate.relayerFeeInSourceFeeToken) * 105n + 99n) / 100n;
     const { address: feeToken } = await this.source.getFeeTokenWithDecimals();
     return {
       fees,
@@ -20455,17 +19845,27 @@ var IntentGateway = class _IntentGateway {
     return this._crypto.decodeERC7821Execute(callData);
   }
   /**
-   * Checks whether an order has been filled on the destination chain.
+   * Checks whether an order is finalized on the destination chain.
    *
    * Delegates to {@link OrderStatusChecker.isOrderFilled}.
    *
    * @param order - The order to check.
-   * @returns `true` if the order's commitment slot on the destination chain is
-   *   non-zero (i.e. `fillOrder` has been called successfully).
+   * @returns `true` once a completing fill or a destination-side cancellation
+   *   has finalized the order; `false` while it is open or only partly filled.
    */
   async isOrderFilled(order) {
     return this.orderStatusChecker.isOrderFilled(order);
   }
+  /**
+   * Output credited to the order so far, one entry per leg.
+   *
+   * Delegates to {@link OrderStatusChecker.getFillProgress}.
+   *
+   * @param order - The order to check.
+   */
+  async getFillProgress(order) {
+    return this.orderStatusChecker.getFillProgress(order);
+  }
   /**
    * Checks whether all escrowed inputs for an order have been refunded on the
    * source chain.
@@ -20473,8 +19873,8 @@ var IntentGateway = class _IntentGateway {
    * Delegates to {@link OrderStatusChecker.isOrderRefunded}.
    *
    * @param order - The order to check.
-   * @returns `true` if every input token's escrowed amount has been zeroed out
-   *   in the `_orders` mapping on the source chain.
+   * @returns `true` if every input's escrowed amount has been zeroed out
+   *   in the per-leg `_orders` mapping on the source chain.
    */
   async isOrderRefunded(order) {
     return this.orderStatusChecker.isOrderRefunded(order);
@@ -20511,9 +19911,7 @@ var IntentGateway = class _IntentGateway {
   }
   requireIndexer() {
     if (!this.indexer) {
-      throw new Error(
-        "IntentGateway: call withQueryClient(queryClient) before using indexer-backed methods or Phantom quotes"
-      );
+      throw new Error("IntentGateway: call withQueryClient(queryClient) before using indexer-backed methods");
     }
     return this.indexer;
   }
@@ -20536,74 +19934,64 @@ var IntentGateway = class _IntentGateway {
     const { queryClient, pollInterval, logger } = this.requireIndexer();
     const streamLogger = logger.withTag("[orderStatusStream]");
     const TERMINAL = ["FILLED", "REDEEMED", "REFUNDED"];
+    const latestOrderStatus = (order2) => {
+      const latest = order2.statuses[order2.statuses.length - 1];
+      if (latest.status === "CANCELLED") {
+        for (let i = order2.statuses.length - 1; i >= 0; i--) {
+          if (TERMINAL.includes(order2.statuses[i].status)) return order2.statuses[i];
+        }
+      }
+      return latest;
+    };
     let order;
     while (!order) {
       await sleep(pollInterval);
       order = await _queryOrderInternal({ commitmentHash: commitment, queryClient, logger });
     }
     streamLogger.trace("`Order` found");
-    const latestStatus = order.statuses[order.statuses.length - 1];
+    let latestStatus = latestOrderStatus(order);
     yield { status: latestStatus.status, metadata: latestStatus.metadata };
     if (TERMINAL.includes(latestStatus.status)) return;
     while (true) {
       await sleep(pollInterval);
       const updatedOrder = await _queryOrderInternal({ commitmentHash: commitment, queryClient, logger });
       if (!updatedOrder) continue;
-      const newLatestStatus = updatedOrder.statuses[updatedOrder.statuses.length - 1];
+      const newLatestStatus = latestOrderStatus(updatedOrder);
       if (newLatestStatus.status !== latestStatus.status) {
+        latestStatus = newLatestStatus;
         yield { status: newLatestStatus.status, metadata: newLatestStatus.metadata };
         if (TERMINAL.includes(newLatestStatus.status)) return;
       }
     }
   }
 };
-function rpcFetch() {
-  const f = globalThis.fetch;
-  if (typeof f !== "function") {
-    throw new Error("No fetch available; call setAggregationFetch() before using the aggregation helpers");
-  }
-  return f;
+
+// src/protocols/intents/liquidity-pool.ts
+function sortPoolSymbols(symbolA, symbolB) {
+  return symbolA.toLowerCase() <= symbolB.toLowerCase() ? [symbolA, symbolB] : [symbolB, symbolA];
 }
-var PhantomRpcError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "PhantomRpcError";
-  }
-  cause;
-};
-async function rpcCall(url, payload) {
-  let lastErr;
-  for (let attempt = 0; attempt < 4; attempt++) {
-    if (attempt > 0) await new Promise((resolve) => setTimeout(resolve, 150 * attempt));
-    let timer;
-    try {
-      const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`rpc timeout: ${url}`)), 12e3);
-      });
-      const response = await Promise.race([
-        rpcFetch()(url, {
-          method: "POST",
-          headers: { accept: "application/json", "content-type": "application/json" },
-          body: JSON.stringify(payload)
-        }),
-        timeout
-      ]);
-      const body = await response.json();
-      if (body?.error) {
-        lastErr = new Error(`rpc error: ${JSON.stringify(body.error).slice(0, 200)}`);
-        continue;
-      }
-      return body;
-    } catch (err) {
-      lastErr = err;
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-  throw new PhantomRpcError(`RPC call failed after 4 attempts: ${url}`, lastErr);
+function poolSlug(symbolA, symbolB) {
+  return sortPoolSymbols(symbolA, symbolB).join("-");
+}
+
+// src/protocols/intents/rateFill.ts
+function ceilDiv(numerator, denominator) {
+  return numerator === 0n ? 0n : (numerator - 1n) / denominator + 1n;
+}
+function previewRateFill(escrow, required, filled, take, offered) {
+  if (escrow <= 0n || required <= 0n || take <= 0n || offered <= 0n) {
+    throw new Error("RateFillInvalidAmount");
+  }
+  if (filled < 0n || filled >= required) throw new Error("RateFillNoProgress");
+  if (ceilDiv(take * required, escrow) > offered) throw new Error("RateBelowOrder");
+  const uncappedCredit = take * required / escrow;
+  const credit = uncappedCredit < required - filled ? uncappedCredit : required - filled;
+  const release = escrow * (filled + credit) / required - escrow * filled / required;
+  if (credit === 0n || release === 0n) throw new Error("RateFillNoProgress");
+  const ratePayment = ceilDiv(offered * release, take);
+  const delivered = ratePayment > credit ? ratePayment : credit;
+  return { credit, release, delivered, surplus: delivered - credit };
 }
-var FILL_ORDER_ABI = IntentGatewayV2_default.ABI;
 var DECLARATION_V1 = 1;
 var DECLARATION_V2 = 2;
 var PAYMASTER_ADDRESS_BYTES = 20;
@@ -20801,40 +20189,6 @@ function encodeAcceptedSourceChains(chains2) {
 function decodeAcceptedSourceChains(paymasterAndData) {
   return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
 }
-var UNISWAP_QUOTE_HAIRCUT_BPS = 10n;
-function haircut(amount, bps) {
-  return amount * (10000n - bps) / 10000n;
-}
-function applyUniswapQuoteHaircut(amount) {
-  return haircut(amount, UNISWAP_QUOTE_HAIRCUT_BPS);
-}
-var SELECTOR_GATEWAY_PARAMS = "0xcff0ab96";
-var GATEWAY_PARAMS_WORDS = 6;
-var GATEWAY_PARAMS_FEE_WORD = 4;
-async function readProtocolFeeHaircutBps(evmRpcUrl, gatewayAddress) {
-  const result = await rpcCall(evmRpcUrl, {
-    id: 1,
-    jsonrpc: "2.0",
-    method: "eth_call",
-    params: [{ to: gatewayAddress, data: SELECTOR_GATEWAY_PARAMS }, "latest"]
-  });
-  const hex = result.result;
-  if (typeof hex !== "string" || hex.length < 2 + 64 * GATEWAY_PARAMS_WORDS) {
-    throw new PhantomRpcError(`IntentGateway.params() returned no usable result from ${gatewayAddress} on ${evmRpcUrl}`);
-  }
-  const start = 2 + 64 * GATEWAY_PARAMS_FEE_WORD;
-  const protocolFeeBps = BigInt(`0x${hex.slice(start, start + 64)}`);
-  if (protocolFeeBps >= 10000n) {
-    throw new PhantomRpcError(`IntentGateway ${gatewayAddress} reports an implausible protocol fee: ${protocolFeeBps} bps`);
-  }
-  return protocolFeeBps;
-}
-function applyProtocolFeeHaircut(amount, protocolFeeBps) {
-  return haircut(amount, protocolFeeBps);
-}
-FILL_ORDER_ABI.find(
-  (item) => item?.type === "function" && item?.name === "fillOrder"
-)?.inputs?.[0];
 var TokenGateway = class {
   source;
   dest;
@@ -25050,9 +24404,9 @@ async function teleport(teleport_param) {
   if (scaleEncodedAssetId === null) {
     throw new Error("Unknown asset id provided");
   }
-  const destinationStateMachine = normalizeStateMachineId(params.destination);
-  const destination = convertStateMachineIdToEnum(destinationStateMachine);
-  const recipient = viem.hexToBytes(normalizeAddressForStateMachine(params.recipient, destinationStateMachine));
+  const destinationStateMachine2 = normalizeStateMachineId(params.destination);
+  const destination = convertStateMachineIdToEnum(destinationStateMachine2);
+  const recipient = viem.hexToBytes(normalizeAddressForStateMachine(params.recipient, destinationStateMachine2));
   const teleportParams = {
     destination,
     recepient: Array.from(recipient),
@@ -25307,7 +24661,7 @@ async function teleportDot(param_) {
 
 exports.ADDRESS_ZERO = ADDRESS_ZERO2;
 exports.BundlerMethod = BundlerMethod;
-exports.CHAINS_WITHOUT_VALID_UNTIL = CHAINS_WITHOUT_VALID_UNTIL;
+exports.CONTRACT_VERSION_ABI = CONTRACT_VERSION_ABI;
 exports.ChainConfigService = ChainConfigService;
 exports.Chains = Chains;
 exports.CryptoUtils = CryptoUtils;
@@ -25320,29 +24674,31 @@ exports.ERC7821_BATCH_MODE = ERC7821_BATCH_MODE;
 exports.EvmChain = EvmChain;
 exports.EvmHostABI = ABI;
 exports.EvmLanguage = EvmLanguage;
-exports.FILL_ORDER_V1_ABI = FILL_ORDER_V1_ABI;
+exports.FILL_ORDER_SELECTOR = FILL_ORDER_SELECTOR;
 exports.HyperClientStatus = HyperClientStatus;
 exports.HyperFungibleToken = HyperFungibleToken;
 exports.HyperFungibleTokenABI = HyperFungibleTokenABI;
+exports.HyperFxOrderbook = HyperFxOrderbook;
 exports.INCLUSION_TIMEOUT_MS = INCLUSION_TIMEOUT_MS;
-exports.IndexedRateUnavailableError = IndexedRateUnavailableError;
+exports.InsufficientOrderbookLiquidityError = InsufficientOrderbookLiquidityError;
 exports.IntentGateway = IntentGateway;
 exports.IntentGatewayABI = ABI3;
 exports.IntentOrderStatus = IntentOrderStatus;
 exports.IntentsCoprocessor = IntentsCoprocessor;
-exports.InvalidIndexedRateError = InvalidIndexedRateError;
-exports.InvalidLiquidityIndexerResponseError = InvalidLiquidityIndexerResponseError;
-exports.InvalidPhantomSnapshotError = InvalidPhantomSnapshotError;
 exports.IsmpClient = IsmpClient;
-exports.LEGACY_FILL_OPTIONS_IMPLEMENTATIONS = LEGACY_FILL_OPTIONS_IMPLEMENTATIONS;
+exports.MAX_DECLARED_ENTRIES = MAX_DECLARED_ENTRIES;
 exports.MOCK_ADDRESS = MOCK_ADDRESS;
+exports.ORDERBOOK_DECIMALS = ORDERBOOK_DECIMALS;
+exports.ORDERBOOK_QUERIES = ORDERBOOK_QUERIES;
+exports.ORDERBOOK_URLS = ORDERBOOK_URLS;
 exports.ORDER_V2_PARAM_TYPE = ORDER_V2_PARAM_TYPE;
 exports.OrderStatus = OrderStatus;
 exports.OrderStatusChecker = OrderStatusChecker;
+exports.OrderbookQuoteNotConvergedError = OrderbookQuoteNotConvergedError;
+exports.OrderbookRequestError = OrderbookRequestError;
 exports.PACKED_USEROP_TYPEHASH = PACKED_USEROP_TYPEHASH;
 exports.PERMIT2_SPONSORSHIP_BYTES = PERMIT2_SPONSORSHIP_BYTES;
 exports.PLACE_ORDER_SELECTOR = PLACE_ORDER_SELECTOR;
-exports.PhantomSnapshotUnavailableError = PhantomSnapshotUnavailableError;
 exports.PharosChain = PharosChain;
 exports.PolkadotHubChain = PolkadotHubChain;
 exports.REQUEST_COMMITMENTS_SLOT = REQUEST_COMMITMENTS_SLOT;
@@ -25353,6 +24709,7 @@ exports.RequestKind = RequestKind;
 exports.RequestStatus = RequestStatus;
 exports.SELECT_SOLVER_TYPEHASH = SELECT_SOLVER_TYPEHASH;
 exports.STATE_COMMITMENTS_SLOT = STATE_COMMITMENTS_SLOT;
+exports.SUPPORTED_INTENTS_VERSION = SUPPORTED_INTENTS_VERSION;
 exports.SubstrateChain = SubstrateChain;
 exports.Swap = Swap;
 exports.TESTNET_CHAINS = TESTNET_CHAINS;
@@ -25360,17 +24717,13 @@ exports.TeleportStatus = TeleportStatus;
 exports.TimeoutStatus = TimeoutStatus;
 exports.TokenGateway = TokenGateway;
 exports.TronChain = TronChain;
-exports.UNISWAP_QUOTE_HAIRCUT_BPS = UNISWAP_QUOTE_HAIRCUT_BPS;
 exports.USE_ETHERSCAN_CHAINS = USE_ETHERSCAN_CHAINS;
-exports.UnsupportedIntentQuotePairError = UnsupportedIntentQuotePairError;
-exports.UnsupportedIntentQuoteStrategyError = UnsupportedIntentQuoteStrategyError;
 exports.UnsupportedLiquidityAssetError = UnsupportedLiquidityAssetError;
 exports.UnsupportedLiquidityChainError = UnsupportedLiquidityChainError;
 exports.WrappedHyperFungibleTokenABI = WrappedHyperFungibleTokenABI;
 exports.__test = __test;
 exports.adjustDecimals = adjustDecimals;
-exports.applyProtocolFeeHaircut = applyProtocolFeeHaircut;
-exports.applyUniswapQuoteHaircut = applyUniswapQuoteHaircut;
+exports.assertGatewayRelease = assertGatewayRelease;
 exports.bytes20ToBytes32 = bytes20ToBytes32;
 exports.bytes32ToBytes20 = bytes32ToBytes20;
 exports.calculateAllowanceMappingLocation = calculateAllowanceMappingLocation;
@@ -25411,7 +24764,6 @@ exports.getChainId = getChainId;
 exports.getConfigByStateMachineId = getConfigByStateMachineId;
 exports.getContractCallInput = getContractCallInput;
 exports.getContractCallInputs = getContractCallInputs;
-exports.getFillOptionsVersion = getFillOptionsVersion;
 exports.getGasPriceFromEtherscan = getGasPriceFromEtherscan;
 exports.getOrFetchStorageSlot = getOrFetchStorageSlot;
 exports.getOrderPlacedFromTx = getOrderPlacedFromTx;
@@ -25424,6 +24776,7 @@ exports.getStorageSlot = getStorageSlot;
 exports.getViemChain = getViemChain;
 exports.hexToString = hexToString;
 exports.hyperbridgeAddress = hyperbridgeAddress;
+exports.isCanonicalEvmToken = isCanonicalEvmToken;
 exports.maxBigInt = maxBigInt;
 exports.normalizeAddressForEvmBytes32 = normalizeAddressForEvmBytes32;
 exports.normalizeAddressForStateMachine = normalizeAddressForStateMachine;
@@ -25431,6 +24784,7 @@ exports.normalizeEvmAddress = normalizeEvmAddress;
 exports.normalizeEvmChainId = normalizeEvmChainId;
 exports.normalizeStateMachineId = normalizeStateMachineId;
 exports.orderCommitment = orderCommitment;
+exports.orderbookUrlFor = orderbookUrlFor;
 exports.parseStateMachineId = parseStateMachineId;
 exports.pharosAtlantic = pharosAtlantic;
 exports.pharosMainnet = pharosMainnet;
@@ -25438,16 +24792,18 @@ exports.polkadotAssetHubPaseo = polkadotAssetHubPaseo;
 exports.polkadotHubMainnet = polkadotHubMainnet;
 exports.poolSlug = poolSlug;
 exports.postRequestCommitment = postRequestCommitment;
+exports.previewRateFill = previewRateFill;
 exports.queryAssetTeleported = queryAssetTeleported;
 exports.queryGetRequest = queryGetRequest;
 exports.queryPostRequest = queryPostRequest;
 exports.quoteUniswap = quoteUniswap;
-exports.readProtocolFeeHaircutBps = readProtocolFeeHaircutBps;
+exports.readLegEscrow = readLegEscrow;
+exports.readLegPartialFill = readLegPartialFill;
 exports.requestCommitmentKey = requestCommitmentKey;
-exports.resetFillOptionsVersionCache = resetFillOptionsVersionCache;
 exports.responseCommitmentKey = responseCommitmentKey;
 exports.retryPromise = retryPromise;
 exports.sortPoolSymbols = sortPoolSymbols;
+exports.supportsRateFills = supportsRateFills;
 exports.teleport = teleport;
 exports.teleportDot = teleportDot;
 exports.transformOrderForContract = transformOrderForContract;