@shogun-sdk/intents-sdk 1.2.6-test.13 → 1.2.6-test.15

package/dist/index.cjs

@@ -144,7 +144,7 @@ function isNativeEvmToken(tokenAddress) {
   const normalizedAddress = tokenAddress.toLowerCase();
   return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
 }
-var import_kit, useProdConfig, IntentsOrderType, PERMIT2_ADDRESS, PROD_CROSS_CHAIN_GUARD_ADDRESSES, TEST_CROSS_CHAIN_GUARD_ADDRESSES, PROD_SINGLE_CHAIN_GUARD_ADDRESSES, TEST_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES, TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, DCA_SINGLE_CHAIN_GUARD_ADDRESSES, NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS, SOLANA_USDC_MINT, SOLANA_MINT_TOKEN, PROD_SUI_PACKAGE_ID, TEST_SUI_PACKAGE_ID, SUI_PACKAGE_ID, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, AUCTIONEER_URL, MAX_UINT_32, MAX_UINT_64, MAX_UINT_128, MAX_UINT_256, NATIVE_EVM_ETH_ADDRESSES, WRAPPED_ETH_ADDRESSES, NATIVE_SUI_TOKEN_ADDRESS, TOKEN_SEARCH_API_BASE_URL, DEV_ACCESS_KEY;
+var import_kit, useProdConfig, IntentsOrderType, PERMIT2_ADDRESS, PROD_CROSS_CHAIN_GUARD_ADDRESSES, TEST_CROSS_CHAIN_GUARD_ADDRESSES, PROD_SINGLE_CHAIN_GUARD_ADDRESSES, TEST_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES, TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, DCA_SINGLE_CHAIN_GUARD_ADDRESSES, NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS, SOLANA_TIP_ACCOUNTS, SOLANA_MIN_TIP_LAMPORTS, SOLANA_USDC_MINT, SOLANA_MINT_TOKEN, PROD_SUI_PACKAGE_ID, TEST_SUI_PACKAGE_ID, SUI_PACKAGE_ID, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, AUCTIONEER_URL, MAX_UINT_32, MAX_UINT_64, MAX_UINT_128, MAX_UINT_256, NATIVE_EVM_ETH_ADDRESSES, WRAPPED_ETH_ADDRESSES, NATIVE_SUI_TOKEN_ADDRESS, TOKEN_SEARCH_API_BASE_URL;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -230,6 +230,19 @@ var init_constants = __esm({
     DCA_SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig ? PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES : TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES;
     NATIVE_SOLANA_TOKEN_ADDRESS = "So11111111111111111111111111111111111111111";
     WRAPPED_SOL_MINT_ADDRESS = "So11111111111111111111111111111111111111112";
+    SOLANA_TIP_ACCOUNTS = [
+      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
+      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
+      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
+      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
+      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
+      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
+      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
+      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
+      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
+      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
+    ];
+    SOLANA_MIN_TIP_LAMPORTS = 200000n;
     SOLANA_USDC_MINT = {
       name: "USDC",
       mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -260,7 +273,6 @@ var init_constants = __esm({
     };
     NATIVE_SUI_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
     TOKEN_SEARCH_API_BASE_URL = "https://shogun-token-search-api-825534211396.europe-west4.run.app";
-    DEV_ACCESS_KEY = process.env.DEV_ACCESS_KEY || process.env.NEXT_PUBLIC_DEV_ACCESS_KEY;
   }
 });
 
@@ -376,7 +388,8 @@ __export(index_exports, {
   ChainType: () => ChainType,
   CrossChainOrder: () => CrossChainOrder,
   DCA_SINGLE_CHAIN_GUARD_ADDRESSES: () => DCA_SINGLE_CHAIN_GUARD_ADDRESSES,
-  DEV_ACCESS_KEY: () => DEV_ACCESS_KEY,
+  DEV_ACCESS_HEADER: () => DEV_ACCESS_HEADER,
+  DEV_ACCESS_STORAGE_KEY: () => DEV_ACCESS_STORAGE_KEY,
   DcaSingleChainOrder: () => DcaSingleChainOrder,
   EVMSDK: () => EVMSDK,
   IntentsOrderType: () => IntentsOrderType,
@@ -396,6 +409,8 @@ __export(index_exports, {
   QuoteProvider: () => QuoteProvider,
   SINGLE_CHAIN_GUARD_ADDRESSES: () => SINGLE_CHAIN_GUARD_ADDRESSES,
   SOLANA_MINT_TOKEN: () => SOLANA_MINT_TOKEN,
+  SOLANA_MIN_TIP_LAMPORTS: () => SOLANA_MIN_TIP_LAMPORTS,
+  SOLANA_TIP_ACCOUNTS: () => SOLANA_TIP_ACCOUNTS,
   SOLANA_USDC_MINT: () => SOLANA_USDC_MINT,
   SUI_GUARD_COLLATERAL_TYPE: () => SUI_GUARD_COLLATERAL_TYPE,
   SUI_GUARD_STABLECOIN_TYPE: () => SUI_GUARD_STABLECOIN_TYPE,
@@ -446,6 +461,7 @@ __export(index_exports, {
   getCancelSingleChainOrderRawData: () => getCancelSingleChainOrderRawData,
   getCoinFromResponse: () => getCoinFromResponse,
   getDcaSecretHash: () => getDcaSecretHash,
+  getDevAccessHeaderValue: () => getDevAccessHeaderValue,
   getEVMCrossChainOrderTypedData: () => getEVMCrossChainOrderTypedData,
   getEVMSingleChainOrderTypedData: () => getEVMSingleChainOrderTypedData,
   getInvalidateNoncesRawData: () => getInvalidateNoncesRawData,
@@ -469,7 +485,8 @@ __export(index_exports, {
   prepareDcaSecretData: () => prepareDcaSecretData,
   prepareSecretData: () => prepareSecretData,
   signSingleChainDcaOrder: () => signSingleChainDcaOrder,
-  signSingleChainLimitOrder: () => signSingleChainLimitOrder
+  signSingleChainLimitOrder: () => signSingleChainLimitOrder,
+  withAuctioneerHeaders: () => withAuctioneerHeaders
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -554,9 +571,9 @@ var BaseValidator = class {
   /**
    * Helper methods that throw specific validation errors
    */
-  validateAddress(address9) {
-    if (!this.isValidAddress(address9)) {
-      throw new ValidationError(`Invalid ${this.getChainName()} address: ${address9}`);
+  validateAddress(address10) {
+    if (!this.isValidAddress(address10)) {
+      throw new ValidationError(`Invalid ${this.getChainName()} address: ${address10}`);
     }
   }
   validateTokenAddress(tokenAddress) {
@@ -3281,9 +3298,9 @@ var ChainProvider = class _ChainProvider {
       }
     });
   }
-  getSingleChainAuctioneerContract(address9) {
+  getSingleChainAuctioneerContract(address10) {
     return (0, import_viem3.getContract)({
-      address: address9,
+      address: address10,
       abi: SINGLE_CHAIN_GUARD_LIMIT_ABI,
       client: {
         wallet: this.walletClient,
@@ -3322,8 +3339,8 @@ var ChainProvider = class _ChainProvider {
 
 // src/core/evm/validator.ts
 var EvmValidator = class extends BaseValidator {
-  isValidAddress(address9) {
-    return (0, import_viem4.isAddress)(address9);
+  isValidAddress(address10) {
+    return (0, import_viem4.isAddress)(address10);
   }
   isValidTokenAddress(tokenAddress) {
     return (0, import_viem4.isAddress)(tokenAddress);
@@ -3420,8 +3437,8 @@ var SolanaValidator = class extends BaseValidator {
   validateSingleChainOrderFeasability() {
     return Promise.resolve();
   }
-  isValidAddress(address9) {
-    return (0, import_kit2.isAddress)(address9);
+  isValidAddress(address10) {
+    return (0, import_kit2.isAddress)(address10);
   }
   isValidTokenAddress(tokenAddress) {
     return (0, import_kit2.isAddress)(tokenAddress);
@@ -3445,12 +3462,12 @@ var import_utils = require("@mysten/sui/utils");
 init_constants();
 var SUI_TOKEN_ADDRESS_REGEX = /^0x[a-fA-F0-9]{64}::\w+::\w+$/;
 var SuiValidator = class extends BaseValidator {
-  isValidAddress(address9) {
-    return (0, import_utils.isValidSuiAddress)((0, import_utils.normalizeSuiAddress)(address9));
+  isValidAddress(address10) {
+    return (0, import_utils.isValidSuiAddress)((0, import_utils.normalizeSuiAddress)(address10));
   }
   isValidTokenAddress(tokenAddress) {
-    const [address9] = tokenAddress.split("::");
-    const isValidAddress = address9 !== void 0 ? this.isValidAddress(address9) : false;
+    const [address10] = tokenAddress.split("::");
+    const isValidAddress = address10 !== void 0 ? this.isValidAddress(address10) : false;
     return isValidAddress && SUI_TOKEN_ADDRESS_REGEX.test(tokenAddress);
   }
   isValidAmount(amount) {
@@ -3557,6 +3574,35 @@ var DcaSingleChainOrderValidator = class {
 init_constants();
 init_errors();
 
+// src/utils/auctioneer-headers.ts
+var DEV_ACCESS_STORAGE_KEY = "x-dev-access";
+var DEV_ACCESS_HEADER = "x-dev-access";
+function getDevAccessHeaderValue() {
+  try {
+    if (typeof globalThis === "undefined") {
+      return void 0;
+    }
+    const storage = globalThis.localStorage;
+    if (!storage?.getItem) {
+      return void 0;
+    }
+    const value = storage.getItem(DEV_ACCESS_STORAGE_KEY)?.trim();
+    return value ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function withAuctioneerHeaders(headers = {}) {
+  const value = getDevAccessHeaderValue();
+  if (!value) {
+    return headers;
+  }
+  return {
+    ...headers,
+    [DEV_ACCESS_HEADER]: value
+  };
+}
+
 // src/utils/parsers.ts
 var import_viem5 = require("viem");
 var Parsers;
@@ -3867,7 +3913,7 @@ async function getEVMDcaSingleChainOrderTypedData(order) {
 // src/core/solana/order-instructions.ts
 var import_system = require("@solana-program/system");
 var import_token = require("@solana-program/token");
-var import_kit4 = require("@solana/kit");
+var import_kit5 = require("@solana/kit");
 init_constants();
 
 // src/core/solana/client.ts
@@ -3916,8 +3962,8 @@ function getOrderDecoder() {
 function decodeOrder(encodedAccount) {
   return (0, import_accounts2.decodeAccount)(encodedAccount, getOrderDecoder());
 }
-async function fetchMaybeOrder(rpc, address9, config) {
-  const maybeAccount = await (0, import_accounts2.fetchEncodedAccount)(rpc, address9, config);
+async function fetchMaybeOrder(rpc, address10, config) {
+  const maybeAccount = await (0, import_accounts2.fetchEncodedAccount)(rpc, address10, config);
   return decodeOrder(maybeAccount);
 }
 
@@ -4106,8 +4152,8 @@ function getDcaOrderDecoder() {
 function decodeDcaOrder(encodedAccount) {
   return (0, import_accounts3.decodeAccount)(encodedAccount, getDcaOrderDecoder());
 }
-async function fetchMaybeDcaOrder(rpc, address9, config) {
-  const maybeAccount = await (0, import_accounts3.fetchEncodedAccount)(rpc, address9, config);
+async function fetchMaybeDcaOrder(rpc, address10, config) {
+  const maybeAccount = await (0, import_accounts3.fetchEncodedAccount)(rpc, address10, config);
   return decodeDcaOrder(maybeAccount);
 }
 
@@ -4132,8 +4178,8 @@ function getLimitOrderDecoder() {
 function decodeLimitOrder(encodedAccount) {
   return (0, import_accounts4.decodeAccount)(encodedAccount, getLimitOrderDecoder());
 }
-async function fetchMaybeLimitOrder(rpc, address9, config) {
-  const maybeAccount = await (0, import_accounts4.fetchEncodedAccount)(rpc, address9, config);
+async function fetchMaybeLimitOrder(rpc, address10, config) {
+  const maybeAccount = await (0, import_accounts4.fetchEncodedAccount)(rpc, address10, config);
   return decodeLimitOrder(maybeAccount);
 }
 
@@ -4457,23 +4503,80 @@ function formatTokenPubkey(token) {
   return token;
 }
 
+// src/core/solana/transaction-options.ts
+var import_kit4 = require("@solana/kit");
+init_constants();
+function resolveSolanaFeePayer(userSigner, feePayer) {
+  if (!feePayer || feePayer === userSigner.address) {
+    return userSigner;
+  }
+  const feePayerAddress = (0, import_kit4.address)(feePayer);
+  return (0, import_kit4.createNoopSigner)(feePayerAddress);
+}
+function resolveSolanaTip(options) {
+  const lamports = normalizeTipLamports(options);
+  if (!lamports) {
+    return void 0;
+  }
+  const selectedTipAccount = options?.tipAccount ?? pickRandomTipAccount(options?.tipAccounts ?? SOLANA_TIP_ACCOUNTS);
+  return {
+    lamports,
+    account: (0, import_kit4.address)(selectedTipAccount)
+  };
+}
+function normalizeTipLamports(options) {
+  if (!options) {
+    return void 0;
+  }
+  if (options.tipLamports !== void 0) {
+    if (options.tipLamports <= 0n) {
+      return void 0;
+    }
+    return options.tipLamports < SOLANA_MIN_TIP_LAMPORTS ? SOLANA_MIN_TIP_LAMPORTS : options.tipLamports;
+  }
+  if (options.tipAmountSol === void 0 || options.tipAmountSol === null || options.tipAmountSol === "") {
+    return void 0;
+  }
+  const tipInSol = Number(options.tipAmountSol);
+  if (!Number.isFinite(tipInSol)) {
+    throw new Error("Invalid Solana tip amount");
+  }
+  if (tipInSol <= 0) {
+    return void 0;
+  }
+  const tipLamports = BigInt(Math.round(tipInSol * 1e9));
+  return tipLamports < SOLANA_MIN_TIP_LAMPORTS ? SOLANA_MIN_TIP_LAMPORTS : tipLamports;
+}
+function pickRandomTipAccount(accounts) {
+  if (!accounts.length) {
+    throw new Error("No Solana tip accounts configured");
+  }
+  const index = Math.floor(Math.random() * accounts.length);
+  const selected = accounts[index];
+  if (!selected) {
+    throw new Error("No Solana tip account selected");
+  }
+  return selected;
+}
+
 // src/core/solana/order-instructions.ts
 async function getSolanaSingleChainOrderInstructions(order, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit4.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderSigner = await (0, import_kit4.generateKeyPairSigner)();
-  const signer = (0, import_kit4.createNoopSigner)(order.user);
-  let tokenInMint = (0, import_kit4.address)(order.tokenIn);
+  const rpc = options?.rpcUrl ? (0, import_kit5.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await (0, import_kit5.generateKeyPairSigner)();
+  const userSigner = (0, import_kit5.createNoopSigner)(order.user);
+  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
+  let tokenInMint = (0, import_kit5.address)(order.tokenIn);
   const { secretHash, secretNumber } = genSecretHashAndNumber(order);
-  const orderUserAddress = (0, import_kit4.address)(order.user);
+  const orderUserAddress = (0, import_kit5.address)(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await (0, import_token.fetchMint)(rpc, tokenInMint);
-  const guardAddress = (0, import_kit4.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
-  const addressEncoder = (0, import_kit4.getAddressEncoder)();
+  const guardAddress = (0, import_kit5.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const addressEncoder = (0, import_kit5.getAddressEncoder)();
   const instructions = [];
-  const [tokenInProgramAccount] = await (0, import_kit4.getProgramDerivedAddress)({
+  const [tokenInProgramAccount] = await (0, import_kit5.getProgramDerivedAddress)({
     programAddress: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -4481,10 +4584,10 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit5.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createAccountIx = await (0, import_token.getCreateAssociatedTokenInstructionAsync)({
-      payer: signer,
+      payer: feePayerSigner,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -4496,7 +4599,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     const transferIx = (0, import_system.getTransferSolInstruction)({
       amount: order.amountIn,
       destination: userTokenInAccount.address,
-      source: signer
+      source: userSigner
     });
     instructions.push(transferIx);
     const syncNativeIx = (0, import_token.getSyncNativeInstruction)({
@@ -4505,7 +4608,7 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     instructions.push(syncNativeIx);
   }
   const createSingleChainLimitOrderIx = await getCreateLimitOrderInstructionAsync({
-    user: signer,
+    user: userSigner,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint,
@@ -4519,16 +4622,26 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
     // TODO
   });
   instructions.push(createSingleChainLimitOrderIx);
+  const tip = resolveSolanaTip(options);
+  if (tip) {
+    instructions.push(
+      (0, import_system.getTransferSolInstruction)({
+        source: feePayerSigner,
+        destination: tip.account,
+        amount: tip.lamports
+      })
+    );
+  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit4.pipe)(
-    (0, import_kit4.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit4.setTransactionMessageFeePayerSigner)(signer, tx),
-    (tx) => (0, import_kit4.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit4.appendTransactionMessageInstructions)(instructions, tx),
-    (tx) => (0, import_kit4.addSignersToTransactionMessage)([orderSigner], tx)
+  const txMessage = (0, import_kit5.pipe)(
+    (0, import_kit5.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit5.setTransactionMessageFeePayerSigner)(feePayerSigner, tx),
+    (tx) => (0, import_kit5.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit5.appendTransactionMessageInstructions)(instructions, tx),
+    (tx) => (0, import_kit5.addSignersToTransactionMessage)([orderSigner], tx)
   );
-  const partiallySignedTransaction = await (0, import_kit4.partiallySignTransactionMessageWithSigners)(txMessage);
-  const txBytes = (0, import_kit4.getTransactionCodec)().encode(partiallySignedTransaction);
+  const partiallySignedTransaction = await (0, import_kit5.partiallySignTransactionMessageWithSigners)(txMessage);
+  const txBytes = (0, import_kit5.getTransactionCodec)().encode(partiallySignedTransaction);
   return {
     orderAddress: orderSigner.address,
     txBytes,
@@ -4536,19 +4649,20 @@ async function getSolanaSingleChainOrderInstructions(order, options) {
   };
 }
 async function getSolanaCrossChainOrderInstructions(order, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit4.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderSigner = await (0, import_kit4.generateKeyPairSigner)();
-  const signer = (0, import_kit4.createNoopSigner)(order.user);
-  let tokenInMint = (0, import_kit4.address)(order.sourceTokenAddress);
-  const orderUserAddress = (0, import_kit4.address)(order.user);
+  const rpc = options?.rpcUrl ? (0, import_kit5.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await (0, import_kit5.generateKeyPairSigner)();
+  const userSigner = (0, import_kit5.createNoopSigner)(order.user);
+  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
+  let tokenInMint = (0, import_kit5.address)(order.sourceTokenAddress);
+  const orderUserAddress = (0, import_kit5.address)(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await (0, import_token.fetchMint)(rpc, tokenInMint);
-  const guardAddress = (0, import_kit4.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
-  const addressEncoder = (0, import_kit4.getAddressEncoder)();
-  const [tokenInProgramAccount] = await (0, import_kit4.getProgramDerivedAddress)({
+  const guardAddress = (0, import_kit5.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const addressEncoder = (0, import_kit5.getAddressEncoder)();
+  const [tokenInProgramAccount] = await (0, import_kit5.getProgramDerivedAddress)({
     programAddress: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -4556,7 +4670,7 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const [guardProgramAccount] = await (0, import_kit4.getProgramDerivedAddress)({
+  const [guardProgramAccount] = await (0, import_kit5.getProgramDerivedAddress)({
     programAddress: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       // Owner
@@ -4568,12 +4682,12 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
     ]
   });
   const instructions = [];
-  const userTokenInAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit5.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (spendingNative) {
     order.sourceTokenAddress = WRAPPED_SOL_MINT_ADDRESS;
     if (!userTokenInAccount.exists) {
       const createAccountIx = await (0, import_token.getCreateAssociatedTokenInstructionAsync)({
-        payer: signer,
+        payer: feePayerSigner,
         ata: tokenInProgramAccount,
         owner: orderUserAddress,
         mint: tokenMintProgram.address,
@@ -4582,7 +4696,7 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
       instructions.push(createAccountIx);
     }
     const transferIx = (0, import_system.getTransferSolInstruction)({
-      source: signer,
+      source: userSigner,
       destination: userTokenInAccount.address,
       amount: order.sourceTokenAmount
     });
@@ -4594,9 +4708,9 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
   }
   const executionHashUint8Array = order.executionDetailsHashToBytes();
   const createOrderIx = getCreateOrderInstruction({
-    user: signer,
+    user: userSigner,
     order: orderSigner,
-    guard: (0, import_kit4.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]),
+    guard: (0, import_kit5.address)(CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]),
     systemProgram: import_system.SYSTEM_PROGRAM_ADDRESS,
     associatedTokenProgram: import_token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     tokenInMint,
@@ -4609,16 +4723,26 @@ async function getSolanaCrossChainOrderInstructions(order, options) {
     minStablecoinsAmount: order.minStablecoinAmount
   });
   instructions.push(createOrderIx);
+  const tip = resolveSolanaTip(options);
+  if (tip) {
+    instructions.push(
+      (0, import_system.getTransferSolInstruction)({
+        source: feePayerSigner,
+        destination: tip.account,
+        amount: tip.lamports
+      })
+    );
+  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit4.pipe)(
-    (0, import_kit4.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit4.setTransactionMessageFeePayerSigner)(signer, tx),
-    (tx) => (0, import_kit4.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit4.appendTransactionMessageInstructions)(instructions, tx),
-    (tx) => (0, import_kit4.addSignersToTransactionMessage)([orderSigner], tx)
+  const txMessage = (0, import_kit5.pipe)(
+    (0, import_kit5.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit5.setTransactionMessageFeePayerSigner)(feePayerSigner, tx),
+    (tx) => (0, import_kit5.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit5.appendTransactionMessageInstructions)(instructions, tx),
+    (tx) => (0, import_kit5.addSignersToTransactionMessage)([orderSigner], tx)
   );
-  const partiallySignedTransaction = await (0, import_kit4.partiallySignTransactionMessageWithSigners)(txMessage);
-  const txBytes = (0, import_kit4.getTransactionCodec)().encode(partiallySignedTransaction);
+  const partiallySignedTransaction = await (0, import_kit5.partiallySignTransactionMessageWithSigners)(txMessage);
+  const txBytes = (0, import_kit5.getTransactionCodec)().encode(partiallySignedTransaction);
   return {
     orderAddress: orderSigner.address,
     txBytes: Uint8Array.from(txBytes)
@@ -5212,113 +5336,113 @@ var RaydiumQuoteProvider = class {
 };
 
 // src/utils/quote/pumpfun/index.ts
-var import_kit7 = require("@solana/kit");
+var import_kit8 = require("@solana/kit");
 
 // src/utils/quote/pumpfun/utils.ts
-var import_kit6 = require("@solana/kit");
+var import_kit7 = require("@solana/kit");
 
 // src/utils/quote/pumpfun/models.ts
-var import_kit5 = require("@solana/kit");
+var import_kit6 = require("@solana/kit");
 function getPumpPoolDataDecoder() {
-  return (0, import_kit5.getStructDecoder)([
-    ["poolBump", (0, import_kit5.getU8Decoder)()],
-    ["index", (0, import_kit5.getU16Decoder)()],
-    ["creator", (0, import_kit5.getAddressDecoder)()],
-    ["baseMint", (0, import_kit5.getAddressDecoder)()],
-    ["quoteMint", (0, import_kit5.getAddressDecoder)()],
-    ["lpMint", (0, import_kit5.getAddressDecoder)()],
-    ["poolBaseTokenAccount", (0, import_kit5.getAddressDecoder)()],
-    ["poolQuoteTokenAccount", (0, import_kit5.getAddressDecoder)()],
-    ["lpSupply", (0, import_kit5.getU64Decoder)()],
-    ["coinCreator", (0, import_kit5.getAddressDecoder)()]
+  return (0, import_kit6.getStructDecoder)([
+    ["poolBump", (0, import_kit6.getU8Decoder)()],
+    ["index", (0, import_kit6.getU16Decoder)()],
+    ["creator", (0, import_kit6.getAddressDecoder)()],
+    ["baseMint", (0, import_kit6.getAddressDecoder)()],
+    ["quoteMint", (0, import_kit6.getAddressDecoder)()],
+    ["lpMint", (0, import_kit6.getAddressDecoder)()],
+    ["poolBaseTokenAccount", (0, import_kit6.getAddressDecoder)()],
+    ["poolQuoteTokenAccount", (0, import_kit6.getAddressDecoder)()],
+    ["lpSupply", (0, import_kit6.getU64Decoder)()],
+    ["coinCreator", (0, import_kit6.getAddressDecoder)()]
   ]);
 }
 function getBondingCurveDecoder() {
-  return (0, import_kit5.getStructDecoder)([
-    ["virtualTokenReserves", (0, import_kit5.getU64Decoder)()],
-    ["virtualSolReserves", (0, import_kit5.getU64Decoder)()],
-    ["realTokenReserves", (0, import_kit5.getU64Decoder)()],
-    ["realSolReserves", (0, import_kit5.getU64Decoder)()],
-    ["tokenTotalSupply", (0, import_kit5.getU64Decoder)()],
-    ["complete", (0, import_kit5.getBooleanDecoder)()],
-    ["creator", (0, import_kit5.getAddressDecoder)()]
+  return (0, import_kit6.getStructDecoder)([
+    ["virtualTokenReserves", (0, import_kit6.getU64Decoder)()],
+    ["virtualSolReserves", (0, import_kit6.getU64Decoder)()],
+    ["realTokenReserves", (0, import_kit6.getU64Decoder)()],
+    ["realSolReserves", (0, import_kit6.getU64Decoder)()],
+    ["tokenTotalSupply", (0, import_kit6.getU64Decoder)()],
+    ["complete", (0, import_kit6.getBooleanDecoder)()],
+    ["creator", (0, import_kit6.getAddressDecoder)()]
   ]);
 }
 function getGlobalAccountDecoder() {
-  return (0, import_kit5.getStructDecoder)([
-    ["initialized", (0, import_kit5.getBooleanDecoder)()],
-    ["authority", (0, import_kit5.getAddressDecoder)()],
-    ["feeRecipient", (0, import_kit5.getAddressDecoder)()],
-    ["initialVirtualTokenReserves", (0, import_kit5.getU64Decoder)()],
-    ["initialVirtualSolReserves", (0, import_kit5.getU64Decoder)()],
-    ["initialRealTokenReserves", (0, import_kit5.getU64Decoder)()],
-    ["tokenTotalSupply", (0, import_kit5.getU64Decoder)()],
-    ["feeBasisPoints", (0, import_kit5.getU64Decoder)()],
-    ["withdrawAuthority", (0, import_kit5.getAddressDecoder)()],
-    ["enableMigrate", (0, import_kit5.getBooleanDecoder)()],
-    ["poolMigrationFee", (0, import_kit5.getU64Decoder)()],
-    ["creatorFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
-    ["feeRecipients", (0, import_kit5.getArrayDecoder)((0, import_kit5.getAddressDecoder)(), { size: 7 })],
+  return (0, import_kit6.getStructDecoder)([
+    ["initialized", (0, import_kit6.getBooleanDecoder)()],
+    ["authority", (0, import_kit6.getAddressDecoder)()],
+    ["feeRecipient", (0, import_kit6.getAddressDecoder)()],
+    ["initialVirtualTokenReserves", (0, import_kit6.getU64Decoder)()],
+    ["initialVirtualSolReserves", (0, import_kit6.getU64Decoder)()],
+    ["initialRealTokenReserves", (0, import_kit6.getU64Decoder)()],
+    ["tokenTotalSupply", (0, import_kit6.getU64Decoder)()],
+    ["feeBasisPoints", (0, import_kit6.getU64Decoder)()],
+    ["withdrawAuthority", (0, import_kit6.getAddressDecoder)()],
+    ["enableMigrate", (0, import_kit6.getBooleanDecoder)()],
+    ["poolMigrationFee", (0, import_kit6.getU64Decoder)()],
+    ["creatorFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
+    ["feeRecipients", (0, import_kit6.getArrayDecoder)((0, import_kit6.getAddressDecoder)(), { size: 7 })],
     // Fixed array of 7 Pubkeys
-    ["setCreatorAuthority", (0, import_kit5.getAddressDecoder)()],
-    ["adminSetCreatorAuthority", (0, import_kit5.getAddressDecoder)()]
+    ["setCreatorAuthority", (0, import_kit6.getAddressDecoder)()],
+    ["adminSetCreatorAuthority", (0, import_kit6.getAddressDecoder)()]
   ]);
 }
 function getGlobalConfigDecoder() {
-  return (0, import_kit5.getStructDecoder)([
-    ["admin", (0, import_kit5.getAddressDecoder)()],
-    ["lpFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
-    ["protocolFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
-    ["disableFlags", (0, import_kit5.getU8Decoder)()],
-    ["protocolFeeRecipients", (0, import_kit5.getArrayDecoder)((0, import_kit5.getAddressDecoder)(), { size: 8 })],
+  return (0, import_kit6.getStructDecoder)([
+    ["admin", (0, import_kit6.getAddressDecoder)()],
+    ["lpFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
+    ["protocolFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
+    ["disableFlags", (0, import_kit6.getU8Decoder)()],
+    ["protocolFeeRecipients", (0, import_kit6.getArrayDecoder)((0, import_kit6.getAddressDecoder)(), { size: 8 })],
     // Fixed array of 8 Pubkeys
-    ["coinCreatorFeeBasisPoints", (0, import_kit5.getU64Decoder)()],
-    ["adminSetCoinCreatorAuthority", (0, import_kit5.getAddressDecoder)()]
+    ["coinCreatorFeeBasisPoints", (0, import_kit6.getU64Decoder)()],
+    ["adminSetCoinCreatorAuthority", (0, import_kit6.getAddressDecoder)()]
   ]);
 }
 
 // src/utils/quote/pumpfun/utils.ts
 var import_token2 = require("@solana-program/token");
-var PUMP_FUN_PROGRAM_ADDRESS = (0, import_kit6.address)("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
-var PUMP_FUN_AMM_PROGRAM_ADDRESS = (0, import_kit6.address)("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
-var WRAPPED_NATIVE_TOKEN_PUBKEY = (0, import_kit6.address)("So11111111111111111111111111111111111111112");
-var GLOBAL_CONFIG_AMM = (0, import_kit6.address)("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
+var PUMP_FUN_PROGRAM_ADDRESS = (0, import_kit7.address)("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
+var PUMP_FUN_AMM_PROGRAM_ADDRESS = (0, import_kit7.address)("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
+var WRAPPED_NATIVE_TOKEN_PUBKEY = (0, import_kit7.address)("So11111111111111111111111111111111111111112");
+var GLOBAL_CONFIG_AMM = (0, import_kit7.address)("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
 var ANCHOR_DISCRIMINATOR_SIZE = 8;
 var globalAccountCache = null;
 var globalConfigCache = null;
 var migratedPoolCache = /* @__PURE__ */ new Map();
 var poolTokensInfoCache = /* @__PURE__ */ new Map();
 async function findBondingCurvePda(tokenMint) {
-  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_PROGRAM_ADDRESS,
-    seeds: [new TextEncoder().encode("bonding-curve"), (0, import_kit6.getAddressEncoder)().encode(tokenMint)]
+    seeds: [new TextEncoder().encode("bonding-curve"), (0, import_kit7.getAddressEncoder)().encode(tokenMint)]
   });
   return pda;
 }
 async function findGlobalAccountPda() {
-  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_PROGRAM_ADDRESS,
     seeds: [new TextEncoder().encode("global")]
   });
   return pda;
 }
 async function findPoolAuthorityPdaAmm(mint) {
-  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_PROGRAM_ADDRESS,
-    seeds: [new TextEncoder().encode("pool-authority"), (0, import_kit6.getAddressEncoder)().encode(mint)]
+    seeds: [new TextEncoder().encode("pool-authority"), (0, import_kit7.getAddressEncoder)().encode(mint)]
   });
   return pda;
 }
 async function findPoolPdaAmm(poolAuthority, baseMint, quoteMint) {
-  const [pda] = await (0, import_kit6.getProgramDerivedAddress)({
+  const [pda] = await (0, import_kit7.getProgramDerivedAddress)({
     programAddress: PUMP_FUN_AMM_PROGRAM_ADDRESS,
     seeds: [
       new TextEncoder().encode("pool"),
       new Uint8Array([0, 0]),
       // Pool type bytes
-      (0, import_kit6.getAddressEncoder)().encode(poolAuthority),
-      (0, import_kit6.getAddressEncoder)().encode(baseMint),
-      (0, import_kit6.getAddressEncoder)().encode(quoteMint)
+      (0, import_kit7.getAddressEncoder)().encode(poolAuthority),
+      (0, import_kit7.getAddressEncoder)().encode(baseMint),
+      (0, import_kit7.getAddressEncoder)().encode(quoteMint)
     ]
   });
   return pda;
@@ -5327,7 +5451,7 @@ async function getPumpFunBondingCurve(tokenMint) {
   const rpc = getDefaultSolanaRPC();
   try {
     const pda = await findBondingCurvePda(tokenMint);
-    const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, pda);
+    const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, pda);
     if (!encodedAccount.exists) {
       throw new Error(`Bonding curve account not found for token mint: ${tokenMint}`);
     }
@@ -5351,7 +5475,7 @@ async function getPumpFunGlobalAccount() {
   }
   const rpc = getDefaultSolanaRPC();
   const pda = await findGlobalAccountPda();
-  const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, pda);
+  const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, pda);
   if (!encodedAccount.exists) {
     throw new Error(`GlobalAccount not found: ${pda}`);
   }
@@ -5378,7 +5502,7 @@ async function getPumpFunGlobalConfig() {
     return globalConfigCache.data;
   }
   const rpc = getDefaultSolanaRPC();
-  const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, GLOBAL_CONFIG_AMM);
+  const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, GLOBAL_CONFIG_AMM);
   if (!encodedAccount.exists) {
     throw new Error(`GlobalConfig account not found: ${GLOBAL_CONFIG_AMM}`);
   }
@@ -5408,7 +5532,7 @@ async function getPumpFunMigratedPool(baseMint) {
   try {
     const poolAuthorityPda = await findPoolAuthorityPdaAmm(baseMint);
     const poolPda = await findPoolPdaAmm(poolAuthorityPda, baseMint, WRAPPED_NATIVE_TOKEN_PUBKEY);
-    const encodedAccount = await (0, import_kit6.fetchEncodedAccount)(rpc, poolPda);
+    const encodedAccount = await (0, import_kit7.fetchEncodedAccount)(rpc, poolPda);
     if (!encodedAccount.exists) {
       throw new Error(`Migrated pool not found for token mint: ${baseMint}`);
     }
@@ -5437,7 +5561,7 @@ async function getPoolTokensInfo(poolBaseTokenAccount, poolQuoteTokenAccount) {
     return cached.data;
   }
   const rpc = getDefaultSolanaRPC();
-  const accountsInfo = await (0, import_kit6.fetchEncodedAccounts)(rpc, [poolBaseTokenAccount, poolQuoteTokenAccount]);
+  const accountsInfo = await (0, import_kit7.fetchEncodedAccounts)(rpc, [poolBaseTokenAccount, poolQuoteTokenAccount]);
   const baseAccountInfo = accountsInfo[0];
   if (!baseAccountInfo || !baseAccountInfo.exists) {
     throw new Error(`Base token account not found: ${poolBaseTokenAccount}`);
@@ -5452,22 +5576,22 @@ async function getPoolTokensInfo(poolBaseTokenAccount, poolQuoteTokenAccount) {
     mint: baseDecoded.mint,
     owner: baseDecoded.owner,
     amount: baseDecoded.amount,
-    delegate: (0, import_kit6.unwrapOption)(baseDecoded.delegate),
+    delegate: (0, import_kit7.unwrapOption)(baseDecoded.delegate),
     state: baseDecoded.state,
-    isNative: (0, import_kit6.unwrapOption)(baseDecoded.isNative),
+    isNative: (0, import_kit7.unwrapOption)(baseDecoded.isNative),
     delegatedAmount: baseDecoded.delegatedAmount,
-    closeAuthority: (0, import_kit6.unwrapOption)(baseDecoded.closeAuthority)
+    closeAuthority: (0, import_kit7.unwrapOption)(baseDecoded.closeAuthority)
   };
   const quoteDecoded = tokenDecoder.decode(quoteAccountInfo.data);
   const quoteTokenAccount = {
     mint: quoteDecoded.mint,
     owner: quoteDecoded.owner,
     amount: quoteDecoded.amount,
-    delegate: (0, import_kit6.unwrapOption)(quoteDecoded.delegate),
+    delegate: (0, import_kit7.unwrapOption)(quoteDecoded.delegate),
     state: quoteDecoded.state,
-    isNative: (0, import_kit6.unwrapOption)(quoteDecoded.isNative),
+    isNative: (0, import_kit7.unwrapOption)(quoteDecoded.isNative),
     delegatedAmount: quoteDecoded.delegatedAmount,
-    closeAuthority: (0, import_kit6.unwrapOption)(quoteDecoded.closeAuthority)
+    closeAuthority: (0, import_kit7.unwrapOption)(quoteDecoded.closeAuthority)
   };
   poolTokensInfoCache.set(cacheKey, {
     data: [baseTokenAccount, quoteTokenAccount],
@@ -5688,8 +5812,8 @@ function estimatePumpFunAmm(baseToken, quoteToken, globalConfig, amount, tradeTy
 // src/utils/quote/pumpfun/index.ts
 var PumpFunQuoteProvider = class {
   async getQuote(raydiumParams) {
-    const inputMint = (0, import_kit7.address)(raydiumParams.inputMint);
-    const outputMint = (0, import_kit7.address)(raydiumParams.outputMint);
+    const inputMint = (0, import_kit8.address)(raydiumParams.inputMint);
+    const outputMint = (0, import_kit8.address)(raydiumParams.outputMint);
     const [inputBondingCurve, outputBondingCurve] = await this.getTokensBondingCurve(inputMint, outputMint);
     const { bondingCurve, isInputPrebonded } = this.ensureSinglePrebondedToken(inputBondingCurve, outputBondingCurve);
     let isInputSol = inputMint === NATIVE_SOLANA_TOKEN_ADDRESS || inputMint === WRAPPED_SOL_MINT_ADDRESS;
@@ -6724,7 +6848,7 @@ var BaseSDK = class _BaseSDK {
   static async makeRequest(url, body) {
     const response = await fetch(url, {
       method: "POST",
-      headers: { "Content-Type": "application/json", "x-dev-access": DEV_ACCESS_KEY },
+      headers: withAuctioneerHeaders({ "Content-Type": "application/json" }),
       body
     });
     console.debug(`url`, url, `body`, body);
@@ -6796,26 +6920,27 @@ var BaseSDK = class _BaseSDK {
 };
 
 // src/core/solana/dca/create-order.ts
-var import_kit8 = require("@solana/kit");
+var import_kit9 = require("@solana/kit");
 init_constants();
 var import_token3 = require("@solana-program/token");
 var import_system2 = require("@solana-program/system");
 async function getSolanaDcaSingleChainOrderInstructions(order, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit8.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderSigner = await (0, import_kit8.generateKeyPairSigner)();
-  const signer = (0, import_kit8.createNoopSigner)(order.user);
-  let tokenInMint = (0, import_kit8.address)(order.tokenIn);
+  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await (0, import_kit9.generateKeyPairSigner)();
+  const userSigner = (0, import_kit9.createNoopSigner)(order.user);
+  const feePayerSigner = resolveSolanaFeePayer(userSigner, options?.feePayer);
+  let tokenInMint = (0, import_kit9.address)(order.tokenIn);
   const { secretHash, secretNumber } = genSecretHashAndNumber(order);
-  const orderUserAddress = (0, import_kit8.address)(order.user);
+  const orderUserAddress = (0, import_kit9.address)(order.user);
   const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
   if (spendingNative) {
     tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
   }
   const tokenMintProgram = await (0, import_token3.fetchMint)(rpc, tokenInMint);
-  const guardAddress = (0, import_kit8.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
-  const addressEncoder = (0, import_kit8.getAddressEncoder)();
+  const guardAddress = (0, import_kit9.address)(SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */]);
+  const addressEncoder = (0, import_kit9.getAddressEncoder)();
   const instructions = [];
-  const [tokenInProgramAccount] = await (0, import_kit8.getProgramDerivedAddress)({
+  const [tokenInProgramAccount] = await (0, import_kit9.getProgramDerivedAddress)({
     programAddress: import_token3.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -6823,10 +6948,10 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit8.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit9.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createAccountIx = await (0, import_token3.getCreateAssociatedTokenInstructionAsync)({
-      payer: signer,
+      payer: feePayerSigner,
       ata: tokenInProgramAccount,
       owner: orderUserAddress,
       mint: tokenMintProgram.address,
@@ -6839,7 +6964,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     const transferIx = (0, import_system2.getTransferSolInstruction)({
       amount: totalAmountIn,
       destination: userTokenInAccount.address,
-      source: signer
+      source: userSigner
     });
     instructions.push(transferIx);
     const syncNativeIx = (0, import_token3.getSyncNativeInstruction)({
@@ -6848,7 +6973,7 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     instructions.push(syncNativeIx);
   }
   const createDcaOrderIx = await getCreateDcaOrderInstructionAsync({
-    user: signer,
+    user: userSigner,
     order: orderSigner,
     guard: guardAddress,
     tokenInMint,
@@ -6864,16 +6989,26 @@ async function getSolanaDcaSingleChainOrderInstructions(order, options) {
     // TODO: Implement extra transfers
   });
   instructions.push(createDcaOrderIx);
+  const tip = resolveSolanaTip(options);
+  if (tip) {
+    instructions.push(
+      (0, import_system2.getTransferSolInstruction)({
+        source: feePayerSigner,
+        destination: tip.account,
+        amount: tip.lamports
+      })
+    );
+  }
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit8.pipe)(
-    (0, import_kit8.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit8.setTransactionMessageFeePayerSigner)(signer, tx),
-    (tx) => (0, import_kit8.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit8.appendTransactionMessageInstructions)(instructions, tx),
-    (tx) => (0, import_kit8.addSignersToTransactionMessage)([orderSigner], tx)
+  const txMessage = (0, import_kit9.pipe)(
+    (0, import_kit9.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit9.setTransactionMessageFeePayerSigner)(feePayerSigner, tx),
+    (tx) => (0, import_kit9.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit9.appendTransactionMessageInstructions)(instructions, tx),
+    (tx) => (0, import_kit9.addSignersToTransactionMessage)([orderSigner], tx)
   );
-  const partiallySignedTransaction = await (0, import_kit8.partiallySignTransactionMessageWithSigners)(txMessage);
-  const txBytes = (0, import_kit8.getTransactionCodec)().encode(partiallySignedTransaction);
+  const partiallySignedTransaction = await (0, import_kit9.partiallySignTransactionMessageWithSigners)(txMessage);
+  const txBytes = (0, import_kit9.getTransactionCodec)().encode(partiallySignedTransaction);
   return {
     orderAddress: orderSigner.address,
     txBytes,
@@ -6999,9 +7134,7 @@ init_constants();
 async function fetchSiweMessage(params) {
   const url = `${AUCTIONEER_URL}/siwe?wallet=${params.wallet}&chainId=${params.chainId}`;
   const response = await fetch(url, {
-    headers: {
-      "x-dev-access": DEV_ACCESS_KEY
-    }
+    headers: withAuctioneerHeaders()
   });
   if (!response.ok) {
     throw new Error(`Failed to fetch SIWE message: ${response.status} ${response.statusText}`);
@@ -7014,9 +7147,9 @@ async function fetchJWTToken(params, token) {
   const response = await fetch(url, {
     method: "POST",
     body: JSON.stringify(params),
-    headers: {
+    headers: withAuctioneerHeaders({
       Authorization: `Bearer ${token}`
-    }
+    })
   });
   if (!response.ok) {
     throw new Error(`Failed to fetch JWT token: ${response.status} ${response.statusText}`);
@@ -7182,15 +7315,15 @@ var EVMSDK = class extends BaseSDK {
 };
 
 // src/core/solana/sdk.ts
-var import_kit11 = require("@solana/kit");
+var import_kit12 = require("@solana/kit");
 
 // src/core/solana/cancel-order.ts
-var import_kit9 = require("@solana/kit");
+var import_kit10 = require("@solana/kit");
 var import_token4 = require("@solana-program/token");
 init_constants();
 async function cancelSingleChainOrderInstructions(orderAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = (0, import_kit9.address)(orderAddress);
+  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = (0, import_kit10.address)(orderAddress);
   const chainOrder = await fetchMaybeLimitOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7199,8 +7332,8 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
   const orderUserAddress = chainOrder.data.user;
   const tokenInMint = chainOrder.data.tokenInMint;
   const tokenMintProgram = await (0, import_token4.fetchMint)(rpc, tokenInMint);
-  const addressEncoder = (0, import_kit9.getAddressEncoder)();
-  const [tokenInProgramAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+  const addressEncoder = (0, import_kit10.getAddressEncoder)();
+  const [tokenInProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -7209,7 +7342,7 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
     ]
   });
   const guardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
-  const [guardProgramAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+  const [guardProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       // Owner
@@ -7220,12 +7353,12 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit9.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit10.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createTokenIx = await (0, import_token4.getCreateAssociatedTokenInstructionAsync)({
       mint: tokenInMint,
       owner: orderUserAddress,
-      payer: (0, import_kit9.createNoopSigner)(orderUserAddress),
+      payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
       tokenProgram: tokenMintProgram.programAddress
     });
     instructions.push(createTokenIx);
@@ -7237,43 +7370,43 @@ async function cancelSingleChainOrderInstructions(orderAddress, options) {
     userTokenInAccount: userTokenInAccount.address,
     guardTokenInAccount: guardProgramAccount,
     tokenInProgram: tokenMintProgram.programAddress,
-    signer: (0, import_kit9.createNoopSigner)(orderUserAddress),
+    signer: (0, import_kit10.createNoopSigner)(orderUserAddress),
     user: orderUserAddress
   });
   instructions.push(cancelLimitOrderIx);
   return instructions;
 }
 async function cancelCrossChainOrderInstructionsAsBytes(orderAddress, signerAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
   const instructions = await cancelCrossChainOrderInstructions(orderAddress, options);
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit9.pipe)(
-    (0, import_kit9.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit9.setTransactionMessageFeePayerSigner)((0, import_kit9.createNoopSigner)((0, import_kit9.address)(signerAddress)), tx),
-    (tx) => (0, import_kit9.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit9.appendTransactionMessageInstructions)(instructions, tx)
+  const txMessage = (0, import_kit10.pipe)(
+    (0, import_kit10.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit10.setTransactionMessageFeePayerSigner)((0, import_kit10.createNoopSigner)((0, import_kit10.address)(signerAddress)), tx),
+    (tx) => (0, import_kit10.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit10.appendTransactionMessageInstructions)(instructions, tx)
   );
-  const compiledTxMessage = (0, import_kit9.compileTransactionMessage)(txMessage);
-  const txBytes = (0, import_kit9.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
+  const compiledTxMessage = (0, import_kit10.compileTransactionMessage)(txMessage);
+  const txBytes = (0, import_kit10.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
   return { versionedMessageBytes: txBytes };
 }
 async function cancelSingleChainOrderInstructionsAsBytes(orderAddress, signerAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
   const instructions = await cancelSingleChainOrderInstructions(orderAddress, options);
   const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-  const txMessage = (0, import_kit9.pipe)(
-    (0, import_kit9.createTransactionMessage)({ version: 0 }),
-    (tx) => (0, import_kit9.setTransactionMessageFeePayerSigner)((0, import_kit9.createNoopSigner)((0, import_kit9.address)(signerAddress)), tx),
-    (tx) => (0, import_kit9.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-    (tx) => (0, import_kit9.appendTransactionMessageInstructions)(instructions, tx)
+  const txMessage = (0, import_kit10.pipe)(
+    (0, import_kit10.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit10.setTransactionMessageFeePayerSigner)((0, import_kit10.createNoopSigner)((0, import_kit10.address)(signerAddress)), tx),
+    (tx) => (0, import_kit10.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit10.appendTransactionMessageInstructions)(instructions, tx)
   );
-  const compiledTxMessage = (0, import_kit9.compileTransactionMessage)(txMessage);
-  const txBytes = (0, import_kit9.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
+  const compiledTxMessage = (0, import_kit10.compileTransactionMessage)(txMessage);
+  const txBytes = (0, import_kit10.getCompiledTransactionMessageEncoder)().encode(compiledTxMessage);
   return { versionedMessageBytes: txBytes };
 }
 async function cancelCrossChainOrderInstructions(orderAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit9.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = (0, import_kit9.address)(orderAddress);
+  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = (0, import_kit10.address)(orderAddress);
   const chainOrder = await fetchMaybeOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7281,11 +7414,11 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   const instructions = [];
   const orderUserAddress = chainOrder.data.user;
   const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
-  const addressEncoder = (0, import_kit9.getAddressEncoder)();
+  const addressEncoder = (0, import_kit10.getAddressEncoder)();
   const isRecoveringTokenIn = chainOrder.data.lockedStablecoins === 0n;
-  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : (0, import_kit9.address)(SOLANA_MINT_TOKEN.mint);
+  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : (0, import_kit10.address)(SOLANA_MINT_TOKEN.mint);
   const recoverTokenMintProgram = await (0, import_token4.fetchMint)(rpc, recoverTokenMint);
-  const [userRecoveredTokenAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+  const [userRecoveredTokenAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -7293,7 +7426,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(recoverTokenMint)
     ]
   });
-  const [guardRecoveredTokenAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+  const [guardRecoveredTokenAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(guardAddress),
@@ -7301,10 +7434,10 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(recoverTokenMint)
     ]
   });
-  const userRecoveredTokenAccountInfo = await (0, import_kit9.fetchEncodedAccount)(rpc, userRecoveredTokenAccount);
+  const userRecoveredTokenAccountInfo = await (0, import_kit10.fetchEncodedAccount)(rpc, userRecoveredTokenAccount);
   if (!userRecoveredTokenAccountInfo.exists) {
     const createRecoveredTokenAccountIx = await (0, import_token4.getCreateAssociatedTokenInstructionAsync)({
-      payer: (0, import_kit9.createNoopSigner)(orderUserAddress),
+      payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
       ata: userRecoveredTokenAccount,
       owner: orderUserAddress,
       mint: recoverTokenMint,
@@ -7315,9 +7448,9 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
   let userCollateralTokenAccount;
   const willClaimCollateral = chainOrder.data.lockedCollateral > 0n;
   if (willClaimCollateral) {
-    const collateralTokenMint2 = (0, import_kit9.address)(SOLANA_MINT_TOKEN.mint);
+    const collateralTokenMint2 = (0, import_kit10.address)(SOLANA_MINT_TOKEN.mint);
     const collateralTokenMintProgram2 = await (0, import_token4.fetchMint)(rpc, collateralTokenMint2);
-    const [userCollateralAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+    const [userCollateralAccount] = await (0, import_kit10.getProgramDerivedAddress)({
       programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
       seeds: [
         addressEncoder.encode(orderUserAddress),
@@ -7326,10 +7459,10 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       ]
     });
     userCollateralTokenAccount = userCollateralAccount;
-    const userCollateralTokenAccountInfo = await (0, import_kit9.fetchEncodedAccount)(rpc, userCollateralTokenAccount);
+    const userCollateralTokenAccountInfo = await (0, import_kit10.fetchEncodedAccount)(rpc, userCollateralTokenAccount);
     if (!userCollateralTokenAccountInfo.exists) {
       const createCollateralTokenAccountIx = await (0, import_token4.getCreateAssociatedTokenInstructionAsync)({
-        payer: (0, import_kit9.createNoopSigner)(orderUserAddress),
+        payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
         ata: userCollateralTokenAccount,
         owner: orderUserAddress,
         mint: collateralTokenMint2,
@@ -7338,9 +7471,9 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
       instructions.push(createCollateralTokenAccountIx);
     }
   }
-  const collateralTokenMint = (0, import_kit9.address)(SOLANA_MINT_TOKEN.mint);
+  const collateralTokenMint = (0, import_kit10.address)(SOLANA_MINT_TOKEN.mint);
   const collateralTokenMintProgram = await (0, import_token4.fetchMint)(rpc, collateralTokenMint);
-  const [guardCollateralTokenAccount] = await (0, import_kit9.getProgramDerivedAddress)({
+  const [guardCollateralTokenAccount] = await (0, import_kit10.getProgramDerivedAddress)({
     programAddress: import_token4.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(guardAddress),
@@ -7360,7 +7493,7 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
     userCollateralTokenAccount,
     guardCollateralTokenAccount,
     collateralTokenProgram: collateralTokenMintProgram.programAddress,
-    signer: (0, import_kit9.createNoopSigner)(orderUserAddress)
+    signer: (0, import_kit10.createNoopSigner)(orderUserAddress)
   });
   instructions.push(cancelOrderIx);
   return instructions;
@@ -7370,12 +7503,12 @@ async function cancelCrossChainOrderInstructions(orderAddress, options) {
 var import_viem11 = require("viem");
 
 // src/core/solana/dca/cancel-order.ts
-var import_kit10 = require("@solana/kit");
+var import_kit11 = require("@solana/kit");
 var import_token5 = require("@solana-program/token");
 init_constants();
 async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
-  const rpc = options?.rpcUrl ? (0, import_kit10.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
-  const orderId = (0, import_kit10.address)(orderAddress);
+  const rpc = options?.rpcUrl ? (0, import_kit11.createSolanaRpc)(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = (0, import_kit11.address)(orderAddress);
   const chainOrder = await fetchMaybeDcaOrder(rpc, orderId);
   if (!chainOrder.exists) {
     throw new Error(`Order with address ${orderAddress} not found`);
@@ -7384,8 +7517,8 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
   const orderUserAddress = chainOrder.data.user;
   const tokenInMint = chainOrder.data.tokenInMint;
   const tokenMintProgram = await (0, import_token5.fetchMint)(rpc, tokenInMint);
-  const addressEncoder = (0, import_kit10.getAddressEncoder)();
-  const [tokenInProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const addressEncoder = (0, import_kit11.getAddressEncoder)();
+  const [tokenInProgramAccount] = await (0, import_kit11.getProgramDerivedAddress)({
     programAddress: import_token5.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       addressEncoder.encode(orderUserAddress),
@@ -7394,7 +7527,7 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
     ]
   });
   const guardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[7565164 /* Solana */];
-  const [guardProgramAccount] = await (0, import_kit10.getProgramDerivedAddress)({
+  const [guardProgramAccount] = await (0, import_kit11.getProgramDerivedAddress)({
     programAddress: import_token5.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [
       // Owner
@@ -7405,19 +7538,19 @@ async function cancelDcaSingleChainOrderInstructions(orderAddress, options) {
       addressEncoder.encode(tokenInMint)
     ]
   });
-  const userTokenInAccount = await (0, import_kit10.fetchEncodedAccount)(rpc, tokenInProgramAccount);
+  const userTokenInAccount = await (0, import_kit11.fetchEncodedAccount)(rpc, tokenInProgramAccount);
   if (!userTokenInAccount.exists) {
     const createTokenIx = await (0, import_token5.getCreateAssociatedTokenInstructionAsync)({
       mint: tokenInMint,
       owner: orderUserAddress,
-      payer: (0, import_kit10.createNoopSigner)(orderUserAddress),
+      payer: (0, import_kit11.createNoopSigner)(orderUserAddress),
       tokenProgram: tokenMintProgram.programAddress
     });
     instructions.push(createTokenIx);
   }
   const cancelLimitOrderIx = getCancelDcaOrderInstruction({
     user: orderUserAddress,
-    signer: (0, import_kit10.createNoopSigner)(orderUserAddress),
+    signer: (0, import_kit11.createNoopSigner)(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,
@@ -7461,17 +7594,17 @@ var SolanaSDK = class extends BaseSDK {
     const instructions = await cancelCrossChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
     const signerKeyPair = await this.getUserCryptoKeypair();
-    const noopSigner = (0, import_kit11.createNoopSigner)(signer.address);
+    const noopSigner = (0, import_kit12.createNoopSigner)(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
-    const transactionMessage = (0, import_kit11.pipe)(
-      (0, import_kit11.createTransactionMessage)({ version: 0 }),
-      (tx) => (0, import_kit11.setTransactionMessageFeePayerSigner)(noopSigner, tx),
-      (tx) => (0, import_kit11.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-      (tx) => (0, import_kit11.appendTransactionMessageInstructions)(instructions, tx)
+    const transactionMessage = (0, import_kit12.pipe)(
+      (0, import_kit12.createTransactionMessage)({ version: 0 }),
+      (tx) => (0, import_kit12.setTransactionMessageFeePayerSigner)(noopSigner, tx),
+      (tx) => (0, import_kit12.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+      (tx) => (0, import_kit12.appendTransactionMessageInstructions)(instructions, tx)
     );
-    const myTx = (0, import_kit11.compileTransaction)(transactionMessage);
-    const signature = await (0, import_kit11.signTransaction)([signerKeyPair], myTx);
-    (0, import_kit11.assertIsSendableTransaction)(signature);
+    const myTx = (0, import_kit12.compileTransaction)(transactionMessage);
+    const signature = await (0, import_kit12.signTransaction)([signerKeyPair], myTx);
+    (0, import_kit12.assertIsSendableTransaction)(signature);
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment
     });
@@ -7481,17 +7614,17 @@ var SolanaSDK = class extends BaseSDK {
     const instructions = await cancelSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
     const signerKeyPair = await this.getUserCryptoKeypair();
-    const noopSigner = (0, import_kit11.createNoopSigner)(signer.address);
+    const noopSigner = (0, import_kit12.createNoopSigner)(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
-    const transactionMessage = (0, import_kit11.pipe)(
-      (0, import_kit11.createTransactionMessage)({ version: 0 }),
-      (tx) => (0, import_kit11.setTransactionMessageFeePayerSigner)(noopSigner, tx),
-      (tx) => (0, import_kit11.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-      (tx) => (0, import_kit11.appendTransactionMessageInstructions)(instructions, tx)
+    const transactionMessage = (0, import_kit12.pipe)(
+      (0, import_kit12.createTransactionMessage)({ version: 0 }),
+      (tx) => (0, import_kit12.setTransactionMessageFeePayerSigner)(noopSigner, tx),
+      (tx) => (0, import_kit12.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+      (tx) => (0, import_kit12.appendTransactionMessageInstructions)(instructions, tx)
     );
-    const myTx = (0, import_kit11.compileTransaction)(transactionMessage);
-    const signature = await (0, import_kit11.signTransaction)([signerKeyPair], myTx);
-    (0, import_kit11.assertIsSendableTransaction)(signature);
+    const myTx = (0, import_kit12.compileTransaction)(transactionMessage);
+    const signature = await (0, import_kit12.signTransaction)([signerKeyPair], myTx);
+    (0, import_kit12.assertIsSendableTransaction)(signature);
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment
     });
@@ -7506,9 +7639,9 @@ var SolanaSDK = class extends BaseSDK {
    * @private
    */
   async getUserCryptoKeypair() {
-    const encoder = (0, import_kit11.getBase58Encoder)();
+    const encoder = (0, import_kit12.getBase58Encoder)();
     const bytesWithPrefix = encoder.encode(this.config.privateKey);
-    return (0, import_kit11.createKeyPairFromBytes)(bytesWithPrefix);
+    return (0, import_kit12.createKeyPairFromBytes)(bytesWithPrefix);
   }
   /**
    * Creates a KeyPairSigner from the user's crypto keypair
@@ -7520,7 +7653,7 @@ var SolanaSDK = class extends BaseSDK {
    */
   async getUserSigner() {
     const signer = await this.getUserCryptoKeypair();
-    return (0, import_kit11.createSignerFromKeyPair)(signer);
+    return (0, import_kit12.createSignerFromKeyPair)(signer);
   }
   async authenticate(token) {
     const wallet = await this.getUserAddress();
@@ -7529,10 +7662,10 @@ var SolanaSDK = class extends BaseSDK {
       wallet
     });
     const message = response.data;
-    const signableMessage = (0, import_kit11.createSignableMessage)(message);
+    const signableMessage = (0, import_kit12.createSignableMessage)(message);
     const signer = await this.getUserSigner();
     const signatureArray = await signer.signMessages([signableMessage]);
-    const signatureBytes = signatureArray.map((signature) => signature[(0, import_kit11.address)(wallet)])[0];
+    const signatureBytes = signatureArray.map((signature) => signature[(0, import_kit12.address)(wallet)])[0];
     if (!signatureBytes) {
       throw new Error("No signature bytes found");
     }
@@ -7563,10 +7696,10 @@ var SolanaSDK = class extends BaseSDK {
   async prepareCrossChainOrder(order) {
     const signerKeyPair = await this.getUserCryptoKeypair();
     const { orderAddress, txBytes } = await getSolanaCrossChainOrderInstructions(order);
-    const transactionCodec = (0, import_kit11.getTransactionCodec)();
+    const transactionCodec = (0, import_kit12.getTransactionCodec)();
     const tx = transactionCodec.decode(txBytes);
-    const signedTx = await (0, import_kit11.signTransaction)([signerKeyPair], tx);
-    const encodedTransaction = (0, import_kit11.getBase64EncodedWireTransaction)(signedTx);
+    const signedTx = await (0, import_kit12.signTransaction)([signerKeyPair], tx);
+    const encodedTransaction = (0, import_kit12.getBase64EncodedWireTransaction)(signedTx);
     await this.client.rpc.sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: "base64" }).send();
     return {
       order,
@@ -7578,10 +7711,10 @@ var SolanaSDK = class extends BaseSDK {
   async prepareSingleChainOrder(order) {
     const signerKeyPair = await this.getUserCryptoKeypair();
     const { orderAddress, txBytes, secretNumber } = await getSolanaSingleChainOrderInstructions(order);
-    const transactionCodec = (0, import_kit11.getTransactionCodec)();
+    const transactionCodec = (0, import_kit12.getTransactionCodec)();
     const tx = transactionCodec.decode(txBytes);
-    const signedTx = await (0, import_kit11.partiallySignTransaction)([signerKeyPair], tx);
-    const encodedTransaction = (0, import_kit11.getBase64EncodedWireTransaction)(signedTx);
+    const signedTx = await (0, import_kit12.partiallySignTransaction)([signerKeyPair], tx);
+    const encodedTransaction = (0, import_kit12.getBase64EncodedWireTransaction)(signedTx);
     await this.client.rpc.sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: "base64" }).send();
     return {
       order,
@@ -7595,17 +7728,17 @@ var SolanaSDK = class extends BaseSDK {
     const instructions = await cancelDcaSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
     const signer = await this.getUserSigner();
     const signerKeyPair = await this.getUserCryptoKeypair();
-    const noopSigner = (0, import_kit11.createNoopSigner)(signer.address);
+    const noopSigner = (0, import_kit12.createNoopSigner)(signer.address);
     const { value: latestBlockhash } = await this.client.rpc.getLatestBlockhash({ commitment: this.config.commitment }).send();
-    const transactionMessage = (0, import_kit11.pipe)(
-      (0, import_kit11.createTransactionMessage)({ version: 0 }),
-      (tx) => (0, import_kit11.setTransactionMessageFeePayerSigner)(noopSigner, tx),
-      (tx) => (0, import_kit11.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
-      (tx) => (0, import_kit11.appendTransactionMessageInstructions)(instructions, tx)
+    const transactionMessage = (0, import_kit12.pipe)(
+      (0, import_kit12.createTransactionMessage)({ version: 0 }),
+      (tx) => (0, import_kit12.setTransactionMessageFeePayerSigner)(noopSigner, tx),
+      (tx) => (0, import_kit12.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+      (tx) => (0, import_kit12.appendTransactionMessageInstructions)(instructions, tx)
     );
-    const myTx = (0, import_kit11.compileTransaction)(transactionMessage);
-    const signature = await (0, import_kit11.signTransaction)([signerKeyPair], myTx);
-    (0, import_kit11.assertIsSendableTransaction)(signature);
+    const myTx = (0, import_kit12.compileTransaction)(transactionMessage);
+    const signature = await (0, import_kit12.signTransaction)([signerKeyPair], myTx);
+    (0, import_kit12.assertIsSendableTransaction)(signature);
     await this.client.sendAndConfirmTransaction(signature, {
       commitment: this.config.commitment
     });
@@ -7614,10 +7747,10 @@ var SolanaSDK = class extends BaseSDK {
   async prepareDcaSingleChainOrder(order) {
     const signerKeyPair = await this.getUserCryptoKeypair();
     const { orderAddress, txBytes, secretNumber } = await getSolanaDcaSingleChainOrderInstructions(order);
-    const transactionCodec = (0, import_kit11.getTransactionCodec)();
+    const transactionCodec = (0, import_kit12.getTransactionCodec)();
     const tx = transactionCodec.decode(txBytes);
-    const signedTx = await (0, import_kit11.partiallySignTransaction)([signerKeyPair], tx);
-    const encodedTransaction = (0, import_kit11.getBase64EncodedWireTransaction)(signedTx);
+    const signedTx = await (0, import_kit12.partiallySignTransaction)([signerKeyPair], tx);
+    const encodedTransaction = (0, import_kit12.getBase64EncodedWireTransaction)(signedTx);
     await this.client.rpc.sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: "base64" }).send();
     return {
       order,
@@ -7782,7 +7915,7 @@ async function fetchUserOrders(evmAddress, solAddress, suiAddress) {
   const url = `${AUCTIONEER_URL}/user_intent?${params.toString()}`;
   const response = await fetch(url, {
     method: "GET",
-    headers: { "Content-Type": "application/json", "x-dev-access": DEV_ACCESS_KEY }
+    headers: withAuctioneerHeaders({ "Content-Type": "application/json" })
   });
   if (!response.ok) {
     throw new Error(`Failed to fetch user orders: ${response.status} ${response.statusText}`);
@@ -7808,10 +7941,10 @@ var AuctioneerAPI = class {
     const url = `${AUCTIONEER_URL}/user_intent`;
     const response = await fetch(url, {
       method: "GET",
-      headers: {
+      headers: withAuctioneerHeaders({
         "Content-Type": "application/json",
         Authorization: `Bearer ${this.aggregatedToken}`
-      }
+      })
     });
     const data = await response.json();
     if (!data.success) {
@@ -8039,7 +8172,7 @@ function getInvalidateNoncesRawData(nonce) {
 }
 
 // src/core/solana/inspect.ts
-var import_kit12 = require("@solana/kit");
+var import_kit13 = require("@solana/kit");
 
 // src/utils/logger.ts
 init_errors();
@@ -8134,8 +8267,8 @@ var logger = Logger.getInstance();
 
 // src/core/solana/inspect.ts
 async function getSolanaOrdersWithLockedFunds(userAddress, config) {
-  const rpc = config?.rpcUrl ? (0, import_kit12.createSolanaRpc)(config.rpcUrl) : getDefaultSolanaRPC();
-  const programAccountAddress = (0, import_kit12.address)("DQZQGiVa1PBXesdbCRzmJpZ7AyntLXfAwP5Qty1hgFqQ");
+  const rpc = config?.rpcUrl ? (0, import_kit13.createSolanaRpc)(config.rpcUrl) : getDefaultSolanaRPC();
+  const programAccountAddress = (0, import_kit13.address)("DQZQGiVa1PBXesdbCRzmJpZ7AyntLXfAwP5Qty1hgFqQ");
   const programAccountsConfig = {
     encoding: "base64",
     filters: [
@@ -8753,14 +8886,14 @@ function createSolanaCrossChainOrderIntentRequest(params) {
     }
   };
 }
-async function generateSolanaSingleChainLimitOrderInstructions(order) {
-  return getSolanaSingleChainOrderInstructions(order);
+async function generateSolanaSingleChainLimitOrderInstructions(order, options) {
+  return getSolanaSingleChainOrderInstructions(order, options);
 }
-async function generateSolanaSingleChainDcaOrderInstructions(order) {
-  return getSolanaDcaSingleChainOrderInstructions(order);
+async function generateSolanaSingleChainDcaOrderInstructions(order, options) {
+  return getSolanaDcaSingleChainOrderInstructions(order, options);
 }
-async function generateSolanaCrossChainOrderInstructions(order) {
-  return getSolanaCrossChainOrderInstructions(order);
+async function generateSolanaCrossChainOrderInstructions(order, options) {
+  return getSolanaCrossChainOrderInstructions(order, options);
 }
 function generateSolanaLimitOrderSecretData(tokenOut, receiver, secretNumber, extraTransfers) {
   const secret = secretNumber || generateSolanaRandomSecretNumber();