@parqxchange/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Parquet contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# Parquet SDK
+
+TypeScript client for the [Parquet](https://parquet.exchange) perpetuals protocol on Solana — Anchor program clients, account decoders, PDA helpers, dual-feed oracle resolution, and a typed indexer client.
+
+Instruction builders return `TransactionInstruction[]` only. **You build, sign, and send** — the SDK never holds keys or sends transactions for you.
+
+## Installation
+
+```bash
+npm install @parqxchange/sdk
+# or: yarn add @parqxchange/sdk / pnpm add @parqxchange/sdk
+```
+
+Peer-pinned against `@solana/web3.js` and `@coral-xyz/anchor` — pin both in your lockfile. Node `>=18` (uses `node:crypto` for discriminators and `AbortSignal.timeout` in the indexer client).
+
+## Getting Started
+
+```typescript
+import { Connection, PublicKey } from "@solana/web3.js";
+import {
+  PROGRAM_IDS_V4,
+  IndexerClient,
+  getMarketOracleFeeds,
+  openPosition,
+  PerpClient,
+} from "@parqxchange/sdk";
+
+const connection = new Connection("https://api.mainnet-beta.solana.com");
+
+// 1. Read market stats from the indexer.
+const indexer = new IndexerClient("https://api.parquet.exchange");
+const stats = await indexer.getStats("aapl-usdc");
+console.log(stats.markPrice, stats.openInterest);
+
+// 2. Resolve the dual-feed oracle accounts for a market.
+const oracleProgramId = new PublicKey(PROGRAM_IDS_V4.ORACLE_ADAPTER);
+const marketId = new TextEncoder().encode("aapl-usdc"); // market id = ascii symbol
+const { primaryFeed, secondaryFeed } = await getMarketOracleFeeds(
+  connection,
+  marketId,
+  oracleProgramId,
+);
+
+// 3. Build an openPosition instruction (you sign + send it).
+const perpClient = new PerpClient(program); // your Anchor Program for the perp-engine
+const ixs = await openPosition(
+  {
+    perpClient,
+    perpEngineId: new PublicKey(PROGRAM_IDS_V4.PERP_ENGINE),
+    poolProgramId: new PublicKey(PROGRAM_IDS_V4.POOL_PROGRAM),
+    oracleProgramId,
+    marketId,
+    primaryFeedAccount: primaryFeed,
+    secondaryFeedAccount: secondaryFeed,
+  },
+  { signer: wallet.publicKey, signerUsdc: usdcAta },
+  {
+    side: { long: {} },
+    sizeUsdc: 1_000_000_000n,      // 1,000 USDC notional (6 decimals)
+    walletCollateral: 100_000_000n, // 100 USDC margin
+    fromQueueAmount: 0n,
+    acceptablePrice: 0n,            // ⚠️ 0 = no slippage guard — set a real limit in prod
+    minOutputUsdc: 0n,
+    positionNonce: 0n,
+    referralCode: Array(32).fill(0),
+  },
+);
+// → add ixs to a transaction, sign with `wallet`, and send.
+```
+
+## Entry points
+
+| Import | Use |
+|--------|-----|
+| `@parqxchange/sdk` | Full surface — program clients, decoders, events, indexer, PDA + oracle helpers. |
+| `@parqxchange/sdk/minimal` | Perp trading actions + `getMarketOracleFeeds` only (smaller dependency graph). |
+| `@parqxchange/sdk/node` | `loadTradingKeypair` and other Node/`fs` helpers. **Never import from browser bundles.** |
+
+## API surface
+
+- **Program clients** — `PerpClient`, `PoolClient`, `OracleClient`, `PriceFeedClient`, `FeeDistributorClient`, `StakingClient`
+- **Actions** (build instructions) — `openPosition`, `closePosition`, `updateMargin`, `addLiquidity`, `removeLiquidity`, `crankFundingRate`
+- **Account resolvers** — `resolveOpenPositionAccounts`, `resolveClosePositionAccounts`, `resolveUpdateMarginAccounts`, `resolveLiquidityAccounts`
+- **Oracle** — `getMarketOracleFeeds`, `clearMarketOracleFeedsCache`
+- **Decoders** — `decodePosition`, `decodeMarketState`, `decodePoolState`, `decodeOrder`, … and `identifyAccountType`
+- **Events** — `ParquetEventEmitter`, `decodeAnchorEvent`
+- **Indexer** — `IndexerClient` (`getStats`)
+- **Auth** — `registerTradingKey` / `revokeTradingKey` (+ `buildRegisterTradingKeyIx` / `buildRevokeTradingKeyIx`)
+- **Constants / utils** — `PROGRAM_IDS_V4`, `withComputeBudget`, `buildVersionedTransaction`, PDA helpers
+
+## Decoding on-chain errors
+
+```typescript
+import { decodeError, isParquetError, ParquetError } from "@parqxchange/sdk";
+
+try {
+  await program.methods.openPosition(/* … */).rpc();
+} catch (err) {
+  // Pass the caught error OBJECT (Anchor error or RPC "custom program error: 0x…").
+  if (isParquetError(err, ParquetError.BelowMinCollateral)) {
+    // handle insufficient collateral
+  }
+  console.log(decodeError(err)); // → ParquetError code, or null
+}
+```
+
+`decodeError` takes the caught error object, never a raw number.
+
+## Production notes
+
+- **Set slippage guards.** `acceptablePrice` / `minOutputUsdc` of `0n` disable protection.
+- **Always pass both oracle feeds** from `getMarketOracleFeeds` (or a resolver) on open/close — never hardcode feed PDAs.
+- **Keep `loadTradingKeypair` server-side** (`/node` entry) so bundlers don't pull `fs` into the browser.
+- `decodeAnchorEvent` returns `null` for unknown/malformed/truncated payloads — validate at app boundaries.
+
+## Documentation
+
+Full reference, market ids, and the complete production checklist: **[docs.parquet.exchange/developer/sdk](https://docs.parquet.exchange/developer/sdk)**
+
+## License
+
+MIT

package/dist/accounts/marketOracle.d.ts

@@ -0,0 +1,21 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+export declare const MARKET_ORACLE_V2_LEN = 158;
+export type OracleType = "switchboard" | "pyth";
+export interface MarketOracleFeeds {
+    primaryFeed: PublicKey;
+    secondaryFeed: PublicKey;
+    primaryOracleType: OracleType;
+    secondaryOracleType: OracleType;
+    primaryMaxStalenessSecs: number;
+    secondaryMaxStalenessSecs: number;
+    maxConfidencePctBps: number;
+}
+export declare function clearMarketOracleFeedsCache(): void;
+export declare function getMarketOracleFeeds(connection: Connection, marketId: Uint8Array, oracleProgramId: PublicKey): Promise<MarketOracleFeeds>;
+export interface DecodedFeedPrice {
+    price: bigint;
+    confidence: bigint;
+    timestamp: number;
+}
+export declare function decodePythPriceUpdate(data: Buffer | Uint8Array): DecodedFeedPrice;
+export declare function decodeSwitchboardPriceFeed(data: Buffer | Uint8Array): DecodedFeedPrice;

package/dist/accounts/marketOracle.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKET_ORACLE_V2_LEN = void 0;
+exports.clearMarketOracleFeedsCache = clearMarketOracleFeedsCache;
+exports.getMarketOracleFeeds = getMarketOracleFeeds;
+exports.decodePythPriceUpdate = decodePythPriceUpdate;
+exports.decodeSwitchboardPriceFeed = decodeSwitchboardPriceFeed;
+const web3_js_1 = require("@solana/web3.js");
+const pda_1 = require("../utils/pda");
+const PRIMARY_FEED_OFFSET = 8 + 32 + 32 + 1 + 1;
+const SECONDARY_FEED_OFFSET = PRIMARY_FEED_OFFSET + 32 + 8 + 1;
+exports.MARKET_ORACLE_V2_LEN = 158;
+const PRIMARY_ORACLE_TYPE_OFFSET = 8 + 32 + 32 + 1;
+const PRIMARY_STALENESS_OFFSET = PRIMARY_ORACLE_TYPE_OFFSET + 1 + 32;
+const SECONDARY_ORACLE_TYPE_OFFSET = PRIMARY_STALENESS_OFFSET + 8;
+const SECONDARY_STALENESS_OFFSET = SECONDARY_ORACLE_TYPE_OFFSET + 1 + 32;
+const MAX_CONF_PCT_OFFSET = SECONDARY_STALENESS_OFFSET + 8;
+function oracleTypeAt(buf, offset) {
+    const v = buf.readUInt8(offset);
+    if (v === 0)
+        return "pyth";
+    if (v === 1)
+        return "switchboard";
+    throw new Error(`MarketOracle unknown oracle_type byte: ${v}`);
+}
+const cache = new Map();
+function clearMarketOracleFeedsCache() {
+    cache.clear();
+}
+async function getMarketOracleFeeds(connection, marketId, oracleProgramId) {
+    const [marketOracle] = (0, pda_1.marketOraclePDA)(marketId, oracleProgramId);
+    const cacheKey = `${connection.rpcEndpoint}::${marketOracle.toBase58()}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const info = await connection.getAccountInfo(marketOracle);
+    if (!info) {
+        throw new Error(`MarketOracle PDA not found: ${marketOracle.toBase58()}`);
+    }
+    if (info.data.length < exports.MARKET_ORACLE_V2_LEN) {
+        throw new Error(`MarketOracle ${marketOracle.toBase58()} data too short for V2 layout ` +
+            `(${info.data.length} < ${exports.MARKET_ORACLE_V2_LEN} bytes); ` +
+            "run migrate_market_oracle_v2 before dual-feed reads.");
+    }
+    const buf = Buffer.isBuffer(info.data) ? info.data : Buffer.from(info.data);
+    const feeds = {
+        primaryFeed: new web3_js_1.PublicKey(buf.subarray(PRIMARY_FEED_OFFSET, PRIMARY_FEED_OFFSET + 32)),
+        secondaryFeed: new web3_js_1.PublicKey(buf.subarray(SECONDARY_FEED_OFFSET, SECONDARY_FEED_OFFSET + 32)),
+        primaryOracleType: oracleTypeAt(buf, PRIMARY_ORACLE_TYPE_OFFSET),
+        secondaryOracleType: oracleTypeAt(buf, SECONDARY_ORACLE_TYPE_OFFSET),
+        primaryMaxStalenessSecs: Number(buf.readBigUInt64LE(PRIMARY_STALENESS_OFFSET)),
+        secondaryMaxStalenessSecs: Number(buf.readBigUInt64LE(SECONDARY_STALENESS_OFFSET)),
+        maxConfidencePctBps: buf.readUInt16LE(MAX_CONF_PCT_OFFSET),
+    };
+    cache.set(cacheKey, feeds);
+    return feeds;
+}
+function decodePythPriceUpdate(data) {
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    if (buf.length < 101) {
+        throw new Error(`Pyth PriceUpdateV2 too short: ${buf.length} < 101`);
+    }
+    const rawPrice = buf.readBigInt64LE(73);
+    const rawConf = buf.readBigUInt64LE(81);
+    const exponent = buf.readInt32LE(89);
+    const timestamp = Number(buf.readBigInt64LE(93));
+    if (exponent < -12 || exponent > 0) {
+        throw new Error(`Pyth exponent out of range: ${exponent}`);
+    }
+    if (rawPrice <= 0n) {
+        throw new Error(`Pyth raw_price not positive: ${rawPrice}`);
+    }
+    const diff = exponent - -9;
+    const price = applyExponent(rawPrice, diff);
+    const confidence = applyExponent(rawConf, diff);
+    return { price, confidence, timestamp };
+}
+function decodeSwitchboardPriceFeed(data) {
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    if (buf.length < 4365) {
+        throw new Error(`PriceFeed PDA too short: ${buf.length} < 4365`);
+    }
+    const low = buf.readBigUInt64LE(4337);
+    const high = buf.readBigInt64LE(4345);
+    const mantissa = (high << 64n) | low;
+    if (mantissa <= 0n) {
+        throw new Error(`PriceFeed mantissa not positive: ${mantissa}`);
+    }
+    const scale = buf.readUInt32LE(4353);
+    const timestamp = Number(buf.readBigInt64LE(4357));
+    const absMantissa = mantissa < 0n ? -mantissa : mantissa;
+    let price1e9;
+    if (scale >= 9) {
+        price1e9 = absMantissa / 10n ** BigInt(scale - 9);
+    }
+    else {
+        price1e9 = absMantissa * 10n ** BigInt(9 - scale);
+    }
+    if (price1e9 > U64_MAX) {
+        throw new Error(`PriceFeed price exceeds u64 range: ${price1e9}`);
+    }
+    return { price: price1e9, confidence: 0n, timestamp };
+}
+const U64_MAX = (1n << 64n) - 1n;
+function applyExponent(value, diff) {
+    if (diff >= 0) {
+        const result = value * 10n ** BigInt(diff);
+        if (result > U64_MAX) {
+            throw new Error(`Pyth apply_exponent overflow: ${result} > u64::MAX`);
+        }
+        return result;
+    }
+    return value / 10n ** BigInt(-diff);
+}

package/dist/accounts/resolve.d.ts

@@ -0,0 +1,75 @@
+import { PublicKey } from "@solana/web3.js";
+export interface ProgramIds {
+    perpEngineId: PublicKey;
+    poolProgramId: PublicKey;
+    oracleProgramId: PublicKey;
+    priceFeedProgramId: PublicKey;
+}
+export declare function resolveOpenPositionAccounts(marketId: Uint8Array, signer: PublicKey, nonce: bigint, usdcMint: PublicKey, primaryFeedAccount: PublicKey, secondaryFeedAccount: PublicKey, programs: ProgramIds, tradingKeyPda?: PublicKey | null, referralConfig?: PublicKey, referralCodeAccount?: PublicKey, traderReferral?: PublicKey): {
+    accounts: {
+        marketState: PublicKey;
+        position: PublicKey;
+        engineAuth: PublicKey;
+        marketOracle: PublicKey;
+        poolState: PublicKey;
+        vaultUsdc: PublicKey;
+        signerUsdc: PublicKey;
+        feeSettings: PublicKey;
+        tradingKey: PublicKey | null;
+        referralConfig: PublicKey;
+        referralCodeAccount: PublicKey;
+        traderReferral: PublicKey;
+        poolProgram: PublicKey;
+        oracleProgram: PublicKey;
+    };
+    primaryFeedAccount: PublicKey;
+    secondaryFeedAccount: PublicKey;
+};
+export declare function resolveClosePositionAccounts(marketId: Uint8Array, owner: PublicKey, signer: PublicKey, position: PublicKey, usdcMint: PublicKey, primaryFeedAccount: PublicKey, secondaryFeedAccount: PublicKey, programs: ProgramIds, tradingKeyPda?: PublicKey | null, referralConfig?: PublicKey, referralCodeAccount?: PublicKey, traderReferral?: PublicKey): {
+    accounts: {
+        marketState: PublicKey;
+        position: PublicKey;
+        engineAuth: PublicKey;
+        marketOracle: PublicKey;
+        poolState: PublicKey;
+        vaultUsdc: PublicKey;
+        vaultAuthority: PublicKey;
+        userUsdc: PublicKey;
+        owner: PublicKey;
+        signer: PublicKey;
+        tradingKey: PublicKey | null;
+        referralConfig: PublicKey;
+        referralCodeAccount: PublicKey;
+        traderReferral: PublicKey;
+        poolProgram: PublicKey;
+        oracleProgram: PublicKey;
+        lpMint: PublicKey;
+        insuranceFund: PublicKey;
+        insuranceVault: PublicKey;
+    };
+    primaryFeedAccount: PublicKey;
+    secondaryFeedAccount: PublicKey;
+};
+export declare function resolveUpdateMarginAccounts(marketId: Uint8Array, owner: PublicKey, signer: PublicKey, position: PublicKey, usdcMint: PublicKey, programs: ProgramIds, tradingKeyPda?: PublicKey | null): {
+    accounts: {
+        marketState: PublicKey;
+        position: PublicKey;
+        engineAuth: PublicKey;
+        poolState: PublicKey;
+        vaultUsdc: PublicKey;
+        vaultAuthority: PublicKey;
+        signerUsdc: PublicKey;
+        owner: PublicKey;
+        signer: PublicKey;
+        tradingKey: PublicKey | null;
+        poolProgram: PublicKey;
+    };
+};
+export declare function resolveLiquidityAccounts(marketId: Uint8Array, user: PublicKey, usdcMint: PublicKey, programs: ProgramIds): {
+    poolState: PublicKey;
+    usdcVault: PublicKey;
+    vaultAuthority: PublicKey;
+    lpMint: PublicKey;
+    userLp: PublicKey;
+    userUsdc: PublicKey;
+};

package/dist/accounts/resolve.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOpenPositionAccounts = resolveOpenPositionAccounts;
+exports.resolveClosePositionAccounts = resolveClosePositionAccounts;
+exports.resolveUpdateMarginAccounts = resolveUpdateMarginAccounts;
+exports.resolveLiquidityAccounts = resolveLiquidityAccounts;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const pda_1 = require("../utils/pda");
+const SYSTEM_PROGRAM = new web3_js_1.PublicKey("11111111111111111111111111111111");
+function resolveOpenPositionAccounts(marketId, signer, nonce, usdcMint, primaryFeedAccount, secondaryFeedAccount, programs, tradingKeyPda, referralConfig, referralCodeAccount, traderReferral) {
+    const [marketState] = (0, pda_1.marketStatePDA)(marketId, programs.perpEngineId);
+    const [position] = (0, pda_1.positionPDA)(signer, marketId, nonce, programs.perpEngineId);
+    const [engineAuth] = (0, pda_1.engineAuthPDA)(marketId, programs.perpEngineId);
+    const [marketOracle] = (0, pda_1.marketOraclePDA)(marketId, programs.oracleProgramId);
+    const [poolState] = (0, pda_1.poolStatePDA)(marketId, programs.poolProgramId);
+    const [vaultUsdc] = (0, pda_1.usdcVaultPDA)(marketId, programs.poolProgramId);
+    const signerUsdc = (0, spl_token_1.getAssociatedTokenAddressSync)(usdcMint, signer);
+    const [feeSettings] = (0, pda_1.feeSettingsPDA)(marketId, programs.poolProgramId);
+    return {
+        accounts: {
+            marketState,
+            position,
+            engineAuth,
+            marketOracle,
+            poolState,
+            vaultUsdc,
+            signerUsdc,
+            feeSettings,
+            tradingKey: tradingKeyPda ?? null,
+            referralConfig: referralConfig ?? SYSTEM_PROGRAM,
+            referralCodeAccount: referralCodeAccount ?? SYSTEM_PROGRAM,
+            traderReferral: traderReferral ?? SYSTEM_PROGRAM,
+            poolProgram: programs.poolProgramId,
+            oracleProgram: programs.oracleProgramId,
+        },
+        primaryFeedAccount,
+        secondaryFeedAccount,
+    };
+}
+function resolveClosePositionAccounts(marketId, owner, signer, position, usdcMint, primaryFeedAccount, secondaryFeedAccount, programs, tradingKeyPda, referralConfig, referralCodeAccount, traderReferral) {
+    const [marketState] = (0, pda_1.marketStatePDA)(marketId, programs.perpEngineId);
+    const [engineAuth] = (0, pda_1.engineAuthPDA)(marketId, programs.perpEngineId);
+    const [marketOracle] = (0, pda_1.marketOraclePDA)(marketId, programs.oracleProgramId);
+    const [poolState] = (0, pda_1.poolStatePDA)(marketId, programs.poolProgramId);
+    const [vaultUsdc] = (0, pda_1.usdcVaultPDA)(marketId, programs.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(marketId, programs.poolProgramId);
+    const [lpMint] = (0, pda_1.lpMintPDA)(marketId, programs.poolProgramId);
+    const [insuranceFund] = (0, pda_1.insuranceFundPda)(programs.poolProgramId);
+    const [insuranceVault] = (0, pda_1.insuranceVaultPda)(programs.poolProgramId);
+    const userUsdc = (0, spl_token_1.getAssociatedTokenAddressSync)(usdcMint, owner);
+    return {
+        accounts: {
+            marketState,
+            position,
+            engineAuth,
+            marketOracle,
+            poolState,
+            vaultUsdc,
+            vaultAuthority,
+            userUsdc,
+            owner,
+            signer,
+            tradingKey: tradingKeyPda ?? null,
+            referralConfig: referralConfig ?? SYSTEM_PROGRAM,
+            referralCodeAccount: referralCodeAccount ?? SYSTEM_PROGRAM,
+            traderReferral: traderReferral ?? SYSTEM_PROGRAM,
+            poolProgram: programs.poolProgramId,
+            oracleProgram: programs.oracleProgramId,
+            lpMint,
+            insuranceFund,
+            insuranceVault,
+        },
+        primaryFeedAccount,
+        secondaryFeedAccount,
+    };
+}
+function resolveUpdateMarginAccounts(marketId, owner, signer, position, usdcMint, programs, tradingKeyPda) {
+    const [marketState] = (0, pda_1.marketStatePDA)(marketId, programs.perpEngineId);
+    const [vaultUsdc] = (0, pda_1.usdcVaultPDA)(marketId, programs.poolProgramId);
+    const [engineAuth] = (0, pda_1.engineAuthPDA)(marketId, programs.perpEngineId);
+    const [poolState] = (0, pda_1.poolStatePDA)(marketId, programs.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(marketId, programs.poolProgramId);
+    const signerUsdc = (0, spl_token_1.getAssociatedTokenAddressSync)(usdcMint, signer);
+    return {
+        accounts: {
+            marketState,
+            position,
+            engineAuth,
+            poolState,
+            vaultUsdc,
+            vaultAuthority,
+            signerUsdc,
+            owner,
+            signer,
+            tradingKey: tradingKeyPda ?? null,
+            poolProgram: programs.poolProgramId,
+        },
+    };
+}
+function resolveLiquidityAccounts(marketId, user, usdcMint, programs) {
+    const [poolState] = (0, pda_1.poolStatePDA)(marketId, programs.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(marketId, programs.poolProgramId);
+    const [lpMint] = (0, pda_1.lpMintPDA)(marketId, programs.poolProgramId);
+    const [usdcVault] = (0, pda_1.usdcVaultPDA)(marketId, programs.poolProgramId);
+    const userUsdc = (0, spl_token_1.getAssociatedTokenAddressSync)(usdcMint, user);
+    const userLp = (0, spl_token_1.getAssociatedTokenAddressSync)(lpMint, user);
+    return {
+        poolState,
+        usdcVault,
+        vaultAuthority,
+        lpMint,
+        userLp,
+        userUsdc,
+    };
+}

package/dist/actions/cranks.d.ts

@@ -0,0 +1,8 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { PerpClient } from "../programs/perp";
+export declare function crankFundingRate(opts: {
+    perpClient: PerpClient;
+    perpEngineId: PublicKey;
+    poolProgramId: PublicKey;
+    marketId: Uint8Array;
+}): Promise<TransactionInstruction[]>;

package/dist/actions/cranks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crankFundingRate = crankFundingRate;
+const pda_1 = require("../utils/pda");
+async function crankFundingRate(opts) {
+    const [marketState] = (0, pda_1.marketStatePDA)(opts.marketId, opts.perpEngineId);
+    const [poolState] = (0, pda_1.poolStatePDA)(opts.marketId, opts.poolProgramId);
+    const ix = await opts.perpClient.updateFundingRateIx({ marketState, poolState });
+    return [ix];
+}

package/dist/actions/liquidity.d.ts

@@ -0,0 +1,23 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { PoolClient } from "../programs/pool";
+export interface LiquidityOpts {
+    poolClient: PoolClient;
+    poolProgramId: PublicKey;
+    marketId: Uint8Array;
+}
+export declare function addLiquidity(opts: LiquidityOpts, accounts: {
+    depositor: PublicKey;
+    userUsdc: PublicKey;
+    userLp: PublicKey;
+}, args: {
+    amountUsdc: bigint;
+    minLpOut: bigint;
+}): Promise<TransactionInstruction[]>;
+export declare function removeLiquidity(opts: LiquidityOpts, accounts: {
+    withdrawer: PublicKey;
+    userUsdc: PublicKey;
+    userLp: PublicKey;
+}, args: {
+    lpAmount: bigint;
+    minOut: bigint;
+}): Promise<TransactionInstruction[]>;

package/dist/actions/liquidity.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLiquidity = addLiquidity;
+exports.removeLiquidity = removeLiquidity;
+const pda_1 = require("../utils/pda");
+async function addLiquidity(opts, accounts, args) {
+    const [poolState] = (0, pda_1.poolStatePDA)(opts.marketId, opts.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(opts.marketId, opts.poolProgramId);
+    const [lpMint] = (0, pda_1.lpMintPDA)(opts.marketId, opts.poolProgramId);
+    const [usdcVault] = (0, pda_1.usdcVaultPDA)(opts.marketId, opts.poolProgramId);
+    const ix = await opts.poolClient.depositIx({ poolState, usdcVault, vaultAuthority, lpMint, userLp: accounts.userLp, userUsdc: accounts.userUsdc, depositor: accounts.depositor }, { amount: args.amountUsdc, minLpOut: args.minLpOut });
+    return [ix];
+}
+async function removeLiquidity(opts, accounts, args) {
+    const [poolState] = (0, pda_1.poolStatePDA)(opts.marketId, opts.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(opts.marketId, opts.poolProgramId);
+    const [lpMint] = (0, pda_1.lpMintPDA)(opts.marketId, opts.poolProgramId);
+    const [usdcVault] = (0, pda_1.usdcVaultPDA)(opts.marketId, opts.poolProgramId);
+    const ix = await opts.poolClient.withdrawIx({ poolState, usdcVault, vaultAuthority, lpMint, userLp: accounts.userLp, userUsdc: accounts.userUsdc, withdrawer: accounts.withdrawer }, { lpAmount: args.lpAmount, minOut: args.minOut });
+    return [ix];
+}

package/dist/actions/trading.d.ts

@@ -0,0 +1,39 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { PerpClient, OpenPositionArgs } from "../programs/perp";
+export interface TradingOpts {
+    perpClient: PerpClient;
+    perpEngineId: PublicKey;
+    poolProgramId: PublicKey;
+    oracleProgramId: PublicKey;
+    marketId: Uint8Array;
+    primaryFeedAccount: PublicKey;
+    secondaryFeedAccount: PublicKey;
+}
+export declare function openPosition(opts: TradingOpts, accounts: {
+    signer: PublicKey;
+    signerUsdc: PublicKey;
+    tradingKey?: PublicKey | null;
+    referralConfig?: PublicKey;
+    referralCodeAccount?: PublicKey;
+    traderReferral?: PublicKey;
+    userClaims?: PublicKey;
+}, args: OpenPositionArgs): Promise<TransactionInstruction[]>;
+export declare function closePosition(opts: TradingOpts, accounts: {
+    position: PublicKey;
+    owner: PublicKey;
+    signer: PublicKey;
+    userUsdc: PublicKey;
+    tradingKey?: PublicKey | null;
+    referralConfig?: PublicKey;
+    referralCodeAccount?: PublicKey;
+    traderReferral?: PublicKey;
+    queueEntryPda?: PublicKey;
+    userClaimsPda?: PublicKey;
+}, closeSize: bigint | null, minOutputUsdc?: bigint): Promise<TransactionInstruction[]>;
+export declare function updateMargin(opts: TradingOpts, accounts: {
+    position: PublicKey;
+    owner: PublicKey;
+    signer: PublicKey;
+    signerUsdc: PublicKey;
+    tradingKey?: PublicKey | null;
+}, delta: bigint): Promise<TransactionInstruction[]>;

package/dist/actions/trading.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openPosition = openPosition;
+exports.closePosition = closePosition;
+exports.updateMargin = updateMargin;
+const pda_1 = require("../utils/pda");
+async function openPosition(opts, accounts, args) {
+    const [marketState] = (0, pda_1.marketStatePDA)(opts.marketId, opts.perpEngineId);
+    const [position] = (0, pda_1.positionPDA)(accounts.signer, opts.marketId, args.positionNonce, opts.perpEngineId);
+    const [engineAuth] = (0, pda_1.engineAuthPDA)(opts.marketId, opts.perpEngineId);
+    const [marketOracle] = (0, pda_1.marketOraclePDA)(opts.marketId, opts.oracleProgramId);
+    const [poolState] = (0, pda_1.poolStatePDA)(opts.marketId, opts.poolProgramId);
+    const [vaultUsdc] = (0, pda_1.usdcVaultPDA)(opts.marketId, opts.poolProgramId);
+    const [feeSettings] = (0, pda_1.feeSettingsPDA)(opts.marketId, opts.poolProgramId);
+    const [defaultUserClaims] = (0, pda_1.userQueueClaimsPDA)(opts.marketId, accounts.signer, opts.poolProgramId);
+    const ix = await opts.perpClient.openPositionIx({
+        marketState,
+        position,
+        tradingKey: accounts.tradingKey ?? null,
+        signer: accounts.signer,
+        signerUsdc: accounts.signerUsdc,
+        vaultUsdc,
+        poolState,
+        poolProgram: opts.poolProgramId,
+        oracleProgram: opts.oracleProgramId,
+        marketOracle,
+        engineAuth,
+        userClaims: accounts.userClaims ?? defaultUserClaims,
+        feeSettings,
+        referralConfig: accounts.referralConfig,
+        referralCodeAccount: accounts.referralCodeAccount,
+        traderReferral: accounts.traderReferral,
+    }, args, opts.primaryFeedAccount, opts.secondaryFeedAccount);
+    return [ix];
+}
+async function closePosition(opts, accounts, closeSize, minOutputUsdc) {
+    const [marketState] = (0, pda_1.marketStatePDA)(opts.marketId, opts.perpEngineId);
+    const [engineAuth] = (0, pda_1.engineAuthPDA)(opts.marketId, opts.perpEngineId);
+    const [marketOracle] = (0, pda_1.marketOraclePDA)(opts.marketId, opts.oracleProgramId);
+    const [poolState] = (0, pda_1.poolStatePDA)(opts.marketId, opts.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(opts.marketId, opts.poolProgramId);
+    const [vaultUsdc] = (0, pda_1.usdcVaultPDA)(opts.marketId, opts.poolProgramId);
+    const [feeSettings] = (0, pda_1.feeSettingsPDA)(opts.marketId, opts.poolProgramId);
+    const [lpMint] = (0, pda_1.lpMintPDA)(opts.marketId, opts.poolProgramId);
+    const [insuranceFund] = (0, pda_1.insuranceFundPda)(opts.poolProgramId);
+    const [insuranceVault] = (0, pda_1.insuranceVaultPda)(opts.poolProgramId);
+    const ix = await opts.perpClient.closePositionIx({
+        marketState,
+        position: accounts.position,
+        tradingKey: accounts.tradingKey ?? null,
+        signer: accounts.signer,
+        owner: accounts.owner,
+        userUsdc: accounts.userUsdc,
+        poolState,
+        poolProgram: opts.poolProgramId,
+        oracleProgram: opts.oracleProgramId,
+        marketOracle,
+        vaultUsdc,
+        vaultAuthority,
+        engineAuth,
+        feeSettings,
+        referralConfig: accounts.referralConfig,
+        referralCodeAccount: accounts.referralCodeAccount,
+        traderReferral: accounts.traderReferral,
+        lpMint,
+        insuranceFund,
+        insuranceVault,
+    }, closeSize, opts.primaryFeedAccount, opts.secondaryFeedAccount, minOutputUsdc, accounts.queueEntryPda, accounts.userClaimsPda);
+    return [ix];
+}
+async function updateMargin(opts, accounts, delta) {
+    const [marketState] = (0, pda_1.marketStatePDA)(opts.marketId, opts.perpEngineId);
+    const [vaultUsdc] = (0, pda_1.usdcVaultPDA)(opts.marketId, opts.poolProgramId);
+    const [engineAuth] = (0, pda_1.engineAuthPDA)(opts.marketId, opts.perpEngineId);
+    const [poolState] = (0, pda_1.poolStatePDA)(opts.marketId, opts.poolProgramId);
+    const [vaultAuthority] = (0, pda_1.vaultAuthorityPDA)(opts.marketId, opts.poolProgramId);
+    const [marketOracle] = (0, pda_1.marketOraclePDA)(opts.marketId, opts.oracleProgramId);
+    const ix = await opts.perpClient.updatePositionMarginIx({
+        marketState,
+        position: accounts.position,
+        tradingKey: accounts.tradingKey ?? null,
+        signer: accounts.signer,
+        owner: accounts.owner,
+        signerUsdc: accounts.signerUsdc,
+        vaultUsdc,
+        userUsdc: accounts.signerUsdc,
+        vaultAuthority,
+        poolState,
+        poolProgram: opts.poolProgramId,
+        engineAuth,
+        oracleProgram: opts.oracleProgramId,
+        marketOracle,
+    }, delta, opts.primaryFeedAccount, opts.secondaryFeedAccount);
+    return [ix];
+}