@parqxchange/sdk 0.1.0

package/dist/utils/errors.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParquetError = void 0;
+exports.errorMessage = errorMessage;
+exports.decodeError = decodeError;
+exports.isParquetError = isParquetError;
+var ParquetError;
+(function (ParquetError) {
+    ParquetError[ParquetError["PriceStale"] = 7001] = "PriceStale";
+    ParquetError[ParquetError["PriceUncertain"] = 7002] = "PriceUncertain";
+    ParquetError[ParquetError["OracleNoReturnData"] = 7003] = "OracleNoReturnData";
+    ParquetError[ParquetError["OracleReturnMismatch"] = 7004] = "OracleReturnMismatch";
+    ParquetError[ParquetError["InsufficientPool"] = 8001] = "InsufficientPool";
+    ParquetError[ParquetError["LeverageExceeded"] = 8002] = "LeverageExceeded";
+    ParquetError[ParquetError["BelowMinSize"] = 8003] = "BelowMinSize";
+    ParquetError[ParquetError["WrongPool"] = 8004] = "WrongPool";
+    ParquetError[ParquetError["OiCapExceeded"] = 8005] = "OiCapExceeded";
+    ParquetError[ParquetError["BelowMinCollateral"] = 8006] = "BelowMinCollateral";
+    ParquetError[ParquetError["InvalidConfig"] = 8007] = "InvalidConfig";
+    ParquetError[ParquetError["QueueCollateralExceedsClaim"] = 8008] = "QueueCollateralExceedsClaim";
+    ParquetError[ParquetError["WalletAndQueueZero"] = 8009] = "WalletAndQueueZero";
+    ParquetError[ParquetError["MissingQueueEntryAccount"] = 8010] = "MissingQueueEntryAccount";
+    ParquetError[ParquetError["LeverageExceedsTierCap"] = 8011] = "LeverageExceedsTierCap";
+    ParquetError[ParquetError["MalformedQueueEntry"] = 8012] = "MalformedQueueEntry";
+    ParquetError[ParquetError["QueueOwnerMismatch"] = 8013] = "QueueOwnerMismatch";
+    ParquetError[ParquetError["QueueMarketMismatch"] = 8014] = "QueueMarketMismatch";
+    ParquetError[ParquetError["InitialMarginUnmet"] = 8015] = "InitialMarginUnmet";
+    ParquetError[ParquetError["HealthFactorTooLow"] = 9001] = "HealthFactorTooLow";
+    ParquetError[ParquetError["PositionHealthy"] = 9002] = "PositionHealthy";
+    ParquetError[ParquetError["TradingKeyExpired"] = 10001] = "TradingKeyExpired";
+    ParquetError[ParquetError["Unauthorized"] = 10002] = "Unauthorized";
+    ParquetError[ParquetError["PositionNotFound"] = 10003] = "PositionNotFound";
+    ParquetError[ParquetError["MarketPaused"] = 10004] = "MarketPaused";
+    ParquetError[ParquetError["ProtocolHalted"] = 10005] = "ProtocolHalted";
+    ParquetError[ParquetError["InvalidHaltMode"] = 10006] = "InvalidHaltMode";
+    ParquetError[ParquetError["MathOverflow"] = 11001] = "MathOverflow";
+    ParquetError[ParquetError["SlippageExceeded"] = 12001] = "SlippageExceeded";
+    ParquetError[ParquetError["OrderNotTriggered"] = 12002] = "OrderNotTriggered";
+    ParquetError[ParquetError["WrongOrderType"] = 12003] = "WrongOrderType";
+    ParquetError[ParquetError["ReferralCodeTaken"] = 13001] = "ReferralCodeTaken";
+    ParquetError[ParquetError["ReferralCodeNotFound"] = 13002] = "ReferralCodeNotFound";
+    ParquetError[ParquetError["TraderAlreadyReferred"] = 13003] = "TraderAlreadyReferred";
+    ParquetError[ParquetError["InvalidTier"] = 13004] = "InvalidTier";
+    ParquetError[ParquetError["FundingCadenceTooFast"] = 14001] = "FundingCadenceTooFast";
+    ParquetError[ParquetError["InvalidOptimalUsage"] = 15001] = "InvalidOptimalUsage";
+    ParquetError[ParquetError["MustBePaused"] = 15002] = "MustBePaused";
+    ParquetError[ParquetError["MissingFeeSettings"] = 15003] = "MissingFeeSettings";
+    ParquetError[ParquetError["MissingAffiliateReward"] = 15004] = "MissingAffiliateReward";
+    ParquetError[ParquetError["MissingAffiliateRewardBump"] = 15005] = "MissingAffiliateRewardBump";
+    ParquetError[ParquetError["MissingFeeDistributorAccounts"] = 15006] = "MissingFeeDistributorAccounts";
+    ParquetError[ParquetError["QueueEntryNotPending"] = 6012] = "QueueEntryNotPending";
+    ParquetError[ParquetError["QueueNonEmpty"] = 6013] = "QueueNonEmpty";
+    ParquetError[ParquetError["PhantomEmpty"] = 6014] = "PhantomEmpty";
+    ParquetError[ParquetError["InsufficientClaim"] = 6015] = "InsufficientClaim";
+    ParquetError[ParquetError["PhantomDrainInsufficientFunds"] = 6016] = "PhantomDrainInsufficientFunds";
+    ParquetError[ParquetError["MissingAccount"] = 6017] = "MissingAccount";
+    ParquetError[ParquetError["WrongEntryIndex"] = 6018] = "WrongEntryIndex";
+    ParquetError[ParquetError["WrongMarketId"] = 6019] = "WrongMarketId";
+    ParquetError[ParquetError["OwnerMismatch"] = 6020] = "OwnerMismatch";
+})(ParquetError || (exports.ParquetError = ParquetError = {}));
+const ERROR_MESSAGES = {
+    [ParquetError.PriceStale]: "Price feed is stale",
+    [ParquetError.PriceUncertain]: "Price confidence too wide",
+    [ParquetError.OracleNoReturnData]: "Oracle returned no data",
+    [ParquetError.OracleReturnMismatch]: "Oracle return data mismatch",
+    [ParquetError.InsufficientPool]: "Insufficient pool liquidity",
+    [ParquetError.LeverageExceeded]: "Leverage exceeds max",
+    [ParquetError.BelowMinSize]: "Size below minimum",
+    [ParquetError.WrongPool]: "Wrong pool account",
+    [ParquetError.OiCapExceeded]: "Open interest cap exceeded",
+    [ParquetError.BelowMinCollateral]: "Collateral below minimum ($10)",
+    [ParquetError.InvalidConfig]: "Invalid market config — inconsistent or default-pubkey field",
+    [ParquetError.QueueCollateralExceedsClaim]: "Position's collateral_from_queue exceeds available user claim",
+    [ParquetError.WalletAndQueueZero]: "Both wallet_collateral and from_queue_amount are zero",
+    [ParquetError.MissingQueueEntryAccount]: "Liquidation flow: required queue entry account missing",
+    [ParquetError.LeverageExceedsTierCap]: "Requested leverage exceeds the current-session tier cap for this wallet's notional",
+    [ParquetError.MalformedQueueEntry]: "Liquidation clawback: queue entry/claims account malformed or too short",
+    [ParquetError.QueueOwnerMismatch]: "Liquidation clawback: queue entry/claims owner != liquidated position owner",
+    [ParquetError.QueueMarketMismatch]: "Liquidation clawback: queue entry/claims belongs to a different market",
+    [ParquetError.InitialMarginUnmet]: "Initial margin requirement not met (collateral below notional * initial_margin_bps)",
+    [ParquetError.HealthFactorTooLow]: "Health factor too low",
+    [ParquetError.PositionHealthy]: "Position health >= 1000, not liquidatable",
+    [ParquetError.TradingKeyExpired]: "Trading key expired",
+    [ParquetError.Unauthorized]: "Unauthorized",
+    [ParquetError.PositionNotFound]: "Position not found",
+    [ParquetError.MarketPaused]: "Market is paused",
+    [ParquetError.ProtocolHalted]: "Protocol trading is halted",
+    [ParquetError.InvalidHaltMode]: "Invalid halt mode — must be 0 (None), 1 (ReduceOnly), or 2 (Full)",
+    [ParquetError.MathOverflow]: "Math overflow",
+    [ParquetError.SlippageExceeded]: "Slippage tolerance exceeded",
+    [ParquetError.OrderNotTriggered]: "Order not triggered",
+    [ParquetError.WrongOrderType]: "Wrong order type",
+    [ParquetError.ReferralCodeTaken]: "Referral code already taken",
+    [ParquetError.ReferralCodeNotFound]: "Referral code not found",
+    [ParquetError.TraderAlreadyReferred]: "Trader already has a referral",
+    [ParquetError.InvalidTier]: "Invalid tier — must be 0–3",
+    [ParquetError.FundingCadenceTooFast]: "update_funding_rate called within 5s of last update",
+    [ParquetError.InvalidOptimalUsage]: "Invalid optimal usage factor — must be < PRECISION",
+    [ParquetError.MustBePaused]: "Market must be paused for migration",
+    [ParquetError.MissingFeeSettings]: "Missing fee_settings remaining account",
+    [ParquetError.MissingAffiliateReward]: "Missing affiliate_reward remaining account",
+    [ParquetError.MissingAffiliateRewardBump]: "Missing affiliate_reward_bump in args",
+    [ParquetError.MissingFeeDistributorAccounts]: "Missing fee-distributor remaining accounts (need 4: program, fee_pool, referral_reserve, token_program)",
+    [ParquetError.QueueEntryNotPending]: "Queue entry is not in Pending status",
+    [ParquetError.QueueNonEmpty]: "Queue is non-empty; phantom drain requires queue_total_owed == 0",
+    [ParquetError.PhantomEmpty]: "Phantom credit is zero",
+    [ParquetError.InsufficientClaim]: "Insufficient claim for the requested from_queue_amount",
+    [ParquetError.PhantomDrainInsufficientFunds]: "Pool insufficient funds to satisfy phantom drain",
+    [ParquetError.MissingAccount]: "Required account missing from remaining_accounts",
+    [ParquetError.WrongEntryIndex]: "Queue entry idx does not match queue_head_idx",
+    [ParquetError.WrongMarketId]: "Queue entry market_id mismatch",
+    [ParquetError.OwnerMismatch]: "UserQueueClaims owner mismatch with queue entry owner",
+};
+function errorMessage(code) {
+    return ERROR_MESSAGES[code] ?? `Unknown error: ${code}`;
+}
+const KNOWN_ERROR_CODES = new Set(Object.values(ParquetError).filter((v) => typeof v === "number"));
+function decodeError(err) {
+    if (typeof err !== "object" || err === null)
+        return null;
+    const code = err
+        ?.error?.errorCode?.number;
+    if (code !== undefined && KNOWN_ERROR_CODES.has(code))
+        return code;
+    const message = err?.message;
+    if (typeof message === "string") {
+        const match = message.match(/custom program error: 0x([0-9a-fA-F]+)/);
+        if (match) {
+            const parsed = parseInt(match[1], 16);
+            if (KNOWN_ERROR_CODES.has(parsed))
+                return parsed;
+        }
+    }
+    return null;
+}
+function isParquetError(err, code) {
+    return decodeError(err) === code;
+}

