perp-cli 0.3.3

package/dist/pacifica/client.d.ts

@@ -0,0 +1,111 @@
+import { type Network } from "./constants.js";
+import type { MarketInfo, PriceInfo, Orderbook, Trade, Kline, KlineInterval, AggLevel, AccountInfo, AccountSettings, Position, OrderInfo, MarketOrderParams, LimitOrderParams, StopOrderParams, EditOrderParams, CancelOrderParams, CancelAllOrdersParams, TWAPParams, CancelTWAPParams, TPSLParams, UpdateLeverageParams, WithdrawParams, TransferFundsParams, BatchAction, CreateLakeParams, LakeDepositParams, LakeWithdrawParams } from "./types/index.js";
+type SignMessageFn = (message: Uint8Array) => Promise<Uint8Array>;
+export interface PacificaClientConfig {
+    network?: Network;
+    baseUrl?: string;
+    apiKey?: string;
+    builderCode?: string;
+}
+export declare class PacificaClient {
+    private baseUrl;
+    private apiKey?;
+    private builderCode;
+    constructor(config?: PacificaClientConfig);
+    private headers;
+    private get;
+    private post;
+    private addBuilderCode;
+    getInfo(): Promise<MarketInfo[]>;
+    getPrices(): Promise<PriceInfo[]>;
+    getBook(symbol: string, aggLevel?: AggLevel): Promise<Orderbook>;
+    getTrades(symbol: string): Promise<Trade[]>;
+    getKline(symbol: string, interval: KlineInterval, startTime: number, endTime?: number): Promise<Kline[]>;
+    getFundingHistory(symbol: string, opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    getAccount(account: string): Promise<AccountInfo>;
+    getAccountSettings(account: string): Promise<AccountSettings[]>;
+    getPositions(account: string): Promise<Position[]>;
+    getOrders(account: string): Promise<OrderInfo[]>;
+    getOrderHistory(account: string, opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    getTradeHistory(account: string, opts?: {
+        symbol?: string;
+        start_time?: number;
+        end_time?: number;
+        limit?: number;
+        cursor?: number;
+    }): Promise<unknown>;
+    getFundingAccountHistory(account: string, opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    getPortfolio(account: string, opts?: {
+        time_range?: string;
+        start_time?: number;
+        end_time?: number;
+        limit?: number;
+    }): Promise<unknown>;
+    getBalanceHistory(account: string, opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    getOrderHistoryById(orderId: number): Promise<unknown>;
+    getTWAPOrders(account: string): Promise<unknown[]>;
+    createMarketOrder(params: MarketOrderParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    createLimitOrder(params: LimitOrderParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    createStopOrder(params: StopOrderParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    editOrder(params: EditOrderParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    cancelOrder(params: CancelOrderParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    cancelAllOrders(params: CancelAllOrdersParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    cancelStopOrder(params: {
+        symbol: string;
+        order_id: number;
+    }, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    createTWAP(params: TWAPParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    cancelTWAP(params: CancelTWAPParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    setTPSL(params: TPSLParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    updateLeverage(params: UpdateLeverageParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    updateMarginMode(params: {
+        symbol: string;
+        is_isolated: boolean;
+    }, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    withdraw(params: WithdrawParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    createSubaccount(subaccountName: string, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    listSubaccounts(account: string, signMessage: SignMessageFn): Promise<unknown>;
+    transferFunds(params: TransferFundsParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    bindAgentWallet(agentWallet: string, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    listAgentWallets(account: string, signMessage: SignMessageFn): Promise<unknown>;
+    revokeAgentWallet(agentWallet: string, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    revokeAllAgentWallets(account: string, signMessage: SignMessageFn): Promise<unknown>;
+    createApiKey(name: string, maxFeeRate: string, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    listApiKeys(account: string, signMessage: SignMessageFn): Promise<unknown>;
+    revokeApiKey(apiKey: string, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    createLake(params: CreateLakeParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    depositToLake(params: LakeDepositParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    withdrawFromLake(params: LakeWithdrawParams, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    approveBuilderCode(params: {
+        builder_code: string;
+        max_fee_rate: string;
+    }, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    revokeBuilderCode(params: {
+        builder_code: string;
+    }, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    getBuilderApprovals(account: string): Promise<unknown>;
+    updateBuilderFeeRate(params: {
+        builder_code: string;
+        fee_rate: string;
+    }, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    getBuilderOverview(account: string): Promise<unknown>;
+    getBuilderTrades(builderCode: string): Promise<unknown>;
+    getBuilderLeaderboard(builderCode: string): Promise<unknown>;
+    claimReferralCode(params: {
+        code: string;
+    }, account: string, signMessage: SignMessageFn): Promise<unknown>;
+    batchOrders(actions: BatchAction[]): Promise<unknown>;
+}
+export {};

package/dist/pacifica/client.js

@@ -0,0 +1,310 @@
+import { BUILDER_CODE, getNetworkConfig } from "./constants.js";
+import { buildSignedRequest } from "./signing.js";
+export class PacificaClient {
+    baseUrl;
+    apiKey;
+    builderCode;
+    constructor(config = {}) {
+        this.baseUrl =
+            config.baseUrl || getNetworkConfig(config.network).restUrl;
+        this.apiKey = config.apiKey;
+        this.builderCode = config.builderCode || BUILDER_CODE;
+    }
+    headers() {
+        const h = { "Content-Type": "application/json" };
+        if (this.apiKey)
+            h["PF-API-KEY"] = this.apiKey;
+        return h;
+    }
+    async get(path, params) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (params) {
+            Object.entries(params).forEach(([k, v]) => {
+                if (v !== undefined && v !== null)
+                    url.searchParams.set(k, v);
+            });
+        }
+        const res = await fetch(url.toString(), { headers: this.headers() });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`GET ${path} failed (${res.status}): ${text}`);
+        }
+        const json = await res.json();
+        // Unwrap Pacifica API response envelope: {success, data, error, code}
+        if (json && typeof json === "object" && "data" in json && "success" in json) {
+            return json.data;
+        }
+        return json;
+    }
+    async post(path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`POST ${path} failed (${res.status}): ${text}`);
+        }
+        return res.json();
+    }
+    addBuilderCode(payload) {
+        if (this.builderCode) {
+            return { ...payload, builder_code: this.builderCode };
+        }
+        return payload;
+    }
+    // ==================== PUBLIC ENDPOINTS ====================
+    async getInfo() {
+        return this.get("/info");
+    }
+    async getPrices() {
+        return this.get("/info/prices");
+    }
+    async getBook(symbol, aggLevel) {
+        const params = { symbol };
+        if (aggLevel)
+            params.agg_level = String(aggLevel);
+        return this.get("/book", params);
+    }
+    async getTrades(symbol) {
+        return this.get("/trades", { symbol });
+    }
+    async getKline(symbol, interval, startTime, endTime) {
+        const params = {
+            symbol,
+            interval,
+            start_time: String(startTime),
+        };
+        if (endTime)
+            params.end_time = String(endTime);
+        return this.get("/kline", params);
+    }
+    async getFundingHistory(symbol, opts) {
+        const params = { symbol };
+        if (opts?.limit)
+            params.limit = String(opts.limit);
+        if (opts?.cursor)
+            params.cursor = opts.cursor;
+        return this.get("/funding_rate/history", params);
+    }
+    // ==================== AUTHENTICATED GET ENDPOINTS ====================
+    async getAccount(account) {
+        return this.get("/account", { account });
+    }
+    async getAccountSettings(account) {
+        return this.get("/account/settings", { account });
+    }
+    async getPositions(account) {
+        return this.get("/positions", { account });
+    }
+    async getOrders(account) {
+        return this.get("/orders", { account });
+    }
+    async getOrderHistory(account, opts) {
+        const params = { account };
+        if (opts?.limit)
+            params.limit = String(opts.limit);
+        if (opts?.cursor)
+            params.cursor = opts.cursor;
+        return this.get("/orders/history", params);
+    }
+    async getTradeHistory(account, opts) {
+        const params = { account };
+        if (opts?.symbol)
+            params.symbol = opts.symbol;
+        if (opts?.start_time)
+            params.start_time = String(opts.start_time);
+        if (opts?.end_time)
+            params.end_time = String(opts.end_time);
+        if (opts?.limit)
+            params.limit = String(opts.limit);
+        if (opts?.cursor)
+            params.cursor = String(opts.cursor);
+        return this.get("/trades/history", params);
+    }
+    async getFundingAccountHistory(account, opts) {
+        const params = { account };
+        if (opts?.limit)
+            params.limit = String(opts.limit);
+        if (opts?.cursor)
+            params.cursor = opts.cursor;
+        return this.get("/funding/history", params);
+    }
+    async getPortfolio(account, opts) {
+        const params = { account };
+        if (opts?.time_range)
+            params.time_range = opts.time_range;
+        if (opts?.start_time)
+            params.start_time = String(opts.start_time);
+        if (opts?.end_time)
+            params.end_time = String(opts.end_time);
+        if (opts?.limit)
+            params.limit = String(opts.limit);
+        return this.get("/portfolio", params);
+    }
+    async getBalanceHistory(account, opts) {
+        const params = { account };
+        if (opts?.limit)
+            params.limit = String(opts.limit);
+        if (opts?.cursor)
+            params.cursor = opts.cursor;
+        return this.get("/account/balance/history", params);
+    }
+    async getOrderHistoryById(orderId) {
+        return this.get("/orders/history_by_id", { order_id: String(orderId) });
+    }
+    async getTWAPOrders(account) {
+        return this.get("/orders/twap", { account });
+    }
+    // ==================== AUTHENTICATED POST ENDPOINTS ====================
+    async createMarketOrder(params, account, signMessage) {
+        const payload = this.addBuilderCode({ ...params });
+        const body = await buildSignedRequest("create_market_order", payload, account, signMessage);
+        return this.post("/orders/create_market", body);
+    }
+    async createLimitOrder(params, account, signMessage) {
+        const payload = this.addBuilderCode({ ...params });
+        const body = await buildSignedRequest("create_order", payload, account, signMessage);
+        return this.post("/orders/create", body);
+    }
+    async createStopOrder(params, account, signMessage) {
+        const body = await buildSignedRequest("create_stop_order", params, account, signMessage);
+        return this.post("/orders/stop/create", body);
+    }
+    async editOrder(params, account, signMessage) {
+        const body = await buildSignedRequest("edit_order", params, account, signMessage);
+        return this.post("/orders/edit", body);
+    }
+    async cancelOrder(params, account, signMessage) {
+        const body = await buildSignedRequest("cancel_order", params, account, signMessage);
+        return this.post("/orders/cancel", body);
+    }
+    async cancelAllOrders(params, account, signMessage) {
+        const body = await buildSignedRequest("cancel_all_orders", params, account, signMessage);
+        return this.post("/orders/cancel_all", body);
+    }
+    async cancelStopOrder(params, account, signMessage) {
+        const body = await buildSignedRequest("cancel_stop_order", params, account, signMessage);
+        return this.post("/orders/stop/cancel", body);
+    }
+    async createTWAP(params, account, signMessage) {
+        const payload = this.addBuilderCode({ ...params });
+        const body = await buildSignedRequest("create_twap_order", payload, account, signMessage);
+        return this.post("/orders/twap/create", body);
+    }
+    async cancelTWAP(params, account, signMessage) {
+        const body = await buildSignedRequest("cancel_twap_order", params, account, signMessage);
+        return this.post("/orders/twap/cancel", body);
+    }
+    async setTPSL(params, account, signMessage) {
+        const body = await buildSignedRequest("set_position_tpsl", params, account, signMessage);
+        return this.post("/positions/tpsl", body);
+    }
+    async updateLeverage(params, account, signMessage) {
+        const body = await buildSignedRequest("update_leverage", params, account, signMessage);
+        return this.post("/account/leverage", body);
+    }
+    async updateMarginMode(params, account, signMessage) {
+        const body = await buildSignedRequest("update_margin_mode", params, account, signMessage);
+        return this.post("/account/margin", body);
+    }
+    async withdraw(params, account, signMessage) {
+        const body = await buildSignedRequest("withdraw", params, account, signMessage);
+        return this.post("/account/withdraw", body);
+    }
+    // ==================== SUBACCOUNT ====================
+    async createSubaccount(subaccountName, account, signMessage) {
+        // Step 1: Initiate
+        const initiateBody = await buildSignedRequest("subaccount_initiate", { subaccount_name: subaccountName }, account, signMessage);
+        await this.post("/account/subaccount/create", initiateBody);
+        // Step 2: Confirm
+        const confirmBody = await buildSignedRequest("subaccount_confirm", { subaccount_name: subaccountName }, account, signMessage);
+        return this.post("/account/subaccount/create", confirmBody);
+    }
+    async listSubaccounts(account, signMessage) {
+        const body = await buildSignedRequest("list_subaccounts", {}, account, signMessage);
+        return this.post("/account/subaccount/list", body);
+    }
+    async transferFunds(params, account, signMessage) {
+        const body = await buildSignedRequest("transfer_funds", params, account, signMessage);
+        return this.post("/account/subaccount/transfer", body);
+    }
+    // ==================== AGENT WALLET ====================
+    async bindAgentWallet(agentWallet, account, signMessage) {
+        const body = await buildSignedRequest("bind_agent_wallet", { agent_wallet: agentWallet }, account, signMessage);
+        return this.post("/agent/bind", body);
+    }
+    async listAgentWallets(account, signMessage) {
+        const body = await buildSignedRequest("list_agent_wallets", {}, account, signMessage);
+        return this.post("/agent/list", body);
+    }
+    async revokeAgentWallet(agentWallet, account, signMessage) {
+        const body = await buildSignedRequest("revoke_agent_wallet", { agent_wallet: agentWallet }, account, signMessage);
+        return this.post("/agent/revoke", body);
+    }
+    async revokeAllAgentWallets(account, signMessage) {
+        const body = await buildSignedRequest("revoke_all_agent_wallets", {}, account, signMessage);
+        return this.post("/agent/revoke_all", body);
+    }
+    // ==================== API KEYS ====================
+    async createApiKey(name, maxFeeRate, account, signMessage) {
+        const body = await buildSignedRequest("create_api_key", { name, max_fee_rate: maxFeeRate }, account, signMessage);
+        return this.post("/account/api_keys/create", body);
+    }
+    async listApiKeys(account, signMessage) {
+        const body = await buildSignedRequest("list_api_keys", {}, account, signMessage);
+        return this.post("/account/api_keys", body);
+    }
+    async revokeApiKey(apiKey, account, signMessage) {
+        const body = await buildSignedRequest("revoke_api_key", { api_key: apiKey }, account, signMessage);
+        return this.post("/account/api_keys/revoke", body);
+    }
+    // ==================== LAKE ====================
+    async createLake(params, account, signMessage) {
+        const body = await buildSignedRequest("create_lake", params, account, signMessage);
+        return this.post("/lake/create", body);
+    }
+    async depositToLake(params, account, signMessage) {
+        const body = await buildSignedRequest("deposit_to_lake", params, account, signMessage);
+        return this.post("/lake/deposit", body);
+    }
+    async withdrawFromLake(params, account, signMessage) {
+        const body = await buildSignedRequest("withdraw_from_lake", params, account, signMessage);
+        return this.post("/lake/withdraw", body);
+    }
+    // ==================== BUILDER CODE ====================
+    async approveBuilderCode(params, account, signMessage) {
+        const body = await buildSignedRequest("approve_builder_code", params, account, signMessage);
+        return this.post("/account/builder_codes/approve", body);
+    }
+    async revokeBuilderCode(params, account, signMessage) {
+        const body = await buildSignedRequest("revoke_builder_code", params, account, signMessage);
+        return this.post("/account/builder_codes/revoke", body);
+    }
+    async getBuilderApprovals(account) {
+        return this.get("/account/builder_codes/approvals", { account });
+    }
+    async updateBuilderFeeRate(params, account, signMessage) {
+        const body = await buildSignedRequest("update_builder_code_fee_rate", params, account, signMessage);
+        return this.post("/builder/update_fee_rate", body);
+    }
+    async getBuilderOverview(account) {
+        return this.get("/builder/overview", { account });
+    }
+    async getBuilderTrades(builderCode) {
+        return this.get("/builder/trades", { builder_code: builderCode });
+    }
+    async getBuilderLeaderboard(builderCode) {
+        return this.get("/leaderboard/builder_code", { builder_code: builderCode });
+    }
+    // ==================== REFERRAL ====================
+    async claimReferralCode(params, account, signMessage) {
+        const body = await buildSignedRequest("claim_referral_code", params, account, signMessage);
+        return this.post("/referral/user/code/claim", body);
+    }
+    // ==================== BATCH ====================
+    async batchOrders(actions) {
+        return this.post("/orders/batch", { actions });
+    }
+}

package/dist/pacifica/constants.d.ts

@@ -0,0 +1,27 @@
+export declare const MAINNET_REST = "https://api.pacifica.fi/api/v1";
+export declare const TESTNET_REST = "https://test-api.pacifica.fi/api/v1";
+export declare const MAINNET_WS = "wss://ws.pacifica.fi/ws";
+export declare const TESTNET_WS = "wss://test-ws.pacifica.fi/ws";
+export declare const MAINNET_PROGRAM_ID = "PCFA5iYgmqK6MqPhWNKg7Yv7auX7VZ4Cx7T1eJyrAMH";
+export declare const MAINNET_CENTRAL_STATE = "9Gdmhq4Gv1LnNMp7aiS1HSVd7pNnXNMsbuXALCQRmGjY";
+export declare const MAINNET_PACIFICA_VAULT = "72R843XwZxqWhsJceARQQTTbYtWy6Zw9et2YV4FpRHTa";
+export declare const MAINNET_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export declare const TESTNET_PROGRAM_ID = "peRPsYCcB1J9jvrs29jiGdjkytxs8uHLmSPLKKP9ptm";
+export declare const TESTNET_CENTRAL_STATE = "2zPRq1Qvdq5A4Ld6WsH7usgCge4ApZRYfhhf5VAjfXxv";
+export declare const TESTNET_PACIFICA_VAULT = "5SDFdHZGTZbyRYu54CgmRkCGnPHC5pYaN27p7XGLqnBs";
+export declare const TESTNET_USDC_MINT = "USDPqRbLidFGufty2s3oizmDEKdqx7ePTqzDMbf5ZKM";
+export declare const SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+export declare const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export declare const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+export declare const DEFAULT_EXPIRY_WINDOW = 5000;
+export declare const USDC_DECIMALS = 6;
+export declare const BUILDER_CODE: string;
+export type Network = "mainnet" | "testnet";
+export declare function getNetworkConfig(network?: Network): {
+    restUrl: string;
+    wsUrl: string;
+    programId: string;
+    centralState: string;
+    pacificaVault: string;
+    usdcMint: string;
+};

package/dist/pacifica/constants.js

@@ -0,0 +1,47 @@
+// Pacifica Protocol Constants
+// REST API URLs
+export const MAINNET_REST = "https://api.pacifica.fi/api/v1";
+export const TESTNET_REST = "https://test-api.pacifica.fi/api/v1";
+// WebSocket URLs
+export const MAINNET_WS = "wss://ws.pacifica.fi/ws";
+export const TESTNET_WS = "wss://test-ws.pacifica.fi/ws";
+// Mainnet Program IDs
+export const MAINNET_PROGRAM_ID = "PCFA5iYgmqK6MqPhWNKg7Yv7auX7VZ4Cx7T1eJyrAMH";
+export const MAINNET_CENTRAL_STATE = "9Gdmhq4Gv1LnNMp7aiS1HSVd7pNnXNMsbuXALCQRmGjY";
+export const MAINNET_PACIFICA_VAULT = "72R843XwZxqWhsJceARQQTTbYtWy6Zw9et2YV4FpRHTa";
+export const MAINNET_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+// Testnet (Devnet) Program IDs
+export const TESTNET_PROGRAM_ID = "peRPsYCcB1J9jvrs29jiGdjkytxs8uHLmSPLKKP9ptm";
+export const TESTNET_CENTRAL_STATE = "2zPRq1Qvdq5A4Ld6WsH7usgCge4ApZRYfhhf5VAjfXxv";
+export const TESTNET_PACIFICA_VAULT = "5SDFdHZGTZbyRYu54CgmRkCGnPHC5pYaN27p7XGLqnBs";
+export const TESTNET_USDC_MINT = "USDPqRbLidFGufty2s3oizmDEKdqx7ePTqzDMbf5ZKM";
+// Standard Solana Program IDs
+export const SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+export const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+// Signing defaults
+export const DEFAULT_EXPIRY_WINDOW = 5000; // 5 seconds
+// USDC decimals
+export const USDC_DECIMALS = 6;
+// Builder code — 0% fee, used for Pacifica hackathon tracking
+export const BUILDER_CODE = process.env.PACIFICA_BUILDER_CODE || "PERPCLI";
+export function getNetworkConfig(network = "mainnet") {
+    if (network === "testnet") {
+        return {
+            restUrl: TESTNET_REST,
+            wsUrl: TESTNET_WS,
+            programId: TESTNET_PROGRAM_ID,
+            centralState: TESTNET_CENTRAL_STATE,
+            pacificaVault: TESTNET_PACIFICA_VAULT,
+            usdcMint: TESTNET_USDC_MINT,
+        };
+    }
+    return {
+        restUrl: MAINNET_REST,
+        wsUrl: MAINNET_WS,
+        programId: MAINNET_PROGRAM_ID,
+        centralState: MAINNET_CENTRAL_STATE,
+        pacificaVault: MAINNET_PACIFICA_VAULT,
+        usdcMint: MAINNET_USDC_MINT,
+    };
+}

package/dist/pacifica/deposit.d.ts

@@ -0,0 +1,14 @@
+import { Connection, PublicKey, TransactionInstruction, Transaction, type TransactionSignature } from "@solana/web3.js";
+import { type Network } from "./constants.js";
+/**
+ * Build a Pacifica deposit instruction.
+ *
+ * @param userPubkey - User's wallet public key
+ * @param amount - Amount in USDC (e.g., 100 for $100)
+ * @param network - mainnet or testnet
+ */
+export declare function buildDepositInstruction(userPubkey: PublicKey, amount: number, network?: Network): Promise<TransactionInstruction>;
+/**
+ * Build and send a deposit transaction.
+ */
+export declare function deposit(connection: Connection, userPubkey: PublicKey, amount: number, signTransaction: (tx: Transaction) => Promise<Transaction>, network?: Network): Promise<TransactionSignature>;

package/dist/pacifica/deposit.js

@@ -0,0 +1,78 @@
+import { PublicKey, TransactionInstruction, Transaction, } from "@solana/web3.js";
+import { getNetworkConfig, USDC_DECIMALS } from "./constants.js";
+const TOKEN_PROGRAM = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const ASSOCIATED_TOKEN_PROGRAM = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+const SYSTEM_PROGRAM = new PublicKey("11111111111111111111111111111111");
+/**
+ * Build the Anchor "global:deposit" discriminator.
+ * sha256("global:deposit")[:8]
+ */
+async function getDepositDiscriminator() {
+    const data = new TextEncoder().encode("global:deposit");
+    const hash = await crypto.subtle.digest("SHA-256", data);
+    return new Uint8Array(hash).slice(0, 8);
+}
+/**
+ * Derive the Associated Token Account for a user.
+ */
+function getATA(owner, mint) {
+    const [ata] = PublicKey.findProgramAddressSync([owner.toBytes(), TOKEN_PROGRAM.toBytes(), mint.toBytes()], ASSOCIATED_TOKEN_PROGRAM);
+    return ata;
+}
+/**
+ * Derive the event authority PDA.
+ */
+function getEventAuthority(programId) {
+    const [pda] = PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], programId);
+    return pda;
+}
+/**
+ * Build a Pacifica deposit instruction.
+ *
+ * @param userPubkey - User's wallet public key
+ * @param amount - Amount in USDC (e.g., 100 for $100)
+ * @param network - mainnet or testnet
+ */
+export async function buildDepositInstruction(userPubkey, amount, network = "mainnet") {
+    const config = getNetworkConfig(network);
+    const programId = new PublicKey(config.programId);
+    const centralState = new PublicKey(config.centralState);
+    const pacificaVault = new PublicKey(config.pacificaVault);
+    const usdcMint = new PublicKey(config.usdcMint);
+    const userATA = getATA(userPubkey, usdcMint);
+    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 amountBytes = new Uint8Array(8);
+    const view = new DataView(amountBytes.buffer);
+    view.setBigUint64(0, amountLamports, true); // little-endian
+    const data = new Uint8Array(discriminator.length + amountBytes.length);
+    data.set(discriminator, 0);
+    data.set(amountBytes, discriminator.length);
+    // Account metas (ORDER IS CRITICAL)
+    const keys = [
+        { pubkey: userPubkey, isSigner: true, isWritable: true },
+        { pubkey: userATA, isSigner: false, isWritable: true },
+        { pubkey: centralState, isSigner: false, isWritable: true },
+        { pubkey: pacificaVault, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: usdcMint, isSigner: false, isWritable: false },
+        { pubkey: SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+        { pubkey: eventAuthority, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false },
+    ];
+    return new TransactionInstruction({ keys, programId, data: Buffer.from(data) });
+}
+/**
+ * Build and send a deposit transaction.
+ */
+export async function deposit(connection, userPubkey, amount, signTransaction, network = "mainnet") {
+    const instruction = await buildDepositInstruction(userPubkey, amount, network);
+    const tx = new Transaction().add(instruction);
+    tx.feePayer = userPubkey;
+    tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+    const signed = await signTransaction(tx);
+    return connection.sendRawTransaction(signed.serialize());
+}

package/dist/pacifica/index.d.ts

@@ -0,0 +1,6 @@
+export { PacificaClient, type PacificaClientConfig } from "./client.js";
+export { PacificaWSClient, type PacificaWSConfig } from "./ws-client.js";
+export { sortJsonKeys, prepareMessage, createHeader, signWithWallet, buildSignedRequest, buildAgentSignedRequest, } from "./signing.js";
+export { buildDepositInstruction, deposit } from "./deposit.js";
+export * from "./constants.js";
+export * from "./types/index.js";

package/dist/pacifica/index.js

@@ -0,0 +1,11 @@
+// Core
+export { PacificaClient } from "./client.js";
+export { PacificaWSClient } from "./ws-client.js";
+// Signing
+export { sortJsonKeys, prepareMessage, createHeader, signWithWallet, buildSignedRequest, buildAgentSignedRequest, } from "./signing.js";
+// Deposit
+export { buildDepositInstruction, deposit } from "./deposit.js";
+// Constants
+export * from "./constants.js";
+// Types
+export * from "./types/index.js";

package/dist/pacifica/signing.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Recursively sort all object keys alphabetically.
+ * Exact port of Python SDK's sort_json_keys().
+ */
+export declare function sortJsonKeys(value: unknown): unknown;
+/**
+ * Prepare the message string for signing.
+ * Exact port of Python SDK's prepare_message().
+ *
+ * Header must contain: type, timestamp, expiry_window
+ * Returns compact JSON with sorted keys and payload nested under "data".
+ */
+export declare function prepareMessage(header: {
+    type: string;
+    timestamp: number;
+    expiry_window: number;
+}, payload: object): string;
+/**
+ * Create a signing header with current timestamp.
+ */
+export declare function createHeader(type: string, expiryWindow?: number): {
+    type: string;
+    timestamp: number;
+    expiry_window: number;
+};
+/**
+ * Sign a message using a wallet adapter's signMessage function.
+ * Used in browser context with Phantom/Solflare/etc.
+ *
+ * @param header - Operation header (type, timestamp, expiry_window)
+ * @param payload - Operation payload
+ * @param signMessage - Wallet adapter's signMessage function
+ * @returns [message, base58EncodedSignature]
+ */
+export declare function signWithWallet(header: {
+    type: string;
+    timestamp: number;
+    expiry_window: number;
+}, payload: object, signMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<[string, string]>;
+/**
+ * Build a signed request body for REST API POST.
+ * Flattens payload to top level and adds account, signature, timestamp, expiry_window.
+ */
+export declare function buildSignedRequest(operationType: string, payload: object, account: string, signMessage: (message: Uint8Array) => Promise<Uint8Array>, expiryWindow?: number): Promise<Record<string, unknown>>;
+/**
+ * Build a signed request with agent wallet.
+ * Used when an agent wallet is trading on behalf of a main account.
+ */
+export declare function buildAgentSignedRequest(operationType: string, payload: object, mainAccount: string, agentWallet: string, signMessage: (message: Uint8Array) => Promise<Uint8Array>, expiryWindow?: number): Promise<Record<string, unknown>>;