@parqxchange/sdk 0.1.0

package/dist/events/decoder.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAnchorEvent = decodeAnchorEvent;
+const web3_js_1 = require("@solana/web3.js");
+const node_crypto_1 = require("node:crypto");
+function sha256Disc(name) {
+    return (0, node_crypto_1.createHash)("sha256").update(name).digest().subarray(0, 8);
+}
+const EVENT_DISCS = {
+    PositionOpened: sha256Disc("event:PositionOpened"),
+    PositionClosed: sha256Disc("event:PositionClosed"),
+    Liquidated: sha256Disc("event:Liquidated"),
+    BadDebt: sha256Disc("event:BadDebt"),
+    FundingUpdated: sha256Disc("event:FundingUpdated"),
+    Enqueued: sha256Disc("event:Enqueued"),
+    Harvested: sha256Disc("event:Harvested"),
+    EntryVoided: sha256Disc("event:EntryVoided"),
+    SideBucketCredited: sha256Disc("event:SideBucketCredited"),
+    QueueDrained: sha256Disc("event:QueueDrained"),
+    PhantomCreditDrained: sha256Disc("event:PhantomCreditDrained"),
+    FeesSwept: sha256Disc("event:FeesSwept"),
+    FeesDistributed: sha256Disc("event:FeesDistributed"),
+    TreasuryWithdrawal: sha256Disc("event:TreasuryWithdrawal"),
+    Staked: sha256Disc("event:Staked"),
+    Unstaked: sha256Disc("event:Unstaked"),
+    RewardClaimed: sha256Disc("event:RewardClaimed"),
+    RewardIndexUpdated: sha256Disc("event:RewardIndexUpdated"),
+    CompoundedReward: sha256Disc("event:CompoundedReward"),
+};
+function discMatches(data, disc) {
+    for (let i = 0; i < 8; i++) {
+        if (data[i] !== disc[i])
+            return false;
+    }
+    return true;
+}
+function makeView(data) {
+    return new DataView(data.buffer, data.byteOffset, data.byteLength);
+}
+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 readU64LE(view, offset) {
+    return view.getBigUint64(offset, true);
+}
+function readU128LE(view, offset) {
+    const lo = view.getBigUint64(offset, true);
+    const hi = view.getBigUint64(offset + 8, true);
+    return lo + (hi << 64n);
+}
+function readI64LE(view, offset) {
+    return view.getBigInt64(offset, true);
+}
+function readI128LE(view, offset) {
+    const lo = view.getBigUint64(offset, true);
+    const hi = view.getBigInt64(offset + 8, true);
+    return lo | (hi << 64n);
+}
+function readU8(view, offset) {
+    return view.getUint8(offset);
+}
+function readSide(view, offset) {
+    const v = view.getUint8(offset);
+    if (v === 0)
+        return "long";
+    if (v === 1)
+        return "short";
+    throw new Error(`invalid Side byte: ${v}`);
+}
+function decodePositionOpened(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        side: readSide(v, 72),
+        sizeUsdc: readU64LE(v, 73),
+        collateral: readU64LE(v, 81),
+        entryPrice: readU64LE(v, 89),
+    };
+}
+function decodePositionClosed(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        pnl: readI64LE(v, 72),
+        netReturn: readU64LE(v, 80),
+        exitPrice: readU64LE(v, 88),
+    };
+}
+function decodeLiquidated(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        badDebt: readU64LE(v, 72),
+    };
+}
+function decodeBadDebt(data) {
+    const v = makeView(data);
+    return {
+        marketId: readBytes(v, 8, 32),
+        amount: readU64LE(v, 40),
+    };
+}
+function decodeFundingUpdated(data) {
+    const v = makeView(data);
+    return {
+        marketId: readBytes(v, 8, 32),
+        fundingIndex: readI128LE(v, 40),
+        longOi: readU64LE(v, 56),
+        shortOi: readU64LE(v, 64),
+    };
+}
+function decodeEnqueued(data) {
+    const v = makeView(data);
+    return {
+        idx: readU64LE(v, 8),
+        owner: readPubkey(v, 16),
+        marketId: readBytes(v, 48, 32),
+        amount: readU64LE(v, 80),
+        queueTotalOwedAfter: readU64LE(v, 88),
+    };
+}
+function decodeHarvested(data) {
+    const v = makeView(data);
+    return {
+        idx: readU64LE(v, 8),
+        owner: readPubkey(v, 16),
+        marketId: readBytes(v, 48, 32),
+        amount: readU64LE(v, 80),
+    };
+}
+function decodeEntryVoided(data) {
+    const v = makeView(data);
+    return {
+        idx: readU64LE(v, 8),
+        owner: readPubkey(v, 16),
+        marketId: readBytes(v, 48, 32),
+        amount: readU64LE(v, 80),
+        reason: readU8(v, 88),
+    };
+}
+function decodeSideBucketCredited(data) {
+    const v = makeView(data);
+    return {
+        marketId: readBytes(v, 8, 32),
+        amount: readU64LE(v, 40),
+        source: readU8(v, 48),
+    };
+}
+function decodeQueueDrained(data) {
+    const v = makeView(data);
+    return {
+        marketId: readBytes(v, 8, 32),
+        residualToTreasury: readU64LE(v, 40),
+    };
+}
+function decodePhantomCreditDrained(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        marketId: readBytes(v, 40, 32),
+        amount: readU64LE(v, 72),
+    };
+}
+function decodeFeesSwept(data) {
+    const v = makeView(data);
+    return {
+        marketId: readBytes(v, 8, 32),
+        amount: readU64LE(v, 40),
+    };
+}
+function decodeFeesDistributed(data) {
+    const v = makeView(data);
+    return {
+        total: readU64LE(v, 8),
+        stakerShare: readU64LE(v, 16),
+        treasuryShare: readU64LE(v, 24),
+        referralShare: readU64LE(v, 32),
+    };
+}
+function decodeTreasuryWithdrawal(data) {
+    const v = makeView(data);
+    return {
+        amount: readU64LE(v, 8),
+        destination: readPubkey(v, 16),
+    };
+}
+function decodeStaked(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        amount: readU64LE(v, 40),
+        tier: readU8(v, 48),
+        lockupExpiry: readI64LE(v, 49),
+        weightedAmount: readU64LE(v, 57),
+    };
+}
+function decodeUnstaked(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        amount: readU64LE(v, 40),
+    };
+}
+function decodeRewardClaimed(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        amountUsdc: readU64LE(v, 40),
+    };
+}
+function decodeRewardIndexUpdated(data) {
+    if (data.length < 32) {
+        throw new Error(`RewardIndexUpdated: truncated payload (${data.length} < 32)`);
+    }
+    const v = makeView(data);
+    return {
+        rewardIndex: readU128LE(v, 8),
+        newRewards: readU64LE(v, 24),
+    };
+}
+function decodeCompoundedReward(data) {
+    const v = makeView(data);
+    return {
+        owner: readPubkey(v, 8),
+        amount: readU64LE(v, 40),
+        tier: readU8(v, 48),
+    };
+}
+function tryDecodePayload(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return null;
+    }
+}
+function decodeAnchorEvent(base64Data) {
+    let raw;
+    try {
+        raw = Buffer.from(base64Data, "base64");
+    }
+    catch {
+        return null;
+    }
+    if (raw.length < 8)
+        return null;
+    if (discMatches(raw, EVENT_DISCS.PositionOpened)) {
+        const data = tryDecodePayload(() => decodePositionOpened(raw));
+        if (data)
+            return { type: "positionOpened", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.PositionClosed)) {
+        const data = tryDecodePayload(() => decodePositionClosed(raw));
+        if (data)
+            return { type: "positionClosed", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.Liquidated)) {
+        const data = tryDecodePayload(() => decodeLiquidated(raw));
+        if (data)
+            return { type: "liquidated", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.BadDebt)) {
+        const data = tryDecodePayload(() => decodeBadDebt(raw));
+        if (data)
+            return { type: "badDebt", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.FundingUpdated)) {
+        const data = tryDecodePayload(() => decodeFundingUpdated(raw));
+        if (data)
+            return { type: "fundingUpdated", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.Enqueued)) {
+        const data = tryDecodePayload(() => decodeEnqueued(raw));
+        if (data)
+            return { type: "enqueued", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.Harvested)) {
+        const data = tryDecodePayload(() => decodeHarvested(raw));
+        if (data)
+            return { type: "harvested", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.EntryVoided)) {
+        const data = tryDecodePayload(() => decodeEntryVoided(raw));
+        if (data)
+            return { type: "entryVoided", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.SideBucketCredited)) {
+        const data = tryDecodePayload(() => decodeSideBucketCredited(raw));
+        if (data)
+            return { type: "sideBucketCredited", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.QueueDrained)) {
+        const data = tryDecodePayload(() => decodeQueueDrained(raw));
+        if (data)
+            return { type: "queueDrained", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.PhantomCreditDrained)) {
+        const data = tryDecodePayload(() => decodePhantomCreditDrained(raw));
+        if (data)
+            return { type: "phantomCreditDrained", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.FeesSwept)) {
+        const data = tryDecodePayload(() => decodeFeesSwept(raw));
+        if (data)
+            return { type: "feesSwept", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.FeesDistributed)) {
+        const data = tryDecodePayload(() => decodeFeesDistributed(raw));
+        if (data)
+            return { type: "feesDistributed", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.TreasuryWithdrawal)) {
+        const data = tryDecodePayload(() => decodeTreasuryWithdrawal(raw));
+        if (data)
+            return { type: "treasuryWithdrawal", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.Staked)) {
+        const data = tryDecodePayload(() => decodeStaked(raw));
+        if (data)
+            return { type: "staked", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.Unstaked)) {
+        const data = tryDecodePayload(() => decodeUnstaked(raw));
+        if (data)
+            return { type: "unstaked", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.RewardClaimed)) {
+        const data = tryDecodePayload(() => decodeRewardClaimed(raw));
+        if (data)
+            return { type: "rewardClaimed", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.RewardIndexUpdated)) {
+        const data = tryDecodePayload(() => decodeRewardIndexUpdated(raw));
+        if (data)
+            return { type: "rewardIndexUpdated", data };
+        return null;
+    }
+    if (discMatches(raw, EVENT_DISCS.CompoundedReward)) {
+        const data = tryDecodePayload(() => decodeCompoundedReward(raw));
+        if (data)
+            return { type: "compoundedReward", data };
+        return null;
+    }
+    return null;
+}