package/dist/utils/pda.d.ts

@@ -0,0 +1,28 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function poolStatePDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function vaultAuthorityPDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function usdcVaultPDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function lpMintPDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function marketStatePDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function positionPDA(owner: PublicKey, marketId: Uint8Array, nonce: bigint, programId: PublicKey): [PublicKey, number];
+export declare function tradingKeyPDA(wallet: PublicKey, programId: PublicKey): [PublicKey, number];
+export declare function marketOraclePDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function engineAuthPDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function protocolConfigPDA(programId: PublicKey): [PublicKey, number];
+export declare function priceFeedPDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function marketIdFromString(s: string): Uint8Array;
+export declare function referralConfigPDA(programId: PublicKey): [PublicKey, number];
+export declare function referralCodePDA(code: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function traderReferralPDA(trader: PublicKey, programId: PublicKey): [PublicKey, number];
+export declare function affiliateRewardPDA(affiliate: PublicKey, marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function orderNoncePDA(owner: PublicKey, programId: PublicKey): [PublicKey, number];
+export declare function orderPDA(owner: PublicKey, marketId: Uint8Array, nonce: bigint, programId: PublicKey): [PublicKey, number];
+export declare function payoutQueueEntryPDA(marketId: Uint8Array, idx: bigint, programId: PublicKey): [PublicKey, number];
+export declare function userQueueClaimsPDA(marketId: Uint8Array, owner: PublicKey, programId: PublicKey): [PublicKey, number];
+export declare function insuranceFundPda(programId: PublicKey): [PublicKey, number];
+export declare function insuranceVaultPda(programId: PublicKey): [PublicKey, number];
+export declare function insuranceVaultAuthorityPda(programId: PublicKey): [PublicKey, number];
+export declare function feeSettingsPDA(marketId: Uint8Array, programId: PublicKey): [PublicKey, number];
+export declare function feePoolPDA(feeDistributorProgramId: PublicKey): [PublicKey, number];
+export declare function stakingPoolPDA(tokenMint: PublicKey, programId: PublicKey): [PublicKey, number];
+export declare function stakePositionPDA(pool: PublicKey, owner: PublicKey, programId: PublicKey): [PublicKey, number];

package/dist/utils/pda.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poolStatePDA = poolStatePDA;
+exports.vaultAuthorityPDA = vaultAuthorityPDA;
+exports.usdcVaultPDA = usdcVaultPDA;
+exports.lpMintPDA = lpMintPDA;
+exports.marketStatePDA = marketStatePDA;
+exports.positionPDA = positionPDA;
+exports.tradingKeyPDA = tradingKeyPDA;
+exports.marketOraclePDA = marketOraclePDA;
+exports.engineAuthPDA = engineAuthPDA;
+exports.protocolConfigPDA = protocolConfigPDA;
+exports.priceFeedPDA = priceFeedPDA;
+exports.marketIdFromString = marketIdFromString;
+exports.referralConfigPDA = referralConfigPDA;
+exports.referralCodePDA = referralCodePDA;
+exports.traderReferralPDA = traderReferralPDA;
+exports.affiliateRewardPDA = affiliateRewardPDA;
+exports.orderNoncePDA = orderNoncePDA;
+exports.orderPDA = orderPDA;
+exports.payoutQueueEntryPDA = payoutQueueEntryPDA;
+exports.userQueueClaimsPDA = userQueueClaimsPDA;
+exports.insuranceFundPda = insuranceFundPda;
+exports.insuranceVaultPda = insuranceVaultPda;
+exports.insuranceVaultAuthorityPda = insuranceVaultAuthorityPda;
+exports.feeSettingsPDA = feeSettingsPDA;
+exports.feePoolPDA = feePoolPDA;
+exports.stakingPoolPDA = stakingPoolPDA;
+exports.stakePositionPDA = stakePositionPDA;
+const web3_js_1 = require("@solana/web3.js");
+function poolStatePDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("pool"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function vaultAuthorityPDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("vault_authority"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function usdcVaultPDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("vault"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function lpMintPDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("lp_mint"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function marketStatePDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("market"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function positionPDA(owner, marketId, nonce, programId) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(nonce);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("position"), owner.toBuffer(), marketId instanceof Buffer ? marketId : Buffer.from(marketId), nonceBuf], programId);
+}
+function tradingKeyPDA(wallet, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("trading_key"), wallet.toBuffer()], programId);
+}
+function marketOraclePDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("oracle"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function engineAuthPDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("engine_auth"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function protocolConfigPDA(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("protocol_config")], programId);
+}
+function priceFeedPDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("feed"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function marketIdFromString(s) {
+    const encoded = Buffer.from(s, "utf8");
+    if (encoded.length > 32) {
+        throw new Error(`marketIdFromString: identifier exceeds 32 bytes (${encoded.length})`);
+    }
+    const buf = new Uint8Array(32);
+    buf.set(encoded);
+    return buf;
+}
+function referralConfigPDA(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("referral_config")], programId);
+}
+function referralCodePDA(code, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("referral_code"), code instanceof Buffer ? code : Buffer.from(code)], programId);
+}
+function traderReferralPDA(trader, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("trader_referral"), trader.toBuffer()], programId);
+}
+function affiliateRewardPDA(affiliate, marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("affiliate_reward"), affiliate.toBuffer(), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function orderNoncePDA(owner, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("order_nonce"), owner.toBuffer()], programId);
+}
+function orderPDA(owner, marketId, nonce, programId) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(nonce);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("order"), owner.toBuffer(), marketId instanceof Buffer ? marketId : Buffer.from(marketId), nonceBuf], programId);
+}
+function payoutQueueEntryPDA(marketId, idx, programId) {
+    const idxLe = Buffer.alloc(8);
+    idxLe.writeBigUInt64LE(idx);
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from("payout_queue_entry"),
+        marketId instanceof Buffer ? marketId : Buffer.from(marketId),
+        idxLe,
+    ], programId);
+}
+function userQueueClaimsPDA(marketId, owner, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from("user_queue_claims"),
+        marketId instanceof Buffer ? marketId : Buffer.from(marketId),
+        owner.toBuffer(),
+    ], programId);
+}
+function insuranceFundPda(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("insurance_fund")], programId);
+}
+function insuranceVaultPda(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("insurance_vault")], programId);
+}
+function insuranceVaultAuthorityPda(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("insurance_vault_authority")], programId);
+}
+function feeSettingsPDA(marketId, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("fee_settings"), marketId instanceof Buffer ? marketId : Buffer.from(marketId)], programId);
+}
+function feePoolPDA(feeDistributorProgramId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("fee_pool")], feeDistributorProgramId);
+}
+function stakingPoolPDA(tokenMint, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("staking_pool"), tokenMint.toBuffer()], programId);
+}
+function stakePositionPDA(pool, owner, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("stake"), pool.toBuffer(), owner.toBuffer()], programId);
+}

