Environment Constants

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

// Access mainnet endpoints
const mainnetRpcs = EnvironmentConstants.rpcs.mainnet;
const mainnetDataServer = EnvironmentConstants.dataServerUrl.mainnet;

// Access devnet endpoints
const devnetRpcs = EnvironmentConstants.rpcs.dev;
const devnetHistoryServer = EnvironmentConstants.historyServerUrl.dev;

export interface RpcEndpoint {
  label: string; // Human-readable name
  value: string; // HTTP/HTTPS RPC URL
  wsValue?: string; // WebSocket URL
  allowAdditionalConnection: boolean; // Can be used with additional connections
}

const devnetRpcs = 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/3639271b-6f0e-47c6-a643-1aaa0e498f58',
//     wsValue: 'wss://drift-drift-a827.devnet.rpcpool.com/3639271b-6f0e-47c6-a643-1aaa0e498f58/whirligig',
//     allowAdditionalConnection: false,
//   },
// ]

import { Connection } from '@solana/web3.js';

const devnetRpc = EnvironmentConstants.rpcs.dev[0];
const connection = new Connection(devnetRpc.value, 'confirmed');

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 mainnetRpc = EnvironmentConstants.rpcs.mainnet[0];
const connection = new Connection(mainnetRpc.value, 'confirmed');

// Use WebSocket endpoint for subscriptions
const wsConnection = new Connection(mainnetRpc.wsValue, 'confirmed');

function getRpcEndpoint(env: 'dev' | 'mainnet', preferredLabel?: string): string {
  const rpcs = EnvironmentConstants.rpcs[env];
  
  if (preferredLabel) {
    const preferred = rpcs.find(rpc => rpc.label === preferredLabel);
    if (preferred) return preferred.value;
  }
  
  // Use first available RPC
  return rpcs[0].value;
}

// Usage
const endpoint = getRpcEndpoint('mainnet', 'Helius 1');

const historyServerUrl = {
  dev: 'https://master.api.drift.trade',
  mainnet: 'https://mainnet-beta.api.drift.trade',
  staging: 'https://staging.api.drift.trade',
};

const historyUrl = EnvironmentConstants.historyServerUrl.mainnet;
const response = await fetch(`${historyUrl}/trades?marketIndex=0`);

const dataServerUrl = {
  dev: 'https://data-master.api.drift.trade',
  mainnet: 'https://data.api.drift.trade',
  staging: 'https://data-staging.api.drift.trade',
};

const dataUrl = EnvironmentConstants.dataServerUrl.mainnet;
const response = await fetch(`${dataUrl}/fundingRates?marketIndex=0`);

const dlobServerHttpUrl = {
  dev: 'https://master.dlob.drift.trade',
  mainnet: 'https://dlob.drift.trade',
  staging: 'https://staging.dlob.drift.trade',
};

const dlobUrl = EnvironmentConstants.dlobServerHttpUrl.mainnet;
const response = await fetch(`${dlobUrl}/l2?marketName=SOL-PERP`);

const dlobServerWsUrl = {
  dev: 'wss://master.dlob.drift.trade/ws',
  mainnet: 'wss://dlob.drift.trade/ws',
  staging: 'wss://staging.dlob.drift.trade/ws',
};

const wsUrl = EnvironmentConstants.dlobServerWsUrl.mainnet;
const ws = new WebSocket(wsUrl);

ws.on('open', () => {
  ws.send(JSON.stringify({
    type: 'subscribe',
    marketType: 'perp',
    marketIndex: 0,
  }));
});

const eventsServerUrl = {
  mainnet: 'wss://events.drift.trade/ws',
  staging: 'wss://events.drift.trade/ws',
};

const eventsUrl = EnvironmentConstants.eventsServerUrl.mainnet;
const ws = new WebSocket(eventsUrl);

ws.on('message', (data) => {
  const event = JSON.parse(data);
  console.log('Event received:', event);
});

const swiftServerUrl = {
  mainnet: 'https://swift.drift.trade',
  staging: 'https://master.swift.drift.trade',
};

const swiftUrl = EnvironmentConstants.swiftServerUrl.mainnet;

// Swift orders are typically created through the client
await serverDrift.getOpenPerpMarketOrderTxn({
  userAccountPublicKey,
  marketIndex: 0,
  amount: new BN(1_000_000_000),
  direction: PositionDirection.LONG,
  useSwift: true, // Enable Swift (gasless) order
  swiftOptions: {
    // Swift server URL is automatically set by the client
  },
});

import { DriftEnv } from '@drift-labs/sdk';

