@blazephoenix/sdk 1.1.0 → 1.2.1

package/README.md

@@ -58,9 +58,11 @@ const plan = await blaze.buildSwap({
   chain: 'base', tokenIn: 'WETH', tokenOut: 'USDC', amount: '1.5',
   recipient: me, from: me,           // `from` enables the allowance check
   slippageBps: 50,                   // default 50; never below the on-chain floor
+  exact: true,                       // optional: minOut from previewPlanExact (one more eth_call)
 });
 plan.steps;       // [approve?, swap] — { chainId, to, data, value }
 plan.minOut;      // the minimum the Router will enforce for you
+                  // (your userMinOut as given, when set; refused below the quote net of slippage)
 plan.encodedBy;   // 'quoter' on 2.x (the Quoter's own bytes, verified) · 'sdk' on 1.x
 
 // 3) optional: dry-run on your node, then execute with YOUR wallet
@@ -161,7 +163,7 @@ await blaze.quoteBatch([req1, req2]); // per-item { ok, quote } | { ok:false, er
 await blaze.getFills({ chain: 'base', lookbackBlocks: 5_000n }); // Swap (+ ExecutionProof on 2.x)
 const stop = await blaze.watchFills({ chain: 'base', onFill: console.log });
 await blaze.tokenInfo('base', '0x…');  // symbol / name / decimals
-await blaze.solvency();                // the staking engine's proof-of-solvency (Base)
+await blaze.solvency();                // staking proof-of-solvency; `not_deployed` where no engine is registered
 toJSON(quote);                         // bigint → string, for HTTP / queues / LLMs
 ```
 
@@ -186,6 +188,8 @@ Every failure, `solvency()` included, is a `BlazeError` with a stable `code`; pr
 | `no_route` | the Solver found no executable path (`SolverE(5)`) or the quote reverted |
 | `not_executable` | the Quoter says the route cannot settle now (`canExecute = false`) |
 | `calldata_mismatch` | Quoter bytes did not match your request — refused |
+| `min_implausible` | `buildSwap`: `userMinOut` below the quote net of `slippageBps` (or the on-chain floor) |
+| `min_above_exact` | `buildSwap({ exact: true })`: `userMinOut` above `exactOut` less the 50 bps safety margin |
 | `deployment_unverified` | a registry deployment failed on-chain verification |
 | `unsupported_by_version` | e.g. native ETH input on a 1.x Router |
 | `not_deployed` / `bad_request` / `wallet_chain_mismatch` / `reverted` | as named |

package/dist/index.cjs

@@ -4738,8 +4738,7 @@ var CHAINS = {
     explorer: "https://basescan.org",
     weth: "0x4200000000000000000000000000000000000006",
     usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    bzpx: "0x23113e72165a034265Ab8Bf2277CCB7a85Cb7483",
-    staking: "0x3f60C7aa0c36a78D200405feBE143d2Cf3fA0c77",
+    bzpx: "0x053D75c00FdD571538492e3B1686Bd963a0911A7",
     blockTime: 2
   },
   10: {
@@ -4769,7 +4768,8 @@ var CHAINS = {
     explorer: "https://robinhoodchain.blockscout.com",
     weth: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
     usdc: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
-    blockTime: 2
+    blockTime: 0.104
+    // measured ~0.104 s/block
   }
 };
 var ALIASES = {
@@ -4834,7 +4834,7 @@ function urlTransport(url, o) {
     throw new BlazeError("bad_request", `refusing RPC URL "${redact(url)}": use https:// or wss:// (http/ws only for localhost)`);
   }
   const u = url.trim();
