solami 0.1.7

package/README.md

@@ -0,0 +1,201 @@
+# solami
+
+TypeScript SDK for [solami.fast](https://solami.fast) - Solana RPC, gRPC streaming, WebSocket subscriptions, and SWQOS transaction landing.
+
+## Install
+
+```bash
+npm install solami
+```
+
+## Setup
+
+Create a `.env` file:
+
+```
+SOLAMI_RPC_TOKEN=your_rpc_token_here
+SOLANA_KEYPAIR=your_base58_keypair_here
+SOLAMI_SWQOS_KEY=your_swqos_key_here
+```
+
+Get your tokens from the [solami.fast dashboard](https://solami.fast).
+
+## Usage
+
+### Get Account Info
+
+```ts
+import "dotenv/config";
+import { PublicKey } from "@solana/web3.js";
+import { solamiFromEnv } from "solami";
+
+const client = solamiFromEnv().build();
+const pubkey = new PublicKey("11111111111111111111111111111111");
+const account = await client.connection.getAccountInfo(pubkey);
+
+console.log(`Lamports: ${account?.lamports}`);
+console.log(`Owner: ${account?.owner}`);
+```
+
+### Get Balance
+
+```ts
+import "dotenv/config";
+import { PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
+import { solamiFromEnv } from "solami";
+
+const client = solamiFromEnv().build();
+const pubkey = new PublicKey("11111111111111111111111111111111");
+const balance = await client.connection.getBalance(pubkey);
+
+console.log(`Balance: ${balance / LAMPORTS_PER_SOL} SOL`);
+```
+
+### Send Transaction (RPC)
+
+```ts
+import "dotenv/config";
+import { Keypair, PublicKey, Transaction, SystemProgram, sendAndConfirmTransaction } from "@solana/web3.js";
+import bs58 from "bs58";
+import { solamiFromEnv } from "solami";
+
+const client = solamiFromEnv().build();
+const payer = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_KEYPAIR!));
+const recipient = new PublicKey("11111111111111111111111111111112");
+
+const blockhash = await client.connection.getLatestBlockhash();
+const tx = new Transaction({ ...blockhash, feePayer: payer.publicKey }).add(
+  SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: recipient, lamports: 1 }),
+);
+
+const sig = await sendAndConfirmTransaction(client.connection, tx, [payer]);
+console.log(`Signature: ${sig}`);
+```
+
+### Send Transaction (SWQOS)
+
+```ts
+import "dotenv/config";
+import { Keypair, PublicKey, TransactionMessage, VersionedTransaction, SystemProgram } from "@solana/web3.js";
+import bs58 from "bs58";
+import { solamiFromEnv, buildTipIx } from "solami";
+
+const client = solamiFromEnv().buildWithSwqos();
+const payer = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_KEYPAIR!));
+const recipient = new PublicKey("11111111111111111111111111111112");
+
+const blockhash = await client.connection.getLatestBlockhash();
+const message = new TransactionMessage({
+  payerKey: payer.publicKey,
+  recentBlockhash: blockhash.blockhash,
+  instructions: [
+    SystemProgram.transfer({ fromPubkey: payer.publicKey, toPubkey: recipient, lamports: 1 }),
+    buildTipIx(payer.publicKey, 0.0001),
+  ],
+}).compileToV0Message();
+
+const tx = new VersionedTransaction(message);
+tx.sign([payer]);
+
+const sig = await client.landTransaction(tx);
+console.log(`Signature: ${sig}`);
+```
+
+### gRPC: Subscribe to Slots
+
+```ts
+import "dotenv/config";
+import { solamiFromEnv, SubscriptionBuilder } from "solami";
+
+const client = solamiFromEnv().build();
+const request = new SubscriptionBuilder()
+  .addSlots("slot_sub", { filterByCommitment: undefined, interslotUpdates: false })
+  .build();
+
+const stream = await client.grpc.subscribe(request);
+
+stream.on("data", (msg: any) => {
+  if (msg.slot) {
+    console.log(`Slot: ${msg.slot.slot} | Parent: ${msg.slot.parent} | Status: ${msg.slot.status}`);
+  }
+});
+```
+
+### gRPC: Subscribe to Transactions
+
+```ts
+import "dotenv/config";
+import { solamiFromEnv, CommitmentLevel } from "solami";
+import bs58 from "bs58";
+
+const client = solamiFromEnv().build();
+const stream = await client.grpc.subscribeTransactions(
+  "tx_sub",
+  ["11111111111111111111111111111111"],
+  CommitmentLevel.CONFIRMED,
+);
+
+stream.on("data", (msg: any) => {
+  if (msg.transaction) {
+    const sig = bs58.encode(Buffer.from(msg.transaction.transaction.signature));
+    console.log(`Signature: ${sig} | Slot: ${msg.transaction.slot}`);
+  }
+});
+```
+
+### WebSocket: Subscribe to Slots
+
+```ts
+import "dotenv/config";
+import { solamiFromEnv } from "solami";
+
+const client = solamiFromEnv().build();
+client.ws.connection.onSlotChange((slotInfo) => {
+  console.log(`Slot: ${slotInfo.slot} | Parent: ${slotInfo.parent} | Root: ${slotInfo.root}`);
+});
+```
+
+### WebSocket: Subscribe to Logs
+
+```ts
+import "dotenv/config";
+import { PublicKey } from "@solana/web3.js";
+import { solamiFromEnv } from "solami";
+
+const client = solamiFromEnv().build();
+const programId = new PublicKey("11111111111111111111111111111111");
+
+client.ws.connection.onLogs(programId, (log) => {
+  console.log(`Signature: ${log.signature}`);
+  for (const line of log.logs) {
+    console.log(`  ${line}`);
+  }
+}, "confirmed");
+```
+
+## Builder Configuration
+
+```ts
+import { solami } from "solami";
+
+const client = solami("your_rpc_token")
+  .grpcToken("optional_separate_grpc_token")
+  .rpcBase("https://custom-rpc.example.com")
+  .wsBase("wss://custom-ws.example.com")
+  .grpcUrl("https://custom-grpc.example.com")
+  .swqosKey("your_swqos_key")
+  .buildWithSwqos();
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `SOLAMI_RPC_TOKEN` | Yes | RPC/gRPC API token |
+| `SOLAMI_GRPC_TOKEN` | No | Separate gRPC token (defaults to RPC token) |
+| `SOLAMI_SWQOS_KEY` | No | SWQOS API key (required for `buildWithSwqos()`) |
+| `SOLANA_KEYPAIR` | No | Base58 keypair (required for sending transactions) |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,477 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CommitmentLevel: () => import_yellowstone_grpc.CommitmentLevel,
+  DEFAULT_GRPC_URL: () => DEFAULT_GRPC_URL,
+  DEFAULT_RPC_BASE: () => DEFAULT_RPC_BASE,
+  DEFAULT_WS_BASE: () => DEFAULT_WS_BASE,
+  ENDPOINTS: () => ENDPOINTS,
+  ENV_GRPC_TOKEN: () => ENV_GRPC_TOKEN,
+  ENV_RPC_TOKEN: () => ENV_RPC_TOKEN,
+  ENV_SWQOS_KEY: () => ENV_SWQOS_KEY,
+  MIN_TIP_SOL: () => MIN_TIP_SOL,
+  SolamiBuilder: () => SolamiBuilder,
+  SolamiClient: () => SolamiClient,
+  SolamiError: () => SolamiError,
+  SolamiGrpc: () => SolamiGrpc,
+  SolamiRpc: () => SolamiRpc,
+  SolamiWs: () => SolamiWs,
+  SubscriptionBuilder: () => SubscriptionBuilder,
+  SwqosClient: () => SwqosClient,
+  TIP_ACCOUNTS: () => TIP_ACCOUNTS,
+  TIP_API_URL: () => TIP_API_URL,
+  buildTipIx: () => buildTipIx,
+  configFromEnv: () => configFromEnv,
+  createConfig: () => createConfig,
+  extractTip: () => extractTip,
+  fetchTipAccounts: () => fetchTipAccounts,
+  rpcUrl: () => rpcUrl,
+  solami: () => solami,
+  solamiFromEnv: () => solamiFromEnv,
+  wsUrl: () => wsUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/error.ts
+var SolamiError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "SolamiError";
+  }
+};
+
+// src/config.ts
+var DEFAULT_RPC_BASE = "https://rpc.solami.fast/sol";
+var DEFAULT_WS_BASE = "wss://rpc.solami.fast/ws/sol";
+var DEFAULT_GRPC_URL = "https://grpc.solami.fast";
+var ENV_RPC_TOKEN = "SOLAMI_RPC_TOKEN";
+var ENV_GRPC_TOKEN = "SOLAMI_GRPC_TOKEN";
+var ENV_SWQOS_KEY = "SOLAMI_SWQOS_KEY";
+function createConfig(rpcToken) {
+  return {
+    rpcToken,
+    grpcToken: rpcToken,
+    rpcBase: DEFAULT_RPC_BASE,
+    wsBase: DEFAULT_WS_BASE,
+    grpcUrl: DEFAULT_GRPC_URL
+  };
+}
+function configFromEnv() {
+  const rpcToken = process.env[ENV_RPC_TOKEN];
+  if (!rpcToken) {
+    throw new SolamiError("CONFIG_MISSING", `missing environment variable: ${ENV_RPC_TOKEN}`);
+  }
+  const grpcToken = process.env[ENV_GRPC_TOKEN] ?? rpcToken;
+  const swqosKey = process.env[ENV_SWQOS_KEY] ?? void 0;
+  return {
+    rpcToken,
+    grpcToken,
+    rpcBase: DEFAULT_RPC_BASE,
+    wsBase: DEFAULT_WS_BASE,
+    grpcUrl: DEFAULT_GRPC_URL,
+    swqosKey
+  };
+}
+function rpcUrl(config) {
+  return `${config.rpcBase}?api_key=${config.rpcToken}`;
+}
+function wsUrl(config) {
+  return `${config.wsBase}?api_key=${config.rpcToken}`;
+}
+
+// src/rpc.ts
+var import_web3 = require("@solana/web3.js");
+var SolamiRpc = class {
+  connection;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.connection = new import_web3.Connection(rpcUrl(config), "confirmed");
+  }
+  get url() {
+    return rpcUrl(this.config);
+  }
+  async getBlock(slot) {
+    const block = await this.connection.getBlock(slot, {
+      maxSupportedTransactionVersion: 0
+    });
+    if (!block) {
+      throw new Error(`block not found at slot ${slot}`);
+    }
+    return block;
+  }
+};
+
+// src/websocket.ts
+var import_web32 = require("@solana/web3.js");
+var SolamiWs = class {
+  connection;
+  constructor(config) {
+    this.connection = new import_web32.Connection(rpcUrl(config), {
+      wsEndpoint: wsUrl(config),
+      commitment: "confirmed"
+    });
+  }
+};
+
+// src/grpc/client.ts
+var import_yellowstone_grpc2 = __toESM(require("@triton-one/yellowstone-grpc"), 1);
+
+// src/grpc/subscription-builder.ts
+var import_yellowstone_grpc = require("@triton-one/yellowstone-grpc");
+var SubscriptionBuilder = class {
+  accounts = {};
+  slots = {};
+  transactions = {};
+  transactionsStatus = {};
+  blocks = {};
+  blocksMeta = {};
+  entry = {};
+  _commitment;
+  accountsDataSlice = [];
+  _fromSlot;
+  commitment(level) {
+    this._commitment = level;
+    return this;
+  }
+  fromSlot(slot) {
+    this._fromSlot = slot.toString();
+    return this;
+  }
+  addAccounts(label, filter) {
+    this.accounts[label] = filter;
+    return this;
+  }
+  addSlots(label, filter) {
+    this.slots[label] = filter;
+    return this;
+  }
+  addTransactions(label, filter) {
+    this.transactions[label] = filter;
+    return this;
+  }
+  addTransactionsStatus(label, filter) {
+    this.transactionsStatus[label] = filter;
+    return this;
+  }
+  addBlocks(label, filter) {
+    this.blocks[label] = filter;
+    return this;
+  }
+  addBlocksMeta(label) {
+    this.blocksMeta[label] = {};
+    return this;
+  }
+  addEntry(label) {
+    this.entry[label] = {};
+    return this;
+  }
+  addAccountsDataSlice(offset, length) {
+    this.accountsDataSlice.push({ offset, length });
+    return this;
+  }
+  build() {
+    return {
+      accounts: this.accounts,
+      slots: this.slots,
+      transactions: this.transactions,
+      transactionsStatus: this.transactionsStatus,
+      blocks: this.blocks,
+      blocksMeta: this.blocksMeta,
+      entry: this.entry,
+      commitment: this._commitment,
+      accountsDataSlice: this.accountsDataSlice,
+      ping: void 0,
+      fromSlot: this._fromSlot
+    };
+  }
+};
+
+// src/grpc/client.ts
+var Client = import_yellowstone_grpc2.default.default ?? import_yellowstone_grpc2.default;
+var SolamiGrpc = class {
+  client;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.client = new Client(config.grpcUrl, config.grpcToken, void 0);
+  }
+  get url() {
+    return this.config.grpcUrl;
+  }
+  async subscribe(request) {
+    try {
+      const stream = await this.client.subscribe();
+      stream.write(request);
+      return stream;
+    } catch (e) {
+      throw new SolamiError("GRPC_ERROR", e.message ?? String(e));
+    }
+  }
+  async subscribeTransactions(label, accounts, commitment) {
+    const request = new SubscriptionBuilder().addTransactions(label, {
+      vote: false,
+      failed: false,
+      accountInclude: accounts,
+      accountExclude: [],
+      accountRequired: [],
+      signature: void 0
+    }).commitment(commitment).build();
+    return this.subscribe(request);
+  }
+};
+
+// src/swqos/client.ts
+var import_bs58 = __toESM(require("bs58"), 1);
+var SWQOS_SEND_URL = "https://swqos.solami.fast/api/v1/transactions";
+var SwqosClient = class {
+  endpoint;
+  apiKey;
+  constructor(apiKey, endpoint) {
+    this.apiKey = apiKey;
+    this.endpoint = endpoint ?? SWQOS_SEND_URL;
+  }
+  async sendTransaction(tx) {
+    const sig = import_bs58.default.encode(tx.signatures[0]);
+    const serialized = import_bs58.default.encode(tx.serialize());
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        transaction: serialized,
+        encoding: "base58"
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new SolamiError("SWQOS_ERROR", `send failed (${res.status}): ${body}`);
+    }
+    return sig;
+  }
+};
+
+// src/swqos/constants.ts
+var import_web33 = require("@solana/web3.js");
+var ENDPOINTS = ["landing.solami.fast:11000"];
+var TIP_ACCOUNTS = [
+  new import_web33.PublicKey("6993ZufwyEDNdB94kciDTGB17ANXguiNH22VmMQU1ami"),
+  new import_web33.PublicKey("E1BkG293HQocKfCkfPS7tEvs8Enh6FK8pUKi17EH1ami"),
+  new import_web33.PublicKey("2Ga87xvZwpP9WRsSdiPiWre21cQbDcFhGLmT5EMo1ami"),
+  new import_web33.PublicKey("CGzT5jzT68vGUWVagQAQqESfrCEHSKYe9DAjfgfC1ami")
+];
+var TIP_API_URL = "https://api.solami.fast/onchain/tip-addresses";
+var MIN_TIP_SOL = 1e-4;
+
+// src/swqos/tip.ts
+var import_web34 = require("@solana/web3.js");
+function buildTipIx(payer, sol) {
+  const amount = sol < MIN_TIP_SOL ? MIN_TIP_SOL : sol;
+  const lamports = Math.floor(amount * import_web34.LAMPORTS_PER_SOL);
+  const tipAccount = TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)];
+  return import_web34.SystemProgram.transfer({
+    fromPubkey: payer,
+    toPubkey: tipAccount,
+    lamports
+  });
+}
+async function fetchTipAccounts() {
+  const res = await fetch(TIP_API_URL);
+  if (!res.ok) {
+    throw new SolamiError("API_ERROR", `fetch tip accounts failed: ${res.status}`);
+  }
+  const addresses = await res.json();
+  return addresses.map((a) => new import_web34.PublicKey(a));
+}
+function extractTip(tx, tipPubkeys = TIP_ACCOUNTS) {
+  const keys = tx.message.staticAccountKeys;
+  const systemProgramId = import_web34.SystemProgram.programId;
+  for (const ix of tx.message.compiledInstructions) {
+    const programKey = keys[ix.programIdIndex];
+    if (!programKey || !programKey.equals(systemProgramId)) continue;
+    if (ix.data.length < 12) continue;
+    const ixType = ix.data[0] | ix.data[1] << 8 | ix.data[2] << 16 | ix.data[3] << 24;
+    if (ixType !== 2) continue;
+    const view = new DataView(ix.data.buffer, ix.data.byteOffset);
+    const lamports = Number(view.getBigUint64(4, true));
+    const toIndex = ix.accountKeyIndexes[1];
+    if (toIndex === void 0) continue;
+    const toPubkey = keys[toIndex];
+    if (!toPubkey) continue;
+    if (tipPubkeys.some((tip) => tip.equals(toPubkey))) {
+      return { lamports, tipAccount: toPubkey };
+    }
+  }
+  return null;
+}
+
+// src/client.ts
+var SolamiClient = class {
+  config;
+  rpc;
+  ws;
+  grpc;
+  swqos;
+  constructor(config, swqos) {
+    this.config = config;
+    this.rpc = new SolamiRpc(config);
+    this.ws = new SolamiWs(config);
+    this.grpc = new SolamiGrpc(config);
+    this.swqos = swqos;
+  }
+  get connection() {
+    return this.rpc.connection;
+  }
+  async landTransaction(tx) {
+    if (!this.swqos) {
+      throw new SolamiError("SWQOS_ERROR", "client was built without swqos support");
+    }
+    if (!extractTip(tx, TIP_ACCOUNTS)) {
+      throw new SolamiError("TIP_MISSING", "transaction must include a tip instruction");
+    }
+    return this.swqos.sendTransaction(tx);
+  }
+};
+
+// src/builder.ts
+var SolamiBuilder = class _SolamiBuilder {
+  _rpcToken;
+  _grpcToken;
+  _rpcBase;
+  _wsBase;
+  _grpcUrl;
+  _swqosKey;
+  constructor(rpcToken) {
+    this._rpcToken = rpcToken;
+  }
+  static fromEnv() {
+    const builder = new _SolamiBuilder(process.env[ENV_RPC_TOKEN] ?? void 0);
+    builder._grpcToken = process.env[ENV_GRPC_TOKEN] ?? void 0;
+    builder._swqosKey = process.env[ENV_SWQOS_KEY] ?? void 0;
+    return builder;
+  }
+  grpcToken(token) {
+    this._grpcToken = token;
+    return this;
+  }
+  rpcBase(url) {
+    this._rpcBase = url;
+    return this;
+  }
+  wsBase(url) {
+    this._wsBase = url;
+    return this;
+  }
+  grpcUrl(url) {
+    this._grpcUrl = url;
+    return this;
+  }
+  swqosKey(key) {
+    this._swqosKey = key;
+    return this;
+  }
+  intoConfig() {
+    const rpcToken = this._rpcToken;
+    if (!rpcToken) {
+      throw new SolamiError(
+        "CONFIG_MISSING",
+        `missing ${ENV_RPC_TOKEN} (set via env or new SolamiBuilder("token"))`
+      );
+    }
+    return {
+      rpcToken,
+      grpcToken: this._grpcToken ?? rpcToken,
+      rpcBase: this._rpcBase ?? DEFAULT_RPC_BASE,
+      wsBase: this._wsBase ?? DEFAULT_WS_BASE,
+      grpcUrl: this._grpcUrl ?? DEFAULT_GRPC_URL,
+      swqosKey: this._swqosKey
+    };
+  }
+  build() {
+    const config = this.intoConfig();
+    return new SolamiClient(config);
+  }
+  buildWithSwqos() {
+    const config = this.intoConfig();
+    if (!config.swqosKey) {
+      throw new SolamiError(
+        "CONFIG_MISSING",
+        `missing ${ENV_SWQOS_KEY} (set via env or .swqosKey("key"))`
+      );
+    }
+    const swqos = new SwqosClient(config.swqosKey);
+    return new SolamiClient(config, swqos);
+  }
+};
+
+// src/index.ts
+function solami(token) {
+  return new SolamiBuilder(token);
+}
+function solamiFromEnv() {
+  return SolamiBuilder.fromEnv();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommitmentLevel,
+  DEFAULT_GRPC_URL,
+  DEFAULT_RPC_BASE,
+  DEFAULT_WS_BASE,
+  ENDPOINTS,
+  ENV_GRPC_TOKEN,
+  ENV_RPC_TOKEN,
+  ENV_SWQOS_KEY,
+  MIN_TIP_SOL,
+  SolamiBuilder,
+  SolamiClient,
+  SolamiError,
+  SolamiGrpc,
+  SolamiRpc,
+  SolamiWs,
+  SubscriptionBuilder,
+  SwqosClient,
+  TIP_ACCOUNTS,
+  TIP_API_URL,
+  buildTipIx,
+  configFromEnv,
+  createConfig,
+  extractTip,
+  fetchTipAccounts,
+  rpcUrl,
+  solami,
+  solamiFromEnv,
+  wsUrl
+});

package/dist/index.d.cts

@@ -0,0 +1,131 @@
+import * as _solana_web3_js from '@solana/web3.js';
+import { Connection, BlockResponse, VersionedTransaction, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { CommitmentLevel, SubscribeRequestFilterAccounts, SubscribeRequestFilterSlots, SubscribeRequestFilterTransactions, SubscribeRequestFilterBlocks, SubscribeRequest, SubscribeUpdate } from '@triton-one/yellowstone-grpc';
+export { CommitmentLevel, SubscribeRequest } from '@triton-one/yellowstone-grpc';
+import { ClientDuplexStream } from '@grpc/grpc-js';
+
+declare const DEFAULT_RPC_BASE = "https://rpc.solami.fast/sol";
+declare const DEFAULT_WS_BASE = "wss://rpc.solami.fast/ws/sol";
+declare const DEFAULT_GRPC_URL = "https://grpc.solami.fast";
+declare const ENV_RPC_TOKEN = "SOLAMI_RPC_TOKEN";
+declare const ENV_GRPC_TOKEN = "SOLAMI_GRPC_TOKEN";
+declare const ENV_SWQOS_KEY = "SOLAMI_SWQOS_KEY";
+interface SolamiConfig {
+    rpcToken: string;
+    grpcToken: string;
+    rpcBase: string;
+    wsBase: string;
+    grpcUrl: string;
+    swqosKey?: string;
+}
+declare function createConfig(rpcToken: string): SolamiConfig;
+declare function configFromEnv(): SolamiConfig;
+declare function rpcUrl(config: SolamiConfig): string;
+declare function wsUrl(config: SolamiConfig): string;
+
+declare class SolamiRpc {
+    readonly connection: Connection;
+    private readonly config;
+    constructor(config: SolamiConfig);
+    get url(): string;
+    getBlock(slot: number): Promise<BlockResponse>;
+}
+
+declare class SolamiWs {
+    readonly connection: Connection;
+    constructor(config: SolamiConfig);
+}
+
+declare class SubscriptionBuilder {
+    private accounts;
+    private slots;
+    private transactions;
+    private transactionsStatus;
+    private blocks;
+    private blocksMeta;
+    private entry;
+    private _commitment?;
+    private accountsDataSlice;
+    private _fromSlot?;
+    commitment(level: CommitmentLevel): this;
+    fromSlot(slot: bigint | number | string): this;
+    addAccounts(label: string, filter: SubscribeRequestFilterAccounts): this;
+    addSlots(label: string, filter: SubscribeRequestFilterSlots): this;
+    addTransactions(label: string, filter: SubscribeRequestFilterTransactions): this;
+    addTransactionsStatus(label: string, filter: SubscribeRequestFilterTransactions): this;
+    addBlocks(label: string, filter: SubscribeRequestFilterBlocks): this;
+    addBlocksMeta(label: string): this;
+    addEntry(label: string): this;
+    addAccountsDataSlice(offset: string, length: string): this;
+    build(): SubscribeRequest;
+}
+
+type GrpcStream = ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
+declare class SolamiGrpc {
+    private client;
+    private readonly config;
+    constructor(config: SolamiConfig);
+    get url(): string;
+    subscribe(request: SubscribeRequest): Promise<GrpcStream>;
+    subscribeTransactions(label: string, accounts: string[], commitment: CommitmentLevel): Promise<GrpcStream>;
+}
+
+declare class SwqosClient {
+    private readonly endpoint;
+    private readonly apiKey;
+    constructor(apiKey: string, endpoint?: string);
+    sendTransaction(tx: VersionedTransaction): Promise<string>;
+}
+
+declare const ENDPOINTS: readonly ["landing.solami.fast:11000"];
+declare const TIP_ACCOUNTS: PublicKey[];
+declare const TIP_API_URL = "https://api.solami.fast/onchain/tip-addresses";
+declare const MIN_TIP_SOL = 0.0001;
+
+declare function buildTipIx(payer: PublicKey, sol: number): TransactionInstruction;
+declare function fetchTipAccounts(): Promise<PublicKey[]>;
+declare function extractTip(tx: VersionedTransaction, tipPubkeys?: PublicKey[]): {
+    lamports: number;
+    tipAccount: PublicKey;
+} | null;
+
+declare class SolamiClient {
+    readonly config: SolamiConfig;
+    readonly rpc: SolamiRpc;
+    readonly ws: SolamiWs;
+    readonly grpc: SolamiGrpc;
+    readonly swqos?: SwqosClient;
+    constructor(config: SolamiConfig, swqos?: SwqosClient);
+    get connection(): _solana_web3_js.Connection;
+    landTransaction(tx: VersionedTransaction): Promise<string>;
+}
+
+declare class SolamiBuilder {
+    private _rpcToken?;
+    private _grpcToken?;
+    private _rpcBase?;
+    private _wsBase?;
+    private _grpcUrl?;
+    private _swqosKey?;
+    constructor(rpcToken?: string);
+    static fromEnv(): SolamiBuilder;
+    grpcToken(token: string): this;
+    rpcBase(url: string): this;
+    wsBase(url: string): this;
+    grpcUrl(url: string): this;
+    swqosKey(key: string): this;
+    intoConfig(): SolamiConfig;
+    build(): SolamiClient;
+    buildWithSwqos(): SolamiClient;
+}
+
+type SolamiErrorCode = "CONFIG_MISSING" | "RPC_ERROR" | "WS_ERROR" | "GRPC_ERROR" | "SWQOS_ERROR" | "TIP_MISSING" | "API_ERROR";
+declare class SolamiError extends Error {
+    readonly code: SolamiErrorCode;
+    constructor(code: SolamiErrorCode, message: string, options?: ErrorOptions);
+}
+
+declare function solami(token: string): SolamiBuilder;
+declare function solamiFromEnv(): SolamiBuilder;
+
+export { DEFAULT_GRPC_URL, DEFAULT_RPC_BASE, DEFAULT_WS_BASE, ENDPOINTS, ENV_GRPC_TOKEN, ENV_RPC_TOKEN, ENV_SWQOS_KEY, type GrpcStream, MIN_TIP_SOL, SolamiBuilder, SolamiClient, type SolamiConfig, SolamiError, type SolamiErrorCode, SolamiGrpc, SolamiRpc, SolamiWs, SubscriptionBuilder, SwqosClient, TIP_ACCOUNTS, TIP_API_URL, buildTipIx, configFromEnv, createConfig, extractTip, fetchTipAccounts, rpcUrl, solami, solamiFromEnv, wsUrl };

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+import * as _solana_web3_js from '@solana/web3.js';
+import { Connection, BlockResponse, VersionedTransaction, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { CommitmentLevel, SubscribeRequestFilterAccounts, SubscribeRequestFilterSlots, SubscribeRequestFilterTransactions, SubscribeRequestFilterBlocks, SubscribeRequest, SubscribeUpdate } from '@triton-one/yellowstone-grpc';
+export { CommitmentLevel, SubscribeRequest } from '@triton-one/yellowstone-grpc';
+import { ClientDuplexStream } from '@grpc/grpc-js';
+
+declare const DEFAULT_RPC_BASE = "https://rpc.solami.fast/sol";
+declare const DEFAULT_WS_BASE = "wss://rpc.solami.fast/ws/sol";
+declare const DEFAULT_GRPC_URL = "https://grpc.solami.fast";
+declare const ENV_RPC_TOKEN = "SOLAMI_RPC_TOKEN";
+declare const ENV_GRPC_TOKEN = "SOLAMI_GRPC_TOKEN";
+declare const ENV_SWQOS_KEY = "SOLAMI_SWQOS_KEY";
+interface SolamiConfig {
+    rpcToken: string;
+    grpcToken: string;
+    rpcBase: string;
+    wsBase: string;
+    grpcUrl: string;
+    swqosKey?: string;
+}
+declare function createConfig(rpcToken: string): SolamiConfig;
+declare function configFromEnv(): SolamiConfig;
+declare function rpcUrl(config: SolamiConfig): string;
+declare function wsUrl(config: SolamiConfig): string;
+
+declare class SolamiRpc {
+    readonly connection: Connection;
+    private readonly config;
+    constructor(config: SolamiConfig);
+    get url(): string;
+    getBlock(slot: number): Promise<BlockResponse>;
+}
+
+declare class SolamiWs {
+    readonly connection: Connection;
+    constructor(config: SolamiConfig);
+}
+
+declare class SubscriptionBuilder {
+    private accounts;
+    private slots;
+    private transactions;
+    private transactionsStatus;
+    private blocks;
+    private blocksMeta;
+    private entry;
+    private _commitment?;
+    private accountsDataSlice;
+    private _fromSlot?;
+    commitment(level: CommitmentLevel): this;
+    fromSlot(slot: bigint | number | string): this;
+    addAccounts(label: string, filter: SubscribeRequestFilterAccounts): this;
+    addSlots(label: string, filter: SubscribeRequestFilterSlots): this;
+    addTransactions(label: string, filter: SubscribeRequestFilterTransactions): this;
+    addTransactionsStatus(label: string, filter: SubscribeRequestFilterTransactions): this;
+    addBlocks(label: string, filter: SubscribeRequestFilterBlocks): this;
+    addBlocksMeta(label: string): this;
+    addEntry(label: string): this;
+    addAccountsDataSlice(offset: string, length: string): this;
+    build(): SubscribeRequest;
+}
+
+type GrpcStream = ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
+declare class SolamiGrpc {
+    private client;
+    private readonly config;
+    constructor(config: SolamiConfig);
+    get url(): string;
+    subscribe(request: SubscribeRequest): Promise<GrpcStream>;
+    subscribeTransactions(label: string, accounts: string[], commitment: CommitmentLevel): Promise<GrpcStream>;
+}
+
+declare class SwqosClient {
+    private readonly endpoint;
+    private readonly apiKey;
+    constructor(apiKey: string, endpoint?: string);
+    sendTransaction(tx: VersionedTransaction): Promise<string>;
+}
+
+declare const ENDPOINTS: readonly ["landing.solami.fast:11000"];
+declare const TIP_ACCOUNTS: PublicKey[];
+declare const TIP_API_URL = "https://api.solami.fast/onchain/tip-addresses";
+declare const MIN_TIP_SOL = 0.0001;
+
+declare function buildTipIx(payer: PublicKey, sol: number): TransactionInstruction;
+declare function fetchTipAccounts(): Promise<PublicKey[]>;
+declare function extractTip(tx: VersionedTransaction, tipPubkeys?: PublicKey[]): {
+    lamports: number;
+    tipAccount: PublicKey;
+} | null;
+
+declare class SolamiClient {
+    readonly config: SolamiConfig;
+    readonly rpc: SolamiRpc;
+    readonly ws: SolamiWs;
+    readonly grpc: SolamiGrpc;
+    readonly swqos?: SwqosClient;
+    constructor(config: SolamiConfig, swqos?: SwqosClient);
+    get connection(): _solana_web3_js.Connection;
+    landTransaction(tx: VersionedTransaction): Promise<string>;
+}
+
+declare class SolamiBuilder {
+    private _rpcToken?;
+    private _grpcToken?;
+    private _rpcBase?;
+    private _wsBase?;
+    private _grpcUrl?;
+    private _swqosKey?;
+    constructor(rpcToken?: string);
+    static fromEnv(): SolamiBuilder;
+    grpcToken(token: string): this;
+    rpcBase(url: string): this;
+    wsBase(url: string): this;
+    grpcUrl(url: string): this;
+    swqosKey(key: string): this;
+    intoConfig(): SolamiConfig;
+    build(): SolamiClient;
+    buildWithSwqos(): SolamiClient;
+}
+
+type SolamiErrorCode = "CONFIG_MISSING" | "RPC_ERROR" | "WS_ERROR" | "GRPC_ERROR" | "SWQOS_ERROR" | "TIP_MISSING" | "API_ERROR";
+declare class SolamiError extends Error {
+    readonly code: SolamiErrorCode;
+    constructor(code: SolamiErrorCode, message: string, options?: ErrorOptions);
+}
+
+declare function solami(token: string): SolamiBuilder;
+declare function solamiFromEnv(): SolamiBuilder;
+
+export { DEFAULT_GRPC_URL, DEFAULT_RPC_BASE, DEFAULT_WS_BASE, ENDPOINTS, ENV_GRPC_TOKEN, ENV_RPC_TOKEN, ENV_SWQOS_KEY, type GrpcStream, MIN_TIP_SOL, SolamiBuilder, SolamiClient, type SolamiConfig, SolamiError, type SolamiErrorCode, SolamiGrpc, SolamiRpc, SolamiWs, SubscriptionBuilder, SwqosClient, TIP_ACCOUNTS, TIP_API_URL, buildTipIx, configFromEnv, createConfig, extractTip, fetchTipAccounts, rpcUrl, solami, solamiFromEnv, wsUrl };

package/dist/index.js

@@ -0,0 +1,417 @@
+// src/error.ts
+var SolamiError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "SolamiError";
+  }
+};
+
+// src/config.ts
+var DEFAULT_RPC_BASE = "https://rpc.solami.fast/sol";
+var DEFAULT_WS_BASE = "wss://rpc.solami.fast/ws/sol";
+var DEFAULT_GRPC_URL = "https://grpc.solami.fast";
+var ENV_RPC_TOKEN = "SOLAMI_RPC_TOKEN";
+var ENV_GRPC_TOKEN = "SOLAMI_GRPC_TOKEN";
+var ENV_SWQOS_KEY = "SOLAMI_SWQOS_KEY";
+function createConfig(rpcToken) {
+  return {
+    rpcToken,
+    grpcToken: rpcToken,
+    rpcBase: DEFAULT_RPC_BASE,
+    wsBase: DEFAULT_WS_BASE,
+    grpcUrl: DEFAULT_GRPC_URL
+  };
+}
+function configFromEnv() {
+  const rpcToken = process.env[ENV_RPC_TOKEN];
+  if (!rpcToken) {
+    throw new SolamiError("CONFIG_MISSING", `missing environment variable: ${ENV_RPC_TOKEN}`);
+  }
+  const grpcToken = process.env[ENV_GRPC_TOKEN] ?? rpcToken;
+  const swqosKey = process.env[ENV_SWQOS_KEY] ?? void 0;
+  return {
+    rpcToken,
+    grpcToken,
+    rpcBase: DEFAULT_RPC_BASE,
+    wsBase: DEFAULT_WS_BASE,
+    grpcUrl: DEFAULT_GRPC_URL,
+    swqosKey
+  };
+}
+function rpcUrl(config) {
+  return `${config.rpcBase}?api_key=${config.rpcToken}`;
+}
+function wsUrl(config) {
+  return `${config.wsBase}?api_key=${config.rpcToken}`;
+}
+
+// src/rpc.ts
+import { Connection } from "@solana/web3.js";
+var SolamiRpc = class {
+  connection;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.connection = new Connection(rpcUrl(config), "confirmed");
+  }
+  get url() {
+    return rpcUrl(this.config);
+  }
+  async getBlock(slot) {
+    const block = await this.connection.getBlock(slot, {
+      maxSupportedTransactionVersion: 0
+    });
+    if (!block) {
+      throw new Error(`block not found at slot ${slot}`);
+    }
+    return block;
+  }
+};
+
+// src/websocket.ts
+import { Connection as Connection2 } from "@solana/web3.js";
+var SolamiWs = class {
+  connection;
+  constructor(config) {
+    this.connection = new Connection2(rpcUrl(config), {
+      wsEndpoint: wsUrl(config),
+      commitment: "confirmed"
+    });
+  }
+};
+
+// src/grpc/client.ts
+import YellowstoneModule from "@triton-one/yellowstone-grpc";
+
+// src/grpc/subscription-builder.ts
+import { CommitmentLevel } from "@triton-one/yellowstone-grpc";
+var SubscriptionBuilder = class {
+  accounts = {};
+  slots = {};
+  transactions = {};
+  transactionsStatus = {};
+  blocks = {};
+  blocksMeta = {};
+  entry = {};
+  _commitment;
+  accountsDataSlice = [];
+  _fromSlot;
+  commitment(level) {
+    this._commitment = level;
+    return this;
+  }
+  fromSlot(slot) {
+    this._fromSlot = slot.toString();
+    return this;
+  }
+  addAccounts(label, filter) {
+    this.accounts[label] = filter;
+    return this;
+  }
+  addSlots(label, filter) {
+    this.slots[label] = filter;
+    return this;
+  }
+  addTransactions(label, filter) {
+    this.transactions[label] = filter;
+    return this;
+  }
+  addTransactionsStatus(label, filter) {
+    this.transactionsStatus[label] = filter;
+    return this;
+  }
+  addBlocks(label, filter) {
+    this.blocks[label] = filter;
+    return this;
+  }
+  addBlocksMeta(label) {
+    this.blocksMeta[label] = {};
+    return this;
+  }
+  addEntry(label) {
+    this.entry[label] = {};
+    return this;
+  }
+  addAccountsDataSlice(offset, length) {
+    this.accountsDataSlice.push({ offset, length });
+    return this;
+  }
+  build() {
+    return {
+      accounts: this.accounts,
+      slots: this.slots,
+      transactions: this.transactions,
+      transactionsStatus: this.transactionsStatus,
+      blocks: this.blocks,
+      blocksMeta: this.blocksMeta,
+      entry: this.entry,
+      commitment: this._commitment,
+      accountsDataSlice: this.accountsDataSlice,
+      ping: void 0,
+      fromSlot: this._fromSlot
+    };
+  }
+};
+
+// src/grpc/client.ts
+var Client = YellowstoneModule.default ?? YellowstoneModule;
+var SolamiGrpc = class {
+  client;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.client = new Client(config.grpcUrl, config.grpcToken, void 0);
+  }
+  get url() {
+    return this.config.grpcUrl;
+  }
+  async subscribe(request) {
+    try {
+      const stream = await this.client.subscribe();
+      stream.write(request);
+      return stream;
+    } catch (e) {
+      throw new SolamiError("GRPC_ERROR", e.message ?? String(e));
+    }
+  }
+  async subscribeTransactions(label, accounts, commitment) {
+    const request = new SubscriptionBuilder().addTransactions(label, {
+      vote: false,
+      failed: false,
+      accountInclude: accounts,
+      accountExclude: [],
+      accountRequired: [],
+      signature: void 0
+    }).commitment(commitment).build();
+    return this.subscribe(request);
+  }
+};
+
+// src/swqos/client.ts
+import bs58 from "bs58";
+var SWQOS_SEND_URL = "https://swqos.solami.fast/api/v1/transactions";
+var SwqosClient = class {
+  endpoint;
+  apiKey;
+  constructor(apiKey, endpoint) {
+    this.apiKey = apiKey;
+    this.endpoint = endpoint ?? SWQOS_SEND_URL;
+  }
+  async sendTransaction(tx) {
+    const sig = bs58.encode(tx.signatures[0]);
+    const serialized = bs58.encode(tx.serialize());
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        transaction: serialized,
+        encoding: "base58"
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new SolamiError("SWQOS_ERROR", `send failed (${res.status}): ${body}`);
+    }
+    return sig;
+  }
+};
+
+// src/swqos/constants.ts
+import { PublicKey } from "@solana/web3.js";
+var ENDPOINTS = ["landing.solami.fast:11000"];
+var TIP_ACCOUNTS = [
+  new PublicKey("6993ZufwyEDNdB94kciDTGB17ANXguiNH22VmMQU1ami"),
+  new PublicKey("E1BkG293HQocKfCkfPS7tEvs8Enh6FK8pUKi17EH1ami"),
+  new PublicKey("2Ga87xvZwpP9WRsSdiPiWre21cQbDcFhGLmT5EMo1ami"),
+  new PublicKey("CGzT5jzT68vGUWVagQAQqESfrCEHSKYe9DAjfgfC1ami")
+];
+var TIP_API_URL = "https://api.solami.fast/onchain/tip-addresses";
+var MIN_TIP_SOL = 1e-4;
+
+// src/swqos/tip.ts
+import {
+  PublicKey as PublicKey2,
+  SystemProgram,
+  LAMPORTS_PER_SOL
+} from "@solana/web3.js";
+function buildTipIx(payer, sol) {
+  const amount = sol < MIN_TIP_SOL ? MIN_TIP_SOL : sol;
+  const lamports = Math.floor(amount * LAMPORTS_PER_SOL);
+  const tipAccount = TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)];
+  return SystemProgram.transfer({
+    fromPubkey: payer,
+    toPubkey: tipAccount,
+    lamports
+  });
+}
+async function fetchTipAccounts() {
+  const res = await fetch(TIP_API_URL);
+  if (!res.ok) {
+    throw new SolamiError("API_ERROR", `fetch tip accounts failed: ${res.status}`);
+  }
+  const addresses = await res.json();
+  return addresses.map((a) => new PublicKey2(a));
+}
+function extractTip(tx, tipPubkeys = TIP_ACCOUNTS) {
+  const keys = tx.message.staticAccountKeys;
+  const systemProgramId = SystemProgram.programId;
+  for (const ix of tx.message.compiledInstructions) {
+    const programKey = keys[ix.programIdIndex];
+    if (!programKey || !programKey.equals(systemProgramId)) continue;
+    if (ix.data.length < 12) continue;
+    const ixType = ix.data[0] | ix.data[1] << 8 | ix.data[2] << 16 | ix.data[3] << 24;
+    if (ixType !== 2) continue;
+    const view = new DataView(ix.data.buffer, ix.data.byteOffset);
+    const lamports = Number(view.getBigUint64(4, true));
+    const toIndex = ix.accountKeyIndexes[1];
+    if (toIndex === void 0) continue;
+    const toPubkey = keys[toIndex];
+    if (!toPubkey) continue;
+    if (tipPubkeys.some((tip) => tip.equals(toPubkey))) {
+      return { lamports, tipAccount: toPubkey };
+    }
+  }
+  return null;
+}
+
+// src/client.ts
+var SolamiClient = class {
+  config;
+  rpc;
+  ws;
+  grpc;
+  swqos;
+  constructor(config, swqos) {
+    this.config = config;
+    this.rpc = new SolamiRpc(config);
+    this.ws = new SolamiWs(config);
+    this.grpc = new SolamiGrpc(config);
+    this.swqos = swqos;
+  }
+  get connection() {
+    return this.rpc.connection;
+  }
+  async landTransaction(tx) {
+    if (!this.swqos) {
+      throw new SolamiError("SWQOS_ERROR", "client was built without swqos support");
+    }
+    if (!extractTip(tx, TIP_ACCOUNTS)) {
+      throw new SolamiError("TIP_MISSING", "transaction must include a tip instruction");
+    }
+    return this.swqos.sendTransaction(tx);
+  }
+};
+
+// src/builder.ts
+var SolamiBuilder = class _SolamiBuilder {
+  _rpcToken;
+  _grpcToken;
+  _rpcBase;
+  _wsBase;
+  _grpcUrl;
+  _swqosKey;
+  constructor(rpcToken) {
+    this._rpcToken = rpcToken;
+  }
+  static fromEnv() {
+    const builder = new _SolamiBuilder(process.env[ENV_RPC_TOKEN] ?? void 0);
+    builder._grpcToken = process.env[ENV_GRPC_TOKEN] ?? void 0;
+    builder._swqosKey = process.env[ENV_SWQOS_KEY] ?? void 0;
+    return builder;
+  }
+  grpcToken(token) {
+    this._grpcToken = token;
+    return this;
+  }
+  rpcBase(url) {
+    this._rpcBase = url;
+    return this;
+  }
+  wsBase(url) {
+    this._wsBase = url;
+    return this;
+  }
+  grpcUrl(url) {
+    this._grpcUrl = url;
+    return this;
+  }
+  swqosKey(key) {
+    this._swqosKey = key;
+    return this;
+  }
+  intoConfig() {
+    const rpcToken = this._rpcToken;
+    if (!rpcToken) {
+      throw new SolamiError(
+        "CONFIG_MISSING",
+        `missing ${ENV_RPC_TOKEN} (set via env or new SolamiBuilder("token"))`
+      );
+    }
+    return {
+      rpcToken,
+      grpcToken: this._grpcToken ?? rpcToken,
+      rpcBase: this._rpcBase ?? DEFAULT_RPC_BASE,
+      wsBase: this._wsBase ?? DEFAULT_WS_BASE,
+      grpcUrl: this._grpcUrl ?? DEFAULT_GRPC_URL,
+      swqosKey: this._swqosKey
+    };
+  }
+  build() {
+    const config = this.intoConfig();
+    return new SolamiClient(config);
+  }
+  buildWithSwqos() {
+    const config = this.intoConfig();
+    if (!config.swqosKey) {
+      throw new SolamiError(
+        "CONFIG_MISSING",
+        `missing ${ENV_SWQOS_KEY} (set via env or .swqosKey("key"))`
+      );
+    }
+    const swqos = new SwqosClient(config.swqosKey);
+    return new SolamiClient(config, swqos);
+  }
+};
+
+// src/index.ts
+function solami(token) {
+  return new SolamiBuilder(token);
+}
+function solamiFromEnv() {
+  return SolamiBuilder.fromEnv();
+}
+export {
+  CommitmentLevel,
+  DEFAULT_GRPC_URL,
+  DEFAULT_RPC_BASE,
+  DEFAULT_WS_BASE,
+  ENDPOINTS,
+  ENV_GRPC_TOKEN,
+  ENV_RPC_TOKEN,
+  ENV_SWQOS_KEY,
+  MIN_TIP_SOL,
+  SolamiBuilder,
+  SolamiClient,
+  SolamiError,
+  SolamiGrpc,
+  SolamiRpc,
+  SolamiWs,
+  SubscriptionBuilder,
+  SwqosClient,
+  TIP_ACCOUNTS,
+  TIP_API_URL,
+  buildTipIx,
+  configFromEnv,
+  createConfig,
+  extractTip,
+  fetchTipAccounts,
+  rpcUrl,
+  solami,
+  solamiFromEnv,
+  wsUrl
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "solami",
+  "version": "0.1.7",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.98.0",
+    "@triton-one/yellowstone-grpc": "^1.4.0",
+    "bs58": "^6.0.0",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.0.0"
+  }
+}