@parqxchange/sdk 0.1.0

package/dist/programs/staking.d.ts

@@ -0,0 +1,76 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare class StakingClient {
+    private readonly program;
+    constructor(program: Program);
+    stakeIx(accounts: {
+        owner: PublicKey;
+        stakingPool: PublicKey;
+        stakePosition: PublicKey;
+        stakedVault: PublicKey;
+        ownerTokenAccount: PublicKey;
+        tokenMint: PublicKey;
+        tokenProgram?: PublicKey;
+        rewardUsdc?: PublicKey;
+        rewardVault?: PublicKey;
+    }, amount: bigint, tier: number): Promise<TransactionInstruction>;
+    unstakeIx(accounts: {
+        owner: PublicKey;
+        stakingPool: PublicKey;
+        stakePosition: PublicKey;
+        stakedVault: PublicKey;
+        ownerTokenAccount: PublicKey;
+        stakedMint: PublicKey;
+        rewardMint: PublicKey;
+        stakedTokenProgram?: PublicKey;
+        rewardTokenProgram?: PublicKey;
+        rewardUsdc?: PublicKey;
+        ownerUsdcAccount?: PublicKey;
+        rewardVault?: PublicKey;
+        ownerRewardAccount?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    claimRewardIx(accounts: {
+        owner: PublicKey;
+        stakingPool: PublicKey;
+        stakePosition: PublicKey;
+        rewardMint: PublicKey;
+        rewardTokenProgram?: PublicKey;
+        rewardUsdc?: PublicKey;
+        ownerUsdcAccount?: PublicKey;
+        rewardVault?: PublicKey;
+        ownerRewardAccount?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    updateRewardIndexIx(accounts: {
+        stakingPool: PublicKey;
+        rewardUsdc?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    initializeEmissionPoolIx(accounts: {
+        admin: PublicKey;
+        stakingPool: PublicKey;
+        stakedMint: PublicKey;
+        rewardMint: PublicKey;
+        adminRewardTokens: PublicKey;
+        rewardVault: PublicKey;
+        tokenProgram?: PublicKey;
+    }, totalAllocation: bigint, durationSeconds: bigint): Promise<TransactionInstruction>;
+    claimAndRestakeIx(accounts: {
+        owner: PublicKey;
+        lpStakingPool: PublicKey;
+        lpStakePosition: PublicKey;
+        lpRewardVault: PublicKey;
+        protoStakingPool: PublicKey;
+        protoStakePosition: PublicKey;
+        protoStakedVault: PublicKey;
+        protoMint: PublicKey;
+        protoRewardUsdc: PublicKey;
+        tokenProgram?: PublicKey;
+    }, tier: number): Promise<TransactionInstruction>;
+    reclaimUnallocatedIx(accounts: {
+        admin: PublicKey;
+        stakingPool: PublicKey;
+        rewardVault: PublicKey;
+        rewardMint: PublicKey;
+        adminTokenAccount: PublicKey;
+        tokenProgram?: PublicKey;
+    }): Promise<TransactionInstruction>;
+}

package/dist/programs/staking.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingClient = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+class StakingClient {
+    program;
+    constructor(program) {
+        this.program = program;
+    }
+    async stakeIx(accounts, amount, tier) {
+        const accs = {
+            owner: accounts.owner,
+            stakingPool: accounts.stakingPool,
+            stakePosition: accounts.stakePosition,
+            stakedVault: accounts.stakedVault,
+            ownerTokenAccount: accounts.ownerTokenAccount,
+            tokenMint: accounts.tokenMint,
+            tokenProgram: accounts.tokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        };
+        if (accounts.rewardUsdc)
+            accs.rewardUsdc = accounts.rewardUsdc;
+        if (accounts.rewardVault)
+            accs.rewardVault = accounts.rewardVault;
+        return this.program.methods
+            .stake({ amount: new anchor_1.BN(amount.toString()), tier })
+            .accounts(accs)
+            .instruction();
+    }
+    async unstakeIx(accounts) {
+        const noneAcct = this.program.programId;
+        const accs = {
+            owner: accounts.owner,
+            stakingPool: accounts.stakingPool,
+            stakePosition: accounts.stakePosition,
+            stakedVault: accounts.stakedVault,
+            ownerTokenAccount: accounts.ownerTokenAccount,
+            stakedMint: accounts.stakedMint,
+            rewardMint: accounts.rewardMint,
+            stakedTokenProgram: accounts.stakedTokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+            rewardTokenProgram: accounts.rewardTokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+            rewardUsdc: accounts.rewardUsdc ?? noneAcct,
+            ownerUsdcAccount: accounts.ownerUsdcAccount ?? noneAcct,
+            rewardVault: accounts.rewardVault ?? noneAcct,
+            ownerRewardAccount: accounts.ownerRewardAccount ?? noneAcct,
+        };
+        return this.program.methods
+            .unstake()
+            .accounts(accs)
+            .instruction();
+    }
+    async claimRewardIx(accounts) {
+        const noneAcct = this.program.programId;
+        const accs = {
+            owner: accounts.owner,
+            stakingPool: accounts.stakingPool,
+            stakePosition: accounts.stakePosition,
+            rewardMint: accounts.rewardMint,
+            rewardTokenProgram: accounts.rewardTokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+            rewardUsdc: accounts.rewardUsdc ?? noneAcct,
+            ownerUsdcAccount: accounts.ownerUsdcAccount ?? noneAcct,
+            rewardVault: accounts.rewardVault ?? noneAcct,
+            ownerRewardAccount: accounts.ownerRewardAccount ?? noneAcct,
+        };
+        return this.program.methods
+            .claimReward()
+            .accounts(accs)
+            .instruction();
+    }
+    async updateRewardIndexIx(accounts) {
+        const accs = {
+            stakingPool: accounts.stakingPool,
+        };
+        if (accounts.rewardUsdc)
+            accs.rewardUsdc = accounts.rewardUsdc;
+        return this.program.methods
+            .updateRewardIndex()
+            .accounts(accs)
+            .instruction();
+    }
+    async initializeEmissionPoolIx(accounts, totalAllocation, durationSeconds) {
+        return this.program.methods
+            .initializeEmissionPool({
+            tokenMint: accounts.stakedMint,
+            rewardMint: accounts.rewardMint,
+            totalAllocation: new anchor_1.BN(totalAllocation.toString()),
+            durationSeconds: new anchor_1.BN(durationSeconds.toString()),
+        })
+            .accounts({
+            admin: accounts.admin,
+            stakingPool: accounts.stakingPool,
+            stakedMint: accounts.stakedMint,
+            rewardMint: accounts.rewardMint,
+            adminRewardTokens: accounts.adminRewardTokens,
+            rewardVault: accounts.rewardVault,
+            tokenProgram: accounts.tokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async claimAndRestakeIx(accounts, tier) {
+        return this.program.methods
+            .claimAndRestake({ tier })
+            .accounts({
+            owner: accounts.owner,
+            lpStakingPool: accounts.lpStakingPool,
+            lpStakePosition: accounts.lpStakePosition,
+            lpRewardVault: accounts.lpRewardVault,
+            protoStakingPool: accounts.protoStakingPool,
+            protoStakePosition: accounts.protoStakePosition,
+            protoStakedVault: accounts.protoStakedVault,
+            protoMint: accounts.protoMint,
+            protoRewardUsdc: accounts.protoRewardUsdc,
+            tokenProgram: accounts.tokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async reclaimUnallocatedIx(accounts) {
+        return this.program.methods
+            .reclaimUnallocated()
+            .accounts({
+            admin: accounts.admin,
+            stakingPool: accounts.stakingPool,
+            rewardVault: accounts.rewardVault,
+            rewardMint: accounts.rewardMint,
+            adminTokenAccount: accounts.adminTokenAccount,
+            tokenProgram: accounts.tokenProgram ?? spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+    }
+}
+exports.StakingClient = StakingClient;

package/dist/types/index.d.ts

@@ -0,0 +1,337 @@
+import { PublicKey } from "@solana/web3.js";
+export type Side = "long" | "short";
+export interface Position {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    side: Side;
+    sizeUsdc: bigint;
+    collateralUsdc: bigint;
+    entryPrice: bigint;
+    fundingIndexSnapshot: bigint;
+    borrowingFactorSnapshot: bigint;
+    reservedMaxPayout: bigint;
+    collateralFromQueue: bigint;
+    openedAt: bigint;
+    bump: number;
+}
+export interface MarketState {
+    marketId: Uint8Array;
+    longOi: bigint;
+    shortOi: bigint;
+    fundingIndex: bigint;
+    lastFundingTs: bigint;
+    maxLeverage: number;
+    baseFeeBps: number;
+    mmrBps: number;
+    poolState: PublicKey;
+    poolProgram: PublicKey;
+    oracleProgram: PublicKey;
+    treasury: PublicKey;
+    stakingProgramId: PublicKey;
+    engineAuthBump: number;
+    isPaused: boolean;
+    savedFundingFactorPerSecond: bigint;
+    fundingIncreaseFactorPerSecond: bigint;
+    fundingDecreaseFactorPerSecond: bigint;
+    thresholdForStableFunding: bigint;
+    thresholdForDecreaseFunding: bigint;
+    minFundingFactorPerSecond: bigint;
+    maxFundingFactorPerSecond: bigint;
+    longCumulativeBorrowingFactor: bigint;
+    shortCumulativeBorrowingFactor: bigint;
+    lastBorrowingTs: bigint;
+    borrowingFactor: bigint;
+    optimalUsageFactor: bigint;
+    aboveOptimalBorrowingFactor: bigint;
+    longReservedUsdc: bigint;
+    shortReservedUsdc: bigint;
+    priceImpactFactor: bigint;
+    maxPriceImpactBps: number;
+    impactPoolUsdc: bigint;
+    keeper: PublicKey;
+    maxOiLong: bigint;
+    maxOiShort: bigint;
+    feeBpsFavorable: number;
+    bump: number;
+    offHoursMaxOiLong?: bigint;
+    offHoursMaxOiShort?: bigint;
+    adlFrozen?: number;
+    adlTailTriggerUsdcRth?: bigint;
+    adlTailTriggerUsdcOff?: bigint;
+    adlTailMinAgeSecsRth?: number;
+    adlTailMinAgeSecsOff?: number;
+    adlHaircutBpsRth?: number;
+    adlHaircutBpsOff?: number;
+    adlMaxHaircutBps?: number;
+    adlMaxFeedDivergenceBps?: number;
+    initialMarginBps?: number;
+}
+export interface Market {
+    marketId: Uint8Array;
+    longOi: bigint;
+    shortOi: bigint;
+    fundingIndex: bigint;
+    lastFundingTs: bigint;
+    maxLeverage: number;
+    baseFeeBps: number;
+    mmrBps: number;
+    isPaused: boolean;
+}
+export interface PoolState {
+    marketId: Uint8Array;
+    usdcVault: PublicKey;
+    vaultAuthorityBump: number;
+    lpMint: PublicKey;
+    totalUsdc: bigint;
+    reservedUsdc: bigint;
+    cumulativeFees: bigint;
+    engineAuth: PublicKey;
+    engineAuthBump: number;
+    admin: PublicKey;
+    isPaused: boolean;
+    reserveFactor: bigint;
+    depositFeeBps: number;
+    withdrawalFeeBps: number;
+    sideBucket: bigint;
+    queueHeadIdx: bigint;
+    queueTailIdx: bigint;
+    queueTotalOwed: bigint;
+    bump: number;
+    currentAdlEpoch: number;
+    lastAdlCutIdx: bigint;
+}
+export type OrderType = "marketIncrease" | "limitIncrease" | "stopIncrease" | "marketDecrease" | "limitDecrease" | "stopLossDecrease";
+export interface Order {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    orderType: OrderType;
+    side: Side;
+    sizeUsdc: bigint;
+    collateralUsdc: bigint;
+    triggerPrice: bigint;
+    acceptablePrice: bigint;
+    minOutputUsdc: bigint;
+    referralCode: Uint8Array;
+    positionNonce: bigint;
+    createdAt: bigint;
+    nonce: bigint;
+    bump: number;
+}
+export interface OrderNonce {
+    owner: PublicKey;
+    nonce: bigint;
+    bump: number;
+}
+export interface TradingKey {
+    wallet: PublicKey;
+    delegate: PublicKey;
+    expiresAt: bigint;
+    bump: number;
+}
+export declare enum HaltMode {
+    None = 0,
+    ReduceOnly = 1,
+    Full = 2
+}
+export interface ProtocolConfig {
+    admin: PublicKey;
+    bump: number;
+    haltMode: number;
+    rthOpenMinutesUtc: number;
+    rthCloseMinutesUtc: number;
+    tierBreakpointsUsdc: bigint[];
+    rthMaxLeverage: number[];
+    offHoursMaxLeverage: number[];
+}
+export interface ReferralTier {
+    totalRebateBps: number;
+    discountSharePct: number;
+}
+export interface ReferralConfig {
+    admin: PublicKey;
+    tiers: [ReferralTier, ReferralTier, ReferralTier, ReferralTier];
+    bump: number;
+}
+export interface ReferralCode {
+    owner: PublicKey;
+    code: Uint8Array;
+    tier: number;
+    bump: number;
+}
+export interface TraderReferral {
+    trader: PublicKey;
+    code: Uint8Array;
+    bump: number;
+}
+export interface AffiliateReward {
+    affiliate: PublicKey;
+    marketId: Uint8Array;
+    accruedUsdc: bigint;
+    bump: number;
+}
+export interface FeePool {
+    admin: PublicKey;
+    perpEngine: PublicKey;
+    usdcAccount: PublicKey;
+    stakingReward: PublicKey;
+    treasury: PublicKey;
+    referralReserve: PublicKey;
+    stakerSplitBps: number;
+    treasurySplitBps: number;
+    referralSplitBps: number;
+    totalDistributed: bigint;
+    bump: number;
+}
+export interface StakingPool {
+    admin: PublicKey;
+    tokenMint: PublicKey;
+    stakedVault: PublicKey;
+    rewardSource: number;
+    rewardMint: PublicKey;
+    rewardVault: PublicKey;
+    rewardUsdc: PublicKey;
+    totalWeightedStake: bigint;
+    rewardIndex: bigint;
+    totalRewardsDistributed: bigint;
+    totalAllocation: bigint;
+    startTs: bigint;
+    endTs: bigint;
+    emittedSoFar: bigint;
+    lastUpdateTs: bigint;
+    bump: number;
+}
+export interface StakePosition {
+    pool: PublicKey;
+    owner: PublicKey;
+    amount: bigint;
+    lockupTier: number;
+    lockupExpiry: bigint;
+    weightedAmount: bigint;
+    rewardIndexSnap: bigint;
+    accruedReward: bigint;
+    bump: number;
+}
+export interface PayoutQueueEntry {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    idx: bigint;
+    amount: bigint;
+    enqueuedAt: bigint;
+    status: number;
+    bump: number;
+}
+export interface UserQueueClaims {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    unpaidOwed: bigint;
+    collateralDrawn: bigint;
+    phantomUnpaidOwed: bigint;
+    bump: number;
+}
+export interface PriceData {
+    price: bigint;
+    confidence: bigint;
+    timestamp: bigint;
+}
+export interface PositionOpenedEvent {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    side: Side;
+    sizeUsdc: bigint;
+    collateral: bigint;
+    entryPrice: bigint;
+}
+export interface PositionClosedEvent {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    pnl: bigint;
+    netReturn: bigint;
+    exitPrice: bigint;
+}
+export interface LiquidatedEvent {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    badDebt: bigint;
+}
+export interface BadDebtEvent {
+    marketId: Uint8Array;
+    amount: bigint;
+}
+export interface FundingUpdatedEvent {
+    marketId: Uint8Array;
+    fundingIndex: bigint;
+    longOi: bigint;
+    shortOi: bigint;
+}
+export interface EnqueuedEvent {
+    idx: bigint;
+    owner: PublicKey;
+    marketId: Uint8Array;
+    amount: bigint;
+    queueTotalOwedAfter: bigint;
+}
+export interface HarvestedEvent {
+    idx: bigint;
+    owner: PublicKey;
+    marketId: Uint8Array;
+    amount: bigint;
+}
+export interface EntryVoidedEvent {
+    idx: bigint;
+    owner: PublicKey;
+    marketId: Uint8Array;
+    amount: bigint;
+    reason: number;
+}
+export interface SideBucketCreditedEvent {
+    marketId: Uint8Array;
+    amount: bigint;
+    source: number;
+}
+export interface QueueDrainedEvent {
+    marketId: Uint8Array;
+    residualToTreasury: bigint;
+}
+export interface PhantomCreditDrainedEvent {
+    owner: PublicKey;
+    marketId: Uint8Array;
+    amount: bigint;
+}
+export interface FeesSweptEvent {
+    marketId: Uint8Array;
+    amount: bigint;
+}
+export interface FeesDistributedEvent {
+    total: bigint;
+    stakerShare: bigint;
+    treasuryShare: bigint;
+    referralShare: bigint;
+}
+export interface TreasuryWithdrawalEvent {
+    amount: bigint;
+    destination: PublicKey;
+}
+export interface StakedEvent {
+    owner: PublicKey;
+    amount: bigint;
+    tier: number;
+    lockupExpiry: bigint;
+    weightedAmount: bigint;
+}
+export interface UnstakedEvent {
+    owner: PublicKey;
+    amount: bigint;
+}
+export interface RewardClaimedEvent {
+    owner: PublicKey;
+    amountUsdc: bigint;
+}
+export interface RewardIndexUpdatedEvent {
+    rewardIndex: bigint;
+    newRewards: bigint;
+}
+export interface CompoundedRewardEvent {
+    owner: PublicKey;
+    amount: bigint;
+    tier: number;
+}

package/dist/types/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HaltMode = void 0;
+var HaltMode;
+(function (HaltMode) {
+    HaltMode[HaltMode["None"] = 0] = "None";
+    HaltMode[HaltMode["ReduceOnly"] = 1] = "ReduceOnly";
+    HaltMode[HaltMode["Full"] = 2] = "Full";
+})(HaltMode || (exports.HaltMode = HaltMode = {}));

package/dist/utils/computeBudget.d.ts

@@ -0,0 +1,5 @@
+import { TransactionInstruction } from "@solana/web3.js";
+export declare function withComputeBudget(ixs: TransactionInstruction[], opts?: {
+    units?: number;
+    microLamports?: number;
+}): TransactionInstruction[];

package/dist/utils/computeBudget.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withComputeBudget = withComputeBudget;
+const web3_js_1 = require("@solana/web3.js");
+function withComputeBudget(ixs, opts) {
+    const units = opts?.units ?? 400_000;
+    const prefix = [
+        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units }),
+    ];
+    if (opts?.microLamports && opts.microLamports > 0) {
+        prefix.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: opts.microLamports }));
+    }
+    return [...prefix, ...ixs];
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1,56 @@
+export declare enum ParquetError {
+    PriceStale = 7001,
+    PriceUncertain = 7002,
+    OracleNoReturnData = 7003,
+    OracleReturnMismatch = 7004,
+    InsufficientPool = 8001,
+    LeverageExceeded = 8002,
+    BelowMinSize = 8003,
+    WrongPool = 8004,
+    OiCapExceeded = 8005,
+    BelowMinCollateral = 8006,
+    InvalidConfig = 8007,
+    QueueCollateralExceedsClaim = 8008,
+    WalletAndQueueZero = 8009,
+    MissingQueueEntryAccount = 8010,
+    LeverageExceedsTierCap = 8011,
+    MalformedQueueEntry = 8012,
+    QueueOwnerMismatch = 8013,
+    QueueMarketMismatch = 8014,
+    InitialMarginUnmet = 8015,
+    HealthFactorTooLow = 9001,
+    PositionHealthy = 9002,
+    TradingKeyExpired = 10001,
+    Unauthorized = 10002,
+    PositionNotFound = 10003,
+    MarketPaused = 10004,
+    ProtocolHalted = 10005,
+    InvalidHaltMode = 10006,
+    MathOverflow = 11001,
+    SlippageExceeded = 12001,
+    OrderNotTriggered = 12002,
+    WrongOrderType = 12003,
+    ReferralCodeTaken = 13001,
+    ReferralCodeNotFound = 13002,
+    TraderAlreadyReferred = 13003,
+    InvalidTier = 13004,
+    FundingCadenceTooFast = 14001,
+    InvalidOptimalUsage = 15001,
+    MustBePaused = 15002,
+    MissingFeeSettings = 15003,
+    MissingAffiliateReward = 15004,
+    MissingAffiliateRewardBump = 15005,
+    MissingFeeDistributorAccounts = 15006,
+    QueueEntryNotPending = 6012,
+    QueueNonEmpty = 6013,
+    PhantomEmpty = 6014,
+    InsufficientClaim = 6015,
+    PhantomDrainInsufficientFunds = 6016,
+    MissingAccount = 6017,
+    WrongEntryIndex = 6018,
+    WrongMarketId = 6019,
+    OwnerMismatch = 6020
+}
+export declare function errorMessage(code: ParquetError): string;
+export declare function decodeError(err: unknown): ParquetError | null;
+export declare function isParquetError(err: unknown, code: ParquetError): boolean;