@xitadel-fi/sdk 0.2.3 → 0.2.5

package/dist/sdk/src/program.d.ts

@@ -454,7 +454,12 @@ export declare class XitadelProgram {
         verifier: PublicKey;
         accessController: PublicKey;
         config: PublicKey;
-    }): Promise<TransactionInstruction>;
+    }): Promise<{
+        maturateIx: TransactionInstruction;
+        createLookupTableIx: TransactionInstruction;
+        extendLookupTableIx: TransactionInstruction[];
+        lookupTableAddress: PublicKey;
+    }>;
     /**
      * Stop liquidation
      * @param lttId The LTT ID
@@ -476,15 +481,12 @@ export declare class XitadelProgram {
     harvestLTT(lttId: PublicKey, manager: PublicKey, positionNftMint: PublicKey): Promise<TransactionInstruction[]>;
     getHarvestVaultPda(lttId: PublicKey): PublicKey;
     /**
-     * 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
+     * Claim LP fees from both cp_amm positions of an LTT.
+     * Pool B accounts default to pool A accounts when LTT is single-pool
+     * (positionNftMintB == default). The on-chain program skips the pool B
+     * CPI in that case.
      */
-    claimFees(signer: PublicKey, lttId: PublicKey, positionNftMint: PublicKey, ammConfig: PublicKey, cpAmmProgramId: PublicKey, receiver: PublicKey): Promise<TransactionInstruction>;
+    claimFees(signer: PublicKey, lttId: PublicKey, positionNftMint: PublicKey, ammConfig: PublicKey, cpAmmProgramId: PublicKey, receiver: PublicKey, positionNftMintB?: PublicKey, ammConfigB?: PublicKey): Promise<TransactionInstruction>;
     /**
      * Deposit stake to flash trade from collateral vault
      * @param lttId The LTT ID
@@ -536,4 +538,13 @@ export declare class XitadelProgram {
      * @returns Transaction instruction for withdrawing stake from flash trade
      */
     withdrawStakeFlashTrade(lttId: PublicKey, authority: PublicKey, unstakeAmount: BN, lpTokenMint: PublicKey, flashTradeProgramId: PublicKey, transferAuthority: PublicKey, perpetuals: PublicKey, pool: PublicKey, flpStakeAccount: PublicKey, poolStakedLpVault: PublicKey, rewardCustody: PublicKey, eventAuthority: PublicKey): Promise<TransactionInstruction>;
+    /**
+     * Build a `version` instruction.
+     */
+    versionInstruction(): Promise<TransactionInstruction>;
+    /**
+     * Return the deployed program's git commit hash by simulating
+     * the `version` instruction and parsing its log output.
+     */
+    getVersion(): Promise<string>;
 }

package/dist/sdk/src/program.js

@@ -22,16 +22,17 @@ exports.SEEDS = {
 };
 class XitadelProgram {
     constructor(provider, address) {
-        const idl = Object.assign(xitadel_json_1.default, {});
-        if (address) {
-            idl.address = address;
+        if (process.env.NODE_ENV === 'development') {
+            const workspace = require('@coral-xyz/anchor').workspace;
+            this.program = workspace.Xitadel;
+        }
+        else {
+            const idl = Object.assign(xitadel_json_1.default, {});
+            if (address) {
+                idl.address = address;
+            }
+            this.program = new anchor_1.Program(idl, provider);
         }
-        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;
@@ -709,7 +710,9 @@ class XitadelProgram {
             }));
         }
         const signedReport = params.signedReport ?? Buffer.alloc(0);
