@mysten/deepbook-v3 2.1.4 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @mysten/deepbook-v3
 
+## 2.4.0
+
+### Minor Changes
+
+- b07659a: Predict: export the generated move-call bindings from `@mysten/deepbook-v3/predict`, the
+  way `/account` already exports `accountMoveCalls`. Each `client.predict.tx.*` builder returns a
+  finished `Transaction`, so a Predict call could not join a PTB the caller was building — creating
+  an account, funding it and queueing a PLP supply in one transaction meant hand-writing
+  `plp::request_supply` as a raw `moveCall`. Every Predict module with a callable function is now
+  reachable as a namespace of transaction thunks (`plpMoveCalls`, `expiryMarketMoveCalls`,
+  `predictAccountMoveCalls`, `protocolConfigMoveCalls`, `registryMoveCalls`, `builderCodeMoveCalls`,
+  `marketManagerMoveCalls`, `pricingMoveCalls`, `rangeCodecMoveCalls`, and the cap modules),
+  alongside the event layouts (`vaultEvents`, `orderEvents`, `configEvents`, `builderCodeEvents`).
+  Pass `config: toGeneratedConfig(cfg)` and the shared objects fill themselves in; owner-authorized
+  calls take an `Auth` from `generateAuth(cfg)`. Additive only: no existing export changes.
+
+### Patch Changes
+
+- ee8df5d: Predict docs: document both recorded deployments. `PREDICT.md` and the README now
+  describe the `deepbook-predict-mainnet` and `deepbook-predict-testnet` records that `getConfig`,
+  `getDeployment`, `getUnits`, `getAccountConfig`, and `getSessionsConfig` resolve, the quote coin
+  per network (Circle native USDC on mainnet, a mintable test coin that displays as DUSDC on
+  testnet, read from `quoteCoinType`), the `side: 'range'` descriptor arm, which decoders have
+  plural forms, what is exported for PTB composition, that `read.markets()` returns
+  live-and-not-yet-settled markets, and the `supplyPlp` / `withdrawPlp` floor options as shipped.
+  Documentation only; no runtime change.
+
+## 2.3.0
+
+### Minor Changes
+
+- 7b47a9a: Predict: let `supplyPlp` and `withdrawPlp` set a price floor. Both hard-pinned the
+  request's floor to 0, so the SDK could only ever queue an LP request that accepts whatever mark
+  the next pool flush quotes. They now take an optional third argument — `{ minPlpOut }` (raw
+  `bigint` shares) and `{ minUsdcOut }` (USD decimals) — defaulting to the previous no-floor
+  behaviour.
+- 1e2f728: Add Mainnet deployment ids for Predict, sessions and the account primitive. `getConfig`,
+  `getAccountConfig`, `getSessionsConfig`, `getUnits` and `getDeployment` now resolve `'mainnet'`
+  instead of throwing, and `MAINNET_CONFIG` / `MAINNET_DEPLOYMENT` / `MAINNET_UNITS` are exported
+  alongside their testnet counterparts. `DeployedNetwork` widens to `'testnet' | 'mainnet'`.
+
+  Mainnet settles in Circle's native USDC
+  (`0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC`). The in-repo
+  test currency is never published to Mainnet, so the collateral type resolves to Circle's package
+  there and to the DeepBook test coin on Testnet — read `quoteCoinType` from the config rather than
+  assuming either.
+
+  The ids are generated from the deploy tooling's own Mainnet manifest, like Testnet's, so both
+  networks move together on a redeploy and cannot drift apart across subpaths.
+
+## 2.2.0
+
+### Minor Changes
+
+- e7c8014: Target the `deepbook-predict-testnet` deployment. Every testnet id the SDK ships changes
+  — the Predict, account and sessions packages and their shared objects — so `getConfig('testnet')`,
+  `getAccountConfig('testnet')`, `getSessionsConfig('testnet')` and `TESTNET_CONFIG` all resolve
+  against the new deployment, and `getDeployment('testnet')` reports it by name and source commit.
+  Anything pinned to the previous testnet deployment's ids will not find its accounts, positions or
+  markets there; they are separate deployments, not an upgrade.
+
+  The settlement collateral is renamed upstream from `dusdc::dusdc::DUSDC` to `usdc::usdc::USDC`, so
+  one Move module path resolves on both testnet and mainnet and mainnet can link native USDC by
+  address alone. `quoteCoinType` carries the new type. The testnet coin keeps the `DUSDC` display
+  symbol, which is what distinguishes the mintable test coin from native USDC in wallets and
+  explorers — read `quoteCoinType` rather than assuming a symbol or a type.
+
+  The exported surface is otherwise unchanged: no symbol is added, removed or re-typed, and the
+  renamed Move argument (`min_usdc_out`) is internal to the transaction builders.
+
 ## 2.1.4
 
 ## 2.1.3

package/PREDICT.md

@@ -1,8 +1,8 @@
 # DeepBook Predict (`@mysten/deepbook-v3/predict`)
 
-TypeScript SDK for DeepBook Predict — binary markets on Sui. Builds ready-to-sign transactions and
-reads on-chain state through your Sui client. The SDK never signs and never touches keys: every
-`tx.*` method returns a `Transaction` for your wallet (dapp-kit) or signer to execute.
+TypeScript SDK for DeepBook Predict — binary and range markets on Sui. Builds ready-to-sign
+transactions and reads on-chain state through your Sui client. The SDK never signs and never touches
+keys: every `tx.*` method returns a `Transaction` for your wallet (dapp-kit) or signer to execute.
 
 ## Install
 
@@ -12,8 +12,10 @@ npm i @mysten/deepbook-v3 @mysten/sui
 
 `@mysten/sui` is a peer dependency.
 