package/dist/utils/priceMath.d.ts

@@ -0,0 +1,5 @@
+export declare function calcPnl(side: "long" | "short", entry: bigint, exit: bigint, size: bigint): bigint;
+export declare function calcFee(size: bigint, feeBps: number, discountPct: number): bigint;
+export declare function formatUsdcAmount(amount: bigint): string;
+export declare function formatPrice(price: bigint): string;
+export declare function calcHealth(collateral: bigint, size: bigint, mmrBps: number): bigint;

package/dist/utils/priceMath.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcPnl = calcPnl;
+exports.calcFee = calcFee;
+exports.formatUsdcAmount = formatUsdcAmount;
+exports.formatPrice = formatPrice;
+exports.calcHealth = calcHealth;
+function calcPnl(side, entry, exit, size) {
+    if (entry === 0n) {
+        throw new Error("calcPnl: entry price must be non-zero");
+    }
+    const diff = side === "long" ? exit - entry : entry - exit;
+    const num = diff * size;
+    return diff < 0n ? (num - (entry - 1n)) / entry : num / entry;
+}
+function calcFee(size, feeBps, discountPct) {
+    if (!Number.isInteger(feeBps) || feeBps < 0 || feeBps > 65_535) {
+        throw new Error("calcFee: feeBps must be an integer in u16 range (0–65535)");
+    }
+    if (!Number.isInteger(discountPct) || discountPct < 0 || discountPct > 100) {
+        throw new Error("calcFee: discountPct must be an integer in 0–100");
+    }
+    const numerator = size * BigInt(feeBps) * BigInt(Math.max(0, 100 - discountPct));
+    return numerator / 10000000n;
+}
+function formatUsdcAmount(amount) {
+    const abs = amount < 0n ? -amount : amount;
+    const sign = amount < 0n ? "-" : "";
+    const whole = abs / 1000000n;
+    const frac = (abs % 1000000n).toString().padStart(6, "0");
+    return `${sign}${whole}.${frac}`;
+}
+function formatPrice(price) {
+    const whole = price / 1000000000n;
+    const frac = (price % 1000000000n).toString().padStart(9, "0");
+    return `${whole}.${frac}`;
+}
+function calcHealth(collateral, size, mmrBps) {
+    if (mmrBps <= 0) {
+        throw new Error("calcHealth: mmrBps must be positive");
+    }
+    const threshold = (size * BigInt(mmrBps)) / 10000n;
+    if (threshold === 0n)
+        return (1n << 64n) - 1n;
+    return (collateral * 1000n) / threshold;
+}

