@hyperbridge/sdk 2.8.12 → 2.8.16

package/dist/node/intents-helpers.cjs

@@ -3,10 +3,9 @@
 var viem = require('viem');
 require('@polkadot/api');
 var util = require('@polkadot/util');
-var utilCrypto = require('@polkadot/util-crypto');
+require('@polkadot/util-crypto');
 var scaleTs = require('scale-ts');
 require('p-queue');
-var accounts = require('viem/accounts');
 
 // src/protocols/intents/decode-utils.ts
 
@@ -67,13 +66,70 @@ function decodeERC7821ExecuteBatch(callData) {
   }
 }
 
+// src/chains/intentsCoprocessor.ts
+new TextEncoder().encode("intents::bid::");
+scaleTs.Struct({ filler: scaleTs.Bytes(32), user_op: scaleTs.Vector(scaleTs.u8) });
+var PackedUserOperationCodec = scaleTs.Struct({
+  sender: scaleTs.Bytes(20),
+  // address is 20 bytes
+  nonce: scaleTs.Bytes(32),
+  // uint256 as 32 bytes
+  initCode: scaleTs.Vector(scaleTs.u8),
+  // variable length bytes
+  callData: scaleTs.Vector(scaleTs.u8),
+  // variable length bytes
+  accountGasLimits: scaleTs.Bytes(32),
+  // bytes32
+  preVerificationGas: scaleTs.Bytes(32),
+  // uint256 as 32 bytes
+  gasFees: scaleTs.Bytes(32),
+  // bytes32
+  paymasterAndData: scaleTs.Vector(scaleTs.u8),
+  // variable length bytes
+  signature: scaleTs.Vector(scaleTs.u8)
+  // variable length bytes
+});
+function encodeUserOpScale(userOp) {
+  const encoded = PackedUserOperationCodec.enc({
+    sender: util.hexToU8a(userOp.sender),
+    nonce: viem.numberToBytes(userOp.nonce, { size: 32 }),
+    initCode: Array.from(util.hexToU8a(userOp.initCode)),
+    callData: Array.from(util.hexToU8a(userOp.callData)),
+    accountGasLimits: util.hexToU8a(userOp.accountGasLimits),
+    preVerificationGas: viem.numberToBytes(userOp.preVerificationGas, { size: 32 }),
+    gasFees: util.hexToU8a(userOp.gasFees),
+    paymasterAndData: Array.from(util.hexToU8a(userOp.paymasterAndData)),
+    signature: Array.from(util.hexToU8a(userOp.signature))
+  });
+  return util.u8aToHex(encoded);
+}
+function decodeUserOpScale(hex) {
+  const decoded = PackedUserOperationCodec.dec(util.hexToU8a(hex));
+  return {
+    sender: util.u8aToHex(new Uint8Array(decoded.sender)),
+    nonce: viem.bytesToBigInt(new Uint8Array(decoded.nonce)),
+    initCode: util.u8aToHex(new Uint8Array(decoded.initCode)),
+    callData: util.u8aToHex(new Uint8Array(decoded.callData)),
+    accountGasLimits: util.u8aToHex(new Uint8Array(decoded.accountGasLimits)),
+    preVerificationGas: viem.bytesToBigInt(new Uint8Array(decoded.preVerificationGas)),
+    gasFees: util.u8aToHex(new Uint8Array(decoded.gasFees)),
+    paymasterAndData: util.u8aToHex(new Uint8Array(decoded.paymasterAndData)),
+    signature: util.u8aToHex(new Uint8Array(decoded.signature))
+  };
+}
+
 // src/abis/IntentGatewayV2.ts
 var ABI2 = [
   {
     type: "constructor",
     inputs: [
       {
-        name: "owner",
+        name: "intrinsic",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "extrinsic",
         type: "address",
         internalType: "address"
       }
@@ -172,8 +228,8 @@ var ABI2 = [
       },
       {
         name: "",
-        type: "address",
-        internalType: "address"
+        type: "uint256",
+        internalType: "uint256"
       }
     ],
     outputs: [
@@ -187,20 +243,31 @@ var ABI2 = [
   },
   {
     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: "",
@@ -209,19 +276,31 @@ var ABI2 = [
       },
       {
         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",
@@ -431,6 +510,19 @@ var ABI2 = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "extrinsicModule",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "fillOrder",
@@ -593,6 +685,23 @@ var ABI2 = [
                 internalType: "uint256"
               }
             ]
+          },
+          {
+            name: "inputs",
+            type: "tuple[]",
+            internalType: "struct TokenInfo[]",
+            components: [
+              {
+                name: "token",
+                type: "bytes32",
+                internalType: "bytes32"
+              },
+              {
+                name: "amount",
+                type: "uint256",
+                internalType: "uint256"
+              }
+            ]
           }
         ]
       }
@@ -618,51 +727,63 @@ var ABI2 = [
     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: [],
@@ -687,12 +808,25 @@ var ABI2 = [
     ],
     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"
       }
@@ -767,7 +901,7 @@ var ABI2 = [
     name: "onGetResponse",
     inputs: [
       {
-        name: "incoming",
+        name: "",
         type: "tuple",
         internalType: "struct IncomingGetResponse",
         components: [
@@ -982,6 +1116,19 @@ var ABI2 = [
     outputs: [],
     stateMutability: "nonpayable"
   },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "params",
@@ -1027,6 +1174,39 @@ var ABI2 = [
     ],
     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",
@@ -1282,6 +1462,13 @@ var ABI2 = [
     ],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
   {
     type: "function",
     name: "select",
@@ -1320,10 +1507,10 @@ var ABI2 = [
   },
   {
     type: "function",
-    name: "setRelayer",
+    name: "transferOwnership",
     inputs: [
       {
-        name: "relayer",
+        name: "newOwner",
         type: "address",
         internalType: "address"
       }
@@ -1333,19 +1520,8 @@ var ABI2 = [
   },
   {
     type: "function",
-    name: "upgradeToAndCall",
-    inputs: [
-      {
-        name: "newImplementation",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "data",
-        type: "bytes",
-        internalType: "bytes"
-      }
-    ],
+    name: "unpause",
+    inputs: [],
     outputs: [],
     stateMutability: "nonpayable"
   },
@@ -1491,6 +1667,12 @@ var ABI2 = [
         indexed: true,
         internalType: "bytes32"
       },
+      {
+        name: "solver",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
       {
         name: "tokens",
         type: "tuple[]",
@@ -1728,12 +1910,50 @@ var ABI2 = [
   },
   {
     type: "event",
-    name: "ParamsUpdated",
+    name: "OwnershipTransferStarted",
     inputs: [
       {
-        name: "previous",
-        type: "tuple",
-        indexed: false,
+        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: [
           {
@@ -1866,46 +2086,73 @@ var ABI2 = [
   },
   {
     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",
@@ -1941,28 +2188,17 @@ var ABI2 = [
   },
   {
     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: []
   },
   {
@@ -2005,11 +2241,43 @@ var ABI2 = [
     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",
@@ -2070,60 +2338,6 @@ var ABI2 = [
 ];
 var IntentGatewayV2_default = { ABI: ABI2 };
 
-// src/chains/intentsCoprocessor.ts
-util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a("System", 128), utilCrypto.xxhashAsU8a("Events", 128)));
-new TextEncoder().encode("intents::bid::");
-new TextEncoder().encode("intents::phantom::order::");
-scaleTs.Struct({ filler: scaleTs.Bytes(32), user_op: scaleTs.Vector(scaleTs.u8) });
-var PackedUserOperationCodec = scaleTs.Struct({
-  sender: scaleTs.Bytes(20),
-  // address is 20 bytes
-  nonce: scaleTs.Bytes(32),
-  // uint256 as 32 bytes
-  initCode: scaleTs.Vector(scaleTs.u8),
-  // variable length bytes
-  callData: scaleTs.Vector(scaleTs.u8),
-  // variable length bytes
-  accountGasLimits: scaleTs.Bytes(32),
-  // bytes32
-  preVerificationGas: scaleTs.Bytes(32),
-  // uint256 as 32 bytes
-  gasFees: scaleTs.Bytes(32),
-  // bytes32
-  paymasterAndData: scaleTs.Vector(scaleTs.u8),
-  // variable length bytes
-  signature: scaleTs.Vector(scaleTs.u8)
-  // variable length bytes
-});
-function encodeUserOpScale(userOp) {
-  const encoded = PackedUserOperationCodec.enc({
-    sender: util.hexToU8a(userOp.sender),
-    nonce: viem.numberToBytes(userOp.nonce, { size: 32 }),
-    initCode: Array.from(util.hexToU8a(userOp.initCode)),
-    callData: Array.from(util.hexToU8a(userOp.callData)),
-    accountGasLimits: util.hexToU8a(userOp.accountGasLimits),
-    preVerificationGas: viem.numberToBytes(userOp.preVerificationGas, { size: 32 }),
-    gasFees: util.hexToU8a(userOp.gasFees),
-    paymasterAndData: Array.from(util.hexToU8a(userOp.paymasterAndData)),
-    signature: Array.from(util.hexToU8a(userOp.signature))
-  });
-  return util.u8aToHex(encoded);
-}
-function decodeUserOpScale(hex) {
-  const decoded = PackedUserOperationCodec.dec(util.hexToU8a(hex));
-  return {
-    sender: util.u8aToHex(new Uint8Array(decoded.sender)),
-    nonce: viem.bytesToBigInt(new Uint8Array(decoded.nonce)),
-    initCode: util.u8aToHex(new Uint8Array(decoded.initCode)),
-    callData: util.u8aToHex(new Uint8Array(decoded.callData)),
-    accountGasLimits: util.u8aToHex(new Uint8Array(decoded.accountGasLimits)),
-    preVerificationGas: viem.bytesToBigInt(new Uint8Array(decoded.preVerificationGas)),
-    gasFees: util.u8aToHex(new Uint8Array(decoded.gasFees)),
-    paymasterAndData: util.u8aToHex(new Uint8Array(decoded.paymasterAndData)),
-    signature: util.u8aToHex(new Uint8Array(decoded.signature))
-  };
-}
-
 // src/protocols/intents/liquidity-pool.ts
 function sortPoolSymbols(symbolA, symbolB) {
   return symbolA.toLowerCase() <= symbolB.toLowerCase() ? [symbolA, symbolB] : [symbolB, symbolA];
@@ -2131,553 +2345,6 @@ function sortPoolSymbols(symbolA, symbolB) {
 function poolSlug(symbolA, symbolB) {
   return sortPoolSymbols(symbolA, symbolB).join("-");
 }
-var FILL_ORDER_V1_ABI = [
-  {
-    type: "function",
-    name: "fillOrder",
-    stateMutability: "payable",
-    outputs: [],
-    inputs: [
-      ABI2.find((e) => e.type === "function" && e.name === "fillOrder").inputs[0],
-      {
-        name: "options",
-        type: "tuple",
-        internalType: "struct FillOptions",
-        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" }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-];
-function decodeFillOrder(data) {
-  try {
-    const decoded = viem.decodeFunctionData({ abi: ABI2, data });
-    if (decoded.functionName === "fillOrder" && decoded.args && decoded.args.length >= 2) {
-      return { order: decoded.args[0], options: decoded.args[1] };
-    }
-  } catch {
-  }
-  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 {
-  }
-  return null;
-}
-var SELECT_SOLVER_TYPEHASH = viem.keccak256(viem.toHex("SelectSolver(bytes32 commitment,address solver)"));
-var PACKED_USEROP_TYPEHASH = viem.keccak256(
-  viem.toHex(
-    "PackedUserOperation(address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData)"
-  )
-);
-var DOMAIN_TYPEHASH = viem.keccak256(
-  viem.toHex("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
-);
-var CryptoUtils = class _CryptoUtils {
-  /**
-   * @param ctx - Shared IntentsV2 context; used to access the bundler URL for
-   *   JSON-RPC calls.
-   */
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  ctx;
-  /**
-   * Computes an EIP-712 domain separator for a given contract.
-   *
-   * @param contractName - Human-readable name of the contract (e.g. `"IntentGateway"`).
-   * @param version - Version string (e.g. `"2"`).
-   * @param chainId - Chain ID of the network the contract is deployed on.
-   * @param contractAddress - Address of the verifying contract.
-   * @returns The 32-byte domain separator as a hex string.
-   */
-  static getDomainSeparator(contractName, version, chainId, contractAddress) {
-    return viem.keccak256(
-      viem.encodeAbiParameters(viem.parseAbiParameters("bytes32, bytes32, bytes32, uint256, address"), [
-        DOMAIN_TYPEHASH,
-        viem.keccak256(viem.toHex(contractName)),
-        viem.keccak256(viem.toHex(version)),
-        chainId,
-        contractAddress
-      ])
-    );
-  }
-  /**
-   * Signs a `SelectSolver` EIP-712 message with a session key.
-   *
-   * The session key authorises the selection of a specific solver for the
-   * given order commitment. The resulting signature is appended to the
-   * solver's UserOperation signature before bundle submission.
-   *
-   * @param commitment - The order commitment (bytes32) being fulfilled.
-   * @param solverAddress - Address of the solver account selected to fill the order.
-   * @param domainSeparator - EIP-712 domain separator for the IntentGatewayV2 contract.
-   * @param privateKey - Hex-encoded private key of the session key that signs the message.
-   * @returns The ECDSA signature as a hex string, or `null` if signing fails.
-   */
-  static async signSolverSelection(commitment, solverAddress, domainSeparator, privateKey) {
-    const account = accounts.privateKeyToAccount(privateKey);
-    const structHash = viem.keccak256(
-      viem.encodeAbiParameters(
-        [{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }],
-        [SELECT_SOLVER_TYPEHASH, commitment, solverAddress]
-      )
-    );
-    const digest = viem.keccak256(viem.concat(["0x1901", domainSeparator, structHash]));
-    const signature = await account.sign({ hash: digest });
-    return signature;
-  }
-  /**
-   * Computes the EIP-712 hash of a `PackedUserOperation` as defined by
-   * ERC-4337 EntryPoint v0.8.
-   *
-   * @param userOp - The packed UserOperation to hash.
-   * @param entryPoint - Address of the EntryPoint v0.8 contract.
-   * @param chainId - Chain ID of the network on which the operation will execute.
-   * @returns The UserOperation hash as a hex string.
-   */
-  static computeUserOpHash(userOp, entryPoint, chainId) {
-    const structHash = _CryptoUtils.getPackedUserStructHash(userOp);
-    const domainSeparator = _CryptoUtils.getDomainSeparator("ERC4337", "1", chainId, entryPoint);
-    return viem.keccak256(
-      viem.encodePacked(["bytes1", "bytes1", "bytes32", "bytes32"], ["0x19", "0x01", domainSeparator, structHash])
-    );
-  }
-  /**
-   * 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.
-   *
-   * @param commitment - The order commitment (`order.id`).
-   * @param sessionKey - The order's session key address (`order.session`).
-   * @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;
-  }
-  /**
-   * Builds the EIP-712 typed-data payload whose digest is the EntryPoint v0.8
-   * `userOpHash` (i.e. `hashTypedData(packedUserOpTypedData(...)) ===
-   * computeUserOpHash(...)`). Signing this typed data is bit-identical to
-   * signing the raw userOpHash, but keeps the full operation visible to
-   * signing infrastructure (hardware wallets, MPC/TEE policy engines) instead
-   * of an opaque 32-byte digest.
-   *
-   * The payload must be a standard self-describing `eth_signTypedData_v4`
-   * payload — `EIP712Domain` listed in `types`, `chainId` as a JSON number —
-   * because some signing backends (e.g. MPC Vault) hash it server-side from
-   * the JSON rather than locally via viem. viem ignores both details when
-   * hashing, so the digest is unchanged for local signers.
-   *
-   * @param userOp - The packed UserOperation to sign (signature field ignored).
-   * @param entryPoint - Address of the EntryPoint v0.8 contract.
-   * @param chainId - Chain ID of the network on which the operation will execute.
-   * @returns A viem `TypedDataDefinition` for the operation.
-   */
-  static packedUserOpTypedData(userOp, entryPoint, chainId) {
-    return {
-      domain: {
-        name: "ERC4337",
-        version: "1",
-        // Runtime number so JSON.stringify emits a canonical v4 numeric chainId for
-        // server-side hashers; viem's uint256 type mapping wants bigint but its
-        // runtime accepts numbers, hence the cast.
-        chainId: Number(chainId),
-        verifyingContract: entryPoint
-      },
-      // `as const`: viem derives the domain's TYPE from `types.EIP712Domain`, so the
-      // entries must stay string literals — widened `string` fields make viem's
-      // typed-data generics reject the payload at every call site.
-      types: {
-        EIP712Domain: [
-          { name: "name", type: "string" },
-          { name: "version", type: "string" },
-          { name: "chainId", type: "uint256" },
-          { name: "verifyingContract", type: "address" }
-        ],
-        PackedUserOperation: [
-          { name: "sender", type: "address" },
-          { name: "nonce", type: "uint256" },
-          { name: "initCode", type: "bytes" },
-          { name: "callData", type: "bytes" },
-          { name: "accountGasLimits", type: "bytes32" },
-          { name: "preVerificationGas", type: "uint256" },
-          { name: "gasFees", type: "bytes32" },
-          { name: "paymasterAndData", type: "bytes" }
-        ]
-      },
-      primaryType: "PackedUserOperation",
-      message: {
-        sender: userOp.sender,
-        nonce: userOp.nonce,
-        initCode: userOp.initCode,
-        callData: userOp.callData,
-        accountGasLimits: userOp.accountGasLimits,
-        preVerificationGas: userOp.preVerificationGas,
-        gasFees: userOp.gasFees,
-        paymasterAndData: userOp.paymasterAndData
-      }
-    };
-  }
-  /**
-   * Computes the EIP-712 struct hash of a `PackedUserOperation`.
-   *
-   * Hashes dynamic fields (`initCode`, `callData`, `paymasterAndData`) before
-   * ABI-encoding so the final hash is a fixed-length 32-byte value.
-   *
-   * @param userOp - The packed UserOperation to hash.
-   * @returns The struct hash as a 32-byte hex string.
-   */
-  static getPackedUserStructHash(userOp) {
-    return viem.keccak256(
-      viem.encodeAbiParameters(
-        viem.parseAbiParameters("bytes32, address, uint256, bytes32, bytes32, bytes32, uint256, bytes32, bytes32"),
-        [
-          PACKED_USEROP_TYPEHASH,
-          userOp.sender,
-          userOp.nonce,
-          viem.keccak256(userOp.initCode),
-          viem.keccak256(userOp.callData),
-          userOp.accountGasLimits,
-          userOp.preVerificationGas,
-          userOp.gasFees,
-          viem.keccak256(userOp.paymasterAndData)
-        ]
-      )
-    );
-  }
-  /**
-   * Packs `verificationGasLimit` and `callGasLimit` into the ERC-4337
-   * `accountGasLimits` bytes32 field.
-   *
-   * The high 16 bytes hold `verificationGasLimit` and the low 16 bytes hold
-   * `callGasLimit`, matching the EntryPoint v0.8 packed representation.
-   *
-   * @param verificationGasLimit - Gas limit for the account verification step.
-   * @param callGasLimit - Gas limit for the main execution call.
-   * @returns A 32-byte hex string with both limits packed.
-   */
-  static packGasLimits(verificationGasLimit, callGasLimit) {
-    const verificationGasHex = viem.pad(viem.toHex(verificationGasLimit), { size: 16 });
-    const callGasHex = viem.pad(viem.toHex(callGasLimit), { size: 16 });
-    return viem.concat([verificationGasHex, callGasHex]);
-  }
-  /**
-   * Packs `maxPriorityFeePerGas` and `maxFeePerGas` into the ERC-4337
-   * `gasFees` bytes32 field.
-   *
-   * The high 16 bytes hold `maxPriorityFeePerGas` and the low 16 bytes hold
-   * `maxFeePerGas`, matching the EntryPoint v0.8 packed representation.
-   *
-   * @param maxPriorityFeePerGas - Maximum tip per gas (EIP-1559).
-   * @param maxFeePerGas - Maximum total fee per gas (EIP-1559).
-   * @returns A 32-byte hex string with both fee values packed.
-   */
-  static packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
-    const priorityFeeHex = viem.pad(viem.toHex(maxPriorityFeePerGas), { size: 16 });
-    const maxFeeHex = viem.pad(viem.toHex(maxFeePerGas), { size: 16 });
-    return viem.concat([priorityFeeHex, maxFeeHex]);
-  }
-  /**
-   * Unpacks the `accountGasLimits` bytes32 field back into its constituent
-   * gas limits.
-   *
-   * @param accountGasLimits - The packed 32-byte gas limits field from a `PackedUserOperation`.
-   * @returns Object with `verificationGasLimit` and `callGasLimit` as bigints.
-   */
-  static unpackGasLimits(accountGasLimits) {
-    const hex = accountGasLimits.slice(2);
-    const verificationGasLimit = BigInt(`0x${hex.slice(0, 32)}`);
-    const callGasLimit = BigInt(`0x${hex.slice(32, 64)}`);
-    return { verificationGasLimit, callGasLimit };
-  }
-  /**
-   * Unpacks the `gasFees` bytes32 field back into its constituent fee values.
-   *
-   * @param gasFees - The packed 32-byte gas fees field from a `PackedUserOperation`.
-   * @returns Object with `maxPriorityFeePerGas` and `maxFeePerGas` as bigints.
-   */
-  static unpackGasFees(gasFees) {
-    const hex = gasFees.slice(2);
-    const maxPriorityFeePerGas = BigInt(`0x${hex.slice(0, 32)}`);
-    const maxFeePerGas = BigInt(`0x${hex.slice(32, 64)}`);
-    return { maxPriorityFeePerGas, maxFeePerGas };
-  }
-  /**
-   * Converts a packed `PackedUserOperation` into the JSON object format
-   * expected by ERC-4337 bundler JSON-RPC endpoints.
-   *
-   * Unpacks `accountGasLimits` and `gasFees`, separates optional factory and
-   * paymaster fields, and converts all numeric fields to hex strings.
-   *
-   * @param userOp - The packed UserOperation to convert.
-   * @returns A plain object safe to pass as the first element of bundler RPC params.
-   */
-  static prepareBundlerCall(userOp) {
-    const { verificationGasLimit, callGasLimit } = _CryptoUtils.unpackGasLimits(userOp.accountGasLimits);
-    const { maxPriorityFeePerGas, maxFeePerGas } = _CryptoUtils.unpackGasFees(userOp.gasFees);
-    const hasFactory = userOp.initCode && userOp.initCode !== "0x" && userOp.initCode.length > 2;
-    const factory = hasFactory ? `0x${userOp.initCode.slice(2, 42)}` : void 0;
-    const factoryData = hasFactory ? `0x${userOp.initCode.slice(42)}` : void 0;
-    const hasPaymaster = userOp.paymasterAndData && userOp.paymasterAndData !== "0x" && userOp.paymasterAndData.length > 2;
-    const pmHex = hasPaymaster ? userOp.paymasterAndData.slice(2) : "";
-    const paymaster = hasPaymaster ? `0x${pmHex.slice(0, 40)}` : void 0;
-    const paymasterVerificationGasLimit = hasPaymaster ? BigInt(`0x${pmHex.slice(40, 72)}`) : void 0;
-    const paymasterPostOpGasLimit = hasPaymaster ? BigInt(`0x${pmHex.slice(72, 104)}`) : void 0;
-    const paymasterData = hasPaymaster ? `0x${pmHex.slice(104)}` : void 0;
-    const userOpBundler = {
-      sender: userOp.sender,
-      nonce: viem.toHex(userOp.nonce),
-      callData: userOp.callData,
-      callGasLimit: viem.toHex(callGasLimit),
-      verificationGasLimit: viem.toHex(verificationGasLimit),
-      preVerificationGas: viem.toHex(userOp.preVerificationGas),
-      maxFeePerGas: viem.toHex(maxFeePerGas),
-      maxPriorityFeePerGas: viem.toHex(maxPriorityFeePerGas),
-      signature: userOp.signature
-    };
-    if (factory) {
-      userOpBundler.factory = factory;
-      userOpBundler.factoryData = factoryData || "0x";
-    }
-    if (paymaster) {
-      userOpBundler.paymaster = paymaster;
-      userOpBundler.paymasterData = paymasterData || "0x";
-      userOpBundler.paymasterVerificationGasLimit = viem.toHex(paymasterVerificationGasLimit);
-      userOpBundler.paymasterPostOpGasLimit = viem.toHex(paymasterPostOpGasLimit);
-    }
-    return userOpBundler;
-  }
-  /**
-   * Sends a JSON-RPC request to the configured ERC-4337 bundler endpoint.
-   *
-   * @param method - The JSON-RPC method name (one of {@link BundlerMethod}).
-   * @param params - Array of parameters for the RPC call.
-   * @returns Resolves with the `result` field of the bundler's JSON-RPC response,
-   *   typed as `T`.
-   * @throws If the bundler URL is not configured or the bundler returns an error.
-   */
-  async sendBundler(method, params = []) {
-    if (!this.ctx.bundlerUrl) {
-      throw new Error("Bundler URL not configured");
-    }
-    const response = await fetch(this.ctx.bundlerUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
-    });
-    const result = await response.json();
-    if (result.error) {
-      throw new Error(`Bundler error: ${result.error.message || JSON.stringify(result.error)}`);
-    }
-    return result.result;
-  }
-  /**
-   * Sends multiple JSON-RPC requests to the bundler in a single HTTP call
-   * using JSON-RPC 2.0 batch syntax.  Results are returned in the same order
-   * as the input `requests` array.
-   *
-   * @throws If the bundler URL is not configured, the HTTP call fails, or any
-   *   individual response contains an error.
-   */
-  async sendBundlerBatch(requests) {
-    if (!this.ctx.bundlerUrl) {
-      throw new Error("Bundler URL not configured");
-    }
-    const body = requests.map((r, i) => ({
-      jsonrpc: "2.0",
-      id: i + 1,
-      method: r.method,
-      params: r.params
-    }));
-    const response = await fetch(this.ctx.bundlerUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    const results = await response.json();
-    results.sort((a, b) => a.id - b.id);
-    return results.map((r) => {
-      if (r.error) {
-        throw new Error(`Bundler error: ${r.error.message || JSON.stringify(r.error)}`);
-      }
-      return r.result;
-    });
-  }
-  /**
-   * Encodes a list of calls into ERC-7821 `execute` calldata using
-   * single-batch mode (`ERC7821_BATCH_MODE`).
-   *
-   * @param calls - Ordered list of calls to batch; each specifies a `target`
-   *   address, ETH `value`, and `data`.
-   * @returns ABI-encoded calldata for the ERC-7821 `execute(bytes32,bytes)` function.
-   */
-  encodeERC7821Execute(calls) {
-    const executionData = viem.encodeAbiParameters(
-      [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
-      [calls.map((call) => ({ target: call.target, value: call.value, data: call.data }))]
-    );
-    return viem.encodeFunctionData({
-      abi: erc7281_default.ABI,
-      functionName: "execute",
-      args: [ERC7821_BATCH_MODE, executionData]
-    });
-  }
-  /**
-   * Decodes ERC-7821 `execute` calldata back into its constituent calls.
-   *
-   * Returns `null` if the calldata does not match the expected `execute`
-   * function signature or cannot be decoded.
-   *
-   * @param callData - Hex-encoded calldata previously produced by
-   *   {@link encodeERC7821Execute} or an equivalent encoder.
-   * @returns Array of decoded {@link ERC7821Call} objects, or `null` on failure.
-   */
-  decodeERC7821Execute(callData) {
-    try {
-      const decoded = viem.decodeFunctionData({
-        abi: erc7281_default.ABI,
-        data: callData
-      });
-      if (decoded?.functionName !== "execute" || !decoded.args || decoded.args.length < 2) {
-        return null;
-      }
-      const executionData = decoded.args[1];
-      const [calls] = viem.decodeAbiParameters(
-        [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
-        executionData
-      );
-      return calls.map((call) => ({
-        target: call.target,
-        value: call.value,
-        data: call.data
-      }));
-    } catch {
-      return null;
-    }
-  }
-};
-
-// src/protocols/intents/uniswap-v4-position.ts
-var Q96 = 1n << 96n;
-var MIN_TICK = -887272;
-var MAX_TICK = 887272;
-function word(data, index) {
-  const hex = data.startsWith("0x") ? data.slice(2) : data;
-  const start = index * 64;
-  if (hex.length < start + 64) throw new Error(`return data too short for word ${index}`);
-  return BigInt(`0x${hex.slice(start, start + 64)}`);
-}
-function asSigned(value, bits) {
-  const width = 1n << BigInt(bits);
-  const masked = value & width - 1n;
-  return masked >= width >> 1n ? masked - width : masked;
-}
-function addressFromWord(data, index) {
-  const hex = data.startsWith("0x") ? data.slice(2) : data;
-  return `0x${hex.slice(index * 64 + 24, (index + 1) * 64)}`.toLowerCase();
-}
-function getSqrtRatioAtTick(tick) {
-  if (!Number.isInteger(tick) || tick < MIN_TICK || tick > MAX_TICK) {
-    throw new Error(`tick out of range: ${tick}`);
-  }
-  const absTick = BigInt(Math.abs(tick));
-  let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
-  const factors = [
-    [0x2n, 0xfff97272373d413259a46990580e213an],
-    [0x4n, 0xfff2e50f5f656932ef12357cf3c7fdccn],
-    [0x8n, 0xffe5caca7e10e4e61c3624eaa0941cd0n],
-    [0x10n, 0xffcb9843d60f6159c9db58835c926644n],
-    [0x20n, 0xff973b41fa98c081472e6896dfb254c0n],
-    [0x40n, 0xff2ea16466c96a3843ec78b326b52861n],
-    [0x80n, 0xfe5dee046a99a2a811c461f1969c3053n],
-    [0x100n, 0xfcbe86c7900a88aedcffc83b479aa3a4n],
-    [0x200n, 0xf987a7253ac413176f2b074cf7815e54n],
-    [0x400n, 0xf3392b0822b70005940c7a398e4b70f3n],
-    [0x800n, 0xe7159475a2c29b7443b29c7fa6e889d9n],
-    [0x1000n, 0xd097f3bdfd2022b8845ad8f792aa5825n],
-    [0x2000n, 0xa9f746462d870fdf8a65dc1f90e061e5n],
-    [0x4000n, 0x70d869a156d2a1b890bb3df62baf32f7n],
-    [0x8000n, 0x31be135f97d08fd981231505542fcfa6n],
-    [0x10000n, 0x9aa508b5b7a84e1c677de54f3e99bc9n],
-    [0x20000n, 0x5d6af8dedb81196699c329225ee604n],
-    [0x40000n, 0x2216e584f5fa1ea926041bedfe98n],
-    [0x80000n, 0x48a170391f7dc42444e8fa2n]
-  ];
-  for (const [bit, factor] of factors) {
-    if ((absTick & bit) !== 0n) ratio = ratio * factor >> 128n;
-  }
-  if (tick > 0) ratio = (1n << 256n) / ratio;
-  return (ratio >> 32n) + (ratio % (1n << 32n) === 0n ? 0n : 1n);
-}
-function positionTicks(info) {
-  return {
-    tickLower: Number(asSigned(info >> 8n, 24)),
-    tickUpper: Number(asSigned(info >> 32n, 24))
-  };
-}
-function getAmountsForLiquidity(params) {
-  let { sqrtRatioAX96, sqrtRatioBX96 } = params;
-  const { sqrtPriceX96, liquidity } = params;
-  if (sqrtRatioAX96 > sqrtRatioBX96) [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
-  const amount0For = (from, to) => liquidity * Q96 * (to - from) / to / from;
-  const amount1For = (from, to) => liquidity * (to - from) / Q96;
-  if (sqrtPriceX96 <= sqrtRatioAX96) {
-    return { amount0: amount0For(sqrtRatioAX96, sqrtRatioBX96), amount1: 0n };
-  }
-  if (sqrtPriceX96 < sqrtRatioBX96) {
-    return {
-      amount0: amount0For(sqrtPriceX96, sqrtRatioBX96),
-      amount1: amount1For(sqrtRatioAX96, sqrtPriceX96)
-    };
-  }
-  return { amount0: 0n, amount1: amount1For(sqrtRatioAX96, sqrtRatioBX96) };
-}
-function decodePoolAndPositionInfo(data) {
-  const hex = data.startsWith("0x") ? data.slice(2) : data;
-  if (hex.length < 6 * 64) throw new Error("getPoolAndPositionInfo returned too little data");
-  const { tickLower, tickUpper } = positionTicks(word(data, 5));
-  return {
-    currency0: addressFromWord(data, 0),
-    currency1: addressFromWord(data, 1),
-    poolKeyEncoded: `0x${hex.slice(0, 5 * 64)}`,
-    tickLower,
-    tickUpper
-  };
-}
-function positionAmountOfToken(params) {
-  const { info, liquidity, sqrtPriceX96 } = params;
-  const outputToken = params.outputToken.toLowerCase();
-  if (outputToken !== info.currency0 && outputToken !== info.currency1) return 0n;
-  if (liquidity <= 0n || sqrtPriceX96 <= 0n) return 0n;
-  const { amount0, amount1 } = getAmountsForLiquidity({
-    sqrtPriceX96,
-    sqrtRatioAX96: getSqrtRatioAtTick(info.tickLower),
-    sqrtRatioBX96: getSqrtRatioAtTick(info.tickUpper),
-    liquidity
-  });
-  return outputToken === info.currency0 ? amount0 : amount1;
-}
-
-// src/protocols/intents/phantom-aggregation.ts
-var ENTRY_POINT_V08_ADDRESS = "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
 var injectedFetch;
 function setAggregationFetch(fetchImpl) {
   injectedFetch = fetchImpl;
@@ -2685,18 +2352,10 @@ function setAggregationFetch(fetchImpl) {
 function rpcFetch() {
   const f = injectedFetch ?? globalThis.fetch;
   if (typeof f !== "function") {
-    throw new Error("No fetch available; call setAggregationFetch() before using the aggregation helpers");
+    throw new Error("No fetch available; call setAggregationFetch() before reading bids");
   }
   return f;
 }
-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++) {
@@ -2726,13 +2385,80 @@ async function rpcCall(url, payload) {
       if (timer) clearTimeout(timer);
     }
   }
-  throw new PhantomRpcError(`RPC call failed after 4 attempts: ${url}`, lastErr);
+  throw new Error(`RPC call failed after 4 attempts: ${url}`, { cause: lastErr });
+}
+async function fetchBidsForOrder(nodeUrl, commitment) {
+  const data = await rpcCall(nodeUrl, {
+    id: 1,
+    jsonrpc: "2.0",
+    method: "intents_getBidsForOrder",
+    params: [commitment]
+  });
+  return Array.isArray(data.result) ? data.result : [];
 }
-var FILL_ORDER_ABI = IntentGatewayV2_default.ABI;
 var DECLARATION_V1 = 1;
 var DECLARATION_V2 = 2;
+var PAYMASTER_ADDRESS_BYTES = 20;
+var PAYMASTER_GAS_LIMIT_BYTES = 16;
+var PAYMASTER_DATA_OFFSET = PAYMASTER_ADDRESS_BYTES + 2 * PAYMASTER_GAS_LIMIT_BYTES;
+var SIMPLEX_MODE_PERMIT2 = 2;
+var PERMIT2_DATA_BYTES = 1 + 20 + 32 + 32 + 32 + 1 + 32 + 32;
+var PERMIT2_SPONSORSHIP_BYTES = PAYMASTER_DATA_OFFSET + PERMIT2_DATA_BYTES;
 var MAX_DECLARED_ENTRIES = 255;
 var MAX_TOKEN_ID_BYTES = 32;
+function utf8Encode(text) {
+  const bytes = [];
+  for (const char of text) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint < 128) bytes.push(codePoint);
+    else if (codePoint < 2048) bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
+    else if (codePoint < 65536) {
+      bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+    } else {
+      bytes.push(
+        240 | codePoint >> 18,
+        128 | codePoint >> 12 & 63,
+        128 | codePoint >> 6 & 63,
+        128 | codePoint & 63
+      );
+    }
+  }
+  return bytes;
+}
+function utf8Decode(bytes) {
+  let text = "";
+  for (let offset = 0; offset < bytes.length; ) {
+    const lead = bytes[offset];
+    let codePoint;
+    let continuations;
+    if (lead < 128) {
+      codePoint = lead;
+      continuations = 0;
+    } else if ((lead & 224) === 192) {
+      codePoint = lead & 31;
+      continuations = 1;
+    } else if ((lead & 240) === 224) {
+      codePoint = lead & 15;
+      continuations = 2;
+    } else if ((lead & 248) === 240) {
+      codePoint = lead & 7;
+      continuations = 3;
+    } else {
+      return null;
+    }
+    if (offset + continuations >= bytes.length) return null;
+    for (let index = 1; index <= continuations; index++) {
+      const byte = bytes[offset + index];
+      if ((byte & 192) !== 128) return null;
+      codePoint = codePoint << 6 | byte & 63;
+    }
+    const overlong = continuations === 1 && codePoint < 128 || continuations === 2 && codePoint < 2048 || continuations === 3 && codePoint < 65536;
+    if (overlong || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343) return null;
+    text += String.fromCodePoint(codePoint);
+    offset += continuations + 1;
+  }
+  return text;
+}
 function tokenIdToBytes(tokenId) {
   if (tokenId < 0n) throw new Error(`Uniswap V4 tokenId cannot be negative: ${tokenId}`);
   const bytes = [];
@@ -2755,7 +2481,7 @@ function encodePhantomBidDeclaration(declaration) {
   const version = positions.length > 0 ? DECLARATION_V2 : DECLARATION_V1;
   const bytes = [version, chains.length];
   for (const chain of chains) {
-    const encoded = util.stringToU8a(chain);
+    const encoded = utf8Encode(chain);
     if (encoded.length === 0 || encoded.length > 255) {
       throw new Error(`Invalid state machine id in source chain declaration: ${chain}`);
     }
@@ -2773,573 +2499,117 @@ function encodePhantomBidDeclaration(declaration) {
   }
   return util.u8aToHex(new Uint8Array(bytes));
 }
-function decodePhantomBidDeclaration(paymasterAndData) {
-  const absent = { acceptedSources: null, uniswapV4Positions: [] };
-  if (!paymasterAndData || !util.isHex(paymasterAndData)) return absent;
-  const bytes = util.hexToU8a(paymasterAndData);
-  if (bytes.length < 2) return absent;
-  const version = bytes[0];
-  if (version !== DECLARATION_V1 && version !== DECLARATION_V2) return absent;
+function parseDeclaration(bytes, start) {
+  if (bytes.length - start < 2) return null;
+  const version = bytes[start];
+  if (version !== DECLARATION_V1 && version !== DECLARATION_V2) return null;
   const chains = [];
-  let offset = 2;
-  for (let entry = 0; entry < bytes[1]; entry++) {
-    if (offset >= bytes.length) return absent;
+  let offset = start + 2;
+  for (let entry = 0; entry < bytes[start + 1]; entry++) {
+    if (offset >= bytes.length) return null;
     const length = bytes[offset];
     offset += 1;
-    if (length === 0 || offset + length > bytes.length) return absent;
-    chains.push(util.u8aToString(bytes.subarray(offset, offset + length)));
+    if (length === 0 || offset + length > bytes.length) return null;
+    const chain = utf8Decode(bytes.subarray(offset, offset + length));
+    if (chain === null) return null;
+    chains.push(chain);
     offset += length;
   }
   const positions = [];
   if (version === DECLARATION_V2) {
-    if (offset >= bytes.length) return absent;
+    if (offset >= bytes.length) return null;
     const count = bytes[offset];
     offset += 1;
     for (let entry = 0; entry < count; entry++) {
-      if (offset >= bytes.length) return absent;
+      if (offset >= bytes.length) return null;
       const length = bytes[offset];
       offset += 1;
-      if (length === 0 || length > MAX_TOKEN_ID_BYTES || offset + length > bytes.length) return absent;
-      let tokenId = 0n;
-      for (const byte of bytes.subarray(offset, offset + length)) tokenId = tokenId << 8n | BigInt(byte);
-      positions.push(tokenId);
+      if (length === 0 || length > MAX_TOKEN_ID_BYTES || offset + length > bytes.length) return null;
+      positions.push(bytesToBigInt2(bytes.subarray(offset, offset + length)));
       offset += length;
     }
   }
-  if (offset !== bytes.length) return absent;
+  if (offset !== bytes.length) return null;
   return { acceptedSources: chains, uniswapV4Positions: positions };
 }
-function encodeAcceptedSourceChains(chains) {
-  return encodePhantomBidDeclaration({ acceptedSourceChains: chains });
-}
-function decodeAcceptedSourceChains(paymasterAndData) {
-  return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
-}
-function zipFillLegs(assets, outputs) {
-  return assets.map((asset, index) => {
-    const rawAmount = outputs[index]?.amount;
-    return {
-      outputToken: asset.token,
-      solverAmount: rawAmount === void 0 || rawAmount === null ? 0n : BigInt(rawAmount.toString())
-    };
-  });
-}
-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);
-}
-function weightedMedian(entries) {
-  const sorted = [...entries].sort((a, b) => a.price < b.price ? -1 : a.price > b.price ? 1 : 0);
-  const totalWeight = sorted.reduce((acc, e) => e.weight > 0n ? acc + e.weight : acc, 0n);
-  if (totalWeight === 0n) {
-    return sorted[Math.floor(sorted.length / 2)].price;
-  }
-  let cumulative = 0n;
-  for (const entry of sorted) {
-    if (entry.weight <= 0n) continue;
-    cumulative += entry.weight;
-    if (cumulative * 2n >= totalWeight) return entry.price;
-  }
-  return sorted[sorted.length - 1].price;
-}
-function extractFillData(callData, gatewayAddress) {
-  const calls = decodeERC7821ExecuteBatch(callData);
-  if (!calls) return null;
-  const normalized = gatewayAddress.toLowerCase();
-  for (const call of calls) {
-    if (call.target.toLowerCase() !== normalized) continue;
-    try {
-      const decoded = decodeFillOrder(call.data);
-      if (!decoded) continue;
-      const order = decoded.order;
-      const options = decoded.options;
-      const assets = order?.output?.assets;
-      const outputs = options?.outputs;
-      if (!assets?.length || !outputs?.length) continue;
-      return { order, options, legs: zipFillLegs(assets, outputs) };
-    } catch {
-      continue;
-    }
-  }
-  return null;
+function bytesToBigInt2(bytes) {
+  let value = 0n;
+  for (const byte of bytes) value = value << 8n | BigInt(byte);
+  return value;
 }
-var FILL_ORDER_INPUT = FILL_ORDER_ABI.find(
-  (item) => item?.type === "function" && item?.name === "fillOrder"
-)?.inputs?.[0];
-function orderCommitmentFromDecoded(order) {
-  try {
-    if (!FILL_ORDER_INPUT) return null;
-    return viem.keccak256(viem.encodeAbiParameters([FILL_ORDER_INPUT], [order]));
-  } catch {
-    return null;
-  }
+function bytesToAddress(bytes) {
+  return util.u8aToHex(bytes);
 }
-var BID_COMMITMENT_BYTES = 32;
-var SOLVER_SIGNATURE_BYTES = 65;
-function splitBidSignature(signature) {
-  const raw = signature.replace(/^0x/, "");
-  const commitmentChars = BID_COMMITMENT_BYTES * 2;
-  const end = commitmentChars + SOLVER_SIGNATURE_BYTES * 2;
-  if (raw.length < end) return null;
-  return {
-    commitment: `0x${raw.slice(0, commitmentChars)}`,
-    solverSignature: `0x${raw.slice(commitmentChars, end)}`
-  };
+function hasPermit2Sponsorship(bytes) {
+  return bytes.length >= PERMIT2_SPONSORSHIP_BYTES && bytes[PAYMASTER_DATA_OFFSET] === SIMPLEX_MODE_PERMIT2;
 }
-var recoverBidSignerViem = async (userOp, entryPoint, chainId, solverSignature) => {
-  try {
-    const userOpHash = CryptoUtils.computeUserOpHash(userOp, entryPoint, chainId);
-    return await viem.recoverAddress({ hash: userOpHash, signature: solverSignature });
-  } catch {
-    return null;
-  }
-};
-var DELEGATION_INDICATOR_PREFIX = "0xef0100";
-async function isDelegatedToSolverAccount(evmRpcUrl, account, solverAccounts) {
-  const response = await rpcCall(evmRpcUrl, {
-    id: 1,
-    jsonrpc: "2.0",
-    method: "eth_getCode",
-    params: [account, "latest"]
-  });
-  if (typeof response.result !== "string") {
-    throw new PhantomRpcError(`eth_getCode returned no code for ${account} on ${evmRpcUrl}`);
-  }
-  const code = response.result.toLowerCase();
-  if (!code.startsWith(DELEGATION_INDICATOR_PREFIX)) return false;
-  const delegate = `0x${code.slice(DELEGATION_INDICATOR_PREFIX.length)}`;
-  return solverAccounts.some((solverAccount) => solverAccount.toLowerCase() === delegate);
-}
-function memoizedDelegationCheck() {
-  const cache = /* @__PURE__ */ new Map();
-  return (evmRpcUrl, account, solverAccounts) => {
-    const targets = solverAccounts.map((a) => a.toLowerCase()).sort().join(",");
-    const key = `${evmRpcUrl}|${account.toLowerCase()}|${targets}`;
-    let pending = cache.get(key);
-    if (!pending) {
-      pending = isDelegatedToSolverAccount(evmRpcUrl, account, solverAccounts).catch((err) => {
-        cache.delete(key);
-        throw err;
-      });
-      cache.set(key, pending);
-    }
-    return pending;
+function parseSponsorship(bytes) {
+  let offset = 0;
+  const take = (length) => {
+    const slice = bytes.subarray(offset, offset + length);
+    offset += length;
+    return slice;
   };
+  const paymaster = bytesToAddress(take(PAYMASTER_ADDRESS_BYTES));
+  take(2 * PAYMASTER_GAS_LIMIT_BYTES);
+  take(1);
+  const token = bytesToAddress(take(20));
+  const permitAmount = bytesToBigInt2(take(32));
+  const nonce = bytesToBigInt2(take(32));
+  const deadline = bytesToBigInt2(take(32));
+  return { paymaster, token, permitAmount, nonce, deadline };
 }
-function evmChainId(chain) {
-  const [prefix, id] = chain.split("-");
-  if (prefix !== "EVM" || !id || !/^\d+$/.test(id)) return null;
-  return BigInt(id);
-}
-async function isVerifiedSolverBid(params) {
-  const {
-    userOp,
-    commitment,
-    sessionKey,
-    chainId,
-    solverAccounts,
-    evmRpcUrl,
-    recoverSigner,
-    bidNonceKey,
-    isDelegated,
-    logger
-  } = params;
-  const solver = userOp.sender;
-  const parsed = splitBidSignature(userOp.signature);
-  if (!parsed) {
-    logger?.warn({ solver, commitment }, "Rejecting phantom bid: malformed userOp signature");
-    return false;
-  }
-  if (parsed.commitment.toLowerCase() !== commitment.toLowerCase()) {
-    logger?.warn(
-      { solver, commitment, signedFor: parsed.commitment },
-      "Rejecting phantom bid: signed for another order"
-    );
-    return false;
-  }
-  if (BigInt(userOp.nonce) >> 64n !== bidNonceKey(commitment, sessionKey)) {
-    logger?.warn({ solver, commitment }, "Rejecting phantom bid: nonce does not bind order and session key");
-    return false;
-  }
-  const signer = await recoverSigner(userOp, ENTRY_POINT_V08_ADDRESS, chainId, parsed.solverSignature);
-  if (!signer || signer.toLowerCase() !== solver.toLowerCase()) {
-    logger?.warn({ solver, commitment, signer }, "Rejecting phantom bid: signature does not recover to the sender");
-    return false;
-  }
-  if (!await isDelegated(evmRpcUrl, solver, solverAccounts)) {
-    logger?.warn({ solver, commitment, solverAccounts }, "Rejecting phantom bid: sender is not a delegated solver");
-    return false;
-  }
-  return true;
-}
-async function fetchBidsForOrder(nodeUrl, commitment) {
-  const data = await rpcCall(nodeUrl, {
-    id: 1,
-    jsonrpc: "2.0",
-    method: "intents_getBidsForOrder",
-    params: [commitment]
-  });
-  return Array.isArray(data.result) ? data.result : [];
-}
-async function ethCallUint(evmRpcUrl, to, data, blockTag = "latest") {
-  const result = await rpcCall(evmRpcUrl, {
-    id: 1,
-    jsonrpc: "2.0",
-    method: "eth_call",
-    params: [{ to, data }, blockTag]
-  });
-  if (result.result === "0x") return 0n;
-  if (typeof result.result !== "string") {
-    throw new PhantomRpcError(`eth_call returned no result for ${to} on ${evmRpcUrl}`);
-  }
-  return BigInt(result.result);
+var absentDeclaration = () => ({ acceptedSources: null, uniswapV4Positions: [] });
+function decodePhantomBidPaymasterAndData(paymasterAndData) {
+  const none = { mode: "none", declaration: absentDeclaration(), sponsorship: null };
+  if (!paymasterAndData || !util.isHex(paymasterAndData)) return none;
+  const bytes = util.hexToU8a(paymasterAndData);
+  const bare = parseDeclaration(bytes, 0);
+  if (bare) return { mode: "declaration", declaration: bare, sponsorship: null };
+  if (!hasPermit2Sponsorship(bytes)) return none;
+  const sponsorship = parseSponsorship(bytes);
+  const tail = bytes.length > PERMIT2_SPONSORSHIP_BYTES ? parseDeclaration(bytes, PERMIT2_SPONSORSHIP_BYTES) : null;
+  return { mode: "permit2", declaration: tail ?? absentDeclaration(), sponsorship };
 }
-async function getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVaults, blockTag = "latest") {
-  const padded = solver.replace("0x", "").padStart(64, "0");
-  const raw = await ethCallUint(evmRpcUrl, token, `0x70a08231${padded}`, blockTag);
-  const vaults = yieldVaults[chain]?.[token.toLowerCase()] ?? [];
-  const vaultBalances = await Promise.all(
-    vaults.map((v) => ethCallUint(evmRpcUrl, v, `0xce96cb77${padded}`, blockTag))
-    // maxWithdraw(address)
-  );
-  return vaultBalances.reduce((acc, b) => acc + b, raw);
+function decodePhantomBidDeclaration(paymasterAndData) {
+  return decodePhantomBidPaymasterAndData(paymasterAndData).declaration;
 }
-var SELECTOR_OWNER_OF = "0x6352211e";
-var SELECTOR_POSITION_LIQUIDITY = "0x1efeed33";
-var SELECTOR_POOL_AND_POSITION_INFO = "0x7ba03aad";
-var SELECTOR_GET_SLOT0 = "0xc815641c";
-var uint256Arg = (value) => value.toString(16).padStart(64, "0");
-async function readV4Position(params) {
-  const { evmRpcUrl, contracts, tokenId, keccak, blockTag = "latest", logger } = params;
-  const call = async (to, data) => {
-    const result = await rpcCall(evmRpcUrl, {
-      id: 1,
-      jsonrpc: "2.0",
-      method: "eth_call",
-      params: [{ to, data }, blockTag]
-    });
-    if (result.result === "0x") return null;
-    if (typeof result.result !== "string") {
-      throw new PhantomRpcError(`eth_call returned no result for ${to} on ${evmRpcUrl}`);
-    }
-    return result.result;
-  };
-  const arg = uint256Arg(tokenId);
-  const [ownerData, infoData, liquidityData] = await Promise.all([
-    call(contracts.positionManager, `${SELECTOR_OWNER_OF}${arg}`),
-    call(contracts.positionManager, `${SELECTOR_POOL_AND_POSITION_INFO}${arg}`),
-    call(contracts.positionManager, `${SELECTOR_POSITION_LIQUIDITY}${arg}`)
-  ]);
-  if (!ownerData) return null;
-  if (!infoData || !liquidityData) {
-    logger?.warn(
-      { tokenId: tokenId.toString(), positionManager: contracts.positionManager },
-      "Uniswap V4 position exists but its pool info or liquidity did not read back \u2014 check the configured PositionManager"
-    );
-    return null;
-  }
-  const info = decodePoolAndPositionInfo(infoData);
-  const slot0Data = await call(contracts.stateView, `${SELECTOR_GET_SLOT0}${keccak(info.poolKeyEncoded).slice(2)}`);
-  if (!slot0Data) {
-    logger?.warn(
-      { tokenId: tokenId.toString(), stateView: contracts.stateView, evmRpcUrl },
-      "Uniswap V4 slot0 read returned nothing for a live position \u2014 the configured StateView address is wrong"
+function encodePhantomBidPaymasterAndData(bid) {
+  const declaration = encodePhantomBidDeclaration(bid);
+  const sponsorship = bid.sponsorship;
+  if (!sponsorship || sponsorship === "0x") return declaration;
+  if (!util.isHex(sponsorship)) throw new Error("Phantom bid sponsorship is not hex");
+  const bytes = util.hexToU8a(sponsorship);
+  if (bytes.length !== PERMIT2_SPONSORSHIP_BYTES || !hasPermit2Sponsorship(bytes)) {
+    throw new Error(
+      `Phantom bid sponsorship must be a ${PERMIT2_SPONSORSHIP_BYTES}-byte Permit2-mode paymasterAndData, got ${bytes.length} bytes`
     );
-    return null;
   }
-  return {
-    owner: `0x${ownerData.slice(-40)}`.toLowerCase(),
-    info,
-    liquidity: word(liquidityData, 0),
-    sqrtPriceX96: word(slot0Data, 0)
-  };
-}
-function memoizedV4Position(keccak, logger) {
-  const cache = /* @__PURE__ */ new Map();
-  return (evmRpcUrl, chain, contracts, tokenId) => {
-    const key = `${chain}|${tokenId}`;
-    let pending = cache.get(key);
-    if (!pending) {
-      pending = readV4Position({ evmRpcUrl, contracts, tokenId, keccak, logger }).catch((err) => {
-        cache.delete(key);
-        throw err;
-      });
-      cache.set(key, pending);
-    }
-    return pending;
-  };
-}
-function memoizedSolverBalance(yieldVaults, blockTags = {}) {
-  const cache = /* @__PURE__ */ new Map();
-  return (evmRpcUrl, chain, token, solver) => {
-    const key = `${chain}|${token.toLowerCase()}|${solver.toLowerCase()}`;
-    let pending = cache.get(key);
-    if (!pending) {
-      pending = getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVaults, blockTags[chain]).catch((err) => {
-        cache.delete(key);
-        throw err;
-      });
-      cache.set(key, pending);
-    }
-    return pending;
-  };
+  return `${sponsorship}${declaration.slice(2)}`;
 }
-async function sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance, positions) {
-  const balances = [];
-  for (const [chain, tokens] of Object.entries(yieldVaults)) {
-    const url = evmRpcUrls[chain];
-    if (!url) continue;
-    for (const token of Object.keys(tokens)) {
-      const balance = await getBalance(url, chain, token, solver);
-      const uniswapV4Balance = chain === positions.chain ? positions.states.reduce(
-        (total2, state) => total2 + positionAmountOfToken({
-          info: state.info,
-          liquidity: state.liquidity,
-          sqrtPriceX96: state.sqrtPriceX96,
-          outputToken: token
-        }),
-        0n
-      ) : 0n;
-      const total = balance + uniswapV4Balance;
-      if (total === 0n) continue;
-      balances.push({ solver, chain, tokenAddress: token, balance: total });
-    }
-  }
-  return balances;
-}
-function toAddress(token) {
-  const hex = token.toLowerCase().replace(/^0x/, "");
-  const addr = hex.length > 40 ? hex.slice(-40) : hex.padStart(40, "0");
-  return `0x${addr}`;
-}
-async function aggregatePhantomBids(params) {
-  const isDelegated = memoizedDelegationCheck();
-  let lastErr;
-  for (let attempt = 1; attempt <= AGGREGATION_ATTEMPTS; attempt++) {
-    try {
-      return await runAggregation(params, isDelegated);
-    } catch (err) {
-      lastErr = err;
-      params.logger?.warn(
-        { err, commitment: params.commitment, chain: params.chain, attempt, of: AGGREGATION_ATTEMPTS },
-        "Phantom aggregation attempt failed"
-      );
-      if (attempt < AGGREGATION_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, 250 * attempt));
-    }
-  }
-  throw lastErr;
+function encodeAcceptedSourceChains(chains) {
+  return encodePhantomBidDeclaration({ acceptedSourceChains: chains });
 }
-var AGGREGATION_ATTEMPTS = 5;
-async function runAggregation(params, isDelegated) {
-  const { nodeUrl, evmRpcUrls, chain, gatewayAddress, commitment, yieldVaults, logger } = params;
-  const solverAccounts = (Array.isArray(params.solverAccount) ? params.solverAccount : [params.solverAccount]).filter(
-    (a) => typeof a === "string" && a.length > 0
-  );
-  const extractFill = params.extractFill ?? extractFillData;
-  const recoverSigner = params.recoverSigner ?? recoverBidSignerViem;
-  const bidNonceKey = params.bidNonceKey ?? CryptoUtils.bidNonceKey;
-  const orderCommitment = params.orderCommitment ?? orderCommitmentFromDecoded;
-  const destUrl = evmRpcUrls[chain];
-  if (!destUrl) return null;
-  const chainId = evmChainId(chain);
-  if (solverAccounts.length === 0 || chainId === null) {
-    logger?.warn({ chain, commitment }, "Cannot verify phantom bids: no SolverAccount or chain id for chain");
-    return null;
-  }
-  const bids = await fetchBidsForOrder(nodeUrl, commitment);
-  if (bids.length === 0) return null;
-  const protocolFeeHaircutBps = await readProtocolFeeHaircutBps(destUrl, gatewayAddress);
-  const v4Contracts = params.uniswapV4?.[chain];
-  const readPosition = memoizedV4Position(params.keccak ?? viem.keccak256, logger);
-  const getBalance = params.getBalance ?? memoizedSolverBalance(yieldVaults);
-  const quotesByLeg = /* @__PURE__ */ new Map();
-  const lpBalances = [];
-  const verifiedPositions = [];
-  const countedSolvers = /* @__PURE__ */ new Set();
-  for (const bid of bids) {
-    if (!bid.user_op) continue;
-    try {
-      const decoded = decodeUserOpScale(bid.user_op);
-      const solver = decoded.sender;
-      const fillData = extractFill(decoded.callData, gatewayAddress);
-      if (!fillData) continue;
-      const decodedCommitment = orderCommitment(fillData.order);
-      if (!decodedCommitment || decodedCommitment.toLowerCase() !== commitment.toLowerCase()) {
-        logger?.warn({ solver, commitment }, "Rejecting phantom bid: calldata order is not the indexed order");
-        continue;
-      }
-      const sessionKey = fillData.order?.session;
-      if (!sessionKey) {
-        logger?.warn({ solver, commitment }, "Rejecting phantom bid: order carries no session key");
-        continue;
-      }
-      const verified = await isVerifiedSolverBid({
-        userOp: decoded,
-        commitment,
-        sessionKey,
-        chainId,
-        solverAccounts,
-        evmRpcUrl: destUrl,
-        recoverSigner,
-        bidNonceKey,
-        isDelegated,
-        logger
-      });
-      if (!verified) continue;
-      const normalizedSolver = solver.toLowerCase();
-      if (countedSolvers.has(normalizedSolver)) {
-        logger?.warn({ solver, commitment }, "Skipping phantom bid: solver already counted for this order");
-        continue;
-      }
-      countedSolvers.add(normalizedSolver);
-      const declaration = decodePhantomBidDeclaration(decoded.paymasterAndData);
-      const acceptedSources = declaration.acceptedSources;
-      const poolPriced = declaration.uniswapV4Positions.length > 0;
-      const applyHaircut = (amount) => poolPriced ? applyUniswapQuoteHaircut(amount) : applyProtocolFeeHaircut(amount, protocolFeeHaircutBps);
-      const quotedLegs = [...fillData.legs.entries()].map(([legIndex, leg]) => [
-        legIndex,
-        { ...leg, solverAmount: applyHaircut(leg.solverAmount) }
-      ]).filter(([, leg]) => leg.solverAmount !== 0n);
-      const declaredPositions = v4Contracts ? declaration.uniswapV4Positions : [];
-      const ownedPositions = (await Promise.all(
-        declaredPositions.map(async (tokenId) => ({
-          tokenId,
-          state: await readPosition(destUrl, chain, v4Contracts, tokenId)
-        }))
-      )).filter((entry) => {
-        if (!entry.state) return false;
-        if (entry.state.owner !== normalizedSolver) {
-          logger?.warn(
-            { solver, commitment, tokenId: entry.tokenId.toString(), owner: entry.state.owner },
-            "Ignoring declared Uniswap V4 position: not owned by the bidding solver"
-          );
-          return false;
-        }
-        return true;
-      });
-      const positions = ownedPositions.map((entry) => entry.state);
-      for (const entry of ownedPositions) {
-        verifiedPositions.push({ solver: normalizedSolver, chain, tokenId: entry.tokenId });
-      }
-      const weights = await Promise.all(
-        // Price influence: the solver's liquidity in THIS leg's output token on the destination
-        // chain, so a leg is weighted by the inventory that actually backs it.
-        quotedLegs.map(async ([, leg]) => {
-          const outputToken = toAddress(leg.outputToken);
-          const balance = await getBalance(destUrl, chain, outputToken, solver);
-          return positions.reduce(
-            (total, state) => total + positionAmountOfToken({
-              info: state.info,
-              liquidity: state.liquidity,
-              sqrtPriceX96: state.sqrtPriceX96,
-              outputToken
-            }),
-            balance
-          );
-        })
-      );
-      for (const [position, [legIndex, leg]] of quotedLegs.entries()) {
-        const weight = weights[position];
-        const entry = quotesByLeg.get(legIndex) ?? { outputToken: leg.outputToken, quotes: [], bidders: [] };
-        entry.quotes.push({ price: leg.solverAmount, weight });
-        entry.bidders.push({ solver: normalizedSolver, weight, acceptedSources });
-        quotesByLeg.set(legIndex, entry);
-      }
-      lpBalances.push(
-        ...await sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance, {
-          chain,
-          states: positions
-        })
-      );
-    } catch (err) {
-      if (err instanceof PhantomRpcError) throw err;
-      logger?.warn({ err, filler: bid.filler }, "Failed to process bid for price snapshot");
-    }
-  }
-  if (quotesByLeg.size === 0) return null;
-  const legs = [...quotesByLeg.entries()].sort(([a], [b]) => a - b).flatMap(([legIndex, { outputToken, quotes, bidders }]) => {
-    const backedQuotes = quotes.filter((quote) => quote.weight > 0n);
-    const backedBidders = bidders.filter((bidder) => bidder.weight > 0n);
-    if (backedQuotes.length === 0) {
-      logger?.warn(
-        { commitment, chain, legIndex, outputToken, quotes: quotes.length },
-        "Dropping phantom leg: no bidder holds the output token on this chain, so no quote is backed"
-      );
-      return [];
-    }
-    const medianPrice = weightedMedian(backedQuotes);
-    return [
-      {
-        legIndex,
-        outputToken,
-        lowestPrice: medianPrice,
-        highestPrice: medianPrice,
-        medianPrice,
-        bidCount: backedQuotes.length,
-        bidders: backedBidders
-      }
-    ];
-  });
-  return { legs, lpBalances, positions: verifiedPositions, solvers: [...countedSolvers] };
+function decodeAcceptedSourceChains(paymasterAndData) {
+  return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
 }
 
-exports.ENTRY_POINT_V08_ADDRESS = ENTRY_POINT_V08_ADDRESS;
-exports.FILL_ORDER_ABI = FILL_ORDER_ABI;
-exports.FILL_ORDER_V1_ABI = FILL_ORDER_V1_ABI;
 exports.IntentGatewayV2 = IntentGatewayV2_default;
-exports.UNISWAP_QUOTE_HAIRCUT_BPS = UNISWAP_QUOTE_HAIRCUT_BPS;
-exports.aggregatePhantomBids = aggregatePhantomBids;
-exports.applyProtocolFeeHaircut = applyProtocolFeeHaircut;
-exports.applyUniswapQuoteHaircut = applyUniswapQuoteHaircut;
+exports.MAX_DECLARED_ENTRIES = MAX_DECLARED_ENTRIES;
+exports.PERMIT2_SPONSORSHIP_BYTES = PERMIT2_SPONSORSHIP_BYTES;
 exports.decodeAcceptedSourceChains = decodeAcceptedSourceChains;
 exports.decodeERC7821ExecuteBatch = decodeERC7821ExecuteBatch;
 exports.decodePhantomBidDeclaration = decodePhantomBidDeclaration;
+exports.decodePhantomBidPaymasterAndData = decodePhantomBidPaymasterAndData;
 exports.decodeUserOpScale = decodeUserOpScale;
 exports.encodeAcceptedSourceChains = encodeAcceptedSourceChains;
 exports.encodeERC7821ExecuteBatch = encodeERC7821ExecuteBatch;
 exports.encodePhantomBidDeclaration = encodePhantomBidDeclaration;
+exports.encodePhantomBidPaymasterAndData = encodePhantomBidPaymasterAndData;
 exports.encodeUserOpScale = encodeUserOpScale;
-exports.extractFillData = extractFillData;
 exports.fetchBidsForOrder = fetchBidsForOrder;
-exports.getTotalSolverBalance = getTotalSolverBalance;
-exports.memoizedSolverBalance = memoizedSolverBalance;
-exports.orderCommitmentFromDecoded = orderCommitmentFromDecoded;
 exports.poolSlug = poolSlug;
-exports.positionAmountOfToken = positionAmountOfToken;
-exports.readProtocolFeeHaircutBps = readProtocolFeeHaircutBps;
-exports.readV4Position = readV4Position;
-exports.recoverBidSignerViem = recoverBidSignerViem;
 exports.setAggregationFetch = setAggregationFetch;
 exports.sortPoolSymbols = sortPoolSymbols;
-exports.splitBidSignature = splitBidSignature;
-exports.weightedMedian = weightedMedian;
-exports.zipFillLegs = zipFillLegs;
 //# sourceMappingURL=intents-helpers.cjs.map
 //# sourceMappingURL=intents-helpers.cjs.map