TypeScript SDK - LaserSell Documentation

Installation

npm install @lasersell/lasersell-sdk

The package ships with TypeScript declarations and supports both ESM and CommonJS.

Modules

Import	Purpose
`ExitApiClient`	Build unsigned buy/sell transactions.
`StreamClient`	Low level WebSocket stream client.
`StreamSession`	High level stream with position tracking.
`signUnsignedTx`	Sign an unsigned base64 transaction.
`signUnsignedTxB64Fast`	Fast path in place signing (returns base64).
`sendTransaction`	Submit a signed transaction.
`sendTargetRpc`, `sendTargetHeliusSender`, `sendTargetAstralane`	Send target constructors.

API Client

import {
  ExitApiClient,
  type BuildSellTxRequest,
  type BuildBuyTxRequest,
} from "@lasersell/lasersell-sdk";

const client = ExitApiClient.withApiKey("YOUR_API_KEY");

// Build sell
const sellRequest: BuildSellTxRequest = {
  mint: "TOKEN_MINT",
  user_pubkey: "WALLET",
  amount_tokens: 1_000_000,
  slippage_bps: 2_000,
  output: "SOL",
};
const sellResponse = await client.buildSellTx(sellRequest);
const txB64 = sellResponse.tx;

// Build buy
const buyRequest: BuildBuyTxRequest = {
  mint: "TOKEN_MINT",
  user_pubkey: "WALLET",
  amount: 0.1, // 0.1 SOL
  slippage_bps: 2_000,
};
const buyResponse = await client.buildBuyTx(buyRequest);

Client Options

const client = ExitApiClient.withOptions("YOUR_API_KEY", {
  connect_timeout_ms: 500,
  attempt_timeout_ms: 2000,
  retry_policy: {
    max_attempts: 3,
    initial_backoff_ms: 50,
    max_backoff_ms: 200,
    jitter_ms: 50,
  },
});

Exit Intelligence Stream Session

import {
  StreamClient,
  StreamSession,
  sendTransaction,
  sendTargetHeliusSender,
  signUnsignedTx,
} from "@lasersell/lasersell-sdk";

const client = new StreamClient("YOUR_API_KEY");
const session = await StreamSession.connect(client, {
  wallet_pubkeys: ["WALLET_PUBKEY"],
  strategy: {
    target_profit_pct: 5,
    stop_loss_pct: 1.5,
    trailing_stop_pct: 3,
  },
  deadline_timeout_sec: 45,
  send_mode: "helius_sender",
  tip_lamports: 1000,
});

while (true) {
  const event = await session.recv();
  if (event === null) break;

  switch (event.type) {
    case "position_opened":
      console.log("New position:", event.handle.mint);
      break;

    case "exit_signal_with_tx":
      if (event.message.type === "exit_signal_with_tx") {
        const signed = signUnsignedTx(event.message.unsigned_tx_b64, keypair);
        const sig = await sendTransaction(sendTargetHeliusSender(), signed);
        console.log("Exit submitted:", sig);
      }
      break;

    case "pnl_update":
      if (event.message.type === "pnl_update") {
        console.log(
          `PnL position=${event.message.position_id} profit=${event.message.profit_units}`
        );
      }
      break;
  }
}

Lane Splitting

For high throughput scenarios, split the Exit Intelligence Stream into priority lanes:

const connection = await client.connectLanes(configure, {
  lowPriorityCapacity: 512,
});
const [sender, highRx, lowRx] = connection.split();

// High priority: exit signals, position events
for await (const msg of highRx) {
  // Handle critical messages
}

Liquidity Snapshots and Partial Sells

Tier 1+ only. Requires a Professional or Advanced subscription. See the announcement for full details.

StreamSession caches the latest liquidity snapshot per position. Query slippage bands, maximum sellable amounts, and liquidity trends:

const bands = session.getSlippageBands(positionId);
const maxTokens = session.getMaxSellAtSlippage(positionId, 500); // 5% slippage
const trend = session.getLiquidityTrend(positionId); // "growing" | "stable" | "draining"

Use buildPartialSellTx() to sell a portion of a position based on slippage data:

const maxTokens = session.getMaxSellAtSlippage(positionId, 500);
if (maxTokens !== undefined) {
  const response = await client.buildPartialSellTx(handle, maxTokens, 500, "SOL");
}

Mirror Trading

Configure watch wallets to mirror trades from other wallets. When a watched wallet opens a position on a supported market, the stream sends a mirror_buy_signal with an unsigned transaction for your wallet to execute.

