sol-trade-sdk 0.1.0

package/dist/clients-VITWK7B6.mjs

@@ -0,0 +1,1370 @@
+import {
+  TradeError
+} from "./chunk-NEZDFAYA.mjs";
+import "./chunk-MMQAMIKR.mjs";
+
+// src/swqos/clients.ts
+function randomChoice(arr) {
+  const item = arr[Math.floor(Math.random() * arr.length)];
+  if (item === void 0) {
+    throw new Error("randomChoice called with empty array");
+  }
+  return item;
+}
+var MIN_TIP_JITO = 1e-5;
+var MIN_TIP_BLOXROUTE = 1e-4;
+var MIN_TIP_ZERO_SLOT = 1e-4;
+var MIN_TIP_TEMPORAL = 1e-4;
+var MIN_TIP_FLASH_BLOCK = 1e-4;
+var MIN_TIP_BLOCK_RAZOR = 1e-4;
+var MIN_TIP_NODE1 = 1e-4;
+var MIN_TIP_ASTRALANE = 1e-5;
+var MIN_TIP_HELIUS = 5e-6;
+var MIN_TIP_HELIUS_NORMAL = 2e-4;
+var MIN_TIP_STELLIUM = 1e-4;
+var MIN_TIP_LIGHTSPEED = 1e-4;
+var MIN_TIP_NEXT_BLOCK = 1e-3;
+var MIN_TIP_SOYAS = 1e-3;
+var MIN_TIP_SPEEDLANDING = 1e-3;
+var MIN_TIP_DEFAULT = 0;
+var JITO_TIP_ACCOUNTS = [
+  "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+  "HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe",
+  "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
+  "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
+  "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
+  "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
+  "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
+  "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT"
+];
+var ZERO_SLOT_TIP_ACCOUNTS = [
+  "Eb2KpSC8uMt9GmzyAEm5Eb1AAAgTjRaXWFjKyFXHZxF3",
+  "FCjUJZ1qozm1e8romw216qyfQMaaWKxWsuySnumVCCNe",
+  "ENxTEjSQ1YabmUpXAdCgevnHQ9MHdLv8tzFiuiYJqa13",
+  "6rYLG55Q9RpsPGvqdPNJs4z5WTxJVatMB8zV3WJhs5EK",
+  "Cix2bHfqPcKcM233mzxbLk14kSggUUiz2A87fJtGivXr"
+];
+var TEMPORAL_TIP_ACCOUNTS = [
+  "TEMPaMeCRFAS9EKF53Jd6KpHxgL47uWLcpFArU1Fanq",
+  "noz3jAjPiHuBPqiSPkkugaJDkJscPuRhYnSpbi8UvC4",
+  "noz3str9KXfpKknefHji8L1mPgimezaiUyCHYMDv1GE",
+  "noz6uoYCDijhu1V7cutCpwxNiSovEwLdRHPwmgCGDNo",
+  "noz9EPNcT7WH6Sou3sr3GGjHQYVkN3DNirpbvDkv9YJ",
+  "nozc5yT15LazbLTFVZzoNZCwjh3yUtW86LoUyqsBu4L",
+  "nozFrhfnNGoyqwVuwPAW4aaGqempx4PU6g6D9CJMv7Z",
+  "nozievPk7HyK1Rqy1MPJwVQ7qQg2QoJGyP71oeDwbsu",
+  "noznbgwYnBLDHu8wcQVCEw6kDrXkPdKkydGJGNXGvL7",
+  "nozNVWs5N8mgzuD3qigrCG2UoKxZttxzZ85pvAQVrbP",
+  "nozpEGbwx4BcGp6pvEdAh1JoC2CQGZdU6HbNP1v2p6P",
+  "nozrhjhkCr3zXT3BiT4WCodYCUFeQvcdUkM7MqhKqge",
+  "nozrwQtWhEdrA6W8dkbt9gnUaMs52PdAv5byipnadq3",
+  "nozUacTVWub3cL4mJmGCYjKZTnE9RbdY5AP46iQgbPJ",
+  "nozWCyTPppJjRuw2fpzDhhWbW355fzosWSzrrMYB1Qk",
+  "nozWNju6dY353eMkMqURqwQEoM3SFgEKC6psLCSfUne",
+  "nozxNBgWohjR75vdspfxR5H9ceC7XXH99xpxhVGt3Bb"
+];
+var FLASH_BLOCK_TIP_ACCOUNTS = [
+  "FLaShB3iXXTWE1vu9wQsChUKq3HFtpMAhb8kAh1pf1wi",
+  "FLashhsorBmM9dLpuq6qATawcpqk1Y2aqaZfkd48iT3W",
+  "FLaSHJNm5dWYzEgnHJWWJP5ccu128Mu61NJLxUf7mUXU",
+  "FLaSHR4Vv7sttd6TyDF4yR1bJyAxRwWKbohDytEMu3wL",
+  "FLASHRzANfcAKDuQ3RXv9hbkBy4WVEKDzoAgxJ56DiE4",
+  "FLasHstqx11M8W56zrSEqkCyhMCCpr6ze6Mjdvqope5s",
+  "FLAShWTjcweNT4NSotpjpxAkwxUr2we3eXQGhpTVzRwy",
+  "FLasHXTqrbNvpWFB6grN47HGZfK6pze9HLNTgbukfPSk",
+  "FLAShyAyBcKb39KPxSzXcepiS8iDYUhDGwJcJDPX4g2B",
+  "FLAsHZTRcf3Dy1APaz6j74ebdMC6Xx4g6i9YxjyrDybR"
+];
+var HELIUS_TIP_ACCOUNTS = [
+  "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
+  "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
+  "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
+  "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
+  "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
+  "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
+  "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
+  "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
+  "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
+  "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
+];
+var NODE1_TIP_ACCOUNTS = [
+  "node1PqAa3BWWzUnTHVbw8NJHC874zn9ngAkXjgWEej",
+  "node1UzzTxAAeBTpfZkQPJXBAqixsbdth11ba1NXLBG",
+  "node1Qm1bV4fwYnCurP8otJ9s5yrkPq7SPZ5uhj3Tsv",
+  "node1PUber6SFmSQgvf2ECmXsHP5o3boRSGhvJyPMX1",
+  "node1AyMbeqiVN6eoQzEAwCA6Pk826hrdqdAHR7cdJ3",
+  "node1YtWCoTwwVYTFLfS19zquRQzYX332hs1HEuRBjC"
+];
+var BLOCK_RAZOR_TIP_ACCOUNTS = [
+  "FjmZZrFvhnqqb9ThCuMVnENaM3JGVuGWNyCAxRJcFpg9",
+  "6No2i3aawzHsjtThw81iq1EXPJN6rh8eSJCLaYZfKDTG",
+  "A9cWowVAiHe9pJfKAj3TJiN9VpbzMUq6E4kEvf5mUT22",
+  "Gywj98ophM7GmkDdaWs4isqZnDdFCW7B46TXmKfvyqSm",
+  "68Pwb4jS7eZATjDfhmTXgRJjCiZmw1L7Huy4HNpnxJ3o",
+  "4ABhJh5rZPjv63RBJBuyWzBK3g9gWMUQdTZP2kiW31V9",
+  "B2M4NG5eyZp5SBQrSdtemzk5TqVuaWGQnowGaCBt8GyM",
+  "5jA59cXMKQqZAVdtopv8q3yyw9SYfiE3vUCbt7p8MfVf",
+  "5YktoWygr1Bp9wiS1xtMtUki1PeYuuzuCF98tqwYxf61",
+  "295Avbam4qGShBYK7E9H5Ldew4B3WyJGmgmXfiWdeeyV",
+  "EDi4rSy2LZgKJX74mbLTFk4mxoTgT6F7HxxzG2HBAFyK",
+  "BnGKHAC386n4Qmv9xtpBVbRaUTKixjBe3oagkPFKtoy6",
+  "Dd7K2Fp7AtoN8xCghKDRmyqr5U169t48Tw5fEd3wT9mq",
+  "AP6qExwrbRgBAVaehg4b5xHENX815sMabtBzUzVB4v8S"
+];
+var ASTRALANE_TIP_ACCOUNTS = [
+  "astrazznxsGUhWShqgNtAdfrzP2G83DzcWVJDxwV9bF",
+  "astra4uejePWneqNaJKuFFA8oonqCE1sqF6b45kDMZm",
+  "astra9xWY93QyfG6yM8zwsKsRodscjQ2uU2HKNL5prk",
+  "astraRVUuTHjpwEVvNBeQEgwYx9w9CFyfxjYoobCZhL",
+  "astraEJ2fEj8Xmy6KLG7B3VfbKfsHXhHrNdCQx7iGJK",
+  "astraubkDw81n4LuutzSQ8uzHCv4BhPVhfvTcYv8SKC",
+  "astraZW5GLFefxNPAatceHhYjfA1ciq9gvfEg2S47xk",
+  "astrawVNP4xDBKT7rAdxrLYiTSTdqtUr63fSMduivXK",
+  "AstrA1ejL4UeXC2SBP4cpeEmtcFPZVLxx3XGKXyCW6to",
+  "AsTra79FET4aCKWspPqeSFvjJNyp96SvAnrmyAxqg5b7",
+  "AstrABAu8CBTyuPXpV4eSCJ5fePEPnxN8NqBaPKQ9fHR",
+  "AsTRADtvb6tTmrsqULQ9Wji9PigDMjhfEMza6zkynEvV",
+  "AsTRAEoyMofR3vUPpf9k68Gsfb6ymTZttEtsAbv8Bk4d",
+  "AStrAJv2RN2hKCHxwUMtqmSxgdcNZbihCwc1mCSnG83W",
+  "Astran35aiQUF57XZsmkWMtNCtXGLzs8upfiqXxth2bz",
+  "AStRAnpi6kFrKypragExgeRoJ1QnKH7pbSjLAKQVWUum",
+  "ASTRaoF93eYt73TYvwtsv6fMWHWbGmMUZfVZPo3CRU9C"
+];
+var BLOXROUTE_TIP_ACCOUNTS = [
+  "HWEoBxYs7ssKuudEjzjmpfJVX7Dvi7wescFsVx2L5yoY",
+  "95cfoy472fcQHaw4tPGBTKpn6ZQnfEPfBgDQx6gcRmRg",
+  "3UQUKjhMKaY2S6bjcQD6yHB7utcZt5bfarRCmctpRtUd",
+  "FogxVNs6Mm2w9rnGL1vkARSwJxvLE8mujTv3LK8RnUhF"
+];
+var STELLIUM_TIP_ACCOUNTS = [
+  "ste11JV3MLMM7x7EJUM2sXcJC1H7F4jBLnP9a9PG8PH",
+  "ste11MWPjXCRfQryCshzi86SGhuXjF4Lv6xMXD2AoSt",
+  "ste11p5x8tJ53H1NbNQsRBg1YNRd4GcVpxtDw8PBpmb",
+  "ste11p7e2KLYou5bwtt35H7BM6uMdo4pvioGjJXKFcN",
+  "ste11TMV68LMi1BguM4RQujtbNCZvf1sjsASpqgAvSX"
+];
+var NEXT_BLOCK_TIP_ACCOUNTS = [
+  "NextbLoCkVtMGcV47JzewQdvBpLqT9TxQFozQkN98pE",
+  "NexTbLoCkWykbLuB1NkjXgFWkX9oAtcoagQegygXXA2",
+  "NeXTBLoCKs9F1y5PJS9CKrFNNLU1keHW71rfh7KgA1X",
+  "NexTBLockJYZ7QD7p2byrUa6df8ndV2WSd8GkbWqfbb",
+  "neXtBLock1LeC67jYd1QdAa32kbVeubsfPNTJC1V5At",
+  "nEXTBLockYgngeRmRrjDV31mGSekVPqZoMGhQEZtPVG",
+  "NEXTbLoCkB51HpLBLojQfpyVAMorm3zzKg7w9NFdqid",
+  "nextBLoCkPMgmG8ZgJtABeScP35qLa2AMCNKntAP7Xc"
+];
+var SOYAS_TIP_ACCOUNTS = [
+  "soyas4s6L8KWZ8rsSk1mF3d1mQScoTGGAgjk98bF8nP",
+  "soyascXFW5wEEYiwfEmHy2pNwomqzvggJosGVD6TJdY",
+  "soyasDBdKjADwPz3xk82U3TNPRDKEWJj7wWLajNHZ1L",
+  "soyasE2abjBAynmHbGWgEwk4ctBy7JMTUCNrMbjcnyH",
+  "soyasi59njacMUPvo3TM5paHjeK8pYSdovXgFi32gRt",
+  "soyasQYhJxv8uZgWDxhg72td6piAf7XTkoyWHtSATEz",
+  "soyastP66xyYC8XADXZjdMM5BAVGD2YRvz8dwtLsqb8",
+  "soyasvdgUJWYcUCzDxpmjUnNjH7KamXLXTzLwFvdVPE",
+  "soyasvxAunisNxaoRxkKGjNir7KmbwYnr37JmefkX9G",
+  "soyas5doVFUwH8s5zK8gEvCL5KR5ogDmf52LsrJEZ9h"
+];
+var SPEEDLANDING_TIP_ACCOUNTS = [
+  "SpEEdz8S1KorkMZqjMUxfxrmWwofmp6ReNP2Nx6CUmq",
+  "SpeeDy3GJM4wcrQmk1itRFWgidvxX4rwjTLMv78wwjE",
+  "SPeEdva37vW8vRtqgYjprQs1g3965icfVN5Rt7SMAyh",
+  "speEdrSEpox5GUfHWcBc7tQjRuSfUin2yvB7qoYvvJh",
+  "SPeEDmkHkN3A2roSZf6aZyEMsmrGqTHKqwP51y2Y4rV",
+  "SpeedLdTJXh2RKpXEaP8JCxkWoUVXhtdPQ1EnxBJMxc",
+  "SpEediGKLbbXndSYTzwmz6Z3NDgHQLDcTDEvGFkSMH9",
+  "speede8xCcUq2Tiv1efXeTuE3k9TDNq8TnGKaKSc6J4"
+];
+var JITO_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "https://ny.mainnet.block-engine.jito.wtf",
+  ["Frankfurt" /* Frankfurt */]: "https://frankfurt.mainnet.block-engine.jito.wtf",
+  ["Amsterdam" /* Amsterdam */]: "https://amsterdam.mainnet.block-engine.jito.wtf",
+  ["Dublin" /* Dublin */]: "https://dublin.mainnet.block-engine.jito.wtf",
+  ["SLC" /* SLC */]: "https://slc.mainnet.block-engine.jito.wtf",
+  ["Tokyo" /* Tokyo */]: "https://tokyo.mainnet.block-engine.jito.wtf",
+  ["London" /* London */]: "https://london.mainnet.block-engine.jito.wtf",
+  ["LosAngeles" /* LosAngeles */]: "https://slc.mainnet.block-engine.jito.wtf",
+  ["Singapore" /* Singapore */]: "https://singapore.mainnet.block-engine.jito.wtf",
+  ["Default" /* Default */]: "https://mainnet.block-engine.jito.wtf"
+};
+var BLOXROUTE_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "https://ny.solana.dex.blxrbdn.com",
+  ["Frankfurt" /* Frankfurt */]: "https://germany.solana.dex.blxrbdn.com",
+  ["Amsterdam" /* Amsterdam */]: "https://amsterdam.solana.dex.blxrbdn.com",
+  ["Dublin" /* Dublin */]: "https://uk.solana.dex.blxrbdn.com",
+  ["SLC" /* SLC */]: "https://ny.solana.dex.blxrbdn.com",
+  ["Tokyo" /* Tokyo */]: "https://tokyo.solana.dex.blxrbdn.com",
+  ["London" /* London */]: "https://uk.solana.dex.blxrbdn.com",
+  ["LosAngeles" /* LosAngeles */]: "https://la.solana.dex.blxrbdn.com",
+  ["Singapore" /* Singapore */]: "https://global.solana.dex.blxrbdn.com",
+  ["Default" /* Default */]: "https://global.solana.dex.blxrbdn.com"
+};
+var ZERO_SLOT_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ny.0slot.trade",
+  ["Frankfurt" /* Frankfurt */]: "http://de2.0slot.trade",
+  ["Amsterdam" /* Amsterdam */]: "http://ams.0slot.trade",
+  ["Dublin" /* Dublin */]: "http://ams.0slot.trade",
+  ["SLC" /* SLC */]: "http://la.0slot.trade",
+  ["Tokyo" /* Tokyo */]: "http://jp.0slot.trade",
+  ["London" /* London */]: "http://ams.0slot.trade",
+  ["LosAngeles" /* LosAngeles */]: "http://la.0slot.trade",
+  ["Singapore" /* Singapore */]: "http://jp.0slot.trade",
+  ["Default" /* Default */]: "http://de2.0slot.trade"
+};
+var TEMPORAL_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ewr1.nozomi.temporal.xyz",
+  ["Frankfurt" /* Frankfurt */]: "http://fra2.nozomi.temporal.xyz",
+  ["Amsterdam" /* Amsterdam */]: "http://ams1.nozomi.temporal.xyz",
+  ["Dublin" /* Dublin */]: "http://lon1.nozomi.temporal.xyz",
+  ["SLC" /* SLC */]: "http://lax1.nozomi.temporal.xyz",
+  ["Tokyo" /* Tokyo */]: "http://tyo1.nozomi.temporal.xyz",
+  ["London" /* London */]: "http://lon1.nozomi.temporal.xyz",
+  ["LosAngeles" /* LosAngeles */]: "http://lax1.nozomi.temporal.xyz",
+  ["Singapore" /* Singapore */]: "http://sgp1.nozomi.temporal.xyz",
+  ["Default" /* Default */]: "http://fra2.nozomi.temporal.xyz"
+};
+var FLASH_BLOCK_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ny.flashblock.trade",
+  ["Frankfurt" /* Frankfurt */]: "http://fra.flashblock.trade",
+  ["Amsterdam" /* Amsterdam */]: "http://ams.flashblock.trade",
+  ["Dublin" /* Dublin */]: "http://london.flashblock.trade",
+  ["SLC" /* SLC */]: "http://slc.flashblock.trade",
+  ["Tokyo" /* Tokyo */]: "http://tokyo.flashblock.trade",
+  ["London" /* London */]: "http://london.flashblock.trade",
+  ["LosAngeles" /* LosAngeles */]: "http://slc.flashblock.trade",
+  ["Singapore" /* Singapore */]: "http://singapore.flashblock.trade",
+  ["Default" /* Default */]: "http://fra.flashblock.trade"
+};
+var HELIUS_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ewr-sender.helius-rpc.com/fast",
+  ["Frankfurt" /* Frankfurt */]: "http://fra-sender.helius-rpc.com/fast",
+  ["Amsterdam" /* Amsterdam */]: "http://ams-sender.helius-rpc.com/fast",
+  ["Dublin" /* Dublin */]: "http://lon-sender.helius-rpc.com/fast",
+  ["SLC" /* SLC */]: "http://slc-sender.helius-rpc.com/fast",
+  ["Tokyo" /* Tokyo */]: "http://tyo-sender.helius-rpc.com/fast",
+  ["London" /* London */]: "http://lon-sender.helius-rpc.com/fast",
+  ["LosAngeles" /* LosAngeles */]: "http://slc-sender.helius-rpc.com/fast",
+  ["Singapore" /* Singapore */]: "http://sg-sender.helius-rpc.com/fast",
+  ["Default" /* Default */]: "https://sender.helius-rpc.com/fast"
+};
+var NODE1_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ny.node1.me",
+  ["Frankfurt" /* Frankfurt */]: "http://fra.node1.me",
+  ["Amsterdam" /* Amsterdam */]: "http://ams.node1.me",
+  ["Dublin" /* Dublin */]: "http://lon.node1.me",
+  ["SLC" /* SLC */]: "http://ny.node1.me",
+  ["Tokyo" /* Tokyo */]: "http://tk.node1.me",
+  ["London" /* London */]: "http://lon.node1.me",
+  ["LosAngeles" /* LosAngeles */]: "http://ny.node1.me",
+  ["Singapore" /* Singapore */]: "http://fra.node1.me",
+  ["Default" /* Default */]: "http://fra.node1.me"
+};
+var BLOCK_RAZOR_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://newyork.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["Frankfurt" /* Frankfurt */]: "http://frankfurt.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["Amsterdam" /* Amsterdam */]: "http://amsterdam.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["Dublin" /* Dublin */]: "http://london.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["SLC" /* SLC */]: "http://newyork.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["Tokyo" /* Tokyo */]: "http://tokyo.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["London" /* London */]: "http://london.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["LosAngeles" /* LosAngeles */]: "http://newyork.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["Singapore" /* Singapore */]: "http://frankfurt.solana.blockrazor.xyz:443/v2/sendTransaction",
+  ["Default" /* Default */]: "http://frankfurt.solana.blockrazor.xyz:443/v2/sendTransaction"
+};
+var ASTRALANE_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ny.gateway.astralane.io/irisb",
+  ["Frankfurt" /* Frankfurt */]: "http://fr.gateway.astralane.io/irisb",
+  ["Amsterdam" /* Amsterdam */]: "http://ams.gateway.astralane.io/irisb",
+  ["Dublin" /* Dublin */]: "http://ams.gateway.astralane.io/irisb",
+  ["SLC" /* SLC */]: "http://ny.gateway.astralane.io/irisb",
+  ["Tokyo" /* Tokyo */]: "http://jp.gateway.astralane.io/irisb",
+  ["London" /* London */]: "http://ams.gateway.astralane.io/irisb",
+  ["LosAngeles" /* LosAngeles */]: "http://lax.gateway.astralane.io/irisb",
+  ["Singapore" /* Singapore */]: "http://lim.gateway.astralane.io/irisb",
+  ["Default" /* Default */]: "http://lim.gateway.astralane.io/irisb"
+};
+var ASTRALANE_QUIC_HOSTS = {
+  ["NewYork" /* NewYork */]: "ny.gateway.astralane.io",
+  ["Frankfurt" /* Frankfurt */]: "fr.gateway.astralane.io",
+  ["Amsterdam" /* Amsterdam */]: "ams.gateway.astralane.io",
+  ["Dublin" /* Dublin */]: "ams.gateway.astralane.io",
+  ["SLC" /* SLC */]: "ny.gateway.astralane.io",
+  ["Tokyo" /* Tokyo */]: "jp.gateway.astralane.io",
+  ["London" /* London */]: "ams.gateway.astralane.io",
+  ["LosAngeles" /* LosAngeles */]: "lax.gateway.astralane.io",
+  ["Singapore" /* Singapore */]: "lim.gateway.astralane.io",
+  ["Default" /* Default */]: "lim.gateway.astralane.io"
+};
+var STELLIUM_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ewr1.flashrpc.com",
+  ["Frankfurt" /* Frankfurt */]: "http://fra1.flashrpc.com",
+  ["Amsterdam" /* Amsterdam */]: "http://ams1.flashrpc.com",
+  ["Dublin" /* Dublin */]: "http://lhr1.flashrpc.com",
+  ["SLC" /* SLC */]: "http://ewr1.flashrpc.com",
+  ["Tokyo" /* Tokyo */]: "http://tyo1.flashrpc.com",
+  ["London" /* London */]: "http://lhr1.flashrpc.com",
+  ["LosAngeles" /* LosAngeles */]: "http://ewr1.flashrpc.com",
+  ["Singapore" /* Singapore */]: "http://fra1.flashrpc.com",
+  ["Default" /* Default */]: "http://fra1.flashrpc.com"
+};
+var NEXT_BLOCK_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "http://ny.nextblock.io",
+  ["Frankfurt" /* Frankfurt */]: "http://fra.nextblock.io",
+  ["Amsterdam" /* Amsterdam */]: "http://ams.nextblock.io",
+  ["Dublin" /* Dublin */]: "http://dublin.nextblock.io",
+  ["SLC" /* SLC */]: "http://slc.nextblock.io",
+  ["Tokyo" /* Tokyo */]: "http://tokyo.nextblock.io",
+  ["London" /* London */]: "http://london.nextblock.io",
+  ["LosAngeles" /* LosAngeles */]: "http://slc.nextblock.io",
+  ["Singapore" /* Singapore */]: "http://sgp.nextblock.io",
+  ["Default" /* Default */]: "http://fra.nextblock.io"
+};
+var SOYAS_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "nyc.landing.soyas.xyz:9000",
+  ["Frankfurt" /* Frankfurt */]: "fra.landing.soyas.xyz:9000",
+  ["Amsterdam" /* Amsterdam */]: "ams.landing.soyas.xyz:9000",
+  ["Dublin" /* Dublin */]: "lon.landing.soyas.xyz:9000",
+  ["SLC" /* SLC */]: "nyc.landing.soyas.xyz:9000",
+  ["Tokyo" /* Tokyo */]: "tyo.landing.soyas.xyz:9000",
+  ["London" /* London */]: "lon.landing.soyas.xyz:9000",
+  ["LosAngeles" /* LosAngeles */]: "nyc.landing.soyas.xyz:9000",
+  ["Singapore" /* Singapore */]: "fra.landing.soyas.xyz:9000",
+  ["Default" /* Default */]: "fra.landing.soyas.xyz:9000"
+};
+var SPEEDLANDING_ENDPOINTS = {
+  ["NewYork" /* NewYork */]: "nyc.speedlanding.trade:17778",
+  ["Frankfurt" /* Frankfurt */]: "fra.speedlanding.trade:17778",
+  ["Amsterdam" /* Amsterdam */]: "ams.speedlanding.trade:17778",
+  ["Dublin" /* Dublin */]: "ams.speedlanding.trade:17778",
+  ["SLC" /* SLC */]: "nyc.speedlanding.trade:17778",
+  ["Tokyo" /* Tokyo */]: "tyo.speedlanding.trade:17778",
+  ["London" /* London */]: "fra.speedlanding.trade:17778",
+  ["LosAngeles" /* LosAngeles */]: "nyc.speedlanding.trade:17778",
+  ["Singapore" /* Singapore */]: "fra.speedlanding.trade:17778",
+  ["Default" /* Default */]: "fra.speedlanding.trade:17778"
+};
+var BaseClient = class {
+  async sendTransactions(tradeType, transactions, waitConfirmation) {
+    const signatures = [];
+    for (const tx of transactions) {
+      const sig = await this.sendTransaction(tradeType, tx, waitConfirmation);
+      signatures.push(sig);
+    }
+    return signatures;
+  }
+  async post(url, payload, headers = {}) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new TradeError(response.status, `HTTP error: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async postRaw(url, body, headers = {}) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/plain",
+        ...headers
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new TradeError(response.status, `HTTP error: ${response.statusText}`);
+    }
+    return response.json();
+  }
+};
+var JitoClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = JITO_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [
+        encoded,
+        { encoding: "base64" }
+      ]
+    };
+    const headers = {};
+    let url = `${this.endpoint}/api/v1/transactions`;
+    if (this.authToken) {
+      headers["x-jito-auth"] = this.authToken;
+      url = `${this.endpoint}/api/v1/transactions?uuid=${this.authToken}`;
+    }
+    const result = await this.post(url, payload, headers);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message);
+    }
+    return result.result;
+  }
+  async sendTransactions(tradeType, transactions, waitConfirmation) {
+    if (transactions.length === 0) return [];
+    if (transactions.length === 1) {
+      const tx = transactions[0];
+      return [await this.sendTransaction(tradeType, tx, waitConfirmation)];
+    }
+    const encodedTxs = transactions.map((tx) => tx.toString("base64"));
+    const payload = {
+      jsonrpc: "2.0",
+      method: "sendBundle",
+      params: [encodedTxs, { encoding: "base64" }],
+      id: 1
+    };
+    const headers = {};
+    let url = `${this.endpoint}/api/v1/bundles`;
+    if (this.authToken) {
+      headers["x-jito-auth"] = this.authToken;
+      url = `${this.endpoint}/api/v1/bundles?uuid=${this.authToken}`;
+    }
+    const result = await this.post(url, payload, headers);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message);
+    }
+    return [result.result];
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Jito" /* Jito */;
+  }
+  minTipSol() {
+    return MIN_TIP_JITO;
+  }
+};
+var BloxrouteClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = BLOXROUTE_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      transaction: { content: encoded },
+      frontRunningProtection: false,
+      useStakedRPCs: true
+    };
+    const headers = {};
+    if (this.authToken) {
+      headers["Authorization"] = this.authToken;
+    }
+    const url = `${this.endpoint}/api/v2/submit`;
+    const result = await this.post(url, payload, headers);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || result.error);
+    }
+    if (result.reason) {
+      throw new TradeError(500, result.reason);
+    }
+    return result.signature || result.result || "";
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Bloxroute" /* Bloxroute */;
+  }
+  minTipSol() {
+    return MIN_TIP_BLOXROUTE;
+  }
+};
+var ZeroSlotClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = ZERO_SLOT_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [encoded, { encoding: "base64" }]
+    };
+    let url = this.endpoint;
+    if (this.authToken) {
+      url = `${this.endpoint}?api-key=${this.authToken}`;
+    }
+    const result = await this.post(url, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result;
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "ZeroSlot" /* ZeroSlot */;
+  }
+  minTipSol() {
+    return MIN_TIP_ZERO_SLOT;
+  }
+};
+var TemporalClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = TEMPORAL_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [encoded, { encoding: "base64" }]
+    };
+    let url = this.endpoint;
+    if (this.authToken) {
+      url = `${this.endpoint}/?c=${this.authToken}`;
+    }
+    const result = await this.post(url, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result;
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Temporal" /* Temporal */;
+  }
+  minTipSol() {
+    return MIN_TIP_TEMPORAL;
+  }
+};
+var FlashBlockClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = FLASH_BLOCK_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      transactions: [encoded]
+    };
+    const headers = {};
+    if (this.authToken) {
+      headers["Authorization"] = this.authToken;
+    }
+    const url = `${this.endpoint}/api/v2/submit-batch`;
+    const result = await this.post(url, payload, headers);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    if (Array.isArray(result) && result.length > 0) {
+      return result[0].signature || result[0].result || "";
+    }
+    return result.signature || result.result || "";
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "FlashBlock" /* FlashBlock */;
+  }
+  minTipSol() {
+    return MIN_TIP_FLASH_BLOCK;
+  }
+};
+var HeliusClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, apiKey, swqosOnly = false) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+    this.swqosOnly = swqosOnly;
+  }
+  rpcUrl;
+  endpoint;
+  apiKey;
+  swqosOnly;
+  tipAccounts = HELIUS_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: "1",
+      // string "1" per Helius API spec
+      method: "sendTransaction",
+      params: [
+        encoded,
+        {
+          encoding: "base64",
+          skipPreflight: true,
+          maxRetries: 0
+        }
+      ]
+    };
+    let url = this.endpoint;
+    if (this.apiKey) {
+      url = `${this.endpoint}?api-key=${this.apiKey}`;
+    }
+    const result = await this.post(url, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message);
+    }
+    return result.result;
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Helius" /* Helius */;
+  }
+  minTipSol() {
+    return this.swqosOnly ? MIN_TIP_HELIUS : MIN_TIP_HELIUS_NORMAL;
+  }
+};
+var Node1Client = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = NODE1_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [encoded, { encoding: "base64", skipPreflight: true }]
+    };
+    const headers = {};
+    if (this.authToken) {
+      headers["api-key"] = this.authToken;
+    }
+    const result = await this.post(this.endpoint, payload, headers);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result;
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Node1" /* Node1 */;
+  }
+  minTipSol() {
+    return MIN_TIP_NODE1;
+  }
+};
+var Node1QuicClient = class {
+  constructor(rpcUrl, endpoint, authToken) {
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+    const lastColon = endpoint.lastIndexOf(":");
+    this.host = lastColon >= 0 ? endpoint.slice(0, lastColon) : endpoint;
+    this.port = lastColon >= 0 ? parseInt(endpoint.slice(lastColon + 1), 10) : 16666;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = NODE1_TIP_ACCOUNTS;
+  host;
+  port;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    await sendNode1ViaQUIC(this.host, this.port, this.authToken, new Uint8Array(transaction));
+    return "";
+  }
+  async sendTransactions(tradeType, transactions, waitConfirmation) {
+    const signatures = [];
+    for (const tx of transactions) {
+      signatures.push(await this.sendTransaction(tradeType, tx, waitConfirmation));
+    }
+    return signatures;
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Node1" /* Node1 */;
+  }
+  minTipSol() {
+    return MIN_TIP_NODE1;
+  }
+};
+var BlockRazorClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken, mevProtection = false) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+    this.mevProtection = mevProtection;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  mevProtection;
+  tipAccounts = BLOCK_RAZOR_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const mode = this.mevProtection ? "sandwichMitigation" : "fast";
+    let url = `${this.endpoint}?mode=${mode}`;
+    if (this.authToken) {
+      url = `${this.endpoint}?auth=${this.authToken}&mode=${mode}`;
+    }
+    const result = await this.postRaw(url, encoded);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result || result.signature || "";
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "BlockRazor" /* BlockRazor */;
+  }
+  minTipSol() {
+    return MIN_TIP_BLOCK_RAZOR;
+  }
+};
+var AstralaneClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = ASTRALANE_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [encoded, { encoding: "base64" }]
+    };
+    let url = `${this.endpoint}?method=sendTransaction`;
+    if (this.authToken) {
+      url = `${this.endpoint}?api-key=${this.authToken}&method=sendTransaction`;
+    }
+    const result = await this.post(url, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result || result.signature || "";
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Astralane" /* Astralane */;
+  }
+  minTipSol() {
+    return MIN_TIP_ASTRALANE;
+  }
+};
+var AstralaneQuicClient = class {
+  constructor(rpcUrl, endpoint, authToken) {
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+    const lastColon = endpoint.lastIndexOf(":");
+    this.host = lastColon >= 0 ? endpoint.slice(0, lastColon) : endpoint;
+    this.port = lastColon >= 0 ? parseInt(endpoint.slice(lastColon + 1), 10) : 7e3;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = ASTRALANE_TIP_ACCOUNTS;
+  host;
+  port;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    if (transaction.length > 1232) {
+      throw new TradeError(400, `Astralane QUIC transaction too large: ${transaction.length} > 1232`);
+    }
+    await sendViaQUIC(this.host, this.port, "astralane", new Uint8Array(transaction), {
+      alpn: "astralane-tpu",
+      commonName: this.authToken,
+      algorithm: "ecdsa"
+    });
+    return "";
+  }
+  async sendTransactions(tradeType, transactions, waitConfirmation) {
+    const signatures = [];
+    for (const tx of transactions) {
+      signatures.push(await this.sendTransaction(tradeType, tx, waitConfirmation));
+    }
+    return signatures;
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Astralane" /* Astralane */;
+  }
+  minTipSol() {
+    return MIN_TIP_ASTRALANE;
+  }
+};
+var StelliumClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = STELLIUM_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [encoded, { encoding: "base64" }]
+    };
+    let url = this.endpoint;
+    if (this.authToken) {
+      url = `${this.endpoint}/${this.authToken}`;
+    }
+    const result = await this.post(url, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result || result.signature || "";
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "Stellium" /* Stellium */;
+  }
+  minTipSol() {
+    return MIN_TIP_STELLIUM;
+  }
+};
+var LightspeedClient = class extends BaseClient {
+  constructor(rpcUrl, customUrl) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.customUrl = customUrl;
+  }
+  rpcUrl;
+  customUrl;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [
+        encoded,
+        {
+          encoding: "base64",
+          skipPreflight: true,
+          preflightCommitment: "processed",
+          maxRetries: 0
+        }
+      ]
+    };
+    const result = await this.post(this.customUrl, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    return result.result || result.signature || "";
+  }
+  getTipAccount() {
+    const accounts = [
+      "53PhM3UTdMQWu5t81wcd35AHGc5xpmHoRjem7GQPvXjA",
+      "9tYF5yPDC1NP8s6diiB3kAX6ZZnva9DM3iDwJkBRarBB"
+    ];
+    return randomChoice(accounts);
+  }
+  getSwqosType() {
+    return "Lightspeed" /* Lightspeed */;
+  }
+  minTipSol() {
+    return MIN_TIP_LIGHTSPEED;
+  }
+};
+var NextBlockClient = class extends BaseClient {
+  constructor(rpcUrl, endpoint, authToken) {
+    super();
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.authToken = authToken;
+  }
+  rpcUrl;
+  endpoint;
+  authToken;
+  tipAccounts = NEXT_BLOCK_TIP_ACCOUNTS;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      transaction: { content: encoded },
+      frontRunningProtection: false
+    };
+    const headers = {};
+    if (this.authToken) {
+      headers["Authorization"] = this.authToken;
+    }
+    const url = `${this.endpoint}/api/v2/submit`;
+    const result = await this.post(url, payload, headers);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message || String(result.error));
+    }
+    if (result.reason) {
+      throw new TradeError(500, result.reason);
+    }
+    return result.signature || result.result || "";
+  }
+  getTipAccount() {
+    return randomChoice(this.tipAccounts);
+  }
+  getSwqosType() {
+    return "NextBlock" /* NextBlock */;
+  }
+  minTipSol() {
+    return MIN_TIP_NEXT_BLOCK;
+  }
+};
+var DefaultClient = class extends BaseClient {
+  constructor(rpcUrl) {
+    super();
+    this.rpcUrl = rpcUrl;
+  }
+  rpcUrl;
+  async sendTransaction(tradeType, transaction, waitConfirmation) {
+    const encoded = transaction.toString("base64");
+    const payload = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [
+        encoded,
+        { encoding: "base64" }
+      ]
+    };
+    const result = await this.post(this.rpcUrl, payload);
+    if (result.error) {
+      throw new TradeError(result.error.code || 500, result.error.message);
+    }
+    return result.result;
+  }
+  getTipAccount() {
+    return "";
+  }
+  getSwqosType() {
+    return "Default" /* Default */;
+  }
+  minTipSol() {
+    return MIN_TIP_DEFAULT;
+  }
+};
+async function sendViaQUIC(host, port, serverName, txBytes, options = {}) {
+  let QUICClient;
+  let selfsigned;
+  try {
+    ({ QUICClient } = await import("@matrixai/quic"));
+    selfsigned = (await import("selfsigned")).default ?? await import("selfsigned");
+  } catch {
+    throw new TradeError(
+      501,
+      'QUIC not available: run "npm install @matrixai/quic selfsigned" to enable Soyas/Speedlanding.'
+    );
+  }
+  const pems = selfsigned.generate(
+    [{ name: "commonName", value: options.commonName ?? "Solana node" }],
+    { days: 36500, algorithm: options.algorithm ?? "ed25519" }
+  );
+  const client = await QUICClient.createQUICClient({
+    host,
+    port,
+    config: {
+      key: pems.private,
+      cert: pems.cert,
+      verifyPeer: false,
+      applicationProtos: [options.alpn ?? "solana-tpu"],
+      tlsVersion: "tlsv13"
+    },
+    logger: void 0
+  });
+  try {
+    const stream = client.connection.newStream("uni");
+    const writer = stream.writable.getWriter();
+    await writer.write(txBytes);
+    await writer.close();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  } finally {
+    await client.destroy();
+  }
+}
+function hostPortFromHttp(endpoint, port) {
+  try {
+    const url = new URL(endpoint);
+    return { host: url.hostname, port };
+  } catch {
+    const withoutScheme = endpoint.replace(/^https?:\/\//, "").split("/")[0];
+    const lastColon = withoutScheme.lastIndexOf(":");
+    const host = lastColon >= 0 ? withoutScheme.slice(0, lastColon) : withoutScheme;
+    return { host, port };
+  }
+}
+function uuidToBytes(apiKey) {
+  const hex = apiKey.replace(/-/g, "");
+  if (!/^[0-9a-fA-F]{32}$/.test(hex)) {
+    throw new TradeError(400, "Node1 QUIC API key must be a UUID");
+  }
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+async function readQuicStream(stream) {
+  const reader = stream.readable.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (value) {
+        const chunk = new Uint8Array(value);
+        chunks.push(chunk);
+        total += chunk.length;
+      }
+    }
+  } finally {
+    reader.releaseLock?.();
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+async function sendNode1ViaQUIC(host, port, apiKey, txBytes) {
+  let QUICClient;
+  try {
+    ({ QUICClient } = await import("@matrixai/quic"));
+  } catch {
+    throw new TradeError(501, 'QUIC not available: run "npm install @matrixai/quic" to enable Node1 QUIC.');
+  }
+  if (txBytes.length > 1232) {
+    throw new TradeError(400, `Node1 QUIC transaction too large: ${txBytes.length} > 1232`);
+  }
+  const client = await QUICClient.createQUICClient({
+    host,
+    port,
+    config: {
+      verifyPeer: false,
+      applicationProtos: ["h3"],
+      tlsVersion: "tlsv13",
+      serverName: host
+    },
+    logger: void 0
+  });
+  try {
+    const authStream = client.connection.newStream("bi");
+    const authWriter = authStream.writable.getWriter();
+    await authWriter.write(uuidToBytes(apiKey));
+    await authWriter.close();
+    const authReply = await readQuicStream(authStream);
+    if (authReply[0] !== 0) {
+      throw new TradeError(401, `Node1 QUIC auth rejected: ${authReply[0] ?? -1}`);
+    }
+    const txStream = client.connection.newStream("bi");
+    const txWriter = txStream.writable.getWriter();
+    await txWriter.write(txBytes);
+    await txWriter.close();
+    const response = await readQuicStream(txStream);
+    if (response.length < 6) {
+      throw new TradeError(500, "Node1 QUIC response too short");
+    }
+    const status = response[0] << 8 | response[1];
+    const msgLen = response[2] << 24 | response[3] << 16 | response[4] << 8 | response[5];
+    const msg = Buffer.from(response.slice(6, 6 + msgLen)).toString("utf8");
+    if (status !== 200) {
+      throw new TradeError(status, `Node1 QUIC submit failed: ${msg}`);
+    }
+  } finally {
+    await client.destroy();
+  }
+}
+var SoyasClient = class {
+  constructor(rpcUrl, endpoint, apiKey) {
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+    this.tipAccount = randomChoice(SOYAS_TIP_ACCOUNTS);
+    const parts = endpoint.split(":");
+    this.host = parts.slice(0, -1).join(":") || endpoint;
+    this.port = parts.length > 1 ? parseInt(parts[parts.length - 1], 10) : 9e3;
+  }
+  rpcUrl;
+  endpoint;
+  apiKey;
+  tipAccount;
+  host;
+  port;
+  async sendTransaction(_tradeType, transaction, _waitConfirmation) {
+    await sendViaQUIC(this.host, this.port, "soyas-landing", new Uint8Array(transaction));
+    return "";
+  }
+  async sendTransactions(tradeType, transactions, waitConfirmation) {
+    for (const tx of transactions) {
+      await this.sendTransaction(tradeType, tx, waitConfirmation);
+    }
+    return transactions.map(() => "");
+  }
+  getTipAccount() {
+    return this.tipAccount;
+  }
+  getSwqosType() {
+    return "Soyas" /* Soyas */;
+  }
+  minTipSol() {
+    return MIN_TIP_SOYAS;
+  }
+};
+var SpeedlandingClient = class {
+  constructor(rpcUrl, endpoint, apiKey) {
+    this.rpcUrl = rpcUrl;
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+    this.tipAccount = randomChoice(SPEEDLANDING_TIP_ACCOUNTS);
+    const lastColon = endpoint.lastIndexOf(":");
+    this.host = lastColon >= 0 ? endpoint.slice(0, lastColon) : endpoint;
+    this.port = lastColon >= 0 ? parseInt(endpoint.slice(lastColon + 1), 10) : 17778;
+    this.serverName = /^\d+\.\d+\.\d+\.\d+$/.test(this.host) ? "speed-landing" : this.host;
+  }
+  rpcUrl;
+  endpoint;
+  apiKey;
+  tipAccount;
+  host;
+  port;
+  serverName;
+  async sendTransaction(_tradeType, transaction, _waitConfirmation) {
+    await sendViaQUIC(this.host, this.port, this.serverName, new Uint8Array(transaction));
+    return "";
+  }
+  async sendTransactions(tradeType, transactions, waitConfirmation) {
+    for (const tx of transactions) {
+      await this.sendTransaction(tradeType, tx, waitConfirmation);
+    }
+    return transactions.map(() => "");
+  }
+  getTipAccount() {
+    return this.tipAccount;
+  }
+  getSwqosType() {
+    return "Speedlanding" /* Speedlanding */;
+  }
+  minTipSol() {
+    return MIN_TIP_SPEEDLANDING;
+  }
+};
+var ClientFactory = class {
+  static createClient(config, rpcUrl) {
+    const region = config.region ?? "Default" /* Default */;
+    switch (config.type) {
+      case "Jito" /* Jito */: {
+        const endpoint = config.customUrl || JITO_ENDPOINTS[region];
+        return new JitoClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Bloxroute" /* Bloxroute */: {
+        const endpoint = config.customUrl || BLOXROUTE_ENDPOINTS[region];
+        return new BloxrouteClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "ZeroSlot" /* ZeroSlot */: {
+        const endpoint = config.customUrl || ZERO_SLOT_ENDPOINTS[region];
+        return new ZeroSlotClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Temporal" /* Temporal */: {
+        const endpoint = config.customUrl || TEMPORAL_ENDPOINTS[region];
+        return new TemporalClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "FlashBlock" /* FlashBlock */: {
+        const endpoint = config.customUrl || FLASH_BLOCK_ENDPOINTS[region];
+        return new FlashBlockClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Helius" /* Helius */: {
+        const endpoint = config.customUrl || HELIUS_ENDPOINTS[region];
+        return new HeliusClient(rpcUrl, endpoint, config.apiKey, config.swqosOnly ?? false);
+      }
+      case "Node1" /* Node1 */: {
+        const endpoint = config.customUrl || NODE1_ENDPOINTS[region];
+        if (config.transport === "Quic" /* Quic */) {
+          const parsed = /^https?:\/\//.test(endpoint) ? hostPortFromHttp(endpoint, 16666) : (() => {
+            const lastColon = endpoint.lastIndexOf(":");
+            return {
+              host: lastColon >= 0 ? endpoint.slice(0, lastColon) : endpoint,
+              port: lastColon >= 0 ? parseInt(endpoint.slice(lastColon + 1), 10) : 16666
+            };
+          })();
+          return new Node1QuicClient(rpcUrl, `${parsed.host}:${parsed.port}`, config.apiKey || "");
+        }
+        return new Node1Client(rpcUrl, endpoint, config.apiKey);
+      }
+      case "BlockRazor" /* BlockRazor */: {
+        const endpoint = config.customUrl || BLOCK_RAZOR_ENDPOINTS[region];
+        return new BlockRazorClient(rpcUrl, endpoint, config.apiKey, config.mevProtection ?? false);
+      }
+      case "Astralane" /* Astralane */: {
+        const baseEndpoint = config.customUrl || ASTRALANE_ENDPOINTS[region];
+        if (config.astralaneTransport === "Quic" /* Quic */) {
+          let endpoint2;
+          const port = config.mevProtection ? 9e3 : 7e3;
+          if (config.customUrl) {
+            if (/^https?:\/\//.test(config.customUrl)) {
+              const parsed = hostPortFromHttp(config.customUrl, port);
+              endpoint2 = `${parsed.host}:${parsed.port}`;
+            } else {
+              endpoint2 = config.customUrl;
+            }
+          } else {
+            endpoint2 = `${ASTRALANE_QUIC_HOSTS[region]}:${port}`;
+          }
+          return new AstralaneQuicClient(rpcUrl, endpoint2, config.apiKey || "");
+        }
+        const endpoint = config.astralaneTransport === "Plain" /* Plain */ ? baseEndpoint.replace("/irisb", "/iris") : baseEndpoint;
+        return new AstralaneClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Stellium" /* Stellium */: {
+        const endpoint = config.customUrl || STELLIUM_ENDPOINTS[region];
+        return new StelliumClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Lightspeed" /* Lightspeed */: {
+        if (!config.customUrl) {
+          throw new TradeError(400, "LightspeedClient requires customUrl (format already contains api_key)");
+        }
+        return new LightspeedClient(rpcUrl, config.customUrl);
+      }
+      case "NextBlock" /* NextBlock */: {
+        const endpoint = config.customUrl || NEXT_BLOCK_ENDPOINTS[region];
+        return new NextBlockClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Soyas" /* Soyas */: {
+        const endpoint = config.customUrl || SOYAS_ENDPOINTS[region];
+        return new SoyasClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Speedlanding" /* Speedlanding */: {
+        const endpoint = config.customUrl || SPEEDLANDING_ENDPOINTS[region];
+        return new SpeedlandingClient(rpcUrl, endpoint, config.apiKey);
+      }
+      case "Default" /* Default */:
+      default:
+        return new DefaultClient(rpcUrl);
+    }
+  }
+};
+function createSwqosClient(swqosType, rpcUrl, authToken, region, customUrl, mevProtection = false) {
+  const config = {
+    type: swqosType,
+    region,
+    customUrl,
+    apiKey: authToken,
+    mevProtection
+  };
+  return ClientFactory.createClient(config, rpcUrl);
+}
+export {
+  ASTRALANE_ENDPOINTS,
+  ASTRALANE_QUIC_HOSTS,
+  AstralaneClient,
+  AstralaneQuicClient,
+  BLOCK_RAZOR_ENDPOINTS,
+  BLOXROUTE_ENDPOINTS,
+  BlockRazorClient,
+  BloxrouteClient,
+  ClientFactory,
+  DefaultClient,
+  FLASH_BLOCK_ENDPOINTS,
+  FlashBlockClient,
+  HELIUS_ENDPOINTS,
+  HeliusClient,
+  JITO_ENDPOINTS,
+  JitoClient,
+  LightspeedClient,
+  MIN_TIP_ASTRALANE,
+  MIN_TIP_BLOCK_RAZOR,
+  MIN_TIP_BLOXROUTE,
+  MIN_TIP_DEFAULT,
+  MIN_TIP_FLASH_BLOCK,
+  MIN_TIP_HELIUS,
+  MIN_TIP_HELIUS_NORMAL,
+  MIN_TIP_JITO,
+  MIN_TIP_LIGHTSPEED,
+  MIN_TIP_NEXT_BLOCK,
+  MIN_TIP_NODE1,
+  MIN_TIP_SOYAS,
+  MIN_TIP_SPEEDLANDING,
+  MIN_TIP_STELLIUM,
+  MIN_TIP_TEMPORAL,
+  MIN_TIP_ZERO_SLOT,
+  NEXT_BLOCK_ENDPOINTS,
+  NODE1_ENDPOINTS,
+  NextBlockClient,
+  Node1Client,
+  Node1QuicClient,
+  SOYAS_ENDPOINTS,
+  SPEEDLANDING_ENDPOINTS,
+  STELLIUM_ENDPOINTS,
+  SoyasClient,
+  SpeedlandingClient,
+  StelliumClient,
+  TEMPORAL_ENDPOINTS,
+  TemporalClient,
+  ZERO_SLOT_ENDPOINTS,
+  ZeroSlotClient,
+  createSwqosClient,
+  randomChoice
+};