@lavarage/sdk 6.7.5 → 6.8.0

package/evm.ts

@@ -155,7 +155,7 @@ export async function getPositionsEvm(
         trader: loan.borrower,
         tokenCollateral: loan.collateral.collateralAddress,
         loanId: loan.id,
-        openingPositionSize: loan.amount,
+        openingPositionSize: loan.amount + loan.userPaid,
         collateralAmount: loan.collateralAmount,
         initialMargin: loan.userPaid,
         transactionHash: "", // Not available from loan data

package/index.ts

@@ -27,6 +27,9 @@ import {
   TokenInvalidAccountOwnerError,
 } from "@solana/spl-token";
 
+export * from "./evm";
+export * as lending from "./lending";
+
 export function getPda(seed: Buffer | Buffer[], programId: PublicKey) {
   const seedsBuffer = Array.isArray(seed) ? seed : [seed];
 
@@ -1646,5 +1649,3 @@ export const mergePositionV2 = async (
 
   return tx;
 };
-
-export * from "./evm";

package/interfaces/sol.ts

@@ -0,0 +1,9 @@
+import { Keypair } from "@solana/web3.js";
+
+import { PublicKey } from "@solana/web3.js";
+
+export interface TradingPoolPDA {
+  tradingPool: PublicKey;
+  poolOwnerPublicKey: PublicKey;
+  tokenPublicKey: PublicKey;
+}

package/lending.ts

@@ -0,0 +1,456 @@
+import { BN, Instruction, Program } from "@coral-xyz/anchor";
+import { Lavarage } from "./idl/lavarage";
+import { Lavarage as LavarageV2 } from "./idl/lavaragev2";
+import {
+  ComputeBudgetProgram,
+  Keypair,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import {
+  TOKEN_PROGRAM_ID,
+  createTransferCheckedInstruction,
+  getAssociatedTokenAddressSync,
+  getMint,
+} from "@solana/spl-token";
+import { getPda } from "./index";
+
+export function getNodeWalletPDA(
+  operatorPublicKey: PublicKey,
+  mintPublicKey: PublicKey,
+  programId: PublicKey
+): PublicKey {
+  return getPda(
+    [
+      Buffer.from("node_wallet"),
+      operatorPublicKey.toBuffer(),
+      mintPublicKey.toBuffer(),
+    ],
+    programId
+  );
+}
+
+export function getTradingPoolPDA(
+  poolOwnerPublicKey: PublicKey,
+  tokenPublicKey: PublicKey,
+  programId: PublicKey
+): PublicKey {
+  return getPda(
+    [
+      Buffer.from("trading_pool"),
+      poolOwnerPublicKey.toBuffer(),
+      tokenPublicKey.toBuffer(),
+    ],
+    programId
+  );
+}
+
+const computeFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
+  microLamports: 150000,
+});
+
+async function createNodeWallet(
+  lavarageProgram: Program<Lavarage> | Program<LavarageV2>,
+  params: {
+    operator: PublicKey;
+    mint?: string; // Required for V2, optional for V1
+    liquidationLtv?: number; // Required for V2, optional for V1
+  }
+): Promise<{
+  instruction: TransactionInstruction;
+  nodeWallet: Keypair | undefined;
+}> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  let instruction, nodeWallet;
+
+  // Check if this is V2 program (has liquidationLtv parameter)
+  if (params.liquidationLtv !== undefined && params.mint !== undefined) {
+    nodeWallet = getNodeWalletPDA(
+      new PublicKey(params.operator),
+      new PublicKey(params.mint),
+      lavarageProgram.programId
+    );
+    // V2 version
+    instruction = await (lavarageProgram as Program<LavarageV2>).methods
+      .lpOperatorCreateNodeWallet(new BN(params.liquidationLtv))
+      .accounts({
+        nodeWallet: nodeWallet,
+        operator: new PublicKey(params.operator),
+        systemProgram: SystemProgram.programId,
+        mint: new PublicKey(params.mint),
+      })
+      .instruction();
+  } else {
+    nodeWallet = Keypair.generate();
+    // V1 version
+    instruction = await (lavarageProgram as Program<Lavarage>).methods
+      .lpOperatorCreateNodeWallet()
+      .accounts({
+        nodeWallet: nodeWallet.publicKey,
+        operator: new PublicKey(params.operator),
+        systemProgram: SystemProgram.programId,
+      })
+      .instruction();
+  }
+
+  return {
+    instruction,
+    nodeWallet: nodeWallet instanceof Keypair ? nodeWallet : undefined,
+  };
+}
+
+export async function depositFunds(
+  lavarageProgram: Program<Lavarage>,
+  params: {
+    nodeWallet: PublicKey;
+    mint?: string; // Required for V2, optional for V1
+    funder: PublicKey;
+    amount: number;
+  }
+): Promise<VersionedTransaction> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  let instruction;
+  if (params.mint === undefined) {
+    instruction = await lavarageProgram.methods
+    .lpOperatorFundNodeWallet(new BN(params.amount))
+    .accounts({
+      nodeWallet: params.nodeWallet,
+      funder: params.funder,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+  } else {
+    const mintPubkey = new PublicKey(params.mint);
+    const mintOwner = await lavarageProgram.provider.connection.getAccountInfo(mintPubkey);
+    const mintAccount = await getMint(lavarageProgram.provider.connection, mintPubkey, 'confirmed', mintOwner?.owner);
+    instruction = createTransferCheckedInstruction(
+      getAssociatedTokenAddressSync(mintPubkey, new PublicKey(params.funder), true, mintOwner?.owner),
+      new PublicKey(params.mint),
+      getAssociatedTokenAddressSync(mintPubkey, new PublicKey(params.nodeWallet), true, mintOwner?.owner),
+      lavarageProgram.provider.publicKey!,
+      params.amount,
+      mintAccount.decimals,
+      [],
+      mintOwner?.owner
+    );
+  }
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions: [instruction, computeFeeIx],
+  }).compileToV0Message();
+
+  return new VersionedTransaction(messageV0);
+}
+
+export async function withdrawFundsV1(
+  lavarageProgram: Program<Lavarage>,
+  params: {
+    nodeWallet: PublicKey;
+    funder: PublicKey;
+    amount: number;
+  }
+): Promise<VersionedTransaction> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  const instruction = await lavarageProgram.methods
+    .lpOperatorWithdrawFromNodeWallet(new BN(params.amount))
+    .accounts({
+      nodeWallet: params.nodeWallet,
+      funder: params.funder,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions: [instruction, computeFeeIx],
+  }).compileToV0Message();
+
+  return new VersionedTransaction(messageV0);
+}
+
+export async function withdrawFundsV2(
+  lavarageProgram: Program<LavarageV2>,
+  params: {
+    nodeWallet: PublicKey;
+    funder: PublicKey;
+    mint: string;
+    amount: number;
+    fromTokenAccount?: PublicKey; // Optional, will be derived if not provided
+    toTokenAccount?: PublicKey; // Optional, will be derived if not provided
+  }
+): Promise<VersionedTransaction> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  const mintPubkey = new PublicKey(params.mint);
+
+  // Derive token accounts if not provided
+  const fromTokenAccount =
+    params.fromTokenAccount ||
+    getAssociatedTokenAddressSync(mintPubkey, params.nodeWallet, true);
+  const toTokenAccount =
+    params.toTokenAccount ||
+    getAssociatedTokenAddressSync(mintPubkey, params.funder);
+
+  const instruction = await lavarageProgram.methods
+    .lpOperatorWithdrawFromNodeWallet(new BN(params.amount))
+    .accounts({
+      nodeWallet: params.nodeWallet,
+      funder: params.funder,
+      systemProgram: SystemProgram.programId,
+      mint: mintPubkey,
+      fromTokenAccount,
+      toTokenAccount,
+      tokenProgram: TOKEN_PROGRAM_ID,
+    })
+    .instruction();
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions: [instruction, computeFeeIx],
+  }).compileToV0Message();
+
+  return new VersionedTransaction(messageV0);
+}
+
+// Unified withdraw function that works with both V1 and V2
+export async function withdrawFunds(
+  lavarageProgram: Program<Lavarage> | Program<LavarageV2>,
+  params: {
+    nodeWallet: PublicKey;
+    funder: PublicKey;
+    amount: number;
+    mint?: string; // Required for V2, optional for V1
+    fromTokenAccount?: PublicKey; // Only used for V2
+    toTokenAccount?: PublicKey; // Only used for V2
+  }
+): Promise<VersionedTransaction> {
+  // Check if mint is provided to determine if this is V2
+  if (params.mint) {
+    return withdrawFundsV2(lavarageProgram as Program<LavarageV2>, {
+      nodeWallet: params.nodeWallet,
+      funder: params.funder,
+      mint: params.mint,
+      amount: params.amount,
+      fromTokenAccount: params.fromTokenAccount,
+      toTokenAccount: params.toTokenAccount,
+    });
+  } else {
+    return withdrawFundsV1(lavarageProgram as Program<Lavarage>, {
+      nodeWallet: params.nodeWallet,
+      funder: params.funder,
+      amount: params.amount,
+    });
+  }
+}
+
+export async function createOffer(
+  lavarageProgram: Program<Lavarage> | Program<LavarageV2>,
+  params: {
+    tradingPool: PublicKey;
+    poolOwner: PublicKey;
+    nodeWallet: string;
+    mint?: string;
+    interestRate: number;
+    maxExposure: number;
+  }
+): Promise<VersionedTransaction> {
+
+  const nodeWalletAccount = await lavarageProgram.provider.connection.getAccountInfo(new PublicKey(params.nodeWallet));
+  let nodeWalletSigner, createNodeWalletInstruction;
+  if (!nodeWalletAccount) {
+    // create node wallet
+    const { instruction, nodeWallet } = await createNodeWallet(lavarageProgram, {
+      operator: new PublicKey(params.poolOwner.toBase58()),
+      mint: params.mint,
+      liquidationLtv: 90,
+    });
+    nodeWalletSigner = nodeWallet;
+    createNodeWalletInstruction = instruction;
+  }
+
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  const instruction = await lavarageProgram.methods
+    .lpOperatorCreateTradingPool(new BN(params.interestRate))
+    .accounts({
+      tradingPool: params.tradingPool,
+      operator: params.poolOwner,
+      nodeWallet: new PublicKey(params.nodeWallet),
+      mint: params.mint ? new PublicKey(params.mint) : undefined,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+  
+  const updateMaxExposureInstruction = await lavarageProgram.methods
+    .lpOperatorUpdateMaxExposure(new BN(params.maxExposure))
+    .accounts({
+      tradingPool: params.tradingPool,
+      nodeWallet: new PublicKey(params.nodeWallet),
+      operator: params.poolOwner,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions: [createNodeWalletInstruction === undefined ? null : createNodeWalletInstruction, instruction, updateMaxExposureInstruction, computeFeeIx].filter(Boolean) as TransactionInstruction[],
+  }).compileToV0Message();
+
+  if (nodeWalletSigner) {
+    const transaction = new VersionedTransaction(messageV0);
+    transaction.addSignature(
+      nodeWalletSigner.publicKey,
+      nodeWalletSigner.secretKey
+    );
+    return transaction;
+  }
+
+  return new VersionedTransaction(messageV0);
+}
+
+export async function updateMaxExposure(
+  lavarageProgram: Program<Lavarage> | Program<LavarageV2>,
+  params: {
+    tradingPool: PublicKey;
+    nodeWallet: string;
+    poolOwner: PublicKey;
+    maxExposure: number;
+  }
+): Promise<VersionedTransaction> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  const instruction = await lavarageProgram.methods
+    .lpOperatorUpdateMaxExposure(new BN(params.maxExposure))
+    .accounts({
+      tradingPool: params.tradingPool,
+      nodeWallet: new PublicKey(params.nodeWallet),
+      operator: params.poolOwner,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions: [instruction],
+  }).compileToV0Message();
+
+  return new VersionedTransaction(messageV0);
+}
+
+export async function updateInterestRate(
+  lavarageProgram: Program<Lavarage> | Program<LavarageV2>,
+  params: {
+    tradingPool: PublicKey;
+    nodeWallet: string;
+    poolOwner: PublicKey;
+    interestRate: number;
+  }
+): Promise<VersionedTransaction> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  const instruction = await lavarageProgram.methods
+    .lpOperatorUpdateInterestRate(new BN(params.interestRate))
+    .accounts({
+      tradingPool: params.tradingPool,
+      nodeWallet: new PublicKey(params.nodeWallet),
+      operator: params.poolOwner,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions: [instruction],
+  }).compileToV0Message();
+
+  return new VersionedTransaction(messageV0);
+}
+
+export async function updateOffer(
+  lavarageProgram: Program<Lavarage> | Program<LavarageV2>,
+  params: {
+    tradingPool: PublicKey;
+    poolOwner: PublicKey;
+    nodeWallet: string;
+    mint: string;
+    interestRate: number;
+    maxExposure: number;
+    //includeCreatePool?: boolean; // Optional flag to include pool creation
+  }
+): Promise<VersionedTransaction> {
+  const { blockhash } =
+    await lavarageProgram.provider.connection.getLatestBlockhash("finalized");
+
+  const instructions = [];
+
+  // // Optionally include pool creation instruction
+  // if (params.includeCreatePool) {
+  //   const createPoolInstruction = await lavarageProgram.methods
+  //     .lpOperatorCreateTradingPool(new BN(params.interestRate))
+  //     .accounts({
+  //       tradingPool: params.tradingPool,
+  //       operator: params.poolOwner,
+  //       nodeWallet: new PublicKey(params.nodeWallet),
+  //       mint: new PublicKey(params.mint),
+  //       systemProgram: SystemProgram.programId,
+  //     })
+  //     .instruction();
+
+  //   instructions.push(createPoolInstruction);
+  // }
+
+  // Update max exposure instruction
+  const updateMaxExposureInstruction = await lavarageProgram.methods
+    .lpOperatorUpdateMaxExposure(new BN(params.maxExposure))
+    .accounts({
+      tradingPool: params.tradingPool,
+      nodeWallet: new PublicKey(params.nodeWallet),
+      operator: params.poolOwner,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+
+  // Update interest rate instruction
+  const updateInterestRateInstruction = await lavarageProgram.methods
+    .lpOperatorUpdateInterestRate(new BN(params.interestRate))
+    .accounts({
+      tradingPool: params.tradingPool,
+      nodeWallet: new PublicKey(params.nodeWallet),
+      operator: params.poolOwner,
+      systemProgram: SystemProgram.programId,
+    })
+    .instruction();
+
+  instructions.push(
+    updateMaxExposureInstruction,
+    updateInterestRateInstruction
+  );
+
+  const messageV0 = new TransactionMessage({
+    payerKey: lavarageProgram.provider.publicKey!,
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message();
+
+  return new VersionedTransaction(messageV0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lavarage/sdk",
-  "version": "6.7.5",
+  "version": "6.8.0",
   "description": "Lavarage SDK",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",