@ickb/sdk 1000.0.26 → 1000.0.43

package/src/index.ts

@@ -1,6 +1,6 @@
-import { ccc, type Epoch } from "@ckb-ccc/core";
+import { ccc } from "@ckb-ccc/core";
 import {
-  arrayFrom,
+  collect,
   epochCompare,
   CapacityManager,
   SmartTransaction,
@@ -8,34 +8,36 @@ import {
   type UdtCell,
   type CapacityCell,
   epochAdd,
-  type SmartTransactionLike,
+  asyncBinarySearch,
+  RestrictedTransaction,
+  type ExchangeRatio,
 } from "@ickb/utils";
 import {
   convert,
   ICKB_DEPOSIT_CAP,
   ickbExchangeRatio,
-  IckbManager,
+  IckbUdtManager,
   LogicManager,
   OwnedOwnerManager,
   type IckbDepositCell,
   type ReceiptCell,
-  type WithdrawalGroups,
+  type WithdrawalGroup,
 } from "@ickb/core";
-import { DaoManager } from "@ickb/dao";
+import { DaoManager, type DaoCell } from "@ickb/dao";
 import {
   Info,
   OrderManager,
-  Ratio,
   type OrderCell,
   type OrderGroup,
 } from "@ickb/order";
 
 export class IckbController {
   constructor(
-    public ickbManager: IckbManager,
-    public logicManager: LogicManager,
-    public ownedOwnerManager: OwnedOwnerManager,
-    public orderManager: OrderManager,
+    public readonly ickbUdtManager: IckbUdtManager,
+    public readonly logicManager: LogicManager,
+    public readonly ownedOwnerManager: OwnedOwnerManager,
+    public readonly orderManager: OrderManager,
+    public readonly daoManager: DaoManager,
   ) {}
 
   static fromDeps({
@@ -65,190 +67,205 @@ export class IckbController {
       ),
       cellDeps,
     };
-    const ickbManager = IckbManager.fromDeps(ickbXudt, daoManager);
+    const ickbUdtManager = IckbUdtManager.fromDeps(ickbXudt, daoManager);
 
     return new IckbController(
-      ickbManager,
-      LogicManager.fromDeps(ickbLogic, daoManager, ickbManager),
-      OwnedOwnerManager.fromDeps(ownedOwner, daoManager, ickbManager),
-      OrderManager.fromDeps(order, ickbManager),
+      ickbUdtManager,
+      LogicManager.fromDeps(ickbLogic, daoManager, ickbUdtManager),
+      OwnedOwnerManager.fromDeps(ownedOwner, daoManager, ickbUdtManager),
+      OrderManager.fromDeps(order, ickbUdtManager),
+      daoManager,
     );
   }
 
-  previewConversion(
-    isCkb2Udt: boolean,
-    amount: ccc.FixedPoint,
-    options: ({ ratio: Ratio } | { tip: ccc.ClientBlockHeader }) & {
-      fee?: {
-        numerator: ccc.Num;
-        denominator: ccc.Num;
+  // fee examples:
+  // 100000n => 0.001%
+  // 10000n => 0.01%
+  // 1000n => 0.1%
+  // 100n => 1%
+  // 10n => 10%
+  // 1n => 100%
+  // less than 1n => 0%
+  static previewConversion(conversion: {
+    isCkb2Udt: boolean;
+    amount: ccc.FixedPoint;
+    rate: ExchangeRatio | ccc.ClientBlockHeader;
+    fee: ccc.Num;
+  }): { rate: ExchangeRatio; convertedAmount: ccc.FixedPoint } {
+    const { isCkb2Udt, amount, fee } = conversion;
+    let rate = conversion.rate;
+    rate = "dao" in rate ? ickbExchangeRatio(rate) : rate;
+
+    if (fee > ccc.Zero) {
+      const { ckbScale, udtScale } = rate;
+      rate = {
+        ckbScale,
+        // Worst case scenario where fee applies to the full amount
+        udtScale: udtScale + (isCkb2Udt ? 1n : -1n) * (udtScale / fee),
       };
-    },
-  ): ccc.FixedPoint {
-    // TODO: make compatible with logic.convert(isCkb2Udt, amount, options)!!!
-
-    const { ckbScale, udtScale } =
-      "ratio" in options ? options.ratio : ickbExchangeRatio(options.tip);
-
-    let convertedAmount = isCkb2Udt
-      ? (amount * ckbScale) / udtScale
-      : (amount * udtScale) / ckbScale;
-
-    if (options.fee) {
-      const { numerator, denominator } = options.fee;
-      convertedAmount -= (convertedAmount * numerator) / denominator;
     }
 
-    return convertedAmount;
+    const convertedAmount =
+      amount > ccc.Zero ? convert(isCkb2Udt, amount, rate) : ccc.Zero;
+
+    return { rate, convertedAmount };
   }
 
-  // TODO streamline parameters with previewConversion
   async convert(options: {
+    conversion: Parameters<typeof IckbController.previewConversion>[0] & {
+      ckbMinMatchLog?: number;
+      ckbMinFee?: ccc.Num;
+    };
     signer: ccc.Signer;
-    isCkb2Udt: boolean;
-    amount: ccc.FixedPoint;
     userCells: UserCells;
-    minCkbChange: ccc.FixedPoint;
     system: SystemState;
-    balance: Balance;
-    fee?: {
-      numerator: ccc.Num;
-      denominator: ccc.Num;
+    filters: {
+      isReadyOnly: boolean;
+      isFulfilledOnly: boolean;
     };
   }): Promise<Conversion | undefined> {
-    const { isCkb2Udt, amount, system, signer } = options;
-    // TODO: RatioLike and specify fee!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-    // Or let outside specify adjusted rate...
-    const info = Info.create(isCkb2Udt, Ratio.from(system.exchangeRatio));
-    const address = await signer.getRecommendedAddressObj();
+    // Get user lock
+    const { system, signer } = options;
+    const lock = (await signer.getRecommendedAddressObj()).script;
+
+    // Normalize rate
+    const { rate } = IckbController.previewConversion({
+      ...options.conversion,
+      amount: ccc.Zero,
+    });
+    const { isCkb2Udt, amount, ckbMinMatchLog } = options.conversion;
+    const info = Info.create(isCkb2Udt, rate, ckbMinMatchLog);
+    // feeRate is a good approximation of the bot tx size matching the order
+    const ckbMinFee = options.conversion.ckbMinFee ?? 10n * system.feeRate;
+    const conversion = {
+      isCkb2Udt,
+      amount,
+      rate,
+      info,
+      ckbMinFee,
+      lock,
+    };
+
     const N = isCkb2Udt
       ? Number(amount / system.ckbDepositCap)
-      : system.deposits.slice(0, 30).length;
+      : system.depositPool.slice(0, 30).length;
+
     const cache = Array<ReturnType<IckbController["convert"]>>(N);
-    const attempt = (n: number): ReturnType<IckbController["convert"]> => {
+    const cachedAttempt = (
+      n: number,
+    ): ReturnType<IckbController["convert"]> => {
       n = N - n;
-      return (cache[n] =
-        cache[n] ?? this.attemptConversion(n, info, address, options));
+      return (cache[n] = cache[n] ?? this.attempt(n, conversion, options));
     };
-    return attempt(
+
+    return cachedAttempt(
       await asyncBinarySearch(
         N,
-        async (n: number) => (await attempt(n)) !== undefined,
+        async (n: number) => (await cachedAttempt(n)) !== undefined,
       ),
     );
   }
 
-  private async attemptConversion(
+  private async attempt(
     n: number,
-    info: Info,
-    address: ccc.Address,
-    {
-      signer,
-      isCkb2Udt,
-      amount,
-      userCells,
-      system: { feeRate, tip, deposits, ckbDepositCap, exchangeRatio },
-    }: Parameters<IckbController["convert"]>[0],
+    conversion: {
+      isCkb2Udt: boolean;
+      amount: bigint;
+      rate: ExchangeRatio;
+      info: Info;
+      ckbMinFee: ccc.Num;
+      lock: ccc.Script;
+    },
+    options: Omit<Parameters<IckbController["convert"]>[0], "conversion">,
   ): ReturnType<IckbController["convert"]> {
-    let tx: SmartTransaction = OfflineTransaction.default();
-    const maturities: Epoch[] = [];
-    let ckbFee = ccc.Zero;
-
-    if (n > 0) {
-      if (isCkb2Udt) {
-        amount -= ckbDepositCap * BigInt(n);
-        if (amount < 0n) {
-          // Too many Deposits respectfully to the amount
-          return undefined;
-        }
-        this.logicManager.deposit(tx, n, ckbDepositCap, address.script);
-      } else {
-        const myDeposits = deposits.slice(0, n);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        amount -= myDeposits.slice(-1)[0]!.udtCumulative;
-        if (amount < 0n) {
-          // Too many Withdrawal Requests respectfully to the amount
-          return undefined;
+    try {
+      const { isCkb2Udt, rate, info, ckbMinFee, lock } = conversion;
+      const { signer, userCells, system, filters } = options;
+      const { feeRate, depositPool, ckbDepositCap, exchangeRatio } = system;
+
+      const tx = SmartTransaction.default();
+      const maturities: ccc.Epoch[] = [];
+      let ckbFee = ccc.Zero;
+      let amount = conversion.amount;
+
+      // Core protocol
+      if (n > 0) {
+        if (isCkb2Udt) {
+          amount -= ckbDepositCap * BigInt(n);
+          if (amount < ccc.Zero) {
+            // Too many Deposits respectfully to the amount
+            return undefined;
+          }
+          this.logicManager.deposit(tx, n, ckbDepositCap, lock);
+        } else {
+          const myDeposits = depositPool.slice(0, n);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          amount -= myDeposits.slice(-1)[0]!.udtCumulative;
+          if (amount < ccc.Zero) {
+            // Too many Withdrawal Requests respectfully to the amount
+            return undefined;
+          }
+          this.ownedOwnerManager.requestWithdrawal(tx, myDeposits, lock);
+          maturities.push(...myDeposits.map((d) => d.maturity));
         }
-        this.ownedOwnerManager.requestWithdrawal(
-          tx,
-          myDeposits,
-          address.script,
+      }
+
+      // Order protocol
+      if (amount > ccc.Zero) {
+        this.orderManager.mint(tx, lock, info, {
+          ckbValue: isCkb2Udt ? amount : ccc.Zero,
+          udtValue: isCkb2Udt ? ccc.Zero : amount,
+        });
+
+        const convertedAmount = convert(isCkb2Udt, amount, rate);
+        ckbFee = isCkb2Udt
+          ? amount - convert(false, convertedAmount, exchangeRatio)
+          : convert(true, amount, exchangeRatio) - convertedAmount;
+
+        maturities.push(
+          // TODO: use real world data from deposits, open orders and bot balances
+          orderMaturityEstimate(isCkb2Udt, amount, system.tip),
         );
-        maturities.push(...myDeposits.map((d) => d.maturity));
       }
-    }
 
-    if (amount > 0n) {
-      this.orderManager.mint(
-        tx,
-        address.script,
-        info,
-        isCkb2Udt ? amount : ccc.Zero,
-        isCkb2Udt ? ccc.Zero : amount,
-      );
+      // Check that order provides enough fee to the bot for being matched
+      if (ckbFee < ckbMinFee) {
+        return undefined;
+      }
 
-      const ratio = isCkb2Udt ? info.ckbToUdt : info.udtToCkb;
-      const convertedAmount = convert(isCkb2Udt, amount, ratio);
-      ckbFee = isCkb2Udt
-        ? amount - convert(false, convertedAmount, exchangeRatio)
-        : convert(true, amount, exchangeRatio) - convertedAmount;
+      const { receipts, withdrawalGroups, orders, udts, capacities } =
+        userCells;
 
-      maturities.push(
-        // TODO: use real world data from deposits, open orders and bot balances
-        orderMaturityEstimate(isCkb2Udt, amount, tip),
-      );
-    }
+      this.logicManager.completeDeposit(tx, receipts);
+      this.ownedOwnerManager.withdraw(tx, withdrawalGroups, filters);
+      this.orderManager.melt(tx, orders, filters);
+      this.ickbUdtManager.addUdts(tx, udts);
+      CapacityManager.addCapacities(tx, capacities);
 
-    // Check that order provides enough fee to the bot for being matched
-    // feeRate is a good approximation of the bot tx size matching the order
-    if (10n * (feeRate - ckbFee) > ckbFee) {
-      return undefined;
-    }
+      // Throw an error if inputs do not cover for outputs
+      await new RestrictedTransaction(tx).completeFeeBy(signer, feeRate);
 
-    const { receipts, withdrawalGroups, orders, udts, capacities } = userCells;
+      // Find the maturity most distant in the future
+      const maturity = maturities.reduce((a, b) =>
+        epochCompare(a, b) === -1 ? b : a,
+      );
 
-    this.logicManager.completeDeposit(tx, receipts);
-    this.ownedOwnerManager.withdraw(tx, withdrawalGroups); //TODO: ignore not isReady cells in method!!!
-    for (const order of orders) {
-      this.orderManager.melt(tx, order); //TODO: allow melting multiple groups and give choices!!!
-    }
-    // const outputLen = tx.inputs.length;??
-    // Give choice that let user add this cells the way he prefer!! (Either here or at completeFeeBy)
-    this.ickbManager.addUdts(tx, udts);
-    CapacityManager.addCapacities(tx, capacities);
-    const outputLen = tx.outputs.length;
+      return {
+        tx,
+        ckbFee,
+        maturity,
+      };
 
-    try {
-      await tx.completeFeeBy(signer, feeRate);
-      // TODO: check in SmartTransaction for 64 output cells in DAO transactions
-      if (tx.outputs.length > 64) {
-        return undefined;
-      }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
     } catch (_) {
       return undefined;
     }
-
-    // Revert any change cells
-    tx.outputs = tx.outputs.slice(outputLen);
-    tx = SmartTransaction.from(tx);
-
-    const maturity = maturities.reduce((a, b) =>
-      epochCompare(a, b) === -1 ? b : a,
-    );
-
-    return {
-      tx,
-      ckbFee,
-      maturity,
-    };
   }
 
-  // TODO: Allow filtering which cells are fetched
   async getL1State(
     client: ccc.Client,
-    locks: ccc.ScriptLike[],
+    filter: Set<keyof UserCells | "depositPool">,
+    locks: ccc.Script[],
     options?: {
       minLockUp?: ccc.Epoch;
       maxLockUp?: ccc.Epoch;
@@ -268,25 +285,42 @@ export class IckbController {
       receipts,
       withdrawalGroups,
       orders,
+      deposits,
+      withdrawalRequests,
     ] = await Promise.all([
-      // TODO: fetch user NervosDAO cells
-      // TODO: fetch bot cells for estimating timings
       client.getFeeRate(),
-      arrayFrom(this.logicManager.findDeposits(client, opts)),
-      arrayFrom(CapacityManager.findCapacities(client, locks, opts)),
-      arrayFrom(this.ickbManager.findUdts(client, locks, opts)),
-      arrayFrom(this.logicManager.findReceipts(client, locks, opts)),
-      arrayFrom(
-        this.ownedOwnerManager.findWithdrawalGroups(client, locks, opts),
-      ),
-      this.orderManager.findOrders(client),
+      filter.has("depositPool")
+        ? collect(this.logicManager.findDeposits(client, opts))
+        : [],
+      filter.has("capacities")
+        ? collect(CapacityManager.findCapacities(client, locks, opts))
+        : [],
+      filter.has("udts")
+        ? collect(this.ickbUdtManager.findUdts(client, locks, opts))
+        : [],
+      filter.has("receipts")
+        ? collect(this.logicManager.findReceipts(client, locks, opts))
+        : [],
+      filter.has("withdrawalGroups")
+        ? collect(
+            this.ownedOwnerManager.findWithdrawalGroups(client, locks, opts),
+          )
+        : [],
+      filter.has("orders") ? collect(this.orderManager.findOrders(client)) : [],
+      filter.has("deposits")
+        ? collect(this.daoManager.findDeposits(client, locks, opts))
+        : [],
+      filter.has("withdrawalRequests")
+        ? collect(this.daoManager.findWithdrawalRequests(client, locks, opts))
+        : [],
+      // TODO: fetch bot cells for estimating timings
     ]);
 
     // Sort depositPool by maturity
     depositPool.sort((a, b) => epochCompare(a.maturity, b.maturity));
     // Calculate cumulative value of deposits in the pool
     let udtCumulative = 0n;
-    const cumulativeDepositPool: SystemState["deposits"] = [];
+    const cumulativeDepositPool: SystemState["depositPool"] = [];
     for (const deposit of depositPool) {
       udtCumulative += deposit.udtValue;
       cumulativeDepositPool.push({ ...deposit, udtCumulative });
@@ -303,7 +337,7 @@ export class IckbController {
     }
 
     const exchangeRatio = ickbExchangeRatio(tip);
-    const ckbDepositCap = convert(false, ICKB_DEPOSIT_CAP, exchangeRatio); // TODO: Remove export from core
+    const ckbDepositCap = convert(false, ICKB_DEPOSIT_CAP, exchangeRatio);
 
     return {
       system: {
@@ -312,8 +346,8 @@ export class IckbController {
         exchangeRatio,
         ckbDepositCap,
         udtDepositCap: ICKB_DEPOSIT_CAP,
-        deposits: cumulativeDepositPool,
-        orders: nonUserOrders,
+        depositPool: cumulativeDepositPool,
+        orderPool: nonUserOrders,
       },
       user: {
         capacities,
@@ -321,45 +355,11 @@ export class IckbController {
         receipts,
         withdrawalGroups,
         orders: userOrders,
+        deposits,
+        withdrawalRequests,
       },
     };
   }
-
-  // TODO: Allow filtering which cells are accounted for
-  static getBalance({
-    capacities,
-    udts,
-    receipts,
-    withdrawalGroups,
-    orders,
-  }: UserCells): Balance {
-    const cells: { cell: ccc.Cell; udtValue?: ccc.FixedPoint }[] = [
-      capacities,
-      udts,
-      receipts,
-    ].flat();
-    for (const { owner, owned } of withdrawalGroups) {
-      cells.push(owned, owner);
-    }
-    for (const { master, order } of orders) {
-      cells.push(master, order);
-    }
-    let ckb = ccc.Zero;
-    let udt = ccc.Zero;
-    for (const cell of cells) {
-      ckb += cell.cell.cellOutput.capacity;
-      udt += cell.udtValue ?? ccc.Zero;
-    }
-    return {
-      ckb,
-      udt,
-    };
-  }
-}
-
-export interface Balance {
-  ckb: ccc.FixedPoint;
-  udt: ccc.FixedPoint;
 }
 
 export interface SystemState {
@@ -371,22 +371,24 @@ export interface SystemState {
   };
   ckbDepositCap: ccc.FixedPoint;
   udtDepositCap: ccc.FixedPoint;
-  deposits: (IckbDepositCell & { udtCumulative: bigint })[];
-  orders: OrderCell[];
+  depositPool: (IckbDepositCell & { udtCumulative: bigint })[];
+  orderPool: OrderCell[];
 }
 
 export interface UserCells {
   capacities: CapacityCell[];
   udts: UdtCell[];
   receipts: ReceiptCell[];
-  withdrawalGroups: WithdrawalGroups[];
+  withdrawalGroups: WithdrawalGroup[];
   orders: OrderGroup[];
+  deposits: DaoCell[];
+  withdrawalRequests: DaoCell[];
 }
 
 export interface Conversion {
   tx: SmartTransaction;
   ckbFee: ccc.FixedPoint;
-  maturity: Epoch;
+  maturity: ccc.Epoch;
 }
 
 // Estimate bot ability to fulfill orders:
@@ -403,77 +405,3 @@ function orderMaturityEstimate(
     4n * 60n,
   ]);
 }
-
-class OfflineTransaction extends SmartTransaction {
-  override clone(): OfflineTransaction {
-    const result = super.clone();
-    // Keep inputs metadata when cloning, so it will not refetch that data
-    result.inputs = [...this.inputs];
-    return new OfflineTransaction(result);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  override async completeInputs<T>(
-    _0: never,
-    _1: never,
-    _2: never,
-    init: T,
-  ): Promise<{ addedCount: number; accumulated?: T }> {
-    // Disable completeInputs, so it will not fetch additional cells
-    return {
-      addedCount: 0,
-      accumulated: init,
-    };
-  }
-
-  // Reimplement the rest of transformations
-
-  constructor(tx: SmartTransaction) {
-    super(
-      tx.version,
-      tx.cellDeps,
-      tx.headerDeps,
-      tx.inputs,
-      tx.outputs,
-      tx.outputsData,
-      tx.witnesses,
-      tx.udtHandlers,
-      tx.headers,
-    );
-  }
-
-  static override default(): OfflineTransaction {
-    return new OfflineTransaction(super.default());
-  }
-
-  static override fromLumosSkeleton(
-    skeleton: ccc.LumosTransactionSkeletonType,
-  ): OfflineTransaction {
-    return new OfflineTransaction(super.fromLumosSkeleton(skeleton));
-  }
-
-  static override from(txLike: SmartTransactionLike): OfflineTransaction {
-    return new OfflineTransaction(SmartTransaction.from(txLike));
-  }
-}
-
-// TODO: utils.binarySearch is sync, need an async one for await the result!!!!!!!!!!!!
-async function asyncBinarySearch(
-  n: number,
-  f: (i: number) => Promise<boolean>,
-): Promise<number> {
-  // 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;
-}