@carrot-protocol/clend-vaults-rpc 0.0.2 → 0.0.3-pub2-dev-be4bd59

package/src/state.ts

@@ -1,188 +0,0 @@
-import { BN, web3 } from "@coral-xyz/anchor";
-import { ClendVaultsProgram } from "./program";
-import { getMint, Mint, unpackMint } from "@solana/spl-token";
-
-export interface Vault {
-  address: web3.PublicKey;
-  sharesMint: web3.PublicKey;
-  sharesDecimals: number;
-  sharesSupply: BN;
-  manager: web3.PublicKey;
-  assets: VaultAsset[];
-  clendAccounts: VaultClendAccount[];
-}
-
-export interface VaultAsset {
-  mint: VaultAssetMint;
-  oracle: web3.PublicKey;
-  reserve: VaultAssetReserve;
-  status: number;
-}
-
-export interface VaultAssetMint {
-  address: web3.PublicKey;
-  decimals: number;
-}
-
-export interface VaultAssetReserve {
-  address: web3.PublicKey;
-  amount: BN;
-  amountUi: number;
-}
-
-export interface VaultClendAccount {
-  address: web3.PublicKey;
-  status: number;
-}
-
-export interface VaultEquity {
-  // vault address
-  address: web3.PublicKey;
-
-  // total vault equity in usd
-  vaultEquity: number;
-
-  // equity in each clend account in usd
-  clendAccountEquity: {
-    address: web3.PublicKey;
-    equity: number;
-  }[];
-
-  // equity in each reserve in usd
-  reserveEquity: {
-    address: web3.PublicKey;
-    equity: number;
-  }[];
-}
-
-export async function parseVaultAccount(
-  address: web3.PublicKey,
-  vaultAccountInfo: web3.AccountInfo<Buffer>,
-  connection: web3.Connection,
-): Promise<Vault> {
-  const program = new ClendVaultsProgram();
-  const vaultDataRaw = program.program.coder.accounts.decode(
-    "vault",
-    vaultAccountInfo.data,
-  );
-
-  // filter out unused slots
-  // presuming equal amounts of each asset type
-  const reserves = vaultDataRaw.assets
-    .map((asset: any) => parsePk(asset.reserve))
-    .filter((r: web3.PublicKey) => !r.equals(web3.PublicKey.default));
-  const mints = vaultDataRaw.assets
-    .map((asset: any) => parsePk(asset.mint))
-    .filter((m: web3.PublicKey) => !m.equals(web3.PublicKey.default));
-  const oracles = vaultDataRaw.assets
-    .map((asset: any) => parsePk(asset.oracle))
-    .filter((o: web3.PublicKey) => !o.equals(web3.PublicKey.default));
-
-  const vaultReserveData: VaultAssetReserve[] = await getReserves(
-    reserves,
-    connection,
-  );
-
-  const assets: VaultAsset[] = [];
-  for (let i = 0; i < mints.length; i++) {
-    const asset = vaultDataRaw.assets[i];
-    const reserve = vaultReserveData.find((r) =>
-      r.address.equals(reserves[i]),
-    )!;
-    const oracle = oracles[i];
-    const mint = mints[i];
-    let mintDecimals: number | undefined = undefined;
-    try {
-      const mintState = await getMintState(mint, connection);
-      mintDecimals = parseNumber(mintState.decimals);
-    } catch (e) {
-      continue;
-    }
-    assets.push({
-      mint: {
-        address: mint,
-        decimals: mintDecimals,
-      },
-      oracle,
-      reserve,
-      status: parseNumber(asset.status),
-    });
-  }
-
-  const clendAccounts: VaultClendAccount[] = vaultDataRaw.clendAccounts
-    .map((clendAccount: any) => ({
-      address: parsePk(clendAccount.address),
-      status: parseNumber(clendAccount.status),
-    }))
-    .filter(
-      (ca: VaultClendAccount) => !ca.address.equals(web3.PublicKey.default),
-    );
-  const sharesMint = parsePk(vaultDataRaw.shares);
-  const sharesMintState = await getMintState(sharesMint, connection);
-
-  const vaultData: Vault = {
-    address,
-    sharesMint,
-    sharesDecimals: parseNumber(sharesMintState.decimals),
-    sharesSupply: new BN(sharesMintState.supply.toString()),
-    manager: parsePk(vaultDataRaw.manager),
-    clendAccounts,
-    assets,
-  };
-
-  return vaultData;
-}
-
-export async function getReserves(
-  reserves: web3.PublicKey[],
-  connection: web3.Connection,
-): Promise<VaultAssetReserve[]> {
-  const reservesData: VaultAssetReserve[] = [];
-  for (const reserve of reserves) {
-    const tokenAccountBalanceResponse =
-      await connection.getTokenAccountBalance(reserve);
-    const r = parseReserve(reserve, tokenAccountBalanceResponse.value);
-    reservesData.push(r);
-  }
-  return reservesData;
-}
-
-export function parseReserve(
-  address: web3.PublicKey,
-  tokenAmount: web3.TokenAmount,
-): VaultAssetReserve {
-  return {
-    address,
-    amount: new BN(tokenAmount.amount),
-    amountUi: parseNumber(tokenAmount.uiAmount!),
-  };
-}
-
-export async function getMintState(
-  mint: web3.PublicKey,
-  connection: web3.Connection,
-): Promise<Mint> {
-  const mintAccountInfo = await connection.getAccountInfo(mint);
-  if (!mintAccountInfo) {
-    throw new Error(`Mint account not found: ${mint.toString()}`);
-  }
-  return unpackMint(mint, mintAccountInfo, mintAccountInfo.owner);
-}
-
-export function parseNumber(value: any): number {
-  const n = Number(value);
-  if (isNaN(n)) {
-    throw new Error(`Error Parsing Number: inputValue: ${value}, error: ${n}`);
-  }
-  return n;
-}
-
-export function parsePk(value: any): web3.PublicKey {
-  try {
-    return new web3.PublicKey(value);
-  } catch (e) {
-    throw new Error(
-      `Error Parsing Public Key: inputValue: ${value}, error: ${e}`,
-    );
-  }
-}

