perp-cli 0.12.17 → 0.14.0

package/dist/pacifica/deposit.js

@@ -1,5 +1,6 @@
 import { PublicKey, TransactionInstruction, Transaction, } from "@solana/web3.js";
 import { getNetworkConfig, USDC_DECIMALS } from "./constants.js";
+import { PerpError } from "../errors.js";
 const TOKEN_PROGRAM = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const ASSOCIATED_TOKEN_PROGRAM = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 const SYSTEM_PROGRAM = new PublicKey("11111111111111111111111111111111");
@@ -30,7 +31,8 @@ function getEventAuthority(programId) {
  * Build a Pacifica deposit instruction.
  *
  * @param userPubkey - User's wallet public key
- * @param amount - Amount in USDC (e.g., 100 for $100)
+ * @param amount - Amount in USDC as a plain decimal string with at most 6 decimals (e.g. "100", "99.5");
+ *                 scaled exactly (no float math). Anything else → INVALID_PARAMS.
  * @param network - mainnet or testnet
  */
 export async function buildDepositInstruction(userPubkey, amount, network = "mainnet") {
@@ -43,7 +45,12 @@ export async function buildDepositInstruction(userPubkey, amount, network = "mai
     const eventAuthority = getEventAuthority(programId);
     // Build instruction data: discriminator + amount (u64 LE)
     const discriminator = await getDepositDiscriminator();
-    const amountLamports = BigInt(Math.round(amount * 10 ** USDC_DECIMALS));
+    const amountLamports = usdcUnits(amount);
+    if (amountLamports === null || amountLamports <= 0n) {
+        throw new PerpError("INVALID_PARAMS", `Pacifica deposit amount "${amount}" is not a positive USDC amount with at most ${USDC_DECIMALS} decimals; nothing was built`, {
+            exchange: "pacifica", remediation: `Pass a plain decimal with at most ${USDC_DECIMALS} decimals, e.g. 100 or 99.5`,
+        });
+    }
     const amountBytes = new Uint8Array(8);
     const view = new DataView(amountBytes.buffer);
     view.setBigUint64(0, amountLamports, true); // little-endian
@@ -76,3 +83,113 @@ export async function deposit(connection, userPubkey, amount, signTransaction, n
     const signed = await signTransaction(tx);
     return connection.sendRawTransaction(signed.serialize());
 }
+const COMPUTE_BUDGET_PROGRAM = new PublicKey("ComputeBudget111111111111111111111111111111");
+/** Highest relayer fee (USDC) the CLI signs for a relayed deposit. Above it the transaction is refused. */
+export const PACIFICA_RELAY_FEE_CAP_USDC = 1;
+/** Decimal USDC string → integer base units (6 decimals), exact; null when not a plain decimal with ≤ 6 decimals. */
+function usdcUnits(amount) {
+    const m = /^(\d+)(?:\.(\d{1,6}))?$/.exec(amount.trim());
+    if (m === null)
+        return null;
+    return BigInt(m[1]) * 10n ** BigInt(USDC_DECIMALS) + BigInt((m[2] ?? "").padEnd(USDC_DECIMALS, "0"));
+}
+function readU64LE(data, offset) {
+    if (data.length < offset + 8)
+        return null;
+    return new DataView(data.buffer, data.byteOffset + offset, 8).getBigUint64(0, true);
+}
+/**
+ * Verify a RELAYER-BUILT transaction before the master Solana key signs it. The relayer is an
+ * untrusted HTTP service (PERP_RELAYER_URL): whatever it returns is signed only when it is
+ * exactly
+ *  - ONE pinned Pacifica deposit instruction — the program id, every account (user, user USDC
+ *    ATA, central state, vault, mint, …, in order, same signer / writable flags) and the data
+ *    `buildDepositInstruction` would produce for `declared.netAmount`;
+ *  - any number of ComputeBudget instructions (they move no funds);
+ *  - at most ONE relayer fee transfer: an SPL Token Transfer / TransferChecked of exactly
+ *    `declared.fee` USDC from the user's USDC account, authority = user, to the token account the
+ *    build response declared (`feeRecipient`), with fee ≤ PACIFICA_RELAY_FEE_CAP_USDC;
+ * and fee + netAmount equals the amount the user asked to deposit, and the fee payer is not the
+ * user (the relayer sponsors gas). Anything else → POLICY_DENIED, nothing is signed.
+ */
+export async function assertRelayedDepositTransaction(tx, ctx) {
+    const refuse = (why) => new PerpError("POLICY_DENIED", `Refusing to sign the relayer-built Pacifica deposit: ${why}. Nothing was signed`, {
+        exchange: "pacifica", remediation: "Drop --relay for a direct deposit (you pay gas, ~0.005 SOL)",
+    });
+    const { user, declared } = ctx;
+    const requested = usdcUnits(ctx.requestedAmount);
+    if (requested === null || requested <= 0n)
+        throw refuse(`the requested amount "${ctx.requestedAmount}" is not a USDC amount with at most ${USDC_DECIMALS} decimals`);
+    if (!Number.isFinite(declared.fee) || !Number.isFinite(declared.netAmount) || declared.fee < 0 || declared.netAmount <= 0) {
+        throw refuse(`the build response declares fee ${declared.fee} / netAmount ${declared.netAmount}`);
+    }
+    const feeUnits = BigInt(Math.round(declared.fee * 10 ** USDC_DECIMALS));
+    const netUnits = BigInt(Math.round(declared.netAmount * 10 ** USDC_DECIMALS));
+    if (feeUnits + netUnits !== requested)
+        throw refuse(`declared fee ${declared.fee} + netAmount ${declared.netAmount} is not the requested ${ctx.requestedAmount} USDC`);
+    if (declared.fee > PACIFICA_RELAY_FEE_CAP_USDC)
+        throw refuse(`the relayer fee ${declared.fee} USDC is above the cap of ${PACIFICA_RELAY_FEE_CAP_USDC} USDC`);
+    if (tx.feePayer === undefined || tx.feePayer === null || tx.feePayer.equals(user))
+        throw refuse("the fee payer is not the relayer (a sponsored deposit never makes the user pay gas)");
+    const config = getNetworkConfig(ctx.network);
+    const usdcMint = new PublicKey(config.usdcMint);
+    const userAta = getATA(user, usdcMint);
+    const netDecimal = `${netUnits / 10n ** BigInt(USDC_DECIMALS)}.${(netUnits % 10n ** BigInt(USDC_DECIMALS)).toString().padStart(USDC_DECIMALS, "0")}`;
+    const expected = await buildDepositInstruction(user, netDecimal, ctx.network);
+    let deposits = 0;
+    let feeTransfers = 0;
+    for (const [i, ix] of tx.instructions.entries()) {
+        const at = `instruction ${i} (${ix.programId.toBase58()})`;
+        if (ix.programId.equals(COMPUTE_BUDGET_PROGRAM)) {
+            if (ix.keys.length !== 0)
+                throw refuse(`${at}: a compute-budget instruction with accounts`);
+            continue;
+        }
+        if (ix.programId.equals(expected.programId)) {
+            const sameKeys = ix.keys.length === expected.keys.length && ix.keys.every((k, j) => k.pubkey.equals(expected.keys[j].pubkey) && k.isSigner === expected.keys[j].isSigner && k.isWritable === expected.keys[j].isWritable);
+            if (!sameKeys)
+                throw refuse(`${at}: the deposit accounts are not the pinned user / vault / mint accounts`);
+            if (!Buffer.from(ix.data).equals(Buffer.from(expected.data)))
+                throw refuse(`${at}: the deposit data is not "deposit ${declared.netAmount} USDC"`);
+            deposits++;
+            continue;
+        }
+        if (ix.programId.equals(TOKEN_PROGRAM)) {
+            // SPL Token Transfer (3): [source, destination, authority]; TransferChecked (12): [source, mint, destination, authority].
+            const tag = ix.data[0];
+            const checked = tag === 12;
+            if (tag !== 3 && !checked)
+                throw refuse(`${at}: an SPL token instruction that is not a transfer`);
+            if (ix.data.length !== (checked ? 10 : 9) || ix.keys.length !== (checked ? 4 : 3))
+                throw refuse(`${at}: a malformed token transfer`);
+            const [source, dest, authority] = checked ? [ix.keys[0], ix.keys[2], ix.keys[3]] : [ix.keys[0], ix.keys[1], ix.keys[2]];
+            if (checked && (!ix.keys[1].pubkey.equals(usdcMint) || ix.data[9] !== USDC_DECIMALS))
+                throw refuse(`${at}: the fee transfer is not in the deposit token`);
+            if (!source.pubkey.equals(userAta) || !authority.pubkey.equals(user))
+                throw refuse(`${at}: the token transfer is not from the user's own USDC account`);
+            if (declared.feeRecipient === null)
+                throw refuse(`${at}: a fee transfer the build response did not declare (no feeRecipient)`);
+            let recipient;
+            try {
+                recipient = new PublicKey(declared.feeRecipient);
+            }
+            catch {
+                throw refuse(`the declared feeRecipient "${declared.feeRecipient}" is not a Solana address`);
+            }
+            if (!dest.pubkey.equals(recipient))
+                throw refuse(`${at}: the fee transfer goes to ${dest.pubkey.toBase58()}, not the declared ${recipient.toBase58()}`);
+            if (readU64LE(ix.data, 1) !== feeUnits)
+                throw refuse(`${at}: the fee transfer amount is not the declared ${declared.fee} USDC`);
+            if (++feeTransfers > 1)
+                throw refuse("more than one fee transfer");
+            continue;
+        }
+        throw refuse(`${at} is not a Pacifica deposit, a compute-budget instruction or the declared fee transfer`);
+    }
+    if (deposits !== 1)
+        throw refuse(`it contains ${deposits} Pacifica deposit instructions (exactly one expected)`);
+    if (feeUnits > 0n && feeTransfers !== 1)
+        throw refuse(`the declared fee ${declared.fee} USDC is not transferred by the transaction`);
+    if (feeUnits === 0n && feeTransfers !== 0)
+        throw refuse("a fee transfer although the declared fee is 0");
+}

package/dist/pacifica/faucet.d.ts

@@ -0,0 +1,29 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { SolanaSigner } from "../signer/index.js";
+export declare const PACIFICA_DEVNET_RPC = "https://api.devnet.solana.com";
+export declare const MINT_TEST_USDC_COMPUTE_UNITS = 400000;
+/** sha256("global:mint_test_usdc")[:8]. */
+export declare function mintTestUsdcDiscriminator(): Buffer;
+/** Plain positive decimal with ≤ 6 decimals → base units (u64). */
+export declare function testUsdcBaseUnits(amount: string): bigint;
+export interface MintTestUsdcPlan {
+    user: string;
+    userAccountPda: string;
+    userAta: string;
+    mint: string;
+    centralState: string;
+    programId: string;
+    amount: string;
+    baseUnits: string;
+}
+/** Accounts + amount the faucet instruction uses (pure; used for --dry-run). */
+export declare function mintTestUsdcPlan(user: PublicKey, amount: string): MintTestUsdcPlan;
+export declare function buildMintTestUsdcInstruction(plan: MintTestUsdcPlan): TransactionInstruction;
+/**
+ * Build, sign, SIMULATE, then send + confirm the faucet transaction. A simulation
+ * error throws EXCHANGE_ERROR (with the program logs) and nothing is sent.
+ */
+export declare function mintTestUsdc(connection: Connection, signer: SolanaSigner, amount: string): Promise<{
+    signature: string;
+    plan: MintTestUsdcPlan;
+}>;

package/dist/pacifica/faucet.js

@@ -0,0 +1,100 @@
+/**
+ * Pacifica TESTNET (Solana devnet) test-USDP faucet — Anchor `mint_test_usdc`.
+ *
+ * Testnet tooling only: the instruction exists on the devnet program
+ * (TESTNET_PROGRAM_ID); there is no mainnet equivalent and callers refuse
+ * mainnet before building anything.
+ *
+ * Instruction (verified on devnet 2026-10-02 with a simulated + sent tx):
+ *   data     = sha256("global:mint_test_usdc")[:8] (76904e769bd6b9ba) ‖ u64 LE amount × 1e6
+ *   accounts = user (signer, writable), PDA(["user_account", user], program) (writable),
+ *              user USDP ATA (writable), USDP mint (writable), central_state (read-only —
+ *              the verified tx sent it read-only), ATA program, token program, system program
+ *   + ComputeBudget setComputeUnitLimit(400_000).
+ * The transaction is always simulated before it is sent; a failed simulation sends nothing.
+ */
+import { createHash } from "node:crypto";
+import { ComputeBudgetProgram, PublicKey, SystemProgram, Transaction, TransactionInstruction, } from "@solana/web3.js";
+import { PerpError } from "../errors.js";
+import { getNetworkConfig, USDC_DECIMALS } from "./constants.js";
+import { signSolanaTransaction } from "./sign-tx.js";
+const TOKEN_PROGRAM = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const ASSOCIATED_TOKEN_PROGRAM = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+export const PACIFICA_DEVNET_RPC = "https://api.devnet.solana.com";
+export const MINT_TEST_USDC_COMPUTE_UNITS = 400_000;
+/** sha256("global:mint_test_usdc")[:8]. */
+export function mintTestUsdcDiscriminator() {
+    return createHash("sha256").update("global:mint_test_usdc").digest().subarray(0, 8);
+}
+/** Plain positive decimal with ≤ 6 decimals → base units (u64). */
+export function testUsdcBaseUnits(amount) {
+    if (!/^\d+(\.\d{1,6})?$/.test(amount)) {
+        throw new PerpError("INVALID_PARAMS", `Faucet amount must be a plain decimal with at most ${USDC_DECIMALS} decimals (got "${amount}")`);
+    }
+    const [ip, fp = ""] = amount.split(".");
+    const units = BigInt(ip) * 10n ** BigInt(USDC_DECIMALS) + BigInt(fp.padEnd(USDC_DECIMALS, "0"));
+    if (units <= 0n)
+        throw new PerpError("INVALID_PARAMS", `Faucet amount must be positive (got "${amount}")`);
+    if (units > 0xffffffffffffffffn)
+        throw new PerpError("INVALID_PARAMS", `Faucet amount ${amount} overflows u64`);
+    return units;
+}
+/** Accounts + amount the faucet instruction uses (pure; used for --dry-run). */
+export function mintTestUsdcPlan(user, amount) {
+    const cfg = getNetworkConfig("testnet");
+    const program = new PublicKey(cfg.programId);
+    const mint = new PublicKey(cfg.usdcMint);
+    const [userAccountPda] = PublicKey.findProgramAddressSync([Buffer.from("user_account"), user.toBuffer()], program);
+    const [userAta] = PublicKey.findProgramAddressSync([user.toBuffer(), TOKEN_PROGRAM.toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM);
+    return {
+        user: user.toBase58(),
+        userAccountPda: userAccountPda.toBase58(),
+        userAta: userAta.toBase58(),
+        mint: mint.toBase58(),
+        centralState: cfg.centralState,
+        programId: cfg.programId,
+        amount,
+        baseUnits: testUsdcBaseUnits(amount).toString(),
+    };
+}
+export function buildMintTestUsdcInstruction(plan) {
+    const amt = Buffer.alloc(8);
+    amt.writeBigUInt64LE(BigInt(plan.baseUnits));
+    return new TransactionInstruction({
+        programId: new PublicKey(plan.programId),
+        data: Buffer.concat([mintTestUsdcDiscriminator(), amt]),
+        keys: [
+            { pubkey: new PublicKey(plan.user), isSigner: true, isWritable: true },
+            { pubkey: new PublicKey(plan.userAccountPda), isSigner: false, isWritable: true },
+            { pubkey: new PublicKey(plan.userAta), isSigner: false, isWritable: true },
+            { pubkey: new PublicKey(plan.mint), isSigner: false, isWritable: true },
+            { pubkey: new PublicKey(plan.centralState), isSigner: false, isWritable: false },
+            { pubkey: ASSOCIATED_TOKEN_PROGRAM, isSigner: false, isWritable: false },
+            { pubkey: TOKEN_PROGRAM, isSigner: false, isWritable: false },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+    });
+}
+/**
+ * Build, sign, SIMULATE, then send + confirm the faucet transaction. A simulation
+ * error throws EXCHANGE_ERROR (with the program logs) and nothing is sent.
+ */
+export async function mintTestUsdc(connection, signer, amount) {
+    const user = new PublicKey(signer.getPublicKeyBase58());
+    const plan = mintTestUsdcPlan(user, amount);
+    const tx = new Transaction().add(ComputeBudgetProgram.setComputeUnitLimit({ units: MINT_TEST_USDC_COMPUTE_UNITS }), buildMintTestUsdcInstruction(plan));
+    tx.feePayer = user;
+    tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+    signSolanaTransaction(signer, tx, false);
+    const sim = await connection.simulateTransaction(tx);
+    if (sim.value.err !== null) {
+        throw new PerpError("EXCHANGE_ERROR", `Pacifica testnet faucet simulation failed: ${JSON.stringify(sim.value.err)} — nothing was sent`, {
+            exchange: "pacifica",
+            logs: (sim.value.logs ?? []).slice(-8),
+            remediation: "Check the wallet has devnet SOL for fees (solana airdrop) and retry with a smaller amount",
+        });
+    }
+    const signature = await connection.sendRawTransaction(tx.serialize());
+    await connection.confirmTransaction(signature, "confirmed");
+    return { signature, plan };
+}

package/dist/pacifica/sign-tx.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sign a Solana transaction with any SolanaSigner (local keypair or OWS vault).
+ *
+ * OWS never exposes a raw keypair, so `tx.sign(keypair)` cannot be used for vault
+ * wallets: the serialized transaction is signed through OWS and the signature is
+ * attached with `addSignature`. The signature is always verified locally before
+ * the caller sends anything.
+ */
+import { type Transaction } from "@solana/web3.js";
+import type { SolanaSigner } from "../signer/index.js";
+/**
+ * Add `signer`'s signature to `tx`. `partial` = other signatures (e.g. a relayer fee
+ * payer) are still missing; otherwise every required signature must be present.
+ */
+export declare function signSolanaTransaction(signer: SolanaSigner, tx: Transaction, partial: boolean): void;

package/dist/pacifica/sign-tx.js

@@ -0,0 +1,41 @@
+/**
+ * Sign a Solana transaction with any SolanaSigner (local keypair or OWS vault).
+ *
+ * OWS never exposes a raw keypair, so `tx.sign(keypair)` cannot be used for vault
+ * wallets: the serialized transaction is signed through OWS and the signature is
+ * attached with `addSignature`. The signature is always verified locally before
+ * the caller sends anything.
+ */
+import { PublicKey } from "@solana/web3.js";
+import { PerpError } from "../errors.js";
+import { LocalSolanaSigner } from "../signer/index.js";
+function hasBytesSigner(s) {
+    return typeof s.signTransactionBytes === "function";
+}
+/**
+ * Add `signer`'s signature to `tx`. `partial` = other signatures (e.g. a relayer fee
+ * payer) are still missing; otherwise every required signature must be present.
+ */
+export function signSolanaTransaction(signer, tx, partial) {
+    const pubkey = new PublicKey(signer.getPublicKeyBase58());
+    if (signer instanceof LocalSolanaSigner) {
+        if (partial)
+            signer.partialSignTransaction(tx);
+        else
+            signer.signTransaction(tx);
+    }
+    else if (hasBytesSigner(signer)) {
+        const bytes = tx.serialize({ requireAllSignatures: false, verifySignatures: false });
+        tx.addSignature(pubkey, Buffer.from(signer.signTransactionBytes(bytes)));
+    }
+    else {
+        throw new PerpError("NO_SIGNER_AVAILABLE", "This Solana signer cannot sign transactions", {
+            remediation: "Use an OWS vault wallet or a local key for on-chain Pacifica actions",
+        });
+    }
+    if (!tx.verifySignatures(!partial)) {
+        throw new PerpError("SIGNATURE_FAILED", `Solana transaction signature from ${pubkey.toBase58()} did not verify — nothing was sent`, {
+            remediation: "Check the wallet; the transaction was not submitted",
+        });
+    }
+}

package/dist/pacifica/types/account.d.ts

@@ -14,19 +14,43 @@ export interface AccountInfo {
     orders_count: number;
     stop_orders_count: number;
 }
-export interface AccountSettings {
+/**
+ * One `margin_settings` entry of GET /account/settings (docs.pacifica.fi
+ * api-documentation/api/rest-api/account/get-account-settings): `isolated` = "If the account is set
+ * to isolated margining for this symbol", `leverage` = "Current leverage set by the user (default to max)".
+ */
+export interface AccountMarginSetting {
     symbol: string;
-    margin_mode: "cross" | "isolated";
+    isolated: boolean;
     leverage: number;
+    created_at: number;
+    updated_at: number;
+}
+/**
+ * GET /account/settings `data`. Only markets changed from their defaults are listed — docs: "Upon
+ * account creation, all markets have margin settings default to cross margin and leverage default
+ * to max. When querying this endpoint, all markets with default margin and leverage settings on
+ * this account will return blank."
+ */
+export interface AccountSettings {
+    auto_lend_disabled: boolean | null;
+    margin_settings: AccountMarginSetting[];
+    spot_settings?: Array<{
+        symbol: string;
+        unified_margin_excluded: boolean;
+    }>;
 }
+/**
+ * POST /account/subaccount/transfer. Docs (rest-api/subaccounts/subaccount-fund-transfer): the
+ * sender is the signing `account` ("Sender account address"); the signed payload is only
+ * `to_account` ("Recipient wallet address") and `amount` ("Transfer amount (in USDC)").
+ */
 export interface TransferFundsParams {
-    from_account: string;
     to_account: string;
     amount: string;
 }
 export interface WithdrawParams {
     amount: string;
-    dest_address: string;
 }
 export interface UpdateLeverageParams {
     symbol: string;

package/dist/pacifica/types/lake.d.ts

@@ -1,12 +1,27 @@
+/**
+ * Vault ("lake") request payloads — docs.pacifica.fi api-documentation/api/rest-api/vaults.
+ * Fields the docs mark optional are `T | null` here (null = not sent).
+ */
+/** POST /lake/create ("create_lake"): every payload field is optional per the docs. */
 export interface CreateLakeParams {
-    symbol: string;
-    amount: string;
+    /** "Manager address. Omit to create a fresh vault with no manager." */
+    manager: string | null;
+    /** "Display name for the vault" */
+    nickname: string | null;
+    /** "Seed deposit from the creator in the same request" (decimal string) */
+    initial_deposit: string | null;
 }
+/** POST /lake/deposit ("deposit_to_lake"). */
 export interface LakeDepositParams {
-    lake_id: string;
+    /** "Vault address" */
+    lake: string;
+    /** "Deposit amount in USDC" */
     amount: string;
 }
+/** POST /lake/withdraw ("withdraw_from_lake"). */
 export interface LakeWithdrawParams {
-    lake_id: string;
-    amount: string;
+    /** "Vault address" */
+    lake: string;
+    /** "Number of shares to redeem" */
+    shares: string;
 }

package/dist/pacifica/types/lake.js

@@ -1 +1,5 @@
+/**
+ * Vault ("lake") request payloads — docs.pacifica.fi api-documentation/api/rest-api/vaults.
+ * Fields the docs mark optional are `T | null` here (null = not sent).
+ */
 export {};

package/dist/pacifica/types/market.d.ts

@@ -9,6 +9,11 @@ export interface MarketInfo {
     volume_24h: string;
     mark_price: string;
     index_price: string;
+    /** "perpetual" | "spot" (live /info rows). */
+    instrument_type: string;
+    base_asset: string;
+    /** USD notional minimum. */
+    min_order_size: string;
 }
 export interface PriceInfo {
     symbol: string;

package/dist/pacifica/types/order.d.ts

@@ -26,6 +26,8 @@ export interface StopOrderParams {
         amount: string;
         limit_price?: string;
         client_order_id?: string;
+        /** Trigger price source: "mark_price" (default) | "last_trade_price" | "mid_price". */
+        trigger_price_type?: string;
     };
 }
 export interface EditOrderParams {
@@ -52,9 +54,10 @@ export interface TWAPParams {
     duration_in_seconds: number;
     client_order_id?: string;
 }
+/** POST /orders/twap/cancel — pacifica-fi/python-sdk rest/cancel_twap_order.py signs {symbol, order_id}. */
 export interface CancelTWAPParams {
     symbol: string;
-    twap_order_id: number;
+    order_id: number;
 }
 export interface TPSLParams {
     symbol: string;

package/dist/pacifica/types/position.d.ts

@@ -7,7 +7,15 @@ export interface Position {
     mark_price: string;
     liquidation_price: string;
     unrealized_pnl: string;
+    /** Backing margin. The live spec names this `margin`; older payloads used
+     *  `margin_used`. Both are read defensively. */
+    margin?: string;
     margin_used: string;
-    leverage: number;
+    /** Optional — the live /positions spec omits leverage; treat as possibly absent. */
+    leverage?: number;
+    /** True when the position is isolated-margin. Gates `margin`, which the spec
+     *  documents as "only shown when isolated" — so leverage cannot be derived
+     *  from margin on a cross position. */
+    isolated?: boolean;
     created_at: number;
 }

package/dist/plan-executor.d.ts

@@ -17,7 +17,12 @@ export interface ExecutionPlan {
 export interface StepResult {
     stepId: string;
     action: PlanAction;
-    status: "success" | "failed" | "skipped" | "rolled_back" | "dry_run";
+    /**
+     * pending = an order step whose outcome is unknown (ORDER_PENDING): the plan stopped, the
+     * symbol is quarantined, the step is never rolled back. rollback_failed = a completed step
+     * whose reversal was rejected / unconfirmed / partial (symbol quarantined).
+     */
+    status: "success" | "failed" | "skipped" | "rolled_back" | "cancelled" | "rollback_failed" | "pending" | "dry_run";
     result?: unknown;
     error?: {
         code: string;
@@ -27,8 +32,11 @@ export interface StepResult {
 }
 export interface PlanResult {
     planId: string;
-    status: "completed" | "partial" | "failed" | "dry_run";
+    /** pending = an order step's outcome is unknown; quarantined = a rollback left exposure (see `quarantined`). */
+    status: "completed" | "partial" | "failed" | "pending" | "quarantined" | "dry_run";
     steps: StepResult[];
+    /** Symbols quarantined by this run (unknown order outcome or failed rollback). */
+    quarantined: string[];
     totalDurationMs: number;
     timestamp: string;
 }
@@ -39,9 +47,6 @@ export declare function validatePlan(plan: unknown): {
     valid: boolean;
     errors: string[];
 };
-/**
- * Execute a plan step by step.
- */
 export declare function executePlan(adapter: ExchangeAdapter, plan: ExecutionPlan, opts?: {
     dryRun?: boolean;
     log?: (msg: string) => void;