@parqxchange/sdk 0.1.0

package/dist/programs/perp.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerpClient = 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");
+const types_1 = require("../types");
+const pda_1 = require("../utils/pda");
+const HALT_MODE_OFFSET = 41;
+class PerpClient {
+    program;
+    constructor(program) {
+        this.program = program;
+    }
+    async openPositionIx(accounts, args, primaryFeedAccount, secondaryFeedAccount) {
+        const remainingAccounts = [
+            { pubkey: primaryFeedAccount, isSigner: false, isWritable: false },
+            { pubkey: secondaryFeedAccount, isSigner: false, isWritable: false },
+            { pubkey: accounts.feeSettings, isSigner: false, isWritable: false },
+        ];
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        const { tradingKey, referralConfig, referralCodeAccount, traderReferral, affiliate, affiliateReward, feeSettings: _fs, ...rest } = accounts;
+        return this.program.methods
+            .openPosition({
+            side: args.side,
+            sizeUsdc: new anchor_1.BN(args.sizeUsdc.toString()),
+            walletCollateral: new anchor_1.BN(args.walletCollateral.toString()),
+            fromQueueAmount: new anchor_1.BN(args.fromQueueAmount.toString()),
+            acceptablePrice: new anchor_1.BN(args.acceptablePrice.toString()),
+            minOutputUsdc: new anchor_1.BN(args.minOutputUsdc.toString()),
+            positionNonce: new anchor_1.BN(args.positionNonce.toString()),
+            referralCode: args.referralCode,
+        })
+            .accounts({
+            ...rest,
+            tradingKey: tradingKey,
+            referralConfig: referralConfig ?? systemProgram,
+            referralCodeAccount: referralCodeAccount ?? systemProgram,
+            traderReferral: traderReferral ?? systemProgram,
+            affiliate: affiliate ?? systemProgram,
+            affiliateReward: affiliateReward ?? null,
+            systemProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            perpEngineProgram: this.program.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async closePositionIx(accounts, closeSize, primaryFeedAccount, secondaryFeedAccount, minOutputUsdc, queueEntryPda, userClaimsPda) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        const remainingAccounts = [
+            { pubkey: primaryFeedAccount, isSigner: false, isWritable: false },
+            { pubkey: secondaryFeedAccount, isSigner: false, isWritable: false },
+        ];
+        const queueEntry = queueEntryPda ?? systemProgram;
+        const userClaims = userClaimsPda ?? systemProgram;
+        remainingAccounts.push({ pubkey: queueEntry, isSigner: false, isWritable: true }, { pubkey: userClaims, isSigner: false, isWritable: true }, { pubkey: accounts.feeSettings, isSigner: false, isWritable: false });
+        const { tradingKey, referralConfig, referralCodeAccount, traderReferral, affiliate, affiliateReward, feeSettings: _fs, ...rest } = accounts;
+        return this.program.methods
+            .closePosition({
+            closeSize: closeSize !== null ? new anchor_1.BN(closeSize.toString()) : null,
+            minOutputUsdc: new anchor_1.BN((minOutputUsdc ?? 0n).toString()),
+        })
+            .accounts({
+            ...rest,
+            tradingKey: tradingKey,
+            referralConfig: referralConfig ?? systemProgram,
+            referralCodeAccount: referralCodeAccount ?? systemProgram,
+            traderReferral: traderReferral ?? systemProgram,
+            affiliate: affiliate ?? systemProgram,
+            affiliateReward: affiliateReward ?? null,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram,
+            perpEngineProgram: this.program.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async updatePositionMarginIx(accounts, delta, primaryFeedAccount, secondaryFeedAccount) {
+        const { tradingKey, ...rest } = accounts;
+        const builder = this.program.methods
+            .updatePositionMargin(new anchor_1.BN(delta.toString()))
+            .accounts({
+            ...rest,
+            tradingKey: tradingKey,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            perpEngineProgram: this.program.programId,
+        });
+        if (primaryFeedAccount && secondaryFeedAccount) {
+            builder.remainingAccounts([
+                { pubkey: primaryFeedAccount, isSigner: false, isWritable: false },
+                { pubkey: secondaryFeedAccount, isSigner: false, isWritable: false },
+            ]);
+        }
+        else if (primaryFeedAccount || secondaryFeedAccount) {
+            throw new Error("updatePositionMarginIx: primaryFeedAccount and secondaryFeedAccount must be passed " +
+                "together — the on-chain oracle-adapter CPI requires both feeds.");
+        }
+        return builder.instruction();
+    }
+    async updateFundingRateIx(accounts) {
+        return this.program.methods
+            .updateFundingRate()
+            .accounts(accounts)
+            .instruction();
+    }
+    async createOrderIx(accounts, args) {
+        return this.program.methods.createOrder({
+            orderType: args.orderType,
+            side: args.side,
+            sizeUsdc: new anchor_1.BN(args.sizeUsdc.toString()),
+            collateralUsdc: new anchor_1.BN(args.collateralUsdc.toString()),
+            triggerPrice: new anchor_1.BN(args.triggerPrice.toString()),
+            acceptablePrice: new anchor_1.BN(args.acceptablePrice.toString()),
+            minOutputUsdc: new anchor_1.BN(args.minOutputUsdc.toString()),
+            referralCode: args.referralCode,
+            positionNonce: new anchor_1.BN(args.positionNonce.toString()),
+        })
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: new web3_js_1.PublicKey("11111111111111111111111111111111"),
+        })
+            .instruction();
+    }
+    async cancelOrderIx(accounts) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .cancelOrder()
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram,
+        })
+            .instruction();
+    }
+    async initializeMarketIx(accounts, args) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .initializeMarket({
+            marketId: Array.from(args.marketId),
+            poolState: args.poolState,
+            poolProgram: args.poolProgram,
+            oracleProgram: args.oracleProgram,
+            treasury: args.treasury,
+            stakingProgramId: args.stakingProgramId,
+            maxLeverage: args.maxLeverage,
+            baseFeeBps: args.baseFeeBps,
+            mmrBps: args.mmrBps,
+            maxOiLong: new anchor_1.BN(args.maxOiLong.toString()),
+            maxOiShort: new anchor_1.BN(args.maxOiShort.toString()),
+            feeBpsFavorable: args.feeBpsFavorable,
+            initialMarginBps: args.initialMarginBps,
+        })
+            .accounts({
+            ...accounts,
+            systemProgram,
+        })
+            .instruction();
+    }
+    async updateMarketConfigIx(accounts, args) {
+        const toBnOrNull = (v) => v != null ? new anchor_1.BN(v.toString()) : null;
+        return this.program.methods
+            .updateMarketConfig({
+            fundingIncreaseFactorPerSecond: toBnOrNull(args.fundingIncreaseFactorPerSecond),
+            fundingDecreaseFactorPerSecond: toBnOrNull(args.fundingDecreaseFactorPerSecond),
+            thresholdForStableFunding: toBnOrNull(args.thresholdForStableFunding),
+            thresholdForDecreaseFunding: toBnOrNull(args.thresholdForDecreaseFunding),
+            minFundingFactorPerSecond: toBnOrNull(args.minFundingFactorPerSecond),
+            maxFundingFactorPerSecond: toBnOrNull(args.maxFundingFactorPerSecond),
+            borrowingFactor: toBnOrNull(args.borrowingFactor),
+            optimalUsageFactor: toBnOrNull(args.optimalUsageFactor),
+            aboveOptimalBorrowingFactor: toBnOrNull(args.aboveOptimalBorrowingFactor),
+            priceImpactFactor: toBnOrNull(args.priceImpactFactor),
+            maxPriceImpactBps: args.maxPriceImpactBps,
+            keeper: args.keeper ?? null,
+            stakingProgramId: args.stakingProgramId ?? null,
+            maxOiLong: toBnOrNull(args.maxOiLong),
+            maxOiShort: toBnOrNull(args.maxOiShort),
+            feeBpsFavorable: args.feeBpsFavorable ?? null,
+            offHoursMaxOiLong: toBnOrNull(args.offHoursMaxOiLong),
+            offHoursMaxOiShort: toBnOrNull(args.offHoursMaxOiShort),
+            mmrBps: args.mmrBps ?? null,
+            initialMarginBps: args.initialMarginBps ?? null,
+            maxLeverage: args.maxLeverage ?? null,
+            adlFrozen: args.adlFrozen ?? null,
+            adlTailTriggerUsdcRth: toBnOrNull(args.adlTailTriggerUsdcRth),
+            adlTailTriggerUsdcOff: toBnOrNull(args.adlTailTriggerUsdcOff),
+            adlTailMinAgeSecsRth: args.adlTailMinAgeSecsRth ?? null,
+            adlTailMinAgeSecsOff: args.adlTailMinAgeSecsOff ?? null,
+            adlHaircutBpsRth: args.adlHaircutBpsRth ?? null,
+            adlHaircutBpsOff: args.adlHaircutBpsOff ?? null,
+            adlMaxHaircutBps: args.adlMaxHaircutBps ?? null,
+            adlMaxFeedDivergenceBps: args.adlMaxFeedDivergenceBps ?? null,
+            baseFeeBps: args.baseFeeBps ?? null,
+        })
+            .accounts(accounts)
+            .instruction();
+    }
+    async setTradingHaltIx(admin, mode) {
+        return this.program.methods
+            .setTradingHalt(mode)
+            .accounts({ admin })
+            .instruction();
+    }
+    async migrateMarketStateIx(accounts) {
+        return this.program.methods
+            .migrateMarketState()
+            .accounts(accounts)
+            .instruction();
+    }
+    async migratePositionIx(accounts) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .migratePosition()
+            .accounts({
+            ...accounts,
+            systemProgram,
+        })
+            .instruction();
+    }
+    async setPerSideReservedIx(accounts, args) {
+        return this.program.methods
+            .setPerSideReserved({
+            longReservedUsdc: new anchor_1.BN(args.longReservedUsdc.toString()),
+            shortReservedUsdc: new anchor_1.BN(args.shortReservedUsdc.toString()),
+        })
+            .accounts(accounts)
+            .instruction();
+    }
+    async liquidateIx(accounts, primaryFeedAccount, secondaryFeedAccount, queueEntries, userClaimsPda, hasQueueCollateral, maxCollateralLoss) {
+        if (hasQueueCollateral && userClaimsPda === null) {
+            throw new Error("liquidateIx: userClaimsPda is required when position has queue-funded " +
+                "collateral (hasQueueCollateral=true), regardless of queueEntries.length " +
+                "(F-007). Pass the position owner's UserQueueClaims PDA.");
+        }
+        const remainingAccounts = [
+            { pubkey: primaryFeedAccount, isSigner: false, isWritable: false },
+            { pubkey: secondaryFeedAccount, isSigner: false, isWritable: false },
+        ];
+        for (const entry of queueEntries) {
+            remainingAccounts.push({ pubkey: entry, isSigner: false, isWritable: true });
+        }
+        if (userClaimsPda !== null) {
+            remainingAccounts.push({ pubkey: userClaimsPda, isSigner: false, isWritable: true });
+        }
+        return this.program.methods
+            .liquidate(maxCollateralLoss !== undefined ? new anchor_1.BN(maxCollateralLoss.toString()) : null)
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            perpEngineProgram: this.program.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async executeOrderIx(accounts, primaryFeedAccount, secondaryFeedAccount, feeSettings, enqueueAccounts = null) {
+        const remainingAccounts = [
+            { pubkey: primaryFeedAccount, isSigner: false, isWritable: false },
+            { pubkey: secondaryFeedAccount, isSigner: false, isWritable: false },
+        ];
+        if (enqueueAccounts !== null) {
+            remainingAccounts.push({ pubkey: enqueueAccounts.queueEntry, isSigner: false, isWritable: true }, { pubkey: enqueueAccounts.userClaims, isSigner: false, isWritable: true });
+        }
+        remainingAccounts.push({ pubkey: feeSettings, isSigner: false, isWritable: false });
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .executeOrder()
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram,
+            perpEngineProgram: this.program.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async configureReferralTiersIx(accounts, args) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .configureReferralTiers(args.tiers)
+            .accounts({
+            ...accounts,
+            systemProgram,
+        })
+            .instruction();
+    }
+    async setReferralTierIx(accounts, args) {
+        return this.program.methods
+            .setReferralTier({ tier: args.tier })
+            .accounts(accounts)
+            .instruction();
+    }
+    async createReferralCodeIx(accounts, args) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .createReferralCode(Array.from(args.code))
+            .accounts({
+            ...accounts,
+            systemProgram,
+        })
+            .instruction();
+    }
+    async setTraderReferralIx(accounts, args) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        return this.program.methods
+            .setTraderReferral(Array.from(args.code))
+            .accounts({
+            ...accounts,
+            systemProgram,
+        })
+            .instruction();
+    }
+    async claimAffiliateRewardIx(accounts) {
+        return this.program.methods
+            .claimAffiliateReward()
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+    }
+    async getProtocolConfig() {
+        const [pda] = (0, pda_1.protocolConfigPDA)(this.program.programId);
+        const raw = await this.program.account.protocolConfig.fetch(pda);
+        return {
+            admin: raw.admin,
+            bump: raw.bump,
+            haltMode: raw.haltMode,
+            rthOpenMinutesUtc: raw.rthOpenMinutesUtc,
+            rthCloseMinutesUtc: raw.rthCloseMinutesUtc,
+            tierBreakpointsUsdc: raw.tierBreakpointsUsdc.map((bn) => BigInt(bn.toString())),
+            rthMaxLeverage: Array.from(raw.rthMaxLeverage),
+            offHoursMaxLeverage: Array.from(raw.offHoursMaxLeverage),
+        };
+    }
+    async getHaltMode() {
+        const [pda] = (0, pda_1.protocolConfigPDA)(this.program.programId);
+        const info = await this.program.provider.connection.getAccountInfo(pda);
+        if (!info || info.data.length <= HALT_MODE_OFFSET)
+            return types_1.HaltMode.None;
+        const raw = info.data[HALT_MODE_OFFSET];
+        return raw === types_1.HaltMode.ReduceOnly || raw === types_1.HaltMode.Full ? raw : types_1.HaltMode.None;
+    }
+}
+exports.PerpClient = PerpClient;