package/dist/utils/tokenProgram.d.ts

@@ -0,0 +1,2 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+export declare function probeTokenProgram(connection: Connection, mint: PublicKey): Promise<PublicKey>;

package/dist/utils/tokenProgram.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeTokenProgram = probeTokenProgram;
+const spl_token_1 = require("@solana/spl-token");
+async function probeTokenProgram(connection, mint) {
+    const info = await connection.getAccountInfo(mint);
+    if (!info) {
+        throw new Error(`probeTokenProgram: mint ${mint.toBase58()} not found`);
+    }
+    if (info.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID))
+        return spl_token_1.TOKEN_2022_PROGRAM_ID;
+    if (info.owner.equals(spl_token_1.TOKEN_PROGRAM_ID))
+        return spl_token_1.TOKEN_PROGRAM_ID;
+    throw new Error(`probeTokenProgram: mint ${mint.toBase58()} is owned by ${info.owner.toBase58()}, ` +
+        `not a recognized token program`);
+}

package/dist/utils/transaction.d.ts

@@ -0,0 +1,2 @@
+import { TransactionInstruction, VersionedTransaction, PublicKey, AddressLookupTableAccount } from "@solana/web3.js";
+export declare function buildVersionedTransaction(instructions: TransactionInstruction[], payer: PublicKey, blockhash: string, lookupTables?: AddressLookupTableAccount[]): VersionedTransaction;

