@ickb/sdk 9000.0.1 → 9001.0.0

package/src/conversion/plans.ts

@@ -1,7 +1,7 @@
+import { ccc } from "@ckb-ccc/core";
 import { DAO_OUTPUT_LIMIT } from "../dao.ts";
 import { readyDeposits, type IckbDepositCell } from "../logic.ts";
-import { ICKB_DEPOSIT_CAP, convert } from "../udt.ts";
-import { maxBigInt } from "../utils/utils.ts";
+import { ICKB_DEPOSIT_CAP, ckbFromUdt } from "../udt.ts";
 import {
   DEFAULT_ORDER_FEE,
   DEFAULT_ORDER_FEE_BASE,
@@ -37,7 +37,7 @@ export function ckbToIckbConversionPlans(
   options: ConversionTransactionOptions,
 ): CkbToIckbConversionPlan[] {
   const { amount, context } = options;
-  const depositCapacity = convert(false, ICKB_DEPOSIT_CAP, context.system.exchangeRatio);
+  const depositCapacity = ckbFromUdt(ICKB_DEPOSIT_CAP, context.system.exchangeRatio);
   const depositQuotient = depositCapacity === 0n ? 0n : amount / depositCapacity;
   const maxDeposits =
     depositQuotient > BigInt(MAX_PLANNED_DEPOSITS)
@@ -98,7 +98,7 @@ function ckbToIckbConversionPlan(
     if (estimate?.maturity === undefined) {
       return undefined;
     }
-    estimatedMaturity = maxBigInt(estimatedMaturity, estimate.maturity);
+    estimatedMaturity = ccc.numMax(estimatedMaturity, estimate.maturity);
     order = { amounts, estimate };
   }
 
@@ -118,7 +118,7 @@ function ickbToCkbConversionPlan(
   let estimatedMaturity = context.estimatedMaturity;
   // Selected deposits are ready, so their sampled claim is their date.
   for (const deposit of selectedDeposits) {
-    estimatedMaturity = maxBigInt(
+    estimatedMaturity = ccc.numMax(
       estimatedMaturity,
       deposit.claimEpoch.toUnix(context.system.tip),
     );
@@ -132,7 +132,7 @@ function ickbToCkbConversionPlan(
     if (estimate === undefined) {
       return undefined;
     }
-    estimatedMaturity = maxBigInt(estimatedMaturity, estimate.maturity);
+    estimatedMaturity = ccc.numMax(estimatedMaturity, estimate.maturity);
     order = { amounts, estimate };
   }
 

package/src/conversion/projection.ts

@@ -1,8 +1,8 @@
 import { ccc } from "@ckb-ccc/core";
 import { DAO_HEADER_INDEX_LIMIT } from "../dao.ts";
 import type { OrderGroup } from "../order/cells.ts";
+import { isRefused, isStale } from "../order/fill.ts";
 import type { WithdrawalGroup } from "../owned_owner.ts";
-import { maxBigInt } from "../utils/utils.ts";
 import { maturity } from "./maturity.ts";
 import type {
   AccountAvailabilityProjection,
@@ -13,21 +13,29 @@ import type {
 
 /**
  * Builds the conversion planner context from account state and the caller's own orders,
- * split by what it will melt: `available` orders are collected and budgeted as account
- * value, `pending` ones stay on the book.
+ * split by what it will melt: fulfilled orders, buys the bot's whole-fill rule refuses,
+ * and orders past the age cutoff are collected and budgeted as account value; the rest
+ * stay on the book. DAO growth can make a waiting sell profitable later, so a sell waits
+ * for the age cutoff even when the bot would not fill it today.
  */
 export function projectConversionTransactionContext(
   system: SystemState,
   account: AccountState,
-  orders: { available: OrderGroup[]; pending: OrderGroup[] },
+  orders: readonly OrderGroup[],
 ): ConversionTransactionContextProjection {
-  const projection = projectAccountAvailability(account, orders);
-  const estimatedMaturity = [
+  const collectable = (group: OrderGroup): boolean =>
+    group.order.isFulfilled() || isRefused(group, system) || isStale(group, system.tip);
+  const projection = projectAccountAvailability(account, {
+    available: orders.filter(collectable),
+    pending: orders.filter((group) => !collectable(group)),
+  });
+  const estimatedMaturity = ccc.numMax(
+    system.tip.timestamp,
     ...projection.pendingWithdrawals.map((group) =>
       group.owned.maturity.toUnix(system.tip),
     ),
     ...projection.pendingOrders.map((group) => maturity(group.order, system)),
-  ].reduce(maxBigInt, system.tip.timestamp);
+  );
 
   return {
     projection,

package/src/conversion/types.ts

@@ -1,12 +1,12 @@
 import type { ccc } from "@ckb-ccc/core";
-import type { LockUpPolicy } from "../dao.ts";
+import type { BroadcastDeadline, LockUpPolicy } from "../dao.ts";
 import type { IckbDepositCell, LogicManager, ReceiptCell } from "../logic.ts";
 import type { OrderCell, OrderGroup } from "../order/cells.ts";
 import type { Info } from "../order/info.ts";
 import type { OrderManager } from "../order/order.ts";
 import type { Ratio } from "../order/ratio.ts";
 import type { OwnedOwnerManager, WithdrawalGroup } from "../owned_owner.ts";
-import type { IckbUdt } from "../udt.ts";
+import type { IckbUdt, ProtocolCell } from "../udt.ts";
 import type { ValueComponents } from "../utils/utils.ts";
 
 /**
@@ -88,13 +88,8 @@ export interface ConversionNotice {
   incentiveCkb: bigint;
 }
 
-/**
- * High-level conversion composition used by a built transaction.
- */
-export interface ConversionMetadata {
-  /** Composition category selected for the built conversion. */
-  kind: "direct" | "order" | "direct-plus-order" | "collect-only";
-}
+/** Composition category selected for a built conversion. */
+export type ConversionKind = "direct" | "order" | "direct-plus-order" | "collect-only";
 
 /**
  * Result of attempting to build a conversion transaction.
@@ -107,7 +102,7 @@ export type ConversionTransactionResult =
       /** Estimated maturity timestamp for the conversion result. */
       estimatedMaturity: bigint;
       /** Composition of the selected conversion path. */
-      conversion: ConversionMetadata;
+      conversionKind: ConversionKind;
       /** Optional notice about the selected path. */
       conversionNotice?: ConversionNotice;
       /**
@@ -119,19 +114,25 @@ export type ConversionTransactionResult =
        * The epoch the transaction must be broadcast before for its withdrawal requests to
        * claim at their sampled dates (`system.lockUp`); absent when it requests none.
        */
-      broadcastBefore?: ccc.Epoch;
+      broadcastBefore?: BroadcastDeadline;
     }
   | {
       ok: false;
-      /** Machine-readable failure reason. */
-      reason: ConversionTransactionFailureReason;
+      reason: "amount-too-small";
       /** Best available maturity estimate from the input context. */
       estimatedMaturity: bigint;
       /**
-       * For `amount-too-small`: the smallest amount this direction accepts at the current fee
-       * rate, in the request's unit (CKB shannons or iCKB), so a caller can name it.
+       * The smallest amount this direction accepts at the current fee rate, in the
+       * request's unit (CKB shannons or iCKB), so a caller can name it.
        */
-      minimum?: bigint;
+      minimum: bigint;
+    }
+  | {
+      ok: false;
+      /** Machine-readable failure reason. */
+      reason: Exclude<ConversionTransactionFailureReason, "amount-too-small">;
+      /** Best available maturity estimate from the input context. */
+      estimatedMaturity: bigint;
     };
 
 /**
@@ -149,6 +150,20 @@ export interface CompleteIckbTransactionOptions {
 
   /** The signer's known liquid cells, plain CKB and iCKB, from the account state already read. */
   cells: ccc.Cell[];
+
+  /**
+   * The receipts and iCKB deposits the transaction may spend, valued by the state read;
+   * any superset works, since only the spent ones are summed.
+   */
+  protocolCells: readonly ProtocolCell[];
+
+  /**
+   * The header the plan was priced at, the state read's `system.tip`, named as a header
+   * dep: the chain refuses a transaction whose deps are off the main chain, so a header a
+   * node invented, whose DAO rate set the exchange ratio, cannot price an accepted
+   * transaction.
+   */
+  tip: ccc.ClientBlockHeader;
 }
 
 /**
@@ -244,7 +259,7 @@ export interface ConversionTransactionContextProjection {
 export interface SystemState {
   /** The fee rate for transactions. */
   feeRate: ccc.Num;
-  /** Sampled tip used for this L1 scan. It may be stale after scans complete. */
+  /** The sampled tip's parent, this L1 scan's anchor. It may be stale after scans complete. */
   tip: ccc.ClientBlockHeader;
   /** The exchange ratio between CKB and UDT. */
   exchangeRatio: Ratio;

package/src/conversion/withdrawal_ring.ts

@@ -1,5 +1,5 @@
-import type { ccc } from "@ckb-ccc/core";
-import { DAO_CYCLE_EPOCHS, DAO_OUTPUT_LIMIT } from "../dao.ts";
+import { ccc } from "@ckb-ccc/core";
+import { DAO_OUTPUT_LIMIT } from "../dao.ts";
 import type { IckbDepositCell } from "../logic.ts";
 import { ICKB_DEPOSIT_CAP } from "../udt.ts";
 
@@ -7,9 +7,6 @@ import { ICKB_DEPOSIT_CAP } from "../udt.ts";
  * Ring segment of pool deposits grouped by maturity around the DAO cycle.
  */
 export interface RingSegment {
-  /** Segment index in the ring. */
-  index: number;
-
   /** Deposits assigned to this segment. */
   deposits: IckbDepositCell[];
 
@@ -29,8 +26,7 @@ export function ringSegments(poolDeposits: readonly IckbDepositCell[]): RingSegm
   while (BigInt(segmentCount) * 2n * ICKB_DEPOSIT_CAP < totalUdt) {
     segmentCount *= 2;
   }
-  const segments = Array.from({ length: segmentCount }, (_, index): RingSegment => ({
-    index,
+  const segments = Array.from({ length: segmentCount }, (): RingSegment => ({
     deposits: [],
     udtValue: 0n,
   }));
@@ -53,7 +49,7 @@ export function ringSegmentIndex(epoch: ccc.Epoch, segmentCount: number): number
     throw new Error("Epoch denominator must be positive");
   }
   const scaled = epoch.integer * denominator + epoch.numerator;
-  const ring = DAO_CYCLE_EPOCHS * denominator;
+  const ring = ccc.Epoch.OneNervosDaoCycle.integer * denominator;
   const wrapped = ((scaled % ring) + ring) % ring;
   return Number((wrapped * BigInt(segmentCount)) / ring);
 }

package/src/dao.ts

@@ -1,5 +1,4 @@
 import { ccc } from "@ckb-ccc/core";
-import { CheckedUint64LE } from "./utils/codec.ts";
 
 /**
  * Maximum outputs accepted by deployed dao.c, not a general CKB consensus cap.
@@ -15,9 +14,6 @@ export const DAO_OUTPUT_LIMIT = 64;
  */
 export const DAO_HEADER_INDEX_LIMIT = 256;
 
-/** One DAO cycle, the lock-up a deposit renews by when it is not withdrawn. */
-export const DAO_CYCLE_EPOCHS = 180n;
-
 /**
  * Error thrown when a transaction exceeds the deployed DAO script's output limit.
  */
@@ -76,15 +72,13 @@ export function assertDaoOutputLimit(
   }
 }
 
-/** The canonical DAO deposit data payload. */
-export function depositData(): ccc.Hex {
-  return ccc.hexFrom(CheckedUint64LE.encode(0n));
-}
+/** The canonical DAO deposit data payload: a zero Uint64, eight zero bytes. */
+export const DAO_DEPOSIT_DATA: ccc.Hex = "0x0000000000000000";
 
 /** Whether the cell is a DAO deposit of the given DAO script. */
 export function isDaoDeposit(cell: ccc.CellAny, daoScript: ccc.Script): boolean {
   return (
-    cell.outputData === depositData() && cell.cellOutput.type?.eq(daoScript) === true
+    cell.outputData === DAO_DEPOSIT_DATA && cell.cellOutput.type?.eq(daoScript) === true
   );
 }
 
@@ -97,7 +91,7 @@ export function isDaoWithdrawalRequest(
   daoScript: ccc.Script,
 ): boolean {
   return (
-    cell.outputData !== depositData() && cell.cellOutput.type?.eq(daoScript) === true
+    cell.outputData !== DAO_DEPOSIT_DATA && cell.cellOutput.type?.eq(daoScript) === true
   );
 }
 
@@ -136,6 +130,25 @@ export const WALLET_LOCK_UP: LockUpPolicy = {
   broadcastReserve: ccc.Epoch.from([0n, 3n, 8n]),
 };
 
+/**
+ * How far a tip may trail the local clock under a policy: the selection margin less the
+ * broadcast reserve, the slack a stale tip would eat before a request commits after its
+ * claim. Five minutes for the bot, thirty for a wallet.
+ */
+export function tipMaxAgeMs(policy: LockUpPolicy): number {
+  // The span from the reserve to the margin, on CCC's nominal four-hour epoch.
+  return Number(
+    policy.minLockUp.toUnix({ epoch: policy.broadcastReserve, timestamp: 0n }),
+  );
+}
+
+/** Throws when `header` trails the local clock by more than `maxAgeMs`. */
+export function assertFresh(header: ccc.ClientBlockHeader, maxAgeMs: number): void {
+  if (BigInt(Date.now()) - header.timestamp > BigInt(maxAgeMs)) {
+    throw new Error(`Block ${header.hash} is more than ${String(maxAgeMs)} ms old`);
+  }
+}
+
 /** A deposit's maturity, rolled a cycle when its claim is too close, and whether it is ready. */
 export function depositMaturity(
   claim: ccc.Epoch,
@@ -144,7 +157,7 @@ export function depositMaturity(
 ): { maturity: ccc.Epoch; isReady: boolean } {
   const maturity =
     claim.compare(minLockUp.add(tip.epoch)) <= 0
-      ? claim.add([DAO_CYCLE_EPOCHS, 0n, 1n])
+      ? claim.add(ccc.Epoch.OneNervosDaoCycle)
       : claim;
   return { maturity, isReady: maxLockUp.add(tip.epoch).compare(maturity) > 0 };
 }
@@ -155,13 +168,24 @@ export function depositMaturity(
  */
 export function broadcastDeadline(
   claims: readonly ccc.Epoch[],
-  { broadcastReserve }: LockUpPolicy,
-): ccc.Epoch | undefined {
+  policy: LockUpPolicy,
+): BroadcastDeadline | undefined {
   const earliest = claims.reduce<ccc.Epoch | undefined>(
     (best, claim) => (best === undefined || claim.compare(best) < 0 ? claim : best),
     undefined,
   );
-  return earliest?.sub(broadcastReserve);
+  return earliest === undefined
+    ? undefined
+    : { epoch: earliest.sub(policy.broadcastReserve), tipMaxAgeMs: tipMaxAgeMs(policy) };
+}
+
+/**
+ * The epoch a withdrawal request must be broadcast before, and how far the tip read to
+ * check it may trail the clock, the policy's slack: a stale tip would pass the check late.
+ */
+export interface BroadcastDeadline {
+  epoch: ccc.Epoch;
+  tipMaxAgeMs: number;
 }
 
 /** Adds the header dep once. */

package/src/index.ts

@@ -21,17 +21,17 @@ import type { SupportedChain } from "./utils/chain.ts";
 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. */
+  /** Reads system, user-order, and account state at the sampled tip's parent, under one timing policy. */
   getL1AccountState: (
     client: ccc.Client,
     locks: ccc.Script[],
     lockUp: LockUpPolicy,
+    maxFeeRate?: ccc.NumLike,
   ) => Promise<{
     system: SystemState;
-    user: { orders: OrderGroup[] };
+    userOrders: OrderGroup[];
     account: AccountState;
   }>;
 }
@@ -46,7 +46,7 @@ export type {
   AccountAvailabilityProjection,
   AccountState,
   ConversionDirection,
-  ConversionMetadata,
+  ConversionKind,
   ConversionNotice,
   ConversionTransactionContext,
   ConversionTransactionContextProjection,
@@ -56,14 +56,13 @@ export type {
   SystemState,
 } from "./conversion/types.ts";
 export { WALLET_LOCK_UP } from "./dao.ts";
-export type { LockUpPolicy } from "./dao.ts";
+export type { BroadcastDeadline, LockUpPolicy } from "./dao.ts";
 export type { IckbDepositCell, ReceiptCell } from "./logic.ts";
 export type { MasterCell, OrderCell, OrderGroup } from "./order/cells.ts";
 export {
   OrderConversionRepresentabilityError,
   quoteConversion,
 } from "./order/conversion.ts";
-export { isRefused, isStale } from "./order/fill.ts";
 export type { Info, InfoLike } from "./order/info.ts";
 export type { Master, MasterLike } from "./order/master.ts";
 export type { OrderData, OrderDataLike } from "./order/order_data.ts";
@@ -74,7 +73,7 @@ export type {
   OwnerCell,
   WithdrawalGroup,
 } from "./owned_owner.ts";
-export { hasTransactionActivity, IckbError } from "./sdk.ts";
+export { IckbError } from "./sdk.ts";
 export type { IckbErrorCode } from "./sdk.ts";
 export {
   signAndSendTransaction,
@@ -86,4 +85,5 @@ export { TransactionWaitError, waitTransaction } from "./send/wait_transaction.t
 export type { WaitTransactionOptions } from "./send/wait_transaction.ts";
 export { ickbExchangeRatio } from "./udt.ts";
 export type { SupportedChain } from "./utils/chain.ts";
-export type { ExchangeRatio, TransactionHeader, ValueComponents } from "./utils/utils.ts";
+export { clientCache } from "./utils/utils.ts";
+export type { ExchangeRatio, ValueComponents } from "./utils/utils.ts";

package/src/logic.ts

@@ -1,8 +1,8 @@
 import { ccc } from "@ckb-ccc/core";
 import {
   assertDaoOutputLimit,
+  DAO_DEPOSIT_DATA,
   DaoOutputLimitError,
-  depositData,
   depositMaturity,
   isDaoDeposit,
   pushHeaderDep,
@@ -16,11 +16,11 @@ import {
   receiptDataBytes,
   type ReceiptData,
 } from "./udt.ts";
-import { transactionHeaders } from "./utils/transaction_header.ts";
 import {
   findCells,
+  headersByNumber,
+  type ScannedCell,
   type ScriptDeps,
-  type TransactionHeader,
   type ValueComponents,
 } from "./utils/utils.ts";
 
@@ -36,10 +36,8 @@ const phase2TxFeeReserve = ccc.One;
 export interface IckbDepositCell extends ValueComponents {
   /** The DAO deposit cell. */
   cell: ccc.Cell;
-  /** The deposit header and the tip the readiness was judged against. */
-  headers: [TransactionHeader, TransactionHeader];
-  /** The DAO interest accrued between the two headers. */
-  interests: ccc.Num;
+  /** The header of the block that committed the deposit, which values it. */
+  header: ccc.ClientBlockHeader;
   /**
    * The DAO claim epoch as sampled at the tip, not rolled: each reader judges it against
    * its own {@link LockUpPolicy} with `depositMaturity`.
@@ -53,8 +51,8 @@ export interface IckbDepositCell extends ValueComponents {
 export interface ReceiptCell extends ValueComponents {
   /** The cell associated with the receipt. */
   cell: ccc.Cell;
-  /** The header of the transaction that made the deposits. */
-  header: TransactionHeader;
+  /** The header of the block that committed the deposits, which values them. */
+  header: ccc.ClientBlockHeader;
 }
 
 /**
@@ -94,8 +92,8 @@ export class LogicManager implements ScriptDeps {
    * Adds `depositQuantity` DAO deposits of `depositCapacity` locked by the logic script,
    * then the receipt that mints their iCKB in phase 2, locked by `lock`.
    *
-   * @remarks Caller must ensure UDT cellDeps are added to the transaction
-   * (e.g., via ickbUdt.addCellDeps(tx)).
+   * @remarks Completion (`IckbSdk.completeTransaction`) adds the dep group that also
+   * resolves the xUDT script.
    */
   public deposit(
     txLike: ccc.TransactionLike,
@@ -103,13 +101,11 @@ export class LogicManager implements ScriptDeps {
     depositCapacity: ccc.FixedPoint,
     lock: ccc.Script,
   ): ccc.Transaction {
-    const tx = ccc.Transaction.from(txLike);
-    if (depositQuantity <= 0) {
-      return tx;
-    }
-    if (!Number.isSafeInteger(depositQuantity)) {
-      throw new TypeError("iCKB deposit quantity must be a safe integer");
+    // A zero quantity would mint a receipt for no deposits, which iCKB Logic refuses on chain.
+    if (!Number.isSafeInteger(depositQuantity) || depositQuantity <= 0) {
+      throw new TypeError("iCKB deposit quantity must be a positive safe integer");
     }
+    const tx = ccc.Transaction.from(txLike);
     if (depositQuantity > maxDepositQuantity) {
       // The completion walk steps a plan down on this error.
       throw new DaoOutputLimitError(tx.outputs.length + depositQuantity + 1);
@@ -118,7 +114,7 @@ export class LogicManager implements ScriptDeps {
     const depositCell = ccc.Cell.from({
       previousOutput: { txHash: `0x${"00".repeat(32)}`, index: 0 },
       cellOutput: { capacity: depositCapacity, lock: this.script, type: this.dao.script },
-      outputData: depositData(),
+      outputData: DAO_DEPOSIT_DATA,
     });
     const depositAmount = depositCell.capacityFree;
     if (depositAmount < ccc.fixedPointFrom(1000)) {
@@ -167,15 +163,10 @@ export class LogicManager implements ScriptDeps {
           `Receipt ${outPoint} is not an iCKB receipt for this logic script`,
         );
       }
-      if (receipt.header.txHash !== receipt.cell.outPoint.txHash) {
-        throw new Error(
-          `Receipt ${outPoint} header txHash ${String(receipt.header.txHash)} does not match cell txHash ${receipt.cell.outPoint.txHash}`,
-        );
-      }
     }
     tx.addCellDeps(this.cellDeps);
     for (const receipt of receipts) {
-      pushHeaderDep(tx, receipt.header.header.hash);
+      pushHeaderDep(tx, receipt.header.hash);
       tx.addInput(receipt.cell);
     }
     return tx;
@@ -186,23 +177,22 @@ export class LogicManager implements ScriptDeps {
    */
   public async receiptsFrom(
     client: ccc.Client,
-    cells: readonly ccc.Cell[],
+    cells: readonly ScannedCell[],
   ): Promise<ReceiptCell[]> {
-    const receipts = cells.filter((cell) => this.isReceipt(cell));
-    const headers = await transactionHeaders(
+    const receipts = cells.filter(({ cell }) => this.isReceipt(cell));
+    const headers = await headersByNumber(
       client,
-      receipts.map((cell) => cell.outPoint.txHash),
+      receipts.map(({ blockNumber }) => blockNumber),
+    );
+    return receipts.map(({ cell, blockNumber }) =>
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every receipt's block was read above.
+      receiptCell(cell, headers.get(blockNumber)!),
     );
-    return receipts.map((cell) => {
-      const { txHash } = cell.outPoint;
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every receipt's hash was read above.
-      return receiptCell(cell, { header: headers.get(txHash)!, txHash });
-    });
   }
 
   /**
    * Every live iCKB deposit, valued at its deposit header, with its claim epoch at the tip;
-   * each deposit transaction's header is read once.
+   * each deposit block's header is read once.
    */
   public async findDeposits(
     client: ccc.Client,
@@ -214,39 +204,37 @@ export class LogicManager implements ScriptDeps {
         scriptType: "lock",
         filter: {
           script: this.dao.script,
-          outputData: depositData(),
+          outputData: DAO_DEPOSIT_DATA,
           outputDataSearchMode: "exact",
         },
         scriptSearchMode: "exact",
         withData: true,
       })
-    ).filter((cell) => this.isDeposit(cell));
-    const headers = await transactionHeaders(
+    ).filter(({ cell }) => this.isDeposit(cell));
+    const headers = await headersByNumber(
       client,
-      cells.map((cell) => cell.outPoint.txHash),
+      cells.map(({ blockNumber }) => blockNumber),
+    );
+    return cells.map(({ cell, blockNumber }) =>
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every deposit's block was read above.
+      ickbDepositCell(cell, headers.get(blockNumber)!, tip),
     );
-    return cells.map((cell) => {
-      const { txHash } = cell.outPoint;
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every deposit's hash was read above.
-      return ickbDepositCell(cell, { header: headers.get(txHash)!, txHash }, tip);
-    });
   }
 }
 
 /** Values a DAO deposit cell at its deposit header and samples its claim epoch at the tip. */
-export function ickbDepositCell(
+function ickbDepositCell(
   cell: ccc.Cell,
-  depositHeader: TransactionHeader,
+  header: ccc.ClientBlockHeader,
   tip: ccc.ClientBlockHeader,
 ): IckbDepositCell {
-  const interests = ccc.calcDaoProfit(cell.capacityFree, depositHeader.header, tip);
+  const interests = ccc.calcDaoProfit(cell.capacityFree, header, tip);
   return {
     cell,
-    headers: [depositHeader, { header: tip }],
-    interests,
-    claimEpoch: ccc.calcDaoClaimEpoch(depositHeader.header, tip),
+    header,
+    claimEpoch: ccc.calcDaoClaimEpoch(header, tip),
     ckbValue: cell.cellOutput.capacity + interests,
-    udtValue: ickbValue(cell.capacityFree, depositHeader.header),
+    udtValue: ickbValue(cell.capacityFree, header),
   };
 }
 
@@ -262,7 +250,7 @@ export function readyDeposits(
 }
 
 /** Decodes a receipt cell and values it at its deposit header. */
-export function receiptCell(cell: ccc.Cell, header: TransactionHeader): ReceiptCell {
+export function receiptCell(cell: ccc.Cell, header: ccc.ClientBlockHeader): ReceiptCell {
   let receipt: ReceiptData;
   try {
     receipt = decodeReceiptData(cell.outputData);
@@ -276,7 +264,7 @@ export function receiptCell(cell: ccc.Cell, header: TransactionHeader): ReceiptC
     cell,
     header,
     ckbValue: cell.cellOutput.capacity,
-    udtValue: ickbValue(receipt.depositAmount, header.header) * receipt.depositQuantity,
+    udtValue: ickbValue(receipt.depositAmount, header) * receipt.depositQuantity,
   };
 }