-        const signedReportBuf = Buffer.isBuffer(signedReport) ? signedReport : Buffer.from(signedReport);
+        const signedReportBuf = Buffer.isBuffer(signedReport)
+            ? signedReport
+            : Buffer.from(signedReport);
         const configPda = this.getConfigPda();
         instructions.push(await this.program.methods
             .activateLtt(signedReportBuf)
@@ -809,6 +812,56 @@ class XitadelProgram {
         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 [createLookupTableIx, lookupTableAddress] = web3_js_1.AddressLookupTableProgram.createLookupTable({
+            authority: signer,
+            payer: signer,
+            recentSlot: await this.program.provider.connection.getSlot(),
+        });
+        const allAddresses = [
+            lttConfigPda,
+            lpAuthority,
+            poolAuthority,
+            pool,
+            position,
+            poolB,
+            positionB,
+            fundingVaultAta,
+            collateralVaultAta,
+            lttConfig.collateralTokenMint,
+            priceFeed,
+            chainLinkProgram,
+            verifierAccounts.verifier,
+            verifierAccounts.accessController,
+            verifierAccounts.config,
+            lttTokenAccount,
+            stableCoinTokenAccount,
+            lttVault,
+            stableVault,
+            lttVaultB,
+            stableVaultB,
+            lttId,
+            lttConfig.fundingTokenMint,
+            positionNftMint,
+            positionNftAccount,
+            positionNftMintB,
+            positionNftAccountB,
+            spl_token_1.TOKEN_PROGRAM_ID,
+            spl_token_1.TOKEN_PROGRAM_ID,
+            eventAuthority,
+            cpAmmProgramId,
+        ];
+        const uniqueAddressesStr = new Set(allAddresses.map(a => a.toBase58()));
+        const uniqueAddresses = Array.from(uniqueAddressesStr).map(a => new web3_js_1.PublicKey(a));
+        const extendLookupTableIxs = [];
+        const chunkSize = 15;
+        for (let i = 0; i < uniqueAddresses.length; i += chunkSize) {
+            extendLookupTableIxs.push(web3_js_1.AddressLookupTableProgram.extendLookupTable({
+                payer: signer,
+                authority: signer,
+                lookupTable: lookupTableAddress,
+                addresses: uniqueAddresses.slice(i, i + chunkSize),
+            }));
+        }
         const configPda = this.getConfigPda();
         const maturateIx = await this.program.methods
             .maturate(Buffer.from(reportBuffer))
@@ -848,7 +901,12 @@ class XitadelProgram {
             cpAmmProgram: cpAmmProgramId,
         })
             .instruction();
-        return maturateIx;
+        return {
+            maturateIx,
+            createLookupTableIx,
+            extendLookupTableIx: extendLookupTableIxs,
+            lookupTableAddress,
+        };
     }
     /**
      * Stop liquidation
@@ -977,37 +1035,46 @@ class XitadelProgram {
         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
+     * Claim LP fees from both cp_amm positions of an LTT.
+     * Pool B accounts default to pool A accounts when LTT is single-pool
+     * (positionNftMintB == default). The on-chain program skips the pool B
+     * CPI in that case.
      */
