@meteora-ag/zap-sdk 1.3.2 → 2.0.0-rc.1

package/dist/index.js

@@ -75,12 +75,14 @@ __export(index_exports, {
   DAMM_V2_PROGRAM_ID: () => DAMM_V2_PROGRAM_ID,
   DAMM_V2_SWAP_DISCRIMINATOR: () => DAMM_V2_SWAP_DISCRIMINATOR,
   DEFAULT_JUPITER_API_URL: () => DEFAULT_JUPITER_API_URL,
+  DEFAULT_JUPITER_API_VERSION: () => DEFAULT_JUPITER_API_VERSION,
   DLMM_PROGRAM_ID: () => DLMM_PROGRAM_ID,
   DLMM_SWAP_DISCRIMINATOR: () => DLMM_SWAP_DISCRIMINATOR,
   DlmmDirectSwapQuoteRoute: () => DlmmDirectSwapQuoteRoute,
   DlmmSingleSided: () => DlmmSingleSided,
   DlmmSwapType: () => DlmmSwapType,
   JUP_V6_PROGRAM_ID: () => JUP_V6_PROGRAM_ID,
+  JupiterApiVersion: () => JupiterApiVersion,
   MEMO_PROGRAM_ID: () => MEMO_PROGRAM_ID,
   SwapExternalType: () => SwapExternalType,
   ZAP_PROGRAM_ID: () => ZAP_PROGRAM_ID,
@@ -125,21 +127,30 @@ module.exports = __toCommonJS(index_exports);
 // src/zap.ts
 var import_web38 = require("@solana/web3.js");
 var import_invariant2 = __toESM(require("invariant"));
-var import_anchor = require("@coral-xyz/anchor");
+var import_core = require("@anchor-lang/core");
 
 // src/idl/zap/idl.json
 var idl_default = {
   address: "zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz",
   metadata: {
     name: "zap",
-    version: "0.2.0",
+    version: "0.2.3",
     spec: "0.1.0",
     description: "Created with Anchor"
   },
   instructions: [
     {
       name: "close_ledger_account",
-      discriminator: [189, 122, 172, 13, 122, 54, 54, 51],
+      discriminator: [
+        189,
+        122,
+        172,
+        13,
+        122,
+        54,
+        54,
+        51
+      ],
       accounts: [
         {
           name: "ledger",
@@ -148,7 +159,9 @@ var idl_default = {
         {
           name: "owner",
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "rent_receiver",
@@ -160,7 +173,16 @@ var idl_default = {
     },
     {
       name: "initialize_ledger_account",
-      discriminator: [120, 69, 30, 74, 76, 242, 153, 162],
+      discriminator: [
+        120,
+        69,
+        30,
+        74,
+        76,
+        242,
+        153,
+        162
+      ],
       accounts: [
         {
           name: "ledger",
@@ -169,7 +191,19 @@ var idl_default = {
             seeds: [
               {
                 kind: "const",
-                value: [117, 115, 101, 114, 95, 108, 101, 100, 103, 101, 114]
+                value: [
+                  117,
+                  115,
+                  101,
+                  114,
+                  95,
+                  108,
+                  101,
+                  100,
+                  103,
+                  101,
+                  114
+                ]
               },
               {
                 kind: "account",
@@ -196,7 +230,16 @@ var idl_default = {
     },
     {
       name: "set_ledger_balance",
-      discriminator: [131, 49, 240, 17, 228, 248, 156, 54],
+      discriminator: [
+        131,
+        49,
+        240,
+        17,
+        228,
+        248,
+        156,
+        54
+      ],
       accounts: [
         {
           name: "ledger",
@@ -205,7 +248,9 @@ var idl_default = {
         {
           name: "owner",
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         }
       ],
       args: [
@@ -221,7 +266,16 @@ var idl_default = {
     },
     {
       name: "update_ledger_balance_after_swap",
-      discriminator: [59, 206, 173, 232, 94, 57, 174, 202],
+      discriminator: [
+        59,
+        206,
+        173,
+        232,
+        94,
+        57,
+        174,
+        202
+      ],
       accounts: [
         {
           name: "ledger",
@@ -233,7 +287,9 @@ var idl_default = {
         {
           name: "owner",
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         }
       ],
       args: [
@@ -253,7 +309,16 @@ var idl_default = {
     },
     {
       name: "zap_in_damm_v2",
-      discriminator: [243, 243, 119, 52, 199, 44, 154, 186],
+      discriminator: [
+        243,
+        243,
+        119,
+        52,
+        199,
+        44,
+        154,
+        186
+      ],
       accounts: [
         {
           name: "ledger",
@@ -297,9 +362,13 @@ var idl_default = {
         },
         {
           name: "owner",
-          docs: ["owner of position"],
+          docs: [
+            "owner of position"
+          ],
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "token_a_program"
@@ -328,7 +397,16 @@ var idl_default = {
     },
     {
       name: "zap_in_dlmm_for_initialized_position",
-      discriminator: [184, 71, 198, 231, 129, 110, 193, 67],
+      discriminator: [
+        184,
+        71,
+        198,
+        231,
+        129,
+        110,
+        193,
+        67
+      ],
       accounts: [
         {
           name: "ledger",
@@ -336,7 +414,9 @@ var idl_default = {
         },
         {
           name: "lb_pair",
-          docs: ["lb pair"],
+          docs: [
+            "lb pair"
+          ],
           writable: true
         },
         {
@@ -376,9 +456,13 @@ var idl_default = {
         },
         {
           name: "owner",
-          docs: ["owner of position"],
+          docs: [
+            "owner of position"
+          ],
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "rent_payer",
@@ -442,7 +526,16 @@ var idl_default = {
     },
     {
       name: "zap_in_dlmm_for_uninitialized_position",
-      discriminator: [59, 220, 182, 27, 254, 253, 2, 232],
+      discriminator: [
+        59,
+        220,
+        182,
+        27,
+        254,
+        253,
+        2,
+        232
+      ],
       accounts: [
         {
           name: "ledger",
@@ -450,7 +543,9 @@ var idl_default = {
         },
         {
           name: "lb_pair",
-          docs: ["lb pair"],
+          docs: [
+            "lb pair"
+          ],
           writable: true
         },
         {
@@ -495,9 +590,13 @@ var idl_default = {
         },
         {
           name: "owner",
-          docs: ["owner of position"],
+          docs: [
+            "owner of position"
+          ],
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "rent_payer",
@@ -561,7 +660,16 @@ var idl_default = {
     },
     {
       name: "zap_out",
-      discriminator: [155, 108, 185, 112, 104, 210, 161, 64],
+      discriminator: [
+        155,
+        108,
+        185,
+        112,
+        104,
+        210,
+        161,
+        64
+      ],
       accounts: [
         {
           name: "user_token_in_account",
@@ -584,17 +692,18 @@ var idl_default = {
     }
   ],
   accounts: [
-    {
-      name: "LbPair",
-      discriminator: [33, 11, 49, 98, 181, 101, 177, 13]
-    },
-    {
-      name: "Pool",
-      discriminator: [241, 154, 109, 4, 17, 177, 109, 188]
-    },
     {
       name: "UserLedger",
-      discriminator: [185, 84, 101, 128, 8, 6, 160, 83]
+      discriminator: [
+        185,
+        84,
+        101,
+        128,
+        8,
+        6,
+        160,
+        83
+      ]
     }
   ],
   errors: [
@@ -661,7 +770,9 @@ var idl_default = {
           },
           {
             name: "TransferHookMultiReward",
-            fields: ["u8"]
+            fields: [
+              "u8"
+            ]
           },
           {
             name: "TransferHookReferral"
@@ -670,7 +781,7 @@ var idl_default = {
       }
     },
     {
-      name: "BaseFeeStruct",
+      name: "BaseFeeInfo",
       serialization: "bytemuck",
       repr: {
         kind: "c"
@@ -679,33 +790,34 @@ var idl_default = {
         kind: "struct",
         fields: [
           {
-            name: "cliff_fee_numerator",
-            type: "u64"
-          },
-          {
-            name: "base_fee_mode",
-            type: "u8"
-          },
-          {
-            name: "padding_0",
+            name: "data",
             type: {
-              array: ["u8", 5]
+              array: [
+                "u8",
+                32
+              ]
             }
-          },
-          {
-            name: "first_factor",
-            type: "u16"
-          },
+          }
+        ]
+      }
+    },
+    {
+      name: "BaseFeeStruct",
+      serialization: "bytemuck",
+      repr: {
+        kind: "c"
+      },
+      type: {
+        kind: "struct",
+        fields: [
           {
-            name: "second_factor",
+            name: "base_fee_info",
             type: {
-              array: ["u8", 8]
+              defined: {
+                name: "BaseFeeInfo"
+              }
             }
           },
-          {
-            name: "third_factor",
-            type: "u64"
-          },
           {
             name: "padding_1",
             type: "u64"
@@ -729,7 +841,10 @@ var idl_default = {
           {
             name: "padding",
             type: {
-              array: ["u8", 7]
+              array: [
+                "u8",
+                7
+              ]
             }
           },
           {
@@ -807,13 +922,19 @@ var idl_default = {
           {
             name: "bump_seed",
             type: {
-              array: ["u8", 1]
+              array: [
+                "u8",
+                1
+              ]
             }
           },
           {
             name: "bin_step_seed",
             type: {
-              array: ["u8", 2]
+              array: [
+                "u8",
+                2
+              ]
             }
           },
           {
@@ -839,7 +960,10 @@ var idl_default = {
           {
             name: "base_factor_seed",
             type: {
-              array: ["u8", 2]
+              array: [
+                "u8",
+                2
+              ]
             }
           },
           {
@@ -877,7 +1001,10 @@ var idl_default = {
           {
             name: "_padding_1",
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
@@ -900,7 +1027,10 @@ var idl_default = {
           {
             name: "bin_array_bitmap",
             type: {
-              array: ["u64", 16]
+              array: [
+                "u64",
+                16
+              ]
             }
           },
           {
@@ -910,7 +1040,10 @@ var idl_default = {
           {
             name: "_padding_2",
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
@@ -932,7 +1065,10 @@ var idl_default = {
           {
             name: "_padding_3",
             type: {
-              array: ["u8", 8]
+              array: [
+                "u8",
+                8
+              ]
             }
           },
           {
@@ -951,10 +1087,17 @@ var idl_default = {
             name: "token_mint_y_program_flag",
             type: "u8"
           },
+          {
+            name: "version",
+            type: "u8"
+          },
           {
             name: "_reserved",
             type: {
-              array: ["u8", 22]
+              array: [
+                "u8",
+                21
+              ]
             }
           }
         ]
@@ -971,7 +1114,9 @@ var idl_default = {
         fields: [
           {
             name: "pool_fees",
-            docs: ["Pool fee"],
+            docs: [
+              "Pool fee"
+            ],
             type: {
               defined: {
                 name: "PoolFeesStruct"
@@ -980,22 +1125,30 @@ var idl_default = {
           },
           {
             name: "token_a_mint",
-            docs: ["token a mint"],
+            docs: [
+              "token a mint"
+            ],
             type: "pubkey"
           },
           {
             name: "token_b_mint",
-            docs: ["token b mint"],
+            docs: [
+              "token b mint"
+            ],
             type: "pubkey"
           },
           {
             name: "token_a_vault",
-            docs: ["token a vault"],
+            docs: [
+              "token a vault"
+            ],
             type: "pubkey"
           },
           {
             name: "token_b_vault",
-            docs: ["token b vault"],
+            docs: [
+              "token b vault"
+            ],
             type: "pubkey"
           },
           {
@@ -1006,17 +1159,26 @@ var idl_default = {
             type: "pubkey"
           },
           {
-            name: "partner",
-            docs: ["partner"],
-            type: "pubkey"
+            name: "padding_0",
+            docs: [
+              "padding, previously partner pubkey, be careful when using this field"
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
           },
           {
             name: "liquidity",
-            docs: ["liquidity share"],
+            docs: [
+              "liquidity share"
+            ],
             type: "u128"
           },
           {
-            name: "_padding",
+            name: "padding_1",
             docs: [
               "padding, previous reserve amount, be careful to use that field"
             ],
@@ -1024,100 +1186,128 @@ var idl_default = {
           },
           {
             name: "protocol_a_fee",
-            docs: ["protocol a fee"],
+            docs: [
+              "protocol a fee"
+            ],
             type: "u64"
           },
           {
             name: "protocol_b_fee",
-            docs: ["protocol b fee"],
-            type: "u64"
-          },
-          {
-            name: "partner_a_fee",
-            docs: ["partner a fee"],
+            docs: [
+              "protocol b fee"
+            ],
             type: "u64"
           },
           {
-            name: "partner_b_fee",
-            docs: ["partner b fee"],
-            type: "u64"
+            name: "padding_2",
+            type: "u128"
           },
           {
             name: "sqrt_min_price",
-            docs: ["min price"],
+            docs: [
+              "min price"
+            ],
             type: "u128"
           },
           {
             name: "sqrt_max_price",
-            docs: ["max price"],
+            docs: [
+              "max price"
+            ],
             type: "u128"
           },
           {
             name: "sqrt_price",
-            docs: ["current price"],
+            docs: [
+              "current price"
+            ],
             type: "u128"
           },
           {
             name: "activation_point",
-            docs: ["Activation point, can be slot or timestamp"],
+            docs: [
+              "Activation point, can be slot or timestamp"
+            ],
             type: "u64"
           },
           {
             name: "activation_type",
-            docs: ["Activation type, 0 means by slot, 1 means by timestamp"],
+            docs: [
+              "Activation type, 0 means by slot, 1 means by timestamp"
+            ],
             type: "u8"
           },
           {
             name: "pool_status",
-            docs: ["pool status, 0: enable, 1 disable"],
+            docs: [
+              "pool status, 0: enable, 1 disable"
+            ],
             type: "u8"
           },
           {
             name: "token_a_flag",
-            docs: ["token a flag"],
+            docs: [
+              "token a flag"
+            ],
             type: "u8"
           },
           {
             name: "token_b_flag",
-            docs: ["token b flag"],
+            docs: [
+              "token b flag"
+            ],
             type: "u8"
           },
           {
             name: "collect_fee_mode",
             docs: [
-              "0 is collect fee in both token, 1 only collect fee in token a, 2 only collect fee in token b"
+              "0 is collect fee in both token, 1 only collect fee only in token b"
             ],
             type: "u8"
           },
           {
             name: "pool_type",
-            docs: ["pool type"],
+            docs: [
+              "pool type"
+            ],
             type: "u8"
           },
           {
-            name: "version",
+            name: "fee_version",
             docs: [
-              "pool version, 0: max_fee is still capped at 50%, 1: max_fee is capped at 99%"
+              "pool fee version, 0: max_fee is still capped at 50%, 1: max_fee is capped at 99%"
             ],
             type: "u8"
           },
           {
-            name: "_padding_0",
-            docs: ["padding"],
+            name: "padding_3",
+            docs: [
+              "padding"
+            ],
             type: "u8"
           },
           {
             name: "fee_a_per_liquidity",
-            docs: ["cumulative"],
+            docs: [
+              "cumulative"
+            ],
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
             name: "fee_b_per_liquidity",
-            docs: ["cumulative"],
+            docs: [
+              "cumulative"
+            ],
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
@@ -1126,7 +1316,9 @@ var idl_default = {
           },
           {
             name: "metrics",
-            docs: ["metrics"],
+            docs: [
+              "metrics"
+            ],
             type: {
               defined: {
                 name: "PoolMetrics"
@@ -1135,19 +1327,61 @@ var idl_default = {
           },
           {
             name: "creator",
-            docs: ["pool creator"],
+            docs: [
+              "pool creator"
+            ],
             type: "pubkey"
           },
           {
-            name: "_padding_1",
-            docs: ["Padding for further use"],
+            name: "token_a_amount",
+            docs: [
+              "token a amount"
+            ],
+            type: "u64"
+          },
+          {
+            name: "token_b_amount",
+            docs: [
+              "token b amount"
+            ],
+            type: "u64"
+          },
+          {
+            name: "layout_version",
+            docs: [
+              "layout version: version 0: haven't track token_a_amount and token_b_amount, version 1: track token_a_amount and token_b_amount"
+            ],
+            type: "u8"
+          },
+          {
+            name: "padding_4",
+            docs: [
+              "Padding for further use"
+            ],
+            type: {
+              array: [
+                "u8",
+                7
+              ]
+            }
+          },
+          {
+            name: "padding_5",
+            docs: [
+              "Padding for further use"
+            ],
             type: {
-              array: ["u64", 6]
+              array: [
+                "u64",
+                3
+              ]
             }
           },
           {
             name: "reward_infos",
-            docs: ["Farming reward information"],
+            docs: [
+              "Farming reward information"
+            ],
             type: {
               array: [
                 {
@@ -1168,8 +1402,7 @@ var idl_default = {
         "Information regarding fee charges",
         "trading_fee = amount * trade_fee_numerator / denominator",
         "protocol_fee = trading_fee * protocol_fee_percentage / 100",
-        "referral_fee = protocol_fee * referral_percentage / 100",
-        "partner_fee = (protocol_fee - referral_fee) * partner_fee_percentage / denominator"
+        "referral_fee = protocol_fee * referral_percentage / 100"
       ],
       serialization: "bytemuck",
       repr: {
@@ -1202,25 +1435,43 @@ var idl_default = {
             type: "u8"
           },
           {
-            name: "partner_fee_percent",
-            docs: ["partner fee"],
+            name: "padding_0",
+            docs: [
+              "padding for future use"
+            ],
             type: "u8"
           },
           {
             name: "referral_fee_percent",
-            docs: ["referral fee"],
+            docs: [
+              "referral fee"
+            ],
             type: "u8"
           },
           {
-            name: "padding_0",
-            docs: ["padding"],
+            name: "padding_1",
+            docs: [
+              "padding"
+            ],
             type: {
-              array: ["u8", 5]
+              array: [
+                "u8",
+                3
+              ]
             }
           },
+          {
+            name: "compounding_fee_bps",
+            docs: [
+              "compounding fee bps, only non-zero in CollectFeeMode::Compounding"
+            ],
+            type: "u16"
+          },
           {
             name: "dynamic_fee",
-            docs: ["dynamic fee"],
+            docs: [
+              "dynamic fee"
+            ],
             type: {
               defined: {
                 name: "DynamicFeeStruct"
@@ -1228,11 +1479,8 @@ var idl_default = {
             }
           },
           {
-            name: "padding_1",
-            docs: ["padding"],
-            type: {
-              array: ["u64", 2]
-            }
+            name: "init_sqrt_price",
+            type: "u128"
           }
         ]
       }
@@ -1263,12 +1511,13 @@ var idl_default = {
             type: "u64"
           },
           {
-            name: "total_partner_a_fee",
-            type: "u64"
-          },
-          {
-            name: "total_partner_b_fee",
-            type: "u64"
+            name: "padding_0",
+            type: {
+              array: [
+                "u64",
+                2
+              ]
+            }
           },
           {
             name: "total_position",
@@ -1341,7 +1590,9 @@ var idl_default = {
     },
     {
       name: "StaticParameters",
-      docs: ["Parameter that set by the protocol"],
+      docs: [
+        "Parameter that set by the protocol"
+      ],
       serialization: "bytemuck",
       repr: {
         kind: "c"
@@ -1389,10 +1640,21 @@ var idl_default = {
             name: "base_fee_power_factor",
             type: "u8"
           },
+          {
+            name: "function_type",
+            type: "u8"
+          },
+          {
+            name: "collect_fee_mode",
+            type: "u8"
+          },
           {
             name: "_padding",
             type: {
-              array: ["u8", 5]
+              array: [
+                "u8",
+                3
+              ]
             }
           }
         ]
@@ -1441,7 +1703,9 @@ var idl_default = {
     },
     {
       name: "VariableParameters",
-      docs: ["Parameters that changes based on dynamic of the market"],
+      docs: [
+        "Parameters that changes based on dynamic of the market"
+      ],
       serialization: "bytemuck",
       repr: {
         kind: "c"
@@ -1464,7 +1728,10 @@ var idl_default = {
           {
             name: "_padding",
             type: {
-              array: ["u8", 4]
+              array: [
+                "u8",
+                4
+              ]
             }
           },
           {
@@ -1474,7 +1741,10 @@ var idl_default = {
           {
             name: "_padding_1",
             type: {
-              array: ["u8", 8]
+              array: [
+                "u8",
+                8
+              ]
             }
           }
         ]
@@ -1522,70 +1792,96 @@ var idl_default = {
         fields: [
           {
             name: "initialized",
-            docs: ["Indicates if the reward has been initialized"],
+            docs: [
+              "Indicates if the reward has been initialized"
+            ],
             type: "u8"
           },
           {
             name: "reward_token_flag",
-            docs: ["reward token flag"],
+            docs: [
+              "reward token flag"
+            ],
             type: "u8"
           },
           {
             name: "_padding_0",
-            docs: ["padding"],
+            docs: [
+              "padding"
+            ],
             type: {
-              array: ["u8", 6]
+              array: [
+                "u8",
+                6
+              ]
             }
           },
           {
-            name: "_padding_1",
+            name: "dead_liquidity_reward_checkpoint",
             docs: [
-              "Padding to ensure `reward_rate: u128` is 16-byte aligned"
+              "Cumulative dead-liquidity reward (Compounding Pool only)"
             ],
-            type: {
-              array: ["u8", 8]
-            }
+            type: "u64"
           },
           {
             name: "mint",
-            docs: ["Reward token mint."],
+            docs: [
+              "Reward token mint."
+            ],
             type: "pubkey"
           },
           {
             name: "vault",
-            docs: ["Reward vault token account."],
+            docs: [
+              "Reward vault token account."
+            ],
             type: "pubkey"
           },
           {
             name: "funder",
-            docs: ["Authority account that allows to fund rewards"],
+            docs: [
+              "Authority account that allows to fund rewards"
+            ],
             type: "pubkey"
           },
           {
             name: "reward_duration",
-            docs: ["reward duration"],
+            docs: [
+              "reward duration"
+            ],
             type: "u64"
           },
           {
             name: "reward_duration_end",
-            docs: ["reward duration end"],
+            docs: [
+              "reward duration end"
+            ],
             type: "u64"
           },
           {
             name: "reward_rate",
-            docs: ["reward rate"],
+            docs: [
+              "reward rate"
+            ],
             type: "u128"
           },
           {
             name: "reward_per_token_stored",
-            docs: ["Reward per token stored"],
+            docs: [
+              "Reward per token stored"
+            ],
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
             name: "last_update_time",
-            docs: ["The last time reward states were updated."],
+            docs: [
+              "The last time reward states were updated."
+            ],
             type: "u64"
           },
           {
@@ -1648,44 +1944,6 @@ var idl_default = {
     }
   ],
   constants: [
-    {
-      name: "DAMM_V2",
-      type: "pubkey",
-      value: "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
-    },
-    {
-      name: "DAMM_V2_SWAP_DISC",
-      type: {
-        array: ["u8", 8]
-      },
-      value: "[248, 198, 158, 145, 225, 117, 135, 200]"
-    },
-    {
-      name: "DLMM_SWAP2_DISC",
-      type: {
-        array: ["u8", 8]
-      },
-      value: "[65, 75, 63, 76, 235, 91, 91, 136]"
-    },
-    {
-      name: "JUP_V6",
-      type: "pubkey",
-      value: "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
-    },
-    {
-      name: "JUP_V6_ROUTE_DISC",
-      type: {
-        array: ["u8", 8]
-      },
-      value: "[229, 23, 203, 151, 122, 227, 173, 42]"
-    },
-    {
-      name: "JUP_V6_SHARED_ACCOUNT_ROUTE_DISC",
-      type: {
-        array: ["u8", 8]
-      },
-      value: "[193, 32, 155, 51, 65, 214, 156, 129]"
-    },
     {
       name: "MAX_BASIS_POINT",
       type: "u16",
@@ -1700,6 +1958,11 @@ var idl_default = {
 };
 
 // src/types.ts
+var JupiterApiVersion = /* @__PURE__ */ ((JupiterApiVersion3) => {
+  JupiterApiVersion3["V1"] = "v1";
+  JupiterApiVersion3["V2"] = "v2";
+  return JupiterApiVersion3;
+})(JupiterApiVersion || {});
 var ZapInDammV2PoolSwapRoute = /* @__PURE__ */ ((ZapInDammV2PoolSwapRoute2) => {
   ZapInDammV2PoolSwapRoute2["Jupiter"] = "jupiter";
   ZapInDammV2PoolSwapRoute2["DammV2"] = "dammV2";
@@ -1729,7 +1992,7 @@ var DlmmSingleSided = /* @__PURE__ */ ((DlmmSingleSided2) => {
 })(DlmmSingleSided || {});
 
 // src/helpers/jupiter.ts
-var import_web32 = require("@solana/web3.js");
+var import_web33 = require("@solana/web3.js");
 
 // src/constants.ts
 var import_web3 = require("@solana/web3.js");
@@ -1770,6 +2033,68 @@ var AccountsType = {
 var DLMM_SWAP_DISCRIMINATOR = [65, 75, 63, 76, 235, 91, 91, 136];
 var AMOUNT_IN_DLMM_OFFSET = 8;
 var AMOUNT_IN_JUP_V6_REVERSE_OFFSET = 19;
+var JUP_V6_ROUTE_DISCRIMINATOR = [
+  229,
+  23,
+  203,
+  151,
+  122,
+  227,
+  173,
+  42
+];
+var JUP_V6_SHARED_ACCOUNTS_ROUTE_DISCRIMINATOR = [
+  193,
+  32,
+  155,
+  51,
+  65,
+  214,
+  156,
+  129
+];
+var JUP_V6_ROUTE_V2_DISCRIMINATOR = [
+  187,
+  100,
+  250,
+  204,
+  49,
+  196,
+  175,
+  20
+];
+var JUP_V6_SHARED_ACCOUNTS_ROUTE_V2_DISCRIMINATOR = [
+  209,
+  152,
+  83,
+  147,
+  124,
+  254,
+  216,
+  233
+];
+var JUPITER_INSTRUCTION_LAYOUTS = {
+  // route
+  [Buffer.from(JUP_V6_ROUTE_DISCRIMINATOR).toString("hex")]: {
+    amountInOffset: (dataLength) => dataLength - AMOUNT_IN_JUP_V6_REVERSE_OFFSET,
+    userTransferAuthorityIndex: 1
+  },
+  // shared_accounts_route
+  [Buffer.from(JUP_V6_SHARED_ACCOUNTS_ROUTE_DISCRIMINATOR).toString("hex")]: {
+    amountInOffset: (dataLength) => dataLength - AMOUNT_IN_JUP_V6_REVERSE_OFFSET,
+    userTransferAuthorityIndex: 2
+  },
+  // route_v2
+  [Buffer.from(JUP_V6_ROUTE_V2_DISCRIMINATOR).toString("hex")]: {
+    amountInOffset: () => 8,
+    userTransferAuthorityIndex: 0
+  },
+  // shared_accounts_route_v2
+  [Buffer.from(JUP_V6_SHARED_ACCOUNTS_ROUTE_V2_DISCRIMINATOR).toString("hex")]: {
+    amountInOffset: () => 9,
+    userTransferAuthorityIndex: 1
+  }
+};
 var AMOUNT_IN_DAMM_V2_OFFSET = 8;
 var DAMM_V2_SWAP_DISCRIMINATOR = [
   248,
@@ -1782,42 +2107,214 @@ var DAMM_V2_SWAP_DISCRIMINATOR = [
   200
 ];
 var DEFAULT_JUPITER_API_URL = "https://api.jup.ag";
+var DEFAULT_JUPITER_API_VERSION = "v2" /* V2 */;
+
+// src/helpers/token.ts
+var import_spl_token = require("@solana/spl-token");
+var import_web32 = require("@solana/web3.js");
+var getOrCreateATAInstruction = (_connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
+  const toAccount = (0, import_spl_token.getAssociatedTokenAddressSync)(
+    tokenMint,
+    owner,
+    allowOwnerOffCurve,
+    tokenProgram
+  );
+  const ix = (0, import_spl_token.createAssociatedTokenAccountIdempotentInstruction)(
+    payer,
+    toAccount,
+    owner,
+    tokenMint,
+    tokenProgram
+  );
+  return { ataPubkey: toAccount, ix };
+});
+function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
+  const wSolATAAccount = (0, import_spl_token.getAssociatedTokenAddressSync)(
+    import_spl_token.NATIVE_MINT,
+    owner,
+    allowOwnerOffCurve
+  );
+  if (wSolATAAccount) {
+    const closedWrappedSolInstruction = (0, import_spl_token.createCloseAccountInstruction)(
+      wSolATAAccount,
+      receiver,
+      owner,
+      [],
+      import_spl_token.TOKEN_PROGRAM_ID
+    );
+    return closedWrappedSolInstruction;
+  }
+  return null;
+}
+function getTokenAccountBalance(connection, tokenAccount) {
+  return __async(this, null, function* () {
+    let balance;
+    try {
+      balance = (yield connection.getTokenAccountBalance(tokenAccount)).value.amount;
+    } catch (e) {
+      balance = "0";
+    }
+    return balance;
+  });
+}
+function wrapSOLInstruction(from, to, amount, tokenProgram = import_spl_token.TOKEN_PROGRAM_ID) {
+  return [
+    import_web32.SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports: amount
+    }),
+    new import_web32.TransactionInstruction({
+      keys: [
+        {
+          pubkey: to,
+          isSigner: false,
+          isWritable: true
+        }
+      ],
+      data: Buffer.from(new Uint8Array([17])),
+      programId: tokenProgram
+    })
+  ];
+}
+var CLOSE_ACCOUNT_DISCRIMINATOR = 9;
+function filterOutCloseSplTokenAccountInstructions(instructions) {
+  return instructions.filter((ix) => {
+    if (ix.programId.equals(import_spl_token.TOKEN_PROGRAM_ID)) {
+      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
+    }
+    return true;
+  });
+}
+function getCreateAtaInstructions(user, tokens) {
+  const tokenAccounts = tokens.map(
+    ({ mint, tokenProgram }) => (0, import_spl_token.getAssociatedTokenAddressSync)(mint, user, true, tokenProgram)
+  );
+  const instructions = tokens.map(
+    ({ mint, tokenProgram }, i) => (0, import_spl_token.createAssociatedTokenAccountIdempotentInstruction)(
+      user,
+      tokenAccounts[i],
+      user,
+      mint,
+      tokenProgram
+    )
+  );
+  return { tokenAccounts, instructions };
+}
+function isCreateAtaInstruction(ix) {
+  return ix.programId.equals(import_spl_token.ASSOCIATED_TOKEN_PROGRAM_ID) && (ix.data.length === 0 || ix.data[0] === 0 || ix.data[0] === 1);
+}
+function dedupeCreateAtaInstructions(instructions) {
+  const createdAccounts = /* @__PURE__ */ new Set();
+  return instructions.filter((ix) => {
+    if (!isCreateAtaInstruction(ix)) {
+      return true;
+    }
+    const account = ix.keys[1].pubkey.toBase58();
+    if (createdAccounts.has(account)) {
+      return false;
+    }
+    createdAccounts.add(account);
+    return true;
+  });
+}
 
 // src/helpers/jupiter.ts
-function getJupiterQuote(_0, _1, _2, _3, _4) {
-  return __async(this, arguments, function* (inputMint, outputMint, amount, maxAccounts, slippageBps, dynamicSlippage = false, onlyDirectRoutes, restrictIntermediateTokens, forJitoBundle = true, config = {}) {
-    const params = new URLSearchParams({
-      inputMint: inputMint.toString(),
-      outputMint: outputMint.toString(),
-      amount: amount.toString(),
-      slippageBps: slippageBps.toString(),
-      maxAccounts: maxAccounts.toString(),
-      onlyDirectRoutes: onlyDirectRoutes.toString(),
-      restrictIntermediateTokens: restrictIntermediateTokens.toString(),
-      dynamicSlippage: dynamicSlippage.toString(),
-      forJitoBundle: forJitoBundle.toString()
-    });
-    const url = `${config.jupiterApiUrl || DEFAULT_JUPITER_API_URL}/swap/v1/quote?${params.toString()}`;
+function resolveJupiterConfig(config) {
+  var _a;
+  return {
+    url: (config == null ? void 0 : config.jupiterApiUrl) || DEFAULT_JUPITER_API_URL,
+    apiKey: (config == null ? void 0 : config.jupiterApiKey) || "",
+    version: (_a = config == null ? void 0 : config.jupiterApiVersion) != null ? _a : DEFAULT_JUPITER_API_VERSION
+  };
+}
+function getJupiterInstructionLayout(data) {
+  const discriminator = data.subarray(0, 8).toString("hex");
+  const layout = JUPITER_INSTRUCTION_LAYOUTS[discriminator];
+  if (!layout) {
+    throw new Error(
+      `Unsupported Jupiter instruction discriminator ${discriminator}`
+    );
+  }
+  return layout;
+}
+function isJupiterBuildResponse(quoteResponse) {
+  return quoteResponse.swapInstruction !== void 0;
+}
+function isJupiterSwapInstructionForUser(swapInstruction, user) {
+  const layout = getJupiterInstructionLayout(
+    Buffer.from(swapInstruction.data, "base64")
+  );
+  const authority = swapInstruction.accounts[layout.userTransferAuthorityIndex];
+  return authority !== void 0 && new import_web33.PublicKey(authority.pubkey).equals(user);
+}
+function jupiterHeaders(apiKey, json) {
+  return __spreadValues(__spreadValues({
+    Accept: "application/json"
+  }, json ? { "Content-Type": "application/json" } : {}), apiKey ? { "x-api-key": apiKey } : {});
+}
+function toSearchParams(params) {
+  var _a;
+  const searchParams = new URLSearchParams();
+  for (const [name, value] of Object.entries((_a = params.queryParams) != null ? _a : {})) {
+    searchParams.set(name, value.toString());
+  }
+  searchParams.set("inputMint", params.inputMint.toString());
+  searchParams.set("outputMint", params.outputMint.toString());
+  searchParams.set("amount", params.amount.toString());
+  return searchParams;
+}
+function fetchJupiterQuoteV1(params, config) {
+  return __async(this, null, function* () {
+    const { url: baseUrl, apiKey } = resolveJupiterConfig(config);
+    const url = `${baseUrl}/swap/v1/quote?${toSearchParams(params).toString()}`;
     try {
       const response = yield fetch(url, {
         method: "GET",
-        headers: __spreadValues({
-          Accept: "application/json"
-        }, config.jupiterApiKey ? { "x-api-key": config.jupiterApiKey } : {})
+        headers: jupiterHeaders(apiKey, false)
       });
       if (!response.ok) {
         return null;
       }
-      const result = yield response.json();
-      return result;
+      return yield response.json();
     } catch (error) {
       return null;
     }
   });
 }
-function getJupiterSwapInstruction(_0, _1) {
-  return __async(this, arguments, function* (userPublicKey, quoteResponse, config = {}) {
-    const url = `${config.jupiterApiUrl || DEFAULT_JUPITER_API_URL}/swap/v1/swap-instructions`;
+function fetchJupiterBuildV2(params, config) {
+  return __async(this, null, function* () {
+    const { url: baseUrl, apiKey } = resolveJupiterConfig(config);
+    const searchParams = toSearchParams(params);
+    searchParams.set("taker", params.user.toString());
+    const url = `${baseUrl}/swap/v2/build?${searchParams.toString()}`;
+    try {
+      const response = yield fetch(url, {
+        method: "GET",
+        headers: jupiterHeaders(apiKey, false)
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return yield response.json();
+    } catch (error) {
+      return null;
+    }
+  });
+}
+function getJupiterQuote(params, config) {
+  return __async(this, null, function* () {
+    const { version } = resolveJupiterConfig(config);
+    if (version === "v1" /* V1 */) {
+      return fetchJupiterQuoteV1(params, config);
+    }
+    return fetchJupiterBuildV2(params, config);
+  });
+}
+function fetchJupiterSwapInstructionV1(userPublicKey, quoteResponse, config) {
+  return __async(this, null, function* () {
+    const { url: baseUrl, apiKey } = resolveJupiterConfig(config);
+    const url = `${baseUrl}/swap/v1/swap-instructions`;
     const requestBody = {
       userPublicKey: userPublicKey.toString(),
       quoteResponse
@@ -1826,10 +2323,7 @@ function getJupiterSwapInstruction(_0, _1) {
     try {
       response = yield fetch(url, {
         method: "POST",
-        headers: __spreadValues({
-          "Content-Type": "application/json",
-          Accept: "application/json"
-        }, config.jupiterApiKey ? { "x-api-key": config.jupiterApiKey } : {}),
+        headers: jupiterHeaders(apiKey, true),
         body: JSON.stringify(requestBody)
       });
       if (!response.ok) {
@@ -1841,22 +2335,124 @@ function getJupiterSwapInstruction(_0, _1) {
     } catch (error) {
       throw new Error(`Jupiter swap instruction failed to fetch`);
     }
-    const result = yield response.json();
-    return result;
+    return yield response.json();
   });
 }
-function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6) {
-  return __async(this, arguments, function* (user, inputMint, outputMint, amount, maxAccounts, slippageBps, jupiterQuoteResponse, config = {}) {
+function getJupiterSwapInstruction(userPublicKey, quoteResponse, config) {
+  return __async(this, null, function* () {
+    const { version } = resolveJupiterConfig(config);
+    if (version === "v1" /* V1 */) {
+      return fetchJupiterSwapInstructionV1(userPublicKey, quoteResponse, config);
+    }
+    if (!isJupiterBuildResponse(quoteResponse)) {
+      throw new Error(
+        "Jupiter quote has no swap instructions, get the quote with getJupiterQuote under Jupiter API v2"
+      );
+    }
+    if (!isJupiterSwapInstructionForUser(
+      quoteResponse.swapInstruction,
+      userPublicKey
+    )) {
+      throw new Error(
+        `Jupiter quote swap instructions are not built for ${userPublicKey.toBase58()}`
+      );
+    }
+    return quoteResponse;
+  });
+}
+function isQuoteMatchesSwap(quoteResponse, user, amount) {
+  if (quoteResponse.inAmount !== amount.toString()) {
+    return false;
+  }
+  if (isJupiterBuildResponse(quoteResponse)) {
+    return isJupiterSwapInstructionForUser(quoteResponse.swapInstruction, user);
+  }
+  return true;
+}
+var ACTIVE_LOOKUP_TABLE_DEACTIVATION_SLOT = BigInt("0xffffffffffffffff");
+function toAddressLookupTableAccounts(addressesByLookupTableAddress) {
+  return Object.entries(addressesByLookupTableAddress != null ? addressesByLookupTableAddress : {}).map(
+    ([key, addresses]) => new import_web33.AddressLookupTableAccount({
+      key: new import_web33.PublicKey(key),
+      state: {
+        addresses: addresses.map((address) => new import_web33.PublicKey(address)),
+        deactivationSlot: ACTIVE_LOOKUP_TABLE_DEACTIVATION_SLOT,
+        lastExtendedSlot: 0,
+        lastExtendedSlotStartIndex: 0
+      }
+    })
+  );
+}
+function fetchAddressLookupTableAccounts(connection, addresses) {
+  return __async(this, null, function* () {
+    if (addresses.length === 0) {
+      return [];
+    }
+    const keys = addresses.map((address) => new import_web33.PublicKey(address));
+    const accounts = yield connection.getMultipleAccountsInfo(keys);
+    return keys.map((key, i) => {
+      const account = accounts[i];
+      if (!account || !account.owner.equals(import_web33.AddressLookupTableProgram.programId)) {
+        throw new Error(`Address lookup table not found: ${key.toBase58()}`);
+      }
+      return new import_web33.AddressLookupTableAccount({
+        key,
+        state: import_web33.AddressLookupTableAccount.deserialize(account.data)
+      });
+    });
+  });
+}
+function mergeAddressLookupTableAccounts(...lists) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const table of lists.flat()) {
+    const key = table.key.toBase58();
+    if (!merged.has(key)) {
+      merged.set(key, table);
+    }
+  }
+  return [...merged.values()];
+}
+function getJupiterAddressLookupTableAccounts(connection, response) {
+  return __async(this, null, function* () {
+    var _a;
+    if (response.addressesByLookupTableAddress) {
+      return toAddressLookupTableAccounts(response.addressesByLookupTableAddress);
+    }
+    return fetchAddressLookupTableAccounts(
+      connection,
+      (_a = response.addressLookupTableAddresses) != null ? _a : []
+    );
+  });
+}
+function toTransactionInstruction(instruction) {
+  return new import_web33.TransactionInstruction({
+    keys: instruction.accounts.map((item) => ({
+      pubkey: new import_web33.PublicKey(item.pubkey),
+      isSigner: item.isSigner,
+      isWritable: item.isWritable
+    })),
+    programId: new import_web33.PublicKey(instruction.programId),
+    data: Buffer.from(instruction.data, "base64")
+  });
+}
+function getJupiterCreateAtaInstructions(setupInstructions) {
+  return setupInstructions.filter(isCreateAtaInstruction);
+}
+function buildJupiterSwapTransaction(connection, user, inputMint, outputMint, amount, slippageBps, jupiterQuoteResponse, config, jupiterQuoteOptions) {
+  return __async(this, null, function* () {
+    if (jupiterQuoteResponse && !isQuoteMatchesSwap(jupiterQuoteResponse, user, amount)) {
+      throw new Error(
+        `Jupiter quote does not match the swap of ${amount.toString()} by ${user.toBase58()} (quoted inAmount ${jupiterQuoteResponse.inAmount})`
+      );
+    }
     const quoteResponse = jupiterQuoteResponse != null ? jupiterQuoteResponse : yield getJupiterQuote(
-      inputMint,
-      outputMint,
-      amount,
-      maxAccounts,
-      slippageBps,
-      false,
-      true,
-      true,
-      true,
+      {
+        inputMint,
+        outputMint,
+        amount,
+        user,
+        queryParams: __spreadValues({ slippageBps }, jupiterQuoteOptions)
+      },
       config
     );
     if (!quoteResponse) {
@@ -1869,47 +2465,51 @@ function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6) {
       quoteResponse,
       config
     );
-    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 };
+    const instruction = toTransactionInstruction(
+      swapInstructionResponse.swapInstruction
+    );
+    const setupInstructions = swapInstructionResponse.setupInstructions.map(
+      toTransactionInstruction
+    );
+    const addressLookupTableAccounts = yield getJupiterAddressLookupTableAccounts(
+      connection,
+      swapInstructionResponse
+    );
+    return {
+      instruction,
+      setupInstructions,
+      addressLookupTableAccounts,
+      quoteResponse
+    };
   });
 }
 
 // src/helpers/dammV2.ts
-var import_spl_token = require("@solana/spl-token");
+var import_spl_token2 = require("@solana/spl-token");
 var import_cp_amm_sdk = require("@meteora-ag/cp-amm-sdk");
 
 // src/helpers/pda.ts
-var import_web33 = require("@solana/web3.js");
+var import_web34 = require("@solana/web3.js");
 function deriveDammV2EventAuthority() {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveDammV2PoolAuthority() {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("pool_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveLedgerAccount(owner) {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("user_ledger"), owner.toBuffer()],
     ZAP_PROGRAM_ID
   )[0];
 }
 function deriveDlmmEventAuthority() {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DLMM_PROGRAM_ID
   )[0];
@@ -1923,7 +2523,7 @@ function getDammV2Pool(connection, poolAddress) {
   });
 }
 function getDammV2RemainingAccounts(_0, _1, _2, _3) {
-  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = import_spl_token.TOKEN_PROGRAM_ID, tokenBProgram = import_spl_token.TOKEN_PROGRAM_ID, poolState) {
+  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = import_spl_token2.TOKEN_PROGRAM_ID, tokenBProgram = import_spl_token2.TOKEN_PROGRAM_ID, poolState) {
     const remainingAccounts = [
       {
         isSigner: false,
@@ -2014,118 +2614,45 @@ function createDammV2SwapPayload(amountIn, minimumSwapAmountOut) {
 }
 
 // src/helpers/common.ts
-var import_spl_token2 = require("@solana/spl-token");
-var import_web34 = require("@solana/web3.js");
-var import_decimal = __toESM(require("decimal.js"));
-function getTokenProgramFromMint(connection, mint) {
-  return __async(this, null, function* () {
-    if (mint.equals(import_spl_token2.NATIVE_MINT)) {
-      return import_spl_token2.TOKEN_PROGRAM_ID;
-    }
-    try {
-      const mintInfo = yield connection.getAccountInfo(mint);
-      if (!mintInfo) {
-        throw new Error(`Mint account not found: ${mint.toString()}`);
-      }
-      if (mintInfo.owner.equals(
-        new import_web34.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
-      )) {
-        return new import_web34.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
-      } else {
-        return import_spl_token2.TOKEN_PROGRAM_ID;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
-        error
-      );
-      return import_spl_token2.TOKEN_PROGRAM_ID;
-    }
-  });
-}
-function convertLamportsToUiAmount(amount, decimals) {
-  return amount.div(import_decimal.default.pow(10, decimals));
-}
-function convertUiAmountToLamports(amount, decimals) {
-  return amount.mul(import_decimal.default.pow(10, decimals));
-}
-
-// src/helpers/token.ts
 var import_spl_token3 = require("@solana/spl-token");
 var import_web35 = require("@solana/web3.js");
-var getOrCreateATAInstruction = (connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
-  const toAccount = (0, import_spl_token3.getAssociatedTokenAddressSync)(
-    tokenMint,
-    owner,
-    allowOwnerOffCurve,
-    tokenProgram
-  );
-  const ix = (0, import_spl_token3.createAssociatedTokenAccountIdempotentInstruction)(
-    payer,
-    toAccount,
-    owner,
-    tokenMint,
-    tokenProgram
-  );
-  return { ataPubkey: toAccount, ix };
-});
-function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
-  const wSolATAAccount = (0, import_spl_token3.getAssociatedTokenAddressSync)(
-    import_spl_token3.NATIVE_MINT,
-    owner,
-    allowOwnerOffCurve
-  );
-  if (wSolATAAccount) {
-    const closedWrappedSolInstruction = (0, import_spl_token3.createCloseAccountInstruction)(
-      wSolATAAccount,
-      receiver,
-      owner,
-      [],
-      import_spl_token3.TOKEN_PROGRAM_ID
-    );
-    return closedWrappedSolInstruction;
-  }
-  return null;
-}
-function getTokenAccountBalance(connection, tokenAccount) {
+var import_decimal = __toESM(require("decimal.js"));
+function getTokenProgramFromMint(connection, mint) {
   return __async(this, null, function* () {
-    let balance;
+    if (mint.equals(import_spl_token3.NATIVE_MINT)) {
+      return import_spl_token3.TOKEN_PROGRAM_ID;
+    }
     try {
-      balance = (yield connection.getTokenAccountBalance(tokenAccount)).value.amount;
-    } catch (e) {
-      balance = "0";
+      const mintInfo = yield connection.getAccountInfo(mint);
+      if (!mintInfo) {
+        throw new Error(`Mint account not found: ${mint.toString()}`);
+      }
+      if (mintInfo.owner.equals(
+        new import_web35.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
+      )) {
+        return new import_web35.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+      } else {
+        return import_spl_token3.TOKEN_PROGRAM_ID;
+      }
+    } catch (error) {
+      console.warn(
+        `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
+        error
+      );
+      return import_spl_token3.TOKEN_PROGRAM_ID;
     }
-    return balance;
   });
 }
-function wrapSOLInstruction(from, to, amount, tokenProgram = import_spl_token3.TOKEN_PROGRAM_ID) {
-  return [
-    import_web35.SystemProgram.transfer({
-      fromPubkey: from,
-      toPubkey: to,
-      lamports: amount
-    }),
-    new import_web35.TransactionInstruction({
-      keys: [
-        {
-          pubkey: to,
-          isSigner: false,
-          isWritable: true
-        }
-      ],
-      data: Buffer.from(new Uint8Array([17])),
-      programId: tokenProgram
-    })
-  ];
+function convertLamportsToUiAmount(amount, decimals) {
+  return amount.div(import_decimal.default.pow(10, decimals));
 }
-var CLOSE_ACCOUNT_DISCRIMINATOR = 9;
-function filterOutCloseSplTokenAccountInstructions(instructions) {
-  return instructions.filter((ix) => {
-    if (ix.programId.equals(import_spl_token3.TOKEN_PROGRAM_ID)) {
-      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
-    }
-    return true;
-  });
+function convertUiAmountToLamports(amount, decimals) {
+  return amount.mul(import_decimal.default.pow(10, decimals));
+}
+function filterOutComputeBudgetInstructions(instructions) {
+  return instructions.filter(
+    (ix) => !ix.programId.equals(import_web35.ComputeBudgetProgram.programId)
+  );
 }
 
 // src/helpers/dlmm.ts
@@ -2489,8 +3016,8 @@ function estimateSwapOutput(inAmount, effectiveRate) {
   const estimatedOutput = inAmountDecimal.mul(effectiveRate);
   return new import_bn3.default(estimatedOutput.floor().toString());
 }
-function getBestSwapQuoteJupiterDlmm(_0, _1, _2, _3, _4, _5, _6) {
-  return __async(this, arguments, function* (dlmm, inMint, outMint, inAmount, swapSlippageBps, swapForY, binArrays, config = {}) {
+function getBestSwapQuoteJupiterDlmm(dlmm, user, inMint, outMint, inAmount, swapSlippageBps, swapForY, binArrays, config, jupiterQuoteOptions) {
+  return __async(this, null, function* () {
     let dlmmQuoteResult = null;
     try {
       dlmmQuoteResult = dlmm.swapQuote(
@@ -2503,15 +3030,15 @@ function getBestSwapQuoteJupiterDlmm(_0, _1, _2, _3, _4, _5, _6) {
       console.error("Error getting DLMM quote, using jupiter quote only:", error);
     }
     const jupiterQuoteResult = yield getJupiterQuote(
-      inMint,
-      outMint,
-      inAmount,
-      50,
-      swapSlippageBps,
-      false,
-      true,
-      true,
-      true,
+      {
+        inputMint: inMint,
+        outputMint: outMint,
+        amount: inAmount,
+        user,
+        queryParams: __spreadValues({
+          slippageBps: swapSlippageBps
+        }, jupiterQuoteOptions)
+      },
       config
     );
     const jupiterQuote = jupiterQuoteResult ? {
@@ -2627,6 +3154,7 @@ function binarySearchRefineDirectSwapAmount(dlmm, initialActiveBin, initialMinBi
 }
 function estimateDlmmIndirectSwap(_0) {
   return __async(this, arguments, function* ({
+    user,
     amountIn,
     inputTokenMint,
     lbPair,
@@ -2636,7 +3164,8 @@ function estimateDlmmIndirectSwap(_0) {
     maxDeltaId,
     strategy,
     singleSided,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     const dlmm = yield import_dlmm3.default.create(connection, lbPair);
     const activeBin = yield dlmm.getActiveBin();
@@ -2660,15 +3189,15 @@ function estimateDlmmIndirectSwap(_0) {
       const singleSidedX = singleSided === 0 /* X */;
       const outputTokenMint = singleSidedX ? tokenXMint : tokenYMint;
       const quote = yield getJupiterQuote(
-        inputTokenMint,
-        outputTokenMint,
-        amountIn,
-        50,
-        swapSlippageBps,
-        false,
-        true,
-        true,
-        true,
+        {
+          inputMint: inputTokenMint,
+          outputMint: outputTokenMint,
+          amount: amountIn,
+          user,
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       );
       if (!quote) {
@@ -2691,27 +3220,27 @@ function estimateDlmmIndirectSwap(_0) {
     const halfAmount = amountIn.div(new import_bn3.default(2));
     const [quoteToXResult, quoteToYResult] = yield Promise.allSettled([
       getJupiterQuote(
-        inputTokenMint,
-        tokenXMint,
-        halfAmount,
-        50,
-        swapSlippageBps,
-        false,
-        true,
-        true,
-        true,
+        {
+          inputMint: inputTokenMint,
+          outputMint: tokenXMint,
+          amount: halfAmount,
+          user,
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       ),
       getJupiterQuote(
-        inputTokenMint,
-        tokenYMint,
-        halfAmount,
-        50,
-        swapSlippageBps,
-        false,
-        true,
-        true,
-        true,
+        {
+          inputMint: inputTokenMint,
+          outputMint: tokenYMint,
+          amount: halfAmount,
+          user,
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       )
     ]);
@@ -2807,27 +3336,27 @@ function estimateDlmmIndirectSwap(_0) {
     }
     const [finalQuoteToXResult, finalQuoteToYResult] = yield Promise.allSettled([
       getJupiterQuote(
-        inputTokenMint,
-        tokenXMint,
-        bestAmountToX,
-        50,
-        swapSlippageBps,
-        false,
-        true,
-        true,
-        true,
+        {
+          inputMint: inputTokenMint,
+          outputMint: tokenXMint,
+          amount: bestAmountToX,
+          user,
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       ),
       getJupiterQuote(
-        inputTokenMint,
-        tokenYMint,
-        bestAmountToY,
-        50,
-        swapSlippageBps,
-        false,
-        true,
-        true,
-        true,
+        {
+          inputMint: inputTokenMint,
+          outputMint: tokenYMint,
+          amount: bestAmountToY,
+          user,
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       )
     ]);
@@ -2863,6 +3392,7 @@ function estimateDlmmIndirectSwap(_0) {
 }
 function estimateDlmmDirectSwapCore(_0) {
   return __async(this, arguments, function* ({
+    user,
     tokenXAmount,
     tokenYAmount,
     dlmm,
@@ -2871,7 +3401,8 @@ function estimateDlmmDirectSwapCore(_0) {
     maxDeltaId,
     strategy,
     singleSided,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     if (singleSided !== void 0) {
       const singleSidedX = singleSided === 0 /* X */;
@@ -2883,13 +3414,15 @@ function estimateDlmmDirectSwapCore(_0) {
         );
         const quote = yield getBestSwapQuoteJupiterDlmm(
           dlmm,
+          user,
           dlmm.lbPair.tokenYMint,
           dlmm.lbPair.tokenXMint,
           tokenYAmount,
           swapSlippageBps,
           swapForY2,
           binArrayForSwap2,
-          config
+          config,
+          jupiterQuoteOptions
         );
         if (!quote) {
           throw new Error(
@@ -2912,13 +3445,15 @@ function estimateDlmmDirectSwapCore(_0) {
         );
         const quote = yield getBestSwapQuoteJupiterDlmm(
           dlmm,
+          user,
           dlmm.lbPair.tokenXMint,
           dlmm.lbPair.tokenYMint,
           tokenXAmount,
           swapSlippageBps,
           swapForY2,
           binArrayForSwap2,
-          config
+          config,
+          jupiterQuoteOptions
         );
         if (!quote) {
           throw new Error(
@@ -3007,13 +3542,15 @@ function estimateDlmmDirectSwapCore(_0) {
     );
     const initialQuote = yield getBestSwapQuoteJupiterDlmm(
       dlmm,
+      user,
       inMint,
       outMint,
       initialSwapAmount,
       swapSlippageBps,
       swapForY,
       binArrayForSwap,
-      config
+      config,
+      jupiterQuoteOptions
     );
     if (!initialQuote) {
       throw new Error(
@@ -3065,13 +3602,15 @@ function estimateDlmmDirectSwapCore(_0) {
     );
     const finalQuote = yield getBestSwapQuoteJupiterDlmm(
       dlmm,
+      user,
       inMint,
       outMint,
       refinedAmount,
       swapSlippageBps,
       swapForY,
       binArrayForSwap,
-      config
+      config,
+      jupiterQuoteOptions
     );
     if (!finalQuote) {
       return {
@@ -3097,6 +3636,7 @@ function estimateDlmmDirectSwapCore(_0) {
 }
 function estimateDlmmDirectSwap(_0) {
   return __async(this, arguments, function* ({
+    user,
     amountIn,
     inputTokenMint,
     lbPair,
@@ -3106,7 +3646,8 @@ function estimateDlmmDirectSwap(_0) {
     maxDeltaId,
     strategy,
     singleSided,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     const dlmm = yield import_dlmm3.default.create(connection, lbPair);
     (0, import_invariant.default)(
@@ -3117,6 +3658,7 @@ function estimateDlmmDirectSwap(_0) {
     const tokenXAmount = isInputTokenX ? amountIn : new import_bn3.default(0);
     const tokenYAmount = isInputTokenX ? new import_bn3.default(0) : amountIn;
     const result = yield estimateDlmmDirectSwapCore({
+      user,
       tokenXAmount,
       tokenYAmount,
       dlmm,
@@ -3125,6 +3667,7 @@ function estimateDlmmDirectSwap(_0) {
       maxDeltaId,
       strategy,
       singleSided,
+      jupiterQuoteOptions,
       config
     });
     return {
@@ -3144,6 +3687,7 @@ function estimateDlmmDirectSwap(_0) {
 }
 function estimateDlmmRebalanceSwap(_0) {
   return __async(this, arguments, function* ({
+    user,
     lbPair,
     position,
     connection,
@@ -3151,11 +3695,13 @@ function estimateDlmmRebalanceSwap(_0) {
     minDeltaId,
     maxDeltaId,
     strategy,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     const dlmm = yield import_dlmm3.default.create(connection, lbPair);
     const userPosition = yield dlmm.getPosition(position);
     const result = yield estimateDlmmDirectSwapCore({
+      user,
       tokenXAmount: new import_bn3.default(userPosition.positionData.totalXAmount),
       tokenYAmount: new import_bn3.default(userPosition.positionData.totalYAmount),
       dlmm,
@@ -3165,6 +3711,7 @@ function estimateDlmmRebalanceSwap(_0) {
       strategy,
       singleSided: void 0,
       // rebalance does not use single-sided deposits
+      jupiterQuoteOptions,
       config
     });
     return {
@@ -3232,13 +3779,15 @@ function getExtendMaxAmountTransfer(amount, percentage) {
 var Zap = class {
   /**
    * @param connection - The connection to the Solana cluster
-   * @param config - Optional configuration for Jupiter API URL (default: https://api.jup.ag) and API key (default: empty string)
+   * @param config - Optional configuration for Jupiter API URL (default: https://api.jup.ag), API key (default: empty string) and API version (default: JupiterApiVersion.V2)
    */
-  constructor(connection, config = {}) {
+  constructor(connection, config) {
+    var _a;
     this.connection = connection;
-    this.zapProgram = new import_anchor.Program(idl_default, { connection });
-    this.jupiterApiUrl = config.jupiterApiUrl || DEFAULT_JUPITER_API_URL;
-    this.jupiterApiKey = config.jupiterApiKey || "";
+    this.zapProgram = new import_core.Program(idl_default, { connection });
+    this.jupiterApiUrl = (config == null ? void 0 : config.jupiterApiUrl) || DEFAULT_JUPITER_API_URL;
+    this.jupiterApiKey = (config == null ? void 0 : config.jupiterApiKey) || "";
+    this.jupiterApiVersion = (_a = config == null ? void 0 : config.jupiterApiVersion) != null ? _a : DEFAULT_JUPITER_API_VERSION;
   }
   /////// PRIVATE FUNDTIONS //////
   initializeLedgerAccount(owner, payer) {
@@ -3247,7 +3796,7 @@ var Zap = class {
         ledger: deriveLedgerAccount(owner),
         owner,
         payer
-      }).transaction();
+      }).instruction();
     });
   }
   closeLedgerAccount(owner, rentReceiver) {
@@ -3256,7 +3805,7 @@ var Zap = class {
         ledger: deriveLedgerAccount(owner),
         owner,
         rentReceiver
-      }).transaction();
+      }).instruction();
     });
   }
   setLedgerBalance(owner, amount, isTokenA) {
@@ -3264,7 +3813,7 @@ var Zap = class {
       return yield this.zapProgram.methods.setLedgerBalance(amount, isTokenA).accountsPartial({
         ledger: deriveLedgerAccount(owner),
         owner
-      }).transaction();
+      }).instruction();
     });
   }
   updateLedgerBalanceAfterSwap(owner, tokenAccount, preSourceTokenAccount, maxTransferAmount, isTokenA) {
@@ -3277,7 +3826,7 @@ var Zap = class {
         ledger: deriveLedgerAccount(owner),
         tokenAccount,
         owner
-      }).transaction();
+      }).instruction();
     });
   }
   zapInDammV2(params) {
@@ -3315,7 +3864,7 @@ var Zap = class {
         tokenBProgram,
         dammProgram: DAMM_V2_PROGRAM_ID,
         dammEventAuthority: deriveDammV2EventAuthority()
-      }).transaction();
+      }).instruction();
     });
   }
   resetOrInitializeLedgerAccount(user) {
@@ -3325,9 +3874,9 @@ var Zap = class {
       if (accountInfo) {
         const closeLedger = yield this.closeLedgerAccount(user, user);
         const reInitializeLedger = yield this.initializeLedgerAccount(user, user);
-        return new import_web38.Transaction().add(closeLedger).add(reInitializeLedger);
+        return [closeLedger, reInitializeLedger];
       }
-      return yield this.initializeLedgerAccount(user, user);
+      return [yield this.initializeLedgerAccount(user, user)];
     });
   }
   zapInDlmmForInitializedPosition(params) {
@@ -3394,7 +3943,7 @@ var Zap = class {
         memoProgram: MEMO_PROGRAM_ID,
         dlmmEventAuthority: deriveDlmmEventAuthority(),
         systemProgram: import_web38.SystemProgram.programId
-      }).remainingAccounts(binArrays).transaction();
+      }).remainingAccounts(binArrays).instruction();
     });
   }
   zapInDlmmForUninitializedPosition(params) {
@@ -3458,7 +4007,7 @@ var Zap = class {
         memoProgram: MEMO_PROGRAM_ID,
         dlmmEventAuthority: deriveDlmmEventAuthority(),
         systemProgram: import_web38.SystemProgram.programId
-      }).remainingAccounts(binArrays).transaction();
+      }).remainingAccounts(binArrays).instruction();
     });
   }
   //#region Zap In
@@ -3472,12 +4021,12 @@ var Zap = class {
    * @param params.amountIn - The amount of input token
    * @param params.inputTokenMint - The input token mint
    * @param params.positionNftMint - The position NFT mint account's public key
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
    * @param params.maxSqrtPriceChangeBps - The maximum sqrt price change in basis points
    * @param params.slippageBps - The swap slippage tolerance in basis points
    * @param params.dammV2Quote - The DAMM V2 swap quote for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.jupiterQuote - The Jupiter swap quote for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
+   * @param params.jupiterQuoteOptions - Optional Jupiter query parameters, see `GetJupiterQuoteParams.queryParams`
    * @returns The zap-in transaction parameters for a DAMM V2 direct pool
    * @throws if input token mint matches either tokenA or tokenB in the pool
    * @throws if failed to get both Jupiter and DAMM v2 swap quotes
@@ -3491,12 +4040,12 @@ var Zap = class {
         inputTokenMint,
         amountIn,
         positionNftMint,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         slippageBps,
         dammV2Quote,
         jupiterQuote,
-        maxTransferAmountExtendPercentage
+        maxTransferAmountExtendPercentage,
+        jupiterQuoteOptions
       } = params;
       const poolState = yield getDammV2Pool(this.connection, pool);
       const {
@@ -3516,7 +4065,7 @@ var Zap = class {
       const tokenAProgram = (0, import_cp_amm_sdk3.getTokenProgram)(tokenAFlag);
       const tokenBProgram = (0, import_cp_amm_sdk3.getTokenProgram)(tokenBFlag);
       const preInstructions = [];
-      if (tokenAMint.equals(import_spl_token6.NATIVE_MINT) || tokenBMint.equals(import_spl_token6.NATIVE_MINT)) {
+      if (inputTokenMint.equals(import_spl_token6.NATIVE_MINT)) {
         const { ataPubkey: userWrapSolAcc, ix: initializeUserWrapSOLAta } = yield getOrCreateATAInstruction(
           this.connection,
           import_spl_token6.NATIVE_MINT,
@@ -3568,49 +4117,56 @@ var Zap = class {
       const singleSidedA = isSingleSidedA(poolState);
       const singleSidedB = isSingleSidedB(poolState);
       let amount;
-      let swapTransactions = [];
+      let swapInstructions = [];
+      let addressLookupTableAccounts = [];
       let maxTransferAmount;
       let swapInAmount;
       let swapRoute;
       if (singleSidedA && isInputTokenA || singleSidedB && !isInputTokenA) {
         amount = amountIn;
-        swapInAmount = new import_anchor.BN(0);
-        maxTransferAmount = new import_anchor.BN(0);
+        swapInAmount = new import_core.BN(0);
+        maxTransferAmount = new import_core.BN(0);
         swapRoute = "dammV2" /* DammV2 */;
       } else if (singleSidedA && !isInputTokenA || singleSidedB && isInputTokenA) {
-        if (jupiterQuote !== null && (dammV2Quote === null || new import_anchor.BN(jupiterQuote.outAmount).gte(dammV2Quote.swapOutAmount))) {
+        if (jupiterQuote !== null && (dammV2Quote === null || new import_core.BN(jupiterQuote.outAmount).gte(dammV2Quote.swapOutAmount))) {
           swapInAmount = amountIn;
-          amount = new import_anchor.BN(0);
+          amount = new import_core.BN(0);
           const result = yield buildJupiterSwapTransaction(
+            this.connection,
             user,
             inputTokenMint,
             outputTokenMint,
             swapInAmount,
-            maxAccounts,
             slippageBps,
             void 0,
             {
               jupiterApiUrl: this.jupiterApiUrl,
-              jupiterApiKey: this.jupiterApiKey
-            }
+              jupiterApiKey: this.jupiterApiKey,
+              jupiterApiVersion: this.jupiterApiVersion
+            },
+            jupiterQuoteOptions
+          );
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(result.setupInstructions)
           );
-          swapTransactions = [result.transaction];
+          swapInstructions = [result.instruction];
+          addressLookupTableAccounts = result.addressLookupTableAccounts;
           maxTransferAmount = getExtendMaxAmountTransfer(
             result.quoteResponse.outAmount,
             maxTransferAmountExtendPercentage
           );
           swapRoute = "jupiter" /* Jupiter */;
         } else if (dammV2Quote !== null) {
-          swapInAmount = new import_anchor.BN(0);
+          swapInAmount = new import_core.BN(0);
           amount = amountIn;
-          maxTransferAmount = new import_anchor.BN(0);
+          maxTransferAmount = new import_core.BN(0);
           swapRoute = "dammV2" /* DammV2 */;
         } else {
           throw new Error(
             "No Jupiter or DAMM v2 quote found for single-sided swap, unable to proceed"
           );
         }
-      } else if (jupiterQuote !== null && (dammV2Quote === null || new import_anchor.BN(jupiterQuote.outAmount).gte(dammV2Quote.swapOutAmount))) {
+      } else if (jupiterQuote !== null && (dammV2Quote === null || new import_core.BN(jupiterQuote.outAmount).gte(dammV2Quote.swapOutAmount))) {
         const price = convertLamportsToUiAmount(
           new import_decimal4.default(jupiterQuote.outAmount),
           isInputTokenA ? tokenBDecimal : tokenADecimal
@@ -3631,19 +4187,25 @@ var Zap = class {
         );
         amount = amountIn.sub(swapInAmount);
         const result = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           outputTokenMint,
           swapInAmount,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
         );
-        swapTransactions = [result.transaction];
+        swapInstructions = [result.instruction];
+        addressLookupTableAccounts = result.addressLookupTableAccounts;
         maxTransferAmount = getExtendMaxAmountTransfer(
           result.quoteResponse.outAmount,
           maxTransferAmountExtendPercentage
@@ -3701,7 +4263,8 @@ var Zap = class {
         preSqrtPrice: poolState.sqrtPrice,
         maxSqrtPriceChangeBps,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         swapInEstimate: {
           inAmount: swapInAmount,
@@ -3720,12 +4283,12 @@ var Zap = class {
    * @param params.amountIn - The amount of input token
    * @param params.inputTokenMint - The input token mint
    * @param params.positionNftMint - The position NFT mint account's public key
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
    * @param params.maxSqrtPriceChangeBps - The maximum sqrt price change in basis points
    * @param params.slippageBps - The swap slippage tolerance in basis points
    * @param params.jupiterQuoteToA - The Jupiter quote for swapping to tokenA for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.jupiterQuoteToB - The Jupiter quote for swapping to tokenB for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
+   * @param params.jupiterQuoteOptions - Optional Jupiter query parameters, see `GetJupiterQuoteParams.queryParams`
    * @returns The zap-in transaction parameters for a DAMM V2 indirect pool
    * @throws if input token mint matches either tokenA or tokenB in the pool
    * @throws if no Jupiter quote provided for both tokens
@@ -3739,12 +4302,12 @@ var Zap = class {
         pool,
         positionNftMint,
         amountIn,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         maxTransferAmountExtendPercentage,
         slippageBps,
         jupiterQuoteToA,
-        jupiterQuoteToB
+        jupiterQuoteToB,
+        jupiterQuoteOptions
       } = params;
       const poolState = yield getDammV2Pool(this.connection, pool);
       const {
@@ -3829,17 +4392,22 @@ var Zap = class {
           );
         }
         const result = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenAMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
         );
         return {
           user,
@@ -3847,7 +4415,7 @@ var Zap = class {
           position,
           positionNftAccount,
           maxSqrtPriceChangeBps,
-          amount: new import_anchor.BN(0),
+          amount: new import_core.BN(0),
           isDirectPool: false,
           tokenAMint,
           tokenBMint,
@@ -3860,14 +4428,15 @@ var Zap = class {
             maxTransferAmountExtendPercentage
           ),
           swapType: 0 /* swapToA */,
-          maxTransferAmountB: new import_anchor.BN(0),
+          maxTransferAmountB: new import_core.BN(0),
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
             inAmountA: amountIn,
-            inAmountB: new import_anchor.BN(0),
+            inAmountB: new import_core.BN(0),
             routeA: "jupiter" /* Jupiter */,
             routeB: "dammV2" /* DammV2 */
           }
@@ -3880,17 +4449,22 @@ var Zap = class {
           );
         }
         const result = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenBMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
         );
         return {
           user,
@@ -3898,7 +4472,7 @@ var Zap = class {
           position,
           positionNftAccount,
           maxSqrtPriceChangeBps,
-          amount: new import_anchor.BN(0),
+          amount: new import_core.BN(0),
           isDirectPool: false,
           tokenAMint,
           tokenBMint,
@@ -3906,7 +4480,7 @@ var Zap = class {
           tokenBVault,
           tokenAProgram,
           tokenBProgram,
-          maxTransferAmountA: new import_anchor.BN(0),
+          maxTransferAmountA: new import_core.BN(0),
           maxTransferAmountB: getExtendMaxAmountTransfer(
             result.quoteResponse.outAmount,
             maxTransferAmountExtendPercentage
@@ -3914,10 +4488,11 @@ var Zap = class {
           swapType: 1 /* swapToB */,
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
-            inAmountA: new import_anchor.BN(0),
+            inAmountA: new import_core.BN(0),
             inAmountB: amountIn,
             routeA: "dammV2" /* DammV2 */,
             routeB: "jupiter" /* Jupiter */
@@ -3926,17 +4501,22 @@ var Zap = class {
       }
       if (jupiterQuoteToA && jupiterQuoteToB === null) {
         const result = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenAMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
         );
         return {
           user,
@@ -3944,7 +4524,7 @@ var Zap = class {
           position,
           positionNftAccount,
           maxSqrtPriceChangeBps,
-          amount: new import_anchor.BN(0),
+          amount: new import_core.BN(0),
           isDirectPool: false,
           tokenAMint,
           tokenBMint,
@@ -3957,14 +4537,15 @@ var Zap = class {
             maxTransferAmountExtendPercentage
           ),
           swapType: 0 /* swapToA */,
-          maxTransferAmountB: new import_anchor.BN(0),
+          maxTransferAmountB: new import_core.BN(0),
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
             inAmountA: amountIn,
-            inAmountB: new import_anchor.BN(0),
+            inAmountB: new import_core.BN(0),
             routeA: "jupiter" /* Jupiter */,
             routeB: "dammV2" /* DammV2 */
           }
@@ -3972,17 +4553,22 @@ var Zap = class {
       }
       if (jupiterQuoteToB && jupiterQuoteToA === null) {
         const result = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenBMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
         );
         return {
           user,
@@ -3990,7 +4576,7 @@ var Zap = class {
           position,
           positionNftAccount,
           maxSqrtPriceChangeBps,
-          amount: new import_anchor.BN(0),
+          amount: new import_core.BN(0),
           isDirectPool: false,
           tokenAMint,
           tokenBMint,
@@ -3998,7 +4584,7 @@ var Zap = class {
           tokenBVault,
           tokenAProgram,
           tokenBProgram,
-          maxTransferAmountA: new import_anchor.BN(0),
+          maxTransferAmountA: new import_core.BN(0),
           maxTransferAmountB: getExtendMaxAmountTransfer(
             result.quoteResponse.outAmount,
             maxTransferAmountExtendPercentage
@@ -4006,10 +4592,11 @@ var Zap = class {
           swapType: 1 /* swapToB */,
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
-            inAmountA: new import_anchor.BN(0),
+            inAmountA: new import_core.BN(0),
             inAmountB: amountIn,
             routeA: "dammV2" /* DammV2 */,
             routeB: "jupiter" /* Jupiter */
@@ -4046,7 +4633,7 @@ var Zap = class {
           position,
           positionNftAccount,
           maxSqrtPriceChangeBps,
-          amount: new import_anchor.BN(0),
+          amount: new import_core.BN(0),
           isDirectPool: false,
           tokenAMint,
           tokenBMint,
@@ -4058,43 +4645,57 @@ var Zap = class {
           preSqrtPrice: poolState.sqrtPrice,
           cleanUpInstructions
         };
-        const { transaction: swapToATransaction, quoteResponse: swapToAQuote } = yield buildJupiterSwapTransaction(
+        const swapToA = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenAMint,
           swapAmountToA,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToA.setupInstructions)
         );
-        const { transaction: swapToBTransaction, quoteResponse: swapToBQuote } = yield buildJupiterSwapTransaction(
+        const swapToB = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenBMint,
           swapAmountToB,
-          maxAccounts,
           slippageBps,
           void 0,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
-          }
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
+          },
+          jupiterQuoteOptions
+        );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToB.setupInstructions)
         );
         return __spreadProps(__spreadValues({}, baseParams), {
           maxTransferAmountA: getExtendMaxAmountTransfer(
-            swapToAQuote.outAmount,
+            swapToA.quoteResponse.outAmount,
             maxTransferAmountExtendPercentage
           ),
           maxTransferAmountB: getExtendMaxAmountTransfer(
-            swapToBQuote.outAmount,
+            swapToB.quoteResponse.outAmount,
             maxTransferAmountExtendPercentage
           ),
           swapType: 2 /* swapToBoth */,
-          swapTransactions: [swapToATransaction, swapToBTransaction],
+          swapInstructions: [swapToA.instruction, swapToB.instruction],
+          addressLookupTableAccounts: mergeAddressLookupTableAccounts(
+            swapToA.addressLookupTableAccounts,
+            swapToB.addressLookupTableAccounts
+          ),
           swapInEstimate: {
             inAmountA: swapAmountToA,
             inAmountB: swapAmountToB,
@@ -4109,7 +4710,12 @@ var Zap = class {
     });
   }
   /**
-   * Build DAMM v2 zap-in transaction
+   * Build the DAMM v2 zap-in instructions
+   *
+   * Instructions are ordered: setup (token accounts, wrap SOL), swaps, ledger, zap in, clean up.
+   * They must run in that order but can be split across several transactions, because state
+   * between steps lives in accounts. Splitting loses atomicity, so send split transactions as a bundle.
+   * No compute budget instructions are included; the client sets the compute budget for each transaction.
    *
    * @param params.user - The user's public key
    * @param params.pool - The pool's public key
@@ -4125,10 +4731,11 @@ var Zap = class {
    * @param params.amount - The amount to deposit
    * @param params.preSqrtPrice - The sqrt price before the operation
    * @param params.maxSqrtPriceChangeBps - The maximum sqrt price change in basis points
-   * @param params.preInstructions - Instructions to run before the zap in
-   * @param params.swapTransactions - Swap transactions to execute
+   * @param params.preInstructions - Instructions to run before the zap in, including the token accounts the Jupiter swaps need. Token account creation repeated here is removed
+   * @param params.swapInstructions - Swap instructions to execute
+   * @param params.addressLookupTableAccounts - Lookup tables used by the swap instructions
    * @param params.cleanUpInstructions - Instructions to run after the zap in
-   * @returns Response containing transaction components
+   * @returns The ordered instructions and the lookup tables they use
    */
   buildZapInDammV2Transaction(params) {
     return __async(this, null, function* () {
@@ -4148,61 +4755,41 @@ var Zap = class {
         preSqrtPrice,
         maxSqrtPriceChangeBps,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions
       } = params;
-      const [
-        { ataPubkey: tokenAAccount, ix: initializeTokenAIx },
-        { ataPubkey: tokenBAccount, ix: initializeTokenBIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenAMint,
-          user,
-          user,
-          false,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenBMint,
-          user,
-          user,
-          false,
-          tokenBProgram
-        )
+      const {
+        tokenAccounts: [tokenAAccount, tokenBAccount],
+        instructions: setupInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: tokenAMint, tokenProgram: tokenAProgram },
+        { mint: tokenBMint, tokenProgram: tokenBProgram }
       ]);
-      const setupTransaction = new import_web38.Transaction();
-      initializeTokenAIx && setupTransaction.add(initializeTokenAIx);
-      initializeTokenBIx && setupTransaction.add(initializeTokenBIx);
-      if (preInstructions.length > 0) {
-        setupTransaction.add(...preInstructions);
-      }
-      const ledgerTransaction = new import_web38.Transaction();
-      const resetOrInitializeLedgerTx = yield this.resetOrInitializeLedgerAccount(user);
-      ledgerTransaction.add(resetOrInitializeLedgerTx);
+      setupInstructions.push(...preInstructions);
+      const ledgerInstructions = yield this.resetOrInitializeLedgerAccount(user);
       if (isDirectPool) {
         const isTokenA = params.isTokenA;
-        const setLedgerBalanceTx = yield this.setLedgerBalance(
+        const setLedgerBalanceIx = yield this.setLedgerBalance(
           user,
           amount,
           isTokenA
         );
-        ledgerTransaction.add(setLedgerBalanceTx);
-        if (swapTransactions.length > 0) {
+        ledgerInstructions.push(setLedgerBalanceIx);
+        if (swapInstructions.length > 0) {
           const tokenAccount = isTokenA ? tokenBAccount : tokenAAccount;
           const preTokenBalance = yield getTokenAccountBalance(
             this.connection,
             tokenAccount
           );
-          const updateLedgerBalanceAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             tokenAccount,
-            new import_anchor.BN(preTokenBalance),
+            new import_core.BN(preTokenBalance),
             params.maxTransferAmount,
             !isTokenA
           );
-          ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
         }
       } else {
         const preTokenABalance = yield getTokenAccountBalance(
@@ -4213,32 +4800,35 @@ var Zap = class {
           this.connection,
           tokenBAccount
         );
-        const updateLedgerBalanceTokenAAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+        const updateLedgerBalanceTokenAAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
           user,
           tokenAAccount,
-          new import_anchor.BN(preTokenABalance),
+          new import_core.BN(preTokenABalance),
           params.maxTransferAmountA,
           true
           // is token A
         );
-        const updateLedgerBalanceTokenBAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+        const updateLedgerBalanceTokenBAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
           user,
           tokenBAccount,
-          new import_anchor.BN(preTokenBBalance),
+          new import_core.BN(preTokenBBalance),
           params.maxTransferAmountB,
           false
           // isn't token A
         );
         const swapType = params.swapType;
         if (swapType == 0 /* swapToA */) {
-          ledgerTransaction.add(updateLedgerBalanceTokenAAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceTokenAAfterSwapIx);
         } else if (swapType == 1 /* swapToB */) {
-          ledgerTransaction.add(updateLedgerBalanceTokenBAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceTokenBAfterSwapIx);
         } else {
-          ledgerTransaction.add(updateLedgerBalanceTokenAAfterSwapTx).add(updateLedgerBalanceTokenBAfterSwapTx);
+          ledgerInstructions.push(
+            updateLedgerBalanceTokenAAfterSwapIx,
+            updateLedgerBalanceTokenBAfterSwapIx
+          );
         }
       }
-      const zapInTransaction = yield this.zapInDammV2({
+      const zapInInstruction = yield this.zapInDammV2({
         user,
         pool,
         position,
@@ -4254,18 +4844,17 @@ var Zap = class {
         tokenAAccount,
         tokenBAccount
       });
-      const cleanUpTransaction = new import_web38.Transaction();
-      const closeLedgerTransaction = yield this.closeLedgerAccount(user, user);
-      cleanUpTransaction.add(closeLedgerTransaction);
-      if (cleanUpInstructions.length > 0) {
-        cleanUpTransaction.add(...cleanUpInstructions);
-      }
+      const closeLedgerInstruction = yield this.closeLedgerAccount(user, user);
       return {
-        setupTransaction: setupTransaction.instructions.length > 0 ? setupTransaction : void 0,
-        swapTransactions,
-        ledgerTransaction,
-        zapInTransaction,
-        cleanUpTransaction
+        instructions: [
+          ...dedupeCreateAtaInstructions(setupInstructions),
+          ...swapInstructions,
+          ...ledgerInstructions,
+          zapInInstruction,
+          closeLedgerInstruction,
+          ...cleanUpInstructions
+        ],
+        addressLookupTableAccounts
       };
     });
   }
@@ -4282,8 +4871,7 @@ var Zap = class {
    * @param params.maxDeltaId - The bin delta relative to the active bin for the upper bin position
    * @param params.strategy - The liquidity distribution strategy
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
-   * @param params.swapSlippageBps - The swap slippage tolerance in basis points
+   * @param params.swapSlippageBps - Swap slippage vs the **quoted route**, not vs a fair input/output price. Validate `directSwapEstimate` / `outAmount` before send.
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
    * @param params.maxActiveBinSlippage - The maximum active bin slippage
    * @param params.directSwapEstimate - The result from the direct swap estimate
@@ -4303,7 +4891,6 @@ var Zap = class {
         maxDeltaId,
         strategy,
         favorXInActiveId,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -4336,25 +4923,31 @@ var Zap = class {
         initializeWrapSolIx && preInstructions.push(initializeWrapSolIx);
         preInstructions.push(...wrapSOL);
       }
-      const swapTransactions = [];
+      const swapInstructions = [];
+      let addressLookupTableAccounts = [];
       let maxTransferAmount;
       if (directSwapEstimate.swapType !== 2 /* NoSwap */ && directSwapEstimate.quote) {
         const swapQuote = directSwapEstimate.quote;
         if (swapQuote.route === 0 /* Jupiter */) {
-          const { transaction: swapTx } = yield buildJupiterSwapTransaction(
+          const swap = yield buildJupiterSwapTransaction(
+            this.connection,
             user,
             directSwapEstimate.swapType === 0 /* XToY */ ? tokenXMint : tokenYMint,
             directSwapEstimate.swapType === 0 /* XToY */ ? tokenYMint : tokenXMint,
             directSwapEstimate.swapAmount,
-            maxAccounts,
             swapSlippageBps,
             swapQuote.originalQuote,
             {
               jupiterApiUrl: this.jupiterApiUrl,
-              jupiterApiKey: this.jupiterApiKey
+              jupiterApiKey: this.jupiterApiKey,
+              jupiterApiVersion: this.jupiterApiVersion
             }
           );
-          swapTransactions.push(swapTx);
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(swap.setupInstructions)
+          );
+          swapInstructions.push(swap.instruction);
+          addressLookupTableAccounts = swap.addressLookupTableAccounts;
         } else {
           const swapForY = directSwapEstimate.swapType === 0 /* XToY */;
           const binArrays2 = yield dlmm.getBinArrayForSwap(swapForY);
@@ -4367,6 +4960,9 @@ var Zap = class {
             user,
             binArraysPubkey: binArrays2.map((item) => item.publicKey)
           });
+          swapTx.instructions = filterOutComputeBudgetInstructions(
+            swapTx.instructions
+          );
           if (tokenXMint.equals(import_spl_token6.NATIVE_MINT) || tokenYMint.equals(import_spl_token6.NATIVE_MINT)) {
             swapTx.instructions = swapTx.instructions.filter((ix) => {
               if (ix.programId.equals(import_spl_token6.TOKEN_PROGRAM_ID)) {
@@ -4375,14 +4971,14 @@ var Zap = class {
               return true;
             });
           }
-          swapTransactions.push(swapTx);
+          swapInstructions.push(...swapTx.instructions);
         }
         maxTransferAmount = getExtendMaxAmountTransfer(
           directSwapEstimate.expectedOutput.toString(),
           maxTransferAmountExtendPercentage
         );
       } else {
-        maxTransferAmount = new import_anchor.BN(0);
+        maxTransferAmount = new import_core.BN(0);
       }
       const amount = isTokenX ? directSwapEstimate.postSwapX : directSwapEstimate.postSwapY;
       const cleanUpInstructions = [];
@@ -4392,8 +4988,8 @@ var Zap = class {
       }
       const binArrays = (0, import_dlmm4.getBinArraysRequiredByPositionRange)(
         lbPair,
-        new import_anchor.BN(activeId + minDeltaId),
-        new import_anchor.BN(activeId + maxDeltaId),
+        new import_core.BN(activeId + minDeltaId),
+        new import_core.BN(activeId + maxDeltaId),
         DLMM_PROGRAM_ID
       ).map((item) => ({
         pubkey: item.key,
@@ -4425,7 +5021,8 @@ var Zap = class {
         amount,
         maxTransferAmount,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         binArrays,
         binArrayBitmapExtension: binArrayBitmapExtensionData ? binArrayBitmapExtension : null,
@@ -4447,7 +5044,6 @@ var Zap = class {
    * @param params.strategy - The liquidity distribution strategy
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
    * @param params.indirectSwapEstimate - The result from the indirect swap estimate
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
    * @param params.swapSlippageBps - The swap slippage tolerance in basis points
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
    * @param params.maxActiveBinSlippage - The maximum active bin slippage
@@ -4468,7 +5064,6 @@ var Zap = class {
         strategy,
         favorXInActiveId,
         indirectSwapEstimate,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -4506,41 +5101,55 @@ var Zap = class {
       }
       let maxTransferAmountX;
       let maxTransferAmountY;
-      const swapTransactions = [];
+      const swapInstructions = [];
+      const swapLookupTables = [];
       const swapAmountToXInLamports = indirectSwapEstimate.swapAmountToX;
       const swapAmountToYInLamports = indirectSwapEstimate.swapAmountToY;
       if (!indirectSwapEstimate.swapAmountToX.isZero() && indirectSwapEstimate.swapToX !== null) {
-        const { transaction: swapToXTransaction } = yield buildJupiterSwapTransaction(
+        const swapToX = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenXMint,
           swapAmountToXInLamports,
-          maxAccounts,
           swapSlippageBps,
           indirectSwapEstimate.swapToX,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
           }
         );
-        swapTransactions.push(swapToXTransaction);
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToX.setupInstructions)
+        );
+        swapInstructions.push(swapToX.instruction);
+        swapLookupTables.push(swapToX.addressLookupTableAccounts);
       }
       if (!indirectSwapEstimate.swapAmountToY.isZero() && indirectSwapEstimate.swapToY !== null) {
-        const { transaction: swapToYTransaction } = yield buildJupiterSwapTransaction(
+        const swapToY = yield buildJupiterSwapTransaction(
+          this.connection,
           user,
           inputTokenMint,
           tokenYMint,
           swapAmountToYInLamports,
-          maxAccounts,
           swapSlippageBps,
           indirectSwapEstimate.swapToY,
           {
             jupiterApiUrl: this.jupiterApiUrl,
-            jupiterApiKey: this.jupiterApiKey
+            jupiterApiKey: this.jupiterApiKey,
+            jupiterApiVersion: this.jupiterApiVersion
           }
         );
-        swapTransactions.push(swapToYTransaction);
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToY.setupInstructions)
+        );
+        swapInstructions.push(swapToY.instruction);
+        swapLookupTables.push(swapToY.addressLookupTableAccounts);
       }
+      const addressLookupTableAccounts = mergeAddressLookupTableAccounts(
+        ...swapLookupTables
+      );
       maxTransferAmountX = getExtendMaxAmountTransfer(
         indirectSwapEstimate.postSwapX.toString(),
         maxTransferAmountExtendPercentage
@@ -4551,8 +5160,8 @@ var Zap = class {
       );
       const binArrays = (0, import_dlmm4.getBinArraysRequiredByPositionRange)(
         lbPair,
-        new import_anchor.BN(activeId + minDeltaId),
-        new import_anchor.BN(activeId + maxDeltaId),
+        new import_core.BN(activeId + minDeltaId),
+        new import_core.BN(activeId + maxDeltaId),
         DLMM_PROGRAM_ID
       ).map((item) => ({
         pubkey: item.key,
@@ -4582,7 +5191,8 @@ var Zap = class {
         maxTransferAmountX,
         maxTransferAmountY,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         binArrays,
         binArrayBitmapExtension: binArrayBitmapExtensionData ? binArrayBitmapExtension : null,
@@ -4592,7 +5202,12 @@ var Zap = class {
     });
   }
   /**
-   * Builds a DLMM zap-in transaction
+   * Build the DLMM zap-in instructions
+   *
+   * Instructions are ordered: setup (token accounts, wrap SOL), swaps, ledger, zap in, clean up.
+   * They must run in that order but can be split across several transactions, because state
+   * between steps lives in accounts. Splitting loses atomicity, so send split transactions as a bundle.
+   * No compute budget instructions are included; the client sets the compute budget for each transaction.
    *
    * @param params.user - The user's public key
    * @param params.lbPair - The DLMM pool's public key
@@ -4607,14 +5222,15 @@ var Zap = class {
    * @param params.maxActiveBinSlippage - The maximum active bin slippage
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
    * @param params.strategy - The liquidity distribution strategy
-   * @param params.preInstructions - Instructions to run before the zap in
-   * @param params.swapTransactions - Swap transactions to execute
+   * @param params.preInstructions - Instructions to run before the zap in, including the token accounts the Jupiter swaps need. Token account creation repeated here is removed
+   * @param params.swapInstructions - Swap instructions to execute
+   * @param params.addressLookupTableAccounts - Lookup tables used by the swap instructions
    * @param params.cleanUpInstructions - Instructions to run after the zap in
    * @param params.binArrays - The bin arrays required for the position
    * @param params.binArrayBitmapExtension - The bin array bitmap extension account if it exists
    * @param params.isDirectRoute - Whether this is a direct route
    * @param params.singleSided - Optional single-sided deposit mode (X or Y only) - default is non-single-sided
-   * @returns Response containing transaction components
+   * @returns The ordered instructions and the lookup tables they use
    */
   buildZapInDlmmTransaction(params) {
     return __async(this, null, function* () {
@@ -4633,90 +5249,70 @@ var Zap = class {
         favorXInActiveId,
         strategy,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         binArrays,
         binArrayBitmapExtension,
         isDirectRoute,
         singleSided
       } = params;
-      const [
-        { ataPubkey: tokenXAccount, ix: initializeTokenXIx },
-        { ataPubkey: tokenYAccount, ix: initializeTokenYIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenXMint,
-          user,
-          user,
-          false,
-          tokenXProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenYMint,
-          user,
-          user,
-          false,
-          tokenYProgram
-        )
+      const {
+        tokenAccounts: [tokenXAccount, tokenYAccount],
+        instructions: setupInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: tokenXMint, tokenProgram: tokenXProgram },
+        { mint: tokenYMint, tokenProgram: tokenYProgram }
       ]);
-      const setupTransaction = new import_web38.Transaction();
-      initializeTokenXIx && setupTransaction.add(initializeTokenXIx);
-      initializeTokenYIx && setupTransaction.add(initializeTokenYIx);
-      if (preInstructions.length > 0) {
-        setupTransaction.add(...preInstructions);
-      }
-      const ledgerTransaction = new import_web38.Transaction();
-      const resetOrInitializeLedgerTx = yield this.resetOrInitializeLedgerAccount(user);
-      ledgerTransaction.add(resetOrInitializeLedgerTx);
+      setupInstructions.push(...preInstructions);
+      const ledgerInstructions = yield this.resetOrInitializeLedgerAccount(user);
       if (isDirectRoute) {
         const { isTokenX, amount, maxTransferAmount } = params;
         if (singleSided !== void 0) {
           const singleSidedX = singleSided === 0 /* X */;
-          if (swapTransactions.length > 0) {
+          if (swapInstructions.length > 0) {
             const swappedTokenAccount = singleSidedX ? tokenXAccount : tokenYAccount;
             const preSwappedTokenBalance = yield getTokenAccountBalance(
               this.connection,
               swappedTokenAccount
             );
-            const updateLedgerBalanceAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+            const updateLedgerBalanceAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
               user,
               swappedTokenAccount,
-              new import_anchor.BN(preSwappedTokenBalance),
+              new import_core.BN(preSwappedTokenBalance),
               maxTransferAmount,
               singleSidedX
             );
-            ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+            ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
           } else {
-            const setLedgerBalanceTx = yield this.setLedgerBalance(
+            const setLedgerBalanceIx = yield this.setLedgerBalance(
               user,
               amount,
               singleSidedX
             );
-            ledgerTransaction.add(setLedgerBalanceTx);
+            ledgerInstructions.push(setLedgerBalanceIx);
           }
         } else {
-          const setLedgerBalanceTx = yield this.setLedgerBalance(
+          const setLedgerBalanceIx = yield this.setLedgerBalance(
             user,
             amount,
             isTokenX
           );
-          ledgerTransaction.add(setLedgerBalanceTx);
-          if (swapTransactions.length > 0) {
+          ledgerInstructions.push(setLedgerBalanceIx);
+          if (swapInstructions.length > 0) {
             const swappedTokenAccount = isTokenX ? tokenYAccount : tokenXAccount;
             const preSwappedTokenBalance = yield getTokenAccountBalance(
               this.connection,
               swappedTokenAccount
             );
-            const updateLedgerBalanceAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+            const updateLedgerBalanceAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
               user,
               swappedTokenAccount,
-              new import_anchor.BN(preSwappedTokenBalance),
+              new import_core.BN(preSwappedTokenBalance),
               maxTransferAmount,
               !isTokenX
             );
-            ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+            ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
           }
         }
       } else {
@@ -4728,14 +5324,14 @@ var Zap = class {
             this.connection,
             swappedTokenAccount
           );
-          const updateLedgerBalanceAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             swappedTokenAccount,
-            new import_anchor.BN(preSwappedTokenBalance),
+            new import_core.BN(preSwappedTokenBalance),
             singleSidedX ? maxTransferAmountX : maxTransferAmountY,
             singleSidedX
           );
-          ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
         } else {
           const preTokenXBalance = yield getTokenAccountBalance(
             this.connection,
@@ -4745,22 +5341,22 @@ var Zap = class {
             this.connection,
             tokenYAccount
           );
-          const updateLedgerBalanceTokenXAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceTokenXAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             tokenXAccount,
-            new import_anchor.BN(preTokenXBalance),
+            new import_core.BN(preTokenXBalance),
             maxTransferAmountX,
             true
           );
-          const updateLedgerBalanceTokenYAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceTokenYAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             tokenYAccount,
-            new import_anchor.BN(preTokenYBalance),
+            new import_core.BN(preTokenYBalance),
             maxTransferAmountY,
             false
           );
-          ledgerTransaction.add(updateLedgerBalanceTokenXAfterSwapTx);
-          ledgerTransaction.add(updateLedgerBalanceTokenYAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceTokenXAfterSwapIx);
+          ledgerInstructions.push(updateLedgerBalanceTokenYAfterSwapIx);
         }
       }
       const dlmm = yield import_dlmm4.default.create(this.connection, lbPair);
@@ -4774,7 +5370,7 @@ var Zap = class {
         tokenYProgram,
         dlmm.lbPair
       );
-      const zapInTransaction = yield this.zapInDlmmForUninitializedPosition({
+      const zapInInstruction = yield this.zapInDlmmForUninitializedPosition({
         user,
         lbPair,
         position,
@@ -4788,18 +5384,17 @@ var Zap = class {
         strategy,
         remainingAccountInfo
       });
-      const cleanUpTransaction = new import_web38.Transaction();
-      const closeLedgerTransaction = yield this.closeLedgerAccount(user, user);
-      cleanUpTransaction.add(closeLedgerTransaction);
-      if (cleanUpInstructions.length > 0) {
-        cleanUpTransaction.add(...cleanUpInstructions);
-      }
+      const closeLedgerInstruction = yield this.closeLedgerAccount(user, user);
       return {
-        setupTransaction: setupTransaction.instructions.length > 0 ? setupTransaction : void 0,
-        swapTransactions,
-        ledgerTransaction,
-        zapInTransaction,
-        cleanUpTransaction
+        instructions: [
+          ...dedupeCreateAtaInstructions(setupInstructions),
+          ...swapInstructions,
+          ...ledgerInstructions,
+          zapInInstruction,
+          closeLedgerInstruction,
+          ...cleanUpInstructions
+        ],
+        addressLookupTableAccounts
       };
     });
   }
@@ -4807,6 +5402,13 @@ var Zap = class {
    * High level method for DLMM position rebalancing
    * Consist of remove liquidity, zap out through Jupiter or DLMM, and zap back in to rebalance the position
    *
+   * Instructions are ordered: setup (token accounts), init bin arrays, rebalance position, swap, ledger,
+   * zap in, clean up. They must run in that order but can be split across several transactions.
+   * Splitting loses atomicity, so send split transactions as a bundle.
+   * No compute budget instructions are included. The zap-in instruction was measured at about 462k
+   * compute units. Without a compute unit limit, a transaction gets 200k units per instruction (up to
+   * 1.4M), which may not cover it, so set a compute unit limit on the transaction that holds it.
+   *
    * @param params - Rebalancing DLMM position parameters
    * @param params.lbPairAddress - The DLMM pool address
    * @param params.positionAddress - The position address
@@ -4818,8 +5420,7 @@ var Zap = class {
    * @param params.strategy - The strategy to use for the rebalance
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
    * @param params.directSwapEstimate - The estimate of the direct swap operation
-   * @param params.maxAccounts - The maximum number of accounts to use for the swap operation
-   * @returns Response containing transactions and estimation details
+   * @returns The ordered instructions, the lookup tables they use, and the estimated balances
    * @throws if fail to get jupiter quote or jupiter swap instruction
    */
   rebalanceDlmmPosition(params) {
@@ -4834,45 +5435,27 @@ var Zap = class {
         swapSlippageBps,
         strategy,
         favorXInActiveId,
-        directSwapEstimate,
-        maxAccounts = 50
+        directSwapEstimate
       } = params;
       const dlmm = yield import_dlmm4.default.create(this.connection, lbPair);
       const userPosition = yield dlmm.getPosition(position);
       const { tokenXProgram, tokenYProgram } = (0, import_dlmm4.getTokenProgramId)(dlmm.lbPair);
-      const [
-        { ataPubkey: userTokenX, ix: userTokenXIx },
-        { ataPubkey: userTokenY, ix: userTokenYIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          dlmm.lbPair.tokenXMint,
-          user,
-          user,
-          true,
-          tokenXProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          dlmm.lbPair.tokenYMint,
-          user,
-          user,
-          true,
-          tokenYProgram
-        )
+      const {
+        tokenAccounts: [userTokenX, userTokenY],
+        instructions: setupInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: dlmm.lbPair.tokenXMint, tokenProgram: tokenXProgram },
+        { mint: dlmm.lbPair.tokenYMint, tokenProgram: tokenYProgram }
       ]);
-      const setupTransaction = new import_web38.Transaction();
-      userTokenXIx && setupTransaction.add(userTokenXIx);
-      userTokenYIx && setupTransaction.add(userTokenYIx);
       const strategyParamBuilder = (0, import_dlmm4.getLiquidityStrategyParameterBuilder)(strategy);
       const { x0, y0, deltaX, deltaY } = (0, import_dlmm4.buildLiquidityStrategyParameters)(
-        new import_anchor.BN(0),
-        new import_anchor.BN(0),
-        new import_anchor.BN(minDeltaId),
-        new import_anchor.BN(maxDeltaId),
-        new import_anchor.BN(dlmm.lbPair.binStep),
+        new import_core.BN(0),
+        new import_core.BN(0),
+        new import_core.BN(minDeltaId),
+        new import_core.BN(maxDeltaId),
+        new import_core.BN(dlmm.lbPair.binStep),
         favorXInActiveId,
-        new import_anchor.BN(dlmm.lbPair.activeId),
+        new import_core.BN(dlmm.lbPair.activeId),
         strategyParamBuilder
       );
       const { rebalancePosition, simulationResult } = yield dlmm.simulateRebalancePosition(
@@ -4888,16 +5471,16 @@ var Zap = class {
             y0,
             deltaX,
             deltaY,
-            minDeltaId: new import_anchor.BN(minDeltaId),
-            maxDeltaId: new import_anchor.BN(maxDeltaId),
+            minDeltaId: new import_core.BN(minDeltaId),
+            maxDeltaId: new import_core.BN(maxDeltaId),
             favorXInActiveBin: favorXInActiveId
           }
         ],
         [
           {
-            minBinId: new import_anchor.BN(userPosition.positionData.lowerBinId),
-            maxBinId: new import_anchor.BN(userPosition.positionData.upperBinId),
-            bps: new import_anchor.BN(import_dlmm4.BASIS_POINT_MAX)
+            minBinId: new import_core.BN(userPosition.positionData.lowerBinId),
+            maxBinId: new import_core.BN(userPosition.positionData.upperBinId),
+            bps: new import_core.BN(import_dlmm4.BASIS_POINT_MAX)
             // remove all liquidity
           }
         ]
@@ -4912,34 +5495,42 @@ var Zap = class {
         rebalancePositionInstruction: _rebalancePositionInstruction
       } = yield dlmm.rebalancePosition(
         { simulationResult, rebalancePosition },
-        new import_anchor.BN(maxActiveBinSlippage)
+        new import_core.BN(maxActiveBinSlippage)
+      );
+      let rebalancePositionInstruction = filterOutComputeBudgetInstructions(
+        _rebalancePositionInstruction
       );
-      let rebalancePositionInstruction = _rebalancePositionInstruction;
       if (dlmm.lbPair.tokenXMint.equals(import_spl_token6.NATIVE_MINT) || dlmm.lbPair.tokenYMint.equals(import_spl_token6.NATIVE_MINT)) {
         rebalancePositionInstruction = filterOutCloseSplTokenAccountInstructions(
-          _rebalancePositionInstruction
+          rebalancePositionInstruction
         );
       }
-      const tokenXAmount = new import_anchor.BN(userPosition.positionData.totalXAmount);
-      const tokenYAmount = new import_anchor.BN(userPosition.positionData.totalYAmount);
-      let swapTransaction;
+      const tokenXAmount = new import_core.BN(userPosition.positionData.totalXAmount);
+      const tokenYAmount = new import_core.BN(userPosition.positionData.totalYAmount);
+      let swapInstructions = [];
+      let addressLookupTableAccounts = [];
       if (directSwapEstimate.swapType !== 2 /* NoSwap */ && directSwapEstimate.quote) {
         const swapQuote = directSwapEstimate.quote;
         if (swapQuote.route === 0 /* Jupiter */) {
-          const { transaction: swapTx } = yield buildJupiterSwapTransaction(
+          const swap = yield buildJupiterSwapTransaction(
+            this.connection,
             user,
             directSwapEstimate.swapType === 0 /* XToY */ ? dlmm.lbPair.tokenXMint : dlmm.lbPair.tokenYMint,
             directSwapEstimate.swapType === 0 /* XToY */ ? dlmm.lbPair.tokenYMint : dlmm.lbPair.tokenXMint,
             directSwapEstimate.swapAmount,
-            maxAccounts,
             swapSlippageBps,
             swapQuote.originalQuote,
             {
               jupiterApiUrl: this.jupiterApiUrl,
-              jupiterApiKey: this.jupiterApiKey
+              jupiterApiKey: this.jupiterApiKey,
+              jupiterApiVersion: this.jupiterApiVersion
             }
           );
-          swapTransaction = swapTx;
+          setupInstructions.push(
+            ...getJupiterCreateAtaInstructions(swap.setupInstructions)
+          );
+          swapInstructions = [swap.instruction];
+          addressLookupTableAccounts = swap.addressLookupTableAccounts;
         } else {
           const swapForY = directSwapEstimate.swapType === 0 /* XToY */;
           const binArrays2 = yield dlmm.getBinArrayForSwap(swapForY);
@@ -4952,12 +5543,15 @@ var Zap = class {
             user,
             binArraysPubkey: binArrays2.map((item) => item.publicKey)
           });
+          swapTx.instructions = filterOutComputeBudgetInstructions(
+            swapTx.instructions
+          );
           if (dlmm.lbPair.tokenXMint.equals(import_spl_token6.NATIVE_MINT) || dlmm.lbPair.tokenYMint.equals(import_spl_token6.NATIVE_MINT)) {
             swapTx.instructions = filterOutCloseSplTokenAccountInstructions(
               swapTx.instructions
             );
           }
-          swapTransaction = swapTx;
+          swapInstructions = swapTx.instructions;
         }
       }
       const preTokenXBalance = yield getTokenAccountBalance(
@@ -4972,31 +5566,31 @@ var Zap = class {
       const tokenYAmountAfterSwap = directSwapEstimate.swapType === 0 /* XToY */ ? tokenYAmount.add(directSwapEstimate.expectedOutput) : directSwapEstimate.swapType === 1 /* YToX */ ? tokenYAmount.sub(directSwapEstimate.swapAmount) : tokenYAmount;
       const ledgerAddress = deriveLedgerAccount(user);
       const ledgerAccountInfo = yield this.connection.getAccountInfo(ledgerAddress);
-      const ledgerTransaction = new import_web38.Transaction();
+      const ledgerInstructions = [];
       if (!ledgerAccountInfo) {
-        const initLedgerTx = yield this.initializeLedgerAccount(user, user);
-        ledgerTransaction.add(...initLedgerTx.instructions);
+        const initLedgerIx = yield this.initializeLedgerAccount(user, user);
+        ledgerInstructions.push(initLedgerIx);
       }
-      const updateLedgerXTx = yield this.updateLedgerBalanceAfterSwap(
+      const updateLedgerXIx = yield this.updateLedgerBalanceAfterSwap(
         user,
         userTokenX,
-        new import_anchor.BN(preTokenXBalance),
+        new import_core.BN(preTokenXBalance),
         tokenXAmountAfterSwap,
         true
       );
-      ledgerTransaction.add(...updateLedgerXTx.instructions);
-      const updateLedgerYTx = yield this.updateLedgerBalanceAfterSwap(
+      ledgerInstructions.push(updateLedgerXIx);
+      const updateLedgerYIx = yield this.updateLedgerBalanceAfterSwap(
         user,
         userTokenY,
-        new import_anchor.BN(preTokenYBalance),
+        new import_core.BN(preTokenYBalance),
         tokenYAmountAfterSwap,
         false
       );
-      ledgerTransaction.add(...updateLedgerYTx.instructions);
+      ledgerInstructions.push(updateLedgerYIx);
       const binArrays = (0, import_dlmm4.getBinArraysRequiredByPositionRange)(
         lbPair,
-        new import_anchor.BN(dlmm.lbPair.activeId + minDeltaId),
-        new import_anchor.BN(dlmm.lbPair.activeId + maxDeltaId),
+        new import_core.BN(dlmm.lbPair.activeId + minDeltaId),
+        new import_core.BN(dlmm.lbPair.activeId + maxDeltaId),
         DLMM_PROGRAM_ID
       ).map((item) => ({
         pubkey: item.key,
@@ -5013,7 +5607,7 @@ var Zap = class {
         tokenYProgram,
         dlmm.lbPair
       );
-      const zapInTransaction = yield this.zapInDlmmForInitializedPosition({
+      const zapInInstruction = yield this.zapInDlmmForInitializedPosition({
         user,
         lbPair,
         position,
@@ -5026,28 +5620,26 @@ var Zap = class {
         strategy,
         remainingAccountInfo
       });
-      zapInTransaction.instructions.unshift(
-        // based on 1 tx that consumed 462_610. Add 20% for safety and round up to nearest 100,000
-        // 462_610 * 1.2 = 555_132 => 600_000
-        import_web38.ComputeBudgetProgram.setComputeUnitLimit({ units: 6e5 })
-      );
-      const cleanUpTransaction = new import_web38.Transaction();
-      const closeLedgerTx = yield this.closeLedgerAccount(user, user);
-      cleanUpTransaction.add(closeLedgerTx);
+      const cleanUpInstructions = [
+        yield this.closeLedgerAccount(user, user)
+      ];
       if (dlmm.lbPair.tokenXMint.equals(import_spl_token6.NATIVE_MINT) || dlmm.lbPair.tokenYMint.equals(import_spl_token6.NATIVE_MINT)) {
         const unwrapIx = unwrapSOLInstruction(user, user);
         if (unwrapIx) {
-          cleanUpTransaction.add(unwrapIx);
+          cleanUpInstructions.push(unwrapIx);
         }
       }
       return {
-        setupTransaction,
-        initBinArrayTransaction: initBinArrayInstructions.length > 0 ? new import_web38.Transaction().add(...initBinArrayInstructions) : void 0,
-        rebalancePositionTransaction: rebalancePositionInstruction.length > 0 ? new import_web38.Transaction().add(...rebalancePositionInstruction) : void 0,
-        swapTransaction,
-        ledgerTransaction,
-        zapInTransaction,
-        cleanUpTransaction,
+        instructions: [
+          ...dedupeCreateAtaInstructions(setupInstructions),
+          ...filterOutComputeBudgetInstructions(initBinArrayInstructions),
+          ...rebalancePositionInstruction,
+          ...swapInstructions,
+          ...ledgerInstructions,
+          zapInInstruction,
+          ...cleanUpInstructions
+        ],
+        addressLookupTableAccounts,
         estimation: {
           currentBalances: {
             tokenX: tokenXAmount,
@@ -5073,7 +5665,7 @@ var Zap = class {
    * @param params.ammProgram - AMM program ID to interact with
    * @param params.preInstructions - Instructions to run before the zap out
    * @param params.postInstructions - Instructions to run after the zap out
-   * @returns builder transaction
+   * @returns The pre-instructions, the zap out instruction and the post-instructions in order, with no lookup tables
    */
   zapOut(params) {
     return __async(this, null, function* () {
@@ -5085,10 +5677,18 @@ var Zap = class {
         preInstructions,
         postInstructions
       } = params;
-      return this.zapProgram.methods.zapOut(zapOutParams).accountsPartial({
+      const zapOutInstruction = yield this.zapProgram.methods.zapOut(zapOutParams).accountsPartial({
         userTokenInAccount,
         ammProgram
-      }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+      }).remainingAccounts(remainingAccounts).instruction();
+      return {
+        instructions: [
+          ...preInstructions,
+          zapOutInstruction,
+          ...postInstructions
+        ],
+        addressLookupTableAccounts: []
+      };
     });
   }
   /**
@@ -5099,15 +5699,16 @@ var Zap = class {
    * @param params.user - Public key of the user performing the swap
    * @param params.inputMint - Token mint being swapped from
    * @param params.outputMint - Token mint being swapped to
-   * @param params.jupiterSwapResponse - Jupiter swap instruction response
+   * @param params.jupiterSwapResponse - Jupiter swap instruction response. Its lookup table fields, when present, are returned as `addressLookupTableAccounts` (v1 tables are fetched with one RPC call)
    * @param params.inputTokenProgram - Token program for the input token (defaults to SPL Token)
    * @param params.outputTokenProgram - Token program for the output token (defaults to SPL Token)
    * @param params.maxSwapAmount - Maximum amount of input token to swap
    * @param params.percentageToZapOut - Percentage of input token to zap out
-   * @returns built transaction
+   * @returns The ordered instructions and the lookup tables of the Jupiter swap
    */
   zapOutThroughJupiter(params) {
     return __async(this, null, function* () {
+      var _a;
       const {
         user,
         inputMint,
@@ -5120,29 +5721,21 @@ var Zap = class {
       } = params;
       const preInstructions = [];
       const postInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: inputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: outputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          inputMint,
-          user,
-          user,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          outputMint,
-          user,
-          user,
-          true,
-          outputTokenProgram
-        )
+      const {
+        tokenAccounts: [inputTokenAccount],
+        instructions: createAtaInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: inputMint, tokenProgram: inputTokenProgram },
+        { mint: outputMint, tokenProgram: outputTokenProgram }
       ]);
-      inputTokenAccountIx && preInstructions.push(inputTokenAccountIx);
-      outputTokenAccountIx && preInstructions.push(outputTokenAccountIx);
+      preInstructions.push(...createAtaInstructions);
+      preInstructions.push(
+        ...getJupiterCreateAtaInstructions(
+          ((_a = jupiterSwapResponse.setupInstructions) != null ? _a : []).map(
+            toTransactionInstruction
+          )
+        )
+      );
       let preUserTokenBalance;
       try {
         preUserTokenBalance = yield getTokenAccountBalance(
@@ -5166,27 +5759,36 @@ var Zap = class {
         jupiterSwapResponse.swapInstruction.data,
         "base64"
       );
-      const offsetAmountIn = payloadData.length - AMOUNT_IN_JUP_V6_REVERSE_OFFSET;
+      const offsetAmountIn = getJupiterInstructionLayout(
+        payloadData
+      ).amountInOffset(payloadData.length);
       if (inputMint.equals(import_spl_token6.NATIVE_MINT) || outputMint.equals(import_spl_token6.NATIVE_MINT)) {
         const unwrapInstructions = unwrapSOLInstruction(user, user);
         if (unwrapInstructions) {
           postInstructions.push(unwrapInstructions);
         }
       }
-      return yield this.zapOut({
-        userTokenInAccount: inputTokenAccount,
-        zapOutParams: {
-          percentage: percentageToZapOut,
-          offsetAmountIn,
-          preUserTokenBalance: new import_anchor.BN(preUserTokenBalance),
-          maxSwapAmount,
-          payloadData
-        },
-        remainingAccounts,
-        ammProgram: JUP_V6_PROGRAM_ID,
-        preInstructions,
-        postInstructions
-      });
+      const [{ instructions }, addressLookupTableAccounts] = yield Promise.all([
+        this.zapOut({
+          userTokenInAccount: inputTokenAccount,
+          zapOutParams: {
+            percentage: percentageToZapOut,
+            offsetAmountIn,
+            preUserTokenBalance: new import_core.BN(preUserTokenBalance),
+            maxSwapAmount,
+            payloadData
+          },
+          remainingAccounts,
+          ammProgram: JUP_V6_PROGRAM_ID,
+          preInstructions: dedupeCreateAtaInstructions(preInstructions),
+          postInstructions
+        }),
+        getJupiterAddressLookupTableAccounts(
+          this.connection,
+          jupiterSwapResponse
+        )
+      ]);
+      return { instructions, addressLookupTableAccounts };
     });
   }
   /**
@@ -5202,6 +5804,7 @@ var Zap = class {
    * @param params.minimumSwapAmountOut - Minimum amount of output token to receive
    * @param params.maxSwapAmount - Maximum amount of input token to swap
    * @param params.percentageToZapOut - Percentage of input token to zap out
+   * @returns The ordered instructions, with no lookup tables
    */
   zapOutThroughDammV2(params) {
     return __async(this, null, function* () {
@@ -5220,29 +5823,14 @@ var Zap = class {
       const poolState = yield getDammV2Pool(this.connection, poolAddress);
       const preInstructions = [];
       const postInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: inputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: outputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          inputMint,
-          user,
-          user,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          outputMint,
-          user,
-          user,
-          true,
-          outputTokenProgram
-        )
+      const {
+        tokenAccounts: [inputTokenAccount, outputTokenAccount],
+        instructions: createAtaInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: inputMint, tokenProgram: inputTokenProgram },
+        { mint: outputMint, tokenProgram: outputTokenProgram }
       ]);
-      inputTokenAccountIx && preInstructions.push(inputTokenAccountIx);
-      outputTokenAccountIx && preInstructions.push(outputTokenAccountIx);
+      preInstructions.push(...createAtaInstructions);
       let preUserTokenBalance;
       try {
         preUserTokenBalance = yield getTokenAccountBalance(
@@ -5274,7 +5862,7 @@ var Zap = class {
         zapOutParams: {
           percentage: percentageToZapOut,
           offsetAmountIn,
-          preUserTokenBalance: new import_anchor.BN(preUserTokenBalance),
+          preUserTokenBalance: new import_core.BN(preUserTokenBalance),
           maxSwapAmount,
           payloadData
         },
@@ -5298,6 +5886,7 @@ var Zap = class {
    * @param params.minimumSwapAmountOut - Minimum amount of output token to receive
    * @param params.maxSwapAmount - Maximum amount of input token to swap
    * @param params.percentageToZapOut - Percentage of input token to zap out
+   * @returns The ordered instructions, with no lookup tables
    */
   zapOutThroughDlmm(params) {
     return __async(this, null, function* () {
@@ -5316,29 +5905,14 @@ var Zap = class {
       const lbPairState = yield getLbPairState(this.connection, lbPairAddress);
       const preInstructions = [];
       const postInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: inputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: outputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          inputMint,
-          user,
-          user,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          outputMint,
-          user,
-          user,
-          true,
-          outputTokenProgram
-        )
+      const {
+        tokenAccounts: [inputTokenAccount, outputTokenAccount],
+        instructions: createAtaInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: inputMint, tokenProgram: inputTokenProgram },
+        { mint: outputMint, tokenProgram: outputTokenProgram }
       ]);
-      inputTokenAccountIx && preInstructions.push(inputTokenAccountIx);
-      outputTokenAccountIx && preInstructions.push(outputTokenAccountIx);
+      preInstructions.push(...createAtaInstructions);
       let preUserTokenBalance;
       try {
         preUserTokenBalance = yield getTokenAccountBalance(
@@ -5374,7 +5948,7 @@ var Zap = class {
         zapOutParams: {
           percentage: percentageToZapOut,
           offsetAmountIn: AMOUNT_IN_DLMM_OFFSET,
-          preUserTokenBalance: new import_anchor.BN(preUserTokenBalance),
+          preUserTokenBalance: new import_core.BN(preUserTokenBalance),
           maxSwapAmount,
           payloadData
         },
@@ -5396,12 +5970,14 @@ var Zap = class {
   DAMM_V2_PROGRAM_ID,
   DAMM_V2_SWAP_DISCRIMINATOR,
   DEFAULT_JUPITER_API_URL,
+  DEFAULT_JUPITER_API_VERSION,
   DLMM_PROGRAM_ID,
   DLMM_SWAP_DISCRIMINATOR,
   DlmmDirectSwapQuoteRoute,
   DlmmSingleSided,
   DlmmSwapType,
   JUP_V6_PROGRAM_ID,
+  JupiterApiVersion,
   MEMO_PROGRAM_ID,
   SwapExternalType,
   ZAP_PROGRAM_ID,