@carrot-protocol/clend-rpc 0.0.1-mrgn-fork1-dev-7be6ef2

package/src/jupUtils.ts

@@ -0,0 +1,347 @@
+import { web3 } from "@coral-xyz/anchor";
+import axios from "axios";
+import {
+  createJupiterApiClient,
+  Instruction,
+  QuoteGetRequest,
+  QuoteResponse,
+  ResponseError,
+  SwapInfo,
+  SwapInstructionsPostRequest,
+  SwapMode,
+} from "@jup-ag/api";
+import Decimal from "decimal.js";
+
+const DEFAULT_MAX_ACCOUNTS_BUFFER = 2;
+const MAX_LOCKED_ACCOUNTS = 64;
+const JUPITER_PRICE_API = "https://api.jup.ag/price/v2";
+const DEFAULT_JUP_V6_BASE_URL = "https://quote-api.jup.ag/v6";
+
+export type ErrorBody = {
+  error: string;
+  error_code: string;
+};
+
+export type SwapTxResponse = {
+  swapTxs: SwapTxs;
+  lookupTables: web3.PublicKey[];
+  swapResponse: SwapResponse;
+};
+
+export type SwapResponse = {
+  swapInAmountLamports: Decimal;
+  swapOutAmountLamports: Decimal;
+  swapMinOutAmountLamports: Decimal;
+};
+
+export type SwapTxs = {
+  setupIxs: web3.TransactionInstruction[];
+  swapIxs: web3.TransactionInstruction[];
+  cleanupIxs: web3.TransactionInstruction[];
+};
+
+export async function getJupiterPrice(
+  mint: web3.PublicKey | string,
+): Promise<number> {
+  const params = {
+    ids: mint.toString(),
+  };
+
+  const res = await axios.get(JUPITER_PRICE_API, { params });
+  return res.data.data[mint.toString()]?.price || 0;
+}
+
+export type SwapConfig = {
+  wrapAndUnwrapSol?: boolean;
+  slippageBps: number;
+  swapMode: SwapMode;
+  onlyDirectRoutes: boolean;
+};
+
+async function quote(
+  inputMint: web3.PublicKey,
+  outputMint: web3.PublicKey,
+  amountLamports: Decimal,
+  { slippageBps, onlyDirectRoutes, swapMode }: SwapConfig,
+  maxAccs: number,
+  restrictIntermediateTokens: boolean = false,
+): Promise<QuoteResponse> {
+  const quoteApi = createJupiterApiClient({
+    basePath: DEFAULT_JUP_V6_BASE_URL,
+  });
+  try {
+    const quoteParameters: QuoteGetRequest = {
+      inputMint: inputMint.toBase58(),
+      outputMint: outputMint.toBase58(),
+      amount: amountLamports.floor().toNumber(),
+      slippageBps: slippageBps,
+      onlyDirectRoutes: onlyDirectRoutes,
+      restrictIntermediateTokens: restrictIntermediateTokens,
+      //maxAccounts: maxAccs, NOT SUPPORTED WITH EXACT OUT
+      swapMode,
+    };
+    return await quoteApi.quoteGet(quoteParameters);
+  } catch (e) {
+    if (e instanceof ResponseError) {
+      const body = (await e.response.json()) as ErrorBody;
+      throw new JupQuoteResponseError(e, body);
+    }
+    throw e;
+  }
+}
+
+export async function getJupiterQuote(
+  inputMint: web3.PublicKey,
+  outputMint: web3.PublicKey,
+  inputAmountLamports: Decimal,
+  slippageBps: number,
+  swapMode: SwapMode,
+  inputMintDecimals: number,
+  outputMintDecimals: number,
+): Promise<SwapQuote<QuoteResponse>> {
+  const maxAccounts = 15;
+  const quoteResponse = await quote(
+    inputMint,
+    outputMint,
+    inputAmountLamports,
+    {
+      slippageBps: slippageBps,
+      wrapAndUnwrapSol: false,
+      onlyDirectRoutes: true,
+      swapMode,
+    },
+    maxAccounts,
+    true,
+  );
+
+  const inAmount = new Decimal(quoteResponse.inAmount).div(
+    new Decimal(10).pow(inputMintDecimals),
+  );
+  const minAmountOut = new Decimal(quoteResponse.otherAmountThreshold).div(
+    new Decimal(10).pow(outputMintDecimals),
+  );
+  const priceDebtToColl = minAmountOut.div(inAmount);
+
+  return {
+    priceAInB: priceDebtToColl,
+    quoteResponse,
+  };
+}
+
+export async function getJupiterSwap(
+  payer: web3.PublicKey,
+  inputs: SwapInputs,
+  quote: SwapQuote<QuoteResponse>,
+): Promise<SwapIxs> {
+  const scaledQuoteResponse = scaleJupQuoteResponse(
+    quote.quoteResponse!,
+    new Decimal(inputs.inputAmountLamports),
+  );
+  const { swapTxs, lookupTables } = await swapTxFromQuote(
+    payer,
+    scaledQuoteResponse,
+    {
+      slippageBps: quote.quoteResponse!.slippageBps,
+      wrapAndUnwrapSol: false,
+      onlyDirectRoutes: true,
+      swapMode: quote.quoteResponse!.swapMode,
+    },
+  );
+  return {
+    preActionIxs: [],
+    swapIxs: [...swapTxs.setupIxs, ...swapTxs.swapIxs, ...swapTxs.cleanupIxs],
+    lookupTables,
+  };
+}
+
+export async function swapTxFromQuote(
+  payer: web3.PublicKey,
+  quote: QuoteResponse,
+  swapConfig: SwapConfig,
+): Promise<SwapTxResponse> {
+  const quoteApi = createJupiterApiClient({
+    basePath: DEFAULT_JUP_V6_BASE_URL,
+  });
+  try {
+    const swapParameters: SwapInstructionsPostRequest = {
+      swapRequest: {
+        userPublicKey: payer.toBase58(),
+        quoteResponse: quote,
+        computeUnitPriceMicroLamports: 1,
+        wrapAndUnwrapSol: swapConfig?.wrapAndUnwrapSol ?? false,
+        destinationTokenAccount: undefined,
+        useSharedAccounts: false,
+        feeAccount: undefined,
+        skipUserAccountsRpcCalls: true,
+      },
+    };
+    const swap = await quoteApi.swapInstructionsPost(swapParameters);
+
+    const swapIxs = [transformResponseIx(swap.swapInstruction)];
+    return {
+      swapTxs: {
+        setupIxs: transformResponseIxs(swap.setupInstructions),
+        swapIxs,
+        cleanupIxs: transformResponseIxs(
+          swap.cleanupInstruction ? [swap.cleanupInstruction] : [],
+        ),
+      },
+      lookupTables: swap.addressLookupTableAddresses.map(
+        (k) => new web3.PublicKey(k),
+      ),
+      swapResponse: {
+        swapInAmountLamports: new Decimal(quote.inAmount),
+        swapOutAmountLamports: new Decimal(quote.outAmount),
+        swapMinOutAmountLamports: new Decimal(quote.otherAmountThreshold),
+      },
+    };
+  } catch (e) {
+    if (e instanceof ResponseError) {
+      const body = (await e.response.json()) as ErrorBody;
+      throw new JupSwapResponseError(e, body);
+    }
+    throw e;
+  }
+}
+
+export function scaleJupQuoteResponse(
+  ogQuote: QuoteResponse,
+  swapInputAmountLamports: Decimal,
+): QuoteResponse {
+  const ogInLamports = new Decimal(ogQuote.inAmount);
+  const ogOutLamports = new Decimal(ogQuote.outAmount);
+  const ogOtherAmountThreshold = new Decimal(ogQuote.otherAmountThreshold);
+  const scale = swapInputAmountLamports.div(ogInLamports);
+  const scaledOutLamports = ogOutLamports.mul(scale).floor();
+  const scaledOtherAmountThreshold = ogOtherAmountThreshold.mul(scale).floor();
+  const newRoutes = ogQuote.routePlan.map((r) => {
+    const ogSwapInfo = r.swapInfo;
+    const newSwapInfo: SwapInfo = {
+      ...ogSwapInfo,
+      inAmount: new Decimal(r.swapInfo.inAmount).mul(scale).ceil().toString(),
+      outAmount: new Decimal(r.swapInfo.outAmount)
+        .mul(scale)
+        .floor()
+        .toString(),
+      feeAmount: new Decimal(r.swapInfo.feeAmount).mul(scale).ceil().toString(),
+    };
+    return {
+      ...r,
+      swapInfo: newSwapInfo,
+    };
+  });
+  const newQuote = {
+    ...ogQuote,
+    inAmount: swapInputAmountLamports.toString(),
+    outAmount: scaledOutLamports.toString(),
+    otherAmountThreshold: scaledOtherAmountThreshold.toString(),
+    routePlan: newRoutes,
+  };
+  return newQuote;
+}
+
+export function getMaxAccountsWithBuffer(
+  numberOfUniqueAccs: number,
+  buffer: number = DEFAULT_MAX_ACCOUNTS_BUFFER,
+): number {
+  return maxLockedAccounts(numberOfUniqueAccs + buffer);
+}
+
+export function maxLockedAccounts(count: number): number {
+  return MAX_LOCKED_ACCOUNTS - count;
+}
+
+/**
+ * Wrapper to read the response body multiple times
+ */
+export class JupQuoteResponseError extends Error {
+  err: ResponseError;
+  body: ErrorBody;
+
+  constructor(err: ResponseError, body: ErrorBody) {
+    super(
+      `Received ${err.response.statusText} (${err.response.status}) error response for jup quote. Request url: ${
+        err.response.url
+      } \nResponse body:\n${JSON.stringify(body, null, 2)}`,
+    );
+    this.err = err;
+    this.body = body;
+  }
+}
+
+/**
+ * Wrapper to read the response body multiple times
+ */
+export class JupSwapResponseError extends Error {
+  err: ResponseError;
+  body: ErrorBody;
+
+  constructor(err: ResponseError, body: ErrorBody) {
+    super(
+      `Received ${err.response.statusText} (${err.response.status}) error response for jup swap. Request url: ${
+        err.response.url
+      } \nResponse body:\n${JSON.stringify(body, null, 2)}`,
+    );
+    this.err = err;
+    this.body = body;
+  }
+}
+
+export const getLookupTableAccountsFromKeys = async (
+  connection: web3.Connection,
+  keys: web3.PublicKey[],
+): Promise<web3.AddressLookupTableAccount[]> => {
+  const lookupTableAccounts: web3.AddressLookupTableAccount[] = [];
+
+  for (const lookupTable of keys) {
+    const lookupTableAccount = await connection
+      .getAddressLookupTable(lookupTable)
+      .then((res) => res.value);
+
+    if (!lookupTableAccount) {
+      throw new Error("lookup table is not found");
+    }
+
+    lookupTableAccounts.push(lookupTableAccount);
+  }
+
+  return lookupTableAccounts;
+};
+
+export function transformResponseIx(
+  ix: Instruction,
+): web3.TransactionInstruction {
+  return new web3.TransactionInstruction({
+    programId: new web3.PublicKey(ix.programId),
+    keys: ix.accounts.map((k) => ({
+      pubkey: new web3.PublicKey(k.pubkey),
+      isSigner: k.isSigner,
+      isWritable: k.isWritable,
+    })),
+    data: ix.data ? Buffer.from(ix.data, "base64") : undefined,
+  });
+}
+
+export function transformResponseIxs(
+  ixs: Instruction[],
+): web3.TransactionInstruction[] {
+  return ixs.map((ix) => transformResponseIx(ix));
+}
+
+export type SwapQuote<QuoteResponse> = {
+  priceAInB: Decimal;
+  quoteResponse?: QuoteResponse;
+};
+
+export type SwapIxs = {
+  preActionIxs: web3.TransactionInstruction[];
+  swapIxs: web3.TransactionInstruction[];
+  lookupTables: web3.PublicKey[];
+};
+
+export type SwapInputs = {
+  inputAmountLamports: Decimal;
+  minOutAmountLamports?: Decimal;
+  inputMint: web3.PublicKey;
+  outputMint: web3.PublicKey;
+};