-> Predict is deployed on **testnet** only. `getConfig('mainnet')` throws until a mainnet deployment
-> exists.
+> Two deployments are recorded, **testnet** and **mainnet**: `predict({ network })` and
+> `getConfig(network)` resolve either, and any other network throws. They settle in different coins
+> that share one Move module path — read `quoteCoinType` from the config rather than assuming a
+> symbol or a type. See [Networks & deployments](#networks--deployments).
 
 ## Quickstart
 
@@ -32,16 +34,22 @@ const client = new SuiGrpcClient({
 // One-time: create your Predict account (a shared AccountWrapper).
 const createTx = client.predict.tx.createManager();
 
-// Fund it: pulls DUSDC from your address (coin objects and/or address balance).
+// Fund it: pulls the deployment's quote coin (`client.predict.cfg.quoteCoinType`) from your
+// address (coin objects and/or address balance).
 const depositTx = client.predict.tx.deposit(myAddress, 250); // $250
 
-// Cash out: lands in your DUSDC address balance by default (no coin-object churn).
+// Cash out: lands in your quote-coin address balance by default (no coin-object churn).
 // Pass { toCoinObject: true } if you need a discrete Coin<T> instead.
 const withdrawTx = client.predict.tx.withdraw(myAddress, 100); // $100
 
-// Pick a live market. Expiries are absolute timestamps, so never hardcode one.
+// Pick a market. `read.markets()` lists ACTIVE markets — live and not yet settled — which
+// includes a market past its expiry that nobody has settled yet; quoting against one aborts.
+// Expiries are absolute timestamps, so never hardcode one: filter on `expiryMs`, leaving
+// room to quote, sign and land (and clear the pre-expiry no-trade window).
 const markets = await client.predict.read.markets();
-const expiryMs = markets[0].expiryMs;
+// -> [{ id, expiryMs, tickSize, admissionTickSize, mintPaused, referencePrice }, ...]
+const tradeable = markets.filter((m) => Number(m.expiryMs) > Date.now() + 30_000 && !m.mintPaused);
+const expiryMs = tradeable[0].expiryMs;
 
 // Describe the position once and reuse it — quoting and minting take the same descriptor.
 const desc = { underlying: 'BTC', expiryMs, strike: 'reference', side: 'up' } as const;
@@ -73,14 +81,10 @@ receipt.entryProbability; // your fill price (0..1 per $1 payout)
 receipt.premium; // exact cost breakdown
 receipt.fees;
 
-// Read: tradeable markets and pool state.
-const markets = await client.predict.read.markets();
-// -> [{ id, expiryMs, tickSize, admissionTickSize, mintPaused, referencePrice }, ...]
-const market = await client.predict.read.market({
-	underlying: 'BTC',
-	expiryMs: markets[0].expiryMs,
-});
+// Read: one market's live state (+ NAV) and the pool.
+const market = await client.predict.read.market({ underlying: 'BTC', expiryMs });
 console.log(market?.nav, market?.tickSize, market?.mintPaused);
+const pool = await client.predict.read.pool();
 ```
 
 ## ⚠ Slippage defaults are UNCAPPED
@@ -89,25 +93,41 @@ console.log(market?.nav, market?.tickSize, market?.mintPaused);
 **uncapped** — if the price moves between your quote and execution, the position can cost up to your
 full account balance. **Call `read.quoteMint` and pass its `cost` (plus your buffer) as `maxCost`.**
 The same applies to `redeem`: the deployed `redeem_live` DOES take `min_probability` /
-`min_proceeds` floors, but the facade does not surface them yet and always sends `0` (uncapped).
-`read.quoteRedeem` first, close fast — or drive `redeemLive` from the tx layer to set the floors.
+`min_proceeds` floors, but the facade's `tx.redeem` does not surface them and always sends `0`
+(uncapped). `read.quoteRedeem` first, close fast. The floors are reachable through `/sessions`:
+`SessionsContract.redeemLive` takes `minProbability` / `minProceeds` (raw units —
+`probabilityToRaw`, `usdcToRaw`) plus a `pricer` from `loadLivePricer`, and is signed by a session
+key the owner has authorized (see the README's `/sessions` section).
 
 ## Units
 
 Everything human-facing is decimal; everything on-chain is scaled integers. The facade converts
 **inputs** exactly (string/bigint math — no floats on the money path in). Read outputs typed
-`number` are display values: above 2^53 raw they lose low-digit precision — for accounting-exact
-reads use the primitives layer, which returns raw `bigint`s (`accountBalance`, `poolStats`, …).
+`number` are display values: above 2^53 raw they lose low-digit precision — quotes and receipts
+carry a `raw` block of `bigint`s alongside, and `plpBalance` / `pool().plpTotalSupply` are raw
+`bigint` already.
+
+Amounts are in the deployment's quote coin — `getConfig(network).quoteCoinType`: Circle native USDC
+on mainnet, a mintable 6-decimal test coin on testnet. Both are `…::usdc::USDC`, so only the package
+address tells them apart; read the type, never assume a symbol.
 
 | Concept                                     | You pass / receive                                             | On-chain raw                          |
 | ------------------------------------------- | -------------------------------------------------------------- | ------------------------------------- |
-| Amounts (deposit, spend, maxCost, balances) | USD decimal number or string (`12.5`, `"12.5"`)                | ×1e6 (DUSDC)                          |
+| Amounts (deposit, spend, maxCost, balances) | USD decimal number or string (`12.5`, `"12.5"`)                | ×1e6 (quote coin)                     |
 | `quantity`                                  | **max payout** in USD; positions pay $1 per contract at expiry | ×1e6, in $0.01 lots                   |
 | `strike`                                    | USD (`105_000`)                                                | ×1e9, must land on the admission grid |
 | `maxProbability`                            | 0..1 (`0.35` = 35¢ per $1 contract)                            | ×1e9                                  |
 | PLP shares (`withdrawPlp`, `plpBalance`)    | raw `bigint` shares                                            | 6-decimal coin                        |
 
-`side: "up"` wins if the settlement price is above the strike; `"down"` below.
+`side: "up"` wins if the settlement price is above the strike; `"down"` below; `"range"` (see
+[Range positions](#range-positions)) if it lands inside `(lower, upper]`.
+
+Trading closes slightly before expiry: the protocol enforces a short pre-expiry no-trade window
+(`no_trade_window_ms` on the live `ProtocolConfig`, 2 s on both recorded deployments), so a mint or
+redeem submitted inside it aborts `ETradeWindowClosed` rather than filling. Treat the last seconds
+of a window as untradeable rather than retrying, and when choosing a market from `read.markets()`
+leave enough of the window to quote, sign and land — a quote taken seconds before expiry executes
+inside the window.
 
 ## Reference-price markets (Polymarket-style windows)
 
@@ -134,11 +154,11 @@ strikes away from the reference remain fully supported.
 ### Numeric strikes must sit on the admission grid
 
 New mint strikes must be a whole multiple of the market's **`admissionTickSize`** — a step
-deliberately coarser than `tickSize`, and it varies by cadence (on the current testnet deployment
-the 1m/5m/1h markets use `$1` and the 1d/1w markets `$100`, against a `$0.01` tick). Always read it
-off the market rather than assuming a value. The market's `referencePrice` is the one finite strike
-the chain admits off-grid. `read.markets()` and `read.market()` both report `admissionTickSize`, so
-a board can be built from it directly:
+deliberately coarser than `tickSize`, and it is configured per cadence (both recorded deployments
+run `$1` against a `$0.01` tick on their enabled cadences, 1m and 5m). Always read it off the market
+rather than assuming a value. The market's `referencePrice` is the one finite strike the chain
+admits off-grid. `read.markets()` and `read.market()` both report `admissionTickSize`, so a board
+can be built from it directly:
 
 ```ts
 const m = (await client.predict.read.markets())[0];
@@ -148,6 +168,23 @@ const strike = Math.round(target / m.admissionTickSize) * m.admissionTickSize;
 An off-grid numeric strike throws `PredictInputError` at build time rather than aborting on chain
 with `EInvalidAdmissionTick`.
 
+### Range positions
+
+`MarketDescriptor` has a third arm: `{ underlying, expiryMs, side: 'range', lower, upper }`. It pays
+$1 per contract when the settlement price lands inside `(lower, upper]` — left-open, right-closed,
+the same convention as the on-chain range key. Both bounds are USD strikes that must be finite, on
+the tick grid, with `lower < upper`, and **each is admission-grid checked** exactly like a binary
+numeric strike. `strike: 'reference'` is binary-only — a range has no single reference strike — and
+`read.price` is binary-only too; price a range locally with `pricer.range(lower, upper)`.
+
+```ts
+const tx = await client.predict.tx.mint(
+	myAddress,
+	{ underlying: 'BTC', expiryMs, side: 'range', lower: 104_000, upper: 106_000 },
+	{ quantity: 25, maxCost: 10 },
+);
+```
+
 ## What's in the box
 
 - **`client.predict.tx`** — `createManager`, `deposit`, `withdraw`, `mint`, `mintAmount`, `redeem`,
@@ -155,23 +192,59 @@ with `EInvalidAdmissionTick`.
   `setBuilderCode`, `unsetBuilderCode`. Market-resolving builders
   (`mint`/`mintAmount`/`redeem`/`claimSettled`) are async: they resolve the market object from
   `{ underlying, expiryMs, strike, side }` via the on-chain registry (cached per client).
-- **`client.predict.read`** — `markets()` (tradeable summaries: id, expiry, tick size, mint-paused,
-  reference price), `market(desc)` (state + live NAV), `price(m)` (anonymous both-sides pricing for
-  any strike, one chain call per strike), `pricer(m)` (a **client-side board pricer** — one chain
-  read of the resolved pricer, then price every strike locally; see below),
+- **`client.predict.read`** — `markets()` (summaries of the pool's **active** markets — live and not
+  yet settled, so a market past expiry that nobody has settled is still listed and quoting against
+  it aborts; filter on `expiryMs` and `mintPaused` before trading: id, expiry, tick size, admission
+  tick size, mint-paused, reference price), `market(desc)` (state + live NAV), `price(m)` (anonymous
+  both-sides pricing for any strike, one chain call per strike), `pricer(m)` (a **client-side board
+  pricer** — one chain read of the resolved pricer, then price every strike locally; see below),
   `quoteMint(owner, m, opts)` / `quoteRedeem(owner, m, opts)` (exact dry-run quotes: real fees from
   the real code path — and they throw the same typed errors the real trade would, so a quote doubles
   as preflight), `balance(owner)`, `plpBalance(owner)`, `pool()`, `positions(owner)` (chain-only
   enumeration of open positions), `hasPosition(owner, marketId, orderId)`. All reads run over the
   client's `simulateTransaction`; no indexer required.
 - **`client.predict.decode`** — pure execution-result decoders (no network): `mint`, `redeem`,
-  `claim`, `createManager`, `deposit`, `withdraw`, `plpRequest`, `plpCancel`, `builderCode`, each
-  with a plural form for batched PTBs. Execute transactions with events included and pass the
-  result; receipts come back in SDK units with raw bigints alongside. Decoding uses the events'
-  canonical BCS bytes, so it is transport-independent.
-- **PTB composition** — integrators who need to compose their own transactions can use the generated
-  Move bindings under `contracts/` directly (transaction thunks + BCS structs), the same layer the
-  facade builds on.
+  `claim`, `createManager`, `deposit`, `withdraw`, `plpRequest`, `plpCancel`, `builderCode`. Each
+  singular form throws unless exactly one matching event is present; `mints`, `redeems` and `claims`
+  are the plural forms for batched PTBs and return every receipt (the other decoders have no
+  plural). Execute transactions with events included and pass the result; receipts come back in SDK
+  units with raw bigints alongside. Decoding uses the events' canonical BCS bytes, so it is
+  transport-independent.
+- **PTB composition** — each `client.predict.tx.*` builder returns a finished `Transaction`, so to
+  put a Predict call into a PTB you are building, use the generated move-call bindings `/predict`
+  exports: one namespace of transaction thunks per Predict module (`plpMoveCalls`,
+  `expiryMarketMoveCalls`, `predictAccountMoveCalls`, `protocolConfigMoveCalls`,
+  `registryMoveCalls`, `builderCodeMoveCalls`, `marketManagerMoveCalls`, `pricingMoveCalls`,
+  `rangeCodecMoveCalls`, `adminMoveCalls` and the cap modules) plus the event layouts
+  (`vaultEvents`, `orderEvents`, `configEvents`, `builderCodeEvents`). Pass
+  `config: toGeneratedConfig(cfg)` — the flat config slice the bindings resolve the shared objects
+  against — and give owner-authorized calls `auth: tx.add(generateAuth(cfg))`, the hot-potato `Auth`
+  the account calls consume. The account itself (create, deposit, share) is
+  `@mysten/deepbook-v3/account`'s `accountRegistryMoveCalls` / `accountMoveCalls`. Also exported:
+  `loadLivePricer(toGeneratedConfig(cfg), { expiryMarketId, ...cfg.underlyings[sym] })` — the
+  `pricer` every live trade call borrows, which the `/sessions` Predict wrappers take as a PTB
+  result — and `deriveAccountWrapperId(cfg, owner)`.
+
+  ```ts
+  // Create an account, fund it, and queue a PLP supply — one PTB, one signature.
+  const config = toGeneratedConfig(cfg);
+  const wrapper = tx.add(accountRegistryMoveCalls._new({ config }));
+  tx.add(
+  	accountMoveCalls.depositFunds({
+  		config,
+  		arguments: { wrapper, auth: tx.add(generateAuth(cfg)), coin },
+  		typeArguments: [cfg.quoteCoinType],
+  	}),
+  );
+  tx.add(
+  	plpMoveCalls.requestSupply({
+  		config,
+  		arguments: { wrapper, auth: tx.add(generateAuth(cfg)), amount, minPlpOut },
+  	}),
+  );
+  tx.add(accountMoveCalls.share({ config, arguments: { self: wrapper } }));
+  ```
+
 - **Typed errors** — invalid inputs throw `PredictInputError` before the chain sees them; failed
   simulations throw `PredictMoveError` with the decoded Move abort (`module`, `code`, `abortName`).
 
@@ -198,9 +271,9 @@ on-chain; the client only evaluates the digital. It throws the same typed stale-
 The math is a faithful float port of the deployed `pricing::compute_nd2` (SVI with the skew
 correction, signed params, and the remaining-time roll-down). It agrees with the chain closely —
 within ~1e-4 in probability, up to ~1e-4 near ATM where the chain's fixed-point truncation dominates
-(`tests/testnet/pricing.test.ts` bounds it live). The pure functions are exported under a `pricing`
-namespace for callers who already hold their own oracle inputs (e.g. a live feed) and want zero
-chain calls:
+(`test/predict/testnet/pricing.test.ts` bounds it live). The pure functions are exported under a
+`pricing` namespace for callers who already hold their own oracle inputs (e.g. a live feed) and want
+zero chain calls:
 
 ```ts
 import { pricing } from '@mysten/deepbook-v3/predict';
@@ -218,11 +291,29 @@ const rolled = pricing.rollDown(rawSvi, remainingMs, anchorTteMs); // decay a, b
 
 ## Networks & deployments
 
-**Testnet only today** — `getConfig("mainnet")` throws until a mainnet deployment exists. Object ids
-for the current testnet deployment are baked into the SDK (`TESTNET_CONFIG`); they are updated, with
-a release, whenever a new package version is deployed. Move-call targets flow through one resolution
-seam, which will switch to MVR names (`@deepbook/predict`) once registered — package upgrades then
-stop requiring an SDK release for target resolution.
+Two deployments are recorded. `getDeployment(network)` names each one and the deepbookv3 commit its
+ids were generated at:
+
+| Network   | Deployment                 | Chain id   | Source commit | `quoteCoinType`                                                                                                            |
+| --------- | -------------------------- | ---------- | ------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `mainnet` | `deepbook-predict-mainnet` | `35834a8a` | `14a7e8f8`    | Circle native USDC — `0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC`                      |
+| `testnet` | `deepbook-predict-testnet` | `4c78adac` | `a928bd2d`    | mintable test coin, displays as `DUSDC` — `0xc028557a1ed49e42ed091e115aedefd70a442b184c18fbec5c48d5b6c0b8c184::usdc::USDC` |
+
+Object ids for both are baked into the SDK — `MAINNET_CONFIG` / `TESTNET_CONFIG`, with
+`MAINNET_DEPLOYMENT` / `TESTNET_DEPLOYMENT` and `MAINNET_UNITS` / `TESTNET_UNITS` alongside — and
+are regenerated, with a release, whenever a deployment moves. `getConfig`, `getDeployment` and
+`getUnits` resolve both networks and throw on any other; `getAccountConfig` (`/account`) and
+`getSessionsConfig` (`/sessions`) read slices of the same generated record, so the three subpaths
+cannot address different deployments. Units are identical on both (`$0.01` lots, 6 quote decimals,
+1e9 fixed-point scale).
+
+Move-call targets resolve from the config's package ids, so a deployment of your own is addressed by
+passing `config` — `predict({ network, config })` or
+`new PredictClient({ client, network, config })` — and `network` is then not consulted.
+
+An expired market stays in `read.markets()` until someone settles it — the list is the pool's
+live-and-not-yet-settled set, not a tradeable set. On either network, check `expiryMs` against the
+clock (and `mintPaused`) before quoting rather than assuming the list is tradeable.
 
 ## Notes
 
@@ -233,11 +324,26 @@ stop requiring an SDK release for target resolution.
   as the cheap validator.
 - PLP supply/withdraw are queued and fill at the next pool flush; cancels take the queue `index` —
   get it from `decode.plpRequest(result).index`.
+- **Both take an optional price floor**, and default to none:
+  `supplyPlp(owner, amountUsdc, { minPlpOut })` (`PlpSupplyOptions`, raw `bigint` shares; omitted →
+  `0n`) and `withdrawPlp(owner, shares, { minUsdcOut })` (`PlpWithdrawOptions`, USD decimals as
+  `number | string`, measured after the protocol's withdraw fee; omitted → no floor). Each floors
+  the flush's MARK for the whole request rather than naming a quantity — a flush quoting less
+  declines instead of filling smaller. What a miss costs is the deployment's
+  `lp_request_limit_flush_attempts`: the deployed value is one on both recorded deployments, so the
+  first flush below the floor cancels the request and refunds it, and re-queueing is a fresh
+  transaction (three is the configurable maximum, not the default). Leave the floor off and the
+  request takes whatever mark the flush quotes.
+- **First-time funding in one PTB**: `deposit(owner, amount, { create: true })` creates the wrapper,
+  deposits through the fresh handle and shares it last. `owner` must be the transaction signer (the
+  wrapper is derived from the sender), and it aborts if the account already exists — the builder
+  does no chain read, so gate on `wrapperIdFor(owner)` + a `getObject`, or fall back to `deposit`
+  without the flag on that abort.
 - `claimSettled` closes the order in full — the deployed entrypoint takes no quantity.
 - **`withdraw` lands in your address balance by default** (`0x2::coin::send_funds`), not a coin
   object — it merges into the versionless accumulator `deposit` already draws from, so the round
-  trip never accretes stray `Coin<DUSDC>` objects. `read.balance(owner)` reflects the account's
-  internal custody balance; use the client's `getBalance(owner)` for the wallet-side DUSDC total
+  trip never accretes stray `Coin<USDC>` objects. `read.balance(owner)` reflects the account's
+  internal custody balance; use the client's `getBalance(owner)` for the wallet-side USDC total
   (coin objects + address balance). Pass `withdraw(owner, amt, { toCoinObject: true })` for a
   discrete coin (wallets/explorers that only render coin objects, or same-PTB composition).
 

package/README.md

@@ -2,12 +2,12 @@
 
 ## Entry points
 
-| Import                         | Contents                                                                                                                                                                                                            |
-| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@mysten/deepbook-v3`          | DeepBook spot and margin — pools, orders, balance managers, flash loans, governance, margin managers/pools, TPSL.                                                                                                   |
-| `@mysten/deepbook-v3/account`  | The shared on-chain **account primitive** (`AccountContract`): the canonical `AccountWrapper`, `Auth`, and custody balances that DeepBook's core account wrapper and DeepBook Predict both build on.                |
-| `@mysten/deepbook-v3/sessions` | **Time-limited trading sessions** over a canonical Account (`SessionsContract`): grant an ephemeral address bounded authority until a fixed expiry. Covers the session lifecycle and the DeepBook Predict wrappers. |
-| `@mysten/deepbook-v3/predict`  | **DeepBook Predict** — binary markets: market discovery, quotes, mint/redeem/claim, PLP, typed receipts and a client-side board pricer. See [PREDICT.md](./PREDICT.md).                                             |
+| Import                         | Contents                                                                                                                                                                                                                     |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@mysten/deepbook-v3`          | DeepBook spot and margin — pools, orders, balance managers, flash loans, governance, margin managers/pools, TPSL.                                                                                                            |
+| `@mysten/deepbook-v3/account`  | The shared on-chain **account primitive** (`AccountContract`): the canonical `AccountWrapper`, `Auth`, and custody balances that DeepBook's core account wrapper and DeepBook Predict both build on.                         |
+| `@mysten/deepbook-v3/sessions` | **Time-limited trading sessions** over a canonical Account (`SessionsContract`): grant an ephemeral address bounded authority until a fixed expiry. Covers the session lifecycle and the DeepBook Predict wrappers.          |
+| `@mysten/deepbook-v3/predict`  | **DeepBook Predict** — binary and range markets: market discovery, quotes, mint/redeem/claim, PLP, typed receipts and a client-side board pricer, with deployed ids for testnet and mainnet. See [PREDICT.md](./PREDICT.md). |
 
 Subpaths are separate module graphs — importing `@mysten/deepbook-v3/account` does not load any spot
 or margin code.
@@ -15,10 +15,13 @@ or margin code.
 Each subpath also exports the **deployed ids** for its own surface, so a caller never transcribes
 them: `getAccountConfig(network)` on `/account`, `getSessionsConfig(network)` on `/sessions`,
 `getConfig(network)` on `/predict`. All three read one generated record (`src/deployments/`), so a
-redeploy updates every subpath at once and they cannot end up addressing different deployments.
-`getDeployment(network)` names the deployment and the deepbookv3 commit those ids came from.
-Predict, sessions and the account primitive are testnet-only today; an unrecorded network throws
-rather than returning placeholder ids.
+redeploy updates every subpath at once and they cannot end up addressing different deployments. Two
+networks are recorded, `testnet` (`deepbook-predict-testnet`) and `mainnet`
+(`deepbook-predict-mainnet`); `getDeployment(network)` names the deployment and the deepbookv3
+commit those ids came from, and an unrecorded network throws rather than returning placeholder ids.
+The two deployments settle in different coins that share one Move module path — Circle native USDC
+on mainnet, a mintable test coin (displayed as `DUSDC`) on testnet — so take the coin type from
+`getConfig(network).quoteCoinType` on `/predict` rather than assuming either.
 
 ### `@mysten/deepbook-v3/account`
 
@@ -30,7 +33,7 @@ is computable off-chain with no chain read. `AccountContract` takes only the dep
 import { Transaction } from '@mysten/sui/transactions';
 import { AccountContract, getAccountConfig } from '@mysten/deepbook-v3/account';
 
-// Deployed ids ship with the package — no transcription.
+// Deployed ids ship with the package — no transcription. 'testnet' | 'mainnet'.
 const account = new AccountContract(getAccountConfig('testnet'));
 
 // …or drive a deployment of your own:
@@ -38,8 +41,10 @@ const custom = new AccountContract({ accountPackageId: '0x…', accountRegistry:
 
 const wrapperId = account.deriveAccountWrapperId(owner);
 
+// `quoteCoinType` is the deployment's settlement coin — `getConfig(network).quoteCoinType`
+// from `/predict` — not a symbol you assume.
 const tx = new Transaction();
-tx.add(account.depositFunds({ wrapperId, coin, coinType: USDC }));
+tx.add(account.depositFunds({ wrapperId, coin, coinType: quoteCoinType }));
 ```
 
 > `Account` exported from the package root is `@deepbook/core::account::Account` (the per-pool
@@ -61,7 +66,7 @@ withdrawal or arbitrary-mutation entrypoint.
 ```ts
 import { SessionsContract, getSessionsConfig } from '@mysten/deepbook-v3/sessions';
 
-// Deployed ids ship with the package — no transcription.
+// Deployed ids ship with the package — no transcription. 'testnet' | 'mainnet'.
 const sessions = new SessionsContract(getSessionsConfig('testnet'));
 
 const wrapperId = sessions.deriveAccountWrapperId(owner);

package/dist/account.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"account.d.mts","names":[],"sources":["../src/account.ts"],"mappings":";;;;;;;;;;;;AAoCA;;;;;;;;;AAiBA;;UAjBiB,aAAA,SAAsB,eAAA;EAiB6B;EAfnE,gBAAA;EAegC;EAbhC,eAAA;AAAA;;AAqCD;;;;;;;;;iBAxBgB,gBAAA,CAAiB,OAAA,EAAS,UAAA,GAAa,aAAA;;;;;;;;;;cAwB1C,eAAA;EAAA;EAMQ;;;cAAR,MAAA,EAAQ,aAAA;EA0BpB;;;;;;;EAfA,sBAAA,CAAuB,KAAA;EA0CW;;;;;;EA3BlC,YAAA,CAAA,IACS,EAAA,EAAI,WAAA,KAAc,iBAAA;EAgDJ;;;;;;EAtCvB,aAAA,CAAA,IACS,EAAA,EAAI,WAAA;EA0Db;;;;;;;;;EA3CA,uBAAA,CAAwB,MAAA;IAAU,IAAA,EAAM,yBAAA;IAA2B,QAAA;EAAA,KAC1D,EAAA,EAAI,WAAA;EA8Dc;;;;;;;EAzC3B,YAAA,CAAa,MAAA;IAAU,SAAA;IAAmB,IAAA,EAAM,yBAAA;IAA2B,QAAA;EAAA,KAClE,EAAA,EAAI,WAAA;;;;;;;;;EAoBb,aAAA,CAAc,MAAA;IAAU,SAAA;IAAmB,MAAA;IAAgB,QAAA;EAAA,KAClD,EAAA,EAAI,WAAA,KAAc,iBAAA;;;;;;;EAkB3B,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA,KACb,EAAA,EAAI,WAAA,KAAc,iBAAA;;;;;;;;EAW3B,OAAA,CAAQ,MAAA;IAAU,KAAA;IAAe,QAAA;EAAA,KACxB,EAAA,EAAI,WAAA,KAAc,iBAAA;AAAA"}
+{"version":3,"file":"account.d.mts","names":[],"sources":["../src/account.ts"],"mappings":";;;;;;;;;;;;AAqCA;;;;;;;;;AAiBA;;UAjBiB,aAAA,SAAsB,eAAA;EAiB6B;EAfnE,gBAAA;EAegC;EAbhC,eAAA;AAAA;;AAsCD;;;;;;;;;iBAzBgB,gBAAA,CAAiB,OAAA,EAAS,UAAA,GAAa,aAAA;;;;;;;;;;cAyB1C,eAAA;EAAA;EAMQ;;;cAAR,MAAA,EAAQ,aAAA;EA0BpB;;;;;;;EAfA,sBAAA,CAAuB,KAAA;EA0CW;;;;;;EA3BlC,YAAA,CAAA,IACS,EAAA,EAAI,WAAA,KAAc,iBAAA;EAgDJ;;;;;;EAtCvB,aAAA,CAAA,IACS,EAAA,EAAI,WAAA;EA0Db;;;;;;;;;EA3CA,uBAAA,CAAwB,MAAA;IAAU,IAAA,EAAM,yBAAA;IAA2B,QAAA;EAAA,KAC1D,EAAA,EAAI,WAAA;EA8Dc;;;;;;;EAzC3B,YAAA,CAAa,MAAA;IAAU,SAAA;IAAmB,IAAA,EAAM,yBAAA;IAA2B,QAAA;EAAA,KAClE,EAAA,EAAI,WAAA;;;;;;;;;EAoBb,aAAA,CAAc,MAAA;IAAU,SAAA;IAAmB,MAAA;IAAgB,QAAA;EAAA,KAClD,EAAA,EAAI,WAAA,KAAc,iBAAA;;;;;;;EAkB3B,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA,KACb,EAAA,EAAI,WAAA,KAAc,iBAAA;;;;;;;;EAW3B,OAAA,CAAQ,MAAA;IAAU,KAAA;IAAe,QAAA;EAAA,KACxB,EAAA,EAAI,WAAA,KAAc,iBAAA;AAAA"}

package/dist/account.mjs

@@ -1,5 +1,6 @@
 import { Account, AccountWrapper, account_exports, balance, depositFunds, generateAuth, loadAccount, share, withdrawFunds } from "./contracts/account/account.mjs";
 import { _new, account_registry_exports } from "./contracts/account/account_registry.mjs";
+import { MAINNET_ACCOUNT } from "./deployments/mainnet.mjs";
 import { TESTNET_ACCOUNT, TESTNET_DEPLOYMENT, TESTNET_UNITS } from "./deployments/testnet.mjs";
 import { getDeployment, getUnits } from "./deployments/index.mjs";
 import { account_events_exports } from "./contracts/account/account_events.mjs";
@@ -19,7 +20,8 @@ import { deriveObjectID } from "@mysten/sui/utils";
 */
 function getAccountConfig(network) {
 	if (network === "testnet") return TESTNET_ACCOUNT;
-	throw new Error(`@mysten/deepbook-v3/account: no account deployment recorded for network '${network}'. The account primitive is testnet-only today; for your own deployment pass \`{ accountPackageId, accountRegistry }\` to AccountContract directly.`);
+	if (network === "mainnet") return MAINNET_ACCOUNT;
+	throw new Error(`@mysten/deepbook-v3/account: no account deployment recorded for network '${network}'. The account primitive is recorded for testnet and mainnet; for your own deployment pass \`{ accountPackageId, accountRegistry }\` to AccountContract directly.`);
 }
 const AccountWrapperKey = bcs.struct("AccountWrapperKey", { pos0: bcs.Address });
 /**

package/dist/account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"account.mjs","names":["#config","account.generateAuth","accountRegistry._new","account.share","account.depositFunds","account.withdrawFunds","account.loadAccount","account.balance"],"sources":["../src/account.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { bcs } from '@mysten/sui/bcs';\nimport type {\n\tTransaction,\n\tTransactionObjectArgument,\n\tTransactionResult,\n} from '@mysten/sui/transactions';\nimport { deriveObjectID } from '@mysten/sui/utils';\n\nimport * as account from './contracts/account/account.js';\nimport * as accountRegistry from './contracts/account/account_registry.js';\nimport type { AccountConfig as GeneratedAccountConfig } from './contracts/account/config-arguments.js';\nimport { TESTNET_ACCOUNT } from './deployments/testnet.js';\nimport type { NetworkArg } from './deployments/index.js';\n\n// Provenance: which on-chain deployment the ids above came from. Re-exported so a consumer\n// can answer \"which deploy is this build pinned to?\" without reaching for another subpath.\nexport { getDeployment, getUnits, TESTNET_DEPLOYMENT, TESTNET_UNITS } from './deployments/index.js';\nexport type { NetworkArg } from './deployments/index.js';\nexport type { DeployedNetwork } from './deployments/index.js';\n\n/**\n * The deployed ids of the shared `account` package this contract builds against.\n *\n * Kept deliberately minimal — ids only — so any consumer of the shared account primitive\n * (DeepBook core's account wrapper, Predict, …) can drive these builders with its OWN\n * deployment's ids without constructing a full product-SDK config.\n *\n * Extends the codegen-generated config interface so there is exactly one config shape and\n * casing: the generated bindings resolve `options.config` against these same keys, and if\n * codegen adds, drops, or renames a key this file stops compiling instead of silently\n * building a PTB against the wrong object. The ids are narrowed to `string` — codegen types\n * the package id as optional and the registry as the wider `ConfigValue`, but the\n * wrapper-address derivation needs plain ids.\n */\nexport interface AccountConfig extends GeneratedAccountConfig {\n\t/** The `account` Move package id. */\n\taccountPackageId: string;\n\t/** The shared `AccountRegistry` object id. */\n\taccountRegistry: string;\n}\n\n/**\n * @description The deployed `account` ids for `network`, so a caller does not transcribe\n * them. Generated from the deploy manifest — see `src/deployments/`.\n * @throws if the network has no recorded deployment, rather than returning placeholder ids\n * that would fail as a confusing on-chain abort.\n *\n * ```ts\n * const account = new AccountContract(getAccountConfig('testnet'));\n * ```\n */\nexport function getAccountConfig(network: NetworkArg): AccountConfig {\n\tif (network === 'testnet') return TESTNET_ACCOUNT;\n\tthrow new Error(\n\t\t`@mysten/deepbook-v3/account: no account deployment recorded for network '${network}'. ` +\n\t\t\t'The account primitive is testnet-only today; for your own deployment pass ' +\n\t\t\t'`{ accountPackageId, accountRegistry }` to AccountContract directly.',\n\t);\n}\n\n// `AccountWrapperKey(address)` is a one-field positional struct, so its BCS is just the\n// owner's 32-byte address. See `packages/account/sources/account_registry.move`.\nconst AccountWrapperKey = bcs.struct('AccountWrapperKey', {\n\tpos0: bcs.Address,\n});\n\n/**\n * AccountContract — the reusable on-chain account primitive (`packages/account`).\n *\n * An owner has one canonical `AccountWrapper`, a *derived* object of the account registry,\n * so its id is computable off-chain (no read). The wrapper holds an `Account` whose custody\n * balances apps deposit into and withdraw from; app-specific data hangs off it under an\n * app-keyed slot. Authority is a hot-potato `Auth` minted from the tx sender and consumed\n * by the very next account-loading call.\n */\nexport class AccountContract {\n\t#config: AccountConfig;\n\n\t/**\n\t * @param {AccountConfig} config Deployed ids of the shared `account` package\n\t */\n\tconstructor(config: AccountConfig) {\n\t\tthis.#config = config;\n\t}\n\n\t/**\n\t * @description The deterministic id of an owner's canonical account wrapper — no chain\n\t * read needed. The wrapper is a derived object of the account registry, so its id is\n\t * `derive_address(registry, AccountWrapperKey(owner))`.\n\t * @param {string} owner Owner address\n\t * @returns The wrapper object id\n\t */\n\tderiveAccountWrapperId(owner: string): string {\n\t\tconst key = AccountWrapperKey.serialize({ pos0: owner }).toBytes();\n\t\treturn deriveObjectID(\n\t\t\tthis.#config.accountRegistry,\n\t\t\t`${this.#config.accountPackageId}::account_registry::AccountWrapperKey`,\n\t\t\tkey,\n\t\t);\n\t}\n\n\t/**\n\t * @description Mint owner authority for the transaction sender. A hot-potato `Auth`\n\t * consumed by the very next account-loading call (`load_account_mut` inside\n\t * `deposit_funds` / `withdraw_funds` / an app's own entrypoints).\n\t * @returns A function that takes a Transaction object\n\t */\n\tgenerateAuth() {\n\t\treturn (tx: Transaction): TransactionResult =>\n\t\t\ttx.add(account.generateAuth({ config: this.#config }));\n\t}\n\n\t/**\n\t * @description Create the sender's canonical account wrapper and share it. `new` derives\n\t * the wrapper at its deterministic address (see `deriveAccountWrapperId`) and aborts if\n\t * it already exists; `share` publishes the shared object apps borrow against.\n\t * @returns A function that takes a Transaction object\n\t */\n\tcreateAccount() {\n\t\treturn (tx: Transaction): void => {\n\t\t\tconst wrapper = tx.add(accountRegistry._new({ config: this.#config }));\n\t\t\ttx.add(account.share({ config: this.#config, arguments: { self: wrapper } }));\n\t\t};\n\t}\n\n\t/**\n\t * @description First-time funding in ONE PTB: create the sender's wrapper, deposit\n\t * `coin` through the fresh handle, then `share` LAST (once shared, by-value use of the\n\t * handle is over). This cannot be split into `createAccount` + `depositFunds`: an object\n\t * input can only address an object that pre-exists the PTB, so a wrapper created inside\n\t * it is reachable only through `new`'s result handle.\n\t * @param {object} params Coin to deposit and its coin type\n\t * @returns A function that takes a Transaction object\n\t */\n\tcreateAccountAndDeposit(params: { coin: TransactionObjectArgument; coinType: string }) {\n\t\treturn (tx: Transaction): void => {\n\t\t\tconst wrapper = tx.add(accountRegistry._new({ config: this.#config }));\n\t\t\tconst auth = tx.add(this.generateAuth());\n\t\t\ttx.add(\n\t\t\t\taccount.depositFunds({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\targuments: { wrapper, auth, coin: params.coin },\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t}),\n\t\t\t);\n\t\t\ttx.add(account.share({ config: this.#config, arguments: { self: wrapper } }));\n\t\t};\n\t}\n\n\t/**\n\t * @description Deposit a caller-provided `coin` into the account's stored balance via the\n\t * PTB-callable `deposit_funds` (folds settle → authorize → load → deposit; clock and\n\t * accumulator root auto-injected). The caller owns coin sourcing.\n\t * @param {object} params Wrapper id, coin to deposit, and its coin type\n\t * @returns A function that takes a Transaction object\n\t */\n\tdepositFunds(params: { wrapperId: string; coin: TransactionObjectArgument; coinType: string }) {\n\t\treturn (tx: Transaction): void => {\n\t\t\tconst auth = tx.add(this.generateAuth());\n\t\t\ttx.add(\n\t\t\t\taccount.depositFunds({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\targuments: { wrapper: params.wrapperId, auth, coin: params.coin },\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t}),\n\t\t\t);\n\t\t};\n\t}\n\n\t/**\n\t * @description Withdraw `amount` (raw u64 units) from the account's stored balance via\n\t * the PTB-callable `withdraw_funds` (folds settle → authorize → load → withdraw; clock\n\t * and accumulator root auto-injected), returning the minted `Coin<T>` for the caller to\n\t * transfer or compose.\n\t * @param {object} params Wrapper id, raw amount, and coin type\n\t * @returns A function that takes a Transaction object and returns the `Coin<T>`\n\t */\n\twithdrawFunds(params: { wrapperId: string; amount: bigint; coinType: string }) {\n\t\treturn (tx: Transaction): TransactionResult => {\n\t\t\tconst auth = tx.add(this.generateAuth());\n\t\t\treturn tx.add(\n\t\t\t\taccount.withdrawFunds({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\targuments: { wrapper: params.wrapperId, auth, amount: params.amount },\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t}),\n\t\t\t);\n\t\t};\n\t}\n\n\t/**\n\t * @description Borrow the `Account` out of its wrapper — the read-side entry point apps\n\t * chain their own getters onto (`account::balance<T>`, an app's own data accessors).\n\t * @param {object} params Wrapper id\n\t * @returns A function that takes a Transaction object and returns the `Account`\n\t */\n\tloadAccount(params: { wrapperId: string }) {\n\t\treturn (tx: Transaction): TransactionResult =>\n\t\t\ttx.add(account.loadAccount({ config: this.#config, arguments: { self: params.wrapperId } }));\n\t}\n\n\t/**\n\t * @description Read an owner's stored custody balance for a coin type: chains\n\t * `load_account(wrapper)` → `balance<T>(account, root, clock)`. Compose in a\n\t * dev-inspect/simulate PTB and read the u64 return of the LAST command.\n\t * @param {object} params Owner address and coin type\n\t * @returns A function that takes a Transaction object\n\t */\n\tbalance(params: { owner: string; coinType: string }) {\n\t\treturn (tx: Transaction): TransactionResult => {\n\t\t\tconst acct = tx.add(\n\t\t\t\tthis.loadAccount({ wrapperId: this.deriveAccountWrapperId(params.owner) }),\n\t\t\t);\n\t\t\treturn tx.add(\n\t\t\t\taccount.balance({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t\targuments: { self: acct },\n\t\t\t\t}),\n\t\t\t);\n\t\t};\n\t}\n}\n\n// === Generated bindings ===\n// The move-call thunks and BCS structs, for consumers composing their own PTBs or\n// parsing account objects/events (e.g. `AccountWrapper.parse`, the event layouts).\n//\n// NOTE: `Account` here is the shared account primitive's custody account\n// (`account::account::Account`). It is deliberately NOT re-exported from this\n// package's root — the root already exports a different `Account`\n// (`@deepbook/core::account::Account`, the per-pool trading account) and the two\n// have unrelated layouts. Keep them separated by subpath.\nexport * as accountMoveCalls from './contracts/account/account.js';\nexport * as accountRegistryMoveCalls from './contracts/account/account_registry.js';\nexport * as accountEvents from './contracts/account/account_events.js';\nexport { Account, AccountWrapper } from './contracts/account/account.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqDA,SAAgB,iBAAiB,SAAoC;AACpE,KAAI,YAAY,UAAW,QAAO;AAClC,OAAM,IAAI,MACT,4EAA4E,QAAQ,qJAGpF;;AAKF,MAAM,oBAAoB,IAAI,OAAO,qBAAqB,EACzD,MAAM,IAAI,SACV,CAAC;;;;;;;;;;AAWF,IAAa,kBAAb,MAA6B;CAC5B;;;;CAKA,YAAY,QAAuB;AAClC,QAAKA,SAAU;;;;;;;;;CAUhB,uBAAuB,OAAuB;EAC7C,MAAM,MAAM,kBAAkB,UAAU,EAAE,MAAM,OAAO,CAAC,CAAC,SAAS;AAClE,SAAO,eACN,MAAKA,OAAQ,iBACb,GAAG,MAAKA,OAAQ,iBAAiB,wCACjC,IACA;;;;;;;;CASF,eAAe;AACd,UAAQ,OACP,GAAG,IAAIC,aAAqB,EAAE,QAAQ,MAAKD,QAAS,CAAC,CAAC;;;;;;;;CASxD,gBAAgB;AACf,UAAQ,OAA0B;GACjC,MAAM,UAAU,GAAG,IAAIE,KAAqB,EAAE,QAAQ,MAAKF,QAAS,CAAC,CAAC;AACtE,MAAG,IAAIG,MAAc;IAAE,QAAQ,MAAKH;IAAS,WAAW,EAAE,MAAM,SAAS;IAAE,CAAC,CAAC;;;;;;;;;;;;CAa/E,wBAAwB,QAA+D;AACtF,UAAQ,OAA0B;GACjC,MAAM,UAAU,GAAG,IAAIE,KAAqB,EAAE,QAAQ,MAAKF,QAAS,CAAC,CAAC;GACtE,MAAM,OAAO,GAAG,IAAI,KAAK,cAAc,CAAC;AACxC,MAAG,IACFI,aAAqB;IACpB,QAAQ,MAAKJ;IACb,WAAW;KAAE;KAAS;KAAM,MAAM,OAAO;KAAM;IAC/C,eAAe,CAAC,OAAO,SAAS;IAChC,CAAC,CACF;AACD,MAAG,IAAIG,MAAc;IAAE,QAAQ,MAAKH;IAAS,WAAW,EAAE,MAAM,SAAS;IAAE,CAAC,CAAC;;;;;;;;;;CAW/E,aAAa,QAAkF;AAC9F,UAAQ,OAA0B;GACjC,MAAM,OAAO,GAAG,IAAI,KAAK,cAAc,CAAC;AACxC,MAAG,IACFI,aAAqB;IACpB,QAAQ,MAAKJ;IACb,WAAW;KAAE,SAAS,OAAO;KAAW;KAAM,MAAM,OAAO;KAAM;IACjE,eAAe,CAAC,OAAO,SAAS;IAChC,CAAC,CACF;;;;;;;;;;;CAYH,cAAc,QAAiE;AAC9E,UAAQ,OAAuC;GAC9C,MAAM,OAAO,GAAG,IAAI,KAAK,cAAc,CAAC;AACxC,UAAO,GAAG,IACTK,cAAsB;IACrB,QAAQ,MAAKL;IACb,WAAW;KAAE,SAAS,OAAO;KAAW;KAAM,QAAQ,OAAO;KAAQ;IACrE,eAAe,CAAC,OAAO,SAAS;IAChC,CAAC,CACF;;;;;;;;;CAUH,YAAY,QAA+B;AAC1C,UAAQ,OACP,GAAG,IAAIM,YAAoB;GAAE,QAAQ,MAAKN;GAAS,WAAW,EAAE,MAAM,OAAO,WAAW;GAAE,CAAC,CAAC;;;;;;;;;CAU9F,QAAQ,QAA6C;AACpD,UAAQ,OAAuC;GAC9C,MAAM,OAAO,GAAG,IACf,KAAK,YAAY,EAAE,WAAW,KAAK,uBAAuB,OAAO,MAAM,EAAE,CAAC,CAC1E;AACD,UAAO,GAAG,IACTO,QAAgB;IACf,QAAQ,MAAKP;IACb,eAAe,CAAC,OAAO,SAAS;IAChC,WAAW,EAAE,MAAM,MAAM;IACzB,CAAC,CACF"}
+{"version":3,"file":"account.mjs","names":["#config","account.generateAuth","accountRegistry._new","account.share","account.depositFunds","account.withdrawFunds","account.loadAccount","account.balance"],"sources":["../src/account.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { bcs } from '@mysten/sui/bcs';\nimport type {\n\tTransaction,\n\tTransactionObjectArgument,\n\tTransactionResult,\n} from '@mysten/sui/transactions';\nimport { deriveObjectID } from '@mysten/sui/utils';\n\nimport * as account from './contracts/account/account.js';\nimport * as accountRegistry from './contracts/account/account_registry.js';\nimport type { AccountConfig as GeneratedAccountConfig } from './contracts/account/config-arguments.js';\nimport { MAINNET_ACCOUNT } from './deployments/mainnet.js';\nimport { TESTNET_ACCOUNT } from './deployments/testnet.js';\nimport type { NetworkArg } from './deployments/index.js';\n\n// Provenance: which on-chain deployment the ids above came from. Re-exported so a consumer\n// can answer \"which deploy is this build pinned to?\" without reaching for another subpath.\nexport { getDeployment, getUnits, TESTNET_DEPLOYMENT, TESTNET_UNITS } from './deployments/index.js';\nexport type { NetworkArg } from './deployments/index.js';\nexport type { DeployedNetwork } from './deployments/index.js';\n\n/**\n * The deployed ids of the shared `account` package this contract builds against.\n *\n * Kept deliberately minimal — ids only — so any consumer of the shared account primitive\n * (DeepBook core's account wrapper, Predict, …) can drive these builders with its OWN\n * deployment's ids without constructing a full product-SDK config.\n *\n * Extends the codegen-generated config interface so there is exactly one config shape and\n * casing: the generated bindings resolve `options.config` against these same keys, and if\n * codegen adds, drops, or renames a key this file stops compiling instead of silently\n * building a PTB against the wrong object. The ids are narrowed to `string` — codegen types\n * the package id as optional and the registry as the wider `ConfigValue`, but the\n * wrapper-address derivation needs plain ids.\n */\nexport interface AccountConfig extends GeneratedAccountConfig {\n\t/** The `account` Move package id. */\n\taccountPackageId: string;\n\t/** The shared `AccountRegistry` object id. */\n\taccountRegistry: string;\n}\n\n/**\n * @description The deployed `account` ids for `network`, so a caller does not transcribe\n * them. Generated from the deploy manifest — see `src/deployments/`.\n * @throws if the network has no recorded deployment, rather than returning placeholder ids\n * that would fail as a confusing on-chain abort.\n *\n * ```ts\n * const account = new AccountContract(getAccountConfig('testnet'));\n * ```\n */\nexport function getAccountConfig(network: NetworkArg): AccountConfig {\n\tif (network === 'testnet') return TESTNET_ACCOUNT;\n\tif (network === 'mainnet') return MAINNET_ACCOUNT;\n\tthrow new Error(\n\t\t`@mysten/deepbook-v3/account: no account deployment recorded for network '${network}'. ` +\n\t\t\t'The account primitive is recorded for testnet and mainnet; for your own deployment pass ' +\n\t\t\t'`{ accountPackageId, accountRegistry }` to AccountContract directly.',\n\t);\n}\n\n// `AccountWrapperKey(address)` is a one-field positional struct, so its BCS is just the\n// owner's 32-byte address. See `packages/account/sources/account_registry.move`.\nconst AccountWrapperKey = bcs.struct('AccountWrapperKey', {\n\tpos0: bcs.Address,\n});\n\n/**\n * AccountContract — the reusable on-chain account primitive (`packages/account`).\n *\n * An owner has one canonical `AccountWrapper`, a *derived* object of the account registry,\n * so its id is computable off-chain (no read). The wrapper holds an `Account` whose custody\n * balances apps deposit into and withdraw from; app-specific data hangs off it under an\n * app-keyed slot. Authority is a hot-potato `Auth` minted from the tx sender and consumed\n * by the very next account-loading call.\n */\nexport class AccountContract {\n\t#config: AccountConfig;\n\n\t/**\n\t * @param {AccountConfig} config Deployed ids of the shared `account` package\n\t */\n\tconstructor(config: AccountConfig) {\n\t\tthis.#config = config;\n\t}\n\n\t/**\n\t * @description The deterministic id of an owner's canonical account wrapper — no chain\n\t * read needed. The wrapper is a derived object of the account registry, so its id is\n\t * `derive_address(registry, AccountWrapperKey(owner))`.\n\t * @param {string} owner Owner address\n\t * @returns The wrapper object id\n\t */\n\tderiveAccountWrapperId(owner: string): string {\n\t\tconst key = AccountWrapperKey.serialize({ pos0: owner }).toBytes();\n\t\treturn deriveObjectID(\n\t\t\tthis.#config.accountRegistry,\n\t\t\t`${this.#config.accountPackageId}::account_registry::AccountWrapperKey`,\n\t\t\tkey,\n\t\t);\n\t}\n\n\t/**\n\t * @description Mint owner authority for the transaction sender. A hot-potato `Auth`\n\t * consumed by the very next account-loading call (`load_account_mut` inside\n\t * `deposit_funds` / `withdraw_funds` / an app's own entrypoints).\n\t * @returns A function that takes a Transaction object\n\t */\n\tgenerateAuth() {\n\t\treturn (tx: Transaction): TransactionResult =>\n\t\t\ttx.add(account.generateAuth({ config: this.#config }));\n\t}\n\n\t/**\n\t * @description Create the sender's canonical account wrapper and share it. `new` derives\n\t * the wrapper at its deterministic address (see `deriveAccountWrapperId`) and aborts if\n\t * it already exists; `share` publishes the shared object apps borrow against.\n\t * @returns A function that takes a Transaction object\n\t */\n\tcreateAccount() {\n\t\treturn (tx: Transaction): void => {\n\t\t\tconst wrapper = tx.add(accountRegistry._new({ config: this.#config }));\n\t\t\ttx.add(account.share({ config: this.#config, arguments: { self: wrapper } }));\n\t\t};\n\t}\n\n\t/**\n\t * @description First-time funding in ONE PTB: create the sender's wrapper, deposit\n\t * `coin` through the fresh handle, then `share` LAST (once shared, by-value use of the\n\t * handle is over). This cannot be split into `createAccount` + `depositFunds`: an object\n\t * input can only address an object that pre-exists the PTB, so a wrapper created inside\n\t * it is reachable only through `new`'s result handle.\n\t * @param {object} params Coin to deposit and its coin type\n\t * @returns A function that takes a Transaction object\n\t */\n\tcreateAccountAndDeposit(params: { coin: TransactionObjectArgument; coinType: string }) {\n\t\treturn (tx: Transaction): void => {\n\t\t\tconst wrapper = tx.add(accountRegistry._new({ config: this.#config }));\n\t\t\tconst auth = tx.add(this.generateAuth());\n\t\t\ttx.add(\n\t\t\t\taccount.depositFunds({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\targuments: { wrapper, auth, coin: params.coin },\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t}),\n\t\t\t);\n\t\t\ttx.add(account.share({ config: this.#config, arguments: { self: wrapper } }));\n\t\t};\n\t}\n\n\t/**\n\t * @description Deposit a caller-provided `coin` into the account's stored balance via the\n\t * PTB-callable `deposit_funds` (folds settle → authorize → load → deposit; clock and\n\t * accumulator root auto-injected). The caller owns coin sourcing.\n\t * @param {object} params Wrapper id, coin to deposit, and its coin type\n\t * @returns A function that takes a Transaction object\n\t */\n\tdepositFunds(params: { wrapperId: string; coin: TransactionObjectArgument; coinType: string }) {\n\t\treturn (tx: Transaction): void => {\n\t\t\tconst auth = tx.add(this.generateAuth());\n\t\t\ttx.add(\n\t\t\t\taccount.depositFunds({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\targuments: { wrapper: params.wrapperId, auth, coin: params.coin },\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t}),\n\t\t\t);\n\t\t};\n\t}\n\n\t/**\n\t * @description Withdraw `amount` (raw u64 units) from the account's stored balance via\n\t * the PTB-callable `withdraw_funds` (folds settle → authorize → load → withdraw; clock\n\t * and accumulator root auto-injected), returning the minted `Coin<T>` for the caller to\n\t * transfer or compose.\n\t * @param {object} params Wrapper id, raw amount, and coin type\n\t * @returns A function that takes a Transaction object and returns the `Coin<T>`\n\t */\n\twithdrawFunds(params: { wrapperId: string; amount: bigint; coinType: string }) {\n\t\treturn (tx: Transaction): TransactionResult => {\n\t\t\tconst auth = tx.add(this.generateAuth());\n\t\t\treturn tx.add(\n\t\t\t\taccount.withdrawFunds({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\targuments: { wrapper: params.wrapperId, auth, amount: params.amount },\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t}),\n\t\t\t);\n\t\t};\n\t}\n\n\t/**\n\t * @description Borrow the `Account` out of its wrapper — the read-side entry point apps\n\t * chain their own getters onto (`account::balance<T>`, an app's own data accessors).\n\t * @param {object} params Wrapper id\n\t * @returns A function that takes a Transaction object and returns the `Account`\n\t */\n\tloadAccount(params: { wrapperId: string }) {\n\t\treturn (tx: Transaction): TransactionResult =>\n\t\t\ttx.add(account.loadAccount({ config: this.#config, arguments: { self: params.wrapperId } }));\n\t}\n\n\t/**\n\t * @description Read an owner's stored custody balance for a coin type: chains\n\t * `load_account(wrapper)` → `balance<T>(account, root, clock)`. Compose in a\n\t * dev-inspect/simulate PTB and read the u64 return of the LAST command.\n\t * @param {object} params Owner address and coin type\n\t * @returns A function that takes a Transaction object\n\t */\n\tbalance(params: { owner: string; coinType: string }) {\n\t\treturn (tx: Transaction): TransactionResult => {\n\t\t\tconst acct = tx.add(\n\t\t\t\tthis.loadAccount({ wrapperId: this.deriveAccountWrapperId(params.owner) }),\n\t\t\t);\n\t\t\treturn tx.add(\n\t\t\t\taccount.balance({\n\t\t\t\t\tconfig: this.#config,\n\t\t\t\t\ttypeArguments: [params.coinType],\n\t\t\t\t\targuments: { self: acct },\n\t\t\t\t}),\n\t\t\t);\n\t\t};\n\t}\n}\n\n// === Generated bindings ===\n// The move-call thunks and BCS structs, for consumers composing their own PTBs or\n// parsing account objects/events (e.g. `AccountWrapper.parse`, the event layouts).\n//\n// NOTE: `Account` here is the shared account primitive's custody account\n// (`account::account::Account`). It is deliberately NOT re-exported from this\n// package's root — the root already exports a different `Account`\n// (`@deepbook/core::account::Account`, the per-pool trading account) and the two\n// have unrelated layouts. Keep them separated by subpath.\nexport * as accountMoveCalls from './contracts/account/account.js';\nexport * as accountRegistryMoveCalls from './contracts/account/account_registry.js';\nexport * as accountEvents from './contracts/account/account_events.js';\nexport { Account, AccountWrapper } from './contracts/account/account.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,iBAAiB,SAAoC;AACpE,KAAI,YAAY,UAAW,QAAO;AAClC,KAAI,YAAY,UAAW,QAAO;AAClC,OAAM,IAAI,MACT,4EAA4E,QAAQ,mKAGpF;;AAKF,MAAM,oBAAoB,IAAI,OAAO,qBAAqB,EACzD,MAAM,IAAI,SACV,CAAC;;;;;;;;;;AAWF,IAAa,kBAAb,MAA6B;CAC5B;;;;CAKA,YAAY,QAAuB;AAClC,QAAKA,SAAU;;;;;;;;;CAUhB,uBAAuB,OAAuB;EAC7C,MAAM,MAAM,kBAAkB,UAAU,EAAE,MAAM,OAAO,CAAC,CAAC,SAAS;AAClE,SAAO,eACN,MAAKA,OAAQ,iBACb,GAAG,MAAKA,OAAQ,iBAAiB,wCACjC,IACA;;;;;;;;CASF,eAAe;AACd,UAAQ,OACP,GAAG,IAAIC,aAAqB,EAAE,QAAQ,MAAKD,QAAS,CAAC,CAAC;;;;;;;;CASxD,gBAAgB;AACf,UAAQ,OAA0B;GACjC,MAAM,UAAU,GAAG,IAAIE,KAAqB,EAAE,QAAQ,MAAKF,QAAS,CAAC,CAAC;AACtE,MAAG,IAAIG,MAAc;IAAE,QAAQ,MAAKH;IAAS,WAAW,EAAE,MAAM,SAAS;IAAE,CAAC,CAAC;;;;;;;;;;;;CAa/E,wBAAwB,QAA+D;AACtF,UAAQ,OAA0B;GACjC,MAAM,UAAU,GAAG,IAAIE,KAAqB,EAAE,QAAQ,MAAKF,QAAS,CAAC,CAAC;GACtE,MAAM,OAAO,GAAG,IAAI,KAAK,cAAc,CAAC;AACxC,MAAG,IACFI,aAAqB;IACpB,QAAQ,MAAKJ;IACb,WAAW;KAAE;KAAS;KAAM,MAAM,OAAO;KAAM;IAC/C,eAAe,CAAC,OAAO,SAAS;IAChC,CAAC,CACF;AACD,MAAG,IAAIG,MAAc;IAAE,QAAQ,MAAKH;IAAS,WAAW,EAAE,MAAM,SAAS;IAAE,CAAC,CAAC;;;;;;;;;;CAW/E,aAAa,QAAkF;AAC9F,UAAQ,OAA0B;GACjC,MAAM,OAAO,GAAG,IAAI,KAAK,cAAc,CAAC;AACxC,MAAG,IACFI,aAAqB;IACpB,QAAQ,MAAKJ;IACb,WAAW;KAAE,SAAS,OAAO;KAAW;KAAM,MAAM,OAAO;KAAM;IACjE,eAAe,CAAC,OAAO,SAAS;IAChC,CAAC,CACF;;;;;;;;;;;CAYH,cAAc,QAAiE;AAC9E,UAAQ,OAAuC;GAC9C,MAAM,OAAO,GAAG,IAAI,KAAK,cAAc,CAAC;AACxC,UAAO,GAAG,IACTK,cAAsB;IACrB,QAAQ,MAAKL;IACb,WAAW;KAAE,SAAS,OAAO;KAAW;KAAM,QAAQ,OAAO;KAAQ;IACrE,eAAe,CAAC,OAAO,SAAS;IAChC,CAAC,CACF;;;;;;;;;CAUH,YAAY,QAA+B;AAC1C,UAAQ,OACP,GAAG,IAAIM,YAAoB;GAAE,QAAQ,MAAKN;GAAS,WAAW,EAAE,MAAM,OAAO,WAAW;GAAE,CAAC,CAAC;;;;;;;;;CAU9F,QAAQ,QAA6C;AACpD,UAAQ,OAAuC;GAC9C,MAAM,OAAO,GAAG,IACf,KAAK,YAAY,EAAE,WAAW,KAAK,uBAAuB,OAAO,MAAM,EAAE,CAAC,CAC1E;AACD,UAAO,GAAG,IACTO,QAAgB;IACf,QAAQ,MAAKP;IACb,eAAe,CAAC,OAAO,SAAS;IAChC,WAAW,EAAE,MAAM,MAAM;IACzB,CAAC,CACF"}

package/dist/client.d.mts

@@ -163,7 +163,7 @@ declare class DeepBookClient {
   }[] | null>;
   getLevel2Range(poolKey: string, priceLow: number | bigint, priceHigh: number | bigint, isBid: boolean): Promise<Level2Range>;
   getLevel2TicksFromMid(poolKey: string, ticks: number): Promise<Level2TicksFromMid>;
-  getAccountOrderDetails(poolKey: string, managerKey: string): Promise<[] | {
+  getAccountOrderDetails(poolKey: string, managerKey: string): Promise<{
     balance_manager_id: string;
     order_id: string;
     client_order_id: string;
@@ -177,7 +177,7 @@ declare class DeepBookClient {
     epoch: string;
     status: number;
     expire_timestamp: string;
-  }[]>;
+  }[] | []>;
   account(poolKey: string, managerKey: string): Promise<AccountInfo>;
   lockedBalance(poolKey: string, balanceManagerKey: string): Promise<LockedBalances>;
   getPoolDeepPrice(poolKey: string): Promise<PoolDeepPrice>;