Sanctum Gateway SDK

TypeScript SDK for Sanctum Gateway - Solana transaction optimization and multi-path delivery.

What is Sanctum Gateway?

Sanctum Gateway is a high-performance API for optimizing and delivering Solana transactions through multiple paths simultaneously (RPC, Jito, Triton, Paladin). It provides:

• Transaction Optimization - Auto-calculate compute units and priority fees
• Multi-Path Delivery - Send transactions through multiple channels at once
• Jito Tip Refunds - Get refunded if regular RPC succeeds first
• Real-time Metrics - Track which delivery method succeeded

Installation

npm install @sanctum-gateway/sdk

Quick Start

import { GatewayClient } from '@sanctum-gateway/sdk';

// Initialize the client
const gateway = new GatewayClient({
  rpcUrl: 'https://tpg.sanctum.so/v1/mainnet?apiKey=YOUR_API_KEY',
  apiKey: 'YOUR_API_KEY',
  network: 'mainnet-beta'
});

// Send a transaction
const result = await gateway.sendTransaction({
  transaction: signedTransactionBase64,
  jitoTip: 10000 // Optional: 0.00001 SOL tip
});

console.log('Transaction signature:', result.signature);
console.log('Delivered via:', result.deliveryPath);
console.log('Landing time:', result.landingTime, 'ms');
console.log('Jito refunded:', result.jitoRefunded);

API Reference

Constructor

const gateway = new GatewayClient(config);

Parameters:

• config.rpcUrl (string) - Gateway RPC endpoint URL
• config.apiKey (string, optional) - Your Gateway API key
• config.network ('mainnet-beta' | 'devnet' | 'testnet') - Solana network
• config.timeout (number, optional) - Request timeout in ms (default: 30000)

Methods

optimizeTransaction(params)

Optimize a transaction with auto-calculated compute units and priority fees.

const optimized = await gateway.optimizeTransaction({
  transaction: base64Transaction,
  cuPrice: 1000, // Optional: priority fee in microlamports
  enabledDeliveryMethods: ['rpc', 'jito'], // Optional
  expireInSlot: 100 // Optional: slots until expiry
});

console.log('Optimized transaction:', optimized.optimizedTransaction);
console.log('Estimated cost:', optimized.estimatedCost);

Returns:

• optimizedTransaction (string) - Base64 encoded optimized transaction
• computeUnits (number) - Calculated compute units
• priorityFee (number) - Optimal priority fee
• estimatedCost (number) - Estimated transaction cost

sendTransaction(params)

Send a transaction through Gateway's multi-path delivery.

const result = await gateway.sendTransaction({
  transaction: signedBase64Transaction,
  enabledDeliveryMethods: ['rpc', 'jito', 'triton', 'paladin'], // Optional
  jitoTip: 10000, // Optional: tip in lamports
  deliveryDelay: 50 // Optional: delay between methods in ms
});

Returns:

• signature (string) - Transaction signature
• deliveryPath ('rpc' | 'jito' | 'triton' | 'paladin') - Which method succeeded
• landingTime (number) - Time to land in milliseconds
• actualCost (number) - Actual cost paid in lamports
• jitoRefunded (boolean) - Whether Jito tip was refunded

getTransactionStatus(signature)

Get the status of a transaction.

const status = await gateway.getTransactionStatus(signature);

Configuration

Getting an API Key

1. Visit gateway.sanctum.so
2. Create an account
3. Generate an API key
4. Use it in your configuration

Network Endpoints

Mainnet:

https://tpg.sanctum.so/v1/mainnet?apiKey=YOUR_API_KEY

Devnet:

https://tpg.sanctum.so/v1/devnet?apiKey=YOUR_API_KEY

Complete Example

import { Connection, Keypair, Transaction, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
import { GatewayClient } from '@sanctum-gateway/sdk';

async function sendWithGateway() {
  // 1. Create a transaction
  const connection = new Connection('https://api.mainnet-beta.solana.com');
  const wallet = Keypair.generate();

  const transaction = new Transaction().add(
    SystemProgram.transfer({
      fromPubkey: wallet.publicKey,
      toPubkey: wallet.publicKey,
      lamports: 0.001 * LAMPORTS_PER_SOL
    })
  );

  // 2. Get recent blockhash
  const { blockhash } = await connection.getLatestBlockhash();
  transaction.recentBlockhash = blockhash;
  transaction.feePayer = wallet.publicKey;

  // 3. Sign transaction
  transaction.sign(wallet);

  // 4. Serialize to base64
  const serialized = transaction.serialize().toString('base64');

  // 5. Send via Gateway
  const gateway = new GatewayClient({
    rpcUrl: 'https://tpg.sanctum.so/v1/mainnet?apiKey=YOUR_API_KEY',
    apiKey: 'YOUR_API_KEY',
    network: 'mainnet-beta'
  });

  const result = await gateway.sendTransaction({
    transaction: serialized,
    jitoTip: 10000 // 0.00001 SOL
  });

  console.log('Success!');
  console.log('Signature:', result.signature);
  console.log('Delivered via:', result.deliveryPath);
  console.log('Landing time:', result.landingTime, 'ms');

  if (result.jitoRefunded) {
    console.log('Jito tip was refunded!');
  }
}

sendWithGateway();

Delivery Methods

The SDK supports these delivery methods:

• RPC - Standard Solana RPC nodes
• Jito - Jito MEV bundle delivery
• Triton - Triton Cascade delivery
• Paladin - Paladin delivery network

Transactions are sent through all enabled methods simultaneously. The first to succeed wins, and Jito tips are refunded if RPC succeeds first.

Error Handling

try {
  const result = await gateway.sendTransaction({
    transaction: signedTx
  });
  console.log('Success:', result.signature);
} catch (error) {
  console.error('Gateway error:', error.message);
  // Handle error
}

TypeScript Support

The SDK is written in TypeScript and includes full type definitions.

import {
  GatewayClient,
  GatewayConfig,
  SendTransactionParams,
  SendTransactionResponse,
  DeliveryMethod
} from '@sanctum-gateway/sdk';

License

MIT

Resources

• Sanctum Gateway Docs
• Sanctum Website
• GitHub Repository

Contributing

Contributions welcome! Please open an issue or PR on GitHub.