package/src/jupiterUtils.ts

@@ -0,0 +1,288 @@
+import { BN, web3 } from "@coral-xyz/anchor";
+import Decimal from "decimal.js";
+import {
+  createJupiterApiClient,
+  Instruction,
+  QuoteGetRequest,
+  QuoteResponse,
+  ResponseError,
+  SwapInfo,
+  SwapInstructionsPostRequest,
+  SwapMode,
+} from "@jup-ag/api";
+import axios from "axios";
+
+const JUPITER_PRICE_API = "https://api.jup.ag/price/v2";
+const DEFAULT_JUP_V6_BASE_URL = "https://quote-api.jup.ag/v6";
+
+export type ErrorBody = {
+  error: string;
+  error_code: string;
+};
+
+export type SwapTxResponse = {
+  swapTxs: SwapTxs;
+  lookupTables: web3.PublicKey[];
+  swapResponse: SwapResponse;
+};
+
+export type SwapResponse = {
+  swapInAmountLamports: Decimal;
+  swapOutAmountLamports: Decimal;
+  swapMinOutAmountLamports: Decimal;
+};
+
+export type SwapTxs = {
+  setupIxs: web3.TransactionInstruction[];
+  swapIxs: web3.TransactionInstruction[];
+  cleanupIxs: web3.TransactionInstruction[];
+};
+
+export type SwapConfig = {
+  slippageBps: number;
+  wrapAndUnwrapSol?: boolean;
+  onlyDirectRoutes?: boolean;
+  swapMode?: SwapMode;
+};
+
+export type SwapInputs = {
+  inputMint: web3.PublicKey;
+  outputMint: web3.PublicKey;
+  inputAmountLamports: Decimal;
+};
+
+export type SwapIxs = {
+  preActionIxs: web3.TransactionInstruction[];
+  swapIxs: web3.TransactionInstruction[];
+  lookupTables: web3.PublicKey[];
+};
+
+export type SwapQuote<T> = {
+  priceAInB: Decimal;
+  quoteResponse?: T;
+};
+
+export class JupSwapResponseError extends Error {
+  constructor(
+    public error: ResponseError,
+    public body: ErrorBody,
+  ) {
+    super(`JupSwapResponseError: ${body.error} (${body.error_code})`);
+  }
+}
+
+// Define the JupiterUtils interface
+export interface IJupiterUtils {
+  getJupiterPrice(mint: web3.PublicKey | string): Promise<number>;
+
+  getJupiterQuote(
+    inputMint: web3.PublicKey,
+    outputMint: web3.PublicKey,
+    inputMintDecimals: number,
+    outputMintDecimals: number,
+    inputAmountLamports: Decimal,
+    slippageBps: number,
+    swapMode?: SwapMode,
+  ): Promise<SwapQuote<QuoteResponse>>;
+
+  getJupiterSwap(
+    payer: web3.PublicKey,
+    inputs: SwapInputs,
+    quote: SwapQuote<QuoteResponse>,
+  ): Promise<SwapIxs>;
+}
+
+// Default implementation of JupiterUtils
+export class JupiterUtils implements IJupiterUtils {
+  async getJupiterPrice(mint: web3.PublicKey | string): Promise<number> {
+    const params = {
+      ids: mint.toString(),
+    };
+
+    const res = await axios.get(JUPITER_PRICE_API, { params });
+    return res.data.data[mint.toString()]?.price || 0;
+  }
+
+  async getJupiterQuote(
+    inputMint: web3.PublicKey,
+    outputMint: web3.PublicKey,
+    inputMintDecimals: number,
+    outputMintDecimals: number,
+    inputAmountLamports: Decimal,
+    slippageBps: number,
+    swapMode: SwapMode = "ExactIn",
+  ): Promise<SwapQuote<QuoteResponse>> {
+    const quoteResponse = await quote(
+      inputMint,
+      outputMint,
+      inputAmountLamports,
+      {
+        slippageBps: slippageBps,
+        wrapAndUnwrapSol: false,
+        onlyDirectRoutes: true,
+        swapMode,
+      },
+    );
+
+    const inAmount = new Decimal(quoteResponse.inAmount).div(
+      new Decimal(10).pow(inputMintDecimals),
+    );
+    const minAmountOut = new Decimal(quoteResponse.otherAmountThreshold).div(
+      new Decimal(10).pow(outputMintDecimals),
+    );
+    const priceDebtToColl = minAmountOut.div(inAmount);
+
+    return {
+      priceAInB: priceDebtToColl,
+      quoteResponse,
+    };
+  }
+
+  async getJupiterSwap(
+    payer: web3.PublicKey,
+    inputs: SwapInputs,
+    quote: SwapQuote<QuoteResponse>,
+  ): Promise<SwapIxs> {
+    const scaledQuoteResponse = scaleJupQuoteResponse(
+      quote.quoteResponse!,
+      new Decimal(inputs.inputAmountLamports),
+    );
+    const { swapTxs, lookupTables } = await swapTxFromQuote(
+      payer,
+      scaledQuoteResponse,
+      {
+        slippageBps: quote.quoteResponse!.slippageBps,
+        wrapAndUnwrapSol: false,
+        onlyDirectRoutes: true,
+        swapMode: quote.quoteResponse!.swapMode,
+      },
+    );
+    return {
+      preActionIxs: [],
+      swapIxs: [...swapTxs.setupIxs, ...swapTxs.swapIxs, ...swapTxs.cleanupIxs],
+      lookupTables,
+    };
+  }
+}
+
+// Helper functions
+export async function quote(
+  inputMint: web3.PublicKey,
+  outputMint: web3.PublicKey,
+  amount: Decimal,
+  swapConfig: SwapConfig,
+): Promise<QuoteResponse> {
+  const quoteApi = createJupiterApiClient({
+    basePath: DEFAULT_JUP_V6_BASE_URL,
+  });
+
+  const quoteRequest: QuoteGetRequest = {
+    inputMint: inputMint.toBase58(),
+    outputMint: outputMint.toBase58(),
+    amount: Number(amount),
+    slippageBps: Number(swapConfig.slippageBps),
+    swapMode: swapConfig.swapMode,
+    onlyDirectRoutes: swapConfig.onlyDirectRoutes,
+  };
+
+  try {
+    return await quoteApi.quoteGet(quoteRequest);
+  } catch (e) {
+    if (e instanceof ResponseError) {
+      const body = (await e.response.json()) as ErrorBody;
+      throw new JupSwapResponseError(e, body);
+    }
+    throw e;
+  }
+}
+
+export async function swapTxFromQuote(
+  payer: web3.PublicKey,
+  quote: QuoteResponse,
+  swapConfig: SwapConfig,
+): Promise<SwapTxResponse> {
+  const quoteApi = createJupiterApiClient({
+    basePath: DEFAULT_JUP_V6_BASE_URL,
+  });
+  try {
+    const swapParameters: SwapInstructionsPostRequest = {
+      swapRequest: {
+        userPublicKey: payer.toBase58(),
+        quoteResponse: quote,
+        computeUnitPriceMicroLamports: 1,
+        wrapAndUnwrapSol: swapConfig?.wrapAndUnwrapSol ?? false,
+        destinationTokenAccount: undefined,
+        useSharedAccounts: false,
+        feeAccount: undefined,
+        skipUserAccountsRpcCalls: true,
+      },
+    };
+    const swap = await quoteApi.swapInstructionsPost(swapParameters);
+
+    const swapIxs = [transformResponseIx(swap.swapInstruction)];
+    return {
+      swapTxs: {
+        setupIxs: transformResponseIxs(swap.setupInstructions),
+        swapIxs,
+        cleanupIxs: transformResponseIxs(
+          swap.cleanupInstruction ? [swap.cleanupInstruction] : [],
+        ),
+      },
+      lookupTables: swap.addressLookupTableAddresses.map(
+        (k) => new web3.PublicKey(k),
+      ),
+      swapResponse: {
+        swapInAmountLamports: new Decimal(quote.inAmount),
+        swapOutAmountLamports: new Decimal(quote.outAmount),
+        swapMinOutAmountLamports: new Decimal(quote.otherAmountThreshold),
+      },
+    };
+  } catch (e) {
+    if (e instanceof ResponseError) {
+      const body = (await e.response.json()) as ErrorBody;
+      throw new JupSwapResponseError(e, body);
+    }
+    throw e;
+  }
+}
+
+export function scaleJupQuoteResponse(
+  quoteResponse: QuoteResponse,
+  newAmount: Decimal,
+): QuoteResponse {
+  const oldAmount = new Decimal(quoteResponse.inAmount);
+  const scaleFactor = newAmount.div(oldAmount);
+
+  const newQuoteResponse = { ...quoteResponse };
+  newQuoteResponse.inAmount = newAmount.toString();
+  // Calculate the new output amount based on the price and scale factor
+  const outputAmount = new Decimal(quoteResponse.outAmount);
+  newQuoteResponse.outAmount = outputAmount.mul(scaleFactor).toString();
+  newQuoteResponse.otherAmountThreshold = new Decimal(
+    quoteResponse.otherAmountThreshold,
+  )
+    .mul(scaleFactor)
+    .toString();
+
+  return newQuoteResponse;
+}
+
+export function transformResponseIxs(
+  instructions: Instruction[],
+): web3.TransactionInstruction[] {
+  return instructions.map(transformResponseIx);
+}
+
+export 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"),
+  });
+}

package/src/logger.ts

@@ -0,0 +1,21 @@
+import winston from "winston";
+
+// Logger setup
+export const logger = winston.createLogger({
+  level: "debug",
+  defaultMeta: {
+    service: "rpc-client",
+  },
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.printf((info) => {
+      const { timestamp, level, message, service, ...metadata } = info;
+      return (
+        `${timestamp} [${level}] [${service}]: ${message}` +
+        (Object.keys(metadata).length ? ` ${JSON.stringify(metadata)}` : "")
+      );
+    }),
+    winston.format.json(),
+  ),
+  transports: [new winston.transports.Console()],
+});