@ickb/sdk 9000.0.1 → 9001.0.0

package/src/owned_owner.ts

@@ -9,8 +9,12 @@ import {
 import type { IckbDepositCell } from "./logic.ts";
 import { ickbValue } from "./udt.ts";
 import { CheckedInt32LE, CheckedUint64LE } from "./utils/codec.ts";
-import { headersByNumber, transactionHeaders } from "./utils/transaction_header.ts";
-import type { ScriptDeps, TransactionHeader, ValueComponents } from "./utils/utils.ts";
+import {
+  headersByNumber,
+  type ScannedCell,
+  type ScriptDeps,
+  type ValueComponents,
+} from "./utils/utils.ts";
 
 /**
  * A live Nervos DAO withdrawal request cell, valued at the two headers it spans.
@@ -19,9 +23,7 @@ export interface DaoWithdrawalRequestCell {
   /** The DAO withdrawal request cell. */
   cell: ccc.Cell;
   /** The deposit header and the request's own header. */
-  headers: [TransactionHeader, TransactionHeader];
-  /** The DAO interest accrued between the two headers. */
-  interests: ccc.Num;
+  headers: [ccc.ClientBlockHeader, ccc.ClientBlockHeader];
   /** The DAO claim epoch of the request. */
   maturity: ccc.Epoch;
   /** Whether the claim epoch is at or before the tip: the request can be withdrawn. */
@@ -64,23 +66,15 @@ export function decodeOwnerData(outputData: ccc.Hex): OwnerData {
 /**
  * Wraps an owner marker cell that references an owned withdrawal request.
  */
-export class OwnerCell implements ValueComponents {
+export class OwnerCell {
   /** The live owner marker cell whose output data points to the owned request. */
   public cell: ccc.Cell;
 
-  /** Owner marker cells carry no UDT value. */
-  public readonly udtValue = 0n;
-
   /** Creates an owner marker wrapper for a live cell. */
   constructor(cell: ccc.Cell) {
     this.cell = cell;
   }
 
-  /** Returns the CKB capacity held by the owner marker cell. */
-  public get ckbValue(): ccc.FixedPoint {
-    return this.cell.cellOutput.capacity;
-  }
-
   /**
    * Returns the owned withdrawal request out point referenced by this owner marker.
    *
@@ -131,7 +125,7 @@ export class WithdrawalGroup implements ValueComponents {
 
   /** Returns the iCKB amount represented by the owned withdrawal request. */
   public get udtValue(): ccc.FixedPoint {
-    return ickbValue(this.owned.cell.capacityFree, this.owned.headers[0].header);
+    return ickbValue(this.owned.cell.capacityFree, this.owned.headers[0]);
   }
 }
 
@@ -180,8 +174,8 @@ export class OwnedOwnerManager implements ScriptDeps {
    * Spends the deposits into DAO withdrawal requests locked by the Owned Owner script,
    * each followed by an owner marker locked by `lock` that points back at it.
    *
-   * @remarks Caller must ensure UDT cellDeps are added to the transaction, for example
-   * via `ickbUdt.addCellDeps(tx)`.
+   * @remarks Completion (`IckbSdk.completeTransaction`) adds the dep group that also
+   * resolves the xUDT script.
    */
   public requestWithdrawal(
     txLike: ccc.TransactionLike,
@@ -202,21 +196,15 @@ export class OwnedOwnerManager implements ScriptDeps {
     tx.addCellDeps(this.cellDeps);
     tx.addCellDeps(this.dao.cellDeps);
     const requestStart = tx.outputs.length;
-    for (const { cell, headers } of deposits) {
-      const depositHeader = headers[0];
-      if (depositHeader.txHash !== cell.outPoint.txHash) {
-        throw new Error(
-          `DAO deposit ${cell.outPoint.toHex()} header txHash ${String(depositHeader.txHash)} does not match cell txHash ${cell.outPoint.txHash}`,
-        );
-      }
+    for (const { cell, header } of deposits) {
       if (cell.cellOutput.lock.args.length !== this.script.args.length) {
         throw new Error("Withdrawal request lock args has different size from deposit");
       }
-      pushHeaderDep(tx, depositHeader.header.hash);
+      pushHeaderDep(tx, header.hash);
       tx.addInput(cell);
       tx.addOutput(
         { capacity: cell.cellOutput.capacity, lock: this.script, type: this.dao.script },
-        CheckedUint64LE.encode(depositHeader.header.number),
+        CheckedUint64LE.encode(header.number),
       );
     }
     for (let index = 0; index < deposits.length; index += 1) {
@@ -256,12 +244,6 @@ export class OwnedOwnerManager implements ScriptDeps {
           `Withdrawal owner ${group.owner.cell.outPoint.toHex()} points to ${linkedOutPoint.toHex()} but group owned cell is ${ownedOutPoint.toHex()}`,
         );
       }
-      const { cell, headers } = group.owned;
-      if (headers[1].txHash !== cell.outPoint.txHash) {
-        throw new Error(
-          `DAO withdrawal request ${cell.outPoint.toHex()} header txHash ${String(headers[1].txHash)} does not match cell txHash ${cell.outPoint.txHash}`,
-        );
-      }
     }
     tx.addCellDeps(this.cellDeps);
     tx.addCellDeps(this.dao.cellDeps);
@@ -270,17 +252,17 @@ export class OwnedOwnerManager implements ScriptDeps {
     // pushed: the limit then counts these alone. Safe because nothing else in the stack reads
     // a header by position and every built transaction passes here once.
     const depositHashes = [
-      ...new Set(withdrawalGroups.map(({ owned }) => owned.headers[0].header.hash)),
+      ...new Set(withdrawalGroups.map(({ owned }) => owned.headers[0].hash)),
     ];
     tx.headerDeps = [
       ...depositHashes,
       ...tx.headerDeps.filter((hash) => !depositHashes.includes(hash)),
     ];
     for (const { owned } of withdrawalGroups) {
-      pushHeaderDep(tx, owned.headers[1].header.hash);
+      pushHeaderDep(tx, owned.headers[1].hash);
     }
     for (const { owned } of withdrawalGroups) {
-      const headerIndex = tx.headerDeps.indexOf(owned.headers[0].header.hash);
+      const headerIndex = tx.headerDeps.indexOf(owned.headers[0].hash);
       // The deployed dao.c reads one byte of the u64 index field (RFC 0023 erratum,
       // nervosnetwork/rfcs pull 456), so index 256 would be read as 0.
       if (headerIndex >= DAO_HEADER_INDEX_LIMIT) {
@@ -309,52 +291,45 @@ export class OwnedOwnerManager implements ScriptDeps {
 
   /**
    * The owner markers among `cells` paired with their owned withdrawal requests, which live
-   * in the marker's own transaction at the encoded distance. Markers whose target is not an
-   * owned withdrawal request are skipped. Each header is read once per batch.
+   * in the marker's own transaction at the encoded distance, so the marker's block is the
+   * request's. Markers whose target is not an owned withdrawal request are skipped. Each
+   * header is read once per batch.
    */
   public async withdrawalGroupsFrom(
     client: ccc.Client,
-    cells: readonly ccc.Cell[],
+    cells: readonly ScannedCell[],
     tip: ccc.ClientBlockHeader,
   ): Promise<WithdrawalGroup[]> {
     const owners = cells
-      .filter((cell) => this.isOwner(cell))
-      .map((cell) => new OwnerCell(cell));
+      .filter(({ cell }) => this.isOwner(cell))
+      .map(({ cell, blockNumber }) => ({ owner: new OwnerCell(cell), blockNumber }));
     const ownedCells = await Promise.all(
-      owners.map(async (owner) => client.getCell(owner.getOwned())),
+      owners.map(async ({ owner }) => client.getCell(owner.getOwned())),
     );
-    const pairs = owners.flatMap((owner, index) => {
+    const pairs = owners.flatMap(({ owner, blockNumber }, index) => {
       const owned = ownedCells[index];
       return owned !== undefined && this.isOwned(owned)
-        ? [{ owner, owned, depositBlockNumber: depositBlockNumberOf(owned) }]
+        ? [{ owner, owned, blockNumber, depositBlockNumber: depositBlockNumberOf(owned) }]
         : [];
     });
-    const [depositHeaders, requestHeaders] = await Promise.all([
-      headersByNumber(
-        client,
-        pairs.map((pair) => pair.depositBlockNumber),
-      ),
-      transactionHeaders(
-        client,
-        pairs.map((pair) => pair.owned.outPoint.txHash),
-      ),
-    ]);
-    return pairs.map(({ owner, owned, depositBlockNumber }) => {
-      const { txHash } = owned.outPoint;
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- both headers were read above.
-      const depositHeader = depositHeaders.get(depositBlockNumber)!;
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- both headers were read above.
-      const requestHeader = requestHeaders.get(txHash)!;
-      return new WithdrawalGroup(
-        withdrawalRequestCell(
-          owned,
-          depositHeader,
-          { header: requestHeader, txHash },
-          tip,
+    const headers = await headersByNumber(
+      client,
+      pairs.flatMap((pair) => [pair.depositBlockNumber, pair.blockNumber]),
+    );
+    return pairs.map(
+      ({ owner, owned, blockNumber, depositBlockNumber }) =>
+        new WithdrawalGroup(
+          withdrawalRequestCell(
+            owned,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- both headers were read above.
+            headers.get(depositBlockNumber)!,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- both headers were read above.
+            headers.get(blockNumber)!,
+            tip,
+          ),
+          owner,
         ),
-        owner,
-      );
-    });
+    );
   }
 }
 
@@ -362,19 +337,14 @@ export class OwnedOwnerManager implements ScriptDeps {
 export function withdrawalRequestCell(
   cell: ccc.Cell,
   depositHeader: ccc.ClientBlockHeader,
-  requestHeader: TransactionHeader,
+  requestHeader: ccc.ClientBlockHeader,
   tip: ccc.ClientBlockHeader,
 ): DaoWithdrawalRequestCell {
-  const interests = ccc.calcDaoProfit(
-    cell.capacityFree,
-    depositHeader,
-    requestHeader.header,
-  );
-  const maturity = ccc.calcDaoClaimEpoch(depositHeader, requestHeader.header);
+  const interests = ccc.calcDaoProfit(cell.capacityFree, depositHeader, requestHeader);
+  const maturity = ccc.calcDaoClaimEpoch(depositHeader, requestHeader);
   return {
     cell,
-    headers: [{ header: depositHeader }, requestHeader],
-    interests,
+    headers: [depositHeader, requestHeader],
     maturity,
     isReady: maturity.compare(tip.epoch) <= 0,
     ckbValue: cell.cellOutput.capacity + interests,

package/src/sdk.ts

@@ -17,52 +17,23 @@ import type {
 } from "./conversion/types.ts";
 import {
   assertDaoOutputLimit,
+  assertFresh,
   broadcastDeadline,
   DaoHeaderIndexError,
   DaoOutputLimitError,
   type LockUpPolicy,
+  pushHeaderDep,
+  tipMaxAgeMs,
 } from "./dao.ts";
 import type { IckbDepositCell, LogicManager } from "./logic.ts";
 import type { OrderGroup } from "./order/cells.ts";
 import type { OrderManager } from "./order/order.ts";
 import { Ratio } from "./order/ratio.ts";
 import type { OwnedOwnerManager } from "./owned_owner.ts";
-import { ickbExchangeRatio, type IckbUdt } from "./udt.ts";
+import { ickbExchangeRatio, type IckbUdt, type ProtocolCell } from "./udt.ts";
 import type { SupportedChain } from "./utils/chain.ts";
 import { compareBigInt, findCells, isPlainCapacityCell, unique } from "./utils/utils.ts";
-
-/**
- * The whole SDK, which the Node actors drive by relative import; the package barrel
- * exposes the two conversion-workflow methods, and its assignment checks they agree.
- */
-export interface IckbSdk {
-  /** Builds and completes a conversion, or returns a typed planning failure. */
-  buildConversionTransaction(
-    txLike: ccc.TransactionLike,
-    options: ConversionTransactionOptions,
-  ): Promise<ConversionTransactionResult>;
-  /** Reads system, user-order, and account state against one sampled tip, under one timing policy. */
-  getL1AccountState(
-    client: ccc.Client,
-    locks: ccc.Script[],
-    lockUp: LockUpPolicy,
-  ): Promise<{
-    system: SystemState;
-    user: { orders: OrderGroup[] };
-    account: AccountState;
-  }>;
-  /** Adds requested withdrawal, collection, receipt, and ready-withdrawal steps. */
-  buildBaseTransaction(
-    txLike: ccc.TransactionLike,
-    steps: CollectSteps,
-    withdrawalRequest?: { deposits: IckbDepositCell[]; lock: ccc.Script },
-  ): ccc.Transaction;
-  /** Completes iCKB inputs and fees without signing or sending the transaction. */
-  completeTransaction(
-    txLike: ccc.TransactionLike,
-    options: CompleteIckbTransactionOptions,
-  ): Promise<ccc.Transaction>;
-}
+import { verifiedClient } from "./utils/verified_client.ts";
 
 /**
  * Input count up to which one own transaction sweeps liquid cells.
@@ -80,13 +51,16 @@ export const SWEEP_INPUT_LIMIT = 1000;
 type ResolvedConversionOptions = ConversionTransactionOptions & { lock: ccc.Script };
 
 /** What every own transaction collects along: the context's collectable positions. */
-export type CollectSteps = Pick<
+type CollectSteps = Pick<
   ConversionTransactionContext,
   "availableOrders" | "receipts" | "readyWithdrawals"
 >;
 
-// eslint-disable-next-line @typescript-eslint/no-shadow -- Preserve the runtime constructor name.
-const IckbSdkImplementation = class IckbSdk {
+/**
+ * The whole SDK, which the Node actors drive by relative import; the package barrel
+ * exposes the two conversion-workflow methods, and its assignment checks they agree.
+ */
+export class IckbSdk {
   private readonly ickbUdt: IckbUdt;
   private readonly ownedOwner: OwnedOwnerManager;
   private readonly ickbLogic: LogicManager;
@@ -107,28 +81,49 @@ const IckbSdkImplementation = class IckbSdk {
   // ---- State reads -------------------------------------------------------------------
 
   /**
-   * Reads system, user-order, and account state against one sampled tip, under the
-   * caller's withdrawal timing rules (`BOT_LOCK_UP` or `WALLET_LOCK_UP`).
+   * Reads system, user-order, and account state at the sampled tip's parent, under the
+   * caller's withdrawal timing rules (`BOT_LOCK_UP` or `WALLET_LOCK_UP`) and, when given, a
+   * positive fee rate cap that replaces CCC's ceiling; a cap of zero or less throws.
    *
-   * @remarks Every read is complete and uncapped: a large book or pool costs a slower
-   * read, never a partial or failed one. Each account lock is enumerated by one uncached
-   * unfiltered exact-lock scan and classified client-side.
+   * @remarks Every read goes through `verifiedClient` and the tip's parent is bounded by the
+   * policy's slack, so a caller passes a plain client. Every read is complete and uncapped: a large
+   * book or pool costs a slower read, never a partial or failed one. Each account lock is
+   * enumerated by one uncached unfiltered exact-lock scan and classified client-side.
    */
   public async getL1AccountState(
-    client: ccc.Client,
+    plainClient: ccc.Client,
     locks: ccc.Script[],
     lockUp: LockUpPolicy,
+    maxFeeRate?: ccc.NumLike,
   ): Promise<{
     system: SystemState;
-    user: { orders: OrderGroup[] };
+    userOrders: OrderGroup[];
     account: AccountState;
   }> {
-    const tip = await client.getTipHeader();
+    // CCC reads a zero cap as no cap at all and would plan at a negative one.
+    if (maxFeeRate !== undefined && ccc.numFrom(maxFeeRate) <= ccc.Zero) {
+      throw new RangeError("maxFeeRate must be positive");
+    }
+    const client = verifiedClient(plainClient);
+    const live = await client.getTipHeader();
+    // The live tip can still lose a one-block race, and a transaction naming it as a header
+    // dep is then refused after signing; every recorded fork was one block deep.
+    const tip = await client.getHeaderByNumber(live.number - 1n);
+    if (tip?.hash !== live.parentHash) {
+      throw new Error(
+        `Block ${String(live.number - 1n)} is not the parent of tip ${live.hash}`,
+      );
+    }
+    // The age bound is on the header the read is priced at: a fresh tip a node invented can
+    // name any old block as its parent.
+    assertFresh(tip, tipMaxAgeMs(lockUp));
     const exchangeRatio = Ratio.from(ickbExchangeRatio(tip));
     const [poolDeposits, orders, feeRate, accounts] = await Promise.all([
       this.ickbLogic.findDeposits(client, tip),
       this.order.findOrders(client),
-      getFeeRate(client),
+      // CCC clamps the sampled median at the cap, the connector's chosen rate too. A given cap
+      // replaces CCC's default ceiling, on purpose: the caller's cap is the ceiling.
+      client.getFeeRate(undefined, maxFeeRate === undefined ? undefined : { maxFeeRate }),
       Promise.all(
         [...unique(locks)].map(async (lock) => this.readLockCells(client, lock, tip)),
       ),
@@ -144,7 +139,7 @@ const IckbSdkImplementation = class IckbSdk {
         poolDeposits,
         lockUp,
       },
-      user: { orders: orders.filter((group) => group.isOwner(...locks)) },
+      userOrders: orders.filter((group) => group.isOwner(...locks)),
       account: {
         capacityCells: accounts.flatMap((account) => account.capacityCells),
         nativeUdtCells: accounts.flatMap((account) => account.nativeUdtCells),
@@ -160,15 +155,16 @@ const IckbSdkImplementation = class IckbSdk {
     lock: ccc.Script,
     tip: ccc.ClientBlockHeader,
   ): Promise<AccountState> {
-    const cells = await findCells(client, {
+    const scanned = await findCells(client, {
       script: lock,
       scriptType: "lock",
       scriptSearchMode: "exact",
       withData: true,
     });
+    const cells = scanned.map(({ cell }) => cell);
     const [receipts, withdrawalGroups] = await Promise.all([
-      this.ickbLogic.receiptsFrom(client, cells),
-      this.ownedOwner.withdrawalGroupsFrom(client, cells, tip),
+      this.ickbLogic.receiptsFrom(client, scanned),
+      this.ownedOwner.withdrawalGroupsFrom(client, scanned, tip),
     ]);
     return {
       capacityCells: cells.filter(isPlainCapacityCell),
@@ -192,7 +188,6 @@ const IckbSdkImplementation = class IckbSdk {
    * expected planning outcomes; when no plan can be funded the last completion error throws.
    */
   public async buildConversionTransaction(
-    txLike: ccc.TransactionLike,
     options: ConversionTransactionOptions,
   ): Promise<ConversionTransactionResult> {
     const { amount, context, direction } = options;
@@ -206,25 +201,23 @@ const IckbSdkImplementation = class IckbSdk {
       return conversionFailure("insufficient-ickb", context.estimatedMaturity);
     }
 
-    const baseTx = ccc.Transaction.from(txLike);
     const resolved = {
       ...options,
       lock: options.lock ?? (await options.signer.getRecommendedAddressObj()).script,
     };
     if (amount === 0n) {
-      return this.buildCollectOnlyConversion(baseTx, resolved);
+      return this.buildCollectOnlyConversion(resolved);
     }
     return direction === "ckb-to-ickb"
-      ? this.buildCkbToIckbConversion(baseTx, resolved)
-      : this.buildIckbToCkbConversion(baseTx, resolved);
+      ? this.buildCkbToIckbConversion(resolved)
+      : this.buildIckbToCkbConversion(resolved);
   }
 
   private async buildCollectOnlyConversion(
-    baseTx: ccc.Transaction,
     options: ResolvedConversionOptions,
   ): Promise<ConversionTransactionResult> {
     const { context, lock, signer } = options;
-    const tx = this.buildBaseTransaction(baseTx, context);
+    const tx = this.buildBaseTransaction(ccc.Transaction.default(), context);
     // An empty collection to a lock of the signer's own would only compact the account;
     // to another lock it moves the liquid cells, which completion builds from the sweep.
     if (
@@ -238,29 +231,29 @@ const IckbSdkImplementation = class IckbSdk {
       ok: true,
       tx: completed,
       estimatedMaturity: context.estimatedMaturity,
-      conversion: { kind: "collect-only" },
+      conversionKind: "collect-only",
       isSweepComplete: sweepsAll(completed, context.cells),
     };
   }
 
   private async buildCkbToIckbConversion(
-    baseTx: ccc.Transaction,
     options: ResolvedConversionOptions,
   ): Promise<ConversionTransactionResult> {
     const { context, lock } = options;
     // A plan is dropped only for an unrepresentable remainder order.
     const plans = ckbToIckbConversionPlans(options);
     if (plans.length === 0) {
-      return conversionFailure(
-        "amount-too-small",
-        context.estimatedMaturity,
-        minimumOrderAmount(true, context.system),
-      );
+      return {
+        ok: false,
+        reason: "amount-too-small",
+        estimatedMaturity: context.estimatedMaturity,
+        minimum: minimumOrderAmount(true, context.system),
+      };
     }
     const { candidate: plan, tx } = await completeFirstFundable(
       plans,
       (candidate) => {
-        let partial = this.buildBaseTransaction(baseTx.clone(), context);
+        let partial = this.buildBaseTransaction(ccc.Transaction.default(), context);
         if (candidate.depositCount > 0) {
           partial = this.ickbLogic.deposit(
             partial,
@@ -285,30 +278,28 @@ const IckbSdkImplementation = class IckbSdk {
       ok: true,
       tx,
       estimatedMaturity: plan.estimatedMaturity,
-      conversion: {
-        kind: conversionKind(plan.depositCount > 0, plan.order !== undefined),
-      },
+      conversionKind: conversionKind(plan.depositCount > 0, plan.order !== undefined),
       isSweepComplete: sweepsAll(tx, context.cells),
     };
   }
 
   private async buildIckbToCkbConversion(
-    baseTx: ccc.Transaction,
     options: ResolvedConversionOptions,
   ): Promise<ConversionTransactionResult> {
     const { context, lock } = options;
     const plans = ickbToCkbConversionPlans(options, context.system.poolDeposits);
     if (plans.length === 0) {
-      return conversionFailure(
-        "amount-too-small",
-        context.estimatedMaturity,
-        minimumOrderAmount(false, context.system),
-      );
+      return {
+        ok: false,
+        reason: "amount-too-small",
+        estimatedMaturity: context.estimatedMaturity,
+        minimum: minimumOrderAmount(false, context.system),
+      };
     }
     const { candidate: plan, tx } = await completeFirstFundable(
       plans,
       (candidate) => {
-        let partial = this.buildBaseTransaction(baseTx.clone(), context, {
+        let partial = this.buildBaseTransaction(ccc.Transaction.default(), context, {
           deposits: candidate.selectedDeposits,
           lock,
         });
@@ -333,9 +324,10 @@ const IckbSdkImplementation = class IckbSdk {
       ok: true,
       tx,
       estimatedMaturity: plan.estimatedMaturity,
-      conversion: {
-        kind: conversionKind(plan.selectedDeposits.length > 0, plan.order !== undefined),
-      },
+      conversionKind: conversionKind(
+        plan.selectedDeposits.length > 0,
+        plan.order !== undefined,
+      ),
       ...(notice === undefined ? {} : { conversionNotice: notice }),
       isSweepComplete: sweepsAll(tx, context.cells),
       ...(broadcastBefore === undefined ? {} : { broadcastBefore }),
@@ -351,6 +343,11 @@ const IckbSdkImplementation = class IckbSdk {
       lock: options.lock,
       feeRate: options.context.system.feeRate,
       cells: options.context.cells,
+      protocolCells: [
+        ...options.context.receipts,
+        ...options.context.system.poolDeposits,
+      ],
+      tip: options.context.system.tip,
     });
   }
 
@@ -405,7 +402,8 @@ const IckbSdkImplementation = class IckbSdk {
     options: CompleteIckbTransactionOptions,
   ): Promise<ccc.Transaction> {
     const { signer, feeRate } = options;
-    const tx = this.ickbUdt.addCellDeps(ccc.Transaction.from(txLike).clone());
+    const tx = ccc.Transaction.from(txLike).clone();
+    tx.addCellDeps(this.ickbUdt.cellDeps);
     const changeLock = options.lock ?? (await signer.getRecommendedAddressObj()).script;
     // Inputs come from one state read, each cell once, and each action spends its own
     // cell kind, so a repeated out point is a builder bug: this is the one place that
@@ -428,9 +426,18 @@ const IckbSdkImplementation = class IckbSdk {
         compareBigInt(right.cellOutput.capacity, left.cellOutput.capacity),
       );
 
-    await this.completeIckb(tx, signer.client, changeLock, ickbCells);
+    await this.completeIckb(
+      tx,
+      signer.client,
+      changeLock,
+      ickbCells,
+      options.protocolCells,
+    );
     // Plain CKB: the sweep first, then whatever the fee still needs beyond the limit.
     const swept = sweep(tx, plainCells);
+    // Last of the header deps, so no index another step names shifts, and before the fee so
+    // its 32 bytes are paid for.
+    pushHeaderDep(tx, options.tip.hash);
     await completeFee(tx, signer, changeLock, feeRate, plainCells.slice(swept));
     assertDaoOutputLimit(tx, this.ickbLogic.dao.script);
     return tx;
@@ -442,9 +449,10 @@ const IckbSdkImplementation = class IckbSdk {
     client: ccc.Client,
     changeLock: ccc.Script,
     ickbCells: readonly ccc.Cell[],
+    protocolCells: readonly ProtocolCell[],
   ): Promise<void> {
-    const required = this.ickbUdt.outputBalance(tx);
-    let balance = await this.ickbUdt.inputBalance(tx, client);
+    const required = tx.getOutputsUdtBalance(this.ickbUdt.script);
+    let balance = await this.ickbUdt.inputBalance(tx, client, protocolCells);
     for (const cell of ickbCells) {
       if (balance >= required && tx.inputs.length >= SWEEP_INPUT_LIMIT) {
         break;
@@ -459,17 +467,10 @@ const IckbSdkImplementation = class IckbSdk {
     }
     this.ickbUdt.addChange(tx, changeLock, balance - required);
   }
-};
-
-/** Concrete iCKB SDK constructor and static estimators. */
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- The public type and runtime constructor intentionally share a name.
-export const IckbSdk: {
-  new (managers: SdkManagers): IckbSdk;
-  fromChain: (chain: SupportedChain) => IckbSdk;
-} = IckbSdkImplementation;
+}
 
 /** Whether the transaction already carries any input or output. */
-export function hasTransactionActivity(tx: ccc.Transaction): boolean {
+function hasTransactionActivity(tx: ccc.Transaction): boolean {
   return tx.inputs.length > 0 || tx.outputs.length > 0;
 }
 
@@ -484,16 +485,10 @@ function isPastPar(group: OrderGroup, exchangeRatio: Ratio): boolean {
 }
 
 function conversionFailure(
-  reason: ConversionTransactionFailureReason,
+  reason: Exclude<ConversionTransactionFailureReason, "amount-too-small">,
   estimatedMaturity: bigint,
-  minimum?: bigint,
 ): ConversionTransactionResult {
-  return {
-    ok: false,
-    reason,
-    estimatedMaturity,
-    ...(minimum === undefined ? {} : { minimum }),
-  };
+  return { ok: false, reason, estimatedMaturity };
 }
 
 /** A plan always carries a deposit or an order, else it would be a collection. */
@@ -517,14 +512,6 @@ async function isOwnLock(signer: ccc.Signer, lock: ccc.Script): Promise<boolean>
   return (await signer.getAddressObjs()).some(({ script }) => script.eq(lock));
 }
 
-async function getFeeRate(client: ccc.Client): Promise<ccc.Num> {
-  const feeRate = await client.getFeeRate();
-  if (feeRate < 0n) {
-    throw new Error("Client fee rate must be non-negative");
-  }
-  return feeRate;
-}
-
 function udtBalance(cell: ccc.Cell): ccc.Num {
   return ccc.udtBalanceFrom(cell.outputData);
 }
@@ -569,7 +556,7 @@ async function completeFee(
   }
 }
 
-/** Stable machine-readable failures owned by the Phase-2 SDK. */
+/** Stable machine-readable SDK failures. */
 export type IckbErrorCode = "insufficient_capacity" | "insufficient_ickb";
 
 /** Typed SDK failure with a stable machine-readable code. */