Environment Configuration

import { EnvironmentConstants } from '@drift-labs/common';

const mainnetRpcs = EnvironmentConstants.rpcs.mainnet;
// [
//   {
//     label: 'Triton RPC Pool 1',
//     value: 'https://drift-drift_ma-39b5.mainnet.rpcpool.com/',
//     wsValue: 'wss://drift-drift_ma-39b5.mainnet.rpcpool.com/whirligig',
//     allowAdditionalConnection: true
//   },
//   {
//     label: 'Helius 1',
//     value: 'https://kora-8cwrc2-fast-mainnet.helius-rpc.com/',
//     wsValue: 'wss://kora-8cwrc2-fast-mainnet.helius-rpc.com/',
//     allowAdditionalConnection: true
//   }
// ]

const devRpcs = EnvironmentConstants.rpcs.dev;
// [
//   {
//     label: 'Helius',
//     value: 'https://detailed-sharleen-fast-devnet.helius-rpc.com',
//     wsValue: 'wss://detailed-sharleen-fast-devnet.helius-rpc.com',
//     allowAdditionalConnection: true
//   },
//   {
//     label: 'RPC Pool',
//     value: 'https://drift-drift-a827.devnet.rpcpool.com/...',
//     wsValue: 'wss://drift-drift-a827.devnet.rpcpool.com/.../whirligig',
//     allowAdditionalConnection: false
//   }
// ]

interface RpcEndpoint {
  label: string;                    // Human-readable provider name
  value: string;                    // HTTPS RPC endpoint
  wsValue?: string;                 // WebSocket endpoint (optional)
  allowAdditionalConnection: boolean; // Whether multiple connections allowed
}

const historyUrl = EnvironmentConstants.historyServerUrl.mainnet;
// 'https://mainnet-beta.api.drift.trade'

const devHistoryUrl = EnvironmentConstants.historyServerUrl.dev;
// 'https://master.api.drift.trade'

const stagingHistoryUrl = EnvironmentConstants.historyServerUrl.staging;
// 'https://staging.api.drift.trade'

const dataUrl = EnvironmentConstants.dataServerUrl.mainnet;
// 'https://data.api.drift.trade'

const devDataUrl = EnvironmentConstants.dataServerUrl.dev;
// 'https://data-master.api.drift.trade'

// HTTP endpoint
const dlobHttp = EnvironmentConstants.dlobServerHttpUrl.mainnet;
// 'https://dlob.drift.trade'

// WebSocket endpoint
const dlobWs = EnvironmentConstants.dlobServerWsUrl.mainnet;
// 'wss://dlob.drift.trade/ws'

const eventsUrl = EnvironmentConstants.eventsServerUrl.mainnet;
// 'wss://events.drift.trade/ws'

// Note: Only available for mainnet and staging

const swiftUrl = EnvironmentConstants.swiftServerUrl.mainnet;
// 'https://swift.drift.trade'

const swiftStaging = EnvironmentConstants.swiftServerUrl.staging;
// 'https://master.swift.drift.trade'

import { Config, Initialize } from '@drift-labs/common';
import { DriftEnv } from '@drift-labs/sdk';

// Initialize for mainnet
const sdkConfig = Initialize('mainnet-beta');

// Access initialized config
if (Config.initialized) {
  const spotMarkets = Config.spotMarketsLookup;
  const perpMarkets = Config.perpMarketsLookup;
}

export const Config: {
  initialized: boolean;
  spotMarketsLookup: SpotMarketConfig[];
  perpMarketsLookup: PerpMarketConfig[];
  sdkConfig: ReturnType<typeof initialize>;
}

import { Config } from '@drift-labs/common';

// Get spot market by index
const usdcMarket = Config.spotMarketsLookup[0];

// Get perp market by index
const solPerpMarket = Config.perpMarketsLookup[0];

const env: DriftEnv = 'mainnet-beta';
Initialize(env);

const env: DriftEnv = 'devnet';
Initialize(env);

// Staging environment (when available)
// Use staging URLs from EnvironmentConstants

const primaryRpc = EnvironmentConstants.rpcs.mainnet[0];

const connection = new Connection(primaryRpc.value, {
  commitment: 'confirmed',
  wsEndpoint: primaryRpc.wsValue
});

const rpcs = EnvironmentConstants.rpcs.mainnet;
let connection;

for (const rpc of rpcs) {
  try {
    connection = new Connection(rpc.value);
    await connection.getLatestBlockhash();
    break; // Connection successful
  } catch (error) {
    console.error(`Failed to connect to ${rpc.label}`);
  }
}

const allowedRpcs = EnvironmentConstants.rpcs.mainnet
  .filter(rpc => rpc.allowAdditionalConnection);

const connections = allowedRpcs.map(rpc => 
  new Connection(rpc.value, { commitment: 'confirmed' })
);

const DRIFT_ENV = process.env.DRIFT_ENV as DriftEnv || 'mainnet-beta';
Initialize(DRIFT_ENV);

if (!Config.initialized) {
  Initialize('mainnet-beta');
}

type Environment = 'dev' | 'mainnet' | 'staging';

function getHistoryUrl(env: Environment): string {
  return EnvironmentConstants.historyServerUrl[env];
}

try {
  const config = Initialize('mainnet-beta');
  // Use config...
} catch (error) {
  console.error('Failed to initialize SDK:', error);
  // Fallback logic...
}