Pool add getDepositQuote, getWithdrawQuote api's (#47)

* Pool add getDepositQuote, getWithdrawQuote api's

* remove unused functions

* getQuote slippage should be optional

* percentage input, constraint token

* comments update

* change types

* special case: handle SOL in getUserTokenCount

* decimal bug fix

* address comments

* comment update

Author: scuba

src/model/orca/pool/orca-pool.ts

@@ -19,6 +19,10 @@ import {
   TransactionPayload,
   Percentage,
   resolveOrCreateAssociatedTokenAddress,
+  ZERO,
+  DepositQuote,
+  WithdrawQuote,
+  DecimalUtil,
 } from "../../../public";
 import {
   createApprovalInstruction,
@@ -49,6 +53,10 @@ export class OrcaPoolImpl implements OrcaPool {
     return this.poolParams.tokens[tokenId];
   }
 
+  public getPoolTokenMint(): PublicKey {
+    return this.poolParams.poolTokenMint;
+  }
+
   public async getLPBalance(owner: PublicKey): Promise<OrcaU64> {
     const address = await deriveAssociatedTokenAddress(owner, this.poolParams.poolTokenMint);
 
@@ -184,6 +192,57 @@ export class OrcaPoolImpl implements OrcaPool {
       .build();
   }
 
+  public async getDepositQuote(
+    maxTokenAIn: Decimal | OrcaU64,
+    maxTokenBIn: Decimal | OrcaU64,
+    slippage?: Decimal
+  ): Promise<DepositQuote> {
+    const slippageTolerance =
+      slippage === undefined ? defaultSlippagePercentage : Percentage.fromDecimal(slippage);
+
+    const maxTokenAIn_U64 = U64Utils.toTokenU64(maxTokenAIn, this.getTokenA(), "maxTokenAIn");
+    const maxTokenBIn_U64 = U64Utils.toTokenU64(maxTokenBIn, this.getTokenB(), "maxTokenBIn");
+
+    const { inputTokenCount: tokenAAmount, outputTokenCount: tokenBAmount } = await getTokenCount(
+      this.connection,
+      this.poolParams,
+      this.getTokenA(),
+      this.getTokenB()
+    );
+    const lpSupply = await this.getLPSupply();
+
+    if (tokenAAmount.eq(ZERO) || tokenBAmount.eq(ZERO)) {
+      return {
+        minPoolTokenAmountOut: OrcaU64.fromU64(ZERO, lpSupply.scale),
+        maxTokenAIn: OrcaU64.fromU64(maxTokenAIn_U64, this.getTokenA().scale),
+        maxTokenBIn: OrcaU64.fromU64(maxTokenBIn_U64, this.getTokenB().scale),
+      };
+    }
+
+    const poolTokenAmountWithA = maxTokenAIn_U64
+      .mul(slippageTolerance.denominator)
+      .mul(lpSupply.toU64())
+      .div(tokenAAmount)
+      .div(slippageTolerance.numerator.add(slippageTolerance.denominator));
+
+    const poolTokenAmountWithB = maxTokenBIn_U64
+      .mul(slippageTolerance.denominator)
+      .mul(lpSupply.toU64())
+      .div(tokenBAmount)
+      .div(slippageTolerance.numerator.add(slippageTolerance.denominator));
+
+    // Pick the smaller value of the two to calculate the minimum poolTokenAmount out
+    const minPoolTokenAmountOut_U64 = poolTokenAmountWithA.gt(poolTokenAmountWithB)
+      ? poolTokenAmountWithB
+      : poolTokenAmountWithA;
+
+    return {
+      minPoolTokenAmountOut: OrcaU64.fromU64(minPoolTokenAmountOut_U64, lpSupply.scale),
+      maxTokenAIn: OrcaU64.fromU64(maxTokenAIn_U64, this.getTokenA().scale),
+      maxTokenBIn: OrcaU64.fromU64(maxTokenBIn_U64, this.getTokenB().scale),
+    };
+  }
+
   public async deposit(
     owner: Keypair | PublicKey,
     maxTokenAIn: Decimal | OrcaU64,
@@ -270,6 +329,86 @@ export class OrcaPoolImpl implements OrcaPool {
       .build();
   }
 
+  public async getWithdrawQuote(
+    withdrawTokenAmount: Decimal | OrcaU64,
+    withdrawTokenMint: PublicKey,
+    slippage?: Decimal
+  ): Promise<WithdrawQuote> {
+    const slippageTolerance =
+      slippage === undefined ? defaultSlippagePercentage : Percentage.fromDecimal(slippage);
+
+    const lpSupply = await this.getLPSupply();
+    const { inputTokenCount: tokenAAmount, outputTokenCount: tokenBAmount } = await getTokenCount(
+      this.connection,
+      this.poolParams,
+      this.getTokenA(),
+      this.getTokenB()
+    );
+
+    // withdrawTokenAmount needs represent amounts for one of the following: poolTokenAmount, tokenAAmount, or tokenBAmount
+    // determine which token this amount represents, then calculate poolTokenIn_U64
+    let poolTokenIn_U64 = ZERO;
+    if (withdrawTokenMint.equals(this.getPoolTokenMint())) {
+      poolTokenIn_U64 = U64Utils.toPoolU64(
+        withdrawTokenAmount,
+        this.poolParams,
+        "withdrawTokenAmount"
+      );
+    } else if (
+      withdrawTokenMint.equals(this.getTokenA().mint) ||
+      withdrawTokenMint.equals(this.getTokenB().mint)
+    ) {
+      const token = withdrawTokenMint.equals(this.getTokenA().mint)
+        ? this.getTokenA()
+        : this.getTokenB();
+      const totalAmount = token.mint.equals(this.getTokenA().mint) ? tokenAAmount : tokenBAmount;
+
+      const numerator =
+        withdrawTokenAmount instanceof OrcaU64
+          ? withdrawTokenAmount.toDecimal()
+          : withdrawTokenAmount;
+      const denominator = DecimalUtil.fromU64(totalAmount, token.scale);
+      const poolTokenIn = lpSupply.toDecimal().div(denominator).mul(numerator);
+      poolTokenIn_U64 = U64Utils.toPoolU64(poolTokenIn, this.poolParams, "poolTokenIn");
+    } else {
+      throw new Error(
+        `Unable to get withdraw quote with an invalid withdrawTokenMint ${withdrawTokenMint}`
+      );
+    }
+
+    if (poolTokenIn_U64.eq(ZERO)) {
+      return {
+        maxPoolTokenAmountIn: OrcaU64.fromU64(ZERO, lpSupply.scale),
+        minTokenAOut: OrcaU64.fromU64(ZERO, this.getTokenA().scale),
+        minTokenBOut: OrcaU64.fromU64(ZERO, this.getTokenB().scale),
+      };
+    }
+
+    const minTokenAOut = new OrcaU64(
+      poolTokenIn_U64
+        .mul(slippageTolerance.denominator)
+        .mul(tokenAAmount)
+        .div(lpSupply.toU64())
+        .div(slippageTolerance.numerator.add(slippageTolerance.denominator)),
+      this.getTokenA().scale
+    );
+
+    const minTokenBOut = new OrcaU64(
+      poolTokenIn_U64
+        .mul(slippageTolerance.denominator)
+        .mul(tokenBAmount)
+        .div(lpSupply.toU64())
+        .div(slippageTolerance.numerator.add(slippageTolerance.denominator)),
+      this.getTokenB().scale
+    );
+
+    return {
+      maxPoolTokenAmountIn: OrcaU64.fromU64(poolTokenIn_U64, lpSupply.scale),
+      minTokenAOut,
+      minTokenBOut,
+    };
+  }
+
   public async withdraw(
     owner: Keypair | PublicKey,
     poolTokenAmountIn: Decimal | OrcaU64,

src/public/pools/types.ts

@@ -3,6 +3,18 @@ import Decimal from "decimal.js";
 import { OrcaU64 } from "..";
 import { TransactionPayload } from "../utils";
 
+export type DepositQuote = {
+  minPoolTokenAmountOut: OrcaU64;
+  maxTokenAIn: OrcaU64;
+  maxTokenBIn: OrcaU64;
+};
+
+export type WithdrawQuote = {
+  minTokenAOut: OrcaU64;
+  minTokenBOut: OrcaU64;
+  maxPoolTokenAmountIn: OrcaU64;
+};
+
 /**
  * Allows interactions with an Orca liquidity pool.
  */
@@ -19,6 +31,12 @@ export type OrcaPool = {
    */
   getTokenB: () => OrcaPoolToken;
 
+  /**
+   * Query the mint public key for the pool token of this pool.
+   * @returns Returns the tokenMint public key of this pool
+   */
+  getPoolTokenMint: () => PublicKey;
+
   /**
    * Query the balance for an user address
    * @param wallet The public key for the user.
@@ -39,13 +57,13 @@ export type OrcaPool = {
    *
    * @param inputTokenId The token you want to trade from
    * @param inputAmount The amount of token you would to trade
-   * @param slippage The slippage in percentage you are willing to take in this trade
+   * @param slippage An optional slippage in percentage you are willing to take in this trade (default: 0.1%)
    * @return Returns a quote on the exchanged token based on the input token amount
    */
   getQuote: (
     inputToken: OrcaToken,
     inputAmount: Decimal | OrcaU64,
-    slippage: Decimal
+    slippage?: Decimal
   ) => Promise<Quote>;
 
   /**
@@ -69,6 +87,20 @@ export type OrcaPool = {
     minimumAmountOut: Decimal | OrcaU64
   ) => Promise<TransactionPayload>;
 
+  /**
+   * Get suggested pool token deposit amount based on required constraints on maximum tokenA amount and maximum tokenB amount
+   *
+   * @param maxTokenAIn The maximum amount of tokenA to deposit in exchange for pool token
+   * @param maxTokenBIn The maximum amount of tokenB to deposit in exchange for pool token
+   * @param slippage An optional slippage in percentage you are willing to take in deposit (default: 0.1%)
+   * @return Returns the input for deposit
+   */
+  getDepositQuote: (
+    maxTokenAIn: Decimal | OrcaU64,
+    maxTokenBIn: Decimal | OrcaU64,
+    slippage?: Decimal
+  ) => Promise<DepositQuote>;
+
   /**
    * Perform a deposit: send tokenA and tokenB, and receive a poolToken in return.
    * Fee for the transaction will be paid by the owner's wallet.
@@ -90,6 +122,22 @@ export type OrcaPool = {
     minPoolTokenAmountOut: Decimal | OrcaU64
   ) => Promise<TransactionPayload>;
 
+  /**
+   * Get suggested withdraw token amounts based on required withdraw amount of the pool token / one of the paired tokens
+   *
+   * Throws error if withdrawTokenMint does not equal tokenMint of tokenA, tokenB, or poolToken of this pool
+   *
+   * @param withdrawTokenAmount The amount of tokens to withdraw in terms of tokenA amount, tokenB amount, or poolToken amount
+   * @param withdrawTokenMint The token mint public key of tied to withdrawTokenAmount. It should be the mint of tokenA, tokenB, or poolToken
+   * @param slippage An optional slippage in percentage you are willing to take in withdraw (default: 0.1%)
+   * @return Returns the input for withdraw
+   */
+  getWithdrawQuote: (
+    withdrawTokenAmount: Decimal | OrcaU64,
+    withdrawTokenMint: PublicKey,
+    slippage?: Decimal
+  ) => Promise<WithdrawQuote>;
+
   /**
    * Perform a withdraw: send poolToken, and receive tokenA and tokenB in return.
    * Fee for the transaction will be paid by the owner's wallet.