Introduction

SLOT is a sub-slot timing synchronization engine for Solana. It eliminates timing-related transaction failures by analyzing slot phase lifecycles and firing transactions at optimal windows.

SLOT increases transaction landing rates from ~61% to ~94.7% during peak congestion by holding transactions until the next OPEN phase.

Jump to Quick Start

> WHY SLOT?

Every 400ms, Solana produces a new slot with four phases: OPEN, FILLING, PACKING, SEALING. Most failures happen because transactions arrive during the wrong phase — not because of insufficient fees.

PROBLEM	CAUSE	FAILURE RATE
Stale Slot	TX lands after leader finished packing	~31%
Boundary Collision	TX hits gap between slots	~18%
Leader Rotation	TX routes to outgoing leader	~12%
CU Contention	TX arrives at peak density	~22%

Combined, 83% of transaction failures are timing-related. SLOT solves all of them.

Quick Start

Get running in under 60 seconds.

> STEP 1: INSTALL

terminal

npm install @slot/sdk

> STEP 2: INITIALIZE

app.ts

import { Slot } from '@slot/sdk'

const slot = new Slot({
  rpcUrl: 'https://api.mainnet-beta.solana.com',
  strategy: 'aggressive',
})

> STEP 3: FIRE

app.ts

const result = await slot.fire(transaction, {
  wallet,
  maxHoldMs: 2000,
  retries: 3,
})

console.log(result)
// {
//   status: 'confirmed',
//   phase: 'OPEN',
//   holdMs: 258,
//   slot: 284712039,
//   signature: '5Kz9...'
// }

The strategy option controls how aggressively SLOT waits. Use 'conservative' for time-sensitive TXs.

Installation

> REQUIREMENTS

DEPENDENCY	VERSION	REQUIRED
Node.js	>= 18.0.0	Yes
@solana/web3.js	>= 1.87.0	Yes
TypeScript	>= 5.0	Recommended

> NPM

terminal

npm install @slot/sdk

> YARN

terminal

yarn add @slot/sdk

> PNPM

terminal

pnpm add @slot/sdk

> PYTHON

terminal

pip install slot-sdk

Python SDK is in beta. Some features may differ from TypeScript. Check the changelog.

Slot Phases

Every Solana slot (400ms) passes through four distinct phases.

SLOT LIFECYCLE (400ms)

OPEN

FILLING

PACKING

SEALING

0ms100ms200ms300ms400ms

PHASE	TIME	LAND RATE	RECOMMENDATION
OPEN	0-100ms	94%	Best window — fire here
FILLING	100-200ms	81%	Good — acceptable risk
PACKING	200-300ms	47%	Risky — hold if possible
SEALING	300-400ms	11%	Dead zone — never fire

> READING PHASE STATE

phase-check.ts

const phase = await slot.getCurrentPhase()

console.log(phase)
// {
//   name: 'OPEN',
//   slot: 284712039,
//   elapsed: 42,
//   remaining: 358,
//   landRate: 0.94,
//   confidence: 0.97
// }

Hold Engine

The Hold Engine buffers transactions and waits for the next optimal phase window before firing.

HOLD ENGINE FLOW

TX IN

→

ANALYZE

→

HOLD

→

PHASE CHECK

→

FIRE

> STRATEGIES

STRATEGY	MAX HOLD	DESCRIPTION
aggressive	2000ms	Waits up to 5 slots for OPEN phase
moderate	800ms	Waits up to 2 slots for OPEN or FILLING
conservative	400ms	Fires at next non-SEALING phase
instant	0ms	No hold — fire immediately (baseline)

hold-config.ts

const result = await slot.fire(transaction, {
  wallet,
  strategy: 'aggressive',
  maxHoldMs: 2000,
  onHold: (phase, elapsed) => {
    console.log(`Holding... phase=${phase.name} elapsed=${elapsed}ms`)
  },
  onFire: (phase) => {
    console.log(`Fired at ${phase.name} (slot ${phase.slot})`)
  },
})

