@solana-mev-sdk/jito-client 0.2.8

package/README.md

@@ -0,0 +1,75 @@
+# jito-client
+
+**Jito Block Engine client** for Solana: send bundles (up to 5 txs), optional tip transaction, and wait for confirmation.
+
+## Install
+
+```bash
+npm install jito-client @solana/web3.js
+```
+
+`@solana/web3.js` is a peer dependency.
+
+## Usage
+
+### Basic
+
+```ts
+import { Connection, Keypair } from "@solana/web3.js";
+import { JitoClient } from "jito-client";
+
+const connection = new Connection("https://api.mainnet-beta.solana.com");
+const client = new JitoClient(connection);
+
+// Send bundle with tip (tipPayer pays tip; tip tx is appended)
+const ok = await client.sendBundleAndConfirm([signedTx1, signedTx2], tipPayer);
+```
+
+### With options
+
+```ts
+await client.sendBundleAndConfirm(txs, tipPayer, {
+  commitment: "finalized",       // blockhash commitment for tip tx
+  simulate: true,                 // simulate each tx before sending
+  uuid: "your-jito-uuid",        // optional API uuid
+  confirmationCommitment: "finalized",  // wait until last tx is finalized
+});
+```
+
+### Send without waiting
+
+```ts
+const result = await client.sendBundle(txs, tipPayer, { simulate: true });
+if (result) {
+  console.log("Bundle ID:", result.bundleId);
+  const landed = await client.waitForBundleConfirmation(result.lastTx, "finalized");
+}
+```
+
+### Custom tip account / amount and logger
+
+```ts
+const client = new JitoClient(connection, {
+  tipAccount: "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
+  tipSol: 0.00001,
+  logger: {
+    logError: (msg) => console.error(msg),
+    logWarning: (msg) => console.warn(msg),
+  },
+});
+```
+
+## API
+
+- **`JitoClient`** – Main class. Constructor: `new JitoClient(connection, config?)`.
+  - **`sendBundle(txs, tipPayer, options?)`** – Send bundle; returns `{ bundleId, lastTx }` or `null`.
+  - **`sendBundleAndConfirm(txs, tipPayer, options?)`** – Send and wait for last tx to reach `confirmationCommitment`; returns `boolean`.
+  - **`waitForBundleConfirmation(lastTx, commitment?)`** – Poll until last tx reaches `finalized` or `confirmed`.
+
+- **`BundleOptions`** – `commitment`, `simulate`, `uuid`, `confirmationCommitment`.
+- **`JitoClientConfig`** – `tipAccount`, `tipSol`, `logger`.
+- **Constants** – `JITO_BLOCK_ENGINE_HOSTS`, `JITO_TIP_ACCOUNT_DEFAULT`, `JITO_TIP_SOL_DEFAULT`.
+
+## License
+
+MIT

package/dist/JitoClient.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Jito Block Engine client. Send bundles, optional tip tx, wait for confirmation.
+ */
+import { Connection, Keypair, VersionedTransaction } from "@solana/web3.js";
+import type { BundleOptions, JitoClientConfig, SendBundleResult } from "./types";
+export declare class JitoClient {
+    readonly connection: Connection;
+    readonly tipSol: number;
+    private readonly log;
+    constructor(connection: Connection, config?: JitoClientConfig);
+    /**
+     * Send a bundle via Jito Block Engine HTTP API.
+     * @param signedTransactions - Up to 5 signed VersionedTransactions (serialized to base58).
+     * @param tipPayer - Optional keypair to pay Jito tip (adds tip tx to bundle).
+     * @param options - commitment, simulate, uuid, confirmationCommitment.
+     * @returns { bundleId, lastTx } or null on failure.
+     */
+    sendBundle(signedTransactions: VersionedTransaction[], tipPayer: Keypair | null, options?: BundleOptions): Promise<SendBundleResult>;
+    /**
+     * Wait for the last transaction in a bundle to reach the given commitment on-chain.
+     */
+    waitForBundleConfirmation(lastSignedTx: VersionedTransaction, commitment?: "finalized" | "confirmed"): Promise<boolean>;
+    /**
+     * Send a bundle and wait for the last tx to reach the requested commitment.
+     * @returns true if bundle was sent and the last tx reached confirmationCommitment on-chain.
+     */
+    sendBundleAndConfirm(signedTransactions: VersionedTransaction[], tipPayer: Keypair | null, options?: BundleOptions): Promise<boolean>;
+}
+//# sourceMappingURL=JitoClient.d.ts.map

