@ickb/sdk 9000.0.1 → 9001.0.0

package/src/order/cells.ts

@@ -2,10 +2,6 @@ import type { ccc } from "@ckb-ccc/core";
 import type { ValueComponents } from "../utils/utils.ts";
 import { OrderData } from "./order_data.ts";
 
-// The resolver's own group, keyed by its order cell: matching and transactions use this
-// parse, so a caller's own wrapper is only ever a key into it.
-const resolvedOrderGroups = new WeakMap<ccc.Cell, OrderGroup>();
-
 /**
  * Represents a parsed order cell on the blockchain.
  *
@@ -114,15 +110,13 @@ export class OrderCell implements ValueComponents {
       : 0n;
 
     const absTotal = absoluteOrderTotal(ckb2UdtValue, udt2CkbValue, data.info);
-    const absProgress = absoluteOrderProgress({
-      absTotal,
-      ckbUnoccupied,
-      isCkb2Udt,
-      isDualRatio,
-      udtScale: ckbToUdt.udtScale,
-      udtValue,
-      udtToCkbCkbScale: udtToCkb.ckbScale,
-    });
+    // What the order already holds of its output side; a dual-ratio order is complete.
+    let absProgress = ckbUnoccupied * udtToCkb.ckbScale;
+    if (isDualRatio) {
+      absProgress = absTotal;
+    } else if (isCkb2Udt) {
+      absProgress = udtValue * ckbToUdt.udtScale;
+    }
 
     return new OrderCell({ cell, data, ckbUnoccupied, absTotal, absProgress });
   }
@@ -168,56 +162,25 @@ export class OrderCell implements ValueComponents {
   }
 
   /**
-   * Validates a descendant order against this origin order.
+   * Whether `descendant` can be this origin order's live continuation.
    *
    * @remarks
    * This confusion-attack guard requires the same order script, UDT type,
    * master, and info, while forbidding lower total value or lower progress.
    * See {@link https://github.com/ickb/whitepaper/issues/19}.
    */
-  public validate(descendant: OrderCell): void {
-    if (!this.data.isMint()) {
-      throw new Error("Origin is not a mint order");
-    }
-
-    if (!this.cell.cellOutput.lock.eq(descendant.cell.cellOutput.lock)) {
-      throw new Error("Order script different");
-    }
-
-    const udt = this.cell.cellOutput.type;
-    if (udt === undefined || descendant.cell.cellOutput.type?.eq(udt) !== true) {
-      throw new Error("UDT type is different");
-    }
-
-    if (!descendant.getMaster().eq(this.getMaster())) {
-      throw new Error("Master is different");
-    }
-
-    if (!this.data.info.eq(descendant.data.info)) {
-      throw new Error("Info is different");
-    }
-
-    if (this.absTotal > descendant.absTotal) {
-      throw new Error("Total value is lower than the original one");
-    }
-
-    if (this.absProgress > descendant.absProgress) {
-      throw new Error("Progress is lower than the original one");
-    }
-  }
-
-  /**
-   * Checks if the descendant order is valid against this order.
-   * @param descendant - The descendant order to validate.
-   * @returns True if the descendant is valid, otherwise false.
-   */
   public isValid(descendant: OrderCell): boolean {
-    try {
-      this.validate(descendant);
-      return true;
-    } catch {
-      return false;
-    }
+    const udt = this.cell.cellOutput.type;
+    return (
+      this.data.isMint() &&
+      this.cell.cellOutput.lock.eq(descendant.cell.cellOutput.lock) &&
+      udt !== undefined &&
+      descendant.cell.cellOutput.type?.eq(udt) === true &&
+      descendant.getMaster().eq(this.getMaster()) &&
+      this.data.info.eq(descendant.data.info) &&
+      this.absTotal <= descendant.absTotal &&
+      this.absProgress <= descendant.absProgress
+    );
   }
 
   /**
@@ -272,24 +235,6 @@ function absoluteOrderTotal(
   );
 }
 
-function absoluteOrderProgress(options: {
-  absTotal: bigint;
-  ckbUnoccupied: bigint;
-  isCkb2Udt: boolean;
-  isDualRatio: boolean;
-  udtScale: bigint;
-  udtToCkbCkbScale: bigint;
-  udtValue: bigint;
-}): bigint {
-  if (options.isDualRatio) {
-    return options.absTotal;
-  }
-  if (options.isCkb2Udt) {
-    return options.udtValue * options.udtScale;
-  }
-  return options.ckbUnoccupied * options.udtToCkbCkbScale;
-}
-
 function betterOrderResolution(
   current: OrderResolution | undefined,
   candidate: OrderCell,
@@ -325,19 +270,10 @@ function compareOrderScore(left: OrderCell, right: OrderCell): number {
 /**
  * Represents a master cell
  */