function getEnvironmentUrls(env: DriftEnv) {
  const envKey = env === 'devnet' ? 'dev' : 'mainnet';
  
  return {
    rpc: EnvironmentConstants.rpcs[envKey][0].value,
    wsRpc: EnvironmentConstants.rpcs[envKey][0].wsValue,
    historyServer: EnvironmentConstants.historyServerUrl[envKey],
    dataServer: EnvironmentConstants.dataServerUrl[envKey],
    dlobServer: EnvironmentConstants.dlobServerHttpUrl[envKey],
    dlobWebSocket: EnvironmentConstants.dlobServerWsUrl[envKey],
    swiftServer: env === 'devnet' 
      ? EnvironmentConstants.swiftServerUrl.staging
      : EnvironmentConstants.swiftServerUrl.mainnet,
  };
}

// Usage
const urls = getEnvironmentUrls('mainnet-beta');
console.log('RPC:', urls.rpc);
console.log('DLOB:', urls.dlobServer);

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

const authorityDrift = new AuthorityDrift({
  solanaRpcEndpoint: EnvironmentConstants.rpcs.mainnet[0].value,
  driftEnv: 'mainnet-beta',
  // DLOB and Swift URLs are automatically set based on environment
});

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

const serverDrift = new CentralServerDrift({
  solanaRpcEndpoint: EnvironmentConstants.rpcs.mainnet[0].value,
  driftEnv: 'mainnet-beta',
  supportedPerpMarkets: [0, 1, 2],
  supportedSpotMarkets: [0, 1],
});

// Access configured endpoints
const endpoints = serverDrift.driftEndpoints;
console.log('DLOB Server:', endpoints.dlobServerHttpUrl);
console.log('Swift Server:', endpoints.swiftServerUrl);

export const API_URLS = {
  DATA_API: 'https://data.api.drift.trade',
  DLOB: 'https://dlob.drift.trade',
  SWIFT: 'https://swift.drift.trade',
} as const;

export const API_ENDPOINTS = {
  FUNDING_RATES: '/fundingRates',
  BATCH_PRIORITY_FEES: '/batchPriorityFees',
  AUCTION_PARAMS: '/auctionParams',
} as const;

import { API_URLS, API_ENDPOINTS } from '@drift-labs/common';

// Fetch funding rates
const response = await fetch(
  `${API_URLS.DATA_API}${API_ENDPOINTS.FUNDING_RATES}?marketIndex=0`
);

// Fetch auction parameters
const auctionParams = await fetch(
  `${API_URLS.DLOB}${API_ENDPOINTS.AUCTION_PARAMS}`
);

// .env.development
DRIFT_ENV=devnet
SOLANA_RPC_URL=https://detailed-sharleen-fast-devnet.helius-rpc.com

// .env.production
DRIFT_ENV=mainnet-beta
SOLANA_RPC_URL=https://drift-drift_ma-39b5.mainnet.rpcpool.com/

// config.ts
import { DriftEnv } from '@drift-labs/sdk';
import { EnvironmentConstants } from '@drift-labs/common';

export const getConfig = () => {
  const env = (process.env.DRIFT_ENV || 'devnet') as DriftEnv;
  const envKey = env === 'devnet' ? 'dev' : 'mainnet';
  
  return {
    env,
    rpcEndpoint: process.env.SOLANA_RPC_URL || 
      EnvironmentConstants.rpcs[envKey][0].value,
    dlobServerUrl: EnvironmentConstants.dlobServerHttpUrl[envKey],
    dataServerUrl: EnvironmentConstants.dataServerUrl[envKey],
    swiftServerUrl: EnvironmentConstants.swiftServerUrl[
      env === 'devnet' ? 'staging' : 'mainnet'
    ],
  };
};

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

let connection: Connection;
try {
  connection = new Connection(primaryRpc.value, 'confirmed');
  await connection.getLatestBlockhash(); // Test connection
} catch (error) {
  console.warn('Primary RPC failed, using fallback');
  connection = new Connection(fallbackRpc.value, 'confirmed');
}

const fetchWithRetry = async (url: string, retries = 3) => {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url, { timeout: 5000 });
      if (response.ok) return response;
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
};

const isDevelopment = process.env.NODE_ENV === 'development';
const env = isDevelopment ? 'devnet' : 'mainnet-beta';

const config = {
  env,
  rpcEndpoint: EnvironmentConstants.rpcs[
    env === 'devnet' ? 'dev' : 'mainnet'
  ][0].value,
  // ... other config
};