package/src/swapper.ts

@@ -1,221 +0,0 @@
-import { ISwapper } from "@carrot-protocol/clend-rpc";
-import { AnchorProvider, BN, Wallet, web3 } from "@coral-xyz/anchor";
-import {
-  createJupiterApiClient,
-  QuoteResponse as JupQuoteResponse,
-  Instruction,
-} from "@jup-ag/api";
-import { JUPITER_SWAP_PROGRAM_ID } from "./addresses";
-import { TOKEN_PROGRAM_ID } from "@coral-xyz/anchor/dist/cjs/utils/token";
-import { getAssociatedTokenAddressSync } from "@solana/spl-token";
-import { ClendVaultsClient } from "./rpc";
-import { parseVaultAccount, Vault } from "./state";
-import { ClendVaultsProgram } from "./program";
-
-const QUOTE_URL = "https://api.jup.ag/swap/v1/quote";
-
-type ClendVaultsJupSwapperData = {
-  quoteResponse: JupQuoteResponse;
-  vault: web3.PublicKey;
-  inputMint: web3.PublicKey;
-  outputMint: web3.PublicKey;
-};
-
-export class ClendVaultsJupSwapper implements ISwapper {
-  private readonly jupiterApi;
-  private readonly connection: web3.Connection;
-  private readonly clendVaultsProgram: ClendVaultsProgram;
-
-  constructor(connection: web3.Connection, apiKey?: string) {
-    this.jupiterApi = createJupiterApiClient({
-      basePath: QUOTE_URL,
-      apiKey,
-    });
-    this.connection = connection;
-    this.clendVaultsProgram = new ClendVaultsProgram();
-  }
-
-  /**
-   * Implements the getQuote method from the ISwapper interface.
-   * It takes a standardized QuoteRequest and returns a standardized SwapQuote.
-   */
-  async getQuote(request: QuoteRequest): Promise<SwapQuote> {
-    const { inputMint, outputMint, inputAmount, swapMode, slippageBps, payer } =
-      request;
-
-    const quoteResponse: JupQuoteResponse = await this.jupiterApi.quoteGet({
-      inputMint: inputMint.toBase58(),
-      outputMint: outputMint.toBase58(),
-      amount: inputAmount.toNumber(),
-      slippageBps,
-      swapMode,
-      onlyDirectRoutes: true,
-    });
-
-    // Populate the standardized SwapQuote object
-    return {
-      payer,
-      inAmount: new BN(quoteResponse.inAmount),
-      outAmount: new BN(quoteResponse.outAmount),
-      otherAmountThreshold: new BN(quoteResponse.otherAmountThreshold),
-      swapperData: {
-        quoteResponse,
-        inputMint,
-        outputMint,
-        vault: payer,
-      } as ClendVaultsJupSwapperData,
-    };
-  }
-
-  /**
-   * Implements the getSwapIxns method from the ISwapper interface.
-   * It takes a standardized SwapQuote and returns standardized SwapIxns.
-   */
-  async getSwapIxns(quote: SwapQuote): Promise<SwapIxns> {
-    // Cast the swapperData object back to its specific type
-    const { inputMint, outputMint, vault, quoteResponse } =
-      quote.swapperData as ClendVaultsJupSwapperData;
-
-    const {
-      swapInstruction,
-      addressLookupTableAddresses,
-      setupInstructions,
-      cleanupInstruction,
-    } = await this.jupiterApi.swapInstructionsPost({
-      swapRequest: {
-        userPublicKey: vault.toBase58(),
-        payer: quote.payer.toBase58(),
-        quoteResponse: quoteResponse,
-        computeUnitPriceMicroLamports: 1,
-        wrapAndUnwrapSol: false, // TODO: may need to change this
-        destinationTokenAccount: undefined,
-        useSharedAccounts: false,
-        feeAccount: undefined,
-        skipUserAccountsRpcCalls: true,
-      },
-    });
-
-    const swapIx = transformResponseIx(swapInstruction);
-
-    const swapRemainingAccounts: web3.AccountMeta[] = swapIx.keys.map(
-      (key) => ({
-        pubkey: key.pubkey,
-        // If the account is the vault PDA, mark it as NOT a signer for the client transaction.
-        isSigner: key.pubkey.equals(vault) ? false : key.isSigner,
-        isWritable: key.isWritable,
-      }),
-    );
-    const swapData = swapIx.data;
-
-    const vaultAssetInReserve = getAssociatedTokenAddressSync(
-      inputMint,
-      vault,
-      true,
-      TOKEN_PROGRAM_ID,
-    );
-    const vaultAssetOutReserve = getAssociatedTokenAddressSync(
-      outputMint,
-      vault,
-      true,
-      TOKEN_PROGRAM_ID,
-    );
-
-    const vaultAccountInfo = await this.connection.getAccountInfo(vault);
-    if (!vaultAccountInfo) {
-      throw new Error(`Vault account not found: ${vault.toString()}`);
-    }
-    const vaultState = await parseVaultAccount(
-      vault,
-      vaultAccountInfo,
-      this.connection,
-    );
-
-    const ixns = await this.clendVaultsProgram.swap(
-      vault,
-      vaultState.manager,
-      inputMint,
-      outputMint,
-      vaultAssetInReserve,
-      vaultAssetOutReserve,
-      swapData,
-      swapRemainingAccounts,
-      JUPITER_SWAP_PROGRAM_ID,
-    );
-
-    const allIxs = [...ixns];
-
-    // Populate the standardized SwapIxns object
-    return {
-      ixns: allIxs,
-      luts: addressLookupTableAddresses.map((key) => new web3.PublicKey(key)),
-    };
-  }
-}
-
-// Helper functions remain the same
-function transformResponseIxs(
-  instructions: Instruction[],
-): web3.TransactionInstruction[] {
-  return instructions.map(transformResponseIx);
-}
-
-function transformResponseIx(
-  instruction: Instruction,
-): web3.TransactionInstruction {
-  return new web3.TransactionInstruction({
-    programId: new web3.PublicKey(instruction.programId),
-    keys: instruction.accounts.map((account) => ({
-      pubkey: new web3.PublicKey(account.pubkey),
-      isSigner: account.isSigner,
-      isWritable: account.isWritable,
-    })),
-    data: Buffer.from(instruction.data, "base64"),
-  });
-}
-
-type SwapMode = "ExactIn" | "ExactOut";
-
-/**
- * A standardized request object for getting a swap quote.
- */
-interface QuoteRequest {
-  payer: web3.PublicKey;
-  inputMint: web3.PublicKey;
-  inputMintDecimals: number;
-  outputMint: web3.PublicKey;
-  outputMintDecimals: number;
-  inputAmount: BN;
-  swapMode: SwapMode;
-  slippageBps: number;
-}
-
-/**
- * A standardized response from a getQuote call.
- */
-interface SwapQuote {
-  /** The public key of the account swapping. */
-  payer: web3.PublicKey;
-
-  /** The final amount of the input token, considering fees or adjustments. */
-  inAmount: BN;
-
-  /** The optimistic expected amount of the output token. */
-  outAmount: BN;
-
-  /** The minimum output or maximum input amount after applying slippage. */
-  otherAmountThreshold: BN;
-
-  /** A generic property for the swapper to pass its own specific data
-   * (e.g., the full Jupiter API response) from its getQuote method
-   * to its getSwapIxns method.
-   */
-  swapperData: any;
-}
-
-/**
- * The standardized set of instructions and lookup tables returned by a swapper.
- */
-interface SwapIxns {
-  ixns: web3.TransactionInstruction[];
-  luts: web3.PublicKey[];
-}

package/src/utils.ts

@@ -1,7 +0,0 @@
-import { AnchorProvider, Wallet, web3 } from "@coral-xyz/anchor";
-
-export function getDummyProvider(): AnchorProvider {
-  const connection = new web3.Connection("http://localhost:8899");
-  const wallet = new Wallet(web3.Keypair.generate());
-  return new AnchorProvider(connection, wallet, {});
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "module": "commonjs",
-    "target": "es2020",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "sourceMap": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"]
-}
-