-  return u.startsWith("ws") ? viem.webSocket(u, { timeout: o.timeoutMs, retryCount: o.retries }) : viem.http(u, { timeout: o.timeoutMs, retryCount: o.retries, batch: o.batch });
+  return u.startsWith("ws") ? viem.webSocket(u, { timeout: o.timeoutMs, retryCount: o.retries }) : viem.http(u, { timeout: o.timeoutMs, retryCount: o.retries, batch: o.batch, fetchOptions: { redirect: "error" } });
 }
 function redact(url) {
   try {
@@ -4982,6 +4982,9 @@ function scrubCause(c, depth = 0) {
   out.name = c.name;
   return out;
 }
+function untrustedText(t, max = 120) {
+  return (t ?? "").replace(/[^\x20-\x7e]+/g, " ").replace(/\s+/g, " ").trim().slice(0, max);
+}
 var BlazeError = class extends Error {
   code;
   details;
@@ -5813,6 +5816,20 @@ var BlazePhoenix = class {
       if (typeof req.amountIn === "bigint") v = req.amountIn;
       else if (INT.test(String(req.amountIn).trim())) v = BigInt(String(req.amountIn).trim());
       else throw new BlazeError("bad_request", 'amountIn must be an integer in base units \u2014 use `amount` for human units ("1.5")');
+      if (req.amount !== void 0 && req.amount !== null && req.amount !== "") {
+        const d = await this.decimalsOf(client, chainId, tIn).catch((e) => {
+          throw new BlazeError("bad_request", "amount and amountIn are both set and the decimals could not be read to compare them \u2014 pass only one", { cause: e });
+        });
+        let human;
+        try {
+          human = toBaseUnits(req.amount, d);
+        } catch (e) {
+          throw new BlazeError("bad_request", e.message);
+        }
+        if (human !== v) {
+          throw new BlazeError("bad_request", `amount and amountIn disagree (${human} vs ${v} base units): pass only one`);
+        }
+      }
     } else if (req.amount !== void 0) {
       const d = await this.decimalsOf(client, chainId, tIn).catch((e) => {
         throw new BlazeError("bad_request", `could not read decimals of ${tIn.address} on your RPC \u2014 pass amountIn in base units`, { cause: e });
@@ -5920,13 +5937,15 @@ var BlazePhoenix = class {
         args: [tIn.address, tOut.address, amountIn],
         ...req.blockNumber !== void 0 ? { blockNumber: req.blockNumber } : {}
       });
+      const net = featuresOf(ctx.dep.version).previewAndEncode ? exactOut : exactOut - (exactOut * BigInt(FEE_BPS) + 9999n) / 10000n;
       return {
         chainId: ctx.chainId,
         version: ctx.dep.version,
         tokenIn: tIn.address,
         tokenOut: tOut.address,
         amountIn,
-        exactOut,
+        exactOut: net,
+        quoterOut: exactOut,
         route,
         quotedAt: Date.now()
       };
@@ -6035,6 +6054,60 @@ var BlazePhoenix = class {
     let encodedBy = "sdk";
     let entry;
     let minOut;
+    let at;
+    if (req.exact) {
+      try {
+        at = await ctx.client.getBlockNumber();
+      } catch (e) {
+        this.wrapReadError(e, "block number");
+      }
+    }
+    const pin = at !== void 0 ? { blockNumber: at } : {};
+    let exactOut;
+    const exactRead = async (route) => {
+      let ex;
+      try {
+        ex = await ctx.client.readContract({
+          address: ctx.dep.contracts.quoter,
+          abi: QUOTER_ABI,
+          functionName: "previewPlanExact",
+          args: [tIn.address, tOut.address, amountIn],
+          ...pin
+        });
+      } catch (e) {
+        this.wrapReadError(e, "exact quote");
+      }
+      if (!samePath(ex[0], route)) {
+        throw new BlazeError("calldata_mismatch", "previewPlanExact priced a different route than the one to execute");
+      }
+      exactOut = ex[1];
+      return ex[1];
+    };
+    const settleMin = async (p) => {
+      let floor = minOutFor(p.netOut, slippageBps, p.ironFloor);
+      let ceil;
+      if (req.exact) {
+        const ex = await exactRead(p.route);
+        ceil = minOutFor(ex, EXACT_MARGIN_BPS, 0n);
+        floor = maxBig(floor, minOutFor(ceil, slippageBps, 0n));
+      }
+      if (userMinOut === 0n) return floor;
+      if (userMinOut < floor) {
+        throw new BlazeError(
+          "min_implausible",
+          `userMinOut is below ${floor} (this quote net of slippageBps): set it from a price you trust, or raise slippageBps if a lower minimum is intended`,
+          { details: { userMinOut: userMinOut.toString(), floor: floor.toString() } }
+        );
+      }
+      if (ceil !== void 0 && userMinOut > ceil && userMinOut > floor) {
+        throw new BlazeError(
+          "min_above_exact",
+          `userMinOut is above ${ceil} (exactOut less ${EXACT_MARGIN_BPS} bps): an honest swap at this minimum may revert`,
+          { details: { userMinOut: userMinOut.toString(), ceiling: ceil.toString() } }
+        );
+      }
+      return userMinOut;
+    };
     if (features.previewAndEncode && !tIn.native && mode === "route") {
       let call;
       try {
@@ -6042,19 +6115,21 @@ var BlazePhoenix = class {
           address: ctx.dep.contracts.quoter,
           abi: QUOTER_ABI,
           functionName: "previewAndEncodeWithMinOut",
-          args: [tIn.address, tOut.address, amountIn, userMinOut, recipient, deadline]
+          args: [tIn.address, tOut.address, amountIn, userMinOut, recipient, deadline],
+          ...pin
         }) : await ctx.client.readContract({
           address: ctx.dep.contracts.quoter,
           abi: QUOTER_ABI,
           functionName: "previewAndEncode",
-          args: [tIn.address, tOut.address, amountIn, recipient, deadline]
+          args: [tIn.address, tOut.address, amountIn, recipient, deadline],
+          ...pin
         });
         [pv, call] = r;
       } catch (e) {
         this.wrapReadError(e, "previewAndEncode");
       }
       assertExecutable(pv, tIn.address, tOut.address, call);
-      minOut = maxBig(minOutFor(pv.netOut, slippageBps, pv.effectiveMinOut), userMinOut);
+      minOut = await settleMin(pv);
       verifySwapExactIn(call, {
         tokenIn: tIn.address,
         tokenOut: tOut.address,
@@ -6068,9 +6143,9 @@ var BlazePhoenix = class {
       encodedBy = "quoter";
       entry = "swapExactIn";
     } else {
-      ({ pv, fb } = await this.readPreview(ctx, tIn.address, tOut.address, amountIn, userMinOut));
+      ({ pv, fb } = await this.readPreview(ctx, tIn.address, tOut.address, amountIn, userMinOut, at));
       assertExecutable(pv, tIn.address, tOut.address);
-      minOut = maxBig(minOutFor(pv.netOut, slippageBps, pv.effectiveMinOut), userMinOut);
+      minOut = await settleMin(pv);
       if (mode === "best") {
         entry = "swapBestExactIn";
         data = encodeSwapBestExactIn(tIn.address, tOut.address, amountIn, minOut, recipient, deadline);
@@ -6117,7 +6192,8 @@ var BlazePhoenix = class {
       slippageBps,
       approval,
       unwrapAfter: tOut.native,
-      steps: approval ? [approval.tx, tx] : [tx]
+      steps: approval ? [approval.tx, tx] : [tx],
+      ...exactOut !== void 0 ? { exactOut } : {}
     };
   }
   /** eth_call the swap from `from` on your RPC: the realised amountOut if it
@@ -6134,7 +6210,7 @@ var BlazePhoenix = class {
     } catch (e) {
       if (isTransportError(e)) throw new BlazeError("rpc_error", `simulation: your RPC failed (${e?.message?.split("\n")[0]})`, { cause: e });
       const d = decodeBlazeError(e);
-      return { ok: false, error: d ?? { contract: "unknown", name: "revert", reason: e?.message?.split("\n")[0] ?? "execution reverted" } };
+      return { ok: false, error: d ?? { contract: "unknown", name: "revert", reason: untrustedText(e?.message?.split("\n")[0]) || "execution reverted" } };
     }
   }
   /**
@@ -6358,6 +6434,17 @@ function checkDeadlineSec(n) {
   return n;
 }
 var maxBig = (a, b) => a > b ? a : b;
+var EXACT_MARGIN_BPS = 50;
+function samePath(a, b) {
+  const eqA = (x, y) => x.toLowerCase() === y.toLowerCase();
+  return a.hops.length === b.hops.length && a.hops.every((h, i) => {
+    const g = b.hops[i];
+    return eqA(h.tokenIn, g.tokenIn) && eqA(h.tokenOut, g.tokenOut) && h.legs.length === g.legs.length && h.legs.every((l, j) => {
+      const m = g.legs[j];
+      return eqA(l.pool, m.pool) && eqA(l.hooks, m.hooks) && l.kind === m.kind && l.fee === m.fee && l.tickSpacing === m.tickSpacing && l.zeroForOne === m.zeroForOne && l.stable === m.stable;
+    });
+  });
+}
 function deepLink(opts = {}) {
   const base = (opts.baseUrl ?? "https://blazephoenix.xyz").replace(/\/+$/, "");
   const sp = new URLSearchParams();