@meteora-ag/zap-sdk 1.2.0-rc.3 → 1.2.0-rc.4

package/dist/index.d.mts

@@ -2019,6 +2019,8 @@ declare class Zap {
     private updateLedgerBalanceAfterSwap;
     private zapInDammV2;
     private resetOrInitializeLedgerAccount;
+    private isJupiterQuoteableAmount;
+    private findMinimumJupiterQuoteableAmount;
     private zapInDlmmForInitializedPosition;
     private zapInDlmmForUninitializedPosition;
     /**

package/dist/index.d.ts

@@ -2019,6 +2019,8 @@ declare class Zap {
     private updateLedgerBalanceAfterSwap;
     private zapInDammV2;
     private resetOrInitializeLedgerAccount;
+    private isJupiterQuoteableAmount;
+    private findMinimumJupiterQuoteableAmount;
     private zapInDlmmForInitializedPosition;
     private zapInDlmmForUninitializedPosition;
     /**

package/dist/index.js

@@ -1863,37 +1863,18 @@ function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6) {
       quoteResponse,
       config
     );
-    const toTxInstruction = (instruction) => {
-      if (!instruction) return null;
-      return new import_web32.TransactionInstruction({
-        keys: instruction.accounts.map((item) => {
-          return {
-            pubkey: new import_web32.PublicKey(item.pubkey),
-            isSigner: item.isSigner,
-            isWritable: item.isWritable
-          };
-        }),
-        programId: new import_web32.PublicKey(instruction.programId),
-        data: Buffer.from(instruction.data, "base64")
-      });
-    };
-    const transaction = new import_web32.Transaction();
-    const tokenLedgerInstruction = toTxInstruction(
-      swapInstructionResponse.tokenLedgerInstruction
-    );
-    if (tokenLedgerInstruction) {
-      transaction.add(tokenLedgerInstruction);
-    }
-    for (const setupInstruction of swapInstructionResponse.setupInstructions) {
-      const txInstruction = toTxInstruction(setupInstruction);
-      if (txInstruction) transaction.add(txInstruction);
-    }
-    const swapInstruction = toTxInstruction(swapInstructionResponse.swapInstruction);
-    if (!swapInstruction) {
-      throw new Error("Missing Jupiter swap instruction");
-    }
-    transaction.add(swapInstruction);
-    return { transaction, quoteResponse };
+    const instruction = new import_web32.TransactionInstruction({
+      keys: swapInstructionResponse.swapInstruction.accounts.map((item) => {
+        return {
+          pubkey: new import_web32.PublicKey(item.pubkey),
+          isSigner: item.isSigner,
+          isWritable: item.isWritable
+        };
+      }),
+      programId: new import_web32.PublicKey(swapInstructionResponse.swapInstruction.programId),
+      data: Buffer.from(swapInstructionResponse.swapInstruction.data, "base64")
+    });
+    return { transaction: new import_web32.Transaction().add(instruction), quoteResponse };
   });
 }
 
@@ -3224,6 +3205,26 @@ function calculateIndirectPoolSwapAmount(amount, amountDecimals, price1, price2,
     convertUiAmountToLamports(swapAmountDecimal, amountDecimals).floor().toString()
   );
 }
+function splitIndirectSwapAmounts(amountIn, swapAmountToA) {
+  if (swapAmountToA.isNeg()) {
+    throw new Error("Calculated swap amount to token A cannot be negative");
+  }
+  if (swapAmountToA.gt(amountIn)) {
+    throw new Error(
+      "Calculated swap amount to token A exceeds total input amount"
+    );
+  }
+  const swapAmountToB = amountIn.sub(swapAmountToA);
+  if (swapAmountToB.isNeg()) {
+    throw new Error("Calculated swap amount to token B cannot be negative");
+  }
+  return {
+    swapAmountToA,
+    swapAmountToB,
+    hasSwapToA: !swapAmountToA.isZero(),
+    hasSwapToB: !swapAmountToB.isZero()
+  };
+}
 function getExtendMaxAmountTransfer(amount, percentage) {
   const extendAmount = new import_decimal3.default(amount).mul(percentage).div(100).floor().toString();
   return new import_bn4.default(amount).add(new import_bn4.default(extendAmount));
@@ -3331,6 +3332,65 @@ var Zap = class {
       return yield this.initializeLedgerAccount(user, user);
     });
   }
+  isJupiterQuoteableAmount(inputMint, outputMint, amount, maxAccounts, slippageBps) {
+    return __async(this, null, function* () {
+      if (amount.isZero()) {
+        return true;
+      }
+      const quote = yield getJupiterQuote(
+        inputMint,
+        outputMint,
+        amount,
+        maxAccounts,
+        slippageBps,
+        false,
+        true,
+        true,
+        {
+          jupiterApiUrl: this.jupiterApiUrl,
+          jupiterApiKey: this.jupiterApiKey
+        }
+      );
+      return quote !== null;
+    });
+  }
+  findMinimumJupiterQuoteableAmount(inputMint, outputMint, maxAmount, maxAccounts, slippageBps) {
+    return __async(this, null, function* () {
+      if (maxAmount.isZero()) {
+        return null;
+      }
+      const maxAmountQuoteable = yield this.isJupiterQuoteableAmount(
+        inputMint,
+        outputMint,
+        maxAmount,
+        maxAccounts,
+        slippageBps
+      );
+      if (!maxAmountQuoteable) {
+        return null;
+      }
+      let left = new import_anchor.BN(1);
+      let right = maxAmount;
+      let best = maxAmount;
+      while (left.lte(right)) {
+        const mid = left.add(right).div(new import_anchor.BN(2));
+        const isQuoteable = yield this.isJupiterQuoteableAmount(
+          inputMint,
+          outputMint,
+          mid,
+          maxAccounts,
+          slippageBps
+        );
+        if (isQuoteable) {
+          best = mid;
+          right = mid.sub(new import_anchor.BN(1));
+        } else {
+          left = mid.add(new import_anchor.BN(1));
+        }
+      }
+      return best;
+    });
+  }
   zapInDlmmForInitializedPosition(params) {
     return __async(this, null, function* () {
       const {
@@ -3881,8 +3941,63 @@ var Zap = class {
             tokenBDecimal
           )
         );
-        const swapAmountToB = amountIn.sub(swapAmountToA);
-        if (swapAmountToA.isZero()) {
+        let { swapAmountToA: adjustedSwapAmountToA, swapAmountToB } = splitIndirectSwapAmounts(amountIn, swapAmountToA);
+        const quoteableA = yield this.isJupiterQuoteableAmount(
+          inputTokenMint,
+          tokenAMint,
+          adjustedSwapAmountToA,
+          maxAccounts,
+          slippageBps
+        );
+        if (!quoteableA && !adjustedSwapAmountToA.isZero()) {
+          const minQuoteableToA = yield this.findMinimumJupiterQuoteableAmount(
+            inputTokenMint,
+            tokenAMint,
+            amountIn,
+            maxAccounts,
+            slippageBps
+          );
+          if (minQuoteableToA !== null) {
+            adjustedSwapAmountToA = minQuoteableToA;
+            swapAmountToB = amountIn.sub(adjustedSwapAmountToA);
+          } else {
+            adjustedSwapAmountToA = new import_anchor.BN(0);
+            swapAmountToB = amountIn;
+          }
+        }
+        const quoteableB = yield this.isJupiterQuoteableAmount(
+          inputTokenMint,
+          tokenBMint,
+          swapAmountToB,
+          maxAccounts,
+          slippageBps
+        );
+        if (!quoteableB && !swapAmountToB.isZero()) {
+          const minQuoteableToB = yield this.findMinimumJupiterQuoteableAmount(
+            inputTokenMint,
+            tokenBMint,
+            amountIn,
+            maxAccounts,
+            slippageBps
+          );
+          if (minQuoteableToB !== null) {
+            swapAmountToB = minQuoteableToB;
+            adjustedSwapAmountToA = amountIn.sub(swapAmountToB);
+          } else {
+            swapAmountToB = new import_anchor.BN(0);
+            adjustedSwapAmountToA = amountIn;
+          }
+        }
+        const { hasSwapToA, hasSwapToB } = splitIndirectSwapAmounts(
+          amountIn,
+          adjustedSwapAmountToA
+        );
+        if (!hasSwapToA && !hasSwapToB) {
+          throw new Error(
+            "Calculated zero swap amount for both token routes, unable to proceed"
+          );
+        }
+        if (!hasSwapToA) {
           const { transaction: swapToBTransaction2, quoteResponse: swapToBQuote2 } = yield buildJupiterSwapTransaction(
             user,
             inputTokenMint,
@@ -3928,12 +4043,12 @@ var Zap = class {
             }
           };
         }
-        if (swapAmountToB.isZero()) {
+        if (!hasSwapToB) {
           const { transaction: swapToATransaction2, quoteResponse: swapToAQuote2 } = yield buildJupiterSwapTransaction(
             user,
             inputTokenMint,
             tokenAMint,
-            swapAmountToA,
+            adjustedSwapAmountToA,
             maxAccounts,
             slippageBps,
             void 0,
@@ -3960,14 +4075,14 @@ var Zap = class {
               swapToAQuote2.outAmount,
               maxTransferAmountExtendPercentage
             ),
-            maxTransferAmountB: new import_anchor.BN(0),
             swapType: 0 /* swapToA */,
+            maxTransferAmountB: new import_anchor.BN(0),
             preSqrtPrice: poolState.sqrtPrice,
             preInstructions,
             swapTransactions: [swapToATransaction2],
             cleanUpInstructions,
             swapInEstimate: {
-              inAmountA: swapAmountToA,
+              inAmountA: adjustedSwapAmountToA,
               inAmountB: new import_anchor.BN(0),
               routeA: "jupiter" /* Jupiter */,
               routeB: "dammV2" /* DammV2 */
@@ -3978,7 +4093,7 @@ var Zap = class {
           user,
           inputTokenMint,
           tokenAMint,
-          swapAmountToA,
+          adjustedSwapAmountToA,
           maxAccounts,
           slippageBps,
           void 0,
@@ -4028,7 +4143,7 @@ var Zap = class {
           swapTransactions: [swapToATransaction, swapToBTransaction],
           cleanUpInstructions,
           swapInEstimate: {
-            inAmountA: swapAmountToA,
+            inAmountA: adjustedSwapAmountToA,
             inAmountB: swapAmountToB,
             routeA: "jupiter" /* Jupiter */,
             routeB: "jupiter" /* Jupiter */

package/dist/index.mjs

@@ -1793,37 +1793,18 @@ function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6) {
       quoteResponse,
       config
     );
-    const toTxInstruction = (instruction) => {
-      if (!instruction) return null;
-      return new TransactionInstruction({
-        keys: instruction.accounts.map((item) => {
-          return {
-            pubkey: new PublicKey2(item.pubkey),
-            isSigner: item.isSigner,
-            isWritable: item.isWritable
-          };
-        }),
-        programId: new PublicKey2(instruction.programId),
-        data: Buffer.from(instruction.data, "base64")
-      });
-    };
-    const transaction = new Transaction();
-    const tokenLedgerInstruction = toTxInstruction(
-      swapInstructionResponse.tokenLedgerInstruction
-    );
-    if (tokenLedgerInstruction) {
-      transaction.add(tokenLedgerInstruction);
-    }
-    for (const setupInstruction of swapInstructionResponse.setupInstructions) {
-      const txInstruction = toTxInstruction(setupInstruction);
-      if (txInstruction) transaction.add(txInstruction);
-    }
-    const swapInstruction = toTxInstruction(swapInstructionResponse.swapInstruction);
-    if (!swapInstruction) {
-      throw new Error("Missing Jupiter swap instruction");
-    }
-    transaction.add(swapInstruction);
-    return { transaction, quoteResponse };
+    const instruction = new TransactionInstruction({
+      keys: swapInstructionResponse.swapInstruction.accounts.map((item) => {
+        return {
+          pubkey: new PublicKey2(item.pubkey),
+          isSigner: item.isSigner,
+          isWritable: item.isWritable
+        };
+      }),
+      programId: new PublicKey2(swapInstructionResponse.swapInstruction.programId),
+      data: Buffer.from(swapInstructionResponse.swapInstruction.data, "base64")
+    });
+    return { transaction: new Transaction().add(instruction), quoteResponse };
   });
 }
 
@@ -3203,6 +3184,26 @@ function calculateIndirectPoolSwapAmount(amount, amountDecimals, price1, price2,
     convertUiAmountToLamports(swapAmountDecimal, amountDecimals).floor().toString()
   );
 }
