perp-cli 0.12.17 → 0.14.1

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;