package/dist/events/emitter.d.ts

@@ -0,0 +1,49 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import EventEmitter from "events";
+import type { Position, MarketState, Order, PositionOpenedEvent, PositionClosedEvent, LiquidatedEvent, BadDebtEvent, FundingUpdatedEvent, EnqueuedEvent, HarvestedEvent, EntryVoidedEvent, SideBucketCreditedEvent, QueueDrainedEvent, PhantomCreditDrainedEvent, FeesSweptEvent, FeesDistributedEvent, TreasuryWithdrawalEvent, StakedEvent, UnstakedEvent, RewardClaimedEvent, RewardIndexUpdatedEvent, CompoundedRewardEvent } from "../types";
+export type ParquetEventType = "positionOpened" | "positionClosed" | "liquidated" | "badDebt" | "fundingUpdated" | "enqueued" | "harvested" | "entryVoided" | "sideBucketCredited" | "queueDrained" | "phantomCreditDrained" | "feesSwept" | "feesDistributed" | "treasuryWithdrawal" | "staked" | "unstaked" | "rewardClaimed" | "rewardIndexUpdated" | "compoundedReward" | "positionChanged" | "marketStateChanged" | "orderChanged";
+export interface ParquetEventEmitterEvents {
+    positionOpened: (data: PositionOpenedEvent) => void;
+    positionClosed: (data: PositionClosedEvent) => void;
+    liquidated: (data: LiquidatedEvent) => void;
+    badDebt: (data: BadDebtEvent) => void;
+    fundingUpdated: (data: FundingUpdatedEvent) => void;
+    enqueued: (data: EnqueuedEvent) => void;
+    harvested: (data: HarvestedEvent) => void;
+    entryVoided: (data: EntryVoidedEvent) => void;
+    sideBucketCredited: (data: SideBucketCreditedEvent) => void;
+    queueDrained: (data: QueueDrainedEvent) => void;
+    phantomCreditDrained: (data: PhantomCreditDrainedEvent) => void;
+    feesSwept: (data: FeesSweptEvent) => void;
+    feesDistributed: (data: FeesDistributedEvent) => void;
+    treasuryWithdrawal: (data: TreasuryWithdrawalEvent) => void;
+    staked: (data: StakedEvent) => void;
+    unstaked: (data: UnstakedEvent) => void;
+    rewardClaimed: (data: RewardClaimedEvent) => void;
+    rewardIndexUpdated: (data: RewardIndexUpdatedEvent) => void;
+    compoundedReward: (data: CompoundedRewardEvent) => void;
+    positionChanged: (payload: {
+        pubkey: PublicKey;
+        account: Position;
+    }) => void;
+    marketStateChanged: (payload: {
+        pubkey: PublicKey;
+        account: MarketState;
+    }) => void;
+    orderChanged: (payload: {
+        pubkey: PublicKey;
+        account: Order;
+    }) => void;
+    error: (err: Error) => void;
+}
+export declare class ParquetEventEmitter extends EventEmitter {
+    private readonly connection;
+    private readonly perpEngineId;
+    private logsSubId;
+    private accountSubId;
+    constructor(connection: Connection, perpEngineId: PublicKey);
+    startEvents(): void;
+    startAccounts(): void;
+    startAll(): void;
+    stop(): Promise<void>;
+}