package/dist/programs/pool.d.ts

@@ -0,0 +1,113 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, AccountMeta } from "@solana/web3.js";
+export declare class PoolClient {
+    private readonly program;
+    constructor(program: Program);
+    initializePoolIx(accounts: {
+        poolState: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        lpMint: PublicKey;
+        usdcMint: PublicKey;
+        admin: PublicKey;
+    }, args: {
+        marketId: Uint8Array;
+        engineAuth: PublicKey;
+        engineAuthBump: number;
+        reserveFactor: bigint;
+        depositFeeBps: number;
+        withdrawalFeeBps: number;
+    }): Promise<TransactionInstruction>;
+    updatePoolConfigIx(accounts: {
+        admin: PublicKey;
+        poolState: PublicKey;
+    }, args: {
+        reserveFactor?: bigint | null;
+        depositFeeBps?: number | null;
+        withdrawalFeeBps?: number | null;
+    }): Promise<TransactionInstruction>;
+    depositIx(accounts: {
+        poolState: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        lpMint: PublicKey;
+        userLp: PublicKey;
+        userUsdc: PublicKey;
+        depositor: PublicKey;
+    }, args: {
+        amount: bigint;
+        minLpOut: bigint;
+    }): Promise<TransactionInstruction>;
+    withdrawIx(accounts: {
+        poolState: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        lpMint: PublicKey;
+        userLp: PublicKey;
+        userUsdc: PublicKey;
+        withdrawer: PublicKey;
+    }, args: {
+        lpAmount: bigint;
+        minOut: bigint;
+    }): Promise<TransactionInstruction>;
+    sweepFeesIx(accounts: {
+        poolState: PublicKey;
+        feeSettings: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        feePoolUsdc: PublicKey;
+    }): Promise<TransactionInstruction>;
+    accrueFeeIx(accounts: {
+        poolState: PublicKey;
+        feeSettings: PublicKey;
+        engineAuth: PublicKey;
+    }, amount: bigint, alreadyInPool: boolean): Promise<TransactionInstruction>;
+    harvestIx(accounts: {
+        poolState: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        caller: PublicKey;
+    }, maxEntries: number, remainingAccounts: AccountMeta[]): Promise<TransactionInstruction>;
+    voidQueueClaimIx(accounts: {
+        poolState: PublicKey;
+        entry: PublicKey;
+        userClaims: PublicKey;
+        engineAuth: PublicKey;
+    }): Promise<TransactionInstruction>;
+    initializeInsuranceFundIx(accounts: {
+        insuranceFund: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        usdcMint: PublicKey;
+        payer: PublicKey;
+    }, args: {
+        admin: PublicKey;
+    }): Promise<TransactionInstruction>;
+    reimbursePoolFromFundIx(accounts: {
+        insuranceFund: PublicKey;
+        poolState: PublicKey;
+        poolVaultUsdc: PublicKey;
+        insuranceVault: PublicKey;
+        vaultAuthority: PublicKey;
+        admin: PublicKey;
+    }, args: {
+        amount: bigint;
+    }): Promise<TransactionInstruction>;
+    withdrawInsuranceIx(accounts: {
+        insuranceFund: PublicKey;
+        insuranceVault: PublicKey;
+        destination: PublicKey;
+        vaultAuthority: PublicKey;
+        admin: PublicKey;
+    }, args: {
+        amount: bigint;
+    }): Promise<TransactionInstruction>;
+    drainPhantomCreditIx(accounts: {
+        poolState: PublicKey;
+        usdcVault: PublicKey;
+        vaultAuthority: PublicKey;
+        userClaims: PublicKey;
+        user: PublicKey;
+        userUsdc: PublicKey;
+    }): Promise<TransactionInstruction>;
+}

