@pompafly/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,641 @@
+"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, {
+  DEVNET_CONFIG: () => DEVNET_CONFIG,
+  MAINNET_CONFIG: () => MAINNET_CONFIG,
+  PROGRAM_CONSTANTS: () => PROGRAM_CONSTANTS,
+  PompaflyAPI: () => PompaflyAPI,
+  PompaflyClient: () => PompaflyClient,
+  PompaflyStream: () => PompaflyStream,
+  baseToTokens: () => baseToTokens,
+  deriveGlobalConfig: () => deriveGlobalConfig,
+  derivePoolAddresses: () => derivePoolAddresses,
+  lamportsToSol: () => lamportsToSol,
+  solToLamports: () => solToLamports,
+  tokensToBase: () => tokensToBase
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/index.ts
+var import_web32 = require("@solana/web3.js");
+var import_spl_token2 = require("@solana/spl-token");
+var import_bn = __toESM(require("bn.js"));
+var import_crypto = require("crypto");
+
+// src/types/index.ts
+var DEVNET_CONFIG = {
+  rpcUrl: "https://api.devnet.solana.com",
+  programId: "FnBDGeXKx3CsrFqxfKrLMsuNeUmMZPP19DbLbmqj8wCZ",
+  apiUrl: "https://api.pompafly.fun",
+  wsUrl: "wss://api.pompafly.fun/ws"
+};
+var MAINNET_CONFIG = {
+  rpcUrl: "https://api.mainnet-beta.solana.com",
+  programId: "FnBDGeXKx3CsrFqxfKrLMsuNeUmMZPP19DbLbmqj8wCZ",
+  // Update after mainnet deploy
+  apiUrl: "https://api.pompafly.fun",
+  wsUrl: "wss://api.pompafly.fun/ws"
+};
+
+// src/utils/index.ts
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+async function derivePoolAddresses(mint, programId) {
+  const [pool, poolBump] = import_web3.PublicKey.findProgramAddressSync(
+    [Buffer.from("pool"), mint.toBuffer()],
+    programId
+  );
+  const poolTokenVault = await (0, import_spl_token.getAssociatedTokenAddress)(
+    mint,
+    pool,
+    true
+    // allowOwnerOffCurve — pool is a PDA
+  );
+  return { pool, poolBump, poolTokenVault };
+}
+function deriveGlobalConfig(programId) {
+  return import_web3.PublicKey.findProgramAddressSync(
+    [Buffer.from("global_config")],
+    programId
+  );
+}
+function solToLamports(sol) {
+  return Math.floor(sol * 1e9);
+}
+function lamportsToSol(lamports) {
+  return Number(lamports) / 1e9;
+}
+function tokensToBase(tokens) {
+  return Math.floor(tokens * 1e6);
+}
+function baseToTokens(base) {
+  return Number(base) / 1e6;
+}
+var PROGRAM_CONSTANTS = {
+  TOKEN_DECIMALS: 6,
+  TOTAL_SUPPLY: "1000000000000000",
+  // 1B × 10^6
+  GRADUATION_THRESHOLD_SOL: 150,
+  FEE_BPS: 100,
+  PRIORITY_WINDOW_SECONDS: 120
+};
+
+// src/client/index.ts
+function ixDiscriminator(namespace, name) {
+  const hash = (0, import_crypto.createHash)("sha256").update(`${namespace}:${name}`).digest();
+  return hash.subarray(0, 8);
+}
+function encodeString(s) {
+  const strBytes = Buffer.from(s, "utf8");
+  const len = Buffer.alloc(4);
+  len.writeUInt32LE(strBytes.length);
+  return Buffer.concat([len, strBytes]);
+}
+var PompaflyClient = class {
+  connection;
+  programId;
+  config;
+  wallet;
+  globalConfigPda;
+  constructor(options) {
+    this.config = options.config || DEVNET_CONFIG;
+    this.programId = new import_web32.PublicKey(this.config.programId);
+    this.connection = options.connection || new import_web32.Connection(this.config.rpcUrl, "confirmed");
+    if (options.wallet) {
+      this.wallet = options.wallet;
+    } else if (options.keypair) {
+      const kp = options.keypair;
+      this.wallet = {
+        publicKey: kp.publicKey,
+        signTransaction: async (tx) => {
+          tx.partialSign(kp);
+          return tx;
+        },
+        signAllTransactions: async (txs) => {
+          txs.forEach((tx) => tx.partialSign(kp));
+          return txs;
+        }
+      };
+    } else {
+      throw new Error("Either wallet or keypair must be provided");
+    }
+    [this.globalConfigPda] = deriveGlobalConfig(this.programId);
+  }
+  get publicKey() {
+    return this.wallet.publicKey;
+  }
+  // ── Internal helpers ───────────────────────────────────
+  async sendTx(ix, extraSigners = []) {
+    const tx = new import_web32.Transaction().add(ix);
+    tx.feePayer = this.publicKey;
+    tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    if (extraSigners.length > 0) {
+      tx.partialSign(...extraSigners);
+    }
+    const signed = await this.wallet.signTransaction(tx);
+    const signature = await this.connection.sendRawTransaction(
+      signed.serialize()
+    );
+    await this.connection.confirmTransaction(signature, "confirmed");
+    return signature;
+  }
+  // ════════════════════════════════════════════════════════
+  // CREATE POOL
+  // ════════════════════════════════════════════════════════
+  async createPool(name, symbol, uri, creatorXHandle, authoritySigner) {
+    const mintKeypair = import_web32.Keypair.generate();
+    const { pool, poolTokenVault } = await derivePoolAddresses(mintKeypair.publicKey, this.programId);
+    const disc = ixDiscriminator("global", "initialize_pool");
+    const data = Buffer.concat([
+      disc,
+      encodeString(name),
+      encodeString(symbol),
+      encodeString(uri),
+      encodeString(creatorXHandle)
+    ]);
+    const ix = new import_web32.TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: this.globalConfigPda, isSigner: false, isWritable: true },
+        { pubkey: mintKeypair.publicKey, isSigner: true, isWritable: true },
+        { pubkey: pool, isSigner: false, isWritable: true },
+        { pubkey: poolTokenVault, isSigner: false, isWritable: true },
+        { pubkey: this.publicKey, isSigner: true, isWritable: true },
+        { pubkey: authoritySigner.publicKey, isSigner: true, isWritable: false },
+        { pubkey: import_spl_token2.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: import_spl_token2.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: import_web32.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+    const signature = await this.sendTx(ix, [mintKeypair, authoritySigner]);
+    return {
+      signature,
+      mint: mintKeypair.publicKey.toBase58(),
+      pool: pool.toBase58()
+    };
+  }
+  // ════════════════════════════════════════════════════════
+  // BUY
+  // ════════════════════════════════════════════════════════
+  async buy(mint, tokenAmount, maxSlippageSol, prioritySigner) {
+    const mintPk = new import_web32.PublicKey(mint);
+    const { pool, poolTokenVault } = await derivePoolAddresses(mintPk, this.programId);
+    const buyerTokenAccount = await (0, import_spl_token2.getAssociatedTokenAddress)(mintPk, this.publicKey);
+    const baseAmount = new import_bn.default(tokensToBase(tokenAmount));
+    const maxCost = new import_bn.default(solToLamports(maxSlippageSol));
+    const disc = ixDiscriminator("global", "buy");
+    const data = Buffer.alloc(8 + 8 + 8);
+    disc.copy(data, 0);
+    data.writeBigUInt64LE(BigInt(baseAmount.toString()), 8);
+    data.writeBigUInt64LE(BigInt(maxCost.toString()), 16);
+    const keys = [
+      { pubkey: this.globalConfigPda, isSigner: false, isWritable: false },
+      { pubkey: pool, isSigner: false, isWritable: true },
+      { pubkey: mintPk, isSigner: false, isWritable: false },
+      { pubkey: poolTokenVault, isSigner: false, isWritable: true },
+      { pubkey: buyerTokenAccount, isSigner: false, isWritable: true },
+      { pubkey: this.publicKey, isSigner: true, isWritable: true }
+    ];
+    if (prioritySigner) {
+      keys.push({ pubkey: prioritySigner.publicKey, isSigner: true, isWritable: false });
+    }
+    keys.push(
+      { pubkey: import_spl_token2.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: import_spl_token2.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false }
+    );
+    const ix = new import_web32.TransactionInstruction({ programId: this.programId, keys, data });
+    const signers = prioritySigner ? [prioritySigner] : [];
+    const signature = await this.sendTx(ix, signers);
+    return {
+      signature,
+      tokenAmount: baseAmount.toString(),
+      solCost: maxCost.toString()
+    };
+  }
+  // ════════════════════════════════════════════════════════
+  // SELL
+  // ════════════════════════════════════════════════════════
+  async sell(mint, tokenAmount, minReturnSol = 0) {
+    const mintPk = new import_web32.PublicKey(mint);
+    const { pool, poolTokenVault } = await derivePoolAddresses(mintPk, this.programId);
+    const sellerTokenAccount = await (0, import_spl_token2.getAssociatedTokenAddress)(mintPk, this.publicKey);
+    const baseAmount = new import_bn.default(tokensToBase(tokenAmount));
+    const minReturn = new import_bn.default(solToLamports(minReturnSol));
+    const disc = ixDiscriminator("global", "sell");
+    const data = Buffer.alloc(8 + 8 + 8);
+    disc.copy(data, 0);
+    data.writeBigUInt64LE(BigInt(baseAmount.toString()), 8);
+    data.writeBigUInt64LE(BigInt(minReturn.toString()), 16);
+    const ix = new import_web32.TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: this.globalConfigPda, isSigner: false, isWritable: false },
+        { pubkey: pool, isSigner: false, isWritable: true },
+        { pubkey: mintPk, isSigner: false, isWritable: false },
+        { pubkey: poolTokenVault, isSigner: false, isWritable: true },
+        { pubkey: sellerTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: this.publicKey, isSigner: true, isWritable: true },
+        { pubkey: import_spl_token2.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+    const signature = await this.sendTx(ix);
+    return {
+      signature,
+      tokenAmount: baseAmount.toString(),
+      solReceived: minReturn.toString()
+    };
+  }
+  // ════════════════════════════════════════════════════════
+  // COLLECT FEES
+  // ════════════════════════════════════════════════════════
+  async collectFees(mint, validatorWallet, communityWallet, platformWallet) {
+    const mintPk = new import_web32.PublicKey(mint);
+    const { pool } = await derivePoolAddresses(mintPk, this.programId);
+    const disc = ixDiscriminator("global", "collect_fees");
+    const ix = new import_web32.TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: this.globalConfigPda, isSigner: false, isWritable: false },
+        { pubkey: pool, isSigner: false, isWritable: true },
+        { pubkey: new import_web32.PublicKey(validatorWallet), isSigner: false, isWritable: true },
+        { pubkey: new import_web32.PublicKey(communityWallet), isSigner: false, isWritable: true },
+        { pubkey: new import_web32.PublicKey(platformWallet), isSigner: false, isWritable: true },
+        { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false }
+      ],
+      data: disc
+    });
+    const signature = await this.sendTx(ix);
+    return { signature };
+  }
+  // ════════════════════════════════════════════════════════
+  // GRADUATE
+  // ════════════════════════════════════════════════════════
+  async graduate(mint) {
+    const mintPk = new import_web32.PublicKey(mint);
+    const { pool, poolTokenVault } = await derivePoolAddresses(mintPk, this.programId);
+    const disc = ixDiscriminator("global", "graduate");
+    const ix = new import_web32.TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: this.globalConfigPda, isSigner: false, isWritable: true },
+        { pubkey: pool, isSigner: false, isWritable: true },
+        { pubkey: poolTokenVault, isSigner: false, isWritable: true },
+        { pubkey: mintPk, isSigner: false, isWritable: true },
+        { pubkey: this.publicKey, isSigner: true, isWritable: true },
+        { pubkey: import_spl_token2.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: import_web32.SystemProgram.programId, isSigner: false, isWritable: false }
+      ],
+      data: disc
+    });
+    const signature = await this.sendTx(ix);
+    return { signature };
+  }
+  // ════════════════════════════════════════════════════════
+  // READ HELPERS
+  // ════════════════════════════════════════════════════════
+  /**
+   * Get raw account data for a pool PDA.
+   * Returns the raw bytes — use with the Anchor IDL for full deserialization,
+   * or parse manually if you know the layout.
+   */
+  async getPoolAccountInfo(mint) {
+    const mintPk = new import_web32.PublicKey(mint);
+    const { pool } = await derivePoolAddresses(mintPk, this.programId);
+    return this.connection.getAccountInfo(pool);
+  }
+  /** Get the pool PDA address for a given mint */
+  async getPoolAddress(mint) {
+    const { pool } = await derivePoolAddresses(new import_web32.PublicKey(mint), this.programId);
+    return pool.toBase58();
+  }
+  /** Get the token vault ATA address for a pool */
+  async getPoolTokenVault(mint) {
+    const { poolTokenVault } = await derivePoolAddresses(new import_web32.PublicKey(mint), this.programId);
+    return poolTokenVault.toBase58();
+  }
+  /** Get the global config PDA address */
+  getGlobalConfigAddress() {
+    return this.globalConfigPda.toBase58();
+  }
+};
+
+// src/api/index.ts
+var PompaflyAPI = class {
+  baseUrl;
+  token = null;
+  constructor(config) {
+    this.baseUrl = (config || DEVNET_CONFIG).apiUrl;
+  }
+  /** Set JWT token for authenticated requests */
+  setToken(token) {
+    this.token = token;
+  }
+  /** Clear authentication */
+  clearToken() {
+    this.token = null;
+  }
+  async fetch(path, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(body.error || `API error: ${res.status}`);
+    }
+    return res.json();
+  }
+  // ── Auth ────────────────────────────────────────────────
+  /** Request a login nonce for wallet signature */
+  async getNonce(wallet) {
+    return this.fetch(
+      "/api/auth/wallet/nonce",
+      { method: "POST", body: JSON.stringify({ wallet }) }
+    );
+  }
+  /** Verify wallet signature and get JWT */
+  async verifyWallet(wallet, signature) {
+    const res = await this.fetch("/api/auth/wallet/verify", {
+      method: "POST",
+      body: JSON.stringify({ wallet, signature })
+    });
+    if (res.data.token) {
+      this.token = res.data.token;
+    }
+    return res;
+  }
+  /** Get X OAuth login URL (must be authenticated first) */
+  getXLoginUrl() {
+    return `${this.baseUrl}/api/auth/x/login`;
+  }
+  /** Get current user profile */
+  async getMe() {
+    return this.fetch("/api/auth/me");
+  }
+  // ── Pools ──────────────────────────────────────────────
+  /** List pools with filters and sorting */
+  async getPools(params) {
+    const query = new URLSearchParams();
+    if (params?.page) query.set("page", params.page.toString());
+    if (params?.limit) query.set("limit", params.limit.toString());
+    if (params?.status) query.set("status", params.status);
+    if (params?.sort) query.set("sort", params.sort);
+    if (params?.search) query.set("search", params.search);
+    if (params?.creator) query.set("creator", params.creator);
+    return this.fetch(
+      `/api/pools?${query.toString()}`
+    );
+  }
+  /** Get pool details by mint */
+  async getPool(mint) {
+    return this.fetch(`/api/pools/${mint}`);
+  }
+  /** Get current price and curve position */
+  async getPoolPrice(mint) {
+    return this.fetch(`/api/pools/${mint}/price`);
+  }
+  /** Get top holders for a pool */
+  async getHolders(mint, limit) {
+    const query = limit ? `?limit=${limit}` : "";
+    return this.fetch(
+      `/api/pools/${mint}/holders${query}`
+    );
+  }
+  // ── Trades ─────────────────────────────────────────────
+  /** Get trade history for a pool */
+  async getTrades(mint, params) {
+    const query = new URLSearchParams();
+    if (params?.page) query.set("page", params.page.toString());
+    if (params?.limit) query.set("limit", params.limit.toString());
+    if (params?.type) query.set("type", params.type);
+    if (params?.trader) query.set("trader", params.trader);
+    return this.fetch(
+      `/api/trades/${mint}?${query.toString()}`
+    );
+  }
+  /** Get OHLCV candle data for charts */
+  async getCandles(mint, params) {
+    const query = new URLSearchParams();
+    query.set("interval", params.interval);
+    if (params.from) query.set("from", params.from.toString());
+    if (params.to) query.set("to", params.to.toString());
+    if (params.limit) query.set("limit", params.limit.toString());
+    return this.fetch(
+      `/api/trades/${mint}/candles?${query.toString()}`
+    );
+  }
+  /** Get trade history for a specific wallet */
+  async getUserTrades(wallet, params) {
+    const query = new URLSearchParams();
+    if (params?.page) query.set("page", params.page.toString());
+    if (params?.limit) query.set("limit", params.limit.toString());
+    return this.fetch(
+      `/api/trades/user/${wallet}?${query.toString()}`
+    );
+  }
+  // ── Priority ───────────────────────────────────────────
+  /** Get a priority buy authorization (requires X verification) */
+  async getPriorityAuth(mint) {
+    return this.fetch("/api/priority/authorize", {
+      method: "POST",
+      body: JSON.stringify({ mint })
+    });
+  }
+  /** Check priority window status */
+  async getPriorityStatus(mint) {
+    return this.fetch(`/api/priority/status/${mint}`);
+  }
+  // ── Stats ──────────────────────────────────────────────
+  /** Get platform-wide statistics */
+  async getStats() {
+    return this.fetch("/api/stats");
+  }
+  /** Get trending pools (24h volume) */
+  async getTrending(limit) {
+    const query = limit ? `?limit=${limit}` : "";
+    return this.fetch(
+      `/api/stats/trending${query}`
+    );
+  }
+  /** Get trader leaderboard */
+  async getLeaderboard(params) {
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", params.limit.toString());
+    if (params?.period) query.set("period", params.period);
+    return this.fetch(
+      `/api/stats/leaderboard?${query.toString()}`
+    );
+  }
+  /** Get fee distribution breakdown */
+  async getFeeStats() {
+    return this.fetch("/api/stats/fees");
+  }
+};
+
+// src/stream/index.ts
+var PompaflyStream = class {
+  wsUrl;
+  ws = null;
+  listeners = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Set();
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectDelay = 1e3;
+  autoReconnect = true;
+  isConnected = false;
+  constructor(config) {
+    this.wsUrl = (config || DEVNET_CONFIG).wsUrl;
+    this.listeners.set("price", /* @__PURE__ */ new Set());
+    this.listeners.set("trade", /* @__PURE__ */ new Set());
+    this.listeners.set("status", /* @__PURE__ */ new Set());
+    this.listeners.set("all", /* @__PURE__ */ new Set());
+  }
+  /** Connect to the WebSocket server */
+  connect() {
+    if (this.ws?.readyState === WebSocket.OPEN) return;
+    this.ws = new WebSocket(this.wsUrl);
+    this.ws.onopen = () => {
+      this.isConnected = true;
+      this.reconnectAttempts = 0;
+      if (this.subscriptions.size > 0) {
+        this.ws.send(
+          JSON.stringify({
+            type: "subscribe",
+            mints: Array.from(this.subscriptions)
+          })
+        );
+      }
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      this.isConnected = false;
+      if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        setTimeout(() => this.connect(), Math.min(delay, 3e4));
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  /** Disconnect from the WebSocket server */
+  disconnect() {
+    this.autoReconnect = false;
+    this.ws?.close();
+    this.ws = null;
+    this.isConnected = false;
+  }
+  /** Subscribe to real-time updates for specific token mints */
+  subscribe(mints) {
+    mints.forEach((m) => this.subscriptions.add(m));
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "subscribe", mints }));
+    }
+  }
+  /** Unsubscribe from specific token mints */
+  unsubscribe(mints) {
+    mints.forEach((m) => this.subscriptions.delete(m));
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "unsubscribe", mints }));
+    }
+  }
+  /** Listen for price update events */
+  onPrice(handler) {
+    return this.addListener("price", handler);
+  }
+  /** Listen for new trade events */
+  onTrade(handler) {
+    return this.addListener("trade", handler);
+  }
+  /** Listen for pool status change events */
+  onStatus(handler) {
+    return this.addListener("status", handler);
+  }
+  /** Listen for all events */
+  onAny(handler) {
+    return this.addListener("all", handler);
+  }
+  /** Check if connected */
+  get connected() {
+    return this.isConnected;
+  }
+  /** Get currently subscribed mints */
+  get subscribedMints() {
+    return Array.from(this.subscriptions);
+  }
+  // ── Internal ───────────────────────────────────────────
+  addListener(type, handler) {
+    this.listeners.get(type).add(handler);
+    return () => {
+      this.listeners.get(type).delete(handler);
+    };
+  }
+  handleMessage(data) {
+    if (!data.type) return;
+    const event = data;
+    this.listeners.get(data.type)?.forEach((fn) => fn(event));
+    this.listeners.get("all")?.forEach((fn) => fn(event));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEVNET_CONFIG,
+  MAINNET_CONFIG,
+  PROGRAM_CONSTANTS,
+  PompaflyAPI,
+  PompaflyClient,
+  PompaflyStream,
+  baseToTokens,
+  deriveGlobalConfig,
+  derivePoolAddresses,
+  lamportsToSol,
+  solToLamports,
+  tokensToBase
+});