@candledottv/agent-sdk 0.6.3 → 0.6.5

package/README.md

@@ -130,7 +130,8 @@ const fill = await candle.trade({ mint: "9dXSV8...CNDL", side: "buy", amountRaw:
 - `getPortfolio()`, `getProfilePnl(keyPrefix)`, `getProfileTrades(keyPrefix)` and
   `getSpendLimits()` read the account's holdings, a profile's P&L and fills, and this key's caps.
 - `fees.list()` and `fees.claim(mint, { dryRun })` read what the account's launched tokens can pay in creator fees and claim it to the wallet fixed at launch (off until the server enables it).
-- `closeEmptyAccounts()` closes the embedded wallet's empty token accounts and returns the rent.
+- `closeEmptyAccounts()` closes the embedded wallet's empty token accounts and returns the rent;
+  with `wallet` and `privyWalletId`, a Solana TEE wallet's, signed through `signLinkedTransaction()`.
 - The `perps*` methods (`perpsSetup`, `perpsOpen`, `perpsClose`, `perpsOrders`,
   `perpsPositions`, ...) drive Hyperliquid perps.
 

package/dist/client.d.ts

@@ -56,8 +56,12 @@ export type Chain = "solana" | "hood";
  * NFT gate; see docs/superpowers/specs/2026-08-04-test-curve-configs-design.md). Test tiers are
  * creatable only where the API's ENABLE_TEST_CURVES flag is on; the server refuses them
  * otherwise, so client code needs no gate of its own.
+ *
+ * Then the experimental fast curves (Solana, SOL or CNDL): the presets `exp-a`, `exp-b` and
+ * `exp-c`, and `exp-custom`, which takes the launcher's own V and G in `curve`. `exp-custom` is
+ * creatable only where the API has EXP_CUSTOM_CURVES on; elsewhere it is refused as an unknown mode.
  */
-export type LaunchTier = "open" | "exclusive" | "test-open" | "test-exclusive";
+export type LaunchTier = "open" | "exclusive" | "test-open" | "test-exclusive" | "exp-a" | "exp-b" | "exp-c" | "exp-custom";
 /**
  * `finalstretch`: pump.fun tokens at 50% or more of their bonding curve, most complete first; no delta, read the whole list.
  * It exists only where the API has it switched on; elsewhere it is refused like an unknown bucket.
@@ -176,6 +180,49 @@ export interface PresetsPayload {
     matrixVersion: number;
     presets: LaunchPreset[];
 }
+/**
+ * Solana pool fee at graduation: a flat tier in bps, or an anti-snipe fall from `startBps` (at most
+ * 2500) to `endBps` over `minutes` (at most 30). Omitted, the pool keeps today's flat 50 bps.
+ */
+export type PoolFee = {
+    tier: 25 | 50 | 100;
+} | {
+    startBps: number;
+    endBps: 25 | 50 | 100;
+    minutes: number;
+};
+/**
+ * The `graduation` block of a dry run, present only when the launch chose a non-default pool fee or
+ * shape. Estimates are at the graduation threshold; the final burn follows the frozen on-chain price.
+ */
+export interface LaunchGraduationPreview {
+    /** The chosen schedule; absent when the launch kept the flat 50 bps pool. */
+    poolFeeSchedule?: PoolFee;
+    poolOpen?: "curve_price";
+    expPoolShape?: "full_range";
+    /** Base burned at the threshold, raw. */
+    estimatedBurnRaw?: string;
+    /** Base seeded into the pool at the threshold, raw. */
+    estimatedSeedRaw?: string;
+    /** curve_price only: the most bps the staker carve plus the team allocation can add up to on this tier. */
+    maxStakerCarveBps?: number;
+    /** The fee at pool open (a falling schedule's start). */
+    startBps?: number;
+    /** Where a falling schedule settles. */
+    endBps?: number;
+    shape?: "curve_price" | "legacy" | "full_range" | "floor";
+    burnsRemainder?: boolean;
+}
+/**
+ * `mode: "exp-custom"` only, and required there: the launcher-chosen curve, in WHOLE units of the
+ * quote asset (sol or cndl) as decimal strings, never raw units. `"12"` is 12 SOL.
+ */
+export interface LaunchCurve {
+    /** V: the virtual quote the curve starts with. */
+    virtualQuote: string;
+    /** G: the quote the curve raises before it graduates. */
+    threshold: string;
+}
 /** POST /api/v1/launch/headless request body. The server is the authoritative validator. */
 export interface LaunchRequest {
     /** Idempotency key, unique per account. launch() generates "sdk-" + UUID when absent. */
@@ -183,7 +230,20 @@ export interface LaunchRequest {
     chain?: Chain;
     quoteAsset?: string;
     mode?: LaunchTier;
+    /** `mode: "exp-custom"` only, and required there. Dry-run first: the API checks the limits. */
+    curve?: LaunchCurve;
+    /**
+     * An `exp-` mode only: an extra creator fee of 100 or 200 basis points on top of the curve's 1%
+     * and the pool's 0.5%, paid to the creator in full. 0 is the same as leaving it out.
+     */
+    creatorFeeBps?: 0 | 100 | 200;
     stakerAllocationBps?: number;
+    /** Solana only: the graduated pool's fee. Omitted keeps the flat 50 bps pool. */
+    poolFee?: PoolFee;
+    /** Solana preset tiers only: "curve_price" opens the pool at the curve's last price and burns the rest. Omitted is "legacy". */
+    poolOpen?: "legacy" | "curve_price";
+    /** Solana exp- curves only: "full_range" opens the pool across the whole price range. Omitted is "floor". */
+    expPoolShape?: "floor" | "full_range";
     /** Hood only, required there: which Uniswap version the curve graduates through. */
     dexVersion?: "v3" | "v4";
     /** Initial dev buy. Solana: JSON number in the pair's base units. Hood: decimal string in wei. */
@@ -254,21 +314,94 @@ export interface ConfirmSelfLaunchRequest {
 /** POST /api/v1/launch/self/confirm response. Mirrors LaunchResult. */
 export interface ConfirmSelfLaunchResult extends LaunchResult {
 }
+/**
+ * An `exp-` launch's curve terms, on every launch response of those modes. Display figures from the
+ * closed form, before fees.
+ */
+export interface LaunchCurveTerms extends CurveTerms {
+    /** V in the quote's raw units. */
+    virtualQuoteRaw?: string;
+    /** The first buy `firstBuySupplyPct` prices, raw. */
+    firstBuyRaw?: string;
+    /** That buy's share of the whole supply, before fees, as a percentage. */
+    firstBuySupplyPct?: number;
+}
+/** One venue's fee on a trade of one whole quote unit, in whole quote units. */
+export interface LaunchPreviewFeeLine {
+    feeBps: number;
+    fee: number;
+    /** What the token's earning slot receives: half the base fee, and any extra creator fee in full. */
+    creatorShare: number;
+    /** What the platform receives: the other half of the base fee. */
+    platformShare: number;
+}
+/**
+ * The launch preview a dry run returns as `curveTerms`, on every mode, from servers that have it.
+ * `firstBuyRaw` is the request's own `buyAmount` (a reference buy when it is 0) and
+ * `firstBuySupplyPct` that buy's share before fees.
+ */
+export interface LaunchPreviewTerms extends LaunchCurveTerms {
+    firstBuyRaw: string;
+    firstBuySupplyPct: number;
+    /** The same buy as the curve program fills it from an empty curve. */
+    firstBuy: {
+        basis: "buyAmount" | "reference";
+        amountRaw: string;
+        curveFeeRaw: string;
+        /** Tokens received after the curve fee, raw. */
+        tokensOutRaw: string;
+        supplyPct: number;
+    };
+    fees: {
+        curve: LaunchPreviewFeeLine;
+        pool: LaunchPreviewFeeLine;
+    };
+    migration: {
+        venue: "meteora_damm_v2" | "uniswap_v3" | "uniswap_v4";
+        poolFeeBps: number;
+        /** `floor`: the pool's lower bound is the curve's start price (exp- modes). */
+        poolShape: "full_range" | "floor";
+        /** The pool's opening price against the curve's last price, percent; negative opens below it. */
+        openingPriceStepPct: number;
+        lpLock: "permanent";
+    };
+}
+/** The request as a dry run resolved and validated it. */
+export interface ResolvedLaunch {
+    chain: Chain;
+    quoteAsset: string;
+    mode: LaunchTier;
+    stakerAllocationBps: number;
+    /** Present only when the launch has an extra creator fee. */
+    creatorFeeBps?: 100 | 200;
+    /** `exp-custom` only: the curve as validated and hashed, in the quote's raw units. */
+    curve?: {
+        virtualQuoteRaw: string;
+        thresholdRaw: string;
+    };
+    dexVersion: "v3" | "v4" | null;
+    visibility: string;
+    buyAmount: string;
+}
 /** POST /api/v1/launch/headless/dry-run response. */
 export interface DryRunResult {
     success: true;
     dryRun: true;
     /** Wallet the real launch pays from; null when no wallet is available for the resolved chain. */
     launchWallet: string | null;
-    resolved: {
-        chain: Chain;
-        quoteAsset: string;
-        mode: LaunchTier;
-        stakerAllocationBps: number;
-        dexVersion: "v3" | "v4" | null;
-        visibility: string;
-        buyAmount: string;
-    };
+    resolved: ResolvedLaunch;
+    /**
+     * The launch preview: the curve's terms, the first buy priced on this request's own buyAmount,
+     * the fee lines and the migration terms. Every mode, from servers that have it; an older server
+     * sends it on exp- modes only, as `LaunchCurveTerms`.
+     */
+    curveTerms?: LaunchPreviewTerms;
+    /**
+     * The dev-buy ceiling this launch is held to, in buyAmount's base units: on an exp- curve the
+     * lower of 10% of the threshold and the ordinary ceiling. null for a pair with no dev buy; absent
+     * from older servers.
+     */
+    devBuyMax?: string | null;
     checks: {
         image: string;
         /** `"ok"` when a `bannerUrl` was sent and checked; absent otherwise. */
@@ -292,6 +425,8 @@ export interface DryRunResult {
         maxNameBytes: number;
         fits: boolean;
     };
+    /** Present only when the launch chose a non-default pool fee or shape. */
+    graduation?: LaunchGraduationPreview;
 }
 /**
  * POST /api/v1/launch/self/dry-run response: the headless dry run's shape, with `launchWallet` the
@@ -318,6 +453,10 @@ export interface LaunchResult {
     quoteAsset: string;
     mode: LaunchTier;
     stakerAllocationBps: number;
+    /** Present only when the launch has an extra creator fee. */
+    creatorFeeBps?: 100 | 200;
+    /** An exp- launch's curve terms; absent on every other mode. */
+    curveTerms?: LaunchCurveTerms;
     matrixVersion: number;
     links: {
         candle: string;
@@ -1730,7 +1869,7 @@ export interface EvmSignTransactionParams {
  *
  * A TEE payer (Ember Phase 4c) may also start from USDC, and needs `clientTradeId`: the server
  * then resolves the destination to this key's own TEE wallet on Hood (`toWalletId` names one when
- * the key has several), requires a raw cap on the origin asset, and charges no fee. That bridge is
+ * the key has several), honours any cap on the origin asset (none is required), and charges no fee. That bridge is
  * gated by the server's `TEE_BRIDGE_ENABLED`; with it off the build answers `PAIR_UNSUPPORTED`.
  * A Hood-origin bridge signs one leg at a time and is not this call; `candle swap` runs it.
  */
@@ -1999,6 +2138,8 @@ export interface PerpsWithdrawStatus {
     netUsdc: string;
     minimumOutUsdc: string;
     relayRequestId: string;
+    /** Relay `protocol.v2.orderId`, when the quote stored one. Status reads still use `relayRequestId`. */
+    relayOrderId?: string;
     nonce: number;
     failureReason: string | null;
     relay?: {
@@ -2153,7 +2294,7 @@ export interface PerpsOrders {
  * Perps C (BE-647, HL-ED-8): `perpsDeposit()`. Relay moves funds from the key's Hood or Solana TEE
  * wallet onto Hyperliquid perps USDC at the key's EVM TEE wallet's own address. The asset decides
  * the paying chain: SOL or USDC from the Solana TEE wallet, ETH or USDG from the Hood one. Needs
- * `swap:write` and a raw cap on the asset. There is no withdrawal yet.
+ * `swap:write`; any cap on the asset still applies. There is no withdrawal yet.
  */
 export interface PerpsDepositParams {
     /** Idempotency id, 1 to 128 of `A-Za-z0-9._:-`. Rebuilding under the same id answers its job. */
@@ -2171,15 +2312,25 @@ export interface PerpsDepositParams {
     perpsWalletId?: string;
     /** Relay slippage, 1 to 1000 bps (default 100). */
     maxSlippageBps?: number;
-    /** Sign and submit (default), or stop after the build and its check. */
+    /**
+     * Sign and submit (default), or `false` for a dry run: the API previews the deposit (`preview:
+     * true`), locking no wallet, reserving no USD window and recording no id, and nothing is signed.
+     */
     submit?: boolean;
 }
-/** What `POST /agent/perps/deposit` builds. A Hood build also carries the first sequenced leg. */
+/**
+ * What `POST /agent/perps/deposit` builds. A Hood build also carries the first sequenced leg. A
+ * preview (`status: "preview"`, from `submit: false`) has no `depositId`, `expiresAt` or sequenced
+ * leg; from Hood it carries `plannedLegs` instead.
+ */
 export interface PerpsDepositBuild {
     success: true;
-    status: "built";
+    status: "built" | "preview";
+    /** A dry run: nothing is held, and the same id still builds a new deposit. */
+    preview?: true;
     clientDepositId: string;
-    depositId: string;
+    /** Absent on a preview. */
+    depositId?: string;
     chain: "solana" | "hood";
     venue: "relay";
     network: HyperliquidNetwork;
@@ -2205,9 +2356,17 @@ export interface PerpsDepositBuild {
     };
     statusChecks: string[];
     requestId: string | null;
-    expiresAt: number;
+    /** Absent on a preview. */
+    expiresAt?: number;
     /** Solana: the one unsigned deposit. */
     transactionsBase64?: string[];
+    /** A Hood preview: the legs' calldata, nothing sequenced. */
+    plannedLegs?: Array<{
+        kind: string;
+        to: string;
+        data: string;
+        value: string;
+    }>;
     /** Hood: the sequenced leg protocol's first body. */
     mode?: "sequenced";
     operationId?: string;
@@ -2469,11 +2628,18 @@ export interface SkippedEmptyTokenAccount extends EmptyTokenAccount {
 export interface PreviewCloseEmptyAccountsRequest {
     /** Mints whose empty accounts stay open, e.g. the pair token a held holder-reward coin pays in. */
     keep?: string[];
+    /**
+     * A Solana TEE wallet's linked-wallet id, to preview that wallet instead of the embedded one
+     * (BE-1687). Any key bound to the wallet may preview it.
+     */
+    wallet?: string;
 }
 /** previewCloseEmptyAccounts()'s result. Nothing was built, signed or written to produce it. */
 export interface CloseEmptyAccountsPreview {
     success: true;
     wallet: string;
+    /** The TEE wallet's linked-wallet id, on a TEE wallet's preview. */
+    linkedWalletId?: string;
     keep: string[];
     accounts: EmptyTokenAccount[];
     accountCount: number;
@@ -2497,9 +2663,18 @@ export interface CloseEmptyAccountsRequest {
     keep?: string[];
     /** The preview's `accounts[].account`, to close only what was shown. Omit to close every qualifying account. */
     accounts?: string[];
+    /**
+     * A Solana TEE wallet's linked-wallet id, to close that wallet's accounts instead of the embedded
+     * wallet's (BE-1687). Needs `swap:write`, `privyWalletId`, and the wallet's signer in `secretStore`.
+     */
+    wallet?: string;
+    /** The TEE wallet's Privy wallet id, which signLinkedTransaction() signs for. Required with `wallet`. */
+    privyWalletId?: string;
 }
 /** A close transaction that landed. */
 export interface CloseEmptyAccountsBatch {
+    /** The transaction's place in a TEE wallet's built batch. */
+    index?: number;
     signature: string;
     accounts: string[];
     lamports: string;
@@ -2510,18 +2685,37 @@ export interface CloseEmptyAccountsBatch {
  * re-preview before re-running.
  */
 export interface CloseEmptyAccountsFailure {
+    /** The transaction's place in a TEE wallet's built batch. */
+    index?: number;
     accounts: string[];
     code: string;
     message: string;
     signature?: string;
 }
+/**
+ * A TEE wallet's close transaction the chain has not settled yet (BE-1687). Its rent is not counted,
+ * and the operation stays `recovering` until every one is settled.
+ */
+export interface CloseEmptyAccountsUnresolved {
+    index: number;
+    accounts: string[];
+    /** Known once the transaction was signed and recorded. */
+    signature?: string;
+    reason: string;
+}
 /** closeEmptyAccounts()'s result. A run in which nothing landed throws a CandleApiError instead. */
 export interface CloseEmptyAccountsResult {
     success: true;
-    /** `partial`: some batch failed, or more accounts remain than one call closes. */
-    status: "completed" | "partial" | "nothing_to_close";
+    /**
+     * `partial`: some batch failed, or more accounts remain than one call closes. `recovering`, a TEE
+     * wallet's close only: a transaction may still land. Nothing is sent again; read
+     * getCloseEmptyAccountsJob(clientTradeId, { wallet }) until it settles.
+     */
+    status: "completed" | "partial" | "nothing_to_close" | "recovering";
     clientTradeId: string;
     wallet: string;
+    /** The TEE wallet's linked-wallet id, on a TEE wallet's close. */
+    linkedWalletId?: string;
     keep: string[];
     closed: EmptyTokenAccount[];
     transactions: CloseEmptyAccountsBatch[];
@@ -2530,8 +2724,11 @@ export interface CloseEmptyAccountsResult {
     solRecovered: string;
     /** The base network fee of the transactions that landed, reverted ones included, 5,000 lamports each. */
     feeLamports: string;
-    netLamports: string;
-    netSol: string;
+    /** Absent while `status` is `recovering`: no net is final until every transaction settles. */
+    netLamports?: string;
+    netSol?: string;
+    /** A TEE close that landed before its fee could be read: `feeLamports` does not count it yet. */
+    feeUnresolved?: true;
     failed: CloseEmptyAccountsFailure[];
     /** Accounts in batches never sent, after a failure that stops the run. */
     unattempted: string[];
@@ -2544,15 +2741,35 @@ export interface CloseEmptyAccountsResult {
     remaining: number;
     /** Present when this is the stored report of an earlier call under the same id. */
     replayed?: true;
+    /** `recovering` only: what the server says to do next. */
+    message?: string;
+    /** `recovering` only: the TEE close transactions not settled yet. */
+    unresolved?: CloseEmptyAccountsUnresolved[];
+}
+/** Which wallet getCloseEmptyAccountsJob() reads: the embedded wallet's runs, or a TEE wallet's. */
+export interface CloseEmptyAccountsJobOptions {
+    /** A Solana TEE wallet's linked-wallet id (BE-1687). Omit for the embedded wallet. */
+    wallet?: string;
 }
 export interface CloseEmptyAccountsJob {
     clientTradeId: string;
     kind: "close-empty";
-    status: "running" | "completed" | "failed";
+    /** `built`, a TEE wallet's only: the transactions await their signatures, or are being sent or recovered. */
+    status: "running" | "built" | "completed" | "failed";
+    /** On a TEE wallet's job. */
+    walletKind?: "tee";
+    linkedWalletId?: string;
+    /** A TEE wallet's send state: `idle` before submit, then `submitting`, `recovering` or `done`. */
+    submitState?: "idle" | "submitting" | "recovering" | "done";
+    /** On a TEE wallet's job: whether this read reconciled the row against the chain. */
+    reconciled?: boolean;
     createdAt: number;
     finishedAt?: number;
     httpStatus?: number;
-    /** The report the close call returned, once it finished. */
+    /**
+     * The report the close call returned, once it finished. On a TEE wallet's job, the build while
+     * its signatures are awaited, the report (`recovering` until the chain settles), or the stored error.
+     */
     result?: CloseEmptyAccountsResult | Record<string, unknown>;
 }
 /** trade()'s one-call request: mirrors BuildTradeRequest minus clientTradeId/payer, plus who signs. */
@@ -2654,6 +2871,42 @@ export interface BuildAtomicLaunchResult {
     legs: AtomicBundleResponseLeg[];
     expiresAt: number;
 }
+/** One first buy in an atomic dry run, as `/build` would floor it. */
+export interface AtomicDryRunFill {
+    /** The leg's index in the bundle, 1 to 4. */
+    index: number;
+    signer: AtomicBundleLegSigner;
+    payerType: "main" | "linked";
+    wallet: string;
+    amountRaw: string;
+    /** The agent-tier fee `/build` appends to this leg, raw. */
+    feeRaw: string;
+    /** What `/build`'s leg would carry: the ladder fill, and the floor it signs at. */
+    expectedFill: {
+        amountOutRaw: string;
+        minAmountOutRaw: string;
+    };
+    supplyPct: number;
+}
+/** POST /api/v1/launch/atomic/dry-run response. */
+export interface AtomicDryRunResult {
+    success: true;
+    dryRun: true;
+    /** The wallet that pays for the launch leg. Never checked for balance. */
+    launchWallet: string;
+    launchSigner: AtomicBundleLegSigner;
+    resolved: Omit<ResolvedLaunch, "dexVersion" | "buyAmount">;
+    curveTerms?: LaunchPreviewTerms;
+    /** Present only when the launch chose a non-default pool fee or shape. */
+    graduation?: LaunchGraduationPreview;
+    fills: AtomicDryRunFill[];
+    /** Whether the first buys alone take the new curve to its threshold inside the bundle. */
+    graduatesInBundle: boolean;
+    checks: {
+        exclusiveEligible?: boolean;
+    };
+    matrixVersion: number;
+}
 /**
  * POST /api/v1/launch/atomic/submit request body: EXACTLY the client-signer legs
  * `BuildAtomicLaunchResult.legs` named (`signer: "client"`), in leg order -- omit every "server"
@@ -3011,6 +3264,10 @@ export declare class CandleClient {
      * Lists the embedded Solana wallet's empty token accounts that a close would reclaim, on both
      * token programs, and the SOL their rent returns (BE-418). Read-only: nothing is built, signed or
      * written, and any key scope may call it.
+     *
+     * With `wallet` (a Solana TEE wallet's linked-wallet id, BE-1687), the same preview for that TEE
+     * wallet, by any key bound to it. Off on a deployment until it is enabled
+     * (`AGENT_TEE_CLOSE_EMPTY_ENABLED`): until then it throws LAUNCH_DISABLED.
      */
     previewCloseEmptyAccounts(req?: PreviewCloseEmptyAccountsRequest): Promise<CloseEmptyAccountsPreview>;
     /**
@@ -3023,10 +3280,27 @@ export declare class CandleClient {
      * returns its stored report (`replayed: true`), a repeat while it runs throws CLOSE_IN_PROGRESS,
      * and the same id with a different request throws IDEMPOTENCY_CONFLICT. So a retry under the
      * same id is safe, and this method still never retries on its own.
+     *
+     * With `wallet` (a Solana TEE wallet's linked-wallet id bound to this key, BE-1687), the TEE
+     * wallet's close instead. Needs `swap:write`, `privyWalletId`, and that wallet's signer in
+     * `secretStore`. Three steps: `POST /agent/wallets/:id/close-empty/build` (the server builds
+     * the close transactions, every one CloseAccount with the TEE wallet as fee payer, rent
+     * destination and owner, and stamps them for the relay), `signLinkedTransaction()` per
+     * transaction, then `POST .../close-empty/submit` with the whole signed batch, which the server
+     * checks against the build before it sends anything. A build with nothing to close returns
+     * `nothing_to_close` without signing. A `recovering` result means a transaction may still land:
+     * nothing is sent again, and getCloseEmptyAccountsJob(clientTradeId, { wallet }) reads it until
+     * it settles. A TEE wallet's build is signable once: after a lost answer, read the job rather
+     * than calling this again. Off on a deployment until it is enabled
+     * (`AGENT_TEE_CLOSE_EMPTY_ENABLED`): until then it throws LAUNCH_DISABLED.
      */
     closeEmptyAccounts(req: CloseEmptyAccountsRequest): Promise<CloseEmptyAccountsResult>;
-    /** Reads a closeEmptyAccounts() run by its clientTradeId, without sending anything (BE-418). */
-    getCloseEmptyAccountsJob(clientTradeId: string): Promise<CloseEmptyAccountsJob>;
+    /**
+     * Reads a closeEmptyAccounts() run by its clientTradeId, without sending anything (BE-418). With
+     * `wallet`, a TEE wallet's run (BE-1687, `swap:write`): that read also reconciles the run against
+     * the chain, so a `recovering` close settles by reading it again. It never signs or sends.
+     */
+    getCloseEmptyAccountsJob(clientTradeId: string, opts?: CloseEmptyAccountsJobOptions): Promise<CloseEmptyAccountsJob>;
     /**
      * Imports an existing wallet via Candle's ciphertext-only flow (PR3): calls
      * `/agent/wallets/import/init` for Privy's HPKE receiver public key, encrypts `privateKey`
@@ -3361,6 +3635,16 @@ export declare class CandleClient {
      * before the call when you can.
      */
     buildAtomicLaunch(req: BuildAtomicLaunchRequest): Promise<BuildAtomicLaunchResult>;
+    /**
+     * Atomic launch dry run: the same body as `buildAtomicLaunch()`, the same checks (payers, plan,
+     * the Believer check, each leg's fee and spend limits, the key's transaction cap) and the same
+     * refusals, plus the launch preview and one fill per first buy. Records, reserves and draws
+     * nothing: no day-cap slot, no vanity mint, no spend reservation, and the `clientLaunchId` stays
+     * unused. Does not check balances, the day cap, a `clientLaunchId` already used with another body,
+     * a TEE leg's USD spend window or the transaction's size; `buildAtomicLaunch()` can still refuse
+     * for those. Sends the body as given, like `dryRunLaunch()`: name a `clientLaunchId`.
+     */
+    dryRunAtomicLaunch(req: BuildAtomicLaunchRequest): Promise<AtomicDryRunResult>;
     /**
      * The atomic build request itself. Sets `clientLaunchId` on the result from the request, since
      * the server's body omits it. Shared by buildAtomicLaunch() and launchAtomic(), each of which
@@ -3674,11 +3958,12 @@ export declare class CandleClient {
      * through Relay (spec 2026-10-17, route A). MOVES REAL FUNDS. Needs `perps:withdraw`.
      *
      * Every signature is checked first, and a mismatch throws with nothing signed: the NonceMapping
-     * names this key's account and Relay's request, the build lands on one of `ownDestinations`, and
-     * Relay's own record of the request names that same recipient; then the SendAsset carries the
-     * mapping's nonce, the exact amount asked for, and the pinned token, dex and depository. The
-     * client posts the SendAsset to Hyperliquid itself and reports the answer. There is no
-     * confirmation gate here: the CLI has one (`candle perps withdraw`).
+     * names this key's account and the build's Relay order id (`relayOrderId`, never the step
+     * `relayRequestId`), and the build lands on one of `ownDestinations` (the recipient check: Relay's
+     * own record of the request is not read, BE-1777); then the SendAsset carries the mapping's nonce,
+     * the exact amount asked for, and the pinned token, dex and depository. The client posts the
+     * SendAsset to Hyperliquid itself and reports the answer. There is no confirmation gate here: the
+     * CLI has one (`candle perps withdraw`).
      */
     perpsWithdraw(params: PerpsWithdrawParams): Promise<PerpsWithdrawResult>;
     /**
@@ -3729,7 +4014,7 @@ export declare function __setEvmReceiptWaitForTest(opts: {
     pollMs?: number;
 } | null): void;
 /** This build's own version. Kept in lockstep with package.json by the release-bump CI guard. */
-export declare const SDK_VERSION = "0.6.3";
+export declare const SDK_VERSION = "0.6.5";
 /** Test seam: the once-per-process latch would otherwise weld the suite's first case to the rest. */
 export declare function __resetSdkUpdateNoticeForTest(): void;
 //# sourceMappingURL=client.d.ts.map