=> {
- const t0 = Transaction.fromLumosSkeleton(tx);
- const size0 = t0.toBytes().length; // +4
- const t1 = await signer.prepareTransaction(t0);
- const size1 = t1.toBytes().length; // +4
- return size1 - size0;
- };
-
- const sendSigned = async (
- tx: TransactionSkeletonType,
- ): Promise<`0x${string}`> =>
- signer.sendTransaction(Transaction.fromLumosSkeleton(tx));
-
return {
...rootConfig,
- address,
+ signer,
+ address: recommendedAddressObj.toString(),
accountLocks,
- expander,
- getTxSizeOverhead,
- sendSigned,
+ primaryLock: accountLocks[0] ?? ccc.Script.from(recommendedAddressObj.script),
};
},
});
- if (isPending)
+ if (isPending) {
return (
<>
);
+ }
if (error) {
- setTimeout(function () {
- console.log(error);
- location.reload();
- }, 10000);
- return Unable to connect to {walletName} ⚠️
;
+ return Unable to connect to {walletName}: {errorMessageOf(error)}
;
}
return ;
diff --git a/apps/interface/src/Dashboard.tsx b/apps/interface/src/Dashboard.tsx
index 59146ec..72b25d0 100644
--- a/apps/interface/src/Dashboard.tsx
+++ b/apps/interface/src/Dashboard.tsx
@@ -24,6 +24,7 @@ export function Dashboard({
{"{"}
diff --git a/apps/interface/src/Form.tsx b/apps/interface/src/Form.tsx
index 05633c3..f40e164 100644
--- a/apps/interface/src/Form.tsx
+++ b/apps/interface/src/Form.tsx
@@ -1,19 +1,19 @@
+import type { JSX } from "react";
+import { IckbSdk, type SystemState } from "@ickb/sdk";
import {
- calculateOrderRatio,
+ CKB,
direction2Symbol,
- calculateOrderResult,
reservedCKB,
+ sanitizeAmountInput,
symbol2Direction,
toText,
} from "./utils.ts";
-import { CKB, max, min, type I8Header } from "@ickb/lumos-utils";
-import type { JSX } from "react";
export default function Form({
rawText,
setRawText,
amount,
- tipHeader,
+ system,
isFrozen,
ckbNative,
ickbNative,
@@ -23,9 +23,9 @@ export default function Form({
ickbBalance,
}: {
rawText: string;
- setRawText: (s: string) => void;
+ setRawText: (value: string) => void;
amount: bigint;
- tipHeader: I8Header;
+ system: SystemState;
isFrozen: boolean;
ckbNative: bigint;
ickbNative: bigint;
@@ -34,18 +34,20 @@ export default function Form({
ckbAvailable: bigint;
ickbAvailable: bigint;
}): JSX.Element {
- const symbol = rawText[0];
+ const symbol = rawText.startsWith("I") ? "I" : direction2Symbol(true);
const text = rawText.slice(1);
const isCkb2Udt = symbol2Direction(symbol);
const toggle = (): void => {
setRawText(direction2Symbol(!isCkb2Udt) + text);
};
- const nnn = min(max(ckbAvailable - reservedCKB, 0n), ckbNative);
+ const spendableCkb = ckbAvailable > reservedCKB ? ckbAvailable - reservedCKB : 0n;
+ const nativeCkb = spendableCkb < ckbNative ? spendableCkb : ckbNative;
+
let a = {
name: "CKB",
- native: nnn,
- locked: ckbBalance - nnn,
+ native: nativeCkb,
+ locked: ckbBalance - nativeCkb,
status:
ckbBalance === ckbNative
? "✅"
@@ -54,7 +56,7 @@ export default function Form({
: "⏳",
};
let b = {
- name: "ICKB",
+ name: "iCKB",
native: ickbNative,
locked: ickbBalance - ickbNative,
status:
@@ -69,48 +71,40 @@ export default function Form({
}
return (
- <>
-
- {display(a.native, "✅")}
- {a.name}
-
- {display(a.locked, a.status)}
-
- {
- setRawText(symbol + e.target.value);
- }}
- autoComplete="off"
- inputMode="decimal"
- type="text"
- className="col-span-3 w-full rounded border-0 bg-transparent text-center text-3xl text-amber-400 outline-none disabled:cursor-default"
- aria-label="Amount to be converted"
- />
- {"1 " + a.name}
-
-
- {approxConversion(isCkb2Udt, CKB, tipHeader)} {b.name}
-
-
- ⏳{approxConversion(isCkb2Udt, amount, tipHeader)}
-
- {display(b.native, "✅")}
- {b.name}
-
- {display(b.locked, b.status)}
-
+
+ {display(a.native, "✅")}
+ {a.name}
+ {display(a.locked, a.status)}
+ {
+ setRawText(symbol + sanitizeAmountInput(event.target.value));
+ }}
+ autoComplete="off"
+ inputMode="decimal"
+ type="text"
+ className="col-span-3 w-full rounded border-0 bg-transparent text-center text-3xl text-amber-400 outline-none disabled:cursor-default"
+ aria-label="Amount to be converted"
+ />
+ {`1 ${a.name}`}
+
+ {approxConversion(isCkb2Udt, CKB, system)} {b.name}
+
+ ⏳{approxConversion(isCkb2Udt, amount, system)}
-
+ {display(b.native, "✅")}
+ {b.name}
+ {display(b.locked, b.status)}
+
);
}
@@ -131,14 +125,13 @@ function display(shannons: bigint, prefix: string): JSX.Element {
function approxConversion(
isCkb2Udt: boolean,
amount: bigint,
- tipHeader: I8Header,
+ system: SystemState,
): string {
- //Worst case scenario is a 0.001% fee for bot
return toText(
- calculateOrderResult(
+ IckbSdk.estimate(
isCkb2Udt,
- amount,
- calculateOrderRatio(isCkb2Udt, tipHeader),
- ),
+ isCkb2Udt ? { ckbValue: amount, udtValue: 0n } : { ckbValue: 0n, udtValue: amount },
+ system,
+ ).convertedAmount,
);
}
diff --git a/apps/interface/src/main.tsx b/apps/interface/src/main.tsx
index 9f57bc7..b31d7eb 100644
--- a/apps/interface/src/main.tsx
+++ b/apps/interface/src/main.tsx
@@ -1,58 +1,54 @@
import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import Connector from "./Connector.tsx";
-import { getIckbScriptConfigs } from "@ickb/v1-core";
-import { chainConfigFrom } from "@ickb/lumos-utils";
-import { prefetchData } from "./queries.ts";
import { ccc, JoyId } from "@ckb-ccc/ccc";
+import { getConfig, IckbSdk } from "@ickb/sdk";
+import Connector from "./Connector.tsx";
+import type { RootConfig } from "./utils.ts";
import appIcon from "/favicon.png?url";
+
const appName = "iCKB DApp";
-const testnetRootConfigPromise = chainConfigFrom(
- "testnet",
- "https://testnet.ckb.dev/",
- true,
- getIckbScriptConfigs,
-).then((chainConfig) => {
- const rootConfig = {
- ...chainConfig,
- queryClient: new QueryClient(),
- cccClient: new ccc.ClientPublicTestnet(),
- };
- // eslint-disable-next-line @typescript-eslint/no-floating-promises
- prefetchData(rootConfig);
- return rootConfig;
-});
+function createRootConfig(chain: "mainnet" | "testnet"): RootConfig {
+ const { managers, bots } = getConfig(chain);
-const mainnetRootConfigPromise = chainConfigFrom(
- "mainnet",
- "https://mainnet.ckb.dev/",
- true,
- getIckbScriptConfigs,
-).then((chainConfig) => {
- const rootConfig = {
- ...chainConfig,
+ return {
+ chain,
queryClient: new QueryClient(),
- cccClient: new ccc.ClientPublicMainnet(),
+ cccClient:
+ chain === "mainnet"
+ ? new ccc.ClientPublicMainnet()
+ : new ccc.ClientPublicTestnet(),
+ sdk: new IckbSdk(
+ managers.ownedOwner,
+ managers.logic,
+ managers.order,
+ bots,
+ ),
+ managers: {
+ ickbUdt: managers.ickbUdt,
+ logic: managers.logic,
+ ownedOwner: managers.ownedOwner,
+ order: managers.order,
+ },
};
- // eslint-disable-next-line @typescript-eslint/no-floating-promises
- prefetchData(rootConfig);
- return rootConfig;
-});
+}
+
+const rootConfigs = {
+ mainnet: createRootConfig("mainnet"),
+ testnet: createRootConfig("testnet"),
+};
-export async function startApp(wallet_chain: string): Promise {
- const [walletName, chain] = wallet_chain.split("_");
- const rootConfig = await (chain === "mainnet"
- ? mainnetRootConfigPromise
- : testnetRootConfigPromise);
+export function startApp(walletChain: string): void {
+ const [walletName, chain] = walletChain.split("_");
+ const rootConfig = chain === "mainnet" ? rootConfigs.mainnet : rootConfigs.testnet;
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const signer = JoyId.getJoyIdSigners(
rootConfig.cccClient,
appName,
["https://ickb.org", appIcon].join(""),
- ).find((i) => i.name === "CKB")!.signer;
+ ).find((candidate) => candidate.name === "CKB")!.signer;
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const rootElement = document.getElementById("app")!;
diff --git a/apps/interface/src/queries.ts b/apps/interface/src/queries.ts
index 8e24fec..c60cb90 100644
--- a/apps/interface/src/queries.ts
+++ b/apps/interface/src/queries.ts
@@ -1,40 +1,13 @@
+import { ccc } from "@ckb-ccc/ccc";
+import type { WithdrawalGroup } from "@ickb/core";
+import { type OrderGroup } from "@ickb/order";
+import { type SystemState } from "@ickb/sdk";
+import { collect, sum } from "@ickb/utils";
import {
- encodeToAddress,
- type TransactionSkeletonType,
-} from "@ckb-lumos/helpers";
-import { queryOptions } from "@tanstack/react-query";
-import {
- CKB,
- I8Header,
- calculateTxFee,
- capacitySifter,
- ckbDelta,
- hex,
- i8ScriptPadding,
- lockExpanderFrom,
- maturityDiscriminator,
- max,
- shuffle,
- since,
- txSize,
-} from "@ickb/lumos-utils";
-import {
- ickbDelta,
- ickbLogicScript,
- ickbPoolSifter,
- ickbSifter,
- limitOrderScript,
- orderSifter,
- ownedOwnerScript,
-} from "@ickb/v1-core";
-import {
- txInfoPadding,
- type RootConfig,
- type TxInfo,
- type WalletConfig,
-} from "./utils.ts";
-import { addChange, base as add, convert } from "./transaction.ts";
-import type { Cell, Header, HexNumber, Transaction } from "@ckb-lumos/base";
+ buildTransactionPreview,
+ type TransactionContext,
+} from "./transaction.ts";
+import { type TxInfo, type WalletConfig } from "./utils.ts";
export interface L1StateType {
ckbNative: bigint;
@@ -43,201 +16,130 @@ export interface L1StateType {
ickbBalance: bigint;
ckbAvailable: bigint;
ickbAvailable: bigint;
- tipHeader: Readonly;
- txBuilder: (isCkb2Udt: boolean, amount: bigint) => TxInfo;
+ tipTimestamp: bigint;
+ system: SystemState;
+ stateId: string;
+ txBuilder: (isCkb2Udt: boolean, amount: bigint) => Promise;
hasMatchable: boolean;
}
+export function l1StateQueryKey(
+ walletConfig: WalletConfig,
+): readonly [WalletConfig["chain"], string, "l1State"] {
+ return [walletConfig.chain, walletConfig.address, "l1State"] as const;
+}
+
export function l1StateOptions(
walletConfig: WalletConfig,
isFrozen: boolean,
-): ReturnType<
- typeof queryOptions
-> {
- return queryOptions({
- retry: true,
+): {
+ retry: number;
+ refetchInterval: (context: { state: { data?: L1StateType } }) => number;
+ staleTime: number;
+ queryKey: readonly [WalletConfig["chain"], string, "l1State"];
+ queryFn: () => Promise;
+ enabled: boolean;
+} {
+ return {
+ retry: 2,
refetchInterval: ({ state }) => 60000 * (state.data?.hasMatchable ? 1 : 10),
staleTime: 10000,
- queryKey: [walletConfig.chain, walletConfig.address, "l1State"],
- queryFn: async (): Promise => {
- return getL1State(walletConfig).catch((e: unknown) => {
- console.log(e);
- throw e;
- });
- },
- placeholderData: {
- ckbNative: 6n * CKB * CKB,
- ickbNative: 3n * CKB * CKB,
- ckbAvailable: 6n * CKB * CKB,
- ickbAvailable: 3n * CKB * CKB,
- ckbBalance: 6n * CKB * CKB,
- ickbBalance: 3n * CKB * CKB,
- tipHeader: headerPlaceholder,
- txBuilder: () => txInfoPadding,
- hasMatchable: false,
- },
+ queryKey: l1StateQueryKey(walletConfig),
+ queryFn: async () => await getL1State(walletConfig),
enabled: !isFrozen,
- });
-}
-
-async function getL1State(walletConfig: WalletConfig): Promise {
- const { rpc, config, expander, getTxSizeOverhead } = walletConfig;
-
- const mixedCells = await getMixedCells(walletConfig);
-
- // Prefetch feeRate and tipHeader
- const feeRatePromise = rpc.getFeeRate(61n);
- const tipHeaderPromise = rpc.getTipHeader();
-
- // Prefetch headers
- const wanted = new Set();
- const deferredGetHeader = (blockNumber: string): Readonly => {
- wanted.add(blockNumber);
- return headerPlaceholder;
- };
- ickbSifter(mixedCells, expander, deferredGetHeader, config);
- const headersPromise = getHeadersByNumber(wanted, walletConfig);
-
- // Prefetch txs outputs
- const wantedTxsOutputs = new Set();
- const deferredGetTxsOutputs = (txHash: string): never[] => {
- wantedTxsOutputs.add(txHash);
- return [];
};
- orderSifter(mixedCells, expander, deferredGetTxsOutputs, config);
- const txsOutputsPromise = getTxsOutputs(wantedTxsOutputs, walletConfig);
-
- // Do potentially costly operations
- const { capacities, notCapacities } = capacitySifter(mixedCells, expander);
-
- // Await for headers
- const headers = await headersPromise;
+}
- // Sift through iCKB related cells
- const {
- udts,
- receipts,
- withdrawalRequestGroups,
- ickbPool: pool,
- notIckbs,
- } = ickbSifter(
- notCapacities,
- expander,
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- (blockNumber) => headers.get(blockNumber)!,
- config,
+export async function getL1State(
+ walletConfig: WalletConfig,
+): Promise {
+ const sdkState = await walletConfig.sdk.getL1State(
+ walletConfig.cccClient,
+ walletConfig.accountLocks,
);
+ const { system, user } = sdkState;
+ const [accountCells, receipts, withdrawalGroups] = await Promise.all([
+ getAccountCells(walletConfig),
+ collect(
+ walletConfig.managers.logic.findReceipts(
+ walletConfig.cccClient,
+ walletConfig.accountLocks,
+ { onChain: true },
+ ),
+ ),
+ collect(
+ walletConfig.managers.ownedOwner.findWithdrawalGroups(
+ walletConfig.cccClient,
+ walletConfig.accountLocks,
+ { onChain: true, tip: system.tip },
+ ),
+ ),
+ ]);
- const tipHeader = I8Header.from(await tipHeaderPromise);
- // Partition between ripe and non ripe withdrawal requests
- const { mature, notMature } = maturityDiscriminator(
- withdrawalRequestGroups,
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- (g) => g.ownedWithdrawalRequest.cellOutput.type![since],
- tipHeader,
+ const capacityCells = accountCells.filter((cell) => cell.cellOutput.type === undefined);
+ const udtCells = accountCells.filter((cell) =>
+ walletConfig.managers.ickbUdt.isUdt(cell),
);
-
- // min lock: 1/4 epoch (~ 1 hour)
- const minLock = { length: 4, index: 1, number: 0 };
- // Sort the ickbPool based on the tip header
- let ickbPool = ickbPoolSifter(pool, tipHeader, minLock);
- // Take a random convenient subset of max 40 deposits
- if (ickbPool.length > 40) {
- const n = max(Math.round(ickbPool.length / 180), 40);
- ickbPool = shuffle(ickbPool.slice(0, n).map((d, i) => ({ d, i })))
- .slice(0, 40)
- .sort((a, b) => a.i - b.i)
- .map((a) => a.d);
- }
-
- // Await for txsOutputs
- const txsOutputs = await txsOutputsPromise;
-
- // Sift through Orders
- const { myOrders } = orderSifter(
- notIckbs,
- expander,
- (txHash) => txsOutputs.get(txHash) ?? [],
- config,
+ const nativeUdtInfo = await walletConfig.managers.ickbUdt.infoFrom(
+ walletConfig.cccClient,
+ udtCells,
);
- const matchableOrders = [];
- const completedOrders = [];
- for (const o of myOrders) {
- const { isMatchable, isDualRatio } = o.info;
- if (isMatchable && !isDualRatio) {
- matchableOrders.push(o);
+ const ckbNative =
+ sum(0n, ...capacityCells.map((cell) => cell.cellOutput.capacity)) +
+ nativeUdtInfo.capacity;
+ const ickbNative = nativeUdtInfo.balance;
+
+ const readyWithdrawals: WithdrawalGroup[] = [];
+ const pendingWithdrawals: WithdrawalGroup[] = [];
+ for (const group of withdrawalGroups) {
+ if (group.owned.isReady) {
+ readyWithdrawals.push(group);
} else {
- // Withdraw completed orders and dual ratio orders
- completedOrders.push(o);
+ pendingWithdrawals.push(group);
}
}
- const hasMatchable = matchableOrders.length > 0;
-
- const txHasNonNative =
- mature.length > 0 || receipts.length > 0 || completedOrders.length > 0;
-
- // Calculate native balances
- let txInfo = add({ capacities, udts, tipHeader });
- const ckbNative = ckbDelta(txInfo.tx, config);
- const ickbNative = ickbDelta(txInfo.tx, config);
-
- // Calculate Available balances and baseTx
- txInfo = add({
- txInfo,
- myOrders: completedOrders,
- receipts,
- wrGroups: mature,
- tipHeader,
- });
- const txSizeOverheadPromise = getTxSizeOverhead(txInfo.tx);
- const ckbAvailable = ckbDelta(txInfo.tx, config);
- const ickbAvailable = ickbDelta(txInfo.tx, config);
-
- // Calculate full balances
- const fullTxInfo = add({
- txInfo,
- myOrders: matchableOrders,
- wrGroups: notMature,
- tipHeader,
- });
- const ckbBalance = ckbDelta(fullTxInfo.tx, config);
- const ickbBalance = ickbDelta(fullTxInfo.tx, config);
- txInfo = Object.freeze({
- ...txInfo,
- estimatedMaturity: fullTxInfo.estimatedMaturity,
- });
-
- const [txSizeOverhead, feeRate] = await Promise.all([
- txSizeOverheadPromise,
- feeRatePromise,
- ]);
-
- const calculateFee = (tx: TransactionSkeletonType): bigint =>
- calculateTxFee(txSize(tx) + txSizeOverhead, feeRate);
-
- const txBuilder = (isCkb2Udt: boolean, amount: bigint): TxInfo => {
- if (amount > 0n) {
- return convert(
- txInfo,
- isCkb2Udt,
- amount,
- ickbPool,
- tipHeader,
- calculateFee,
- walletConfig,
- );
- }
-
- if (txHasNonNative) {
- return addChange(txInfo, calculateFee, walletConfig);
+ const availableOrders: OrderGroup[] = [];
+ const pendingOrders: OrderGroup[] = [];
+ for (const group of user.orders) {
+ if (group.order.isDualRatio() || !group.order.isMatchable()) {
+ availableOrders.push(group);
+ } else {
+ pendingOrders.push(group);
}
+ }
- return Object.freeze({
- ...txInfo,
- error: "Nothing to do for now",
- });
+ const ckbAvailable =
+ ckbNative +
+ sumCkb(receipts) +
+ sumCkb(readyWithdrawals) +
+ sumCkb(availableOrders);
+ const ickbAvailable =
+ ickbNative +
+ sumUdt(receipts) +
+ sumUdt(readyWithdrawals) +
+ sumUdt(availableOrders);
+
+ const ckbBalance = ckbAvailable + sumCkb(pendingWithdrawals) + sumCkb(pendingOrders);
+ const ickbBalance = ickbAvailable + sumUdt(pendingWithdrawals) + sumUdt(pendingOrders);
+
+ const estimatedMaturity = [
+ system.tip.timestamp,
+ ...pendingWithdrawals.map((group) => group.owned.maturity.toUnix(system.tip)),
+ ...pendingOrders
+ .map((group) => group.order.maturity)
+ .filter((maturity): maturity is bigint => maturity !== undefined),
+ ].reduce((best, maturity) => (best > maturity ? best : maturity));
+
+ const txContext: TransactionContext = {
+ system,
+ receipts,
+ readyWithdrawals,
+ availableOrders,
+ ckbAvailable,
+ ickbAvailable,
+ estimatedMaturity,
};
return {
@@ -247,149 +149,52 @@ async function getL1State(walletConfig: WalletConfig): Promise {
ickbBalance,
ckbAvailable,
ickbAvailable,
- tipHeader,
- txBuilder,
- hasMatchable,
- };
-}
-
-export async function prefetchData(rootConfig: RootConfig): Promise {
- const { queryClient } = rootConfig;
- const dummy: WalletConfig = {
- ...rootConfig,
- accountLocks: [i8ScriptPadding],
- address: encodeToAddress(i8ScriptPadding, rootConfig),
- expander: lockExpanderFrom(i8ScriptPadding),
- getTxSizeOverhead: () => Promise.resolve(0),
- sendSigned: () => Promise.resolve("0x0"),
+ tipTimestamp: system.tip.timestamp,
+ system,
+ stateId: [
+ walletConfig.chain,
+ String(system.tip.timestamp),
+ String(receipts.length),
+ String(readyWithdrawals.length),
+ String(pendingWithdrawals.length),
+ String(availableOrders.length),
+ String(pendingOrders.length),
+ ].join(":"),
+ txBuilder: (isCkb2Udt, amount) =>
+ buildTransactionPreview(txContext, isCkb2Udt, amount, walletConfig),
+ hasMatchable: pendingOrders.length > 0,
};
-
- return queryClient.prefetchQuery(l1StateOptions(dummy, false));
}
-async function getMixedCells(
- walletConfig: WalletConfig,
-): Promise {
- const { accountLocks, config, rpc } = walletConfig;
-
- return Object.freeze(
- (
- await Promise.all(
- [
- ...accountLocks,
- ickbLogicScript(config),
- ownedOwnerScript(config),
- limitOrderScript(config),
- ].map((lock) => rpc.getCellsByLock(lock, "desc", "max")),
- )
- ).flat(),
- );
-}
-
-async function getTxsOutputs(
- txHashes: Set,
- walletConfig: WalletConfig,
-): Promise>> {
- const { chain, rpc, queryClient } = walletConfig;
-
- const known: Readonly> =
- queryClient.getQueryData([chain, "txsOutputs"]) ?? Object.freeze(new Map());
-
- const result = new Map();
- const batch = rpc.createBatchRequest();
- for (const txHash of txHashes) {
- const outputs = known.get(txHash);
- if (outputs !== undefined) {
- result.set(txHash, outputs);
- continue;
+async function getAccountCells(walletConfig: WalletConfig): Promise {
+ const cells: ccc.Cell[] = [];
+
+ for (const lock of walletConfig.accountLocks) {
+ for await (const cell of walletConfig.cccClient.findCellsOnChain(
+ {
+ script: lock,
+ scriptType: "lock",
+ scriptSearchMode: "exact",
+ withData: true,
+ },
+ "asc",
+ 400,
+ )) {
+ if (!cell.cellOutput.lock.eq(lock)) {
+ continue;
+ }
+
+ cells.push(cell);
}
- batch.add("getTransaction", txHash);
- }
-
- if (batch.length === 0) {
- return known;
}
- for (const tx of (await batch.exec()).map(
- ({ transaction: tx }: { transaction: Transaction }) => tx,
- )) {
- result.set(
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- tx.hash!,
- Object.freeze(
- tx.outputs.map(({ lock, type, capacity }, index) =>
- Object.freeze({
- cellOutput: Object.freeze({
- lock: Object.freeze(lock),
- type: Object.freeze(type),
- capacity: Object.freeze(capacity),
- }),
- data: Object.freeze(tx.outputsData[index] ?? "0x"),
- outPoint: Object.freeze({
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- txHash: tx.hash!,
- index: hex(index),
- }),
- } as Cell),
- ),
- ),
- );
- }
-
- const frozenResult = Object.freeze(result);
- queryClient.setQueryData([chain, "txsOutputs"], frozenResult);
- return frozenResult;
+ return cells;
}
-async function getHeadersByNumber(
- wanted: Set,
- walletConfig: WalletConfig,
-): Promise>>> {
- const { chain, rpc, queryClient } = walletConfig;
-
- const known: Readonly>> =
- queryClient.getQueryData([chain, "headers"]) ?? Object.freeze(new Map());
-
- const result = new Map>();
- const batch = rpc.createBatchRequest();
- for (const blockNum of wanted) {
- const h = known.get(blockNum);
- if (h !== undefined) {
- result.set(blockNum, h);
- continue;
- }
- batch.add("getHeaderByNumber", blockNum);
- }
-
- if (batch.length === 0) {
- return known;
- }
-
- for (const h of (await batch.exec()) as Header[]) {
- result.set(h.number, I8Header.from(h));
- }
-
- const frozenResult = Object.freeze(result);
- queryClient.setQueryData([chain, "headers"], frozenResult);
-
- return frozenResult;
+function sumCkb(items: { ckbValue: bigint }[]): bigint {
+ return sum(0n, ...items.map((item) => item.ckbValue));
}
-export const headerPlaceholder = I8Header.from({
- compactTarget: "0x1a08a97e",
- parentHash:
- "0x0000000000000000000000000000000000000000000000000000000000000000",
- transactionsRoot:
- "0x31bf3fdf4bc16d6ea195dbae808e2b9a8eca6941d589f6959b1d070d51ac28f7",
- proposalsHash:
- "0x0000000000000000000000000000000000000000000000000000000000000000",
- extraHash:
- "0x0000000000000000000000000000000000000000000000000000000000000000",
- dao: "0x8874337e541ea12e0000c16ff286230029bfa3320800000000710b00c0fefe06",
- epoch: "0x0",
- hash: "0x92b197aa1fba0f63633922c61c92375c9c074a93e85963554f5499fe1450d0e5",
- nonce: "0x0",
- number: "0x0",
- timestamp: "0x16e70e6985c",
- version: "0x0",
-});
+function sumUdt(items: { udtValue: bigint }[]): bigint {
+ return sum(0n, ...items.map((item) => item.udtValue));
+}
diff --git a/apps/interface/src/transaction.ts b/apps/interface/src/transaction.ts
index 1eb772e..b25fed9 100644
--- a/apps/interface/src/transaction.ts
+++ b/apps/interface/src/transaction.ts
@@ -1,291 +1,344 @@
-import { type TransactionSkeletonType } from "@ckb-lumos/helpers";
+import { ccc } from "@ckb-ccc/ccc";
import {
- addCells,
- addCkbChange,
- binarySearch,
- since,
- type I8Cell,
- type I8Header,
-} from "@ickb/lumos-utils";
+ ICKB_DEPOSIT_CAP,
+ convert,
+ type IckbDepositCell,
+ type ReceiptCell,
+ type WithdrawalGroup,
+} from "@ickb/core";
+import { type OrderGroup } from "@ickb/order";
+import { collect, sum } from "@ickb/utils";
+import { IckbSdk, type SystemState } from "@ickb/sdk";
import {
- addIckbUdtChange,
- addOwnedWithdrawalRequestsChange,
- addReceiptDepositsChange,
- addWithdrawalRequestGroups,
- ickb2Ckb,
- ickbDeposit,
- ickbRequestWithdrawalFrom,
- orderMelt,
- orderMint,
- type ExtendedDeposit,
- type MyOrder,
- type OrderRatio,
-} from "@ickb/v1-core";
-import {
- calculateOrderRatio,
- calculateOrderResult,
- maxEpoch,
- orderMaturityEstimate,
+ errorMessageOf,
+ hasTransactionActivity,
txInfoPadding,
type TxInfo,
type WalletConfig,
} from "./utils.ts";
-import { ckbSoftCapPerDeposit } from "@ickb/v1-core";
-import {
- parseAbsoluteEpochSince,
- parseEpoch,
- type EpochSinceValue,
-} from "@ckb-lumos/base/lib/since";
-import { headerPlaceholder } from "./queries.ts";
-
-export function base({
- txInfo = txInfoPadding,
- capacities = new Array(),
- udts = new Array(),
- receipts = new Array(),
- wrGroups = new Array<
- Readonly<{
- ownedWithdrawalRequest: I8Cell;
- owner: I8Cell;
- }>
- >(),
- myOrders = new Array(),
- tipHeader = headerPlaceholder,
-}): Readonly {
- let { tx } = txInfo;
- const estimatedMaturities = [
- txInfo.estimatedMaturity,
- parseEpoch(tipHeader.epoch),
- ];
-
- if (myOrders.length > 0) {
- tx = orderMelt(tx, myOrders);
- for (const { info: i } of myOrders) {
- if (!i.isMatchable || i.isDualRatio) {
- continue;
+
+const MAX_DIRECT_DEPOSITS = 60;
+const MAX_WITHDRAWAL_REQUESTS = 30;
+
+export interface TransactionContext {
+ system: SystemState;
+ receipts: ReceiptCell[];
+ readyWithdrawals: WithdrawalGroup[];
+ availableOrders: OrderGroup[];
+ ckbAvailable: bigint;
+ ickbAvailable: bigint;
+ estimatedMaturity: bigint;
+}
+
+export async function buildTransactionPreview(
+ context: TransactionContext,
+ isCkb2Udt: boolean,
+ amount: bigint,
+ walletConfig: WalletConfig,
+): Promise {
+ try {
+ if (amount < 0n) {
+ return txInfoWithError("Amount must be positive", context.estimatedMaturity);
+ }
+
+ if (isCkb2Udt && amount > context.ckbAvailable) {
+ return txInfoWithError("Not enough CKB", context.estimatedMaturity);
+ }
+
+ if (!isCkb2Udt && amount > context.ickbAvailable) {
+ return txInfoWithError("Not enough iCKB", context.estimatedMaturity);
+ }
+
+ const baseTx = await buildBaseTransaction(context, walletConfig);
+
+ if (amount === 0n) {
+ if (!hasTransactionActivity(baseTx)) {
+ return txInfoWithError("Nothing to do for now", context.estimatedMaturity);
}
- const isCkb2Udt = i.isCkb2UdtMatchable;
- estimatedMaturities.push(
- orderMaturityEstimate(
- isCkb2Udt,
- isCkb2Udt ? i.ckbUnoccupied : i.udtAmount,
- tipHeader,
- ),
+
+ return await finalizeTransaction(
+ baseTx,
+ context.estimatedMaturity,
+ walletConfig,
);
}
+
+ return await (isCkb2Udt
+ ? buildCkbToIckbPreview(baseTx, context, amount, walletConfig)
+ : buildIckbToCkbPreview(baseTx, context, amount, walletConfig));
+ } catch (error) {
+ return txInfoWithError(errorMessageOf(error), context.estimatedMaturity);
}
- const cc = [capacities, udts, receipts].flat();
- if (cc.length > 0) {
- tx = addCells(tx, "append", cc, []);
- }
- if (wrGroups.length > 0) {
- tx = addWithdrawalRequestGroups(tx, wrGroups);
- estimatedMaturities.push(
- ...wrGroups.map((g) =>
- parseAbsoluteEpochSince(
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- g.ownedWithdrawalRequest.cellOutput.type![since],
- ),
- ),
- );
+}
+
+async function buildBaseTransaction(
+ context: TransactionContext,
+ walletConfig: WalletConfig,
+): Promise {
+ let tx = ccc.Transaction.default();
+
+ if (context.availableOrders.length > 0) {
+ tx = walletConfig.sdk.collect(tx, context.availableOrders);
}
- const estimatedMaturity = Object.freeze(maxEpoch(estimatedMaturities));
- return Object.freeze({ ...txInfo, tx, estimatedMaturity });
-}
+ if (context.receipts.length > 0) {
+ tx = walletConfig.managers.logic.completeDeposit(tx, context.receipts);
+ }
-type MyExtendedDeposit = ExtendedDeposit & { ickbCumulative: bigint };
+ if (context.readyWithdrawals.length > 0) {
+ tx = await walletConfig.managers.ownedOwner.withdraw(
+ tx,
+ context.readyWithdrawals,
+ walletConfig.cccClient,
+ );
+ }
-export interface ConversionAttempt {
- tx: TransactionSkeletonType;
- error: string;
- fee: bigint;
- estimatedMaturity: EpochSinceValue;
+ return tx;
}
-export function convert(
- txInfo: TxInfo,
- isCkb2Udt: boolean,
+async function buildCkbToIckbPreview(
+ baseTx: ccc.Transaction,
+ context: TransactionContext,
amount: bigint,
- deposits: readonly ExtendedDeposit[],
- tipHeader: I8Header,
- calculateFee: (tx: TransactionSkeletonType) => bigint,
walletConfig: WalletConfig,
-): Readonly {
- if (txInfo.error !== "") {
- return txInfo;
- }
+): Promise {
+ const depositAmount = convert(false, ICKB_DEPOSIT_CAP, context.system.exchangeRatio);
+ const depositQuotient = depositAmount === 0n ? 0n : amount / depositAmount;
+ const maxDeposits =
+ depositQuotient > BigInt(MAX_DIRECT_DEPOSITS)
+ ? MAX_DIRECT_DEPOSITS
+ : Number(depositQuotient);
- const ickbPool: MyExtendedDeposit[] = [];
- if (!isCkb2Udt) {
- // Filter deposits
- let ickbCumulative = 0n;
- for (const d of deposits) {
- const c = ickbCumulative + d.ickbValue;
- if (c > amount) {
- continue;
+ return findBestAttempt(maxDeposits, async (depositCount) => {
+ try {
+ let tx = baseTx.clone();
+ let estimatedMaturity = context.estimatedMaturity;
+
+ if (depositCount > 0) {
+ tx = await walletConfig.managers.logic.deposit(
+ tx,
+ depositCount,
+ depositAmount,
+ walletConfig.primaryLock,
+ walletConfig.cccClient,
+ );
}
- ickbCumulative = c;
- ickbPool.push(Object.freeze({ ...d, ickbCumulative }));
- if (ickbPool.length >= 30) {
- break;
+
+ const remainder = amount - depositAmount * BigInt(depositCount);
+ if (remainder > 0n) {
+ const amounts = { ckbValue: remainder, udtValue: 0n };
+ const estimate = IckbSdk.estimate(true, amounts, context.system);
+ if (estimate.maturity === undefined) {
+ return txInfoWithError("Amount too small to build a transaction", estimatedMaturity);
+ }
+
+ estimatedMaturity = maxMaturity(estimatedMaturity, estimate.maturity);
+ tx = await walletConfig.sdk.request(
+ tx,
+ walletConfig.primaryLock,
+ estimate.info,
+ amounts,
+ );
}
+
+ return await finalizeTransaction(tx, estimatedMaturity, walletConfig);
+ } catch (error) {
+ return txInfoWithError(errorMessageOf(error), context.estimatedMaturity);
}
- }
- Object.freeze(ickbPool);
-
- const ratio = calculateOrderRatio(isCkb2Udt, tipHeader);
- const depositAmount = ckbSoftCapPerDeposit(tipHeader);
- const N = isCkb2Udt ? Number(amount / depositAmount) : ickbPool.length;
- const txCache = Array(N);
- const attempt = (n: number): Readonly => {
- n = N - n;
- return (txCache[n] =
- txCache[n] ??
- convertAttempt(
- n,
- isCkb2Udt,
- amount,
- txInfo,
- ratio,
- depositAmount,
- ickbPool,
- tipHeader,
- calculateFee,
- walletConfig,
- ));
- };
- return Object.freeze(
- attempt(binarySearch(N, (n) => attempt(n).error === "")),
- );
+ });
}
-function convertAttempt(
- quantity: number,
- isCkb2Udt: boolean,
+async function buildIckbToCkbPreview(
+ baseTx: ccc.Transaction,
+ context: TransactionContext,
amount: bigint,
- txInfo: TxInfo,
- ratio: OrderRatio,
- depositAmount: bigint,
- ickbPool: readonly MyExtendedDeposit[],
- tipHeader: I8Header,
- calculateFee: (tx: TransactionSkeletonType) => bigint,
walletConfig: WalletConfig,
-): ConversionAttempt {
- let { tx } = txInfo;
- const { accountLocks, config } = walletConfig;
- const estimatedMaturities = [txInfo.estimatedMaturity];
- if (quantity > 0) {
- if (isCkb2Udt) {
- amount -= depositAmount * BigInt(quantity);
- if (amount < 0n) {
- return {
- ...txInfo,
- error: "Too many Deposits respectfully to the amount",
- };
- }
- tx = ickbDeposit(tx, quantity, depositAmount, config);
- tx = addReceiptDepositsChange(tx, accountLocks[0], config);
- } else {
- if (ickbPool.length < quantity) {
- return {
- ...txInfo,
- error: "Not enough Deposits to withdraw from",
- };
- }
- amount -= ickbPool[quantity - 1].ickbCumulative;
- if (amount < 0n) {
- return {
- ...txInfo,
- error: "Too many Withdrawal Requests respectfully to the amount",
- };
+): Promise {
+ const deposits = await collect(
+ walletConfig.managers.logic.findDeposits(walletConfig.cccClient, {
+ onChain: true,
+ tip: context.system.tip,
+ }),
+ );
+
+ const candidates = deposits
+ .filter((deposit) => deposit.isReady)
+ .sort((left, right) => compareBigInt(
+ left.maturity.toUnix(context.system.tip),
+ right.maturity.toUnix(context.system.tip),
+ ));
+
+ return findBestAttempt(
+ Math.min(candidates.length, MAX_WITHDRAWAL_REQUESTS),
+ async (withdrawalCount) => {
+ try {
+ let tx = ccc.Transaction.default();
+ let estimatedMaturity = context.estimatedMaturity;
+ let remainder = amount;
+
+ if (withdrawalCount > 0) {
+ const selectedDeposits = selectReadyDeposits(
+ candidates,
+ withdrawalCount,
+ remainder,
+ );
+ if (selectedDeposits.length !== withdrawalCount) {
+ return txInfoWithError(
+ "Not enough ready deposits to convert now",
+ estimatedMaturity,
+ );
+ }
+
+ tx = await walletConfig.managers.ownedOwner.requestWithdrawal(
+ tx,
+ selectedDeposits,
+ walletConfig.primaryLock,
+ walletConfig.cccClient,
+ );
+
+ remainder -= sum(0n, ...selectedDeposits.map((deposit) => deposit.udtValue));
+ for (const deposit of selectedDeposits) {
+ estimatedMaturity = maxMaturity(
+ estimatedMaturity,
+ deposit.maturity.toUnix(context.system.tip),
+ );
+ }
+ }
+
+ tx = appendTransaction(tx, baseTx);
+
+ if (remainder > 0n) {
+ const amounts = { ckbValue: 0n, udtValue: remainder };
+ const estimate = IckbSdk.estimate(false, amounts, context.system);
+ if (estimate.maturity === undefined) {
+ return txInfoWithError("Amount too small to build a transaction", estimatedMaturity);
+ }
+
+ estimatedMaturity = maxMaturity(estimatedMaturity, estimate.maturity);
+ tx = await walletConfig.sdk.request(
+ tx,
+ walletConfig.primaryLock,
+ estimate.info,
+ amounts,
+ );
+ }
+
+ return await finalizeTransaction(tx, estimatedMaturity, walletConfig);
+ } catch (error) {
+ return txInfoWithError(errorMessageOf(error), context.estimatedMaturity);
}
- ickbPool = ickbPool.slice(0, quantity);
- const deposits = ickbPool.map((d) => d.deposit);
- tx = ickbRequestWithdrawalFrom(tx, deposits, config);
- tx = addOwnedWithdrawalRequestsChange(tx, accountLocks[0], config);
- estimatedMaturities.push(...ickbPool.map((d) => d.estimatedMaturity));
- }
- }
+ },
+ );
+}
- let orderFee = 0n;
- if (amount > 0n) {
- tx = orderMint(
- tx,
- accountLocks[0],
- config,
- isCkb2Udt ? amount : undefined,
- isCkb2Udt ? undefined : amount,
- isCkb2Udt ? ratio : undefined,
- isCkb2Udt ? undefined : ratio,
+async function finalizeTransaction(
+ tx: ccc.Transaction,
+ estimatedMaturity: bigint,
+ walletConfig: WalletConfig,
+): Promise {
+ tx = await walletConfig.managers.ickbUdt.completeBy(tx, walletConfig.signer);
+ await tx.completeFeeBy(walletConfig.signer);
+
+ if (await ccc.isDaoOutputLimitExceeded(tx, walletConfig.cccClient)) {
+ throw new Error(
+ `NervosDAO transaction has ${String(tx.outputs.length)} output cells, exceeding the limit of 64`,
);
+ }
- const convertedAmount = calculateOrderResult(isCkb2Udt, amount, ratio);
- orderFee += isCkb2Udt
- ? amount - ickb2Ckb(convertedAmount, tipHeader)
- : ickb2Ckb(amount, tipHeader) - convertedAmount;
+ return Object.freeze({
+ tx,
+ error: "",
+ fee: await tx.getFee(walletConfig.cccClient),
+ estimatedMaturity,
+ });
+}
- estimatedMaturities.push(
- orderMaturityEstimate(isCkb2Udt, amount, tipHeader),
- );
+async function findBestAttempt(
+ maxQuantity: number,
+ build: (quantity: number) => Promise,
+): Promise {
+ let firstError: TxInfo | undefined;
+ for (let quantity = maxQuantity; quantity >= 0; quantity -= 1) {
+ const attempt = await build(quantity);
+ if (attempt.error === "") {
+ return attempt;
+ }
+
+ firstError ??= attempt;
}
- const estimatedMaturity = maxEpoch(estimatedMaturities);
+ return firstError ?? txInfoWithError("Nothing to do for now", 0n);
+}
- txInfo = addChange(
- { ...txInfo, tx, estimatedMaturity, fee: txInfo.fee + orderFee },
- calculateFee,
- walletConfig,
- );
+function selectReadyDeposits(
+ deposits: IckbDepositCell[],
+ wanted: number,
+ amount: bigint,
+): IckbDepositCell[] {
+ const selected: IckbDepositCell[] = [];
+ let cumulative = 0n;
+
+ for (const deposit of deposits) {
+ if (selected.length >= wanted) {
+ break;
+ }
- // Check that order provides enough fee to the bot for being matched
- if (!txInfo.error && 10n * (txInfo.fee - orderFee) > orderFee) {
- if (isCkb2Udt) {
- return { ...txInfo, error: "CKB amount too small" };
- } else {
- return { ...txInfo, error: "iCKB amount too small" };
+ if (cumulative + deposit.udtValue > amount) {
+ continue;
}
+
+ cumulative += deposit.udtValue;
+ selected.push(deposit);
}
- return txInfo;
+
+ return selected;
}
-export function addChange(
- txInfo: TxInfo,
- calculateFee: (tx: TransactionSkeletonType) => bigint,
- walletConfig: WalletConfig,
-): Readonly<{
- tx: TransactionSkeletonType;
- error: string;
- fee: bigint;
- estimatedMaturity: EpochSinceValue;
-}> {
- const { accountLocks, config } = walletConfig;
- const { tx: intermediateTx, freeIckbUdt: freeIckb } = addIckbUdtChange(
- txInfo.tx,
- accountLocks[0],
- config,
- );
- const { tx, txFee, freeCkb } = addCkbChange(
- intermediateTx,
- accountLocks[0],
- calculateFee,
- config,
- );
+function appendTransaction(
+ target: ccc.Transaction,
+ source: ccc.Transaction,
+): ccc.Transaction {
+ for (const cellDep of source.cellDeps) {
+ target.addCellDeps(cellDep);
+ }
- const fee = txInfo.fee + txFee;
- txInfo = { ...txInfo, tx, fee };
+ for (const headerDep of source.headerDeps) {
+ if (!target.headerDeps.some((hash) => hash === headerDep)) {
+ target.headerDeps.push(headerDep);
+ }
+ }
- if (freeCkb < 0n) {
- return { ...txInfo, error: "Not enough CKB" };
+ for (const input of source.inputs) {
+ target.inputs.push(input);
}
- if (freeIckb < 0n) {
- return { ...txInfo, error: "Not enough iCKB" };
+ target.outputs.push(...source.outputs);
+ target.outputsData.push(...source.outputsData);
+ target.witnesses.push(...source.witnesses);
+
+ return target;
+}
+
+function txInfoWithError(error: string, estimatedMaturity: bigint): TxInfo {
+ return Object.freeze({
+ ...txInfoPadding,
+ error,
+ estimatedMaturity,
+ });
+}
+
+function compareBigInt(left: bigint, right: bigint): number {
+ if (left < right) {
+ return -1;
}
- if (tx.outputs.size > 64) {
- return { ...txInfo, error: "More than 64 output cells" };
+ if (left > right) {
+ return 1;
}
- return txInfo;
+ return 0;
+}
+
+function maxMaturity(left: bigint, right: bigint): bigint {
+ return left > right ? left : right;
}
diff --git a/apps/interface/src/utils.ts b/apps/interface/src/utils.ts
index 9935b94..8058659 100644
--- a/apps/interface/src/utils.ts
+++ b/apps/interface/src/utils.ts
@@ -1,160 +1,121 @@
-import type { Cell, HexString } from "@ckb-lumos/base";
-import {
- TransactionSkeleton,
- type TransactionSkeletonType,
-} from "@ckb-lumos/helpers";
+import { ccc } from "@ckb-ccc/ccc";
import type { QueryClient } from "@tanstack/react-query";
-import {
- CKB,
- epochSinceAdd,
- epochSinceCompare,
- type ChainConfig,
- type I8Header,
- type I8Script,
-} from "@ickb/lumos-utils";
-import { parseEpoch, type EpochSinceValue } from "@ckb-lumos/base/lib/since";
-import { ickbExchangeRatio, type OrderRatio } from "@ickb/v1-core";
-
-export interface RootConfig extends ChainConfig {
+import type { IckbUdt, LogicManager, OwnedOwnerManager } from "@ickb/core";
+import type { OrderManager } from "@ickb/order";
+import type { IckbSdk } from "@ickb/sdk";
+
+export interface RootConfig {
+ chain: "mainnet" | "testnet";
+ cccClient: ccc.Client;
queryClient: QueryClient;
+ sdk: IckbSdk;
+ managers: {
+ ickbUdt: IckbUdt;
+ logic: LogicManager;
+ ownedOwner: OwnedOwnerManager;
+ order: OrderManager;
+ };
}
export interface WalletConfig extends RootConfig {
- address: HexString;
- accountLocks: I8Script[];
- expander: (c: Cell) => I8Script | undefined;
- getTxSizeOverhead: (tx: TransactionSkeletonType) => Promise;
- sendSigned: (tx: TransactionSkeletonType) => Promise<`0x${string}`>;
+ signer: ccc.Signer;
+ address: string;
+ accountLocks: ccc.Script[];
+ primaryLock: ccc.Script;
}
-export function symbol2Direction(s: string): boolean {
- return s === "C";
-}
+export type TxInfo = Readonly<{
+ tx: ccc.Transaction;
+ error: string;
+ fee: bigint;
+ estimatedMaturity: bigint;
+}>;
-export function direction2Symbol(d: boolean): string {
- return d ? "C" : "I";
+export const txInfoPadding: TxInfo = Object.freeze({
+ tx: ccc.Transaction.default(),
+ error: "",
+ fee: 0n,
+ estimatedMaturity: 0n,
+});
+
+export const CKB = ccc.fixedPointFrom(1);
+
+// reservedCKB are reserved for state rent in conversions
+export const reservedCKB = 600n * CKB;
+
+export function symbol2Direction(symbol: string): boolean {
+ return symbol !== "I";
}
-export function sanitize(text: string): string {
- // Filter leading zeros
- let i = 0;
- for (; i < text.length; i++) {
- const c = text[i];
- if (("1" <= c && c <= "9") || c === ".") {
- break;
- }
- }
+export function direction2Symbol(isCkb2Udt: boolean): string {
+ return isCkb2Udt ? "C" : "I";
+}
- //Filter decimal part
- let dot = "";
- const decimalChars: string[] = [];
- for (; i < text.length; i++) {
- const c = text[i];
- if ("0" <= c && c <= "9") {
- decimalChars.push(c);
- } else if (c == ".") {
- dot = ".";
- break;
+export function sanitizeAmountInput(text: string): string {
+ let sanitized = "";
+ let seenDot = false;
+ let fractionalDigits = 0;
+
+ for (const char of text) {
+ if (char >= "0" && char <= "9") {
+ if (!seenDot) {
+ sanitized += char;
+ } else if (fractionalDigits < 8) {
+ sanitized += char;
+ fractionalDigits += 1;
+ }
+ continue;
}
- }
- //Filter fractional part
- const fractionalChars: string[] = [];
- for (; i < text.length && fractionalChars.length < 8; i++) {
- const c = text[i];
- if ("0" <= c && c <= "9") {
- fractionalChars.push(c);
+ if (char === "." && !seenDot) {
+ sanitized = sanitized === "" ? "0." : `${sanitized}.`;
+ seenDot = true;
}
}
- return (
- (decimalChars.length > 0
- ? BigInt(decimalChars.join("")).toLocaleString("en-US")
- : dot.length > 0
- ? "0"
- : "") +
- dot +
- fractionalChars.join("")
- );
+ return sanitized;
}
-export function toText(n: bigint): string {
- return (
- (n / CKB).toLocaleString("en-US") +
- String(Number(n % CKB) / Number(CKB)).slice(1)
- );
+export function toText(amount: bigint): string {
+ const text = ccc.fixedPointToString(amount);
+ return text.replace(/(\.\d*?[1-9])0+$/u, "$1").replace(/\.0*$/u, "");
}
export function toBigInt(text: string): bigint {
- const [decimal, ...fractionals] = text.split(",").join("").split(".");
- return BigInt(decimal + (fractionals.join("") + "00000000").slice(0, 8));
-}
-
-// Estimate bot ability to fulfill orders:
-// - CKB to iCKB orders at 100k CKB every minute
-// - iCKB to CKB orders at 200 CKB every minute
-export function orderMaturityEstimate(
- isCkb2Udt: boolean,
- amount: bigint,
- tipHeader: I8Header,
-): Readonly {
- return Object.freeze(
- epochSinceAdd(parseEpoch(tipHeader.epoch), {
- number: 0,
- index: 1 + Number(amount / (isCkb2Udt ? 100000n * CKB : 200n * CKB)),
- length: 4 * 60,
- }),
- );
-}
+ if (text === "") {
+ return 0n;
+ }
-export function maxEpoch(ee: EpochSinceValue[]): EpochSinceValue {
- return ee.reduce((a, b) => (epochSinceCompare(a, b) === -1 ? b : a));
+ const [wholePart, fractionalPart = ""] = text.split(".", 2);
+ const whole = wholePart === "" ? "0" : wholePart;
+ const fraction = (fractionalPart + "00000000").slice(0, 8);
+ return BigInt(whole) * CKB + BigInt(fraction);
}
-export const epochSinceValuePadding = Object.freeze({
- number: 0,
- index: 0,
- length: 1,
-});
+export function errorMessageOf(error: unknown): string {
+ if (error instanceof Error && error.message) {
+ return error.message;
+ }
-export type TxInfo = Readonly<{
- tx: TransactionSkeletonType;
- error: string;
- fee: bigint;
- estimatedMaturity: EpochSinceValue;
-}>;
+ if (typeof error === "string") {
+ return error;
+ }
-export const txInfoPadding: TxInfo = Object.freeze({
- tx: TransactionSkeleton(),
- error: "",
- fee: 0n,
- estimatedMaturity: epochSinceValuePadding,
-});
+ if (typeof error === "object" && error !== null) {
+ try {
+ return JSON.stringify(error);
+ } catch {
+ return "Unknown error";
+ }
+ }
-// reservedCKB are reserved for state rent in conversions
-export const reservedCKB = 600n * CKB;
+ if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+ return String(error);
+ }
-// Calculate ratio in a way to pay 0.001% fee to bot
-export function calculateOrderRatio(
- isCkb2Udt: boolean,
- tipHeader: I8Header,
-): OrderRatio {
- const { ckbMultiplier, udtMultiplier } = ickbExchangeRatio(tipHeader);
- return {
- ckbMultiplier,
- udtMultiplier:
- // Pay 0.001% fee to bot
- udtMultiplier + (isCkb2Udt ? 1n : -1n) * (udtMultiplier / 100000n),
- };
+ return "Unknown error";
}
-export function calculateOrderResult(
- isCkb2Udt: boolean,
- amount: bigint,
- ratio: OrderRatio,
-): bigint {
- const { ckbMultiplier, udtMultiplier } = ratio;
- return isCkb2Udt
- ? (amount * ckbMultiplier) / udtMultiplier
- : (amount * udtMultiplier) / ckbMultiplier;
+export function hasTransactionActivity(tx: ccc.Transaction): boolean {
+ return tx.inputs.length > 0 || tx.outputs.length > 0;
}
diff --git a/apps/interface/vite.config.ts b/apps/interface/vite.config.ts
index e543e4d..ecbc54f 100644
--- a/apps/interface/vite.config.ts
+++ b/apps/interface/vite.config.ts
@@ -1,22 +1,56 @@
import tailwindcss from "@tailwindcss/vite";
import basicSsl from "@vitejs/plugin-basic-ssl";
import react from "@vitejs/plugin-react";
+import { fileURLToPath } from "node:url";
import { defineConfig } from "vite";
+const monorepoRoot = fileURLToPath(new URL("../..", import.meta.url));
+
// Local CCC iteration resolves built output from forks/ccc/repo, so the
// interface no longer needs the old raw-fork-source Babel/shim escape hatches.
// https://vitejs.dev/config/
export default defineConfig({
+ resolve: {
+ alias: {
+ "@ickb/core": fileURLToPath(
+ new URL("../../packages/core/dist/index.js", import.meta.url),
+ ),
+ "@ickb/order": fileURLToPath(
+ new URL("../../packages/order/dist/index.js", import.meta.url),
+ ),
+ "@ickb/sdk": fileURLToPath(
+ new URL("../../packages/sdk/dist/index.js", import.meta.url),
+ ),
+ "@ickb/utils": fileURLToPath(
+ new URL("../../packages/utils/dist/index.js", import.meta.url),
+ ),
+ },
+ },
server: {
host: true,
},
plugins: [
tailwindcss(),
react({
+ include: [/\.[jt]sx?$/u],
+ exclude: [
+ /\/packages\/core\/src\//u,
+ /\/packages\/order\/src\//u,
+ /\/packages\/sdk\/src\//u,
+ /\/packages\/utils\/src\//u,
+ ],
babel: {
plugins: [["babel-plugin-react-compiler"]],
},
}),
basicSsl(),
],
+ optimizeDeps: {
+ exclude: ["@ickb/core", "@ickb/order", "@ickb/sdk", "@ickb/utils"],
+ },
+ build: {
+ commonjsOptions: {
+ include: [/node_modules/u, new RegExp(`${monorepoRoot}/packages/.+/dist/`)],
+ },
+ },
});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b52269e..6fdd061 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -108,36 +108,21 @@ importers:
'@ckb-ccc/ccc':
specifier: workspace:*
version: link:../../forks/ccc/repo/packages/ccc
- '@ckb-lumos/base':
- specifier: ^0.23.0
- version: 0.23.0
- '@ckb-lumos/codec':
- specifier: ^0.23.0
- version: 0.23.0
- '@ckb-lumos/common-scripts':
- specifier: ^0.23.0
- version: 0.23.0
- '@ckb-lumos/config-manager':
- specifier: ^0.23.0
- version: 0.23.0
- '@ckb-lumos/helpers':
- specifier: ^0.23.0
- version: 0.23.0
- '@ckb-lumos/rpc':
- specifier: ^0.23.0
- version: 0.23.0
- '@ickb/lumos-utils':
- specifier: 1.4.2
- version: 1.4.2
- '@ickb/v1-core':
- specifier: 1.4.2
- version: 1.4.2
+ '@ickb/core':
+ specifier: workspace:*
+ version: link:../../packages/core
+ '@ickb/order':
+ specifier: workspace:*
+ version: link:../../packages/order
+ '@ickb/sdk':
+ specifier: workspace:*
+ version: link:../../packages/sdk
+ '@ickb/utils':
+ specifier: workspace:*
+ version: link:../../packages/utils
'@tanstack/react-query':
specifier: ^5.90.5
version: 5.100.9(react@19.2.5)
- immutable:
- specifier: ^4.3.7
- version: 4.3.8
react:
specifier: ^19.2.0
version: 19.2.5
From a85520a157f8b36b20f70c78203a3f57fe62ae66 Mon Sep 17 00:00:00 2001
From: phroi <90913182+phroi@users.noreply.github.com>
Date: Tue, 5 May 2026 17:28:21 +0000
Subject: [PATCH 2/3] fix: bound interface confirmation polling
Stop the CCC confirmation loop from waiting forever when a transaction never reaches a terminal state. Surface a timeout error instead so the interface can recover and the user gets a concrete failure message.
---
apps/interface/src/Action.tsx | 14 ++++++++++++--
1 file changed, 12 insertions(+), 2 deletions(-)
diff --git a/apps/interface/src/Action.tsx b/apps/interface/src/Action.tsx
index 1f74ff6..07c6992 100644
--- a/apps/interface/src/Action.tsx
+++ b/apps/interface/src/Action.tsx
@@ -130,6 +130,7 @@ async function transact(
walletConfig: WalletConfig,
): Promise {
const { address, chain, cccClient, queryClient, signer } = walletConfig;
+ const maxConfirmationChecks = 60;
try {
freezeTxInfo(txInfo);
@@ -138,14 +139,23 @@ async function transact(
const txHash = await signer.sendTransaction(txInfo.tx);
let status: string | undefined = "sent";
- while (status === undefined || ["sent", "pending", "proposed"].includes(status)) {
+ let checks = 0;
+ while (
+ checks < maxConfirmationChecks &&
+ (status === undefined || ["sent", "pending", "proposed"].includes(status))
+ ) {
setMessage("Waiting for network confirmation...");
await new Promise((resolve) => setTimeout(resolve, 10000));
status = (await cccClient.getTransaction(txHash))?.status;
+ checks += 1;
+ }
+
+ if (checks >= maxConfirmationChecks) {
+ throw new Error("Transaction confirmation timed out");
}
if (status !== "committed") {
- throw new Error(`Transaction ended with status: ${status}`);
+ throw new Error(`Transaction ended with status: ${status ?? "unknown"}`);
}
setMessage("Transaction confirmed.");
From 1d2cd031a00bd2b27b1b9b30defb920cca04f98a Mon Sep 17 00:00:00 2001
From: phroi <90913182+phroi@users.noreply.github.com>
Date: Tue, 5 May 2026 17:49:39 +0000
Subject: [PATCH 3/3] fix: harden interface CCC startup and refresh
Guard the JoyID signer lookup so the app fails with a concrete error when no CKB signer is available, and trim redundant refresh work in the confirmation path. Keep the exact cell search path direct by dropping a now-redundant lock equality recheck.
---
apps/interface/src/Action.tsx | 1 -
apps/interface/src/main.tsx | 10 +++++++---
apps/interface/src/queries.ts | 4 ----
3 files changed, 7 insertions(+), 8 deletions(-)
diff --git a/apps/interface/src/Action.tsx b/apps/interface/src/Action.tsx
index 07c6992..0a51c37 100644
--- a/apps/interface/src/Action.tsx
+++ b/apps/interface/src/Action.tsx
@@ -160,7 +160,6 @@ async function transact(
setMessage("Transaction confirmed.");
formReset();
- await queryClient.invalidateQueries({ queryKey: [chain, address] });
await new Promise((resolve) => setTimeout(resolve, 2000));
} catch (error) {
setFailure(errorMessageOf(error));
diff --git a/apps/interface/src/main.tsx b/apps/interface/src/main.tsx
index b31d7eb..e020ecb 100644
--- a/apps/interface/src/main.tsx
+++ b/apps/interface/src/main.tsx
@@ -43,12 +43,16 @@ export function startApp(walletChain: string): void {
const [walletName, chain] = walletChain.split("_");
const rootConfig = chain === "mainnet" ? rootConfigs.mainnet : rootConfigs.testnet;
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- const signer = JoyId.getJoyIdSigners(
+ const signerInfo = JoyId.getJoyIdSigners(
rootConfig.cccClient,
appName,
["https://ickb.org", appIcon].join(""),
- ).find((candidate) => candidate.name === "CKB")!.signer;
+ ).find((candidate) => candidate.name === "CKB");
+ if (!signerInfo) {
+ throw new Error("CKB signer not found. Please ensure it is enabled in your JoyID app.");
+ }
+
+ const { signer } = signerInfo;
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const rootElement = document.getElementById("app")!;
diff --git a/apps/interface/src/queries.ts b/apps/interface/src/queries.ts
index c60cb90..140b5e5 100644
--- a/apps/interface/src/queries.ts
+++ b/apps/interface/src/queries.ts
@@ -180,10 +180,6 @@ async function getAccountCells(walletConfig: WalletConfig): Promise
"asc",
400,
)) {
- if (!cell.cellOutput.lock.eq(lock)) {
- continue;
- }
-
cells.push(cell);
}
}