Setting maxHoldMs too high can cause timeouts. For DEX swaps, use 'moderate' or lower.

Architecture

Five layers, zero wasted transactions.

CLIENT SDK

TypeScript / Python entry point.

PHASE TRACKER

Real-time slot phase analysis via leader schedule.

HOLD ENGINE

Buffers TXs. Fires at optimal window.

FEE CALIBRATOR

Phase-aware priority fee optimization. -83% overpayment.

ON-CHAIN PROGRAM

Timing state gating. Verifies phase on-chain.

Client SDK

> CONSTRUCTOR

constructor.ts

import { Slot } from '@slot/sdk'

const slot = new Slot(options: SlotOptions)

OPTION	TYPE	DEFAULT	DESCRIPTION
rpcUrl	string	—	Solana RPC endpoint
strategy	Strategy	'moderate'	Hold strategy preset
maxHoldMs	number	800	Max hold duration (ms)
retries	number	3	Retry attempts
commitment	string	'confirmed'	Commitment level
wsUrl	string	auto	WebSocket endpoint

> METHODS

slot.fire(tx, opts?)

Submit a transaction with timing optimization.

fire-result.ts

interface FireResult {
  status: 'confirmed' | 'failed' | 'timeout'
  phase: PhaseName
  holdMs: number
  slot: number
  signature: string
  retries: number
  fee: number
}

slot.getCurrentPhase()

Get real-time phase state without submitting.

slot.subscribe(callback)

Stream phase updates via WebSocket.

subscribe.ts

const unsub = slot.subscribe((phase) => {
  console.log(`Phase: ${phase.name} | Slot: ${phase.slot}`)
  if (phase.name === 'OPEN') {
    // optimal window
  }
})

unsub()

Configuration

> ENVIRONMENT VARIABLES

.env

SLOT_RPC_URL=https://api.mainnet-beta.solana.com
SLOT_WS_URL=wss://api.mainnet-beta.solana.com
SLOT_STRATEGY=aggressive
SLOT_MAX_HOLD_MS=2000
SLOT_RETRIES=3
SLOT_LOG_LEVEL=info

> STRATEGY PRESETS

PRESET	HOLD	PHASES	USE CASE
aggressive	2000ms	OPEN only	Maximum landing rate
moderate	800ms	OPEN, FILLING	Balanced
conservative	400ms	OPEN, FILLING, PACKING	Time-sensitive
instant	0ms	Any	Baseline

> CUSTOM STRATEGY

custom-strategy.ts

const slot = new Slot({
  rpcUrl: process.env.SLOT_RPC_URL,
  strategy: {
    targetPhases: ['OPEN'],
    maxHoldMs: 1200,
    feeMultiplier: 1.5,
    retries: 5,
    retryDelay: 100,
    backoff: 'exponential',
  },
})

Custom strategies override preset values. Unspecified options fall back to 'moderate' defaults.

API Reference

API access requires holding $SLOT tokens. Tier determines rate limits.

> BASE URL

endpoint

https://api.slot.systems/v1

> ENDPOINTS

METHOD	PATH	DESCRIPTION
GET	/phase	Current slot phase state
GET	/phase/history	Phase history (last 100 slots)
POST	/fire	Submit timed transaction
GET	/status/:sig	Check TX status
WS	/ws/phases	Real-time phase stream
GET	/health	API health check

> GET /phase

response.json

{
  "slot": 284712039,
  "phase": "OPEN",
  "elapsed_ms": 42,
  "remaining_ms": 358,
  "land_rate": 0.94,
  "leader": "dv1ZAG...",
  "next_leader": "Certus...",
  "timestamp": 1740700800000
}

> RATE LIMITS

TIER	REQUIREMENT	RATE LIMIT
PUBLIC	Free	2 req/s
STANDARD	100K $SLOT	10 req/s
PRO	500K $SLOT	50 req/s
ENTERPRISE	2M $SLOT	Unlimited

Exceeding rate limits returns 429 with a Retry-After header.

SLOT DOCUMENTATION · MIT LICENSE · 2026