import {
  StreamClient,
  StreamSession,
  sendTransaction,
  sendTargetHeliusSender,
  signUnsignedTx,
} from "@lasersell/lasersell-sdk";

const walletPubkey = "YOUR_WALLET_PUBKEY";

const client = new StreamClient("YOUR_API_KEY");
const session = await StreamSession.connect(client, {
  wallet_pubkeys: [walletPubkey],
  strategy: {
    target_profit_pct: 50,
    stop_loss_pct: 25,
  },
  watch_wallets: [
    {
      pubkey: "WatchedWalletPubkey...",
      auto_buy: {
        wallet_pubkey: walletPubkey,
        amount_quote_units: 100_000_000,
        amount_usd1_units: null,
      },
      mirror_sell: false,
    },
  ],
  mirror_config: {
    max_positions_per_wallet: 1,
    cooldown_sec: 30,
    max_active_sol: 5.0,
    buy_slippage_bps: 2500,
  },
});

while (true) {
  const event = await session.recv();
  if (event === null) break;

  switch (event.type) {
    case "mirror_buy_signal": {
      const { mint, unsigned_tx_b64 } = event.message;
      const signed = signUnsignedTx(unsigned_tx_b64, keypair);
      const sig = await sendTransaction(sendTargetHeliusSender(), signed);
      session.sender().mirrorBuyResult(mint, true);
      console.log("Mirror buy submitted:", sig);
      break;
    }

    case "mirror_buy_failed":
      console.log(`Mirror buy failed: ${event.message.reason}`);
      break;

    case "exit_signal_with_tx": {
      if (event.message.type === "exit_signal_with_tx") {
        const signed = signUnsignedTx(event.message.unsigned_tx_b64, keypair);
        const sig = await sendTransaction(sendTargetHeliusSender(), signed);
        console.log("Exit submitted:", sig);
      }
      break;
    }
  }
}

The watch_wallets array specifies which wallets to mirror. Each entry includes an auto_buy configuration that controls how much to spend when mirroring a trade, and a mirror_sell flag that determines whether to also mirror sell transactions. The mirror_config object sets global limits: max_positions_per_wallet caps concurrent mirrored positions, cooldown_sec enforces a delay between mirror buys, max_active_sol limits total SOL exposure, and buy_slippage_bps sets the slippage tolerance for mirror buy transactions.

Transaction Helpers

import {
  signUnsignedTx,
  signUnsignedTxB64Fast,
  signAndSendUnsignedTxB64,
  sendTransaction,
  sendTransactionB64To,
  encodeSignedTx,
  sendTargetRpc,
  sendTargetHeliusSender,
  sendTargetAstralane,
  sendTargetDefaultRpc,
} from "@lasersell/lasersell-sdk";

// Standard sign
const signedTx = signUnsignedTx(unsignedTxB64, keypair);

// Fast sign (returns base64 string)
const signedB64 = signUnsignedTxB64Fast(unsignedTxB64, keypair);

// Sign + send in one step
const sig = await signAndSendUnsignedTxB64(
  sendTargetHeliusSender(),
  unsignedTxB64,
  keypair,
);

// Send a pre-signed transaction
const sig2 = await sendTransaction(sendTargetRpc("https://rpc.example.com"), signedTx);

// Send a pre-signed base64 string
const sig3 = await sendTransactionB64To(sendTargetHeliusSender(), signedB64);

Error Handling

import { ExitApiError, TxSubmitError, StreamClientError } from "@lasersell/lasersell-sdk";

try {
  await client.buildSellTx(request);
} catch (error) {
  if (error instanceof ExitApiError) {
    // error.kind, error.status, error.body, error.isRetryable()
  }
  if (error instanceof TxSubmitError) {
    // error.kind, error.target, error.status
  }
  if (error instanceof StreamClientError) {
    // error.kind
  }
}

Complete Example

See the Quickstart for a full working example that builds, signs, and submits a sell transaction.

​Installation

​Modules

​API Client

​Client Options

​Exit Intelligence Stream Session

​Lane Splitting

​Liquidity Snapshots and Partial Sells

​Mirror Trading

​Transaction Helpers

​Error Handling

​Complete Example

Installation

Modules

API Client

Client Options

Exit Intelligence Stream Session

Lane Splitting

Liquidity Snapshots and Partial Sells

Mirror Trading

Transaction Helpers

Error Handling

Complete Example