-export class MasterCell implements ValueComponents {
+export class MasterCell {
   /** Raw live master cell that anchors an order group. */
   public readonly cell: ccc.Cell;
 
-  /**
-   * Gets the UDT value of the cell.
-   *
-   * For a Master Cell, the UDT amount is always zero.
-   *
-   * @returns The UDT amount as a `ccc.FixedPoint` (0n).
-   */
-  public readonly udtValue = 0n;
-
   /**
    * Creates an instance of MasterCell.
    * @param cell - The ccc.Cell instance to be wrapped by the MasterCell.
@@ -346,28 +282,12 @@ export class MasterCell implements ValueComponents {
     this.cell = cell;
   }
 
-  /**
-   * Gets the CKB value of the cell.
-   *
-   * @returns The total CKB amount as a `ccc.FixedPoint`.
-   */
-  public get ckbValue(): ccc.FixedPoint {
-    return this.cell.cellOutput.capacity;
-  }
-
-  /**
-   * Validates the MasterCell against an OrderCell.
-   * @param order - The OrderCell to validate against.
-   * @throws Error if the order script is different or if the master is different.
-   */
-  public validate(order: OrderCell): void {
-    if (this.cell.cellOutput.type?.eq(order.cell.cellOutput.lock) !== true) {
-      throw new Error("Order script different");
-    }
-
-    if (!order.getMaster().eq(this.cell.outPoint)) {
-      throw new Error("Master is different");
-    }
+  /** Whether this master anchors `order`: its type is the order script and the order names it. */
+  public anchors(order: OrderCell): boolean {
+    return (
+      this.cell.cellOutput.type?.eq(order.cell.cellOutput.lock) === true &&
+      order.getMaster().eq(this.cell.outPoint)
+    );
   }
 }
 
@@ -381,21 +301,21 @@ export class OrderGroup implements ValueComponents {
   public readonly order: OrderCell;
   /** Origin order used to validate descendant progress and identity. */
   public readonly origin: OrderCell;
-  /** The block that committed the origin, when known: how long the order has been on the book. */
-  public readonly blockNumber: ccc.Num | undefined;
+  /** The block that committed the origin and its master: how long the order has been on the book. */
+  public readonly blockNumber: ccc.Num;
 
   /**
    * Creates an instance of OrderGroup.
    * @param master - The master cell associated with the order group.
    * @param order - The order within the group.
    * @param origin - The original order associated with the group.
-   * @param blockNumber - The block that committed the origin, if committed.
+   * @param blockNumber - The block that committed the origin and its master.
    */
   constructor(
     master: MasterCell,
     order: OrderCell,
     origin: OrderCell,
-    blockNumber?: ccc.Num,
+    blockNumber: ccc.Num,
   ) {
     this.master = master;
     this.order = order;
@@ -432,7 +352,7 @@ export class OrderGroup implements ValueComponents {
     master: MasterCell,
     order: OrderCell,
     origin: OrderCell,
-    blockNumber?: ccc.Num,
+    blockNumber: ccc.Num,
   ): OrderGroup | undefined {
     const og = new OrderGroup(master, order, origin, blockNumber);
     if (og.isValid()) {
@@ -441,27 +361,13 @@ export class OrderGroup implements ValueComponents {
     return undefined;
   }
 
-  /**
-   * Validates the order group against its master and origin orders.
-   * @throws Will throw an error if validation fails.
-   */
-  public validate(): void {
-    this.master.validate(this.origin);
-    this.master.validate(this.order);
-    this.origin.validate(this.order);
-  }
-
-  /**
-   * Checks if the order group is valid.
-   * @returns True if the order group is valid, otherwise false.
-   */
+  /** Whether the master anchors both orders and the order continues its origin. */
   public isValid(): boolean {
-    try {
-      this.validate();
-      return true;
-    } catch {
-      return false;
-    }
+    return (
+      this.master.anchors(this.origin) &&
+      this.master.anchors(this.order) &&
+      this.origin.isValid(this.order)
+    );
   }
 
   /**
@@ -475,46 +381,3 @@ export class OrderGroup implements ValueComponents {
     return locks.some((l) => lock.eq(l));
   }
 }
-
-/**
- * Records canonical resolver output without exposing forgeable provenance data. The
- * group and its parsed parts are frozen, since matching and transactions build on them.
- */
-export function attestResolvedOrderGroup(group: OrderGroup): OrderGroup {
-  group.validate();
-  for (const order of [group.order, group.origin]) {
-    const { info } = order.data;
-    for (const part of [
-      order,
-      order.data,
-      order.data.master,
-      info,
-      info.ckbToUdt,
-      info.udtToCkb,
-    ]) {
-      Object.freeze(part);
-    }
-  }
-  Object.freeze(group.master);
-  resolvedOrderGroups.set(group.order.cell, Object.freeze(group));
-  return group;
-}
-
-/** Returns the resolver's group at a matching or transaction boundary. */
-export function validatedOrderGroup(group: OrderGroup): OrderGroup {
-  if (!(group instanceof OrderGroup)) {
-    throw new TypeError("Matching requires resolved OrderGroups from findOrders()");
-  }
-
-  const attested = resolvedOrderGroups.get(group.order.cell);
-  if (attested === undefined) {
-    throw new TypeError("OrderGroup was not produced by the order resolver");
-  }
-  if (
-    group.master.cell !== attested.master.cell ||
-    group.origin.cell !== attested.origin.cell
-  ) {
-    throw new TypeError("OrderGroup does not match its resolver attestation");
-  }
-  return attested;
-}

package/src/order/conversion.ts

@@ -1,10 +1,6 @@
 import { ccc } from "@ckb-ccc/core";
-import {
-  ceilDiv,
-  minBigInt,
-  type ExchangeRatio,
-  type ValueComponents,
-} from "../utils/utils.ts";
+import { ckbFromUdt } from "../udt.ts";
+import { ceilDiv, type ExchangeRatio, type ValueComponents } from "../utils/utils.ts";
 import { Info } from "./info.ts";
 import { Ratio } from "./ratio.ts";
 
@@ -35,15 +31,8 @@ export function quoteConversion(
   isCkb2Udt: boolean,
   midpoint: ExchangeRatio,
   amounts: ValueComponents,
-  options?: {
-    fee?: ccc.Num;
-    feeBase?: ccc.Num;
-  },
+  { fee, feeBase }: { fee: ccc.Num; feeBase: ccc.Num },
 ): { convertedAmount: ccc.FixedPoint; ckbFee: ccc.FixedPoint; info: Info } {
-  const fee = options?.fee ?? 0n;
-  // Generic denominator for callers that pass a fee without a scale; Stack's
-  // own default pair is owned publicly by the SDK, not by this entity.
-  const feeBase = options?.feeBase ?? 100000n;
   const base = Ratio.from(midpoint);
   const amount = isCkb2Udt ? amounts.ckbValue : amounts.udtValue;
   const { aScale, bScale } = feeAdjustedScales(base, isCkb2Udt, fee, feeBase);
@@ -52,8 +41,8 @@ export function quoteConversion(
 
   if (amount > 0n && fee !== 0n) {
     ckbFee = isCkb2Udt
-      ? amount - base.convert(false, convertedAmount, false)
-      : base.convert(false, amount, false) - convertedAmount;
+      ? amount - ckbFromUdt(convertedAmount, base)
+      : ckbFromUdt(amount, base) - convertedAmount;
   }
 
   // Every order this SDK creates carries the default minimum match, the one the bot's
@@ -99,7 +88,7 @@ function feeAdjustedScales(
  * The ratio that reproduces the quote exactly: the greatest Uint64 fraction at most
  * `quotedOutput / inputAmount`, which must still round the input up to the quoted output.
  */
-export function quotePreservingRatio(
+function quotePreservingRatio(
   inputAmount: ccc.FixedPoint,
   quotedOutput: ccc.FixedPoint,
   isCkb2Udt: boolean,
@@ -147,10 +136,10 @@ export function greatestBoundedFractionAtMost(
     const quotient = n / d;
     let term = quotient;
     if (p !== 0n) {
-      term = minBigInt(term, (maxTerm - previousP) / p);
+      term = ccc.numMin(term, (maxTerm - previousP) / p);
     }
     if (q !== 0n) {
-      term = minBigInt(term, (maxTerm - previousQ) / q);
+      term = ccc.numMin(term, (maxTerm - previousQ) / q);
     }
     const candidate = {
       numerator: term * p + previousP,

package/src/order/fill.ts

@@ -75,9 +75,9 @@ export const STALE_ORDER_BLOCKS = (30n * 24n * 60n * 60n) / 8n;
 /**
  * Whether the order has sat on the book for thirty days: whatever the reason (dust under
  * the fill's cost, a remainder another matcher left, an ask above the market), it is
- * collected and its funds returned. Age from the origin's block, so an uncommitted origin
- * is as fresh as an order gets. The block count assumes eight-second blocks, not wall time.
+ * collected and its funds returned. Age from the origin's block. The block count assumes
+ * eight-second blocks, not wall time.
  */
 export function isStale(group: OrderGroup, tip: ccc.ClientBlockHeader): boolean {
-  return (group.blockNumber ?? tip.number) + STALE_ORDER_BLOCKS <= tip.number;
+  return group.blockNumber + STALE_ORDER_BLOCKS <= tip.number;
 }

package/src/order/info.ts

@@ -66,6 +66,9 @@ export interface Info {
 // cannot fill it whole. Fee changes and an aging buy can still make a remainder unprofitable.
 export const CKB_MIN_MATCH_LOG_DEFAULT = 36;
 
+// An interface, this class expression and a typed const rather than one plain class: a
+// class extending `ccc.Entity.Base<...>()` emits an unexported `*_base` declaration, which
+// API Extractor's ae-forgotten-export rejects (tried 2026-10-30).
 // eslint-disable-next-line @typescript-eslint/no-shadow -- Preserve the runtime constructor name.
 const InfoImplementation = class Info extends InfoBase {
   static {

package/src/order/matcher.ts

@@ -1,5 +1,5 @@
-import type { ccc } from "@ckb-ccc/core";
-import { ceilDiv, minBigInt } from "../utils/utils.ts";
+import { ccc } from "@ckb-ccc/core";
+import { ceilDiv } from "../utils/utils.ts";
 import type { OrderCell, OrderGroup } from "./cells.ts";
 
 /**
@@ -167,7 +167,7 @@ function orderMatcherTerms(
   return {
     ...terms,
     // An order under its own minimum can only be completed.
-    bMinMatch: minBigInt(bMinMatch, bMaxMatch),
+    bMinMatch: ccc.numMin(bMinMatch, bMaxMatch),
     bMaxMatch,
     bMaxOut,
   };

package/src/order/order.ts

@@ -1,19 +1,11 @@
 import { ccc } from "@ckb-ccc/core";
 import { findCells, type ScriptDeps, type ValueComponents } from "../utils/utils.ts";
-import {
-  attestResolvedOrderGroup,
-  MasterCell,
-  OrderCell,
-  OrderGroup,
-  validatedOrderGroup,
-} from "./cells.ts";
+import { MasterCell, OrderCell, OrderGroup } from "./cells.ts";
 import { Info, type InfoLike } from "./info.ts";
 import type { Match } from "./matcher.ts";
 import { OrderData } from "./order_data.ts";
 import { Relative } from "./relative.ts";
 
-type TransactionResponse = Awaited<ReturnType<ccc.Client["getTransaction"]>>;
-
 /**
  * Builds and scans iCKB Stack order cells for one order script deployment.
  */
@@ -124,11 +116,10 @@ export class OrderManager implements ScriptDeps {
    */
   public melt(txLike: ccc.TransactionLike, groups: OrderGroup[]): ccc.Transaction {
     const tx = ccc.Transaction.from(txLike);
-    const selected = groups.map(validatedOrderGroup);
-    if (selected.length === 0) {
+    if (groups.length === 0) {
       return tx;
     }
-    for (const group of selected) {
+    for (const group of groups) {
       if (!this.isOrder(group.order.cell)) {
         throw new Error(
           `Melt order ${group.order.cell.outPoint.toHex()} does not match this order manager`,
@@ -136,7 +127,7 @@ export class OrderManager implements ScriptDeps {
       }
     }
     tx.addCellDeps(this.cellDeps);
-    for (const group of selected) {
+    for (const group of groups) {
       tx.addInput(group.order.cell);
       tx.addInput(group.master.cell);
     }
@@ -153,9 +144,9 @@ export class OrderManager implements ScriptDeps {
       this.findAllMasters(client),
     ]);
     const rawGroups = new Map(
-      masters.map((master) => [
+      masters.map(({ master, blockNumber }) => [
         master.cell.outPoint.toHex(),
-        { master, orders: new Array<OrderCell>() },
+        { master, blockNumber, orders: new Array<OrderCell>() },
       ]),
     );
     for (const order of orders) {
@@ -167,8 +158,8 @@ export class OrderManager implements ScriptDeps {
     const groups = await Promise.all(
       [...rawGroups.values()]
         .filter((rawGroup) => rawGroup.orders.length > 0)
-        .map(async ({ master, orders: candidates }) =>
-          this.resolveOrderGroup(client, master, candidates),
+        .map(async ({ master, blockNumber, orders: candidates }) =>
+          this.resolveOrderGroup(client, master, blockNumber, candidates),
         ),
     );
     return groups.filter((group) => group !== undefined);
@@ -182,13 +173,20 @@ export class OrderManager implements ScriptDeps {
       scriptSearchMode: "exact",
       withData: true,
     });
-    return cells.flatMap((cell) => {
+    return cells.flatMap(({ cell }) => {
       const order = OrderCell.tryFrom(cell);
       return order !== undefined && this.isOrder(cell) ? [order] : [];
     });
   }
 
-  private async findAllMasters(client: ccc.Client): Promise<MasterCell[]> {
+  /**
+   * Every master with the block that committed it, which is its mint order's block too:
+   * a master is created beside its mint order and never changes until melted, so this
+   * dates how long the order has been on the book.
+   */
+  private async findAllMasters(
+    client: ccc.Client,
+  ): Promise<Array<{ master: MasterCell; blockNumber: ccc.Num }>> {
     // An exact type search returns master cells only, so nothing re-filters here.
     const cells = await findCells(client, {
       script: this.script,
@@ -196,40 +194,47 @@ export class OrderManager implements ScriptDeps {
       scriptSearchMode: "exact",
       withData: true,
     });
-    return cells.map((cell) => new MasterCell(cell));
+    return cells.map(({ cell, blockNumber }) => ({
+      master: new MasterCell(cell),
+      blockNumber,
+    }));
   }
 
   /** Resolves one master and its descendant orders into a validated order group. */
   private async resolveOrderGroup(
     client: ccc.Client,
     master: MasterCell,
+    blockNumber: ccc.Num,
     orders: OrderCell[],
   ): Promise<OrderGroup | undefined> {
-    const found = await this.findOrigin(client, master.cell.outPoint);
-    const order = found?.origin.resolve(orders);
-    if (found === undefined || order === undefined) {
+    const origin = await this.findOrigin(client, master.cell.outPoint);
+    const order = origin?.resolve(orders);
+    if (origin === undefined || order === undefined) {
       return undefined;
     }
-    const group = OrderGroup.tryFrom(master, order, found.origin, found.blockNumber);
+    const group = OrderGroup.tryFrom(master, order, origin, blockNumber);
     // A dual-ratio order, valid on chain but placed by nothing in the stack, is left to
     // whoever placed it: neither matched, estimated, shown nor melted here.
     if (group === undefined || group.order.data.info.isDualRatio()) {
       return undefined;
     }
-    return attestResolvedOrderGroup(group);
+    return group;
   }
 
   /**
    * The mint order created beside the master, read from the master's transaction: the
-   * client cache first, then the node, recording the response for the next read. The
-   * response's block number dates the order; an uncommitted origin has none.
+   * client cache first, then the node, which records the response for the next read.
    */
   private async findOrigin(
     client: ccc.Client,
     master: ccc.OutPoint,
-  ): Promise<{ origin: OrderCell; blockNumber: ccc.Num | undefined } | undefined> {
+  ): Promise<OrderCell | undefined> {
     const { txHash, index: masterIndex } = master;
-    const response = await cachedTransactionResponse(client, txHash);
+    // A cached body is trusted like the scan that found the master: an order is a node's
+    // claim until the send checks every cell it spends against its creating transaction.
+    const response =
+      (await client.cache.getTransactionResponse(txHash)) ??
+      (await client.getTransaction(txHash));
     if (response === undefined) {
       return undefined;
     }
@@ -260,9 +265,7 @@ export class OrderManager implements ScriptDeps {
       }
       origin = order;
     }
-    return origin === undefined
-      ? undefined
-      : { origin, blockNumber: response.blockNumber };
+    return origin;
   }
 
   private validatedPartial({
@@ -270,9 +273,8 @@ export class OrderManager implements ScriptDeps {
     ckbOut,
     udtOut,
   }: Match["partials"][number]): Match["partials"][number] {
-    const validated = validatedOrderGroup(group);
-    const outPoint = validated.order.cell.outPoint.toHex();
-    if (!this.isOrder(validated.order.cell)) {
+    const outPoint = group.order.cell.outPoint.toHex();
+    if (!this.isOrder(group.order.cell)) {
       throw new Error(`Match order ${outPoint} does not match this order manager`);
     }
     if (ckbOut < 0n) {
@@ -281,22 +283,6 @@ export class OrderManager implements ScriptDeps {
     if (udtOut < 0n) {
       throw new Error(`Match order ${outPoint} has negative UDT output`);
     }
-    return { group: validated, ckbOut, udtOut };
+    return { group, ckbOut, udtOut };
   }
 }
-
-async function cachedTransactionResponse(
-  client: ccc.Client,
-  txHash: ccc.Hex,
-): Promise<TransactionResponse | undefined> {
-  // As CCC's own readers do, trust the cache only once the transaction is in a block: the
-  // cache also holds what CCC records at broadcast and what a lagging node answered, and a
-  // long-lived client would otherwise keep that answer for good.
-  const cached = await client.cache.getTransactionResponse(txHash);
-  if (cached?.blockNumber !== undefined) {
-    return cached;
-  }
-
-  // CCC's read records a found response in the cache itself.
-  return client.getTransaction(txHash);
-}

package/src/order/order_data.ts

@@ -59,6 +59,9 @@ export interface OrderData {
   validate(): void;
 }
 
+// An interface, this class expression and a typed const rather than one plain class: a
+// class extending `ccc.Entity.Base<...>()` emits an unexported `*_base` declaration, which
+// API Extractor's ae-forgotten-export rejects (tried 2026-10-30).
 // eslint-disable-next-line @typescript-eslint/no-shadow -- Preserve the runtime constructor name.
 const OrderDataImplementation = class OrderData extends OrderBase {
   static {

package/src/order/ratio.ts

@@ -23,8 +23,6 @@ export interface Ratio extends ExchangeRatio {
   clone(): Ratio;
   /** Compares effective CKB-to-UDT prices, returning their numeric ordering. */
   compare(other: Ratio): number;
-  /** Converts an amount in the selected direction, rounding up only when requested. */
-  convert(isCkb2Udt: boolean, amount: ccc.FixedPoint, mustCeil: boolean): ccc.FixedPoint;
   /** Returns whether another value has the same scales. */
   eq(other: ExchangeRatio): boolean;
   /** Returns the CKB hash of the serialized ratio. */
@@ -41,6 +39,9 @@ export interface Ratio extends ExchangeRatio {
   validate(): void;
 }
 
+// An interface, this class expression and a typed const rather than one plain class: a
+// class extending `ccc.Entity.Base<...>()` emits an unexported `*_base` declaration, which
+// API Extractor's ae-forgotten-export rejects (tried 2026-10-30).
 // eslint-disable-next-line @typescript-eslint/no-shadow -- Preserve the runtime constructor name.
 const RatioImplementation = class Ratio extends RatioBase {
   static {
@@ -111,24 +112,6 @@ const RatioImplementation = class Ratio extends RatioBase {
 
     return compareBigInt(this.ckbScale * other.udtScale, other.ckbScale * this.udtScale);
   }
-
-  /** Converts an amount in the requested direction with optional ceiling. */
-  public convert(
-    isCkb2Udt: boolean,
-    amount: ccc.FixedPoint,
-    mustCeil: boolean,
-  ): ccc.FixedPoint {
-    if (!this.isPopulated()) {
-      throw new Error("Invalid midpoint ExchangeRatio");
-    }
-
-    let { ckbScale: aScale, udtScale: bScale } = this;
-    if (!isCkb2Udt) {
-      [aScale, bScale] = [bScale, aScale];
-    }
-
-    return (amount * aScale + (mustCeil ? bScale - 1n : 0n)) / bScale;
-  }
 };
 
 /** CCC-backed ratio constructor and codec. */

package/src/order/relative.ts

@@ -43,6 +43,9 @@ export interface Relative {
   validate(): void;
 }
 
+// An interface, this class expression and a typed const rather than one plain class: a
+// class extending `ccc.Entity.Base<...>()` emits an unexported `*_base` declaration, which
+// API Extractor's ae-forgotten-export rejects (tried 2026-10-30).
 // eslint-disable-next-line @typescript-eslint/no-shadow -- Preserve the runtime constructor name.
 const RelativeImplementation = class Relative extends RelativeBase {
   static {