@ickb/sdk 1000.0.82 → 9001.0.0

package/README.md

@@ -1,35 +1,87 @@
-# iCKB/SDK
-
-iCKB SDK built on top of CCC
-
-## Dependencies
-
-```mermaid
-graph TD;
-    A["@ickb/utils"] --> B["@ckb-ccc/core"];
-    C["@ickb/dao"] --> A;
-    C --> B;
-    D["@ickb/core"] --> A;
-    D --> C;
-    E["@ickb/order"] --> A;
-    E --> B;
-    F["@ickb/sdk"] --> A;
-    F --> C;
-    F --> D;
-    F --> E;
-
-    click A "https://github.com/ickb/utils" "Go to @ickb/utils"
-    click B "https://github.com/ckb-devrel/ccc/tree/master/packages/core" "Go to @ckb-ccc/core"
-    click C "https://github.com/ickb/dao" "Go to @ickb/dao"
-    click D "https://github.com/ickb/core" "Go to @ickb/core"
-    click E "https://github.com/ickb/order" "Go to @ickb/order"
-    click F "https://github.com/ickb/sdk" "Go to @ickb/sdk"
-```
-
-## Epoch Semantic Versioning
-
-This repository follows [Epoch Semantic Versioning](https://antfu.me/posts/epoch-semver). In short ESV aims to provide a more nuanced and effective way to communicate software changes, allowing for better user understanding and smoother upgrades.
+# iCKB SDK
+
+`@ickb/sdk` builds iCKB conversions on CCC. Construct it with `IckbSdk.fromChain(chain)`, read account state, build a funded transaction, then sign, send and wait. The public surface follows that workflow and includes the types its signatures need; managers and raw deployment configuration are internal.
+
+## Layout
+
+The top-level script modules are `src/udt.ts` (iCKB), `src/logic.ts` (deposits and receipts), `src/owned_owner.ts` (requests and withdrawals) and `src/dao.ts` (shared Nervos DAO rules). The other concerns are:
+
+- `src/order/`: UDT limit orders and matching.
+- `src/conversion/`: state projection, estimates, plans, the withdrawal ring and completion.
+- `src/send/`: signing, broadcast and confirmation.
+- `src/utils/`: shared readers and codecs.
+
+`src/index.ts` is the only barrel. The package has one runtime dependency, `@ckb-ccc/core`, and no Node built-ins. A separate DAO manager layer had one caller per operation and no raw-DAO consumer, so those operations now live with the iCKB script that uses them. Internal barrels and alternate public entry points would recreate boundaries without another consumer.
+
+## Account state
+
+`getL1AccountState(client, locks, lockUp, maxFeeRate?)` reads the account, pool and order book; `maxFeeRate` caps the node's sampled fee rate through CCC's `getFeeRate` (a cap of zero or less throws `RangeError`), so every consumer of the state (completion, the planned fee, the collect rule, estimates) plans at one rate. The caller supplies a `LockUpPolicy`, carried on `system.lockUp`; deposits carry a sampled `claimEpoch`, and readers apply the caller's policy to decide readiness. [`src/dao.ts`](src/dao.ts) defines the wallet and bot presets. A human can leave a wallet popup open, so the wallet's selection and broadcast margins are wider than the bot's.
+
+Each account lock is scanned once, unfiltered, then classified by cell kind. The book is also read once: the market sees orders past par, while the account sees its own orders. An older order from the same wallet legitimately queues ahead of its new one. Dual-ratio orders are valid on chain but excluded by the scan because Stack neither places nor handles them; they are not matched, estimated, displayed or collected here.
+
+Every cell scan uses the uncached [`findCells`](src/utils/utils.ts) loop with pages of 400, ending on the first short page. It reads the indexer's raw answer through the client's JSON-RPC requestor, because the answer carries each cell's block number and CCC's typed scan drops it: receipts, deposits and withdrawal requests then read their committing header by number, instead of asking the node for each creating transaction's status first. The number is the node's claim either way. The SDK needs a JSON-RPC client for its raw reads (scans, status polls, transaction proofs); the connector's composition proxy forwards the requestor. It keeps no typed fallback for other clients: none exists in CCC, and two code paths per read had to be kept equivalent. Pages stay at 400 because CKB's sample config recommends that `request_limit`, and a node configured with it refuses a larger page rather than truncating it. There is no aggregate scan budget or page-size option: a large account or book costs a slower read rather than a partial result. A full page whose cursor does not advance throws. The cursor is only a continuation key, not a snapshot; one traversal can return a cell and its successor. Planning must tolerate that rather than assume page coherence.
+
+Transaction and header reads are batched before pure decoding. This replaced promise caches and batch-specific reader wrappers; each deposit carries its value instead of being valued again downstream. CCC's speculative broadcast cache is not authority for committed cells. An order is dated by its master's block from the scan: the master is created beside the mint order and never changes until melted, so no status read is needed; its origin transaction is read cache first, a cached body trusted like the scan itself, since the send checks every cell it spends.
+
+Every node read in `getL1AccountState` and `signAndSendTransaction` goes through a wrapper the SDK puts on the client it is given, so a consumer passes a plain client and cannot forget. Completion and signing read through the signer's client and `waitTransaction` through the plain one: the send verifies every cell completion valued before signing, witnesses and cell deps are the signer's, and a transaction status has nothing to verify against. The wrapper checks every header against its own hash, a header read by number against the number asked for, and a transaction read by hash against the hash of its body; it serves a cell from that verified body, cache first, re-hashing a cache hit since a consumer's cache need not key bodies by their hash. A header's DAO rate sets the interest a withdrawal collects and the iCKB a deposit is worth. CCC's fee completion values that interest through the signer's client, which the SDK does not wrap, at whatever header the node names; the [send](#signing-and-broadcast) measures the fee from verified values and refuses one above what completion planned. The header beside a transaction or a cell is pinned only to the block the node names for it; the chain values a transaction at the headers it names in its deps, and the [send check](#signing-and-broadcast) refuses an input valued outside them and proves which block committed a withdrawal request. The state read is anchored at the tip's parent, which is bound two ways. Its age against the local clock, the selection margin less the broadcast reserve (five minutes for the bot, thirty for a wallet), catches an honest node that has fallen behind; the bound is on the parent, not the tip, because a fresh tip a node invented can name any old block as its parent. Completion names the parent as a header dep, so a header a node invented prices nothing the chain accepts. The send's deadline check reads the live tip under the same age bound. The bot, the generator and the interface open their clients with `clientCache()`: CCC's default cache keeps 128 blocks and 256 transaction bodies, fewer than a pool's deposits span or a large book's order origins, so every read refetched most of them; the larger cache holds 4096 of each, filling only as far as needed, and a cached header or body is still checked.
+
+## Transaction completion
+
+`buildConversionTransaction(...)` returns a completed transaction funded from the cells in its state read. It never discovers more inputs while trying candidates. The [root user-lock assumption](../README.md#user-locks) applies to both the wallet's lock and a caller-supplied destination.
+
+The SDK tries the most direct plan first and returns the first that completes. Completion is the only authority on affordability: markers, remainder orders, change and fees all affect the answer. Removing one withdrawal can introduce a remainder order costing more capacity than the removed marker, so binary search or a policy-side count bound would be wrong. Typed fundability failures advance the walk; transport, scan, signer and malformed-transaction failures propagate. When every candidate fails, the last fundability failure is thrown.
+
+The ready-deposit selection excludes [ring anchors](node/docs/policy.md#rebalancing-and-the-maturity-ring) to preserve the pool's spread of maturities. If every ready deposit is an anchor, only an order plan remains.
+
+Direct-first deliberately favors a known claim date and avoiding an order fee over a faster estimated bot fill. A user may therefore receive a direct withdrawal days away even when an order could be filled in minutes. The estimate describes the chosen plan; it does not rank candidates. The greedy maturity-ordered selection also accepts a larger remainder order where an exact best-fit search could withdraw more directly. Capped deposits and the bot's regular deposit sizes reduce that cost without another combinatorial selector.
+
+### Funding and compaction
+
+Inputs needed by the outputs go in first, largest first. The completer then sweeps remaining liquid cells until the transaction has 1,000 inputs, about 50 KB. That is a compaction target, not a size bound: funding the outputs can exceed it outright, and fee completion can use cells left after the sweep. An integrator should expect a transaction to spend more of the account than the requested amount alone requires: compaction is deliberate.
+
+The sweep limit does not bound the whole transaction. Receipts and collectable orders are added in full, while required funding can exceed that limit. Large collection backlogs can therefore produce an oversized transaction; rebuilding from the same state may repeat the failure. Whole-transaction sizing remains an open design issue.
+
+Plain-cell discovery does not filter mining rewards by cellbase maturity. If the scan returns an immature reward, completion can include it and the node rejects the transaction; rebuilding can select it again until it matures. This limitation is accepted: current use cases do not justify reward-specific discovery checks and their complexity.
+
+CKB capacity and iCKB quantity stay separate, in bigint. An input's full capacity funds the transaction, but the outputs' occupied capacity, a plain change cell, any order master and the fee still have to be paid. Ordinary change remains a plain cell; existing typed outputs are never repurposed as fee change. A duplicate input is a builder defect detected by completion. Completion names the header the plan was priced at as the last header dep: a parent a node invented passes the hash checks and, dated fresh, the age bound, and its DAO rate sets the exchange ratio fills and orders are priced at, but the chain refuses a transaction whose header deps are off the main chain. Last, because the deployed dao.c reads one byte of a deposit header's index, so the deposit headers lead. That header is the tip's parent, for one more read: a tip can still lose a one-block race, and a transaction naming it is then refused after signing, as a testnet order was on 2026-10-30. Every fork recorded as an uncle in a day of each chain (257 on mainnet, 77 on testnet, to 2026-10-30) was one block deep, so a header further back would only add staleness. Receipts and deposits being withdrawn count at the iCKB value the state read gave them at their deposit headers, passed in as `protocolCells`, rather than each candidate asking the node again which block created them; a wrong value can only get the transaction refused by iCKB Logic's strict equality, and a protocol input without a value is a builder defect that throws.
+
+CCC prepares the signer and resolves the witness-aware fee; Stack owns the selected cells and output shape. Calling CCC's input collectors would introduce another discovery path with different cache and filtering rules. All candidate plans use the same sampled state.
+
+DAO output and deposit-header limits come from the deployed script, not a general consensus output cap. Their constants and reasons live in [`src/dao.ts`](src/dao.ts). Collected withdrawals' deposit headers go first, making the projection's batch of at most 256 matured withdrawals addressable regardless of other headers. The claim-epoch model test compares installed CCC with a pinned transcription of deployed `dao.c`, so a dependency regression fails the gate rather than being hidden behind a local copy.
+
+## Signing and broadcast
+
+`signAndSendTransaction(signer, tx, plannedFee, recordTxHash?, broadcastBefore?)` signs locally, then checks the body, the fee and the optional epoch deadline before sending.
+
+- Every input is verified before signing: its creating transaction is read from the client cache, else the node, and accepted only when its hash is the one the `OutPoint` names, so the output at the index is the real cell. A planned cell that differs from it in capacity, lock, type or data is rejected; an input without its cell attached is valued from that output. The default lock signs each input as its `OutPoint` only, so without this a node understating a plain cell's capacity or an iCKB amount would turn the difference into fee or a burn on a transaction that passes every other check. One `get_transaction` per distinct creating transaction not already cached.
+- Different ordered inputs, outputs or outputs data are rejected. Witnesses, `cellDeps` and `headerDeps` remain signer-owned. The fee check values the verified inputs, and a phase-2 DAO input's interest at the deposit and request headers the transaction names in its deps: CCC values that interest from headers it reads afresh, which a node can answer with another real block, while the chain reads the deps, so an input valued at a header outside them is refused. The deps alone bind the request header to some block the transaction names, not to the block that committed the input, so in a withdrawal of several requests a node could swap which named request header values which input, paying the rate drift between the two blocks times the capacity imbalance to the miner. The send therefore asks the node for each request transaction's `get_transaction_proof` against the request header it valued, and refuses unless the Merkle path from the transaction's hash reaches that header's transactions root, which the header's own hash binds. That is one call of a few hundred bytes per request transaction per send, through the client's JSON-RPC requestor, which such a send therefore needs. The proven request header is the real request block, so dao.c's rule that it come after the deposit is left to the chain; a send-side copy of that rule, added before the proof, was dropped. A proven pair never changes, but caching it saved nothing: a request is spent once, and proven again only when a failed send is rebuilt. Rejected: reading the whole block, which proves the same at up to hundreds of kilobytes; a second node, which replaces proof with trust; a planner rule valuing every request at the highest-numbered dep, which closes the swap without a call but splits withdrawals by block; an on-chain script recomputing a digest of the inputs and their headers, whose carrier cell a flow's last transaction leaves behind; and accepting the swap, the earlier choice. Deposits, receipts and their headers need no proof: iCKB Logic settles them with strict equality, so a wrong header gets the transaction refused, and a deposit header is matched by the number in the verified cell data.
+- The fee the chain will take must not exceed `plannedFee`, the fee completion priced: `tx.estimateFee(feeRate)`, which CCC's fee completion meets exactly. Completion valued phase-2 interest at whatever header the node named for the request, and a header that hashes correctly can still be one the chain does not use: a lower rate there shortens the change. Checking only CCC's maximum fee rate let that difference go to the miner, up to about 0.1 CKB per kB of transaction. Amounts are compared rather than rates, so the signed size does not matter. Rejected: re-pricing the completed transaction through a verified client, which reads the same node answer CCC read and so catches only a node changing its answer between two reads. The check also replaces CCC's maximum fee rate, which `sendTransactionNoCache` bypasses: CCC caps the rate `getFeeRate` samples at that maximum, so a fee planned from the state read's rate is within it, unless the caller passes its own `maxFeeRate`, which replaces that ceiling on purpose: the caller's cap is the ceiling, and a cap above CCC's lets a node's sample rise to it. That rate is a node statistic with no proof; the bot caps it with `BOT_MAX_FEE_RATE`, and a wallet shows the resulting fee before the user signs.
+- A withdrawal plan carries `broadcastBefore`, the earliest selected claim less the policy's reserve. After signing and the fee check, one fresh tip read rejects an expired plan with `TransactionExpiredError`, without broadcasting. Timing uses epochs because CKB has no transaction expiry and a request committed after its claim can lock the deposit for another cycle. That tip is not a header dep, so a node can show a fresh tip from before the deadline and let an expired plan through; the cost is that extra cycle, time rather than CKB, which is accepted. Checking the priced header, a dep, plus the local clock's elapsed time would close it at the cost of estimating epochs from time.
+
+`recordTxHash` receives `signed.hash()` before the send RPC starts. That local hash is authoritative; no hash returned by a node replaces it. Comparing a successful response's hash could only reject after the node had already received the transaction. A duplicate response is accepted only when it names the local hash. Every other send failure is ambiguous and throws `TransactionBroadcastError` carrying `txHash`; callers can observe that hash instead of resending. The client cache is never marked by this helper.
+
+## Confirmation
+
+`waitTransaction(client, txHash, { timeout?, interval?, signal? })` observes one already-broadcast transaction for a bounded window and resolves once the node reports commitment, at depth zero. `timeout` defaults to 60,000 ms and covers the whole wait, including in-flight client operations; it must be a non-negative safe integer no larger than a host timer delay. `interval` defaults to 2,000 ms.
+
+The client is polled with `get_transaction` verbosity 1. CCC's typed read hides a rejected transaction with a null body, so raw status is needed to preserve rejection evidence. The body is never read: no caller uses it, and a second answer from the same node would verify nothing.
+
+A terminal rejection throws `TransactionWaitError` with the hash, status and node reason. Timeout uses CCC's `ErrorClientWaitTransactionTimeout`. Aborting or timing out stops the wait, but CCC transports may still finish their in-flight work; late settlement is handled. Nothing clears or marks the cache here.
+
+Callers own what follows a closed window. The actors rebuild from committed state next turn; the app can reopen a window on the same hash without another signature or broadcast. No caller needs positive confirmation depth today; it could be added without replacing this helper. There is no durable signed-byte store, replay graph or pending overlay. Such a store would need reconciliation on every start, while duplicate intent remains an accepted consequence of rebuilding rather than persisting intent.
+
+CCC caches sufficiently old headers even across `ClientCacheMemory.clear()`. A consumer that must discard them after a failed transaction gives the client a new cache, as the [interface](../interface/README.md#wallet-session-and-client) does; a deep reorg is possible, so age alone does not make a header immutable.
+
+## Estimates and fees
+
+[Pool maturity estimates](docs/pool_maturity_estimates.md) explains the model and its limits. The default order fee lives beside the quote and plan code in [`src/conversion/estimate.ts`](src/conversion/estimate.ts). It buys a window for a bot to fill a buy before DAO growth erodes its incentive; it is not a completion guarantee.
+
+## Versioning and API checks
+
+The repository follows [Epoch Semantic Versioning](https://antfu.me/posts/epoch-semver). The [release policy](../README.md#releases) explains this rewrite's starting version.
+
+While the rewritten API has no outside consumers, its shape follows the stack's own rather than a committed API report, and a breaking change takes the next major version. API Extractor still rejects forgotten exports, so every type reachable from the entry point is importable. A frozen report and release tags would add maintenance without a compatibility promise yet; revisit the report when the new surface has published consumers.
 
 ## Licensing
 
-This source code, crafted with care by [Phroi](https://phroi.com/), is freely available on [GitHub](https://github.com/ickb/sdk) and it is released under the [MIT License](./LICENSE).
+This source code, crafted with care by [Phroi](https://phroi.com/), is freely available on [GitHub](https://github.com/ickb/stack/tree/master/sdk) and released under the [MIT License](../LICENSE).

package/dist/constants.d.ts

@@ -1,23 +1,10 @@
-import { ccc } from "@ckb-ccc/core";
-import { IckbUdtManager, LogicManager, OwnedOwnerManager } from "@ickb/core";
-import { DaoManager } from "@ickb/dao";
-import { OrderManager } from "@ickb/order";
-import { CapacityManager, type ScriptDeps } from "@ickb/utils";
-export declare function getConfig(d: "mainnet" | "testnet" | {
-    udt: ScriptDeps;
-    logic: ScriptDeps;
-    ownedOwner: ScriptDeps;
-    order: ScriptDeps;
-    dao: ScriptDeps;
-}, bots?: ccc.ScriptLike[]): {
-    managers: {
-        capacity: CapacityManager;
-        dao: DaoManager;
-        ickbUdt: IckbUdtManager;
-        logic: LogicManager;
-        ownedOwner: OwnedOwnerManager;
-        order: OrderManager;
-    };
-    bots: ccc.Script[];
-};
+import type { SdkManagers } from "./conversion/types.js";
+import type { SupportedChain } from "./utils/chain.js";
+/**
+ * The managers of one network's iCKB deployment.
+ *
+ * @remarks Builders still return partial transactions. `IckbSdk` owns the shared iCKB
+ * completion path as `sdk.completeTransaction(...)`, which callers invoke before send.
+ */
+export declare function getConfig(chain: SupportedChain): SdkManagers;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"../src/","sources":["constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAU,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAgBvE,wBAAgB,SAAS,CACvB,CAAC,EACG,SAAS,GACT,SAAS,GACT;IAEE,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC;CACjB,EACL,IAAI,GAAE,GAAG,CAAC,UAAU,EAAO,GAC1B;IACD,QAAQ,EAAE;QACR,QAAQ,EAAE,eAAe,CAAC;QAC1B,GAAG,EAAE,UAAU,CAAC;QAChB,OAAO,EAAE,cAAc,CAAC;QACxB,KAAK,EAAE,YAAY,CAAC;QACpB,UAAU,EAAE,iBAAiB,CAAC;QAC9B,KAAK,EAAE,YAAY,CAAC;KACrB,CAAC;IACF,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;CACpB,CAiDA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAKzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAwDvD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,WAAW,CAoB5D"}

package/dist/constants.js

@@ -1,95 +1,81 @@
 import { ccc } from "@ckb-ccc/core";
-import { IckbUdtManager, LogicManager, OwnedOwnerManager } from "@ickb/core";
-import { DaoManager } from "@ickb/dao";
-import { OrderManager } from "@ickb/order";
-import { CapacityManager, unique } from "@ickb/utils";
-export function getConfig(d, bots = []) {
-    if (d === "mainnet" || d === "testnet") {
-        bots = bots.concat(d === "mainnet" ? MAINNET_KNOWN_BOTS : TESTNET_KNOWN_BOTS);
-        const depGroup = d === "mainnet" ? MAINNET_DEP_GROUP : TESTNET_DEP_GROUP;
-        d = {
-            udt: from(UDT, depGroup),
-            logic: from(ICKB_LOGIC, depGroup),
-            ownedOwner: from(OWNED_OWNER, depGroup),
-            order: from(ORDER, depGroup),
-            dao: from(DAO, depGroup),
-        };
-    }
-    const capacity = CapacityManager.withAnyData();
-    const dao = new DaoManager(d.dao.script, d.dao.cellDeps);
-    const ickbUdt = new IckbUdtManager(d.udt.script, d.udt.cellDeps, d.logic.script, dao);
-    const logic = new LogicManager(d.logic.script, d.logic.cellDeps, dao, ickbUdt);
-    const ownedOwner = new OwnedOwnerManager(d.ownedOwner.script, d.ownedOwner.cellDeps, dao, ickbUdt);
-    const order = new OrderManager(d.order.script, d.order.cellDeps, ickbUdt);
-    return {
-        managers: {
-            capacity,
-            dao,
-            ickbUdt,
-            logic,
-            ownedOwner,
-            order,
-        },
-        bots: [...unique(bots.map((b) => ccc.Script.from(b)))],
-    };
-}
-function from(script, ...cellDeps) {
-    return {
-        script: ccc.Script.from(script),
-        cellDeps,
-    };
-}
-const DAO = {
+import { LogicManager } from "./logic.js";
+import { OrderManager } from "./order/order.js";
+import { OwnedOwnerManager } from "./owned_owner.js";
+import { IckbUdt } from "./udt.js";
+/** Nervos DAO type script. */
+const DAO = ccc.Script.from({
     codeHash: "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
     hashType: "type",
     args: "0x",
-};
-const UDT = {
+});
+/** Raw xUDT type script; the iCKB args are computed by `IckbUdt.typeScriptFrom`. */
+const UDT = ccc.Script.from({
     codeHash: "0x50bd8d6680b8b9cf98b73f3c08faf8b2a21914311954118ad6609be6e78a1b95",
     hashType: "data1",
-    args: "0xb73b6ab39d79390c6de90a09c96b290c331baf1798ed6f97aed02590929734e800000080",
-};
-const ICKB_LOGIC = {
+    args: "0x",
+});
+/** iCKB Logic script. */
+const ICKB_LOGIC = ccc.Script.from({
     codeHash: "0x2a8100ab5990fa055ab1b50891702e1e895c7bd1df6322cd725c1a6115873bd3",
     hashType: "data1",
     args: "0x",
-};
-const OWNED_OWNER = {
+});
+/** Owned Owner lock script. */
+const OWNED_OWNER = ccc.Script.from({
     codeHash: "0xacc79e07d107831feef4c70c9e683dac5644d5993b9cb106dca6e74baa381bd0",
     hashType: "data1",
     args: "0x",
-};
-const ORDER = {
+});
+/** Order lock script. */
+const ORDER = ccc.Script.from({
     codeHash: "0x49dfb6afee5cc8ac4225aeea8cb8928b150caf3cd92fea33750683c74b13254a",
     hashType: "data1",
     args: "0x",
-};
-const MAINNET_DEP_GROUP = ccc.CellDep.from({
-    outPoint: {
-        txHash: "0x621a6f38de3b9f453016780edac3b26bfcbfa3e2ecb47c2da275471a5d3ed165",
-        index: "0x0",
-    },
-    depType: "depGroup",
-});
-const TESTNET_DEP_GROUP = ccc.CellDep.from({
-    outPoint: {
-        txHash: "0xf7ece4fb33d8378344cab11fcd6a4c6f382fd4207ac921cf5821f30712dcd311",
-        index: "0x0",
-    },
-    depType: "depGroup",
 });
-const MAINNET_KNOWN_BOTS = [
-    {
-        codeHash: "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
-        hashType: "type",
-        args: "0xd096cb29e2f68a85a46bd6bf6cbee6327959ba64",
+/**
+ * Each network's iCKB dep group: it carries every iCKB script's code cell, xUDT's and
+ * iCKB Logic's included, so one group dep resolves them all.
+ */
+const DEPLOYMENTS = {
+    mainnet: {
+        depGroup: {
+            txHash: "0x621a6f38de3b9f453016780edac3b26bfcbfa3e2ecb47c2da275471a5d3ed165",
+            index: 0,
+        },
     },
-];
-const TESTNET_KNOWN_BOTS = [
-    {
-        codeHash: "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
-        hashType: "type",
-        args: "0xb4380110f7679ac31cefe4925485645d82bf619f",
+    testnet: {
+        depGroup: {
+            txHash: "0xf7ece4fb33d8378344cab11fcd6a4c6f382fd4207ac921cf5821f30712dcd311",
+            index: 0,
+        },
     },
-];
+};
+/**
+ * The managers of one network's iCKB deployment.
+ *
+ * @remarks Builders still return partial transactions. `IckbSdk` owns the shared iCKB
+ * completion path as `sdk.completeTransaction(...)`, which callers invoke before send.
+ */
+export function getConfig(chain) {
+    // The runtime check stands for callers outside TypeScript.
+    if (!Object.hasOwn(DEPLOYMENTS, chain)) {
+        throw new TypeError("unsupported iCKB network");
+    }
+    const { depGroup } = DEPLOYMENTS[chain];
+    const cellDeps = [ccc.CellDep.from({ outPoint: depGroup, depType: "depGroup" })];
+    const dao = { script: DAO, cellDeps };
+    const ickbUdt = new IckbUdt({
+        script: IckbUdt.typeScriptFrom(UDT, ICKB_LOGIC),
+        cellDeps,
+        logicScript: ICKB_LOGIC,
+        daoScript: DAO,
+    });
+    return {
+        ickbUdt,
+        ownedOwner: new OwnedOwnerManager(OWNED_OWNER, cellDeps, dao),
+        ickbLogic: new LogicManager(ICKB_LOGIC, cellDeps, dao),
+        order: new OrderManager(ORDER, cellDeps, ickbUdt.script),
+    };
+}
 //# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"../src/","sources":["constants.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEpC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGnC,8BAA8B;AAC9B,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,QAAQ,EAAE,oEAAoE;IAC9E,QAAQ,EAAE,MAAM;IAChB,IAAI,EAAE,IAAI;CACX,CAAC,CAAC;AAEH,oFAAoF;AACpF,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,QAAQ,EAAE,oEAAoE;IAC9E,QAAQ,EAAE,OAAO;IACjB,IAAI,EAAE,IAAI;CACX,CAAC,CAAC;AAEH,yBAAyB;AACzB,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IACjC,QAAQ,EAAE,oEAAoE;IAC9E,QAAQ,EAAE,OAAO;IACjB,IAAI,EAAE,IAAI;CACX,CAAC,CAAC;AAEH,+BAA+B;AAC/B,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IAClC,QAAQ,EAAE,oEAAoE;IAC9E,QAAQ,EAAE,OAAO;IACjB,IAAI,EAAE,IAAI;CACX,CAAC,CAAC;AAEH,yBAAyB;AACzB,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IAC5B,QAAQ,EAAE,oEAAoE;IAC9E,QAAQ,EAAE,OAAO;IACjB,IAAI,EAAE,IAAI;CACX,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,MAAM,EAAE,oEAAoE;YAC5E,KAAK,EAAE,CAAC;SACT;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,MAAM,EAAE,oEAAoE;YAC5E,KAAK,EAAE,CAAC;SACT;KACF;CACO,CAAC;AAEX;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,KAAqB;IAC7C,2DAA2D;IAC3D,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,SAAS,CAAC,0BAA0B,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,EAAE,QAAQ,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;IACjF,MAAM,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;IACtC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC;QAC1B,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,UAAU,CAAC;QAC/C,QAAQ;QACR,WAAW,EAAE,UAAU;QACvB,SAAS,EAAE,GAAG;KACf,CAAC,CAAC;IACH,OAAO;QACL,OAAO;QACP,UAAU,EAAE,IAAI,iBAAiB,CAAC,WAAW,EAAE,QAAQ,EAAE,GAAG,CAAC;QAC7D,SAAS,EAAE,IAAI,YAAY,CAAC,UAAU,EAAE,QAAQ,EAAE,GAAG,CAAC;QACtD,KAAK,EAAE,IAAI,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC;KACzD,CAAC;AACJ,CAAC"}

package/dist/conversion/estimate.d.ts

@@ -0,0 +1,33 @@
+import type { IckbDepositCell } from "../logic.js";
+import { type ValueComponents } from "../utils/utils.js";
+import type { ConversionOrderEstimate, SystemState } from "./types.js";
+/**
+ * Default order fee: 0.01%. At roughly 2% annual DAO yield this buys about two days of
+ * price headroom for a buy, versus hours at 0.001%; actual fillability also depends on
+ * mining fees. It leaves time to notice a stalled bot without charging the much larger 0.1%.
+ */
+export declare const DEFAULT_ORDER_FEE = 10n;
+/** Default order-fee denominator used by Stack conversion quotes and plans. */
+export declare const DEFAULT_ORDER_FEE_BASE = 100000n;
+/** The quote and its maturity estimate, or `undefined` when no order ratio represents it. */
+export declare function estimateConversionOrder(isCkb2Udt: boolean, amounts: ValueComponents, system: SystemState, { fee, feeBase }: {
+    fee: bigint;
+    feeBase: bigint;
+}, takenDeposits?: readonly IckbDepositCell[]): ConversionOrderEstimate | undefined;
+/**
+ * The smallest request one direction accepts as an order at the current fee rate. A
+ * CKB-to-iCKB remainder pays the default order fee, which must cover the maturity threshold
+ * of ten mining fees; an iCKB-to-CKB remainder can give its whole CKB value as the dust
+ * fee, so its value must exceed the threshold. The extra unit covers the quote's rounding,
+ * as the dust search's boundary shows; callers round up further for display.
+ */
+export declare function minimumOrderAmount(isCkb2Udt: boolean, system: SystemState): bigint;
+/**
+ * The order leg of an iCKB-to-CKB conversion: at the default fee when that fee clears the
+ * maturity threshold, else the smallest fee that does (a dust order, noticed). Either way
+ * it is dated: a sell order at par is always covered by the pool (see `maturity`).
+ */
+export declare function estimateIckbToCkbOrder(amounts: ValueComponents, system: SystemState, takenDeposits: readonly IckbDepositCell[]): (ConversionOrderEstimate & {
+    maturity: bigint;
+}) | undefined;
+//# sourceMappingURL=estimate.d.ts.map

package/dist/conversion/estimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate.d.ts","sourceRoot":"","sources":["../../src/conversion/estimate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKnD,OAAO,EAAW,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,KAAK,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAE9C,6FAA6F;AAC7F,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,WAAW,EACnB,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAClD,aAAa,GAAE,SAAS,eAAe,EAAO,GAC7C,uBAAuB,GAAG,SAAS,CAerC;AAWD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,CAOlF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,SAAS,eAAe,EAAE,GACxC,CAAC,uBAAuB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CAyB9D"}

package/dist/conversion/estimate.js

@@ -0,0 +1,117 @@
+import { OrderConversionRepresentabilityError, quoteConversion, } from "../order/conversion.js";
+import { ceilDiv } from "../utils/utils.js";
+import { maturity } from "./maturity.js";
+/**
+ * Default order fee: 0.01%. At roughly 2% annual DAO yield this buys about two days of
+ * price headroom for a buy, versus hours at 0.001%; actual fillability also depends on
+ * mining fees. It leaves time to notice a stalled bot without charging the much larger 0.1%.
+ */
+export const DEFAULT_ORDER_FEE = 10n;
+/** Default order-fee denominator used by Stack conversion quotes and plans. */
+export const DEFAULT_ORDER_FEE_BASE = 100000n;
+/** The quote and its maturity estimate, or `undefined` when no order ratio represents it. */
+export function estimateConversionOrder(isCkb2Udt, amounts, system, { fee, feeBase }, takenDeposits = []) {
+    let quote;
+    try {
+        quote = quoteConversion(isCkb2Udt, system.exchangeRatio, amounts, { fee, feeBase });
+    }
+    catch (error) {
+        if (error instanceof OrderConversionRepresentabilityError) {
+            return undefined;
+        }
+        throw error;
+    }
+    const estimatedMaturity = quote.ckbFee >= estimateMaturityFeeThreshold(system)
+        ? maturity({ info: quote.info, amounts }, system, takenDeposits)
+        : undefined;
+    return { ...quote, maturity: estimatedMaturity };
+}
+/**
+ * Returns the CKB fee threshold above which order maturity is worth estimating.
+ * This conservative proxy stays separate from partialOrderFee: the quote has no built
+ * order whose serialized size could supply that fee yet.
+ */
+function estimateMaturityFeeThreshold(system) {
+    return 10n * system.feeRate;
+}
+/**
+ * The smallest request one direction accepts as an order at the current fee rate. A
+ * CKB-to-iCKB remainder pays the default order fee, which must cover the maturity threshold
+ * of ten mining fees; an iCKB-to-CKB remainder can give its whole CKB value as the dust
+ * fee, so its value must exceed the threshold. The extra unit covers the quote's rounding,
+ * as the dust search's boundary shows; callers round up further for display.
+ */
+export function minimumOrderAmount(isCkb2Udt, system) {
+    const threshold = estimateMaturityFeeThreshold(system) + 1n;
+    if (isCkb2Udt) {
+        return ceilDiv(threshold * DEFAULT_ORDER_FEE_BASE, DEFAULT_ORDER_FEE);
+    }
+    const { ckbScale, udtScale } = system.exchangeRatio;
+    return ceilDiv(threshold * ckbScale, udtScale);
+}
+/**
+ * The order leg of an iCKB-to-CKB conversion: at the default fee when that fee clears the
+ * maturity threshold, else the smallest fee that does (a dust order, noticed). Either way
+ * it is dated: a sell order at par is always covered by the pool (see `maturity`).
+ */
+export function estimateIckbToCkbOrder(amounts, system, takenDeposits) {
+    const base = estimateConversionOrder(false, amounts, system, { fee: DEFAULT_ORDER_FEE, feeBase: DEFAULT_ORDER_FEE_BASE }, takenDeposits);
+    if (base?.maturity !== undefined) {
+        return { ...base, maturity: base.maturity };
+    }
+    const dust = estimateDustIckbToCkbOrder(amounts, system);
+    if (dust === undefined) {
+        return undefined;
+    }
+    return {
+        ...dust,
+        maturity: maturity({ info: dust.info, amounts }, system, takenDeposits),
+        notice: {
+            inputIckb: amounts.udtValue,
+            outputCkb: dust.convertedAmount,
+            incentiveCkb: positiveFee(dust.ckbFee),
+        },
+    };
+}
+function estimateDustIckbToCkbOrder(amounts, system) {
+    const baseEstimate = estimateConversionOrder(false, amounts, system, {
+        fee: 0n,
+        feeBase: DEFAULT_ORDER_FEE_BASE,
+    });
+    if (baseEstimate === undefined) {
+        return undefined;
+    }
+    const targetFee = estimateMaturityFeeThreshold(system);
+    const feeBase = baseEstimate.convertedAmount + 1n;
+    if (targetFee <= 0n || feeBase <= 1n) {
+        return baseEstimate;
+    }
+    const estimateWithFee = (fee) => estimateConversionOrder(false, amounts, system, { fee, feeBase });
+    return lowestFeeEstimateAtThreshold(estimateWithFee, feeBase - 1n, targetFee);
+}
+function lowestFeeEstimateAtThreshold(estimateWithFee, highestFee, targetFee) {
+    const highestDiscount = estimateWithFee(highestFee);
+    if (highestDiscount === undefined || highestDiscount.ckbFee < targetFee) {
+        return undefined;
+    }
+    let low = 0n;
+    let high = highestFee;
+    while (low < high) {
+        const mid = (low + high) / 2n;
+        const estimateAtMid = estimateWithFee(mid);
+        if (estimateAtMid === undefined) {
+            return undefined;
+        }
+        if (estimateAtMid.ckbFee >= targetFee) {
+            high = mid;
+        }
+        else {
+            low = mid + 1n;
+        }
+    }
+    return estimateWithFee(low);
+}
+function positiveFee(fee) {
+    return fee > 0n ? fee : 0n;
+}
+//# sourceMappingURL=estimate.js.map

package/dist/conversion/estimate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate.js","sourceRoot":"","sources":["../../src/conversion/estimate.ts"],"names":[],"mappings":"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"}

package/dist/conversion/maturity.d.ts

@@ -0,0 +1,15 @@
+import type { IckbDepositCell } from "../logic.js";
+import type { MaturityOrderInput, SystemState } from "./types.js";
+/**
+ * Assumed turn duration: the bot's turns start ten minutes apart.
+ * This is a modeling interval, not a bound on the runtime; see sdk/docs/pool_maturity_estimates.md.
+ */
+export declare const BOT_TURN_MS: bigint;
+/**
+ * The estimated fill time of an order on the book or about to be placed, zero when it is
+ * already fulfilled. `takenDeposits` are the pool deposits the same plan withdraws
+ * directly, which cannot fill its order leg too. Dual-ratio orders never reach here: the
+ * scan drops them.
+ */
+export declare function maturity(o: MaturityOrderInput, system: SystemState, takenDeposits?: readonly IckbDepositCell[]): bigint;
+//# sourceMappingURL=maturity.d.ts.map

package/dist/conversion/maturity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maturity.d.ts","sourceRoot":"","sources":["../../src/conversion/maturity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAoB,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,kBAAkB,EACrB,MAAM,EAAE,WAAW,EACnB,aAAa,GAAE,SAAS,eAAe,EAAO,GAC7C,MAAM,CAWR"}