package/dist/JitoClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JitoClient.d.ts","sourceRoot":"","sources":["../src/JitoClient.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,oBAAoB,EAAoB,MAAM,iBAAiB,CAAC;AAK9F,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAqCjB,qBAAa,UAAU;IACrB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkC;gBAE1C,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,gBAAgB;IAM7D;;;;;;OAMG;IACG,UAAU,CACd,kBAAkB,EAAE,oBAAoB,EAAE,EAC1C,QAAQ,EAAE,OAAO,GAAG,IAAI,EACxB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,gBAAgB,CAAC;IA4G5B;;OAEG;IACG,yBAAyB,CAC7B,YAAY,EAAE,oBAAoB,EAClC,UAAU,GAAE,WAAW,GAAG,WAAyB,GAClD,OAAO,CAAC,OAAO,CAAC;IAoBnB;;;OAGG;IACG,oBAAoB,CACxB,kBAAkB,EAAE,oBAAoB,EAAE,EAC1C,QAAQ,EAAE,OAAO,GAAG,IAAI,EACxB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC;CAYpB"}

package/dist/JitoClient.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Jito Block Engine client. Send bundles, optional tip tx, wait for confirmation.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitoClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const bs58_1 = __importDefault(require("bs58"));
+const jito_tip_tx_1 = require("@solana-mev-sdk/jito-tip-tx");
+const constants_1 = require("./constants");
+const constants_2 = require("./constants");
+const logger_1 = require("./logger");
+const BUNDLE_FINALIZE_TIMEOUT_MS = 50000;
+const BUNDLE_POLL_INTERVAL_MS = 500;
+const JITO_429_RETRY_MS = 4000;
+const JITO_429_MAX_RETRIES = 3;
+const DEFAULT_BUNDLE_OPTIONS = {
+    commitment: "finalized",
+    simulate: true,
+    uuid: null,
+    confirmationCommitment: "finalized",
+};
+function resolveBundleOptions(options) {
+    if (!options)
+        return DEFAULT_BUNDLE_OPTIONS;
+    return {
+        commitment: options.commitment ?? DEFAULT_BUNDLE_OPTIONS.commitment,
+        simulate: options.simulate ?? DEFAULT_BUNDLE_OPTIONS.simulate,
+        uuid: options.uuid ?? DEFAULT_BUNDLE_OPTIONS.uuid,
+        confirmationCommitment: options.confirmationCommitment ?? DEFAULT_BUNDLE_OPTIONS.confirmationCommitment,
+    };
+}
+function shortMessage(err) {
+    if (axios_1.default.isAxiosError(err)) {
+        const status = err.response?.status;
+        const msg = err.response?.data?.error?.message ?? err.message;
+        return status ? `HTTP ${status}: ${msg}` : msg;
+    }
+    if (err && typeof err === "object" && "message" in err) {
+        return String(err.message);
+    }
+    return err instanceof Error ? err.message : String(err);
+}
+class JitoClient {
+    constructor(connection, config) {
+        this.connection = connection;
+        this.tipSol = config?.tipSol ?? constants_2.JITO_TIP_SOL_DEFAULT;
+        this.log = (0, logger_1.createLogger)(config?.logger);
+    }
+    /**
+     * Send a bundle via Jito Block Engine HTTP API.
+     * @param signedTransactions - Up to 5 signed VersionedTransactions (serialized to base58).
+     * @param tipPayer - Optional keypair to pay Jito tip (adds tip tx to bundle).
+     * @param options - commitment, simulate, uuid, confirmationCommitment.
+     * @returns { bundleId, lastTx } or null on failure.
+     */
+    async sendBundle(signedTransactions, tipPayer, options) {
+        const opts = resolveBundleOptions(options);
+        if (signedTransactions.length === 0 || signedTransactions.length > 5) {
+            this.log.logError("Jito: bundle must contain 1–5 transactions.");
+            return null;
+        }
+        let transactionsToSend = signedTransactions;
+        let lastTx = signedTransactions[signedTransactions.length - 1];
+        if (tipPayer) {
+            const tipTx = await (0, jito_tip_tx_1.createTipTransaction)(this.connection, tipPayer, this.tipSol, opts.commitment);
+            tipTx.sign([tipPayer]);
+            transactionsToSend = [...signedTransactions, tipTx];
+            lastTx = tipTx;
+            if (transactionsToSend.length > 5) {
+                this.log.logError("Jito: bundle + tip would exceed 5 transactions.");
+                return null;
+            }
+        }
+        if (opts.simulate) {
+            for (let i = 0; i < transactionsToSend.length; i++) {
+                const sim = await this.connection.simulateTransaction(transactionsToSend[i], {
+                    replaceRecentBlockhash: true,
+                    sigVerify: false,
+                });
+                if (sim.value.err) {
+                    this.log.logError(`Jito: simulation failed for tx ${i + 1}/${transactionsToSend.length}: ${JSON.stringify(sim.value.err)}`);
+                    if (sim.value.logs && sim.value.logs.length > 0) {
+                        this.log.logError("Simulation logs:\n" + sim.value.logs.slice(-20).join("\n"));
+                    }
+                    return null;
+                }
+            }
+        }
+        const serialized = transactionsToSend.map((tx) => bs58_1.default.encode(tx.serialize()));
+        const body = { jsonrpc: "2.0", id: 1, method: "sendBundle", params: [serialized] };
+        const hosts = [...constants_1.JITO_BLOCK_ENGINE_HOSTS].sort(() => Math.random() - 0.5);
+        let lastErr = null;
+        for (let attempt = 0; attempt < JITO_429_MAX_RETRIES; attempt++) {
+            const host = hosts[attempt % hosts.length];
+            const targetUrl = `https://${host}/api/v1/bundles${opts.uuid ? `?uuid=${opts.uuid}` : ""}`;
+            try {
+                const { data } = await axios_1.default.post(targetUrl, body, {
+                    headers: { "Content-Type": "application/json" },
+                    timeout: 15000,
+                });
+                if (data.error) {
+                    lastErr = data.error;
+                    const waitMs = Number(data.error.data?.["x-wait-to-retry-ms"]) || JITO_429_RETRY_MS;
+                    if (data.error.code === 429 || (data.error.message && String(data.error.message).includes("429"))) {
+                        if (attempt < JITO_429_MAX_RETRIES - 1) {
+                            this.log.logWarning(`Jito rate limited (429). Retrying in ${Math.round(waitMs / 1000)}s...`);
+                            await new Promise((r) => setTimeout(r, waitMs));
+                            continue;
+                        }
+                        this.log.logError(`Jito sendBundle: rate limited (code 429). Wait ${Math.round(waitMs / 1000)}s and try again.`);
+                        return null;
+                    }
+                    this.log.logError("Jito sendBundle: code " + (data.error.code ?? "(no code)") + " – " + (data.error.message ?? shortMessage(data.error)));
+                    return null;
+                }
+                const bundleId = data.result;
+                if (!bundleId) {
+                    this.log.logError("Jito sendBundle: no bundle ID in response.");
+                    return null;
+                }
+                return { bundleId, lastTx };
+            }
+            catch (err) {
+                lastErr = err;
+                if (axios_1.default.isAxiosError(err) && err.response?.status === 429) {
+                    const h = err.response?.headers;
+                    const waitMs = Number(h?.["x-wait-to-retry-ms"] ?? h?.["X-Wait-To-Retry-Ms"]) || JITO_429_RETRY_MS;
+                    if (attempt < JITO_429_MAX_RETRIES - 1) {
+                        this.log.logWarning(`Jito rate limited (429). Retrying in ${Math.round(waitMs / 1000)}s...`);
+                        await new Promise((r) => setTimeout(r, waitMs));
+                        continue;
+                    }
+                    this.log.logError(`Jito sendBundle: HTTP 429. Wait ${Math.round(waitMs / 1000)}s and try again.`);
+                    return null;
+                }
+                this.log.logError("Jito sendBundle failed: " + shortMessage(err));
+                return null;
+            }
+        }
+        if (lastErr) {
+            this.log.logError("Jito sendBundle failed after retries: " + shortMessage(lastErr));
+        }
+        return null;
+    }
+    /**
+     * Wait for the last transaction in a bundle to reach the given commitment on-chain.
+     */
+    async waitForBundleConfirmation(lastSignedTx, commitment = "finalized") {
+        const signature = bs58_1.default.encode(lastSignedTx.signatures[0]);
+        const deadline = Date.now() + BUNDLE_FINALIZE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            try {
+                const result = await this.connection.getSignatureStatus(signature, {
+                    searchTransactionHistory: true,
+                });
+                const status = result?.value?.confirmationStatus;
+                if (status === "finalized")
+                    return true;
+                if (commitment === "confirmed" && status === "confirmed")
+                    return true;
+            }
+            catch {
+                // ignore
+            }
+            await new Promise((r) => setTimeout(r, BUNDLE_POLL_INTERVAL_MS));
+        }
+        return false;
+    }
+    /**
+     * Send a bundle and wait for the last tx to reach the requested commitment.
+     * @returns true if bundle was sent and the last tx reached confirmationCommitment on-chain.
+     */
+    async sendBundleAndConfirm(signedTransactions, tipPayer, options) {
+        const opts = resolveBundleOptions(options);
+        const result = await this.sendBundle(signedTransactions, tipPayer, options);
+        if (!result)
+            return false;
+        this.log.logInfo("  Jito bundle ID: " + result.bundleId);
+        const finalized = await this.waitForBundleConfirmation(result.lastTx, opts.confirmationCommitment);
+        if (!finalized) {
+            this.log.logError("Jito: bundle sent but not finalized within timeout.");
+        }
+        return finalized;
+    }
+}
+exports.JitoClient = JitoClient;

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Jito Block Engine and tip defaults.
+ */
+/** Jito block engine hostnames (mainnet). */
+export declare const JITO_BLOCK_ENGINE_HOSTS: readonly ["amsterdam.mainnet.block-engine.jito.wtf", "frankfurt.mainnet.block-engine.jito.wtf", "ny.mainnet.block-engine.jito.wtf", "tokyo.mainnet.block-engine.jito.wtf"];
+/** Default Jito tip account (one of the official mainnet tip accounts). */
+export declare const JITO_TIP_ACCOUNT_DEFAULT = "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5";
+/** Default tip amount in SOL. */
+export declare const JITO_TIP_SOL_DEFAULT = 0.00001;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,6CAA6C;AAC7C,eAAO,MAAM,uBAAuB,4KAK1B,CAAC;AAEX,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB,iDAAiD,CAAC;AAEvF,iCAAiC;AACjC,eAAO,MAAM,oBAAoB,UAAU,CAAC"}

