@ickb/sdk 1000.0.82 → 9000.0.1

package/dist/utils/utils.js

@@ -0,0 +1,151 @@
+import { ccc } from "@ckb-ccc/core";
+/**
+ * The default page size used when querying cells from the chain.
+ *
+ * This page size is aligned with Nervos CKB's pull request #4576
+ * (https://github.com/nervosnetwork/ckb/pull/4576) to avoid excessive paging.
+ */
+export const defaultCellPageSize = 400;
+/**
+ * Reads every committed cell matching the key, page by page, without touching
+ * CCC's cell cache. The scan ends on the first short page.
+ *
+ * @remarks A full page must advance the cursor; otherwise the read throws so a faulty
+ * endpoint in the app's public node pool cannot keep the scan looping forever.
+ * The cursor continues ordering, not a coherent snapshot. There is no aggregate budget:
+ * a large book costs a slower read rather than a partial result.
+ */
+export async function findCells(client, keyLike) {
+    const key = ccc.ClientIndexerSearchKey.from(keyLike);
+    const cells = [];
+    let after;
+    for (;;) {
+        const page = await client.findCellsPagedNoCache(key, "asc", defaultCellPageSize, after);
+        cells.push(...page.cells);
+        if (page.cells.length < defaultCellPageSize) {
+            return cells;
+        }
+        if (page.lastCursor === after) {
+            throw new Error("Cell scan cursor did not advance");
+        }
+        after = page.lastCursor;
+    }
+}
+/**
+ * True when a cell has no type script and no data payload.
+ *
+ * @remarks
+ * This is a structural filter for plain capacity cells. Spendability still
+ * depends on the lock script, live cell state, and transaction context.
+ */
+export function isPlainCapacityCell(cell) {
+    return cell.cellOutput.type === undefined && cell.outputData === "0x";
+}
+/**
+ * Performs asynchronously a binary search to find the smallest index `i` in the range [0, n)
+ * such that the function `f(i)` returns true. It is assumed that for the range
+ * [0, n), if `f(i)` is true, then `f(i+1)` is also true. This means that there
+ * is a prefix of the input range where `f` is false, followed by a suffix where
+ * `f` is true. If no such index exists, the function returns `n`.
+ *
+ * The function `f` is only called for indices in the range [0, n).
+ *
+ * @param n - The non-negative integer upper bound of the search range (exclusive).
+ * @param f - An async function that takes an index `i` and returns a boolean value.
+ * @returns The smallest index `i` such that `f(i)` is true, or `n` if no such index exists.
+ *
+ * @remarks Adapted from Go's standard library search implementation:
+ * {@link https://go.dev/src/sort/search.go}
+ */
+export async function asyncBinarySearch(n, f) {
+    // Define f(-1) == false and f(n) == true.
+    // Invariant: f(i-1) == false, f(j) == true.
+    let [i, j] = [0, n];
+    while (i < j) {
+        const h = Math.trunc((i + j) / 2);
+        // i ≤ h < j
+        if (!(await f(h))) {
+            i = h + 1; // preserves f(i-1) == false
+        }
+        else {
+            j = h; // preserves f(j) == true
+        }
+    }
+    // i == j, f(i-1) == false, and f(j) (= f(i)) == true  =>  answer is i.
+    return i;
+}
+/**
+ * The client's JSON-RPC requestor, when it has one. The connector hands the interface a
+ * composition proxy over the public client (`ClientWithFeeRate`, a `ccc.Client` but not a
+ * `ccc.ClientJsonRpc`), so `instanceof` misses it; the proxy forwards the property.
+ */
+export function jsonRpcRequestor(client) {
+    if (!("requestor" in client)) {
+        return undefined;
+    }
+    const { requestor } = client;
+    return requestor instanceof ccc.RequestorJsonRpc ? requestor : undefined;
+}
+/** A node's raw `get_transaction` status record (verbosity 1), the fields the stack reads. */
+export function rawTransactionStatus(response) {
+    const record = typeof response === "object" &&
+        response !== null &&
+        "tx_status" in response &&
+        typeof response.tx_status === "object" &&
+        response.tx_status !== null
+        ? response.tx_status
+        : {};
+    return {
+        status: "status" in record && typeof record.status === "string" ? record.status : undefined,
+        reason: "reason" in record && typeof record.reason === "string" ? record.reason : undefined,
+        blockNumber: "block_number" in record && typeof record.block_number === "string"
+            ? ccc.numFrom(record.block_number)
+            : undefined,
+    };
+}
+export function minBigInt(left, right) {
+    return left < right ? left : right;
+}
+export function maxBigInt(left, right) {
+    return left > right ? left : right;
+}
+/** `numerator / denominator` rounded up; the denominator is positive. */
+export function ceilDiv(numerator, denominator) {
+    return (numerator + denominator - 1n) / denominator;
+}
+/**
+ * Compares two bigint values using sort-compatible ordering.
+ *
+ * @returns `-1` when `left` is smaller, `1` when `left` is larger, and `0` when equal.
+ */
+export function compareBigInt(left, right) {
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Yields unique items from the given iterable based on their hex representation.
+ *
+ * The function uses a Set to track the hex-string keys of items that have already been yielded.
+ * Only the first occurrence of each unique key is yielded.
+ *
+ * @typeParam T - A type that extends ccc.Entity.
+ * @param items - An iterable collection of items of type T.
+ * @returns A generator that yields items from the iterable, ensuring that each item's
+ *          hex representation (via toHex()) is unique.
+ */
+export function* unique(items) {
+    const set = new Set();
+    for (const i of items) {
+        const key = i.toHex();
+        if (!set.has(key)) {
+            set.add(key);
+            yield i;
+        }
+    }
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ickb/sdk",
-  "version": "1000.0.82",
+  "version": "9000.0.1",
   "description": "iCKB SDK built on top of CCC",
   "keywords": [
     "ickb",
@@ -10,52 +10,45 @@
   ],
   "author": "phroi",
   "license": "MIT",
-  "homepage": "https://github.com/ickb/sdk",
+  "homepage": "https://ickb.org",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ickb/sdk"
+    "url": "git+https://github.com/ickb/stack.git"
   },
   "bugs": {
-    "url": "https://github.com/ickb/sdk/issues"
+    "url": "https://github.com/ickb/stack/issues"
   },
   "sideEffects": false,
   "type": "module",
+  "engines": {
+    "node": ">=26"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
-  "engines": {
-    "node": ">=18"
-  },
   "files": [
     "dist",
     "src"
   ],
   "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.29.0",
-    "eslint": "^9.29.0",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.34.0"
+    "access": "public"
   },
   "dependencies": {
-    "@ckb-ccc/core": "canary",
-    "@ickb/core": "^1000.0.82",
-    "@ickb/dao": "^1000.0.82",
-    "@ickb/order": "^1000.0.82",
-    "@ickb/utils": "^1000.0.82"
+    "@ckb-ccc/core": "^1.23.0"
+  },
+  "devDependencies": {
+    "@ickb/testkit": "9000.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2"
   },
   "scripts": {
-    "lint": "eslint ./src",
-    "clean": "rm -fr pnpm-lock.yaml dist/*",
-    "revamp": "pnpm clean; pnpm up && node dist/index.js && pnpm lint"
+    "test": "vitest",
+    "build": "rm -fr dist && tsgo -p tsconfig.build.json && node ../scripts/tooling/build/rewrite-dts-imports.ts dist",
+    "lint:api": "api-extractor run",
+    "lint:publish": "publint --strict --pack pnpm"
   }
 }

