@parqxchange/sdk 0.1.0

package/dist/auth/tradingKey.d.ts

@@ -0,0 +1,27 @@
+import { Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { Program } from "@coral-xyz/anchor";
+export declare function buildRegisterTradingKeyIx(opts: {
+    wallet: PublicKey;
+    delegate: PublicKey;
+    expiresAt: bigint;
+    program: Program;
+    perpEngineId: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function buildRevokeTradingKeyIx(opts: {
+    wallet: PublicKey;
+    program: Program;
+    perpEngineId: PublicKey;
+}): Promise<TransactionInstruction>;
+export declare function registerTradingKey(opts: {
+    wallet: Keypair;
+    delegate: PublicKey;
+    expiresAt: bigint;
+    program: Program;
+    perpEngineId: PublicKey;
+}): Promise<string>;
+export declare function revokeTradingKey(opts: {
+    wallet: Keypair;
+    program: Program;
+    perpEngineId: PublicKey;
+}): Promise<string>;
+export declare function loadTradingKeypair(path: string): Keypair;

package/dist/auth/tradingKey.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRegisterTradingKeyIx = buildRegisterTradingKeyIx;
+exports.buildRevokeTradingKeyIx = buildRevokeTradingKeyIx;
+exports.registerTradingKey = registerTradingKey;
+exports.revokeTradingKey = revokeTradingKey;
+exports.loadTradingKeypair = loadTradingKeypair;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const pda_1 = require("../utils/pda");
+const SYSTEM_PROGRAM = new web3_js_1.PublicKey("11111111111111111111111111111111");
+async function buildRegisterTradingKeyIx(opts) {
+    const [tradingKeyPda] = (0, pda_1.tradingKeyPDA)(opts.wallet, opts.perpEngineId);
+    return opts.program.methods
+        .registerTradingKey(opts.delegate, new anchor_1.BN(opts.expiresAt.toString()))
+        .accounts({
+        tradingKey: tradingKeyPda,
+        wallet: opts.wallet,
+        systemProgram: SYSTEM_PROGRAM,
+    })
+        .instruction();
+}
+async function buildRevokeTradingKeyIx(opts) {
+    const [tradingKeyPda] = (0, pda_1.tradingKeyPDA)(opts.wallet, opts.perpEngineId);
+    return opts.program.methods
+        .revokeTradingKey()
+        .accounts({ tradingKey: tradingKeyPda, wallet: opts.wallet })
+        .instruction();
+}
+async function registerTradingKey(opts) {
+    const [tradingKeyPda] = (0, pda_1.tradingKeyPDA)(opts.wallet.publicKey, opts.perpEngineId);
+    return opts.program.methods
+        .registerTradingKey(opts.delegate, new anchor_1.BN(opts.expiresAt.toString()))
+        .accounts({
+        tradingKey: tradingKeyPda,
+        wallet: opts.wallet.publicKey,
+        systemProgram: SYSTEM_PROGRAM,
+    })
+        .signers([opts.wallet])
+        .rpc();
+}
+async function revokeTradingKey(opts) {
+    const [tradingKeyPda] = (0, pda_1.tradingKeyPDA)(opts.wallet.publicKey, opts.perpEngineId);
+    return opts.program.methods
+        .revokeTradingKey()
+        .accounts({
+        tradingKey: tradingKeyPda,
+        wallet: opts.wallet.publicKey,
+    })
+        .signers([opts.wallet])
+        .rpc();
+}
+function loadTradingKeypair(path) {
+    if (typeof globalThis.process === "undefined") {
+        throw new Error("loadTradingKeypair is Node.js only — use Keypair.fromSecretKey() in browsers");
+    }
+    const fs = require("fs");
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error("loadTradingKeypair: invalid key file (JSON parse failed)");
+    }
+    if (!Array.isArray(raw) ||
+        raw.length !== 64 ||
+        !raw.every((n) => Number.isInteger(n) && n >= 0 && n <= 255)) {
+        throw new Error("loadTradingKeypair: key file must be a JSON array of 64 byte values");
+    }
+    return web3_js_1.Keypair.fromSecretKey(Uint8Array.from(raw));
+}

package/dist/decode/index.d.ts

@@ -0,0 +1,39 @@
+import type { Position, MarketState, PoolState, Order, OrderNonce, TradingKey, ReferralConfig, ReferralCode, TraderReferral, AffiliateReward, FeePool, StakingPool, StakePosition, PayoutQueueEntry, UserQueueClaims } from "../types";
+export declare function sha256Disc(name: string): Buffer;
+export declare const DISCRIMINATORS: {
+    readonly Position: Buffer<ArrayBufferLike>;
+    readonly MarketState: Buffer<ArrayBufferLike>;
+    readonly PoolState: Buffer<ArrayBufferLike>;
+    readonly Order: Buffer<ArrayBufferLike>;
+    readonly OrderNonce: Buffer<ArrayBufferLike>;
+    readonly TradingKey: Buffer<ArrayBufferLike>;
+    readonly ReferralConfig: Buffer<ArrayBufferLike>;
+    readonly ReferralCode: Buffer<ArrayBufferLike>;
+    readonly TraderReferral: Buffer<ArrayBufferLike>;
+    readonly AffiliateReward: Buffer<ArrayBufferLike>;
+    readonly FeePool: Buffer<ArrayBufferLike>;
+    readonly StakingPool: Buffer<ArrayBufferLike>;
+    readonly StakePosition: Buffer<ArrayBufferLike>;
+    readonly PayoutQueueEntry: Buffer<ArrayBufferLike>;
+    readonly UserQueueClaims: Buffer<ArrayBufferLike>;
+};
+export declare class DecoderError extends Error {
+    constructor(message: string);
+}
+export declare function decodePosition(data: Buffer | Uint8Array): Position;
+export declare function decodeMarketState(data: Buffer | Uint8Array): MarketState;
+export declare function decodePoolState(data: Buffer | Uint8Array): PoolState;
+export declare function decodeOrder(data: Buffer | Uint8Array): Order;
+export declare function decodeOrderNonce(data: Buffer | Uint8Array): OrderNonce;
+export declare function decodeTradingKey(data: Buffer | Uint8Array): TradingKey;
+export declare function decodeReferralConfig(data: Buffer | Uint8Array): ReferralConfig;
+export declare function decodeReferralCode(data: Buffer | Uint8Array): ReferralCode;
+export declare function decodeTraderReferral(data: Buffer | Uint8Array): TraderReferral;
+export declare function decodeAffiliateReward(data: Buffer | Uint8Array): AffiliateReward;
+export declare function decodeFeePool(data: Buffer | Uint8Array): FeePool;
+export declare function decodeStakingPool(data: Buffer | Uint8Array): StakingPool;
+export declare function decodeStakePosition(data: Buffer | Uint8Array): StakePosition;
+export declare function decodePayoutQueueEntry(data: Buffer | Uint8Array): PayoutQueueEntry;
+export declare function decodeUserQueueClaims(data: Buffer | Uint8Array): UserQueueClaims;
+export type AccountTypeName = "Position" | "MarketState" | "Order" | "OrderNonce" | "PoolState" | "TradingKey" | "ReferralConfig" | "ReferralCode" | "TraderReferral" | "AffiliateReward" | "FeePool" | "StakingPool" | "StakePosition" | "PayoutQueueEntry" | "UserQueueClaims";
+export declare function identifyAccountType(data: Buffer | Uint8Array): AccountTypeName | null;

package/dist/decode/index.js

@@ -0,0 +1,445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoderError = exports.DISCRIMINATORS = void 0;
+exports.sha256Disc = sha256Disc;
+exports.decodePosition = decodePosition;
+exports.decodeMarketState = decodeMarketState;
+exports.decodePoolState = decodePoolState;
+exports.decodeOrder = decodeOrder;
+exports.decodeOrderNonce = decodeOrderNonce;
+exports.decodeTradingKey = decodeTradingKey;
+exports.decodeReferralConfig = decodeReferralConfig;
+exports.decodeReferralCode = decodeReferralCode;
+exports.decodeTraderReferral = decodeTraderReferral;
+exports.decodeAffiliateReward = decodeAffiliateReward;
+exports.decodeFeePool = decodeFeePool;
+exports.decodeStakingPool = decodeStakingPool;
+exports.decodeStakePosition = decodeStakePosition;
+exports.decodePayoutQueueEntry = decodePayoutQueueEntry;
+exports.decodeUserQueueClaims = decodeUserQueueClaims;
+exports.identifyAccountType = identifyAccountType;
+const node_crypto_1 = require("node:crypto");
+const web3_js_1 = require("@solana/web3.js");
+function sha256Disc(name) {
+    const hash = (0, node_crypto_1.createHash)("sha256").update(`account:${name}`).digest();
+    return hash.subarray(0, 8);
+}
+exports.DISCRIMINATORS = {
+    Position: sha256Disc("Position"),
+    MarketState: sha256Disc("MarketState"),
+    PoolState: sha256Disc("PoolState"),
+    Order: sha256Disc("Order"),
+    OrderNonce: sha256Disc("OrderNonce"),
+    TradingKey: sha256Disc("TradingKey"),
+    ReferralConfig: sha256Disc("ReferralConfig"),
+    ReferralCode: sha256Disc("ReferralCode"),
+    TraderReferral: sha256Disc("TraderReferral"),
+    AffiliateReward: sha256Disc("AffiliateReward"),
+    FeePool: sha256Disc("FeePool"),
+    StakingPool: sha256Disc("StakingPool"),
+    StakePosition: sha256Disc("StakePosition"),
+    PayoutQueueEntry: sha256Disc("PayoutQueueEntry"),
+    UserQueueClaims: sha256Disc("UserQueueClaims"),
+};
+class DecoderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DecoderError";
+    }
+}
+exports.DecoderError = DecoderError;
+function checkDisc(data, expected, typeName) {
+    if (data.byteLength < 8) {
+        throw new DecoderError(`${typeName}: data too short for discriminator (${data.byteLength} < 8)`);
+    }
+    for (let i = 0; i < 8; i++) {
+        if (data[i] !== expected[i]) {
+            throw new DecoderError(`${typeName}: discriminator mismatch at byte ${i} ` +
+                `(got 0x${data[i].toString(16).padStart(2, "0")}, ` +
+                `expected 0x${expected[i].toString(16).padStart(2, "0")})`);
+        }
+    }
+}
+function checkLen(data, expected, typeName) {
+    if (data.byteLength !== expected) {
+        throw new DecoderError(`${typeName}: expected ${expected} bytes, got ${data.byteLength}`);
+    }
+}
+function readU8(view, offset) {
+    return view.getUint8(offset);
+}
+function readU16LE(view, offset) {
+    return view.getUint16(offset, true);
+}
+function readU32LE(view, offset) {
+    return view.getUint32(offset, true);
+}
+function readU64LE(view, offset) {
+    return view.getBigUint64(offset, true);
+}
+function readI64LE(view, offset) {
+    return view.getBigInt64(offset, true);
+}
+function readU128LE(view, offset) {
+    const lo = view.getBigUint64(offset, true);
+    const hi = view.getBigUint64(offset + 8, true);
+    return lo | (hi << 64n);
+}
+function readI128LE(view, offset) {
+    const lo = view.getBigUint64(offset, true);
+    const hi = view.getBigInt64(offset + 8, true);
+    return lo | (hi << 64n);
+}
+function readPubkey(view, offset) {
+    const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, 32);
+    return new web3_js_1.PublicKey(bytes);
+}
+function readBytes(view, offset, len) {
+    return new Uint8Array(view.buffer.slice(view.byteOffset + offset, view.byteOffset + offset + len));
+}
+function readBool(view, offset) {
+    return view.getUint8(offset) !== 0;
+}
+function readSide(view, offset) {
+    const v = view.getUint8(offset);
+    if (v === 0)
+        return "long";
+    if (v === 1)
+        return "short";
+    throw new DecoderError(`invalid Side byte: ${v}`);
+}
+function readOrderType(view, offset) {
+    const v = view.getUint8(offset);
+    const map = [
+        "marketIncrease",
+        "limitIncrease",
+        "stopIncrease",
+        "marketDecrease",
+        "limitDecrease",
+        "stopLossDecrease",
+    ];
+    const result = map[v];
+    if (result === undefined) {
+        throw new DecoderError(`invalid OrderType byte: ${v}`);
+    }
+    return result;
+}
+function makeView(data) {
+    return new DataView(data.buffer, data.byteOffset, data.byteLength);
+}
+function decodePosition(data) {
+    checkDisc(data, exports.DISCRIMINATORS.Position, "Position");
+    checkLen(data, 154, "Position");
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        side: readSide(v, 72),
+        sizeUsdc: readU64LE(v, 73),
+        collateralUsdc: readU64LE(v, 81),
+        entryPrice: readU64LE(v, 89),
+        fundingIndexSnapshot: readI128LE(v, 97),
+        borrowingFactorSnapshot: readU128LE(v, 113),
+        reservedMaxPayout: readU64LE(v, 129),
+        collateralFromQueue: readU64LE(v, 137),
+        openedAt: readI64LE(v, 145),
+        bump: readU8(v, 153),
+    };
+}
+function decodeMarketState(data) {
+    checkDisc(data, exports.DISCRIMINATORS.MarketState, "MarketState");
+    if (data.length !== 460 && data.length !== 476 && data.length !== 511) {
+        checkLen(data, 511, "MarketState");
+    }
+    const v = makeView(data);
+    const base = {
+        marketId: readBytes(v, 8, 32),
+        longOi: readU64LE(v, 40),
+        shortOi: readU64LE(v, 48),
+        fundingIndex: readI128LE(v, 56),
+        lastFundingTs: readI64LE(v, 72),
+        maxLeverage: readU8(v, 80),
+        baseFeeBps: readU16LE(v, 81),
+        mmrBps: readU16LE(v, 83),
+        poolState: readPubkey(v, 85),
+        poolProgram: readPubkey(v, 117),
+        oracleProgram: readPubkey(v, 149),
+        treasury: readPubkey(v, 181),
+        stakingProgramId: readPubkey(v, 213),
+        engineAuthBump: readU8(v, 245),
+        isPaused: readBool(v, 246),
+        savedFundingFactorPerSecond: readI128LE(v, 247),
+        fundingIncreaseFactorPerSecond: readU64LE(v, 263),
+        fundingDecreaseFactorPerSecond: readU64LE(v, 271),
+        thresholdForStableFunding: readU64LE(v, 279),
+        thresholdForDecreaseFunding: readU64LE(v, 287),
+        minFundingFactorPerSecond: readU64LE(v, 295),
+        maxFundingFactorPerSecond: readU64LE(v, 303),
+        longCumulativeBorrowingFactor: readU128LE(v, 311),
+        shortCumulativeBorrowingFactor: readU128LE(v, 327),
+        lastBorrowingTs: readI64LE(v, 343),
+        borrowingFactor: readU64LE(v, 351),
+        optimalUsageFactor: readU64LE(v, 359),
+        aboveOptimalBorrowingFactor: readU64LE(v, 367),
+        longReservedUsdc: readU64LE(v, 375),
+        shortReservedUsdc: readU64LE(v, 383),
+        priceImpactFactor: readU64LE(v, 391),
+        maxPriceImpactBps: readU16LE(v, 399),
+        impactPoolUsdc: readU64LE(v, 401),
+        keeper: readPubkey(v, 409),
+        maxOiLong: readU64LE(v, 441),
+        maxOiShort: readU64LE(v, 449),
+        feeBpsFavorable: readU16LE(v, 457),
+        bump: readU8(v, 459),
+    };
+    if (data.length >= 476) {
+        const v2 = {
+            ...base,
+            offHoursMaxOiLong: readU64LE(v, 460),
+            offHoursMaxOiShort: readU64LE(v, 468),
+        };
+        if (data.length >= 511) {
+            return {
+                ...v2,
+                adlFrozen: readU8(v, 476),
+                adlTailTriggerUsdcRth: readU64LE(v, 477),
+                adlTailTriggerUsdcOff: readU64LE(v, 485),
+                adlTailMinAgeSecsRth: readU32LE(v, 493),
+                adlTailMinAgeSecsOff: readU32LE(v, 497),
+                adlHaircutBpsRth: readU16LE(v, 501),
+                adlHaircutBpsOff: readU16LE(v, 503),
+                adlMaxHaircutBps: readU16LE(v, 505),
+                adlMaxFeedDivergenceBps: readU16LE(v, 507),
+                initialMarginBps: readU16LE(v, 509),
+            };
+        }
+        return v2;
+    }
+    return base;
+}
+function decodePoolState(data) {
+    checkDisc(data, exports.DISCRIMINATORS.PoolState, "PoolState");
+    if (data.byteLength !== 240 && data.byteLength !== 252) {
+        throw new DecoderError(`PoolState: expected 240 or 252 bytes, got ${data.byteLength}`);
+    }
+    const v = makeView(data);
+    const hasAdl = data.byteLength >= 252;
+    return {
+        marketId: readBytes(v, 8, 32),
+        usdcVault: readPubkey(v, 40),
+        vaultAuthorityBump: readU8(v, 72),
+        lpMint: readPubkey(v, 73),
+        totalUsdc: readU64LE(v, 105),
+        reservedUsdc: readU64LE(v, 113),
+        cumulativeFees: readU64LE(v, 121),
+        engineAuth: readPubkey(v, 129),
+        engineAuthBump: readU8(v, 161),
+        admin: readPubkey(v, 162),
+        isPaused: readBool(v, 194),
+        reserveFactor: readU64LE(v, 195),
+        depositFeeBps: readU16LE(v, 203),
+        withdrawalFeeBps: readU16LE(v, 205),
+        sideBucket: readU64LE(v, 207),
+        queueHeadIdx: readU64LE(v, 215),
+        queueTailIdx: readU64LE(v, 223),
+        queueTotalOwed: readU64LE(v, 231),
+        bump: readU8(v, 239),
+        currentAdlEpoch: hasAdl ? readU32LE(v, 240) : 0,
+        lastAdlCutIdx: hasAdl ? readU64LE(v, 244) : 0n,
+    };
+}
+function decodeOrder(data) {
+    checkDisc(data, exports.DISCRIMINATORS.Order, "Order");
+    checkLen(data, 171, "Order");
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        orderType: readOrderType(v, 72),
+        side: readSide(v, 73),
+        sizeUsdc: readU64LE(v, 74),
+        collateralUsdc: readU64LE(v, 82),
+        triggerPrice: readU64LE(v, 90),
+        acceptablePrice: readU64LE(v, 98),
+        minOutputUsdc: readU64LE(v, 106),
+        referralCode: readBytes(v, 114, 32),
+        positionNonce: readU64LE(v, 146),
+        createdAt: readI64LE(v, 154),
+        nonce: readU64LE(v, 162),
+        bump: readU8(v, 170),
+    };
+}
+function decodeOrderNonce(data) {
+    checkDisc(data, exports.DISCRIMINATORS.OrderNonce, "OrderNonce");
+    checkLen(data, 49, "OrderNonce");
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        nonce: readU64LE(v, 40),
+        bump: readU8(v, 48),
+    };
+}
+function decodeTradingKey(data) {
+    checkDisc(data, exports.DISCRIMINATORS.TradingKey, "TradingKey");
+    checkLen(data, 81, "TradingKey");
+    const v = makeView(data);
+    return {
+        wallet: readPubkey(v, 8),
+        delegate: readPubkey(v, 40),
+        expiresAt: readI64LE(v, 72),
+        bump: readU8(v, 80),
+    };
+}
+function decodeReferralConfig(data) {
+    checkDisc(data, exports.DISCRIMINATORS.ReferralConfig, "ReferralConfig");
+    checkLen(data, 53, "ReferralConfig");
+    const v = makeView(data);
+    function readTier(offset) {
+        return {
+            totalRebateBps: readU16LE(v, offset),
+            discountSharePct: readU8(v, offset + 2),
+        };
+    }
+    return {
+        admin: readPubkey(v, 8),
+        tiers: [
+            readTier(40),
+            readTier(43),
+            readTier(46),
+            readTier(49),
+        ],
+        bump: readU8(v, 52),
+    };
+}
+function decodeReferralCode(data) {
+    checkDisc(data, exports.DISCRIMINATORS.ReferralCode, "ReferralCode");
+    checkLen(data, 74, "ReferralCode");
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        code: readBytes(v, 40, 32),
+        tier: readU8(v, 72),
+        bump: readU8(v, 73),
+    };
+}
+function decodeTraderReferral(data) {
+    checkDisc(data, exports.DISCRIMINATORS.TraderReferral, "TraderReferral");
+    checkLen(data, 73, "TraderReferral");
+    const v = makeView(data);
+    return {
+        trader: readPubkey(v, 8),
+        code: readBytes(v, 40, 32),
+        bump: readU8(v, 72),
+    };
+}
+function decodeAffiliateReward(data) {
+    checkDisc(data, exports.DISCRIMINATORS.AffiliateReward, "AffiliateReward");
+    checkLen(data, 81, "AffiliateReward");
+    const v = makeView(data);
+    return {
+        affiliate: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        accruedUsdc: readU64LE(v, 72),
+        bump: readU8(v, 80),
+    };
+}
+function decodeFeePool(data) {
+    checkDisc(data, exports.DISCRIMINATORS.FeePool, "FeePool");
+    checkLen(data, 215, "FeePool");
+    const v = makeView(data);
+    return {
+        admin: readPubkey(v, 8),
+        perpEngine: readPubkey(v, 40),
+        usdcAccount: readPubkey(v, 72),
+        stakingReward: readPubkey(v, 104),
+        treasury: readPubkey(v, 136),
+        referralReserve: readPubkey(v, 168),
+        stakerSplitBps: readU16LE(v, 200),
+        treasurySplitBps: readU16LE(v, 202),
+        referralSplitBps: readU16LE(v, 204),
+        totalDistributed: readU64LE(v, 206),
+        bump: readU8(v, 214),
+    };
+}
+function decodeStakingPool(data) {
+    checkDisc(data, exports.DISCRIMINATORS.StakingPool, "StakingPool");
+    checkLen(data, 282, "StakingPool");
+    const v = makeView(data);
+    return {
+        admin: readPubkey(v, 8),
+        tokenMint: readPubkey(v, 40),
+        stakedVault: readPubkey(v, 72),
+        rewardSource: readU8(v, 104),
+        rewardMint: readPubkey(v, 105),
+        rewardVault: readPubkey(v, 137),
+        rewardUsdc: readPubkey(v, 169),
+        totalWeightedStake: readU128LE(v, 201),
+        rewardIndex: readU128LE(v, 217),
+        totalRewardsDistributed: readU64LE(v, 233),
+        totalAllocation: readU64LE(v, 241),
+        startTs: readI64LE(v, 249),
+        endTs: readI64LE(v, 257),
+        emittedSoFar: readU64LE(v, 265),
+        lastUpdateTs: readI64LE(v, 273),
+        bump: readU8(v, 281),
+    };
+}
+function decodeStakePosition(data) {
+    checkDisc(data, exports.DISCRIMINATORS.StakePosition, "StakePosition");
+    checkLen(data, 122, "StakePosition");
+    const v = makeView(data);
+    return {
+        pool: readPubkey(v, 8),
+        owner: readPubkey(v, 40),
+        amount: readU64LE(v, 72),
+        lockupTier: readU8(v, 80),
+        lockupExpiry: readI64LE(v, 81),
+        weightedAmount: readU64LE(v, 89),
+        rewardIndexSnap: readU128LE(v, 97),
+        accruedReward: readU64LE(v, 113),
+        bump: readU8(v, 121),
+    };
+}
+function decodePayoutQueueEntry(data) {
+    checkDisc(data, exports.DISCRIMINATORS.PayoutQueueEntry, "PayoutQueueEntry");
+    checkLen(data, 98, "PayoutQueueEntry");
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        idx: readU64LE(v, 72),
+        amount: readU64LE(v, 80),
+        enqueuedAt: readI64LE(v, 88),
+        status: readU8(v, 96),
+        bump: readU8(v, 97),
+    };
+}
+function decodeUserQueueClaims(data) {
+    checkDisc(data, exports.DISCRIMINATORS.UserQueueClaims, "UserQueueClaims");
+    checkLen(data, 97, "UserQueueClaims");
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        unpaidOwed: readU64LE(v, 72),
+        collateralDrawn: readU64LE(v, 80),
+        phantomUnpaidOwed: readU64LE(v, 88),
+        bump: readU8(v, 96),
+    };
+}
+function identifyAccountType(data) {
+    if (data.byteLength < 8)
+        return null;
+    for (const [name, disc] of Object.entries(exports.DISCRIMINATORS)) {
+        let match = true;
+        for (let i = 0; i < 8; i++) {
+            if (data[i] !== disc[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return name;
+    }
+    return null;
+}

package/dist/events/decoder.d.ts

@@ -0,0 +1,60 @@
+import type { PositionOpenedEvent, PositionClosedEvent, LiquidatedEvent, BadDebtEvent, FundingUpdatedEvent, EnqueuedEvent, HarvestedEvent, EntryVoidedEvent, SideBucketCreditedEvent, QueueDrainedEvent, PhantomCreditDrainedEvent, FeesSweptEvent, FeesDistributedEvent, TreasuryWithdrawalEvent, StakedEvent, UnstakedEvent, RewardClaimedEvent, RewardIndexUpdatedEvent, CompoundedRewardEvent } from "../types";
+export type DecodedEvent = {
+    type: "positionOpened";
+    data: PositionOpenedEvent;
+} | {
+    type: "positionClosed";
+    data: PositionClosedEvent;
+} | {
+    type: "liquidated";
+    data: LiquidatedEvent;
+} | {
+    type: "badDebt";
+    data: BadDebtEvent;
+} | {
+    type: "fundingUpdated";
+    data: FundingUpdatedEvent;
+} | {
+    type: "enqueued";
+    data: EnqueuedEvent;
+} | {
+    type: "harvested";
+    data: HarvestedEvent;
+} | {
+    type: "entryVoided";
+    data: EntryVoidedEvent;
+} | {
+    type: "sideBucketCredited";
+    data: SideBucketCreditedEvent;
+} | {
+    type: "queueDrained";
+    data: QueueDrainedEvent;
+} | {
+    type: "phantomCreditDrained";
+    data: PhantomCreditDrainedEvent;
+} | {
+    type: "feesSwept";
+    data: FeesSweptEvent;
+} | {
+    type: "feesDistributed";
+    data: FeesDistributedEvent;
+} | {
+    type: "treasuryWithdrawal";
+    data: TreasuryWithdrawalEvent;
+} | {
+    type: "staked";
+    data: StakedEvent;
+} | {
+    type: "unstaked";
+    data: UnstakedEvent;
+} | {
+    type: "rewardClaimed";
+    data: RewardClaimedEvent;
+} | {
+    type: "rewardIndexUpdated";
+    data: RewardIndexUpdatedEvent;
+} | {
+    type: "compoundedReward";
+    data: CompoundedRewardEvent;
+};
+export declare function decodeAnchorEvent(base64Data: string): DecodedEvent | null;