@lavarage/sdk 7.5.6 → 7.5.8

package/dist/index.d.mts

@@ -692,6 +692,69 @@ type Lavarage$1 = {
                 }
             ];
         },
+        {
+            "name": "tradingCloseRepaySolWithReferral";
+            "accounts": [
+                {
+                    "name": "positionAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "trader";
+                    "isMut": true;
+                    "isSigner": true;
+                },
+                {
+                    "name": "tradingPool";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "nodeWallet";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "systemProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "clock";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "randomAccountAsId";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "feeReceipient";
+                    "isMut": true;
+                    "isSigner": false;
+                }
+            ];
+            "args": [
+                {
+                    "name": "closingPositionSize";
+                    "type": "u64";
+                },
+                {
+                    "name": "closeType";
+                    "type": "u64";
+                },
+                {
+                    "name": "discountBps";
+                    "type": "u64";
+                },
+                {
+                    "name": "referralBps";
+                    "type": "u64";
+                }
+            ];
+        },
         {
             "name": "tradingClosePartialRepaySol";
             "accounts": [
@@ -2371,6 +2434,89 @@ type Lavarage = {
                 }
             ];
         },
+        {
+            "name": "tradingCloseRepaySolWithReferral";
+            "accounts": [
+                {
+                    "name": "positionAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "trader";
+                    "isMut": true;
+                    "isSigner": true;
+                },
+                {
+                    "name": "tradingPool";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "nodeWallet";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "systemProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "clock";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "randomAccountAsId";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "mint";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "fromTokenAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "toTokenAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "feeTokenAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "tokenProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                }
+            ];
+            "args": [
+                {
+                    "name": "closingPositionSize";
+                    "type": "u64";
+                },
+                {
+                    "name": "closeType";
+                    "type": "u64";
+                },
+                {
+                    "name": "discountBps";
+                    "type": "u64";
+                },
+                {
+                    "name": "referralBps";
+                    "type": "u64";
+                }
+            ];
+        },
         {
             "name": "tradingPartialRepaySol";
             "accounts": [
@@ -3479,10 +3625,30 @@ interface LiquidationEvent {
 
 /**
  * Creates an unsigned transaction to open a trading position on EVM chain
+ * @group EVM
+ * @category Trading
  * @param provider - Ethers provider
  * @param borrowerOpsContractAddress - BorrowerOperations contract address
  * @param params - Trading parameters
  * @returns Unsigned transaction object
+ *
+ * @example
+ * ```typescript
+ * const tx = await openPositionEvm(
+ *   provider,
+ *   "0x123...", // contract address
+ *   {
+ *     buyingCode: "0x...", // 1inch swap data
+ *     tokenCollateral: "0x456...", // USDC address
+ *     borrowAmount: ethers.parseEther("2"),
+ *     tokenHolder: "0x789...",
+ *     inchRouter: "0xabc...",
+ *     buyerContribution: ethers.parseEther("1") // 1 ETH margin
+ *   }
+ * );
+ *
+ * const receipt = await signer.sendTransaction(tx);
+ * ```
  */
 declare const openPositionEvm: (provider: Provider, borrowerOpsContractAddress: string, { buyingCode, tokenCollateral, borrowAmount, tokenHolder, inchRouter, integratorFeeAddress, buyerContribution, tokenApproval, gasLimit, gasPrice, }: {
     buyingCode: string;
@@ -3498,10 +3664,29 @@ declare const openPositionEvm: (provider: Provider, borrowerOpsContractAddress:
 }) => Promise<ContractTransaction>;
 /**
  * Creates an unsigned transaction to close a trading position on EVM chain
+ * @group EVM
+ * @category Trading
  * @param provider - Ethers provider
  * @param borrowerOpsContractAddress - BorrowerOperations contract address
  * @param params - Trading parameters
  * @returns Unsigned transaction object
+ *
+ * @example
+ * ```typescript
+ * const tx = await closePositionEvm(
+ *   provider,
+ *   "0x123...", // contract address
+ *   {
+ *     loanId: 1,
+ *     sellingCode: "0x...", // 1inch swap data for selling
+ *     tokenHolder: "0x789...",
+ *     inchRouter: "0xabc...",
+ *     integratorFeeAddress: "0xdef..." // optional
+ *   }
+ * );
+ *
+ * const receipt = await signer.sendTransaction(tx);
+ * ```
  */
 declare const closePositionEvm: (provider: Provider, borrowerOpsContractAddress: string, { loanId, sellingCode, tokenHolder, inchRouter, integratorFeeAddress, gasLimit, gasPrice, tokenApproval, }: {
     loanId: BigNumberish;
@@ -3515,57 +3700,173 @@ declare const closePositionEvm: (provider: Provider, borrowerOpsContractAddress:
 }) => Promise<ContractTransaction>;
 /**
  * Get all positions from active loans
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - TokenHolder contract address
  * @returns Array of active positions
+ *
+ * @example
+ * ```typescript
+ * const positions = await getPositionsEvm(
+ *   provider,
+ *   "0x123..." // TokenHolder address
+ * );
+ *
+ * console.log(`Found ${positions.length} active positions`);
+ *
+ * positions.forEach(pos => {
+ *   console.log(`Loan #${pos.loanId}: ${pos.collateralAmount} collateral`);
+ * });
+ * ```
  */
 declare function getPositionsEvm(provider: Provider, tokenHolderContractAddress: string): Promise<BuyEvent[]>;
 /**
  * Get closed positions from events
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param borrowerOpsContractAddress - BorrowerOperations contract address
  * @param fromBlock - Block to start searching from
  * @returns Array of Sell events representing closed positions
+ *
+ * @example
+ * ```typescript
+ * const closedPositions = await getClosedPositionsEvm(
+ *   provider,
+ *   "0x123...", // BorrowerOps address
+ *   50000000 // optional: custom start block
+ * );
+ *
+ * console.log(`Found ${closedPositions.length} closed positions`);
+ *
+ * // Check profit/loss
+ * closedPositions.forEach(pos => {
+ *   console.log(`Loan #${pos.loanId}: ${pos.profit > 0 ? 'Profit' : 'Loss'}`);
+ * });
  */
 declare function getClosedPositionsEvm(provider: Provider, borrowerOpsContractAddress: string, fromBlock?: number): Promise<SellEvent[]>;
 /**
  * Get liquidated positions from events
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param borrowerOpsContractAddress - BorrowerOperations contract address
  * @param fromBlock - Block to start searching from
  * @returns Array of Liquidation events representing liquidated positions
+ * @example
+ * ```typescript
+ * const liquidations = await getLiquidatedPositionsEvm(
+ *   provider,
+ *   "0x123...", // BorrowerOps address
+ *   50000000 // optional: custom start block
+ * );
+ *
+ * console.log(`Found ${liquidations.length} liquidated positions`);
+ *
+ * // Analyze liquidation data
+ * liquidations.forEach(liq => {
+ *   console.log(`Loan #${liq.loanId}: liquidated ${liq.closingPositionSize}`);
+ *   console.log(`Liquidator repaid: ${liq.liquidatorRepaidAmount}`);
+ * });
+ * ```
  */
 declare function getLiquidatedPositionsEvm(provider: Provider, borrowerOpsContractAddress: string, fromBlock?: number): Promise<LiquidationEvent[]>;
 /**
  * Get a loan by its ID from TokenHolder contract
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param loanId - ID of the loan to retrieve
  * @returns Loan object
+ *
+ * @example
+ * ```typescript
+ * const loan = await getLoanEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   42 // loan ID
+ * );
+ *
+ * console.log(`Loan #${loan.id}`);
+ * console.log(`Borrower: ${loan.borrower}`);
+ * console.log(`Amount: ${loan.amount}`);
+ * console.log(`Collateral: ${loan.collateralAmount}`);
+ * ```
  */
 declare function getLoanEvm(provider: Provider, tokenHolderContractAddress: string, loanId: BigNumberish): Promise<Loan>;
 /**
  * Get all active loans for a user
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param userAddress - Address of the user to get loans for
  * @returns Array of loans belonging to the user
+ *
+ * @example
+ * ```typescript
+ * const userLoans = await getUserLoansEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   "0x456..." // user address
+ * );
+ *
+ * console.log(`User has ${userLoans.length} active loans`);
+ *
+ * userLoans.forEach(loan => {
+ *   console.log(`Loan #${loan.id}: ${loan.amount} borrowed`);
+ * });
+ * ```
  */
 declare function getUserLoansEvm(provider: Provider, tokenHolderContractAddress: string, userAddress: string): Promise<Loan[]>;
 /**
  * Get collateral information for a specific token
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param collateralAddress - Address of the collateral token
  * @returns Collateral object
+ *
+ * @example
+ * ```typescript
+ * const collateralInfo = await getCollateralInfoEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   "0x456..." // USDC or other collateral token address
+ * );
+ *
+ * console.log(`Collateral: ${collateralInfo.symbol}`);
+ * console.log(`Max LTV: ${collateralInfo.maxLTV}`);
+ * console.log(`Liquidation threshold: ${collateralInfo.liquidationThreshold}`);
+ * ```
  */
 declare function getCollateralInfoEvm(provider: Provider, tokenHolderContractAddress: string, collateralAddress: string): Promise<Collateral>;
 /**
  * Get all available collateral information
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param collateralAddresses - Array of collateral token addresses
  * @returns Array of active collaterals
+ *
+ * @example
+ * ```typescript
+ * const collaterals = await getOffersEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   ["0x456...", "0x789...", "0xabc..."] // token addresses to check
+ * );
+ *
+ * console.log(`Found ${collaterals.length} available collaterals`);
+ *
+ * collaterals.forEach(({ address, collateral }) => {
+ *   console.log(`Token ${address}: LTV ${collateral.maxLTV}%`);
+ * });
+ * ```
  */
 declare function getOffersEvm(provider: Provider, tokenHolderContractAddress: string, collateralAddresses: string[]): Promise<Array<{
     address: string;
@@ -3573,63 +3874,196 @@ declare function getOffersEvm(provider: Provider, tokenHolderContractAddress: st
 }>>;
 /**
  * Get the opening fee percentage
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param borrowerOpsContractAddress - BorrowerOperations contract address
  * @returns Opening fee as a BigNumber
+ *
+ * @example
+ * ```typescript
+ * const openingFee = await getOpeningFeeEvm(
+ *   provider,
+ *   "0x123..." // BorrowerOps address
+ * );
+ *
+ * // Convert to percentage (assuming 18 decimals)
+ * const feePercent = Number(openingFee) / 1e16; // e.g., 0.5%
+ * console.log(`Opening fee: ${feePercent}%`);
+ * ```
  */
 declare function getOpeningFeeEvm(provider: Provider, borrowerOpsContractAddress: string): Promise<bigint>;
 /**
  * Get the profit fee percentage
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param borrowerOpsContractAddress - BorrowerOperations contract address
  * @returns Profit fee as a BigNumber
+ *
+ * @example
+ * ```typescript
+ * const profitFee = await getProfitFeeEvm(
+ *   provider,
+ *   "0x123..." // BorrowerOps address
+ * );
+ *
+ * // Convert to percentage (assuming 18 decimals)
+ * const feePercent = Number(profitFee) / 1e16; // e.g., 1%
+ * console.log(`Profit fee: ${feePercent}%`);
+ * ```
  */
 declare function getProfitFeeEvm(provider: Provider, borrowerOpsContractAddress: string): Promise<bigint>;
 /**
  * Get the token balance of the token holder contract
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @returns Token balance as a BigNumber
+ *
+ * @example
+ * ```typescript
+ * const balance = await getTokenBalanceEvm(
+ *   provider,
+ *   "0x123..." // TokenHolder address
+ * );
+ *
+ * // Format for display (assuming 18 decimals)
+ * const formatted = ethers.formatEther(balance);
+ * console.log(`Contract balance: ${formatted} ETH`);
+ * ```
  */
 declare function getTokenBalanceEvm(provider: Provider, tokenHolderContractAddress: string): Promise<bigint>;
 /**
  * Get the active loan count
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @returns Number of active loans
+ *
+ * @example
+ * ```typescript
+ * const loanCount = await getActiveLoanCountEvm(
+ *   provider,
+ *   "0x123..." // TokenHolder address
+ * );
+ *
+ * console.log(`Total active loans: ${loanCount}`);
+ *
+ * // Use for statistics or monitoring
+ * if (loanCount > 1000n) {
+ *   console.log("High activity detected");
+ * }
+ * ```
  */
 declare function getActiveLoanCountEvm(provider: Provider, tokenHolderContractAddress: string): Promise<bigint>;
 /**
  * Get a batch of active loans
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param startIndex - Starting index in the activeLoanIds array
  * @param batchSize - Number of loans to retrieve
  * @returns Array of active loans
+ *
+ * @example
+ * ```typescript
+ * const loans = await getActiveLoansBatchEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   0, // start from first loan
+ *   100 // get 100 loans
+ * );
+ *
+ * console.log(`Retrieved ${loans.length} loans`);
+ *
+ * // Process batch
+ * loans.forEach(loan => {
+ *   console.log(`Loan #${loan.id}: ${loan.borrower}`);
+ * });
+ * ```
  */
 declare function getActiveLoansBatchEvm(provider: Provider, tokenHolderContractAddress: string, startIndex: BigNumberish, batchSize: BigNumberish): Promise<Loan[]>;
 /**
  * Get all loans for a specific borrower
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param borrowerAddress - Address of the borrower
  * @returns Array of loans belonging to the borrower
+ *
+ * @example
+ * ```typescript
+ * const userLoans = await getLoansByBorrowerEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   "0x456..." // borrower address
+ * );
+ *
+ * console.log(`Borrower has ${userLoans.length} loans`);
+ *
+ * userLoans.forEach(loan => {
+ *   console.log(`Loan #${loan.id}: ${loan.collateralAmount} collateral`);
+ * });
+ * ```
  */
 declare function getLoansByBorrowerEvm(provider: Provider, tokenHolderContractAddress: string, borrowerAddress: string): Promise<Loan[]>;
 /**
  * Get current exposure for a collateral
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param collateralAddress - Address of the collateral token
  * @returns Current exposure as a BigNumber
+ *
+ * @example
+ * ```typescript
+ * const exposure = await getCollateralExposureEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   "0x456..." // collateral token address
+ * );
+ *
+ * console.log(`Current exposure: ${ethers.formatEther(exposure)}`);
+ *
+ * // Check if near limit
+ * const maxExposure = 1000000n;
+ * if (exposure > maxExposure * 90n / 100n) {
+ *   console.log("Warning: 90% exposure reached");
+ * }
+ * ```
  */
 declare function getCollateralExposureEvm(provider: Provider, tokenHolderContractAddress: string, collateralAddress: string): Promise<bigint>;
 /**
  * Get available exposure for a collateral
+ * @group EVM
+ * @category Queries
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param collateralAddress - Address of the collateral token
  * @returns Available exposure as a BigNumber
+ *
+ * @example
+ * ```typescript
+ * const available = await getAvailableExposureEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   "0x456..." // collateral token address
+ * );
+ *
+ * console.log(`Available exposure: ${ethers.formatEther(available)}`);
+ *
+ * // Check if can open new position
+ * const newPositionSize = ethers.parseEther("10");
+ * if (available >= newPositionSize) {
+ *   console.log("Sufficient exposure available");
+ * }
+ * ```
  */
 declare function getAvailableExposureEvm(provider: Provider, tokenHolderContractAddress: string, collateralAddress: string): Promise<bigint>;
 /**
@@ -3648,6 +4082,8 @@ declare const liquidatePositionEvm: (provider: Provider, borrowerOpsContractAddr
 }) => Promise<ContractTransaction>;
 /**
  * Update max lend per token for multiple collaterals in batch
+ * @group EVM
+ * @category Operations
  * @param provider - Ethers provider
  * @param tokenHolderContractAddress - Address of the TokenHolder contract
  * @param collateralAddresses - Array of collateral token addresses
@@ -3655,6 +4091,24 @@ declare const liquidatePositionEvm: (provider: Provider, borrowerOpsContractAddr
  * @param gasLimit - Optional gas limit
  * @param gasPrice - Optional gas price
  * @returns Unsigned transaction object
+ *
+ * @example
+ * ```typescript
+ * const tx = await updateMaxLendPerTokenBatchEvm(
+ *   provider,
+ *   "0x123...", // TokenHolder address
+ *   {
+ *     collateralAddresses: ["0x456...", "0x789..."],
+ *     newMaxLendPerTokens: [
+ *       ethers.parseEther("1000"),
+ *       ethers.parseEther("500")
+ *     ]
+ *   }
+ * );
+ *
+ * const receipt = await signer.sendTransaction(tx);
+ * console.log("Max lend limits updated");
+ * ```
  */
 declare const updateMaxLendPerTokenBatchEvm: (provider: Provider, tokenHolderContractAddress: string, { collateralAddresses, newMaxLendPerTokens, gasLimit, gasPrice, }: {
     collateralAddresses: string[];
@@ -3663,9 +4117,88 @@ declare const updateMaxLendPerTokenBatchEvm: (provider: Provider, tokenHolderCon
     gasPrice?: string | number;
 }) => Promise<ContractTransaction>;
 
+/**
+ * Derives a node wallet PDA for lending operations
+ *
+ * @group Lending
+ * @category Utilities
+ *
+ * @param operatorPublicKey - The operator's public key
+ * @param mintPublicKey - The token mint public key
+ * @param programId - The Lavarage program ID
+ *
+ * @returns The derived node wallet PDA
+ *
+ * @example
+ * ```typescript
+ * const nodeWallet = getNodeWalletPDA(
+ *   operatorPublicKey,
+ *   usdcMint,
+ *   programId
+ * );
+ * ```
+ */
 declare function getNodeWalletPDA(operatorPublicKey: PublicKey, mintPublicKey: PublicKey, programId: PublicKey): PublicKey;
+/**
+ * Derives a trading pool PDA for lending operations
+ *
+ * @group Lending
+ * @category Utilities
+ *
+ * @param poolOwnerPublicKey - The pool owner's public key
+ * @param tokenPublicKey - The token mint public key
+ * @param programId - The Lavarage program ID
+ *
+ * @returns The derived trading pool PDA
+ *
+ * @example
+ * ```typescript
+ * const poolPDA = getTradingPoolPDA(
+ *   poolOwnerPublicKey,
+ *   usdcMint,
+ *   programId
+ * );
+ * ```
+ */
 declare function getTradingPoolPDA(poolOwnerPublicKey: PublicKey, tokenPublicKey: PublicKey, programId: PublicKey): PublicKey;
 declare function getWithdrawalAccessListPDA(programId: PublicKey): PublicKey;
+/**
+ * Deposits funds into a node wallet for lending operations
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage V1 program instance
+ * @param params - Deposit parameters
+ * @param params.nodeWallet - The node wallet PDA to deposit into
+ * @param params.mint - Token mint address (optional for V1 SOL deposits)
+ * @param params.funder - The account providing the funds
+ * @param params.amount - Amount to deposit (in lamports for SOL or token units)
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to deposit funds
+ *
+ * @example
+ * ```typescript
+ * // Deposit SOL
+ * const tx = await depositFunds(lavarageProgram, {
+ *   nodeWallet: nodeWalletPDA,
+ *   funder: lenderPublicKey,
+ *   amount: 1000000000 // 1 SOL
+ * });
+ *
+ * // Deposit USDC
+ * const tx = await depositFunds(lavarageProgram, {
+ *   nodeWallet: nodeWalletPDA,
+ *   mint: usdcMint.toString(),
+ *   funder: lenderPublicKey,
+ *   amount: 1000000 // 1 USDC (6 decimals)
+ * });
+ * ```
+ *
+ * @see {@link withdrawFundsV1} - Withdraw funds from a node wallet
+ * @see {@link withdrawFunds} - Unified withdraw function for both V1 and V2
+ */
 declare function depositFunds(lavarageProgram: Program<Lavarage$1>, params: {
     nodeWallet: PublicKey;
     mint?: string;
@@ -3673,12 +4206,73 @@ declare function depositFunds(lavarageProgram: Program<Lavarage$1>, params: {
     amount: number;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Withdraws funds from a node wallet on Lavarage V1
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage V1 program instance
+ * @param params - Withdrawal parameters
+ * @param params.nodeWallet - The node wallet PDA to withdraw from
+ * @param params.funder - The account receiving the withdrawn funds
+ * @param params.amount - Amount to withdraw in lamports
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to withdraw funds
+ *
+ * @example
+ * ```typescript
+ * const tx = await withdrawFundsV1(lavarageProgram, {
+ *   nodeWallet: nodeWalletPDA,
+ *   funder: lenderPublicKey,
+ *   amount: 1000000000 // 1 SOL
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ * @see {@link depositFunds} - Deposit funds into a node wallet
+ * @see {@link withdrawFunds} - Unified withdraw function for both V1 and V2
+ */
 declare function withdrawFundsV1(lavarageProgram: Program<Lavarage$1>, params: {
     nodeWallet: PublicKey;
     funder: PublicKey;
     amount: number;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Withdraws funds from a node wallet on Lavarage V2
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage V2 program instance
+ * @param params - Withdrawal parameters
+ * @param params.nodeWallet - The node wallet PDA to withdraw from
+ * @param params.funder - The account receiving the withdrawn funds
+ * @param params.mint - Token mint address
+ * @param params.amount - Amount to withdraw in token units
+ * @param params.fromTokenAccount - Optional source token account (auto-derived if not provided)
+ * @param params.toTokenAccount - Optional destination token account (auto-derived if not provided)
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to withdraw funds
+ *
+ * @example
+ * ```typescript
+ * // Withdraw USDC
+ * const tx = await withdrawFundsV2(lavarageProgram, {
+ *   nodeWallet: nodeWalletPDA,
+ *   funder: lenderPublicKey,
+ *   mint: usdcMint.toString(),
+ *   amount: 1000000 // 1 USDC (6 decimals)
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ * @see {@link depositFunds} - Deposit funds into a node wallet
+ * @see {@link withdrawFunds} - Unified withdraw function for both V1 and V2
+ */
 declare function withdrawFundsV2(lavarageProgram: Program<Lavarage>, params: {
     nodeWallet: PublicKey;
     funder: PublicKey;
@@ -3688,6 +4282,45 @@ declare function withdrawFundsV2(lavarageProgram: Program<Lavarage>, params: {
     toTokenAccount?: PublicKey;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Withdraws funds from a node wallet (supports both V1 and V2)
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param params - Withdrawal parameters
+ * @param params.nodeWallet - The node wallet PDA to withdraw from
+ * @param params.funder - The account receiving the withdrawn funds
+ * @param params.amount - Amount to withdraw
+ * @param params.mint - Token mint address (required for V2, omit for V1 SOL withdrawal)
+ * @param params.fromTokenAccount - Optional source token account (V2 only)
+ * @param params.toTokenAccount - Optional destination token account (V2 only)
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to withdraw funds
+ *
+ * @example
+ * ```typescript
+ * // V1: Withdraw SOL
+ * const tx = await withdrawFunds(lavarageProgram, {
+ *   nodeWallet: nodeWalletPDA,
+ *   funder: lenderPublicKey,
+ *   amount: 1000000000 // 1 SOL
+ * });
+ *
+ * // V2: Withdraw USDC
+ * const tx = await withdrawFunds(lavarageProgram, {
+ *   nodeWallet: nodeWalletPDA,
+ *   funder: lenderPublicKey,
+ *   mint: usdcMint.toString(),
+ *   amount: 1000000 // 1 USDC
+ * });
+ * ```
+ * @see {@link depositFunds} - Deposit funds into a node wallet
+ * @see {@link withdrawFundsV1} - V1 specific implementation
+ * @see {@link withdrawFundsV2} - V2 specific implementation
+ */
 declare function withdrawFunds(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, params: {
     nodeWallet: PublicKey;
     funder: PublicKey;
@@ -3697,6 +4330,38 @@ declare function withdrawFunds(lavarageProgram: Program<Lavarage$1> | Program<La
     toTokenAccount?: PublicKey;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Creates a lending offer/pool on Lavarage
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param params - Offer creation parameters
+ * @param params.tradingPool - The trading pool PDA
+ * @param params.poolOwner - The pool owner's public key
+ * @param params.mint - The collateral token mint address
+ * @param params.quoteMint - The quote token mint address
+ * @param params.interestRate - Interest rate for the pool
+ * @param params.maxExposure - Maximum exposure limit
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to create the offer
+ *
+ * @example
+ * ```typescript
+ * const tx = await createOffer(lavarageProgram, {
+ *   tradingPool: poolPDA,
+ *   poolOwner: lenderPublicKey,
+ *   mint: collateralMint.toString(),
+ *   quoteMint: usdcMint.toString(),
+ *   interestRate: 500, // 5%
+ *   maxExposure: 1000000
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ */
 declare function createOffer(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, params: {
     tradingPool: PublicKey;
     poolOwner: PublicKey;
@@ -3707,6 +4372,34 @@ declare function createOffer(lavarageProgram: Program<Lavarage$1> | Program<Lava
     computeBudgetMicroLamports?: number;
     maxBorrow?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Updates the maximum exposure limit for a trading pool
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param params - Update parameters
+ * @param params.tradingPool - The trading pool PDA
+ * @param params.nodeWallet - The node wallet address
+ * @param params.poolOwner - The pool owner's public key
+ * @param params.maxExposure - New maximum exposure limit
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to update max exposure
+ *
+ * @example
+ * ```typescript
+ * const tx = await updateMaxExposure(lavarageProgram, {
+ *   tradingPool: poolPDA,
+ *   nodeWallet: nodeWalletAddress,
+ *   poolOwner: lenderPublicKey,
+ *   maxExposure: 2000000 // New limit
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ */
 declare function updateMaxExposure(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, params: {
     tradingPool: PublicKey;
     nodeWallet: string;
@@ -3714,6 +4407,34 @@ declare function updateMaxExposure(lavarageProgram: Program<Lavarage$1> | Progra
     maxExposure: number;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Updates the interest rate for a trading pool
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param params - Update parameters
+ * @param params.tradingPool - The trading pool PDA
+ * @param params.nodeWallet - The node wallet address
+ * @param params.poolOwner - The pool owner's public key
+ * @param params.interestRate - New interest rate
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to update interest rate
+ *
+ * @example
+ * ```typescript
+ * const tx = await updateInterestRate(lavarageProgram, {
+ *   tradingPool: poolPDA,
+ *   nodeWallet: nodeWalletAddress,
+ *   poolOwner: lenderPublicKey,
+ *   interestRate: 750 // 7.5%
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ */
 declare function updateInterestRate(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, params: {
     tradingPool: PublicKey;
     nodeWallet: string;
@@ -3721,6 +4442,41 @@ declare function updateInterestRate(lavarageProgram: Program<Lavarage$1> | Progr
     interestRate: number;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Updates multiple parameters of a trading pool in a single transaction
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param params - Update parameters
+ * @param params.tradingPool - The trading pool PDA
+ * @param params.poolOwner - The pool owner's public key
+ * @param params.nodeWallet - The node wallet address
+ * @param params.mint - The token mint address
+ * @param params.interestRate - New interest rate
+ * @param params.maxExposure - New maximum exposure limit
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to update pool parameters
+ *
+ * @example
+ * ```typescript
+ * const tx = await updateOffer(lavarageProgram, {
+ *   tradingPool: poolPDA,
+ *   poolOwner: lenderPublicKey,
+ *   nodeWallet: nodeWalletAddress,
+ *   mint: collateralMint.toString(),
+ *   interestRate: 600, // 6%
+ *   maxExposure: 3000000
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ *
+ * @see {@link updateInterestRate} - Update only interest rate
+ * @see {@link updateMaxExposure} - Update only max exposure
+ */
 declare function updateOffer(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, params: {
     tradingPool: PublicKey;
     poolOwner: PublicKey;
@@ -3730,6 +4486,34 @@ declare function updateOffer(lavarageProgram: Program<Lavarage$1> | Program<Lava
     maxExposure: number;
     computeBudgetMicroLamports?: number;
 }): Promise<VersionedTransaction>;
+/**
+ * Updates the maximum borrow limit for a trading pool
+ *
+ * @group Lending
+ * @category Operations
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param params - Update parameters
+ * @param params.tradingPool - The trading pool PDA
+ * @param params.nodeWallet - The node wallet address
+ * @param params.oracle - The oracle public key authorized to update
+ * @param params.maxBorrow - New maximum borrow limit
+ * @param params.computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to update max borrow limit
+ *
+ * @example
+ * ```typescript
+ * const tx = await updateMaxBorrow(lavarageProgram, {
+ *   tradingPool: poolPDA,
+ *   nodeWallet: nodeWalletAddress,
+ *   oracle: oraclePublicKey,
+ *   maxBorrow: 5000000
+ * });
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ */
 declare function updateMaxBorrow(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, params: {
     tradingPool: PublicKey;
     nodeWallet: string;
@@ -3771,15 +4555,86 @@ declare namespace lending {
   export { lending_addToWithdrawalAccessList as addToWithdrawalAccessList, lending_createOffer as createOffer, lending_depositFunds as depositFunds, lending_getNodeWalletPDA as getNodeWalletPDA, lending_getTradingPoolPDA as getTradingPoolPDA, lending_getWithdrawalAccessList as getWithdrawalAccessList, lending_getWithdrawalAccessListPDA as getWithdrawalAccessListPDA, lending_removeFromWithdrawalAccessList as removeFromWithdrawalAccessList, lending_updateInterestRate as updateInterestRate, lending_updateMaxBorrow as updateMaxBorrow, lending_updateMaxExposure as updateMaxExposure, lending_updateOffer as updateOffer, lending_withdrawFunds as withdrawFunds, lending_withdrawFundsV1 as withdrawFundsV1, lending_withdrawFundsV2 as withdrawFundsV2 };
 }
 
+/**
+ * @packageDocumentation
+ * @module Lavarage SDK
+ *
+ * The main entry point for the Lavarage SDK, providing functionality for interacting
+ * with the Lavarage DeFi protocol on both Solana and EVM chains.
+ *
+ * @example
+ * ```typescript
+ * import { getPda, getPositionAccountPDA } from '@lavarage/sdk';
+ * import * as lending from '@lavarage/sdk/lending';
+ * ```
+ */
+
 type OptionalRPCResults = {
     addressLookupTableAccounts?: AccountInfo<Buffer>[];
     latestBlockhash?: string;
     tokenAccountConfirmCreatedAddresses?: PublicKey[];
     quoteMintAccountInfo?: AccountInfo<Buffer>;
 };
+/**
+ * Derives a Program Derived Address (PDA) for the given seed(s) and program ID
+ *
+ * @group Traders
+ * @category Utilities
+ *
+ * @param seed - Single buffer or array of buffers to use as seeds
+ * @param programId - The Solana program ID to derive the PDA from
+ * @returns The derived public key address
+ *
+ * @example
+ * ```typescript
+ * const seed = Buffer.from("position");
+ * const pda = getPda(seed, programId);
+ * ```
+ */
 declare function getPda(seed: Buffer | Buffer[], programId: PublicKey): PublicKey;
+/**
+ * Generates a Position Account PDA for a specific offer and user
+ *
+ * @group Traders
+ * @category Utilities
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param offer - The offer program account
+ * @param seed - Additional seed for uniqueness (typically a public key)
+ * @returns The Position Account PDA public key
+ *
+ * @example
+ * ```typescript
+ * const positionPDA = getPositionAccountPDA(
+ *   lavarageProgram,
+ *   offerAccount,
+ *   userPublicKey
+ * );
+ * ```
+ */
 declare function getPositionAccountPDA(lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, offer: ProgramAccount, seed: PublicKey): PublicKey;
 
+/**
+ * Fetches all available lending offers from the Lavarage protocol
+ *
+ * @group Traders
+ * @category Queries
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @returns Promise resolving to an array of all pool/offer accounts
+ *
+ * @example
+ * ```typescript
+ * // Fetch all offers
+ * const offers = await getOffers(lavarageProgram);
+ *
+ * // Process each offer
+ * offers.forEach(offer => {
+ *   console.log('Offer:', offer.publicKey.toString());
+ *   console.log('Data:', offer.account);
+ * });
+ * ```
+ */
 declare const getOffers: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>) => Promise<ProgramAccount<{
     interestRate: number;
     collateralType: PublicKey;
@@ -3788,6 +4643,35 @@ declare const getOffers: (lavarageProgram: Program<Lavarage$1> | Program<Lavarag
     maxExposure: BN;
     currentExposure: BN;
 }>[]>;
+/**
+ * Fetches all open positions from the Lavarage protocol
+ *
+ * This function filters for positions with a specific data structure size (178 bytes)
+ * and checks for positions that are currently open.
+ *
+ * @group Traders
+ * @category Queries
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @returns Promise resolving to an array of open position accounts
+ *
+ * @example
+ * ```typescript
+ * // Get all open positions
+ * const openPositions = await getOpenPositions(lavarageProgram);
+ *
+ * console.log(`Found ${openPositions.length} open positions`);
+ *
+ * // Filter positions by user
+ * const userPositions = openPositions.filter(pos =>
+ *   pos.account.owner.equals(userPublicKey)
+ * );
+ * ```
+ *
+ * @remarks
+ * The function query only open positions
+ * without fetching closed or liquidated positions.
+ */
 declare const getOpenPositions: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>) => Promise<ProgramAccount<{
     pool: PublicKey;
     closeStatusRecallTimestamp: BN;
@@ -3802,6 +4686,30 @@ declare const getOpenPositions: (lavarageProgram: Program<Lavarage$1> | Program<
     interestRate: number;
     lastInterestCollect: BN;
 }>[]>;
+/**
+ * Fetches all closed positions from the Lavarage protocol
+ *
+ *
+ * @group Traders
+ * @category Queries
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @returns Promise resolving to an array of all closed position accounts from all three states
+ *
+ * @example
+ * ```typescript
+ * // Get all closed positions
+ * const closedPositions = await getClosedPositions(lavarageProgram);
+ *
+ * console.log(`Found ${closedPositions.length} closed positions`);
+ *
+ * // Filter by specific user
+ * const userClosedPositions = closedPositions.filter(pos =>
+ *   pos.account.owner.equals(userPublicKey)
+ * );
+ * ```
+ *
+ */
 declare const getClosedPositions: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>) => Promise<ProgramAccount<{
     pool: PublicKey;
     closeStatusRecallTimestamp: BN;
@@ -3816,6 +4724,36 @@ declare const getClosedPositions: (lavarageProgram: Program<Lavarage$1> | Progra
     interestRate: number;
     lastInterestCollect: BN;
 }>[]>;
+/**
+ * Fetches all liquidated positions from the Lavarage protocol
+ *
+ * Liquidated positions are positions that were forcefully closed due to
+ * insufficient collateral or health factor falling below the threshold.
+ *
+ * @group Traders
+ * @category Queries
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @returns Promise resolving to an array of liquidated position accounts
+ *
+ * @example
+ * ```typescript
+ * // Get all liquidated positions
+ * const liquidatedPositions = await getLiquidatedPositions(lavarageProgram);
+ *
+ * console.log(`Found ${liquidatedPositions.length} liquidated positions`);
+ *
+ * // Analyze liquidation data
+ * liquidatedPositions.forEach(pos => {
+ *   console.log('Position:', pos.publicKey.toString());
+ *   console.log('Liquidated amount:', pos.account.amount);
+ * });
+ * ```
+ *
+ *
+ * @see {@link getClosedPositions} - For other types of closed positions
+ * @see {@link getOpenPositions} - For currently active positions
+ */
 declare const getLiquidatedPositions: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>) => Promise<ProgramAccount<{
     pool: PublicKey;
     closeStatusRecallTimestamp: BN;
@@ -3830,6 +4768,40 @@ declare const getLiquidatedPositions: (lavarageProgram: Program<Lavarage$1> | Pr
     interestRate: number;
     lastInterestCollect: BN;
 }>[]>;
+/**
+ * Fetches all positions from the Lavarage protocol
+ *
+ * This function retrieves all position accounts regardless of their state (open, closed, liquidated).
+ *
+ * @group Traders
+ * @category Queries
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @returns Promise resolving to an array of position accounts
+ *
+ * @example
+ * ```typescript
+ * // Get all positions
+ * const allPositions = await getAllPositions(lavarageProgram);
+ *
+ * console.log(`Found ${allPositions.length} total positions`);
+ *
+ * // Filter positions by user
+ * const userPositions = allPositions.filter(pos =>
+ *   pos.account.owner.equals(userPublicKey)
+ * );
+ * ```
+ *
+ * @remarks
+ * Unlike other position query functions, this returns ALL positions without
+ * filtering by status. Use more specific functions like `getOpenPositions`,
+ * `getClosedPositions`, or `getLiquidatedPositions` if you only need positions
+ * with a specific status.
+ *
+ * @see {@link getOpenPositions} - For only open positions
+ * @see {@link getClosedPositions} - For only closed positions
+ * @see {@link getLiquidatedPositions} - For only liquidated positions
+ */
 declare const getAllPositions: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>) => Promise<ProgramAccount<{
     pool: PublicKey;
     closeStatusRecallTimestamp: BN;
@@ -3854,6 +4826,56 @@ declare const borrowV2: (lavarageProgram: Program<Lavarage>, offer: ProgramAccou
     interestRate: number;
     collateralType: PublicKey;
 }>, marginSOL: BN, leverage: number, randomSeed: Keypair, quoteToken: PublicKey, tokenProgram: PublicKey, partnerFeeRecipient?: PublicKey, partnerFeeMarkup?: number, computeBudgetMicroLamports?: number, discountBps?: number, referralBps?: number, referralVaultProgram?: Program<UserVault>) => Promise<VersionedTransaction>;
+/**
+ * Opens a leveraged trading position on Lavarage V1
+ *
+ * This function executes a complete leveraged trade by:
+ * 1. Borrowing funds from the lending pool based on leverage
+ * 2. Swapping tokens through Jupiter DEX
+ * 3. Depositing the swapped tokens as collateral
+ *
+ * @group Traders
+ * @category Trading
+ *
+ * @param lavarageProgram - The Lavarage V1 program instance
+ * @param offer - The lending offer containing terms (interest rate, collateral type, node wallet)
+ * @param jupInstruction - Jupiter swap instructions including setup and swap details
+ * @param marginSOL - The user's margin amount in SOL (as BN)
+ * @param leverage - The leverage multiplier (e.g., 2 for 2x leverage)
+ * @param randomSeed - A keypair used to generate unique position account address
+ * @param tokenProgram - The SPL token program ID
+ * @param partnerFeeRecipient - Optional wallet to receive partner fees
+ * @param partnerFeeMarkup - Optional partner fee amount in basis points
+ * @param computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns A versioned transaction ready to be signed and sent
+ *
+ * @example
+ * ```typescript
+ * // Open a 2x leveraged position with 1 SOL margin
+ * const marginSOL = new BN(1_000_000_000); // 1 SOL in lamports
+ * const leverage = 2;
+ * const randomSeed = Keypair.generate();
+ *
+ * const tx = await openTradeV1(
+ *   lavarageProgram,
+ *   offerAccount,
+ *   jupiterInstructions,
+ *   marginSOL,
+ *   leverage,
+ *   randomSeed,
+ *   TOKEN_PROGRAM_ID
+ * );
+ *
+ * // Sign and send transaction
+ * const signature = await sendAndConfirmTransaction(connection, tx, [wallet, randomSeed]);
+ * ```
+ *
+ * @remarks
+ * - The function creates token accounts if they don't exist
+ *
+ * @throws Will throw if token accounts cannot be created or if Jupiter instructions are invalid
+ */
 declare const openTradeV1: (lavarageProgram: Program<Lavarage$1>, offer: ProgramAccount<{
     nodeWallet: PublicKey;
     interestRate: number;
@@ -3865,6 +4887,61 @@ declare const openTradeV1: (lavarageProgram: Program<Lavarage$1>, offer: Program
         addressLookupTableAddresses: string[];
     };
 }, marginSOL: BN, leverage: number, randomSeed: Keypair, tokenProgram: PublicKey, partnerFeeRecipient?: PublicKey, partnerFeeMarkup?: number, computeBudgetMicroLamports?: number, platformFeeRecipient?: PublicKey, splitTransactions?: boolean, discountBps?: number, referralBps?: number, optionalRPCResults?: OptionalRPCResults) => Promise<VersionedTransaction | VersionedTransaction[]>;
+/**
+ * Opens a leveraged trading position on Lavarage V2
+ *
+ * This function executes a complete leveraged trade similar to V1, but with
+ * enhanced support for multiple quote tokens (not limited to SOL).
+ * The process includes:
+ * 1. Borrowing funds from the lending pool based on leverage
+ * 2. Swapping tokens through Jupiter DEX
+ * 3. Depositing the swapped tokens as collateral
+ *
+ * @group Traders
+ * @category Trading
+ *
+ * @param lavarageProgram - The Lavarage V2 program instance
+ * @param offer - The lending offer containing terms (interest rate, collateral type, node wallet)
+ * @param jupInstruction - Jupiter swap instructions including setup and swap details
+ * @param marginSOL - The user's margin amount in SOL (as BN)
+ * @param leverage - The leverage multiplier (e.g., 2 for 2x leverage)
+ * @param randomSeed - A keypair used to generate unique position account address
+ * @param quoteToken - The quote token mint address (e.g., USDC, USDT, or SOL)
+ * @param tokenProgram - The SPL token program ID for the collateral token
+ * @param partnerFeeRecipient - Optional wallet to receive partner fees
+ * @param partnerFeeMarkup - Optional partner fee amount in basis points
+ * @param computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns A versioned transaction ready to be signed and sent
+ *
+ * @example
+ * ```typescript
+ * // Open a 3x leveraged position with USDC as quote token
+ * const marginSOL = new BN(1_000_000_000); // 1 SOL equivalent
+ * const leverage = 3;
+ * const randomSeed = Keypair.generate();
+ * const usdcMint = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+ *
+ * const tx = await openTradeV2(
+ *   lavarageProgram,
+ *   offerAccount,
+ *   jupiterInstructions,
+ *   marginSOL,
+ *   leverage,
+ *   randomSeed,
+ *   usdcMint,  // Quote token
+ *   TOKEN_PROGRAM_ID
+ * );
+ *
+ * // Sign and send transaction
+ * const signature = await sendAndConfirmTransaction(connection, tx, [wallet, randomSeed]);
+ * ```
+ *
+ * @remarks
+ * - V2 supports multiple quote tokens while V1 only supports SOL
+ *
+ * @see {@link openTradeV1} - The V1 version limited to SOL as quote token
+ */
 declare const openTradeV2: (lavarageProgram: Program<Lavarage>, offer: ProgramAccount<{
     nodeWallet: PublicKey;
     interestRate: number;
@@ -3876,36 +4953,222 @@ declare const openTradeV2: (lavarageProgram: Program<Lavarage>, offer: ProgramAc
         addressLookupTableAddresses: string[];
     };
 }, marginSOL: BN, leverage: number, randomSeed: Keypair, quoteToken: PublicKey, tokenProgram: PublicKey, partnerFeeRecipient?: PublicKey, partnerFeeMarkup?: number, computeBudgetMicroLamports?: number, platformFeeRecipient?: PublicKey, splitTransactions?: boolean, discountBps?: number, referralBps?: number, optionalRPCResults?: OptionalRPCResults) => Promise<VersionedTransaction | VersionedTransaction[]>;
+/**
+ * Creates a take-profit delegate for automated position closing
+ *
+ *
+ * @group Traders
+ * @category Automation
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param position - The position account to set take-profit for
+ * @param tpPrice - The target price at which to take profit (as BN)
+ * @param tpTolerence - Price tolerance/slippage allowed when executing (as BN)
+ * @param prioFee - Priority fee in microlamports for transaction execution
+ * @param quoteToken - The quote token mint address (e.g., USDC, SOL)
+ * @param partnerFeeRecipient - Optional wallet to receive partner fees
+ *
+ * @returns A versioned transaction to create the take-profit delegate
+ *
+ * @example
+ * ```typescript
+ * // Set take-profit at $150 for a position
+ * const position = await getPositionAccount(positionPubkey);
+ * const tpPrice = new BN(150 * 1e6); // $150 with 6 decimals
+ * const tolerance = new BN(1 * 1e6); // $1 tolerance
+ * const prioFee = new BN(100000); // 0.1 SOL priority fee
+ *
+ * const tx = await createTpDelegate(
+ *   lavarageProgram,
+ *   position,
+ *   tpPrice,
+ *   tolerance,
+ *   prioFee,
+ *   usdcMint
+ * );
+ *
+ * // Sign and send
+ * const signature = await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * console.log('Take-profit delegate created:', signature);
+ * ```
+ *
+ * @see {@link modifyTpDelegate} - Modify take-profit settings
+ * @see {@link removeTpDelegate} - Remove take-profit without replacement
+ */
 declare const createTpDelegate: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
     userPaid: BN;
     amount: BN;
 }>, tpPrice: BN, tpTolerence: BN, prioFee: BN, quoteToken: PublicKey, partnerFeeRecipient?: PublicKey) => Promise<VersionedTransaction>;
+/**
+ * Modifies take-profit setting for an existing position.
+ *
+ *
+ * @group Traders
+ * @category Automation
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param position - The position account to modify take-profit for
+ * @param tpPrice - The new target price for take-profit (as BN)
+ * @param tpTolerence - The new price tolerance/slippage allowed (as BN)
+ * @param prioFee - Priority fee in microlamports for transaction execution
+ * @param quoteToken - The quote token mint address (e.g., USDC, SOL)
+ * @param partnerFeeRecipient - Optional wallet to receive partner fees
+ *
+ * @returns Transaction to update the take-profit settings.
+ *
+ * @example
+ * ```typescript
+ * const tx = await modifyTpDelegate(
+ *   program,
+ *   position,
+ *   new BN(160 * 1e6),  // New target: $160
+ *   new BN(2 * 1e6),     // Tolerance: $2
+ *   new BN(100000),      // Priority fee
+ *   usdcMint
+ * );
+ * ```
+ *
+ * @see {@link createTpDelegate} - Initial creation of take-profit
+ * @see {@link removeTpDelegate} - Remove take-profit without replacement
+ */
 declare const modifyTpDelegate: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
     userPaid: BN;
     amount: BN;
 }>, tpPrice: BN, tpTolerence: BN, prioFee: BN, quoteToken: PublicKey, partnerFeeRecipient?: PublicKey) => Promise<VersionedTransaction>;
+/**
+ * Removes take-profit settings from a position
+ *
+ * @group Traders
+ * @category Automation
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param position - The position account to remove take-profit from
+ * @param prioFee - Priority fee in microlamports for transaction execution
+ *
+ * @returns Transaction to remove take-profit settings
+ *
+ * @example
+ * ```typescript
+ * const tx = await removeTpDelegate(
+ *   lavarageProgram,
+ *   position,
+ *   new BN(100000) // Priority fee
+ * );
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ *
+ * @see {@link createTpDelegate} - Initial creation of take-profit
+ * @see {@link modifyTpDelegate} - Modify existing take-profit settings
+ */
 declare const removeTpDelegate: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
     userPaid: BN;
     amount: BN;
 }>, prioFee: BN) => Promise<VersionedTransaction>;
+/**
+ * Partially repays a position on Lavarage V1
+ *
+ * @group Traders
+ * @category Trading
+ *
+ * @param lavarageProgram - The Lavarage V1 program instance
+ * @param position - The position account to partially repay
+ * @param repaymentBps - Repayment amount in basis points (10000 = 100%)
+ *
+ * @returns Transaction for partial repayment
+ *
+ * @example
+ * ```typescript
+ * // Repay 50% of the position
+ * const tx = await partialRepayV1(
+ *   lavarageProgram,
+ *   position,
+ *   5000  // 50% in basis points
+ * );
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ *
+ * @see {@link partialRepayV2} - The V2 version supporting multiple quote tokens
+ */
 declare const partialRepayV1: (lavarageProgram: Program<Lavarage$1>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
     userPaid: BN;
     amount: BN;
 }>, repaymentBps: number) => Promise<VersionedTransaction>;
+/**
+ * Partially repays a position on Lavarage V2
+ *
+ * @group Traders
+ * @category Trading
+ *
+ * @param lavarageProgram - The Lavarage V2 program instance
+ * @param position - The position account to partially repay
+ * @param repaymentBps - Repayment amount in basis points (10000 = 100%)
+ *
+ * @returns Transaction for partial repayment
+ *
+ * @example
+ * ```typescript
+ * // Repay 30% of the position
+ * const tx = await partialRepayV2(
+ *   lavarageProgram,
+ *   position,
+ *   3000  // 30% in basis points
+ * );
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ *
+ * @see {@link partialRepayV1} - The V1 version supporting SOL as quote token
+ */
 declare const partialRepayV2: (lavarageProgram: Program<Lavarage>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
     userPaid: BN;
     amount: BN;
 }>, repaymentBps: number) => Promise<VersionedTransaction>;
+/**
+ * Closes a trading position on Lavarage V1
+ *
+ * @group Traders
+ * @category Trading
+ *
+ * @param lavarageProgram - The Lavarage V1 program instance
+ * @param position - The position account to close
+ * @param offer - The offer/pool account associated with the position
+ * @param jupInstruction - Jupiter swap instructions and quote for closing
+ * @param partnerFeeRecipient - Optional wallet to receive partner fees
+ * @param partnerFeeMarkup - Optional partner fee amount in basis points
+ * @param computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to close the position
+ *
+ * @example
+ * ```typescript
+ * const jupQuote = await getJupiterQuote(...);
+ * const tx = await closeTradeV1(
+ *   lavarageProgram,
+ *   position,
+ *   offer,
+ *   jupQuote,
+ *   partnerWallet, // optional
+ *   100, // optional fee in bps
+ *   150000 // optional priority fee
+ * );
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ * @see {@link openTradeV1} - The V1 version for opening positions
+ * @see {@link partialRepayV1} - Partial repayments on V1
+ */
 declare const closeTradeV1: (lavarageProgram: Program<Lavarage$1>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
@@ -3925,6 +5188,42 @@ declare const closeTradeV1: (lavarageProgram: Program<Lavarage$1>, position: Pro
     };
     quoteResponse: any;
 }, partnerFeeRecipient?: PublicKey, partnerFeeMarkup?: number, computeBudgetMicroLamports?: number, platformFeeRecipient?: PublicKey, splitTransactions?: boolean) => Promise<VersionedTransaction | VersionedTransaction[]>;
+/**
+ * Closes a trading position on Lavarage V2
+ *
+ * @group Traders
+ * @category Trading
+ *
+ * @param lavarageProgram - The Lavarage V2 program instance
+ * @param position - The position account to close
+ * @param offer - The offer/pool account associated with the position
+ * @param jupInstruction - Jupiter swap instructions and quote for closing
+ * @param quoteToken - The quote token mint address for this position
+ * @param partnerFeeRecipient - Optional wallet to receive partner fees
+ * @param partnerFeeMarkup - Optional partner fee amount in basis points
+ * @param computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to close the position
+ *
+ * @example
+ * ```typescript
+ * const jupQuote = await getJupiterQuote(...);
+ * const tx = await closeTradeV2(
+ *   lavarageProgram,
+ *   position,
+ *   offer,
+ *   jupQuote,
+ *   usdcMint, // quote token
+ *   partnerWallet, // optional
+ *   100, // optional fee in bps
+ *   150000 // optional priority fee
+ * );
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ * @see {@link openTradeV2} - The V2 version for opening positions
+ * @see {@link partialRepayV2} - Partial repay a V2 position
+ */
 declare const closeTradeV2: (lavarageProgram: Program<Lavarage>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
@@ -3943,7 +5242,39 @@ declare const closeTradeV2: (lavarageProgram: Program<Lavarage>, position: Progr
         tokenLedgerInstruction?: Record<string, unknown>;
     };
     quoteResponse: any;
-}, quoteToken: PublicKey, partnerFeeRecipient?: PublicKey, partnerFeeMarkup?: number, computeBudgetMicroLamports?: number, platformFeeRecipient?: PublicKey, splitTransactions?: boolean) => Promise<VersionedTransaction | VersionedTransaction[]>;
+}, quoteToken: PublicKey, partnerFeeRecipient?: PublicKey, partnerFeeMarkup?: number, computeBudgetMicroLamports?: number, platformFeeRecipient?: PublicKey, splitTransactions?: boolean, discountBps?: number, referralBps?: number) => Promise<VersionedTransaction | VersionedTransaction[]>;
+/**
+ * Retrieves delegate accounts for automated position management
+ *
+ * @group Traders
+ * @category Queries
+ *
+ * @param lavarageProgram - The Lavarage program instance (V1 or V2)
+ * @param userPubKey - Optional user public key to filter delegates
+ *
+ * @returns Array of delegate accounts with parsed price data
+ *
+ * @example
+ * ```typescript
+ * // Get all delegates for a specific user
+ * const userDelegates = await getDelegateAccounts(
+ *   lavarageProgram,
+ *   userPublicKey
+ * );
+ *
+ * // Get all delegates (no filter)
+ * const allDelegates = await getDelegateAccounts(lavarageProgram);
+ *
+ * // Access parsed data
+ * userDelegates.forEach(delegate => {
+ *   console.log('TP Price:', delegate.parsed.tpPrice.toString());
+ *   console.log('Threshold:', delegate.parsed.tpThreshold.toString());
+ * });
+ * ```
+ * @see {@link createTpDelegate} - Create a new take-profit delegate
+ * @see {@link modifyTpDelegate} - Modify existing take-profit settings
+ * @see {@link removeTpDelegate} - Remove take-profit settings
+ */
 declare const getDelegateAccounts: (lavarageProgram: Program<Lavarage$1> | Program<Lavarage>, userPubKey?: PublicKey) => Promise<{
     parsed: {
         tpPrice: any;
@@ -3962,6 +5293,39 @@ declare const getDelegateAccounts: (lavarageProgram: Program<Lavarage$1> | Progr
         account: PublicKey;
     };
 }[]>;
+/**
+ * Splits a position into two separate positions on Lavarage V2
+ *
+ * @group Traders
+ * @category PositionManagement
+ *
+ * @param lavarageProgram - The Lavarage V2 or V1 program instance
+ * @param position - The original position to split
+ * @param offer - The offer/pool account associated with the position
+ * @param quoteToken - The quote token mint address
+ * @param propotionBps - Split ratio in basis points (5000 = 50/50 split)
+ * @param computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Object containing transaction and new position addresses
+ *
+ * @example
+ * ```typescript
+ * // Split position 70/30
+ * const result = await splitPositionV2(
+ *   lavarageProgram,
+ *   position,
+ *   offer,
+ *   usdcMint,
+ *   7000  // 70% to first position, 30% to second
+ * );
+ *
+ * const tx = result.transaction;
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ *
+ * console.log('New positions:', result.newPositionAddresses);
+ * ```
+ * @see {@link mergePositionV2} - Merge two positions into one
+ */
 declare const splitPositionV2: (lavarageProgram: Program<Lavarage> | Program<Lavarage$1>, position: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;
@@ -3976,6 +5340,37 @@ declare const splitPositionV2: (lavarageProgram: Program<Lavarage> | Program<Lav
     newPositionAddresses: string[];
     newPositionSeeds: string[];
 }>;
+/**
+ * Merges two positions into a single position on Lavarage V2
+ *
+ * @group Traders
+ * @category PositionManagement
+ *
+ * @param lavarageProgram - The Lavarage V2 program instance
+ * @param position1 - The first position to merge
+ * @param position2 - The second position to merge
+ * @param offer - The offer/pool account (must be same for both positions)
+ * @param quoteToken - The quote token mint address
+ * @param computeBudgetMicroLamports - Optional compute budget for priority fees
+ *
+ * @returns Transaction to merge the positions
+ *
+ * @example
+ * ```typescript
+ * // Merge two positions into one
+ * const tx = await mergePositionV2(
+ *   lavarageProgram,
+ *   position1,
+ *   position2,
+ *   offer,
+ *   usdcMint
+ * );
+ *
+ * await sendAndConfirmTransaction(connection, tx, [wallet]);
+ * ```
+ *
+ * @see {@link splitPositionV2} - Split a position into two
+ */
 declare const mergePositionV2: (lavarageProgram: Program<Lavarage>, position1: ProgramAccount<{
     pool: PublicKey;
     seed: PublicKey;