package/src/constants.ts

@@ -1,205 +1,108 @@
 import { ccc } from "@ckb-ccc/core";
-import { IckbUdtManager, LogicManager, OwnedOwnerManager } from "@ickb/core";
-import { DaoManager } from "@ickb/dao";
-import { OrderManager } from "@ickb/order";
-import { CapacityManager, unique, type ScriptDeps } from "@ickb/utils";
+import type { SdkManagers } from "./conversion/types.ts";
+import { LogicManager } from "./logic.ts";
+import { OrderManager } from "./order/order.ts";
+import { OwnedOwnerManager } from "./owned_owner.ts";
+import { IckbUdt } from "./udt.ts";
+import type { SupportedChain } from "./utils/chain.ts";
 
-/**
- * Retrieves the configuration for the given deployment environment.
- *
- * Accepts either a string identifier ("mainnet" or "testnet") or a custom configuration
- * object containing script dependencies for a devnet.
- *
- * It sets up various managers (UDT, Logic, OwnedOwner, Order, Dao, Capacity) and also
- * aggregates a unique list of known bot scripts.
- *
- * @param d - Either a network identifier ("mainnet"/"testnet") or an object containing
- *   explicit script dependencies for devnet.
- * @param bots - An optional array of bot script-like objects to augment the list of known bots.
- * @returns An object containing the instantiated managers and bots.
- */
-export function getConfig(
-  d:
-    | "mainnet"
-    | "testnet"
-    | {
-        // For devnet configuration provide explicit script dependencies.
-        udt: ScriptDeps;
-        logic: ScriptDeps;
-        ownedOwner: ScriptDeps;
-        order: ScriptDeps;
-        dao: ScriptDeps;
-      },
-  bots: ccc.ScriptLike[] = [],
-): {
-  managers: {
-    capacity: CapacityManager;
-    dao: DaoManager;
-    ickbUdt: IckbUdtManager;
-    logic: LogicManager;
-    ownedOwner: OwnedOwnerManager;
-    order: OrderManager;
-  };
-  bots: ccc.Script[];
-} {
-  // If deps is provided as a network string, use the pre-defined constants.
-  if (d === "mainnet" || d === "testnet") {
-    bots = bots.concat(
-      d === "mainnet" ? MAINNET_KNOWN_BOTS : TESTNET_KNOWN_BOTS,
-    );
-    const depGroup = d === "mainnet" ? MAINNET_DEP_GROUP : TESTNET_DEP_GROUP;
-    d = {
-      udt: from(UDT, depGroup),
-      logic: from(ICKB_LOGIC, depGroup),
-      ownedOwner: from(OWNED_OWNER, depGroup),
-      order: from(ORDER, depGroup),
-      dao: from(DAO, depGroup),
-    };
-  }
-
-  const capacity = CapacityManager.withAnyData();
-  const dao = new DaoManager(d.dao.script, d.dao.cellDeps);
-  const ickbUdt = new IckbUdtManager(
-    d.udt.script,
-    d.udt.cellDeps,
-    d.logic.script,
-    dao,
-  );
-  const logic = new LogicManager(
-    d.logic.script,
-    d.logic.cellDeps,
-    dao,
-    ickbUdt,
-  );
-  const ownedOwner = new OwnedOwnerManager(
-    d.ownedOwner.script,
-    d.ownedOwner.cellDeps,
-    dao,
-    ickbUdt,
-  );
-  const order = new OrderManager(d.order.script, d.order.cellDeps, ickbUdt);
-
-  return {
-    managers: {
-      capacity,
-      dao,
-      ickbUdt,
-      logic,
-      ownedOwner,
-      order,
-    },
-    bots: [...unique(bots.map((b) => ccc.Script.from(b)))],
-  };
-}
-
-/**
- * Wraps a script-like object into a ScriptDeps structure.
- *
- * @param script - The script or script-like object.
- * @param cellDeps - Additional cell dependencies that the script may require.
- * @returns An object containing the script and its associated cell dependencies.
- */
-function from(script: ccc.ScriptLike, ...cellDeps: ccc.CellDep[]): ScriptDeps {
-  return {
-    script: ccc.Script.from(script),
-    cellDeps,
-  };
-}
-
-/**
- * DAO (Decentralized Autonomous Organization) lock script information.
- */
-const DAO = {
-  codeHash:
-    "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
+/** Nervos DAO type script. */
+const DAO = ccc.Script.from({
+  codeHash: "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
   hashType: "type",
   args: "0x",
-};
+});
 
