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

package/dist/index.mjs

@@ -40,27 +40,34 @@ var __async = (__this, __arguments, generator) => {
 
 // src/zap.ts
 import {
-  ComputeBudgetProgram,
   PublicKey as PublicKey8,
-  SystemProgram as SystemProgram2,
-  Transaction as Transaction2
+  SystemProgram as SystemProgram2
 } from "@solana/web3.js";
 import invariant2 from "invariant";
-import { BN as BN5, Program } from "@coral-xyz/anchor";
+import { BN as BN5, Program } from "@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",
@@ -69,7 +76,9 @@ var idl_default = {
         {
           name: "owner",
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "rent_receiver",
@@ -81,7 +90,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",
@@ -90,7 +108,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",
@@ -117,7 +147,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",
@@ -126,7 +165,9 @@ var idl_default = {
         {
           name: "owner",
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         }
       ],
       args: [
@@ -142,7 +183,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",
@@ -154,7 +204,9 @@ var idl_default = {
         {
           name: "owner",
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         }
       ],
       args: [
@@ -174,7 +226,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",
@@ -218,9 +279,13 @@ var idl_default = {
         },
         {
           name: "owner",
-          docs: ["owner of position"],
+          docs: [
+            "owner of position"
+          ],
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "token_a_program"
@@ -249,7 +314,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",
@@ -257,7 +331,9 @@ var idl_default = {
         },
         {
           name: "lb_pair",
-          docs: ["lb pair"],
+          docs: [
+            "lb pair"
+          ],
           writable: true
         },
         {
@@ -297,9 +373,13 @@ var idl_default = {
         },
         {
           name: "owner",
-          docs: ["owner of position"],
+          docs: [
+            "owner of position"
+          ],
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "rent_payer",
@@ -363,7 +443,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",
@@ -371,7 +460,9 @@ var idl_default = {
         },
         {
           name: "lb_pair",
-          docs: ["lb pair"],
+          docs: [
+            "lb pair"
+          ],
           writable: true
         },
         {
@@ -416,9 +507,13 @@ var idl_default = {
         },
         {
           name: "owner",
-          docs: ["owner of position"],
+          docs: [
+            "owner of position"
+          ],
           signer: true,
-          relations: ["ledger"]
+          relations: [
+            "ledger"
+          ]
         },
         {
           name: "rent_payer",
@@ -482,7 +577,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",
@@ -505,17 +609,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: [
@@ -582,7 +687,9 @@ var idl_default = {
           },
           {
             name: "TransferHookMultiReward",
-            fields: ["u8"]
+            fields: [
+              "u8"
+            ]
           },
           {
             name: "TransferHookReferral"
@@ -591,7 +698,7 @@ var idl_default = {
       }
     },
     {
-      name: "BaseFeeStruct",
+      name: "BaseFeeInfo",
       serialization: "bytemuck",
       repr: {
         kind: "c"
@@ -600,33 +707,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"
@@ -650,7 +758,10 @@ var idl_default = {
           {
             name: "padding",
             type: {
-              array: ["u8", 7]
+              array: [
+                "u8",
+                7
+              ]
             }
           },
           {
@@ -728,13 +839,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
+              ]
             }
           },
           {
@@ -760,7 +877,10 @@ var idl_default = {
           {
             name: "base_factor_seed",
             type: {
-              array: ["u8", 2]
+              array: [
+                "u8",
+                2
+              ]
             }
           },
           {
@@ -798,7 +918,10 @@ var idl_default = {
           {
             name: "_padding_1",
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
@@ -821,7 +944,10 @@ var idl_default = {
           {
             name: "bin_array_bitmap",
             type: {
-              array: ["u64", 16]
+              array: [
+                "u64",
+                16
+              ]
             }
           },
           {
@@ -831,7 +957,10 @@ var idl_default = {
           {
             name: "_padding_2",
             type: {
-              array: ["u8", 32]
+              array: [
+                "u8",
+                32
+              ]
             }
           },
           {
@@ -853,7 +982,10 @@ var idl_default = {
           {
             name: "_padding_3",
             type: {
-              array: ["u8", 8]
+              array: [
+                "u8",
+                8
+              ]
             }
           },
           {
@@ -872,10 +1004,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
+              ]
             }
           }
         ]
@@ -892,7 +1031,9 @@ var idl_default = {
         fields: [
           {
             name: "pool_fees",
-            docs: ["Pool fee"],
+            docs: [
+              "Pool fee"
+            ],
             type: {
               defined: {
                 name: "PoolFeesStruct"
@@ -901,22 +1042,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"
           },
           {
@@ -927,17 +1076,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"
             ],
@@ -945,100 +1103,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
+              ]
             }
           },
           {
@@ -1047,7 +1233,9 @@ var idl_default = {
           },
           {
             name: "metrics",
-            docs: ["metrics"],
+            docs: [
+              "metrics"
+            ],
             type: {
               defined: {
                 name: "PoolMetrics"
@@ -1056,19 +1244,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: [
                 {
@@ -1089,8 +1319,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: {
@@ -1123,25 +1352,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"
@@ -1149,11 +1396,8 @@ var idl_default = {
             }
           },
           {
-            name: "padding_1",
-            docs: ["padding"],
-            type: {
-              array: ["u64", 2]
-            }
+            name: "init_sqrt_price",
+            type: "u128"
           }
         ]
       }
@@ -1184,12 +1428,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",
@@ -1262,7 +1507,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"
@@ -1310,10 +1557,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
+              ]
             }
           }
         ]
@@ -1362,7 +1620,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"
@@ -1385,7 +1645,10 @@ var idl_default = {
           {
             name: "_padding",
             type: {
-              array: ["u8", 4]
+              array: [
+                "u8",
+                4
+              ]
             }
           },
           {
@@ -1395,7 +1658,10 @@ var idl_default = {
           {
             name: "_padding_1",
             type: {
-              array: ["u8", 8]
+              array: [
+                "u8",
+                8
+              ]
             }
           }
         ]
@@ -1443,71 +1709,97 @@ 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."],
-            type: "u64"
+            docs: [
+              "The last time reward states were updated."
+            ],
+            type: "u64"
           },
           {
             name: "cumulative_seconds_with_empty_liquidity_reward",
@@ -1569,44 +1861,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",
@@ -1621,6 +1875,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";
@@ -1651,9 +1910,10 @@ var DlmmSingleSided = /* @__PURE__ */ ((DlmmSingleSided2) => {
 
 // src/helpers/jupiter.ts
 import {
-  PublicKey as PublicKey2,
-  Transaction,
-  TransactionInstruction
+  AddressLookupTableAccount,
+  AddressLookupTableProgram,
+  PublicKey as PublicKey3,
+  TransactionInstruction as TransactionInstruction2
 } from "@solana/web3.js";
 
 // src/constants.ts
@@ -1698,6 +1958,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,
@@ -1710,42 +2032,224 @@ 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
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+  createCloseAccountInstruction,
+  getAssociatedTokenAddressSync,
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID
+} from "@solana/spl-token";
+import {
+  SystemProgram,
+  TransactionInstruction
+} from "@solana/web3.js";
+var getOrCreateATAInstruction = (_connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
+  const toAccount = getAssociatedTokenAddressSync(
+    tokenMint,
+    owner,
+    allowOwnerOffCurve,
+    tokenProgram
+  );
+  const ix = createAssociatedTokenAccountIdempotentInstruction(
+    payer,
+    toAccount,
+    owner,
+    tokenMint,
+    tokenProgram
+  );
+  return { ataPubkey: toAccount, ix };
+});
+function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
+  const wSolATAAccount = getAssociatedTokenAddressSync(
+    NATIVE_MINT,
+    owner,
+    allowOwnerOffCurve
+  );
+  if (wSolATAAccount) {
+    const closedWrappedSolInstruction = createCloseAccountInstruction(
+      wSolATAAccount,
+      receiver,
+      owner,
+      [],
+      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 = TOKEN_PROGRAM_ID) {
+  return [
+    SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports: amount
+    }),
+    new 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(TOKEN_PROGRAM_ID)) {
+      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
+    }
+    return true;
+  });
+}
+function getCreateAtaInstructions(user, tokens) {
+  const tokenAccounts = tokens.map(
+    ({ mint, tokenProgram }) => getAssociatedTokenAddressSync(mint, user, true, tokenProgram)
+  );
+  const instructions = tokens.map(
+    ({ mint, tokenProgram }, i) => createAssociatedTokenAccountIdempotentInstruction(
+      user,
+      tokenAccounts[i],
+      user,
+      mint,
+      tokenProgram
+    )
+  );
+  return { tokenAccounts, instructions };
+}
+function isCreateAtaInstruction(ix) {
+  return ix.programId.equals(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 PublicKey3(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: jupiterHeaders(apiKey, false)
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return yield response.json();
+    } catch (error) {
+      return null;
+    }
+  });
+}
+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: __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 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
@@ -1754,10 +2258,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) {
@@ -1769,22 +2270,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 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 AddressLookupTableAccount({
+      key: new PublicKey3(key),
+      state: {
+        addresses: addresses.map((address) => new PublicKey3(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 PublicKey3(address));
+    const accounts = yield connection.getMultipleAccountsInfo(keys);
+    return keys.map((key, i) => {
+      const account = accounts[i];
+      if (!account || !account.owner.equals(AddressLookupTableProgram.programId)) {
+        throw new Error(`Address lookup table not found: ${key.toBase58()}`);
+      }
+      return new AddressLookupTableAccount({
+        key,
+        state: 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 buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6) {
-  return __async(this, arguments, function* (user, inputMint, outputMint, amount, maxAccounts, slippageBps, jupiterQuoteResponse, config = {}) {
+function toTransactionInstruction(instruction) {
+  return new TransactionInstruction2({
+    keys: instruction.accounts.map((item) => ({
+      pubkey: new PublicKey3(item.pubkey),
+      isSigner: item.isSigner,
+      isWritable: item.isWritable
+    })),
+    programId: new PublicKey3(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) {
@@ -1797,23 +2400,27 @@ function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6) {
       quoteResponse,
       config
     );
-    const instruction = new TransactionInstruction({
-      keys: swapInstructionResponse.swapInstruction.accounts.map((item) => {
-        return {
-          pubkey: new PublicKey2(item.pubkey),
-          isSigner: item.isSigner,
-          isWritable: item.isWritable
-        };
-      }),
-      programId: new PublicKey2(swapInstructionResponse.swapInstruction.programId),
-      data: Buffer.from(swapInstructionResponse.swapInstruction.data, "base64")
-    });
-    return { transaction: new Transaction().add(instruction), quoteResponse };
+    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
-import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2 } from "@solana/spl-token";
 import {
   CollectFeeMode,
   CpAmm,
@@ -1821,27 +2428,27 @@ import {
 } from "@meteora-ag/cp-amm-sdk";
 
 // src/helpers/pda.ts
-import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
 function deriveDammV2EventAuthority() {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveDammV2PoolAuthority() {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("pool_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveLedgerAccount(owner) {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("user_ledger"), owner.toBuffer()],
     ZAP_PROGRAM_ID
   )[0];
 }
 function deriveDlmmEventAuthority() {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DLMM_PROGRAM_ID
   )[0];
@@ -1855,7 +2462,7 @@ function getDammV2Pool(connection, poolAddress) {
   });
 }
 function getDammV2RemainingAccounts(_0, _1, _2, _3) {
-  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = TOKEN_PROGRAM_ID, tokenBProgram = TOKEN_PROGRAM_ID, poolState) {
+  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = TOKEN_PROGRAM_ID2, tokenBProgram = TOKEN_PROGRAM_ID2, poolState) {
     const remainingAccounts = [
       {
         isSigner: false,
@@ -1946,130 +2553,48 @@ function createDammV2SwapPayload(amountIn, minimumSwapAmountOut) {
 }
 
 // src/helpers/common.ts
+import { NATIVE_MINT as NATIVE_MINT2, TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3 } from "@solana/spl-token";
 import {
-  NATIVE_MINT,
-  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2
-} from "@solana/spl-token";
-import { PublicKey as PublicKey4 } from "@solana/web3.js";
+  ComputeBudgetProgram,
+  PublicKey as PublicKey5
+} from "@solana/web3.js";
 import Decimal from "decimal.js";
 function getTokenProgramFromMint(connection, mint) {
   return __async(this, null, function* () {
-    if (mint.equals(NATIVE_MINT)) {
-      return TOKEN_PROGRAM_ID2;
-    }
-    try {
-      const mintInfo = yield connection.getAccountInfo(mint);
-      if (!mintInfo) {
-        throw new Error(`Mint account not found: ${mint.toString()}`);
-      }
-      if (mintInfo.owner.equals(
-        new PublicKey4("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
-      )) {
-        return new PublicKey4("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
-      } else {
-        return TOKEN_PROGRAM_ID2;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
-        error
-      );
-      return TOKEN_PROGRAM_ID2;
-    }
-  });
-}
-function convertLamportsToUiAmount(amount, decimals) {
-  return amount.div(Decimal.pow(10, decimals));
-}
-function convertUiAmountToLamports(amount, decimals) {
-  return amount.mul(Decimal.pow(10, decimals));
-}
-
-// src/helpers/token.ts
-import {
-  createAssociatedTokenAccountIdempotentInstruction,
-  createCloseAccountInstruction,
-  getAssociatedTokenAddressSync,
-  NATIVE_MINT as NATIVE_MINT2,
-  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3
-} from "@solana/spl-token";
-import {
-  SystemProgram,
-  TransactionInstruction as TransactionInstruction2
-} from "@solana/web3.js";
-var getOrCreateATAInstruction = (connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
-  const toAccount = getAssociatedTokenAddressSync(
-    tokenMint,
-    owner,
-    allowOwnerOffCurve,
-    tokenProgram
-  );
-  const ix = createAssociatedTokenAccountIdempotentInstruction(
-    payer,
-    toAccount,
-    owner,
-    tokenMint,
-    tokenProgram
-  );
-  return { ataPubkey: toAccount, ix };
-});
-function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
-  const wSolATAAccount = getAssociatedTokenAddressSync(
-    NATIVE_MINT2,
-    owner,
-    allowOwnerOffCurve
-  );
-  if (wSolATAAccount) {
-    const closedWrappedSolInstruction = createCloseAccountInstruction(
-      wSolATAAccount,
-      receiver,
-      owner,
-      [],
-      TOKEN_PROGRAM_ID3
-    );
-    return closedWrappedSolInstruction;
-  }
-  return null;
-}
-function getTokenAccountBalance(connection, tokenAccount) {
-  return __async(this, null, function* () {
-    let balance;
+    if (mint.equals(NATIVE_MINT2)) {
+      return TOKEN_PROGRAM_ID3;
+    }
     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 PublicKey5("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
+      )) {
+        return new PublicKey5("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+      } else {
+        return TOKEN_PROGRAM_ID3;
+      }
+    } catch (error) {
+      console.warn(
+        `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
+        error
+      );
+      return TOKEN_PROGRAM_ID3;
     }
-    return balance;
   });
 }
-function wrapSOLInstruction(from, to, amount, tokenProgram = TOKEN_PROGRAM_ID3) {
-  return [
-    SystemProgram.transfer({
-      fromPubkey: from,
-      toPubkey: to,
-      lamports: amount
-    }),
-    new TransactionInstruction2({
-      keys: [
-        {
-          pubkey: to,
-          isSigner: false,
-          isWritable: true
-        }
-      ],
-      data: Buffer.from(new Uint8Array([17])),
-      programId: tokenProgram
-    })
-  ];
+function convertLamportsToUiAmount(amount, decimals) {
+  return amount.div(Decimal.pow(10, decimals));
 }
-var CLOSE_ACCOUNT_DISCRIMINATOR = 9;
-function filterOutCloseSplTokenAccountInstructions(instructions) {
-  return instructions.filter((ix) => {
-    if (ix.programId.equals(TOKEN_PROGRAM_ID3)) {
-      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
-    }
-    return true;
-  });
+function convertUiAmountToLamports(amount, decimals) {
+  return amount.mul(Decimal.pow(10, decimals));
+}
+function filterOutComputeBudgetInstructions(instructions) {
+  return instructions.filter(
+    (ix) => !ix.programId.equals(ComputeBudgetProgram.programId)
+  );
 }
 
 // src/helpers/dlmm.ts
@@ -2089,7 +2614,7 @@ import DLMM, {
 import {
   createTransferCheckedWithTransferHookInstruction,
   getTransferHook,
-  TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2,
+  TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4,
   unpackMint
 } from "@solana/spl-token";
@@ -2109,7 +2634,7 @@ function getExtraAccountMetasForTransferHook(connection, mint) {
     const mintInfo = unpackMint(
       mint,
       accountInfoWithBuffer,
-      TOKEN_2022_PROGRAM_ID2
+      TOKEN_2022_PROGRAM_ID
     );
     const transferHook = getTransferHook(mintInfo);
     if (!transferHook) {
@@ -2125,7 +2650,7 @@ function getExtraAccountMetasForTransferHook(connection, mint) {
         mintInfo.decimals,
         [],
         "confirmed",
-        TOKEN_2022_PROGRAM_ID2
+        TOKEN_2022_PROGRAM_ID
       );
       return (yield transferWithHookIx).keys.slice(4);
     }
@@ -2449,8 +2974,8 @@ function estimateSwapOutput(inAmount, effectiveRate) {
   const estimatedOutput = inAmountDecimal.mul(effectiveRate);
   return new BN3(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(
@@ -2463,15 +2988,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 ? {
@@ -2587,6 +3112,7 @@ function binarySearchRefineDirectSwapAmount(dlmm, initialActiveBin, initialMinBi
 }
 function estimateDlmmIndirectSwap(_0) {
   return __async(this, arguments, function* ({
+    user,
     amountIn,
     inputTokenMint,
     lbPair,
@@ -2596,7 +3122,8 @@ function estimateDlmmIndirectSwap(_0) {
     maxDeltaId,
     strategy,
     singleSided,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     const dlmm = yield DLMM2.create(connection, lbPair);
     const activeBin = yield dlmm.getActiveBin();
@@ -2620,15 +3147,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) {
@@ -2651,27 +3178,27 @@ function estimateDlmmIndirectSwap(_0) {
     const halfAmount = amountIn.div(new BN3(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
       )
     ]);
@@ -2767,27 +3294,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
       )
     ]);
@@ -2823,6 +3350,7 @@ function estimateDlmmIndirectSwap(_0) {
 }
 function estimateDlmmDirectSwapCore(_0) {
   return __async(this, arguments, function* ({
+    user,
     tokenXAmount,
     tokenYAmount,
     dlmm,
@@ -2831,7 +3359,8 @@ function estimateDlmmDirectSwapCore(_0) {
     maxDeltaId,
     strategy,
     singleSided,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     if (singleSided !== void 0) {
       const singleSidedX = singleSided === 0 /* X */;
@@ -2843,13 +3372,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(
@@ -2872,13 +3403,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(
@@ -2967,13 +3500,15 @@ function estimateDlmmDirectSwapCore(_0) {
     );
     const initialQuote = yield getBestSwapQuoteJupiterDlmm(
       dlmm,
+      user,
       inMint,
       outMint,
       initialSwapAmount,
       swapSlippageBps,
       swapForY,
       binArrayForSwap,
-      config
+      config,
+      jupiterQuoteOptions
     );
     if (!initialQuote) {
       throw new Error(
@@ -3025,13 +3560,15 @@ function estimateDlmmDirectSwapCore(_0) {
     );
     const finalQuote = yield getBestSwapQuoteJupiterDlmm(
       dlmm,
+      user,
       inMint,
       outMint,
       refinedAmount,
       swapSlippageBps,
       swapForY,
       binArrayForSwap,
-      config
+      config,
+      jupiterQuoteOptions
     );
     if (!finalQuote) {
       return {
@@ -3057,6 +3594,7 @@ function estimateDlmmDirectSwapCore(_0) {
 }
 function estimateDlmmDirectSwap(_0) {
   return __async(this, arguments, function* ({
+    user,
     amountIn,
     inputTokenMint,
     lbPair,
@@ -3066,7 +3604,8 @@ function estimateDlmmDirectSwap(_0) {
     maxDeltaId,
     strategy,
     singleSided,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     const dlmm = yield DLMM2.create(connection, lbPair);
     invariant(
@@ -3077,6 +3616,7 @@ function estimateDlmmDirectSwap(_0) {
     const tokenXAmount = isInputTokenX ? amountIn : new BN3(0);
     const tokenYAmount = isInputTokenX ? new BN3(0) : amountIn;
     const result = yield estimateDlmmDirectSwapCore({
+      user,
       tokenXAmount,
       tokenYAmount,
       dlmm,
@@ -3085,6 +3625,7 @@ function estimateDlmmDirectSwap(_0) {
       maxDeltaId,
       strategy,
       singleSided,
+      jupiterQuoteOptions,
       config
     });
     return {
@@ -3104,6 +3645,7 @@ function estimateDlmmDirectSwap(_0) {
 }
 function estimateDlmmRebalanceSwap(_0) {
   return __async(this, arguments, function* ({
+    user,
     lbPair,
     position,
     connection,
@@ -3111,11 +3653,13 @@ function estimateDlmmRebalanceSwap(_0) {
     minDeltaId,
     maxDeltaId,
     strategy,
-    config = {}
+    jupiterQuoteOptions,
+    config
   }) {
     const dlmm = yield DLMM2.create(connection, lbPair);
     const userPosition = yield dlmm.getPosition(position);
     const result = yield estimateDlmmDirectSwapCore({
+      user,
       tokenXAmount: new BN3(userPosition.positionData.totalXAmount),
       tokenYAmount: new BN3(userPosition.positionData.totalYAmount),
       dlmm,
@@ -3125,6 +3669,7 @@ function estimateDlmmRebalanceSwap(_0) {
       strategy,
       singleSided: void 0,
       // rebalance does not use single-sided deposits
+      jupiterQuoteOptions,
       config
     });
     return {
@@ -3213,13 +3758,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 Program(idl_default, { connection });
-    this.jupiterApiUrl = config.jupiterApiUrl || DEFAULT_JUPITER_API_URL;
-    this.jupiterApiKey = config.jupiterApiKey || "";
+    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) {
@@ -3228,7 +3775,7 @@ var Zap = class {
         ledger: deriveLedgerAccount(owner),
         owner,
         payer
-      }).transaction();
+      }).instruction();
     });
   }
   closeLedgerAccount(owner, rentReceiver) {
@@ -3237,7 +3784,7 @@ var Zap = class {
         ledger: deriveLedgerAccount(owner),
         owner,
         rentReceiver
-      }).transaction();
+      }).instruction();
     });
   }
   setLedgerBalance(owner, amount, isTokenA) {
@@ -3245,7 +3792,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) {
@@ -3258,7 +3805,7 @@ var Zap = class {
         ledger: deriveLedgerAccount(owner),
         tokenAccount,
         owner
-      }).transaction();
+      }).instruction();
     });
   }
   zapInDammV2(params) {
@@ -3296,7 +3843,7 @@ var Zap = class {
         tokenBProgram,
         dammProgram: DAMM_V2_PROGRAM_ID,
         dammEventAuthority: deriveDammV2EventAuthority()
-      }).transaction();
+      }).instruction();
     });
   }
   resetOrInitializeLedgerAccount(user) {
@@ -3306,9 +3853,9 @@ var Zap = class {
       if (accountInfo) {
         const closeLedger = yield this.closeLedgerAccount(user, user);
         const reInitializeLedger = yield this.initializeLedgerAccount(user, user);
-        return new Transaction2().add(closeLedger).add(reInitializeLedger);
+        return [closeLedger, reInitializeLedger];
       }
-      return yield this.initializeLedgerAccount(user, user);
+      return [yield this.initializeLedgerAccount(user, user)];
     });
   }
   zapInDlmmForInitializedPosition(params) {
@@ -3375,7 +3922,7 @@ var Zap = class {
         memoProgram: MEMO_PROGRAM_ID,
         dlmmEventAuthority: deriveDlmmEventAuthority(),
         systemProgram: SystemProgram2.programId
-      }).remainingAccounts(binArrays).transaction();
+      }).remainingAccounts(binArrays).instruction();
     });
   }
   zapInDlmmForUninitializedPosition(params) {
@@ -3439,7 +3986,7 @@ var Zap = class {
         memoProgram: MEMO_PROGRAM_ID,
         dlmmEventAuthority: deriveDlmmEventAuthority(),
         systemProgram: SystemProgram2.programId
-      }).remainingAccounts(binArrays).transaction();
+      }).remainingAccounts(binArrays).instruction();
     });
   }
   //#region Zap In
@@ -3453,12 +4000,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
@@ -3472,12 +4019,12 @@ var Zap = class {
         inputTokenMint,
         amountIn,
         positionNftMint,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         slippageBps,
         dammV2Quote,
         jupiterQuote,
-        maxTransferAmountExtendPercentage
+        maxTransferAmountExtendPercentage,
+        jupiterQuoteOptions
       } = params;
       const poolState = yield getDammV2Pool(this.connection, pool);
       const {
@@ -3497,7 +4044,7 @@ var Zap = class {
       const tokenAProgram = getTokenProgram(tokenAFlag);
       const tokenBProgram = getTokenProgram(tokenBFlag);
       const preInstructions = [];
-      if (tokenAMint.equals(NATIVE_MINT3) || tokenBMint.equals(NATIVE_MINT3)) {
+      if (inputTokenMint.equals(NATIVE_MINT3)) {
         const { ataPubkey: userWrapSolAcc, ix: initializeUserWrapSOLAta } = yield getOrCreateATAInstruction(
           this.connection,
           NATIVE_MINT3,
@@ -3549,7 +4096,8 @@ 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;
@@ -3563,19 +4111,25 @@ var Zap = class {
           swapInAmount = amountIn;
           amount = new BN5(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
           );
-          swapTransactions = [result.transaction];
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(result.setupInstructions)
+          );
+          swapInstructions = [result.instruction];
+          addressLookupTableAccounts = result.addressLookupTableAccounts;
           maxTransferAmount = getExtendMaxAmountTransfer(
             result.quoteResponse.outAmount,
             maxTransferAmountExtendPercentage
@@ -3612,19 +4166,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
         );
-        swapTransactions = [result.transaction];
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
+        swapInstructions = [result.instruction];
+        addressLookupTableAccounts = result.addressLookupTableAccounts;
         maxTransferAmount = getExtendMaxAmountTransfer(
           result.quoteResponse.outAmount,
           maxTransferAmountExtendPercentage
@@ -3682,7 +4242,8 @@ var Zap = class {
         preSqrtPrice: poolState.sqrtPrice,
         maxSqrtPriceChangeBps,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         swapInEstimate: {
           inAmount: swapInAmount,
@@ -3701,12 +4262,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
@@ -3720,12 +4281,12 @@ var Zap = class {
         pool,
         positionNftMint,
         amountIn,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         maxTransferAmountExtendPercentage,
         slippageBps,
         jupiterQuoteToA,
-        jupiterQuoteToB
+        jupiterQuoteToB,
+        jupiterQuoteOptions
       } = params;
       const poolState = yield getDammV2Pool(this.connection, pool);
       const {
@@ -3810,17 +4371,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,
@@ -3844,7 +4410,8 @@ var Zap = class {
           maxTransferAmountB: new BN5(0),
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
             inAmountA: amountIn,
@@ -3861,17 +4428,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,
@@ -3895,7 +4467,8 @@ var Zap = class {
           swapType: 1 /* swapToB */,
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
             inAmountA: new BN5(0),
@@ -3907,17 +4480,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,
@@ -3941,7 +4519,8 @@ var Zap = class {
           maxTransferAmountB: new BN5(0),
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
             inAmountA: amountIn,
@@ -3953,17 +4532,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,
@@ -3987,7 +4571,8 @@ var Zap = class {
           swapType: 1 /* swapToB */,
           preSqrtPrice: poolState.sqrtPrice,
           preInstructions,
-          swapTransactions: [result.transaction],
+          swapInstructions: [result.instruction],
+          addressLookupTableAccounts: result.addressLookupTableAccounts,
           cleanUpInstructions,
           swapInEstimate: {
             inAmountA: new BN5(0),
@@ -4039,43 +4624,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
         );
-        const { transaction: swapToBTransaction, quoteResponse: swapToBQuote } = yield buildJupiterSwapTransaction(
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToA.setupInstructions)
+        );
+        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,
@@ -4090,7 +4689,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
@@ -4106,10 +4710,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* () {
@@ -4129,61 +4734,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 Transaction2();
-      initializeTokenAIx && setupTransaction.add(initializeTokenAIx);
-      initializeTokenBIx && setupTransaction.add(initializeTokenBIx);
-      if (preInstructions.length > 0) {
-        setupTransaction.add(...preInstructions);
-      }
-      const ledgerTransaction = new Transaction2();
-      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 BN5(preTokenBalance),
             params.maxTransferAmount,
             !isTokenA
           );
-          ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
         }
       } else {
         const preTokenABalance = yield getTokenAccountBalance(
@@ -4194,7 +4779,7 @@ var Zap = class {
           this.connection,
           tokenBAccount
         );
-        const updateLedgerBalanceTokenAAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+        const updateLedgerBalanceTokenAAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
           user,
           tokenAAccount,
           new BN5(preTokenABalance),
@@ -4202,7 +4787,7 @@ var Zap = class {
           true
           // is token A
         );
-        const updateLedgerBalanceTokenBAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+        const updateLedgerBalanceTokenBAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
           user,
           tokenBAccount,
           new BN5(preTokenBBalance),
@@ -4212,14 +4797,17 @@ var Zap = class {
         );
         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,
@@ -4235,18 +4823,17 @@ var Zap = class {
         tokenAAccount,
         tokenBAccount
       });
-      const cleanUpTransaction = new Transaction2();
-      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
       };
     });
   }
@@ -4263,8 +4850,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
@@ -4284,7 +4870,6 @@ var Zap = class {
         maxDeltaId,
         strategy,
         favorXInActiveId,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -4317,25 +4902,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);
@@ -4348,6 +4939,9 @@ var Zap = class {
             user,
             binArraysPubkey: binArrays2.map((item) => item.publicKey)
           });
+          swapTx.instructions = filterOutComputeBudgetInstructions(
+            swapTx.instructions
+          );
           if (tokenXMint.equals(NATIVE_MINT3) || tokenYMint.equals(NATIVE_MINT3)) {
             swapTx.instructions = swapTx.instructions.filter((ix) => {
               if (ix.programId.equals(TOKEN_PROGRAM_ID6)) {
@@ -4356,7 +4950,7 @@ var Zap = class {
               return true;
             });
           }
-          swapTransactions.push(swapTx);
+          swapInstructions.push(...swapTx.instructions);
         }
         maxTransferAmount = getExtendMaxAmountTransfer(
           directSwapEstimate.expectedOutput.toString(),
@@ -4406,7 +5000,8 @@ var Zap = class {
         amount,
         maxTransferAmount,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         binArrays,
         binArrayBitmapExtension: binArrayBitmapExtensionData ? binArrayBitmapExtension : null,
@@ -4428,7 +5023,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
@@ -4449,7 +5043,6 @@ var Zap = class {
         strategy,
         favorXInActiveId,
         indirectSwapEstimate,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -4487,41 +5080,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
@@ -4563,7 +5170,8 @@ var Zap = class {
         maxTransferAmountX,
         maxTransferAmountY,
         preInstructions,
-        swapTransactions,
+        swapInstructions,
+        addressLookupTableAccounts,
         cleanUpInstructions,
         binArrays,
         binArrayBitmapExtension: binArrayBitmapExtensionData ? binArrayBitmapExtension : null,
@@ -4573,7 +5181,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
@@ -4588,14 +5201,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* () {
@@ -4614,90 +5228,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 Transaction2();
-      initializeTokenXIx && setupTransaction.add(initializeTokenXIx);
-      initializeTokenYIx && setupTransaction.add(initializeTokenYIx);
-      if (preInstructions.length > 0) {
-        setupTransaction.add(...preInstructions);
-      }
-      const ledgerTransaction = new Transaction2();
-      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 BN5(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 BN5(preSwappedTokenBalance),
               maxTransferAmount,
               !isTokenX
             );
-            ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+            ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
           }
         }
       } else {
@@ -4709,14 +5303,14 @@ var Zap = class {
             this.connection,
             swappedTokenAccount
           );
-          const updateLedgerBalanceAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             swappedTokenAccount,
             new BN5(preSwappedTokenBalance),
             singleSidedX ? maxTransferAmountX : maxTransferAmountY,
             singleSidedX
           );
-          ledgerTransaction.add(updateLedgerBalanceAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceAfterSwapIx);
         } else {
           const preTokenXBalance = yield getTokenAccountBalance(
             this.connection,
@@ -4726,22 +5320,22 @@ var Zap = class {
             this.connection,
             tokenYAccount
           );
-          const updateLedgerBalanceTokenXAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceTokenXAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             tokenXAccount,
             new BN5(preTokenXBalance),
             maxTransferAmountX,
             true
           );
-          const updateLedgerBalanceTokenYAfterSwapTx = yield this.updateLedgerBalanceAfterSwap(
+          const updateLedgerBalanceTokenYAfterSwapIx = yield this.updateLedgerBalanceAfterSwap(
             user,
             tokenYAccount,
             new BN5(preTokenYBalance),
             maxTransferAmountY,
             false
           );
-          ledgerTransaction.add(updateLedgerBalanceTokenXAfterSwapTx);
-          ledgerTransaction.add(updateLedgerBalanceTokenYAfterSwapTx);
+          ledgerInstructions.push(updateLedgerBalanceTokenXAfterSwapIx);
+          ledgerInstructions.push(updateLedgerBalanceTokenYAfterSwapIx);
         }
       }
       const dlmm = yield DLMM3.create(this.connection, lbPair);
@@ -4755,7 +5349,7 @@ var Zap = class {
         tokenYProgram,
         dlmm.lbPair
       );
-      const zapInTransaction = yield this.zapInDlmmForUninitializedPosition({
+      const zapInInstruction = yield this.zapInDlmmForUninitializedPosition({
         user,
         lbPair,
         position,
@@ -4769,18 +5363,17 @@ var Zap = class {
         strategy,
         remainingAccountInfo
       });
-      const cleanUpTransaction = new Transaction2();
-      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
       };
     });
   }
@@ -4788,6 +5381,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
@@ -4799,8 +5399,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) {
@@ -4815,36 +5414,18 @@ var Zap = class {
         swapSlippageBps,
         strategy,
         favorXInActiveId,
-        directSwapEstimate,
-        maxAccounts = 50
+        directSwapEstimate
       } = params;
       const dlmm = yield DLMM3.create(this.connection, lbPair);
       const userPosition = yield dlmm.getPosition(position);
       const { tokenXProgram, tokenYProgram } = 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 Transaction2();
-      userTokenXIx && setupTransaction.add(userTokenXIx);
-      userTokenYIx && setupTransaction.add(userTokenYIx);
       const strategyParamBuilder = getLiquidityStrategyParameterBuilder(strategy);
       const { x0, y0, deltaX, deltaY } = buildLiquidityStrategyParameters(
         new BN5(0),
@@ -4895,32 +5476,40 @@ var Zap = class {
         { simulationResult, rebalancePosition },
         new BN5(maxActiveBinSlippage)
       );
-      let rebalancePositionInstruction = _rebalancePositionInstruction;
+      let rebalancePositionInstruction = filterOutComputeBudgetInstructions(
+        _rebalancePositionInstruction
+      );
       if (dlmm.lbPair.tokenXMint.equals(NATIVE_MINT3) || dlmm.lbPair.tokenYMint.equals(NATIVE_MINT3)) {
         rebalancePositionInstruction = filterOutCloseSplTokenAccountInstructions(
-          _rebalancePositionInstruction
+          rebalancePositionInstruction
         );
       }
       const tokenXAmount = new BN5(userPosition.positionData.totalXAmount);
       const tokenYAmount = new BN5(userPosition.positionData.totalYAmount);
-      let swapTransaction;
+      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);
@@ -4933,12 +5522,15 @@ var Zap = class {
             user,
             binArraysPubkey: binArrays2.map((item) => item.publicKey)
           });
+          swapTx.instructions = filterOutComputeBudgetInstructions(
+            swapTx.instructions
+          );
           if (dlmm.lbPair.tokenXMint.equals(NATIVE_MINT3) || dlmm.lbPair.tokenYMint.equals(NATIVE_MINT3)) {
             swapTx.instructions = filterOutCloseSplTokenAccountInstructions(
               swapTx.instructions
             );
           }
-          swapTransaction = swapTx;
+          swapInstructions = swapTx.instructions;
         }
       }
       const preTokenXBalance = yield getTokenAccountBalance(
@@ -4953,27 +5545,27 @@ 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 Transaction2();
+      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 BN5(preTokenXBalance),
         tokenXAmountAfterSwap,
         true
       );
-      ledgerTransaction.add(...updateLedgerXTx.instructions);
-      const updateLedgerYTx = yield this.updateLedgerBalanceAfterSwap(
+      ledgerInstructions.push(updateLedgerXIx);
+      const updateLedgerYIx = yield this.updateLedgerBalanceAfterSwap(
         user,
         userTokenY,
         new BN5(preTokenYBalance),
         tokenYAmountAfterSwap,
         false
       );
-      ledgerTransaction.add(...updateLedgerYTx.instructions);
+      ledgerInstructions.push(updateLedgerYIx);
       const binArrays = getBinArraysRequiredByPositionRange(
         lbPair,
         new BN5(dlmm.lbPair.activeId + minDeltaId),
@@ -4994,7 +5586,7 @@ var Zap = class {
         tokenYProgram,
         dlmm.lbPair
       );
-      const zapInTransaction = yield this.zapInDlmmForInitializedPosition({
+      const zapInInstruction = yield this.zapInDlmmForInitializedPosition({
         user,
         lbPair,
         position,
@@ -5007,28 +5599,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
-        ComputeBudgetProgram.setComputeUnitLimit({ units: 6e5 })
-      );
-      const cleanUpTransaction = new Transaction2();
-      const closeLedgerTx = yield this.closeLedgerAccount(user, user);
-      cleanUpTransaction.add(closeLedgerTx);
+      const cleanUpInstructions = [
+        yield this.closeLedgerAccount(user, user)
+      ];
       if (dlmm.lbPair.tokenXMint.equals(NATIVE_MINT3) || dlmm.lbPair.tokenYMint.equals(NATIVE_MINT3)) {
         const unwrapIx = unwrapSOLInstruction(user, user);
         if (unwrapIx) {
-          cleanUpTransaction.add(unwrapIx);
+          cleanUpInstructions.push(unwrapIx);
         }
       }
       return {
-        setupTransaction,
-        initBinArrayTransaction: initBinArrayInstructions.length > 0 ? new Transaction2().add(...initBinArrayInstructions) : void 0,
-        rebalancePositionTransaction: rebalancePositionInstruction.length > 0 ? new Transaction2().add(...rebalancePositionInstruction) : void 0,
-        swapTransaction,
-        ledgerTransaction,
-        zapInTransaction,
-        cleanUpTransaction,
+        instructions: [
+          ...dedupeCreateAtaInstructions(setupInstructions),
+          ...filterOutComputeBudgetInstructions(initBinArrayInstructions),
+          ...rebalancePositionInstruction,
+          ...swapInstructions,
+          ...ledgerInstructions,
+          zapInInstruction,
+          ...cleanUpInstructions
+        ],
+        addressLookupTableAccounts,
         estimation: {
           currentBalances: {
             tokenX: tokenXAmount,
@@ -5054,7 +5644,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* () {
@@ -5066,10 +5656,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: []
+      };
     });
   }
   /**
@@ -5080,15 +5678,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,
@@ -5101,29 +5700,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(
@@ -5147,27 +5738,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(NATIVE_MINT3) || outputMint.equals(NATIVE_MINT3)) {
         const unwrapInstructions = unwrapSOLInstruction(user, user);
         if (unwrapInstructions) {
           postInstructions.push(unwrapInstructions);
         }
       }
-      return yield this.zapOut({
-        userTokenInAccount: inputTokenAccount,
-        zapOutParams: {
-          percentage: percentageToZapOut,
-          offsetAmountIn,
-          preUserTokenBalance: new BN5(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 BN5(preUserTokenBalance),
+            maxSwapAmount,
+            payloadData
+          },
+          remainingAccounts,
+          ammProgram: JUP_V6_PROGRAM_ID,
+          preInstructions: dedupeCreateAtaInstructions(preInstructions),
+          postInstructions
+        }),
+        getJupiterAddressLookupTableAccounts(
+          this.connection,
+          jupiterSwapResponse
+        )
+      ]);
+      return { instructions, addressLookupTableAccounts };
     });
   }
   /**
@@ -5183,6 +5783,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* () {
@@ -5201,29 +5802,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(
@@ -5279,6 +5865,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* () {
@@ -5297,29 +5884,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(
@@ -5376,12 +5948,14 @@ export {
   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,