package/dist/utils/transaction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVersionedTransaction = buildVersionedTransaction;
+const web3_js_1 = require("@solana/web3.js");
+function buildVersionedTransaction(instructions, payer, blockhash, lookupTables) {
+    const message = new web3_js_1.TransactionMessage({
+        payerKey: payer,
+        recentBlockhash: blockhash,
+        instructions,
+    }).compileToV0Message(lookupTables);
+    return new web3_js_1.VersionedTransaction(message);
+}

package/dist/utils/version.d.ts

@@ -0,0 +1,11 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+export type MarketStateDataLayout = "unknown" | "legacy_tiny" | "v1_460" | "v2_476" | "v2_adl_surface" | "v3_511";
+export declare function detectProgramVersion(connection: Connection, marketStatePda: PublicKey): Promise<MarketStateDataLayout>;
+export declare const PROGRAM_IDS_V4: {
+    readonly POOL_PROGRAM: "Acme8JzWrvVqGJz7nTKVsLYisN6MtP83nrs4fVAeXJsN";
+    readonly PERP_ENGINE: "6QrsMTMEu9rsLpyxQgRdvQsWoPgHGY9npNNiwTtXsbdc";
+    readonly ORACLE_ADAPTER: "6fsnWa9tcKcPiuQgdUbTMsiwUr43MNoxa1FECPFrvSpd";
+    readonly PRICE_FEED: "Dgorf5LPiMttdTxWcrsiA2j94kWKw55gJLRJm8P4E1Hn";
+    readonly FEE_DISTRIBUTOR: "CHTpVtZQboxjM6N9xk1RR29jZyWqFNV77cmQNJ18RNNL";
+    readonly STAKING_PROGRAM: "35HddZHf84u6DeyLoZL3Z3a8pZ59594xu1aizj7VrAGR";
+};