-/**
- * UDT (User Defined Token) lock script information used for onchain validation.
- */
-const UDT = {
-  codeHash:
-    "0x50bd8d6680b8b9cf98b73f3c08faf8b2a21914311954118ad6609be6e78a1b95",
+/** Raw xUDT type script; the iCKB args are computed by `IckbUdt.typeScriptFrom`. */
+const UDT = ccc.Script.from({
+  codeHash: "0x50bd8d6680b8b9cf98b73f3c08faf8b2a21914311954118ad6609be6e78a1b95",
   hashType: "data1",
-  args: "0xb73b6ab39d79390c6de90a09c96b290c331baf1798ed6f97aed02590929734e800000080",
-};
+  args: "0x",
+});
 
-/**
- * Logic script information for the iCKB logic contract.
- */
-const ICKB_LOGIC = {
-  codeHash:
-    "0x2a8100ab5990fa055ab1b50891702e1e895c7bd1df6322cd725c1a6115873bd3",
+/** iCKB Logic script. */
+const ICKB_LOGIC = ccc.Script.from({
+  codeHash: "0x2a8100ab5990fa055ab1b50891702e1e895c7bd1df6322cd725c1a6115873bd3",
   hashType: "data1",
   args: "0x",
-};
+});
 
-/**
- * OwnedOwner lock script information.
- */
-const OWNED_OWNER = {
-  codeHash:
-    "0xacc79e07d107831feef4c70c9e683dac5644d5993b9cb106dca6e74baa381bd0",
+/** Owned Owner lock script. */
+const OWNED_OWNER = ccc.Script.from({
+  codeHash: "0xacc79e07d107831feef4c70c9e683dac5644d5993b9cb106dca6e74baa381bd0",
   hashType: "data1",
   args: "0x",
-};
+});
 