package/dist/events/emitter.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParquetEventEmitter = void 0;
+const events_1 = __importDefault(require("events"));
+const decoder_1 = require("./decoder");
+const decode_1 = require("../decode");
+const LOG_PREFIX = "Program log: ";
+class ParquetEventEmitter extends events_1.default {
+    connection;
+    perpEngineId;
+    logsSubId = null;
+    accountSubId = null;
+    constructor(connection, perpEngineId) {
+        super();
+        this.connection = connection;
+        this.perpEngineId = perpEngineId;
+    }
+    startEvents() {
+        if (this.logsSubId !== null)
+            return;
+        this.logsSubId = this.connection.onLogs(this.perpEngineId, (logs, _ctx) => {
+            try {
+                for (const line of logs.logs) {
+                    if (!line.startsWith(LOG_PREFIX))
+                        continue;
+                    const base64 = line.slice(LOG_PREFIX.length);
+                    const decoded = (0, decoder_1.decodeAnchorEvent)(base64);
+                    if (decoded === null)
+                        continue;
+                    switch (decoded.type) {
+                        case "positionOpened":
+                            this.emit("positionOpened", decoded.data);
+                            break;
+                        case "positionClosed":
+                            this.emit("positionClosed", decoded.data);
+                            break;
+                        case "liquidated":
+                            this.emit("liquidated", decoded.data);
+                            break;
+                        case "badDebt":
+                            this.emit("badDebt", decoded.data);
+                            break;
+                        case "fundingUpdated":
+                            this.emit("fundingUpdated", decoded.data);
+                            break;
+                        case "enqueued":
+                            this.emit("enqueued", decoded.data);
+                            break;
+                        case "harvested":
+                            this.emit("harvested", decoded.data);
+                            break;
+                        case "entryVoided":
+                            this.emit("entryVoided", decoded.data);
+                            break;
+                        case "sideBucketCredited":
+                            this.emit("sideBucketCredited", decoded.data);
+                            break;
+                        case "queueDrained":
+                            this.emit("queueDrained", decoded.data);
+                            break;
+                        case "phantomCreditDrained":
+                            this.emit("phantomCreditDrained", decoded.data);
+                            break;
+                        case "feesSwept":
+                            this.emit("feesSwept", decoded.data);
+                            break;
+                        case "feesDistributed":
+                            this.emit("feesDistributed", decoded.data);
+                            break;
+                        case "treasuryWithdrawal":
+                            this.emit("treasuryWithdrawal", decoded.data);
+                            break;
+                        case "staked":
+                            this.emit("staked", decoded.data);
+                            break;
+                        case "unstaked":
+                            this.emit("unstaked", decoded.data);
+                            break;
+                        case "rewardClaimed":
+                            this.emit("rewardClaimed", decoded.data);
+                            break;
+                        case "rewardIndexUpdated":
+                            this.emit("rewardIndexUpdated", decoded.data);
+                            break;
+                        case "compoundedReward":
+                            this.emit("compoundedReward", decoded.data);
+                            break;
+                    }
+                }
+            }
+            catch (err) {
+                this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            }
+        }, "confirmed");
+    }
+    startAccounts() {
+        if (this.accountSubId !== null)
+            return;
+        this.accountSubId = this.connection.onProgramAccountChange(this.perpEngineId, (keyedAccountInfo, _ctx) => {
+            try {
+                const pubkey = keyedAccountInfo.accountId;
+                const data = Buffer.from(keyedAccountInfo.accountInfo.data);
+                if (data.length < 8)
+                    return;
+                const accountType = (0, decode_1.identifyAccountType)(data);
+                if (accountType === null)
+                    return;
+                switch (accountType) {
+                    case "Position": {
+                        const account = (0, decode_1.decodePosition)(data);
+                        this.emit("positionChanged", { pubkey, account });
+                        break;
+                    }
+                    case "MarketState": {
+                        const account = (0, decode_1.decodeMarketState)(data);
+                        this.emit("marketStateChanged", { pubkey, account });
+                        break;
+                    }
+                    case "Order": {
+                        const account = (0, decode_1.decodeOrder)(data);
+                        this.emit("orderChanged", { pubkey, account });
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+            catch (err) {
+                this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            }
+        }, "confirmed");
+    }
+    startAll() {
+        this.startEvents();
+        this.startAccounts();
+    }
+    async stop() {
+        const removals = [];
+        if (this.logsSubId !== null) {
+            removals.push(this.connection.removeOnLogsListener(this.logsSubId));
+            this.logsSubId = null;
+        }
+        if (this.accountSubId !== null) {
+            removals.push(this.connection.removeProgramAccountChangeListener(this.accountSubId));
+            this.accountSubId = null;
+        }
+        await Promise.all(removals);
+    }
+}
+exports.ParquetEventEmitter = ParquetEventEmitter;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export * from "./utils/pda";
+export * from "./utils/errors";
+export * from "./utils/priceMath";
+export { withComputeBudget } from "./utils/computeBudget";
+export { buildVersionedTransaction } from "./utils/transaction";
+export { detectProgramVersion, PROGRAM_IDS_V4, type MarketStateDataLayout, } from "./utils/version";
+export { probeTokenProgram } from "./utils/tokenProgram";
+export * from "./types";
+export { decodePosition, decodeMarketState, decodePoolState, decodeOrder, decodeOrderNonce, decodeTradingKey, decodeReferralConfig, decodeReferralCode, decodeTraderReferral, decodeAffiliateReward, decodeFeePool, decodeStakingPool, decodeStakePosition, decodePayoutQueueEntry, decodeUserQueueClaims, identifyAccountType, DecoderError, DISCRIMINATORS, type AccountTypeName, } from "./decode";
+export { PoolClient } from "./programs/pool";
+export { PerpClient, type OpenPositionArgs } from "./programs/perp";
+export { OracleClient } from "./programs/oracle";
+export { PriceFeedClient, PRICE_FEED_PROGRAM_ID } from "./programs/priceFeed";
+export { FeeDistributorClient } from "./programs/feeDistributor";
+export { StakingClient } from "./programs/staking";
+export { addLiquidity, removeLiquidity, type LiquidityOpts } from "./actions/liquidity";
+export { openPosition, closePosition, updateMargin, type TradingOpts } from "./actions/trading";
+export { crankFundingRate } from "./actions/cranks";
+export { resolveOpenPositionAccounts, resolveClosePositionAccounts, resolveUpdateMarginAccounts, resolveLiquidityAccounts, type ProgramIds, } from "./accounts/resolve";
+export { getMarketOracleFeeds, clearMarketOracleFeedsCache, MARKET_ORACLE_V2_LEN, type MarketOracleFeeds, } from "./accounts/marketOracle";
+export { registerTradingKey, revokeTradingKey, buildRegisterTradingKeyIx, buildRevokeTradingKeyIx, } from "./auth/tradingKey";
+export { ParquetEventEmitter, type ParquetEventType, type ParquetEventEmitterEvents } from "./events/emitter";
+export { decodeAnchorEvent, type DecodedEvent } from "./events/decoder";
+export { IndexerClient, IndexerError } from "./indexer/client";
+export type { StatsResponse } from "./indexer/types";