-    async claimFees(signer, lttId, positionNftMint, ammConfig, cpAmmProgramId, receiver) {
+    async claimFees(signer, lttId, positionNftMint, ammConfig, cpAmmProgramId, receiver, positionNftMintB, ammConfigB) {
         const lttConfigPda = this.getLTTConfigPda(lttId);
         const configPda = this.getConfigPda();
         const lttConfig = await this.getLttConfig(lttId);
         const lpAuthority = this.getLpAuthority();
-        // Derive pool key
+        // Pool A
         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 [positionNftAccount] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position_nft_account'), positionNftMint.toBuffer()], cpAmmProgramId);
         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);
+        // Pool B: prefer explicit args; fall back to on-chain position_nft_mint_b
+        const onChainMintB = lttConfig.positionNftMintB;
+        const hasPoolB = (positionNftMintB && !positionNftMintB.equals(web3_js_1.PublicKey.default)) ||
+            (onChainMintB && !onChainMintB.equals(web3_js_1.PublicKey.default));
+        let poolB = pool;
+        let positionB = position;
+        let lttVaultB = lttVault;
+        let stableVaultB = stableVault;
+        let positionNftAccountB = positionNftAccount;
+        if (hasPoolB) {
+            const mintB = (positionNftMintB ?? onChainMintB);
+            const cfgB = ammConfigB ?? ammConfig;
+            poolB = (0, utils_1.derivePoolKey)(cfgB, lttId, lttConfig.fundingTokenMint, cpAmmProgramId);
+            [positionB] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, mintB.toBuffer()], cpAmmProgramId);
+            lttVaultB = (0, utils_1.getVaultPda)(lttId, cpAmmProgramId, poolB);
+            stableVaultB = (0, utils_1.getVaultPda)(lttConfig.fundingTokenMint, cpAmmProgramId, poolB);
+            [positionNftAccountB] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('position_nft_account'), mintB.toBuffer()], cpAmmProgramId);
+        }
         return await this.program.methods
             .claimFees()
             .accountsPartial({
@@ -1022,9 +1089,14 @@ class XitadelProgram {
             stableCoinMint: lttConfig.fundingTokenMint,
             lttVaultAta: lttVault,
             stableCoinVaultAta: stableVault,
-            receiverTokenAAccount: receiverTokenAAccount,
-            receiverTokenBAccount: receiverTokenBAccount,
+            receiverTokenAAccount,
+            receiverTokenBAccount,
             positionNftAccount,
+            poolB,
+            positionB,
+            lttVaultAtaB: lttVaultB,
+            stableCoinVaultAtaB: stableVaultB,
+            positionNftAccountB,
             eventAuthority,
             tokenAProgram: spl_token_1.TOKEN_PROGRAM_ID,
             tokenBProgram: spl_token_1.TOKEN_PROGRAM_ID,
@@ -1170,5 +1242,24 @@ class XitadelProgram {
             .remainingAccounts([...tokenStakeAccounts])
             .instruction();
     }
+    /**
+     * Build a `version` instruction.
+     */
+    async versionInstruction() {
+        return this.program.methods.version().accounts({}).instruction();
+    }
+    /**
+     * Return the deployed program's git commit hash by simulating
+     * the `version` instruction and parsing its log output.
+     */
+    async getVersion() {
+        const sim = await this.program.methods.version().accounts({}).simulate();
+        const logs = sim.raw ?? [];
+        const versionLog = logs.find((l) => l.includes('program_version:'));
+        if (!versionLog) {
+            throw new Error('program_version log not found in simulation output');
+        }
+        return versionLog.split('program_version:')[1].trim();
+    }
 }
 exports.XitadelProgram = XitadelProgram;

package/dist/target/idl/xitadel.json

@@ -650,6 +650,26 @@
                     "name": "position_nft_account",
                     "writable": true
                 },
+                {
+                    "name": "pool_b",
+                    "writable": true
+                },
+                {
+                    "name": "position_b",
+                    "writable": true
+                },
+                {
+                    "name": "ltt_vault_ata_b",
+                    "writable": true
+                },
+                {
+                    "name": "stable_coin_vault_ata_b",
+                    "writable": true
+                },
+                {
+                    "name": "position_nft_account_b",
+                    "writable": true
+                },
                 {
                     "name": "event_authority",
                     "writable": true
@@ -5022,6 +5042,21 @@
                 }
             ]
         },
+        {
+            "name": "version",
+            "discriminator": [
+                118,
+                65,
+                195,
+                198,
+                129,
+                216,
+                252,
+                192
+            ],
+            "accounts": [],
+            "args": []
+        },
         {
             "name": "withdraw_collateral",
             "discriminator": [

package/dist/target/types/xitadel.d.ts

@@ -656,6 +656,26 @@ export type Xitadel = {
                     "name": "positionNftAccount";
                     "writable": true;
                 },
+                {
+                    "name": "poolB";
+                    "writable": true;
+                },
+                {
+                    "name": "positionB";
+                    "writable": true;
+                },
+                {
+                    "name": "lttVaultAtaB";
+                    "writable": true;
+                },
+                {
+                    "name": "stableCoinVaultAtaB";
+                    "writable": true;
+                },
+                {
+                    "name": "positionNftAccountB";
+                    "writable": true;
+                },
                 {
                     "name": "eventAuthority";
                     "writable": true;
@@ -5028,6 +5048,21 @@ export type Xitadel = {
                 }
             ];
         },
+        {
+            "name": "version";
+            "discriminator": [
+                118,
+                65,
+                195,
+                198,
+                129,
+                216,
+                252,
+                192
+            ];
+            "accounts": [];
+            "args": [];
+        },
         {
             "name": "withdrawCollateral";
             "discriminator": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@xitadel-fi/sdk",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "SDK for interacting with the Xitadel program",
   "main": "dist/sdk/src/index.js",
   "types": "dist/sdk/src/index.d.ts",