SDK Internals

import { VelocityClient, BulkAccountLoader } from "@velocity-exchange/sdk";
 
const accountLoader = new BulkAccountLoader(connection, "confirmed", 1000);
 
const velocityClient = new VelocityClient({
  connection,
  wallet,
  accountSubscription: {
    type: "polling",
    accountLoader,
  },
});

import { VelocityClient } from "@velocity-exchange/sdk";
 
const velocityClient = new VelocityClient({
  connection,
  wallet,
  accountSubscription: {
    type: "websocket",
  },
});

import { VelocityClient } from "@velocity-exchange/sdk";
 
const velocityClient = new VelocityClient({
  connection,
  wallet,
  accountSubscription: {
    type: "grpc",
    grpcConfigs: {
      endpoint: "https://grpc.mainnet.jito.wtf",
      token: "YOUR_GRPC_TOKEN",
    },
  },
});

import { VelocityClient, BulkAccountLoader } from "@velocity-exchange/sdk";
 
// Constructor: (connection, commitment, pollingFrequencyMs)
const bulkAccountLoader = new BulkAccountLoader(connection, "confirmed", 1000);
 
// Typically you don't call addAccount directly. Instead, pass the loader
// to VelocityClient and it registers the accounts it needs automatically.
const velocityClient = new VelocityClient({
  connection,
  wallet,
  accountSubscription: { type: "polling", accountLoader: bulkAccountLoader },
});

// 1. Get instruction
const ix = await velocityClient.getPlacePerpOrderIx(orderParams);
 
// 2. Build transaction
// getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners?, opts?, blockhash?)
// the fee payer/signer is `velocityClient`'s own wallet, not a positional arg.
const tx = await velocityClient.txSender.getVersionedTransaction(
  [ix],
  [], // lookup tables
);
 
// 3. Send transaction
const { txSig } = await velocityClient.txSender.sendVersionedTransaction(
  tx,
  [],
  velocityClient.opts
);

const remainingAccounts = velocityClient.getRemainingAccounts({
  userAccounts: [user.getUserAccount()],
  writableSpotMarketIndexes: [0],  // USDT market
});
 
// These accounts get passed to the instruction
const ix = await velocityClient.program.methods
  .placePerpOrder(params)
  .accounts({
    user: userAccountPubkey,
    // ... other fixed accounts
  })
  .remainingAccounts(remainingAccounts)
  .instruction();

import { EventSubscriber, isVariant, WrappedEvent } from "@velocity-exchange/sdk";
 
const eventSubscriber = new EventSubscriber(connection, velocityClient.program, {
  commitment: "confirmed",
  logProviderConfig: { type: "websocket" },
});
await eventSubscriber.subscribe();
 
// All events come through "newEvent", filter by eventType
eventSubscriber.eventEmitter.on("newEvent", (event) => {
  // `event.eventType === "OrderActionRecord"` alone doesn't narrow `event`'s type
  // (WrappedEvent is generic over EventType, so TS can't correlate the check with
  // the rest of the shape): cast explicitly once you've checked the discriminant.
  if (event.eventType === "OrderActionRecord") {
    const orderEvent = event as WrappedEvent<"OrderActionRecord">;
    if (isVariant(orderEvent.action, "fill")) {
      console.log("Order filled:", orderEvent);
      console.log("  Market:", orderEvent.marketIndex);
    }
  }
});

// Market account caching:
// First call after subscribe: data from subscription cache (no extra RPC)
const market = velocityClient.getPerpMarketAccount(0);
// Subsequent calls: same cached data, updates via subscription
const market2 = velocityClient.getPerpMarketAccount(0);
 
// Oracle price caching:
const oracle = velocityClient.getOracleDataForPerpMarket(0);
// Price is cached from account subscription
 
// User account caching:
const user = velocityClient.getUser();
const position = user.getPerpPosition(0);
// No RPC call, data from subscription

import { UserMap } from "@velocity-exchange/sdk";
 
const userMap = new UserMap({
  velocityClient,
  subscriptionConfig: {
    type: "websocket",
  },
});
await userMap.subscribe();
 
// Add a specific user account to the map
await userMap.addPubkey(userAccountPubkey);
 
// Get user data
const user = userMap.get(userAccountPubkey.toString());
const position = user.getPerpPosition(0);

import { VelocityClient } from "@velocity-exchange/sdk";
import { ComputeBudgetProgram } from "@solana/web3.js";
 
// Initialize and subscribe
const velocityClient = new VelocityClient({
  connection,
  wallet,
  env: "mainnet-beta",
});
await velocityClient.subscribe();
 
const user = velocityClient.getUser();
await user.subscribe();
 
// Transaction with priority fee
const ix = await velocityClient.getPlacePerpOrderIx(orderParams);
const tx = await velocityClient.txSender.getVersionedTransaction([
  ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 50000 }),
  ix,
], []); // lookup tables
const { txSig } = await velocityClient.txSender.sendVersionedTransaction(
  tx, [], velocityClient.opts
);
 
// Switch subaccounts
await velocityClient.switchActiveUser(1);  // Switch to subaccount 1
const user1 = velocityClient.getUser();  // Now returns subaccount 1
 
// Batch operations: place multiple orders in one transaction
await velocityClient.placeOrders([order1, order2, order3]);

// Insufficient collateral
try {
  await velocityClient.placePerpOrder(params);
} catch (e) {
  if (e.message.includes("InsufficientCollateral")) {
    console.log("Need to deposit more collateral");
  }
}
 
// Account subscription errors
velocityClient.eventEmitter.on("error", (e) => {
  console.error("Subscription error:", e);
  // Reconnect logic here
});

// Precompute values: convert once, reuse
const size = velocityClient.convertToPerpPrecision(1);
const price = velocityClient.convertToPricePrecision(100);
 
// Use lookup tables (ALTs) to reduce transaction size
const lookupTables = [/* your AddressLookupTableAccount objects */];
const tx = await velocityClient.txSender.getVersionedTransaction(
  instructions,
  lookupTables
);