-/**
- * Order lock script information.
- */
-const ORDER = {
-  codeHash:
-    "0x49dfb6afee5cc8ac4225aeea8cb8928b150caf3cd92fea33750683c74b13254a",
+/** Order lock script. */
+const ORDER = ccc.Script.from({
+  codeHash: "0x49dfb6afee5cc8ac4225aeea8cb8928b150caf3cd92fea33750683c74b13254a",
   hashType: "data1",
   args: "0x",
-};
-
-/**
- * Mainnet dependency group cell dep.
- */
-const MAINNET_DEP_GROUP = ccc.CellDep.from({
-  outPoint: {
-    txHash:
-      "0x621a6f38de3b9f453016780edac3b26bfcbfa3e2ecb47c2da275471a5d3ed165",
-    index: "0x0",
-  },
-  depType: "depGroup",
 });
 
-/**
- * Testnet dependency group cell dep.
- */
-const TESTNET_DEP_GROUP = ccc.CellDep.from({
-  outPoint: {
-    txHash:
-      "0xf7ece4fb33d8378344cab11fcd6a4c6f382fd4207ac921cf5821f30712dcd311",
-    index: "0x0",
+/** Each network's code cells, given as direct code deps, and the dep group of the rest. */
+const DEPLOYMENTS = {
+  mainnet: {
+    udtCode: {
+      txHash: "0xc07844ce21b38e4b071dd0e1ee3b0e27afd8d7532491327f39b786343f558ab7",
+      index: 0,
+    },
+    logicCode: {
+      txHash: "0xd7309191381f5a8a2904b8a79958a9be2752dbba6871fa193dab6aeb29dc8f44",
+      index: 0,
+    },
+    depGroup: {
+      txHash: "0x621a6f38de3b9f453016780edac3b26bfcbfa3e2ecb47c2da275471a5d3ed165",
+      index: 0,
+    },
   },
-  depType: "depGroup",
-});
+  testnet: {
+    udtCode: {
+      txHash: "0xbf6fb538763efec2a70a6a3dcb7242787087e1030c4e7d86585bc63a9d337f5f",
+      index: 0,
+    },
+    logicCode: {
+      txHash: "0x9ac989b3355764f76cdce02c69dedb819fdfbcbda49a7db1a2c9facdfdb9a7fe",
+      index: 0,
+    },
+    depGroup: {
+      txHash: "0xf7ece4fb33d8378344cab11fcd6a4c6f382fd4207ac921cf5821f30712dcd311",
+      index: 0,
+    },
+  },
+} as const;
 
 /**
- * Array of known bot scripts on the mainnet.
+ * Plain CKB the bot keeps for its own cells and fees: its sizing line for matches and deposits.
  */
-const MAINNET_KNOWN_BOTS = [
-  {
-    codeHash:
-      "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
-    hashType: "type",
-    args: "0xd096cb29e2f68a85a46bd6bf6cbee6327959ba64",
-  },
-];
+export const CKB_RESERVE = ccc.fixedPointFrom(1000);
 
 /**
- * Array of known bot scripts on the testnet.
+ * The managers of one network's iCKB deployment.
+ *
+ * @remarks Builders still return partial transactions. `IckbSdk` owns the shared iCKB
+ * completion path as `sdk.completeTransaction(...)`, which callers invoke before send.
  */
-const TESTNET_KNOWN_BOTS = [
-  {
-    codeHash:
-      "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
-    hashType: "type",
-    args: "0xb4380110f7679ac31cefe4925485645d82bf619f",
-  },
-];
+export function getConfig(chain: SupportedChain): SdkManagers {
+  // The runtime check stands for callers outside TypeScript.
+  if (!Object.hasOwn(DEPLOYMENTS, chain)) {
+    throw new TypeError("unsupported iCKB network");
+  }
+  const { udtCode, logicCode, depGroup } = DEPLOYMENTS[chain];
+  const cellDeps = [ccc.CellDep.from({ outPoint: depGroup, depType: "depGroup" })];
+  const dao = { script: DAO, cellDeps };
+  const ickbUdt = new IckbUdt({
+    code: udtCode,
+    script: IckbUdt.typeScriptFrom(UDT, ICKB_LOGIC),
+    logicCode,
+    logicScript: ICKB_LOGIC,
+    daoScript: DAO,
+  });
+  return {
+    ickbUdt,
+    ownedOwner: new OwnedOwnerManager(OWNED_OWNER, cellDeps, dao),
+    ickbLogic: new LogicManager(ICKB_LOGIC, cellDeps, dao),
+    order: new OrderManager(ORDER, cellDeps, ickbUdt.script),
+  };
+}

package/src/conversion/estimate.ts

@@ -0,0 +1,157 @@
+import type { IckbDepositCell } from "../logic.ts";
+import {
+  OrderConversionRepresentabilityError,
+  quoteConversion,
+} from "../order/conversion.ts";
+import { ceilDiv, type ValueComponents } from "../utils/utils.ts";
+import { maturity } from "./maturity.ts";
+import type { ConversionOrderEstimate, SystemState } from "./types.ts";
+
+/**
+ * Default order fee: 0.01%. At roughly 2% annual DAO yield this buys about two days of
+ * price headroom for a buy, versus hours at 0.001%; actual fillability also depends on
+ * mining fees. It leaves time to notice a stalled bot without charging the much larger 0.1%.
+ */
+export const DEFAULT_ORDER_FEE = 10n;
+
+/** Default order-fee denominator used by Stack conversion quotes and plans. */
+export const DEFAULT_ORDER_FEE_BASE = 100000n;
+
+/** The quote and its maturity estimate, or `undefined` when no order ratio represents it. */
+export function estimateConversionOrder(
+  isCkb2Udt: boolean,
+  amounts: ValueComponents,
+  system: SystemState,
+  { fee, feeBase }: { fee: bigint; feeBase: bigint },
+  takenDeposits: readonly IckbDepositCell[] = [],
+): ConversionOrderEstimate | undefined {
+  let quote: ReturnType<typeof quoteConversion>;
+  try {
+    quote = quoteConversion(isCkb2Udt, system.exchangeRatio, amounts, { fee, feeBase });
+  } catch (error) {
+    if (error instanceof OrderConversionRepresentabilityError) {
+      return undefined;
+    }
+    throw error;
+  }
+  const estimatedMaturity =
+    quote.ckbFee >= estimateMaturityFeeThreshold(system)
+      ? maturity({ info: quote.info, amounts }, system, takenDeposits)
+      : undefined;
+  return { ...quote, maturity: estimatedMaturity };
+}
+
+/**
+ * Returns the CKB fee threshold above which order maturity is worth estimating.
+ * This conservative proxy stays separate from partialOrderFee: the quote has no built
+ * order whose serialized size could supply that fee yet.
+ */
+export function estimateMaturityFeeThreshold(
+  system: Pick<SystemState, "feeRate">,
+): bigint {
+  return 10n * system.feeRate;
+}
+
+/**
+ * The smallest request one direction accepts as an order at the current fee rate. A
+ * CKB-to-iCKB remainder pays the default order fee, which must cover the maturity threshold
+ * of ten mining fees; an iCKB-to-CKB remainder can give its whole CKB value as the dust
+ * fee, so its value must exceed the threshold. The extra unit covers the quote's rounding,
+ * as the dust search's boundary shows; callers round up further for display.
+ */
+export function minimumOrderAmount(isCkb2Udt: boolean, system: SystemState): bigint {
+  const threshold = estimateMaturityFeeThreshold(system) + 1n;
+  if (isCkb2Udt) {
+    return ceilDiv(threshold * DEFAULT_ORDER_FEE_BASE, DEFAULT_ORDER_FEE);
+  }
+  const { ckbScale, udtScale } = system.exchangeRatio;
+  return ceilDiv(threshold * ckbScale, udtScale);
+}
+
+/**
+ * The order leg of an iCKB-to-CKB conversion: at the default fee when that fee clears the
+ * maturity threshold, else the smallest fee that does (a dust order, noticed). Either way
+ * it is dated: a sell order at par is always covered by the pool (see `maturity`).
+ */
+export function estimateIckbToCkbOrder(
+  amounts: ValueComponents,
+  system: SystemState,
+  takenDeposits: readonly IckbDepositCell[],
+): (ConversionOrderEstimate & { maturity: bigint }) | undefined {
+  const base = estimateConversionOrder(
+    false,
+    amounts,
+    system,
+    { fee: DEFAULT_ORDER_FEE, feeBase: DEFAULT_ORDER_FEE_BASE },
+    takenDeposits,
+  );
+  if (base?.maturity !== undefined) {
+    return { ...base, maturity: base.maturity };
+  }
+
+  const dust = estimateDustIckbToCkbOrder(amounts, system);
+  if (dust === undefined) {
+    return undefined;
+  }
+  return {
+    ...dust,
+    maturity: maturity({ info: dust.info, amounts }, system, takenDeposits),
+    notice: {
+      inputIckb: amounts.udtValue,
+      outputCkb: dust.convertedAmount,
+      incentiveCkb: positiveFee(dust.ckbFee),
+    },
+  };
+}
+
+function estimateDustIckbToCkbOrder(
+  amounts: ValueComponents,
+  system: SystemState,
+): ConversionOrderEstimate | undefined {
+  const baseEstimate = estimateConversionOrder(false, amounts, system, {
+    fee: 0n,
+    feeBase: DEFAULT_ORDER_FEE_BASE,
+  });
+  if (baseEstimate === undefined) {
+    return undefined;
+  }
+  const targetFee = estimateMaturityFeeThreshold(system);
+  const feeBase = baseEstimate.convertedAmount + 1n;
+  if (targetFee <= 0n || feeBase <= 1n) {
+    return baseEstimate;
+  }
+  const estimateWithFee = (fee: bigint): ConversionOrderEstimate | undefined =>
+    estimateConversionOrder(false, amounts, system, { fee, feeBase });
+  return lowestFeeEstimateAtThreshold(estimateWithFee, feeBase - 1n, targetFee);
+}
+
+function lowestFeeEstimateAtThreshold(
+  estimateWithFee: (fee: bigint) => ConversionOrderEstimate | undefined,
+  highestFee: bigint,
+  targetFee: bigint,
+): ConversionOrderEstimate | undefined {
+  const highestDiscount = estimateWithFee(highestFee);
+  if (highestDiscount === undefined || highestDiscount.ckbFee < targetFee) {
+    return undefined;
+  }
+
+  let low = 0n;
+  let high = highestFee;
+  while (low < high) {
+    const mid = (low + high) / 2n;
+    const estimateAtMid = estimateWithFee(mid);
+    if (estimateAtMid === undefined) {
+      return undefined;
+    }
+    if (estimateAtMid.ckbFee >= targetFee) {
+      high = mid;
+    } else {
+      low = mid + 1n;
+    }
+  }
+  return estimateWithFee(low);
+}
+
+function positiveFee(fee: bigint): bigint {
+  return fee > 0n ? fee : 0n;
+}