package/dist/programs/pool.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolClient = 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 PoolClient {
+    program;
+    constructor(program) {
+        this.program = program;
+    }
+    async initializePoolIx(accounts, args) {
+        const systemProgram = new web3_js_1.PublicKey("11111111111111111111111111111111");
+        const RENT_SYSVAR = new web3_js_1.PublicKey("SysvarRent111111111111111111111111111111111");
+        return this.program.methods
+            .initializePool({
+            marketId: Array.from(args.marketId),
+            engineAuth: args.engineAuth,
+            engineAuthBump: args.engineAuthBump,
+            reserveFactor: new anchor_1.BN(args.reserveFactor.toString()),
+            depositFeeBps: args.depositFeeBps,
+            withdrawalFeeBps: args.withdrawalFeeBps,
+        })
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram,
+            rent: RENT_SYSVAR,
+        })
+            .instruction();
+    }
+    async updatePoolConfigIx(accounts, args) {
+        return this.program.methods
+            .updatePoolConfig({
+            reserveFactor: args.reserveFactor != null ? new anchor_1.BN(args.reserveFactor.toString()) : null,
+            depositFeeBps: args.depositFeeBps ?? null,
+            withdrawalFeeBps: args.withdrawalFeeBps ?? null,
+        })
+            .accounts({
+            poolState: accounts.poolState,
+            admin: accounts.admin,
+        })
+            .instruction();
+    }
+    async depositIx(accounts, args) {
+        return this.program.methods
+            .deposit(new anchor_1.BN(args.amount.toString()), new anchor_1.BN(args.minLpOut.toString()))
+            .accounts({ ...accounts, tokenProgram: spl_token_1.TOKEN_PROGRAM_ID })
+            .instruction();
+    }
+    async withdrawIx(accounts, args) {
+        return this.program.methods
+            .withdraw(new anchor_1.BN(args.lpAmount.toString()), new anchor_1.BN(args.minOut.toString()))
+            .accounts({ ...accounts, tokenProgram: spl_token_1.TOKEN_PROGRAM_ID })
+            .instruction();
+    }
+    async sweepFeesIx(accounts) {
+        return this.program.methods
+            .sweepFees()
+            .accounts({ ...accounts, tokenProgram: spl_token_1.TOKEN_PROGRAM_ID })
+            .instruction();
+    }
+    async accrueFeeIx(accounts, amount, alreadyInPool) {
+        return this.program.methods
+            .accrueFee(new anchor_1.BN(amount.toString()), alreadyInPool)
+            .accounts(accounts)
+            .instruction();
+    }
+    async harvestIx(accounts, maxEntries, remainingAccounts) {
+        return this.program.methods
+            .harvest(maxEntries)
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async voidQueueClaimIx(accounts) {
+        return this.program.methods
+            .voidQueueClaim()
+            .accounts(accounts)
+            .instruction();
+    }
+    async initializeInsuranceFundIx(accounts, args) {
+        const RENT_SYSVAR = new web3_js_1.PublicKey("SysvarRent111111111111111111111111111111111");
+        return this.program.methods
+            .initializeInsuranceFund(args.admin)
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: RENT_SYSVAR,
+        })
+            .instruction();
+    }
+    async reimbursePoolFromFundIx(accounts, args) {
+        return this.program.methods
+            .reimbursePoolFromFund(new anchor_1.BN(args.amount.toString()))
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+    }
+    async withdrawInsuranceIx(accounts, args) {
+        return this.program.methods
+            .withdrawInsurance(new anchor_1.BN(args.amount.toString()))
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+    }
+    async drainPhantomCreditIx(accounts) {
+        return this.program.methods
+            .drainPhantomCredit()
+            .accounts({
+            ...accounts,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+    }
+}
+exports.PoolClient = PoolClient;

package/dist/programs/priceFeed.d.ts

@@ -0,0 +1,13 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare const PRICE_FEED_PROGRAM_ID: PublicKey;
+export declare class PriceFeedClient {
+    private readonly program;
+    constructor(program: Program);
+    setAdminIx(accounts: {
+        feed: PublicKey;
+        currentAdmin: PublicKey;
+    }, args: {
+        newAdmin: PublicKey;
+    }): Promise<TransactionInstruction>;
+}

package/dist/programs/priceFeed.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceFeedClient = exports.PRICE_FEED_PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.PRICE_FEED_PROGRAM_ID = new web3_js_1.PublicKey("Dgorf5LPiMttdTxWcrsiA2j94kWKw55gJLRJm8P4E1Hn");
+class PriceFeedClient {
+    program;
+    constructor(program) {
+        this.program = program;
+    }
+    async setAdminIx(accounts, args) {
+        return this.program.methods
+            .setAdmin(args.newAdmin)
+            .accounts({
+            feed: accounts.feed,
+            currentAdmin: accounts.currentAdmin,
+        })
+            .instruction();
+    }
+}
+exports.PriceFeedClient = PriceFeedClient;