package/dist/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Jito Block Engine and tip defaults.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JITO_TIP_SOL_DEFAULT = exports.JITO_TIP_ACCOUNT_DEFAULT = exports.JITO_BLOCK_ENGINE_HOSTS = void 0;
+/** Jito block engine hostnames (mainnet). */
+exports.JITO_BLOCK_ENGINE_HOSTS = [
+    "amsterdam.mainnet.block-engine.jito.wtf",
+    "frankfurt.mainnet.block-engine.jito.wtf",
+    "ny.mainnet.block-engine.jito.wtf",
+    "tokyo.mainnet.block-engine.jito.wtf",
+];
+/** Default Jito tip account (one of the official mainnet tip accounts). */
+exports.JITO_TIP_ACCOUNT_DEFAULT = "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5";
+/** Default tip amount in SOL. */
+exports.JITO_TIP_SOL_DEFAULT = 0.00001;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * jito-client: Jito Block Engine client for Solana bundles.
+ *
+ * Usage:
+ *   import { Connection } from "@solana/web3.js";
+ *   import { JitoClient } from "jito-client";
+ *
+ *   const connection = new Connection("https://api.mainnet-beta.solana.com");
+ *   const client = new JitoClient(connection);
+ *   const ok = await client.sendBundleAndConfirm([tx], tipPayer, { simulate: true });
+ */
+export { JitoClient } from "./JitoClient";
+export { JITO_BLOCK_ENGINE_HOSTS, JITO_TIP_ACCOUNT_DEFAULT, JITO_TIP_SOL_DEFAULT, } from "./constants";
+export type { BundleOptions, JitoClientConfig, JitoClientLogger, OnTipSent, ResolvedBundleOptions, SendBundleResult, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * jito-client: Jito Block Engine client for Solana bundles.
+ *
+ * Usage:
+ *   import { Connection } from "@solana/web3.js";
+ *   import { JitoClient } from "jito-client";
+ *
+ *   const connection = new Connection("https://api.mainnet-beta.solana.com");
+ *   const client = new JitoClient(connection);
+ *   const ok = await client.sendBundleAndConfirm([tx], tipPayer, { simulate: true });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JITO_TIP_SOL_DEFAULT = exports.JITO_TIP_ACCOUNT_DEFAULT = exports.JITO_BLOCK_ENGINE_HOSTS = exports.JitoClient = void 0;
+var JitoClient_1 = require("./JitoClient");
+Object.defineProperty(exports, "JitoClient", { enumerable: true, get: function () { return JitoClient_1.JitoClient; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "JITO_BLOCK_ENGINE_HOSTS", { enumerable: true, get: function () { return constants_1.JITO_BLOCK_ENGINE_HOSTS; } });
+Object.defineProperty(exports, "JITO_TIP_ACCOUNT_DEFAULT", { enumerable: true, get: function () { return constants_1.JITO_TIP_ACCOUNT_DEFAULT; } });
+Object.defineProperty(exports, "JITO_TIP_SOL_DEFAULT", { enumerable: true, get: function () { return constants_1.JITO_TIP_SOL_DEFAULT; } });

package/dist/logger.d.ts

@@ -0,0 +1,7 @@
+import type { JitoClientLogger } from "./types";
+export declare function createLogger(custom?: JitoClientLogger): {
+    logError: (m: string) => void;
+    logWarning: (m: string) => void;
+    logInfo: (m: string) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA8BhD,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG;IAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,CAMxJ"}

package/dist/logger.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+function isTty() {
+    return typeof process !== "undefined" && process.stderr?.isTTY === true;
+}
+function defaultLogError(message) {
+    if (isTty()) {
+        process.stderr.write(`${RED}${message}${RESET}\n`);
+    }
+    else {
+        process.stderr.write(`${message}\n`);
+    }
+}
+function defaultLogWarning(message) {
+    if (isTty()) {
+        process.stderr.write(`${YELLOW}${message}${RESET}\n`);
+    }
+    else {
+        process.stderr.write(`${message}\n`);
+    }
+}
+function defaultLogInfo(message) {
+    process.stderr.write(`${message}\n`);
+}
+function createLogger(custom) {
+    return {
+        logError: custom?.logError ?? defaultLogError,
+        logWarning: custom?.logWarning ?? defaultLogWarning,
+        logInfo: custom?.logInfo ?? console.log
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+import type { VersionedTransaction } from "@solana/web3.js";
+/** Result of sendBundle: bundle id and the last tx (e.g. tip tx) for confirmation. */
+export type SendBundleResult = {
+    bundleId: string;
+    lastTx: VersionedTransaction;
+} | null;
+/** Options for sendBundle and sendBundleAndConfirm. */
+export interface BundleOptions {
+    /** Commitment for getLatestBlockhash when building tip tx. Default "finalized". */
+    commitment?: "finalized" | "confirmed" | "processed";
+    /** Simulate each tx before sending; if any fails, do not send. Default true. */
+    simulate?: boolean;
+    /** Optional Jito API uuid query param (e.g. for authenticated endpoints). */
+    uuid?: string | null;
+    /** Consider bundle landed when last tx reaches this status. Default "finalized". */
+    confirmationCommitment?: "finalized" | "confirmed";
+}
+/** Resolved options (all optional fields filled). */
+export type ResolvedBundleOptions = Required<Omit<BundleOptions, "uuid">> & {
+    uuid?: string | null;
+};
+/** Optional logger; defaults to stderr for errors/warnings. */
+export interface JitoClientLogger {
+    logError?(message: string): void;
+    logWarning?(message: string): void;
+    logInfo?(message: string): void;
+}
+/** Called when a bundle that includes a tip is sent successfully. Use to report lamports tipped to your API. */
+export type OnTipSent = (lamports: number) => void | Promise<void>;
+/** Config passed to JitoClient constructor. */
+export interface JitoClientConfig {
+    /** Tip account address when adding tip tx. Default JITO_TIP_ACCOUNT_DEFAULT. */
+    tipAccount?: string;
+    /** Tip amount in SOL when adding tip tx. Default JITO_TIP_SOL_DEFAULT. */
+    tipSol?: number;
+    /** Custom logger (errors/warnings). */
+    logger?: JitoClientLogger;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE,GAAG,IAAI,CAAC;AAEzF,uDAAuD;AACvD,MAAM,WAAW,aAAa;IAC5B,mFAAmF;IACnF,UAAU,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;IACrD,gFAAgF;IAChF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,oFAAoF;IACpF,sBAAsB,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;CACpD;AAED,qDAAqD;AACrD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAErG,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,gHAAgH;AAChH,MAAM,MAAM,SAAS,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnE,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@solana-mev-sdk/jito-client",
+  "version": "0.2.8",
+  "description": "Jito Block Engine client — send bundles, tip tx, wait for confirmation",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "jito",
+    "solana",
+    "bundle",
+    "mev",
+    "block-engine"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "@solana/web3.js": "^1.80.0"
+  },
+  "dependencies": {
+    "axios": "^1.11.0",
+    "bs58": "^6.0.0",
+    "@solana-mev-sdk/jito-tip-tx": "^0.3.2"
+  },
+  "devDependencies": {
+    "@solana/web3.js": "^1.98.4",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.9.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solana-mev-sdk/jito-client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/solana-mev-sdk/jito-client/issues"
+  },
+  "homepage": "https://github.com/solana-mev-sdk/jito-client#readme"
+}