+function splitIndirectSwapAmounts(amountIn, swapAmountToA) {
+  if (swapAmountToA.isNeg()) {
+    throw new Error("Calculated swap amount to token A cannot be negative");
+  }
+  if (swapAmountToA.gt(amountIn)) {
+    throw new Error(
+      "Calculated swap amount to token A exceeds total input amount"
+    );
+  }
+  const swapAmountToB = amountIn.sub(swapAmountToA);
+  if (swapAmountToB.isNeg()) {
+    throw new Error("Calculated swap amount to token B cannot be negative");
+  }
+  return {
+    swapAmountToA,
+    swapAmountToB,
+    hasSwapToA: !swapAmountToA.isZero(),
+    hasSwapToB: !swapAmountToB.isZero()
+  };
+}
 function getExtendMaxAmountTransfer(amount, percentage) {
   const extendAmount = new Decimal3(amount).mul(percentage).div(100).floor().toString();
   return new BN4(amount).add(new BN4(extendAmount));
@@ -3310,6 +3311,65 @@ var Zap = class {
       return yield this.initializeLedgerAccount(user, user);
     });
   }
+  isJupiterQuoteableAmount(inputMint, outputMint, amount, maxAccounts, slippageBps) {
+    return __async(this, null, function* () {
+      if (amount.isZero()) {
+        return true;
+      }
+      const quote = yield getJupiterQuote(
+        inputMint,
+        outputMint,
+        amount,
+        maxAccounts,
+        slippageBps,
+        false,
+        true,
+        true,
+        {
+          jupiterApiUrl: this.jupiterApiUrl,
+          jupiterApiKey: this.jupiterApiKey
+        }
+      );
+      return quote !== null;
+    });
+  }
+  findMinimumJupiterQuoteableAmount(inputMint, outputMint, maxAmount, maxAccounts, slippageBps) {
+    return __async(this, null, function* () {
+      if (maxAmount.isZero()) {
+        return null;
+      }
+      const maxAmountQuoteable = yield this.isJupiterQuoteableAmount(
+        inputMint,
+        outputMint,
+        maxAmount,
+        maxAccounts,
+        slippageBps
+      );
+      if (!maxAmountQuoteable) {
+        return null;
+      }
+      let left = new BN5(1);
+      let right = maxAmount;
+      let best = maxAmount;
+      while (left.lte(right)) {
+        const mid = left.add(right).div(new BN5(2));
+        const isQuoteable = yield this.isJupiterQuoteableAmount(
+          inputMint,
+          outputMint,
+          mid,
+          maxAccounts,
+          slippageBps
+        );
+        if (isQuoteable) {
+          best = mid;
+          right = mid.sub(new BN5(1));
+        } else {
+          left = mid.add(new BN5(1));
+        }
+      }
+      return best;
+    });
+  }
   zapInDlmmForInitializedPosition(params) {
     return __async(this, null, function* () {
       const {
@@ -3860,8 +3920,63 @@ var Zap = class {
             tokenBDecimal
           )
         );
-        const swapAmountToB = amountIn.sub(swapAmountToA);
-        if (swapAmountToA.isZero()) {
+        let { swapAmountToA: adjustedSwapAmountToA, swapAmountToB } = splitIndirectSwapAmounts(amountIn, swapAmountToA);
+        const quoteableA = yield this.isJupiterQuoteableAmount(
+          inputTokenMint,
+          tokenAMint,
+          adjustedSwapAmountToA,
+          maxAccounts,
+          slippageBps
+        );
+        if (!quoteableA && !adjustedSwapAmountToA.isZero()) {
+          const minQuoteableToA = yield this.findMinimumJupiterQuoteableAmount(
+            inputTokenMint,
+            tokenAMint,
+            amountIn,
+            maxAccounts,
+            slippageBps
+          );
+          if (minQuoteableToA !== null) {
+            adjustedSwapAmountToA = minQuoteableToA;
+            swapAmountToB = amountIn.sub(adjustedSwapAmountToA);
+          } else {
+            adjustedSwapAmountToA = new BN5(0);
+            swapAmountToB = amountIn;
+          }
+        }
+        const quoteableB = yield this.isJupiterQuoteableAmount(
+          inputTokenMint,
+          tokenBMint,
+          swapAmountToB,
+          maxAccounts,
+          slippageBps
+        );
+        if (!quoteableB && !swapAmountToB.isZero()) {
+          const minQuoteableToB = yield this.findMinimumJupiterQuoteableAmount(
+            inputTokenMint,
+            tokenBMint,
+            amountIn,
+            maxAccounts,
+            slippageBps
+          );
+          if (minQuoteableToB !== null) {
+            swapAmountToB = minQuoteableToB;
+            adjustedSwapAmountToA = amountIn.sub(swapAmountToB);
+          } else {
+            swapAmountToB = new BN5(0);
+            adjustedSwapAmountToA = amountIn;
+          }
+        }
+        const { hasSwapToA, hasSwapToB } = splitIndirectSwapAmounts(
+          amountIn,
+          adjustedSwapAmountToA
+        );
+        if (!hasSwapToA && !hasSwapToB) {
+          throw new Error(
+            "Calculated zero swap amount for both token routes, unable to proceed"
+          );
+        }
+        if (!hasSwapToA) {
           const { transaction: swapToBTransaction2, quoteResponse: swapToBQuote2 } = yield buildJupiterSwapTransaction(
             user,
             inputTokenMint,
@@ -3907,12 +4022,12 @@ var Zap = class {
             }
           };
         }
-        if (swapAmountToB.isZero()) {
+        if (!hasSwapToB) {
           const { transaction: swapToATransaction2, quoteResponse: swapToAQuote2 } = yield buildJupiterSwapTransaction(
             user,
             inputTokenMint,
             tokenAMint,
-            swapAmountToA,
+            adjustedSwapAmountToA,
             maxAccounts,
             slippageBps,
             void 0,
@@ -3939,14 +4054,14 @@ var Zap = class {
               swapToAQuote2.outAmount,
               maxTransferAmountExtendPercentage
             ),
-            maxTransferAmountB: new BN5(0),
             swapType: 0 /* swapToA */,
+            maxTransferAmountB: new BN5(0),
             preSqrtPrice: poolState.sqrtPrice,
             preInstructions,
             swapTransactions: [swapToATransaction2],
             cleanUpInstructions,
             swapInEstimate: {
-              inAmountA: swapAmountToA,
+              inAmountA: adjustedSwapAmountToA,
               inAmountB: new BN5(0),
               routeA: "jupiter" /* Jupiter */,
               routeB: "dammV2" /* DammV2 */
@@ -3957,7 +4072,7 @@ var Zap = class {
           user,
           inputTokenMint,
           tokenAMint,
-          swapAmountToA,
+          adjustedSwapAmountToA,
           maxAccounts,
           slippageBps,
           void 0,
@@ -4007,7 +4122,7 @@ var Zap = class {
           swapTransactions: [swapToATransaction, swapToBTransaction],
           cleanUpInstructions,
           swapInEstimate: {
-            inAmountA: swapAmountToA,
+            inAmountA: adjustedSwapAmountToA,
             inAmountB: swapAmountToB,
             routeA: "jupiter" /* Jupiter */,
             routeB: "jupiter" /* Jupiter */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteora-ag/zap-sdk",
-  "version": "1.2.0-rc.3",
+  "version": "1.2.0-rc.4",
   "description": "A Typescript SDK for interacting with the Zap program on Meteora.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -32,17 +32,17 @@
     "@types/bn.js": "^5.1.0",
     "@types/bun": "latest",
     "@types/invariant": "^2.2.37",
-    "tsup": "^8.4.0",
-    "tsx": "^4.20.3",
     "bip39": "^3.1.0",
-    "ed25519-hd-key": "^1.3.0"
+    "ed25519-hd-key": "^1.3.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.20.3"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.1",
-    "@meteora-ag/cp-amm-sdk": "^1.2.3",
+    "@meteora-ag/cp-amm-sdk": "^1.3.6",
     "@meteora-ag/dlmm": "^1.9.0",
     "@solana/spl-token": "^0.4.13",
     "@solana/web3.js": "^1.98.2",
@@ -52,6 +52,7 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsup src/index.ts --format esm,cjs --dts",
-    "clean": "rm -rf dist && rm -rf node_modules rm -rf pnpm-lock.yaml"
+    "clean": "rm -rf dist && rm -rf node_modules rm -rf pnpm-lock.yaml",
+    "test": "node --import tsx --test tests/**/*.test.ts"
   }
 }