@xitadel-fi/sdk 0.1.1

package/dist/sdk/src/program.js

@@ -0,0 +1,825 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XitadelProgram = exports.SEEDS = 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 web3_js_2 = require("@solana/web3.js");
+const xitadel_json_1 = __importDefault(require("../../target/idl/xitadel.json"));
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+exports.SEEDS = {
+    LTT_CONFIG: Buffer.from('ltt_config'),
+    LTT_MINT: Buffer.from('ltt_mint'),
+    ORACLE_PRICE_FEED: Buffer.from('oracle_price_feed'),
+    METADATA: Buffer.from('metadata'),
+    FUNDING_RECORD: Buffer.from('funding_record'),
+    COLLATERAL_STATE: Buffer.from('collateral_state'),
+    COLLATERAL_VAULT: Buffer.from('collateral_vault'),
+};
+class XitadelProgram {
+    constructor(provider, address) {
+        const idl = Object.assign(xitadel_json_1.default, {});
+        if (address) {
+            idl.address = address;
+        }
+        this.program = new anchor_1.Program(idl, provider);
+        // if (process.env.NODE_ENV === 'development') {
+        //   const workspace = require('@coral-xyz/anchor').workspace;
+        //   this.program = workspace.Xitadel as Program<Xitadel>;
+        // } else {
+        // }
+    }
+    getProgramId() {
+        return this.program.programId;
+    }
+    getConfigPda() {
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('config')], this.program.programId)[0];
+    }
+    async getConfig() {
+        return this.program.account.config.fetch(this.getConfigPda());
+    }
+    /**
+     * Initialize the Xitadel program configuration
+     * @param manager The manager's public key (can be different from payer)
+     * @param payer Optional payer public key (defaults to manager if not provided)
+     * @returns Transaction instruction for initializing the program configuration
+     */
+    async initConfig(manager, payer) {
+        const [configPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('config')], this.program.programId);
+        const payerKey = payer || manager;
+        return this.program.methods
+            .initConfig()
+            .accountsPartial({
+            payer: payerKey,
+            manager,
+            config: configPda,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /**
+     * Helper method to get LTT configuration PDA
+     * @param lttId The LTT ID (Pubkey)
+     * @returns LTT configuration PDA
+     */
+    getLTTConfigPda(lttId) {
+        return web3_js_1.PublicKey.findProgramAddressSync([exports.SEEDS.LTT_CONFIG, lttId.toBuffer()], this.program.programId)[0];
+    }
+    /**
+     * Get LTT configuration data
+     * @param lttId The LTT ID (Pubkey)
+     * @returns LTT configuration data
+     */
+    async getLttConfig(lttId) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        return this.program.account.lttConfiguration.fetch(lttConfigPda);
+    }
+    /**
+     * Helper method to get LP authority PDA
+     * @returns LP authority PDA
+     */
+    getLpAuthority() {
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('lp_authority')], this.program.programId)[0];
+    }
+    /**
+     * Helper method to get metadata PDA
+     * @param lttMintPda The LTT mint PDA
+     * @returns Metadata PDA
+     */
+    getMetadataPda(lttMintPda) {
+        return web3_js_1.PublicKey.findProgramAddressSync([exports.SEEDS.METADATA, constants_1.METADATA_PROGRAM_ID.toBuffer(), lttMintPda.toBuffer()], constants_1.METADATA_PROGRAM_ID)[0];
+    }
+    /**
+     * Helper method to get funding record PDA
+     * @param lttId The LTT ID
+     * @param investor The investor's public key
+     * @returns Funding record PDA
+     */
+    getFundingRecordPda(lttConfig, investor) {
+        return web3_js_1.PublicKey.findProgramAddressSync([exports.SEEDS.FUNDING_RECORD, lttConfig.toBuffer(), investor.toBuffer()], this.program.programId)[0];
+    }
+    /**
+     * Helper method to get collateral state PDA
+     * @param lttId The LTT ID
+     * @returns Collateral state PDA
+     */
+    getCollateralStatePda(lttId) {
+        return web3_js_1.PublicKey.findProgramAddressSync([exports.SEEDS.COLLATERAL_STATE, lttId.toBuffer()], this.program.programId)[0];
+    }
+    /**
+     * Register a new LTT
+     * @param manager The manager's public key
+     * @param params The LTT registration parameters
+     * @param fundingTokenMint The funding token mint account
+     * @param collateralTokenMint The collateral token mint account
+     * @returns Transaction instruction for registering the LTT
+     */
+    async registerLTT(manager, fundingTokenMint, collateralTokenMint, params) {
+        const config = this.getConfigPda();
+        const lttConfigPda = this.getLTTConfigPda(params.lttId);
+        const metadataPda = this.getMetadataPda(params.lttId);
+        return this.program.methods
+            .registerLtt(params)
+            .accountsPartial({
+            manager: manager,
+            config: config,
+            lttConfiguration: lttConfigPda,
+            lttTokenMint: params.lttId,
+            fundingTokenMint: fundingTokenMint,
+            collateralTokenMint: collateralTokenMint,
+            metadataAccount: metadataPda,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenMetadataProgram: constants_1.METADATA_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /**
+     * Fund an LTT
+     * @param lttId The LTT ID to fund
+     * @param investor The investor's public key
+     * @param amount The amount to fund
+     * @returns Transaction instruction for funding the LTT
+     */
+    async fundLTT(lttId, investor, fundingAmount) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const fundingRecordPda = this.getFundingRecordPda(lttConfigPda, investor);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const fundingTokenMint = lttConfig.fundingTokenMint;
+        const fundingVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(fundingTokenMint, lttConfigPda, true);
+        const investorStablecoinAta = (0, spl_token_1.getAssociatedTokenAddressSync)(fundingTokenMint, investor, true);
+        const investorLTTAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttId, investor, true);
+        const instructions = [];
+        let ataInfo = null;
+        try {
+            ataInfo = await this.program.provider.connection.getAccountInfo(investorLTTAta);
+        }
+        catch (error) { }
+        if (ataInfo == null) {
+            const createInvestorLTTAtaIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(investor, investorLTTAta, investor, lttId);
+            instructions.push(createInvestorLTTAtaIx);
+        }
+        instructions.push(await this.program.methods
+            .fundLtt(fundingAmount)
+            .accountsPartial({
+            investor,
+            lttConfiguration: lttConfigPda,
+            fundingVaultAta,
+            investorFundingAta: investorStablecoinAta,
+            investorLttAta: investorLTTAta,
+            fundingTokenMint,
+            lttTokenMint: lttId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction());
+        return instructions;
+    }
+    /**
+     * Activate liquidation for an LTT
+     * @param lttId The LTT ID
+     * @param keeperBot The keeper bot's public key
+     * @returns Transaction instruction for activating liquidation
+     */
+    async activateLiquidation(lttId, keeperBot, pricefeed, chainLinkProgram, signedReport, verifierAccounts) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        return this.program.methods
+            .activateLiquidation(Buffer.from(signedReport))
+            .accountsPartial({
+            lttConfiguration: lttConfigPda,
+            priceFeed: pricefeed,
+            signer: keeperBot,
+            collateralVaultAta,
+            collateralTokenMint: lttConfig.collateralTokenMint,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            stableTokenMint: lttConfig.fundingTokenMint,
+            systemProgram: web3_js_2.SystemProgram.programId,
+            chainlinkProgram: chainLinkProgram,
+            verifierAccount: verifierAccounts.verifier,
+            accessController: verifierAccounts.accessController,
+            configAccount: verifierAccounts.config,
+        })
+            .instruction();
+    }
+    /**
+     * Execute liquidation for an LTT
+     * @param lttId The LTT ID
+     * @param keeperBot The keeper bot's public key
+     * @param priceFeed Switchboard price feed
+     * @returns Transaction instruction for executing liquidation
+     */
+    async executeLiquidation(lttId, keeperBot, priceFeed, chainLinkProgram, signedReport, verifierAccounts) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        return this.program.methods
+            .executeLiquidation(Buffer.from(signedReport))
+            .accountsPartial({
+            priceFeed,
+            lttConfiguration: lttConfigPda,
+            signer: keeperBot,
+            collateralVaultAta,
+            lttTokenMint: lttId,
+            collateralTokenMint: lttConfig.collateralTokenMint,
+            stableTokenMint: lttConfig.fundingTokenMint,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+            chainlinkProgram: chainLinkProgram,
+            verifierAccount: verifierAccounts.verifier,
+            accessController: verifierAccounts.accessController,
+            configAccount: verifierAccounts.config,
+        })
+            .instruction();
+    }
+    /**
+     * Withdraw collateral from an LTT
+     * @param lttId The LTT ID
+     * @param withdrawer The withdrawer's public key
+     * @param amount The amount to withdraw
+     * @returns Transaction instruction for withdrawing collateral
+     */
+    async withdrawCollateral(lttId, withdrawer, amount, chainLinkProgram, priceFeed, signedReport, verifierAccounts) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const instructions = [];
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        const withdrawerCollateralAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, withdrawer, true);
+        const ataInfo = await this.program.provider.connection.getAccountInfo(withdrawerCollateralAta);
+        const needsCreate = ataInfo == null;
+        if (needsCreate) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(withdrawer, withdrawerCollateralAta, withdrawer, lttConfig.collateralTokenMint));
+        }
+        instructions.push(await this.program.methods
+            .withdrawCollateral(amount, Buffer.from(signedReport))
+            .accountsPartial({
+            lttConfiguration: lttConfigPda,
+            issuer: withdrawer,
+            collateralVaultAta,
+            stableTokenMint: lttConfig.fundingTokenMint,
+            issuerCollateralAta: withdrawerCollateralAta,
+            collateralTokenMint: lttConfig.collateralTokenMint,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            chainlinkProgram: chainLinkProgram,
+            priceFeed,
+            systemProgram: web3_js_2.SystemProgram.programId,
+            verifierAccount: verifierAccounts.verifier,
+            accessController: verifierAccounts.accessController,
+            configAccount: verifierAccounts.config,
+        })
+            .instruction());
+        return instructions;
+    }
+    /**
+     * Withdraw USDC from an LTT
+     * @param lttId The LTT ID
+     * @param withdrawer The withdrawer's public key
+     * @param amount The amount to withdraw
+     * @returns Transaction instruction for withdrawing USDC
+     */
+    async withdrawUsdc(lttId, withdrawer, amount) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const fundingVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true);
+        const withdrawerFundingAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, withdrawer, true);
+        return this.program.methods
+            .withdrawUsdc(amount)
+            .accountsPartial({
+            lttConfiguration: lttConfigPda,
+            issuer: withdrawer,
+            fundingVaultAta,
+            issuerFundingAta: withdrawerFundingAta,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            fundingTokenMint: lttConfig.fundingTokenMint,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /**
+     * Fetch LTT configuration
+     * @param lttId The LTT ID
+     * @returns LTT configuration
+     */
+    async fetchLTTConfiguration(lttId) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        return this.program.account.lttConfiguration.fetch(lttConfigPda);
+    }
+    /**
+     * Redeem LTT tokens
+     * @param lttId The LTT ID
+     * @param investor The investor's public key
+     * @param amount The amount to redeem
+     * @returns Transaction instruction for redeeming LTT tokens
+     */
+    async redeemLTT(lttId, investor, amount) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        // Get all required token accounts
+        const fundingVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true);
+        const investorFundingAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, investor, true);
+        const investorLttAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttId, investor, true);
+        const interestVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        const investorInterestAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, investor, true);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        const investorCollateralAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, investor, true);
+        const instructions = [];
+        // Check if investor's collateral token account exists
+        let investorCollateralAtaInfo = null;
+        try {
+            investorCollateralAtaInfo = await this.program.provider.connection.getAccountInfo(investorCollateralAta);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (investorCollateralAtaInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(investor, investorCollateralAta, investor, lttConfig.collateralTokenMint));
+        }
+        instructions.push(await this.program.methods
+            .redeem(amount)
+            .accountsPartial({
+            investor: investor,
+            lttConfiguration: lttConfigPda,
+            fundingVaultAta,
+            investorFundingAta,
+            investorLttAta,
+            interestVaultAta,
+            investorInterestAta,
+            collateralVaultAta,
+            investorCollateralAta,
+            fundingTokenMint: lttConfig.fundingTokenMint,
+            lttTokenMint: lttId,
+            collateralTokenMint: lttConfig.collateralTokenMint,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction());
+        return instructions;
+    }
+    /**
+     * Update LTT status
+     * @param lttId The LTT ID
+     * @returns Transaction instruction for updating LTT status
+     */
+    async updateLTTStatus(lttId) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const fundingVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        return this.program.methods
+            .updateLttStatus()
+            .accountsPartial({
+            lttConfiguration: lttConfigPda,
+            fundingVaultAta,
+            collateralVaultAta,
+            fundingTokenMint: lttConfig.fundingTokenMint,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /**
+     * Deactivate an LTT
+     * @param signer
+     * @param lttId The LTT ID
+     * @param positionNftMint The position NFT mint
+     * @param cpAmmProgramId The CP AMM program ID
+     * @returns Transaction instructions for deactivating the LTT
+     */
+    async deactivateLTT(signer, lttId, positionNftMint, cpAmmProgramId) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.getLttConfig(lttId);
+        const lpAuthority = this.getLpAuthority();
+        const harvestVault = this.getHarvestVaultPda(lttId);
+        const instructions = [];
+        // Check if harvest vault position NFT ATA exists, create if not
+        const harvestVaultPositionNftAta = (0, spl_token_1.getAssociatedTokenAddressSync)(positionNftMint, harvestVault, true, spl_token_1.TOKEN_2022_PROGRAM_ID);
+        let harvestVaultPositionNftAtaInfo = null;
+        try {
+            harvestVaultPositionNftAtaInfo = await this.program.provider.connection.getAccountInfo(harvestVaultPositionNftAta);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (harvestVaultPositionNftAtaInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, harvestVaultPositionNftAta, harvestVault, positionNftMint, spl_token_1.TOKEN_2022_PROGRAM_ID));
+        }
+        // Check if harvest vault funding ATA exists, create if not
+        const harvestVaultFundingAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, harvestVault, true);
+        let harvestVaultFundingAtaInfo = null;
+        try {
+            harvestVaultFundingAtaInfo = await this.program.provider.connection.getAccountInfo(harvestVaultFundingAta);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (harvestVaultFundingAtaInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, harvestVaultFundingAta, harvestVault, lttConfig.fundingTokenMint));
+        }
+        // Check if harvest vault collateral ATA exists, create if not
+        const harvestVaultCollateralAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, harvestVault, true);
+        let harvestVaultCollateralAtaInfo = null;
+        try {
+            harvestVaultCollateralAtaInfo = await this.program.provider.connection.getAccountInfo(harvestVaultCollateralAta);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (harvestVaultCollateralAtaInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, harvestVaultCollateralAta, harvestVault, lttConfig.collateralTokenMint));
+        }
+        // Use Token-2022 ATA for position NFT account owned by lpAuthority
+        const [positionNftAccount] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_NFT_ACCOUNT_SEED, positionNftMint.toBuffer()], cpAmmProgramId);
+        let positionNftAccountInfo = null;
+        try {
+            positionNftAccountInfo = await this.program.provider.connection.getAccountInfo(positionNftAccount);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (positionNftAccountInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, positionNftAccount, lpAuthority, positionNftMint, spl_token_1.TOKEN_2022_PROGRAM_ID));
+        }
+        console.log('harvestVaultPositionNftAta', harvestVaultPositionNftAta.toBase58());
+        console.log('harvestVaultFundingAta', harvestVaultFundingAta.toBase58());
+        console.log('harvestVaultCollateralAta', harvestVaultCollateralAta.toBase58());
+        console.log('positionNftAccount', positionNftAccount.toBase58());
+        // Add the main deactivate instruction
+        instructions.push(await this.program.methods
+            .deactivateLtt()
+            .accountsPartial({
+            signer: signer,
+            lttConfiguration: lttConfigPda,
+            lpAuthority: lpAuthority,
+            harvestVault,
+            fundingVaultAta: (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true),
+            collateralVaultAta: (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true),
+            positionNftMint,
+            positionNftAccount: positionNftAccount,
+            harvestVaultPositionNftAta,
+            harvestVaultFundingAta,
+            harvestVaultCollateralAta,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            token2022Program: spl_token_1.TOKEN_2022_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction());
+        return instructions;
+    }
+    /**
+     * Activate an LTT
+     * @param signer The signer's public key
+     * @param positionNftMintKeypair
+     * @param ammConfig
+     * @param params The LP creation parameters
+     * @returns Transaction instructions for creating LP
+     */
+    async activateLtt(signer, positionNftMintKeypair, positionNftMintKeypairB, ammConfig, ammConfigB, params) {
+        const lpAuthority = this.getLpAuthority();
+        const lttConfigPda = this.getLTTConfigPda(params.lttId);
+        const lttTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(params.lttId, lpAuthority, true);
+        // console.log("lpAuthority", lpAuthority.toBase58());
+        const instructions = [];
+        // Create stable coin token account if it doesn't exist
+        const stableCoinVaultTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(params.stableCoinMint, lpAuthority, true);
+        const fundingVaultTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(params.stableCoinMint, lttConfigPda, true);
+        let stableCoinTokenAccountInfo = null;
+        try {
+            stableCoinTokenAccountInfo = await this.program.provider.connection.getAccountInfo(stableCoinVaultTokenAccount);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (stableCoinTokenAccountInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, stableCoinVaultTokenAccount, lpAuthority, params.stableCoinMint));
+        }
+        const pool = (0, utils_1.derivePoolKey)(ammConfig, params.lttId, params.stableCoinMint, params.cpAmmProgramId);
+        const poolb = (0, utils_1.derivePoolKey)(ammConfigB, params.lttId, params.stableCoinMint, params.cpAmmProgramId);
+        const [lpMint] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('lp_mint'), pool.toBuffer()], params.cpAmmProgramId);
+        let lttVaultAta, stableVaultAta, lttVaultAtaB, stableVaultAtaB;
+        [lttVaultAta, stableVaultAta, lttVaultAtaB, stableVaultAtaB] = [
+            (0, utils_1.getVaultPda)(params.lttId, params.cpAmmProgramId, pool),
+            (0, utils_1.getVaultPda)(params.stableCoinMint, params.cpAmmProgramId, pool),
+            (0, utils_1.getVaultPda)(params.lttId, params.cpAmmProgramId, poolb),
+            (0, utils_1.getVaultPda)(params.stableCoinMint, params.cpAmmProgramId, poolb),
+        ];
+        let lttTokenAccountInfo = null;
+        try {
+            lttTokenAccountInfo = await this.program.provider.connection.getAccountInfo(lttTokenAccount);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (lttTokenAccountInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, lttTokenAccount, lpAuthority, params.lttId));
+        }
+        // Initialize payer LTT token account
+        const payerLttTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(params.lttId, lpAuthority, true);
+        // Initialize payer stablecoin token account
+        const payerStableCoinTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(params.stableCoinMint, lpAuthority, true);
+        let payerStableCoinTokenAccountInfo = null;
+        try {
+            payerStableCoinTokenAccountInfo = await this.program.provider.connection.getAccountInfo(payerStableCoinTokenAccount);
+        }
+        catch (error) {
+            // Account doesn't exist, will create it
+        }
+        if (payerStableCoinTokenAccountInfo == null) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(signer, payerStableCoinTokenAccount, lpAuthority, params.stableCoinMint));
+        }
+        // Generate position NFT mint and account
+        const [positionNftAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position_nft_account'), positionNftMintKeypair.publicKey.toBuffer()], params.cpAmmProgramId);
+        const [positionNftAccountB] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position_nft_account'), positionNftMintKeypairB.publicKey.toBuffer()], params.cpAmmProgramId);
+        // Get position PDA
+        const [position] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position'), positionNftMintKeypair.publicKey.toBuffer()], params.cpAmmProgramId);
+        const [positionB] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position'), positionNftMintKeypairB.publicKey.toBuffer()], params.cpAmmProgramId);
+        const [poolAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('pool_authority')], params.cpAmmProgramId);
+        const [eventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('__event_authority')], params.cpAmmProgramId);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(params.collateralTokenMint, lttConfigPda, true);
+        instructions.push(await this.program.methods
+            .activateLtt()
+            .accountsPartial({
+            signer: signer,
+            lttConfiguration: lttConfigPda,
+            lpAuthority,
+            poolAuthority: poolAuthority,
+            pool,
+            poolb,
+            lpMint,
+            poolConfig: ammConfig,
+            poolConfigB: ammConfigB,
+            lttMint: params.lttId,
+            stableCoinMint: params.stableCoinMint,
+            fundingVaultAccount: fundingVaultTokenAccount,
+            lttVaultAta: lttVaultAta,
+            stableCoinVaultAta: stableVaultAta,
+            lttVaultAtaB,
+            stableCoinVaultAtaB: stableVaultAtaB,
+            payerLttTokenAccount: payerLttTokenAccount,
+            payerStableCoinTokenAccount: payerStableCoinTokenAccount,
+            positionNftMint: positionNftMintKeypair.publicKey,
+            positionNftMintB: positionNftMintKeypairB.publicKey,
+            positionNftAccount: positionNftAccount,
+            positionNftAccountB,
+            position: position,
+            positionB,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+            collateralAta: collateralVaultAta,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenBProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            token2022Program: spl_token_1.TOKEN_2022_PROGRAM_ID,
+            eventAuthority: eventAuthority,
+            cpAmmProgram: params.cpAmmProgramId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+        })
+            .instruction());
+        return instructions;
+    }
+    /**
+     * Maturate an LTT
+     * @param signer
+     * @param lttId The LTT ID
+     * @param positionNftMint The position NFT mint
+     * @param ammConfig The AMM config
+     * @param cpAmmProgramId The CP AMM program ID
+     * @param params The maturate parameters
+     * @returns Transaction instruction for maturing the LTT
+     */
+    async maturateLtt(signer, lttId, positionNftMint, positionNftMintB, ammConfig, ammConfigB, cpAmmProgramId) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.getLttConfig(lttId);
+        const lpAuthority = this.getLpAuthority();
+        // Derive pool key
+        const pool = (0, utils_1.derivePoolKey)(ammConfig, lttId, lttConfig.fundingTokenMint, cpAmmProgramId);
+        const poolB = (0, utils_1.derivePoolKey)(ammConfigB, lttId, lttConfig.fundingTokenMint, cpAmmProgramId);
+        // Derive position PDA
+        const [position] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, positionNftMint.toBuffer()], cpAmmProgramId);
+        const [positionB] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, positionNftMintB.toBuffer()], cpAmmProgramId);
+        // Derive pool authority
+        const [poolAuthority] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POOL_AUTHORITY_SEED], cpAmmProgramId);
+        // Derive event authority
+        const [eventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('__event_authority')], cpAmmProgramId);
+        // Derive vault addresses
+        const [lttVault, stableVault] = [
+            (0, utils_1.getVaultPda)(lttId, cpAmmProgramId, pool),
+            (0, utils_1.getVaultPda)(lttConfig.fundingTokenMint, cpAmmProgramId, pool),
+        ];
+        const [lttVaultB, stableVaultB] = [
+            (0, utils_1.getVaultPda)(lttId, cpAmmProgramId, poolB),
+            (0, utils_1.getVaultPda)(lttConfig.fundingTokenMint, cpAmmProgramId, poolB),
+        ];
+        // Get LP authority token accounts
+        const lttTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(lttId, lpAuthority, true);
+        const stableCoinTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lpAuthority, true);
+        // Derive position NFT account
+        const [positionNftAccount] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_NFT_ACCOUNT_SEED, positionNftMint.toBuffer()], cpAmmProgramId);
+        const [positionNftAccountB] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_NFT_ACCOUNT_SEED, positionNftMintB.toBuffer()], cpAmmProgramId);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        const fundingVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true);
+        const maturateIx = await this.program.methods
+            .maturate()
+            .accountsPartial({
+            signer,
+            lpAuthority,
+            lttConfiguration: lttConfigPda,
+            poolAuthority,
+            pool,
+            position,
+            poolB,
+            positionB,
+            fundingVaultAta,
+            collateralVaultAta,
+            tokenAAccount: lttTokenAccount,
+            tokenBAccount: stableCoinTokenAccount,
+            tokenAVault: lttVault,
+            tokenBVault: stableVault,
+            tokenAVaultB: lttVaultB,
+            tokenBVaultB: stableVaultB,
+            tokenAMint: lttId,
+            tokenBMint: lttConfig.fundingTokenMint,
+            positionNftMint,
+            positionNftAccount,
+            positionNftMintB,
+            positionNftAccountB,
+            tokenAProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenBProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            eventAuthority,
+            cpAmmProgram: cpAmmProgramId,
+        })
+            .instruction();
+        return maturateIx;
+    }
+    /**
+     * Stop liquidation
+     * @param lttId The LTT ID
+     * @param signer The signer's public key
+     * @returns Transaction instruction for stopping liquidation
+     */
+    async stopLiquidation(lttId, signer, priceFeed, chainlinkProgram, signedReport, verifierAccounts) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const lttConfig = await this.program.account.lttConfiguration.fetch(lttConfigPda);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true);
+        return this.program.methods
+            .stopLiquidation(Buffer.from(signedReport))
+            .accountsPartial({
+            lttConfiguration: lttConfigPda,
+            signer: signer,
+            priceFeed,
+            chainlinkProgram,
+            collateralVaultAta,
+            collateralTokenMint: lttConfig.collateralTokenMint,
+            stableTokenMint: lttConfig.fundingTokenMint,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+            verifierAccount: verifierAccounts.verifier,
+            accessController: verifierAccounts.accessController,
+            configAccount: verifierAccounts.config,
+        })
+            .instruction();
+    }
+    /**
+     * Harvest funds or NFTs from the LTT harvest vault.
+     * @param lttId The LTT ID
+     * @param manager The manager's keypair or public key
+     * @param positionNftMint The position NFT mint
+     * @returns A transaction instruction to perform the harvest
+     */
+    async harvestLTT(lttId, manager, positionNftMint) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const harvestVault = this.getHarvestVaultPda(lttId);
+        const configPda = this.getConfigPda();
+        const lttConfig = await this.getLttConfig(lttId);
+        // Derive all ATAs
+        const harvestVaultPositionNftAta = (0, spl_token_1.getAssociatedTokenAddressSync)(positionNftMint, harvestVault, true, spl_token_1.TOKEN_2022_PROGRAM_ID);
+        const managerPositionNftAta = (0, spl_token_1.getAssociatedTokenAddressSync)(positionNftMint, manager, true, spl_token_1.TOKEN_2022_PROGRAM_ID);
+        const harvestVaultFundingAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, harvestVault, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const harvestVaultCollateralAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, harvestVault, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const managerFundingAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, manager, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const managerCollateralAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, manager, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const fundingVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const collateralVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.collateralTokenMint, lttConfigPda, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const interestVaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, lttConfigPda, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const instructions = [];
+        // Create missing ATAs if needed
+        const connection = this.program.provider.connection;
+        const harvestVaultPositionNftAtaInfo = await connection.getAccountInfo(harvestVaultPositionNftAta);
+        if (!harvestVaultPositionNftAtaInfo) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(manager, harvestVaultPositionNftAta, harvestVault, positionNftMint, spl_token_1.TOKEN_2022_PROGRAM_ID));
+        }
+        const managerPositionNftAtaInfo = await connection.getAccountInfo(managerPositionNftAta);
+        if (!managerPositionNftAtaInfo) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(manager, managerPositionNftAta, manager, positionNftMint, spl_token_1.TOKEN_2022_PROGRAM_ID));
+        }
+        const harvestVaultFundingAtaInfo = await connection.getAccountInfo(harvestVaultFundingAta);
+        if (!harvestVaultFundingAtaInfo) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(manager, harvestVaultFundingAta, harvestVault, lttConfig.fundingTokenMint, spl_token_1.TOKEN_PROGRAM_ID));
+        }
+        const harvestVaultCollateralAtaInfo = await connection.getAccountInfo(harvestVaultCollateralAta);
+        if (!harvestVaultCollateralAtaInfo) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(manager, harvestVaultCollateralAta, harvestVault, lttConfig.collateralTokenMint, spl_token_1.TOKEN_PROGRAM_ID));
+        }
+        const managerCollateralAtaInfo = await connection.getAccountInfo(managerCollateralAta);
+        if (!managerCollateralAtaInfo) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(manager, managerCollateralAta, manager, lttConfig.collateralTokenMint, spl_token_1.TOKEN_PROGRAM_ID));
+        }
+        // Add the harvest instruction
+        const harvestIx = await this.program.methods
+            .harvest()
+            .accountsPartial({
+            lttConfiguration: lttConfigPda,
+            config: configPda,
+            manager,
+            harvestVault,
+            positionNftMint,
+            harvestVaultPositionNftAta,
+            managerPositionNftAta,
+            harvestVaultFundingAta,
+            managerFundingAta,
+            managerCollateralAta,
+            fundingVaultAta,
+            harvestVaultCollateralAta,
+            interestVaultAta,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            token2022Program: spl_token_1.TOKEN_2022_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction();
+        instructions.push(harvestIx);
+        return instructions;
+    }
+    getHarvestVaultPda(lttId) {
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('harvest_vault'), lttId.toBuffer()], this.program.programId)[0];
+    }
+    /**
+     * Claim LP fees for an active LTT
+     * @param signer The signer's public key
+     * @param lttId The LTT ID
+     * @param positionNftMint The position NFT mint
+     * @param ammConfig The AMM config
+     * @param cpAmmProgramId The CP AMM program ID
+     * @returns Transaction instruction for claiming fees
+     */
+    async claimFees(signer, lttId, positionNftMint, ammConfig, cpAmmProgramId, receiver) {
+        const lttConfigPda = this.getLTTConfigPda(lttId);
+        const configPda = this.getConfigPda();
+        const lttConfig = await this.getLttConfig(lttId);
+        const lpAuthority = this.getLpAuthority();
+        // Derive pool key
+        const pool = (0, utils_1.derivePoolKey)(ammConfig, lttId, lttConfig.fundingTokenMint, cpAmmProgramId);
+        // Derive position PDA
+        const [position] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, positionNftMint.toBuffer()], cpAmmProgramId);
+        // Derive pool authority
+        const [poolAuthority] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POOL_AUTHORITY_SEED], cpAmmProgramId);
+        // Derive event authority
+        const [eventAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('__event_authority')], cpAmmProgramId);
+        // Derive vault addresses
+        const [lttVault, stableVault] = [
+            (0, utils_1.getVaultPda)(lttId, cpAmmProgramId, pool),
+            (0, utils_1.getVaultPda)(lttConfig.fundingTokenMint, cpAmmProgramId, pool),
+        ];
+        // Get receiver's token accounts for receiving fees
+        const receiverTokenAAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(lttId, receiver, true);
+        const receiverTokenBAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(lttConfig.fundingTokenMint, receiver, true);
+        // Get position NFT account
+        const [positionNftAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position_nft_account'), positionNftMint.toBuffer()], cpAmmProgramId);
+        return await this.program.methods
+            .claimFees()
+            .accountsPartial({
+            signer,
+            lpAuthority,
+            config: configPda,
+            lttConfiguration: lttConfigPda,
+            pool,
+            position,
+            poolAuthority,
+            lttMint: lttId,
+            stableCoinMint: lttConfig.fundingTokenMint,
+            lttVaultAta: lttVault,
+            stableCoinVaultAta: stableVault,
+            receiverTokenAAccount: receiverTokenAAccount,
+            receiverTokenBAccount: receiverTokenBAccount,
+            positionNftAccount,
+            eventAuthority,
+            tokenAProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenBProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            cpAmmProgram: cpAmmProgramId,
+            systemProgram: web3_js_2.SystemProgram.programId,
+        })
+            .instruction();
+    }
+}
+exports.XitadelProgram = XitadelProgram;