package/dist/utils/version.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROGRAM_IDS_V4 = void 0;
+exports.detectProgramVersion = detectProgramVersion;
+async function detectProgramVersion(connection, marketStatePda) {
+    const info = await connection.getAccountInfo(marketStatePda);
+    if (!info)
+        return "unknown";
+    const len = info.data.length;
+    if (len <= 256)
+        return "legacy_tiny";
+    if (len === 511)
+        return "v3_511";
+    if (len === 476)
+        return "v2_476";
+    if (len === 460)
+        return "v1_460";
+    if (len >= 484 && len <= 510)
+        return "v2_adl_surface";
+    return "unknown";
+}
+exports.PROGRAM_IDS_V4 = {
+    POOL_PROGRAM: "Acme8JzWrvVqGJz7nTKVsLYisN6MtP83nrs4fVAeXJsN",
+    PERP_ENGINE: "6QrsMTMEu9rsLpyxQgRdvQsWoPgHGY9npNNiwTtXsbdc",
+    ORACLE_ADAPTER: "6fsnWa9tcKcPiuQgdUbTMsiwUr43MNoxa1FECPFrvSpd",
+    PRICE_FEED: "Dgorf5LPiMttdTxWcrsiA2j94kWKw55gJLRJm8P4E1Hn",
+    FEE_DISTRIBUTOR: "CHTpVtZQboxjM6N9xk1RR29jZyWqFNV77cmQNJ18RNNL",
+    STAKING_PROGRAM: "35HddZHf84u6DeyLoZL3Z3a8pZ59594xu1aizj7VrAGR",
+};