solana-keygen new --outfile ~/.config/solana/my-keypair.json

export ANCHOR_WALLET=~/.config/solana/my-keypair.json

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

// the default RPC for devnet is `https://api.devnet.solana.com`
const connection = new Connection('https://api.mainnet-beta.solana.com');

from solana.rpc.async_api import AsyncClient

url = 'https://api.mainnet-beta.solana.com' # replace w/ any rpc
connection = AsyncClient(url)

import {Wallet, loadKeypair} from "@drift-labs/sdk";

const keyPairFile = '~/.config/solana/my-keypair.json';
const wallet = new Wallet(loadKeypair(privateKeyFile));

from solana.keypair import Keypair
from anchorpy import Wallet
import os
import json

key_pair_file = '~/.config/solana/my-keypair.json'
with open(os.path.expanduser(key_pair_file), 'r') as f: secret = json.load(f)
kp = Keypair.from_secret_key(bytes(secret))
wallet = Wallet(kp)

import {Connection} from "@solana/web3.js";
import {Wallet, loadKeypair, DriftClient} from "@drift-labs/sdk";

const connection = new Connection('https://api.mainnet-beta.solana.com');

const keyPairFile = '~/.config/solana/my-keypair.json';
const wallet = new Wallet(loadKeypair(privateKeyFile))

const driftClient = new DriftClient({
  connection,
  wallet,
  env: 'mainnet-beta',
});

driftClient.subscribe();

  import driftpy
  from anchorpy import Wallet, Provider
  from driftpy.constants.config import configs
  from driftpy.clearing_house import ClearingHouse

  # set connection and wallet
  # ...
  provider = Provider(connection, wallet)
  config = configs['mainnet'] # or devnet
  drift_client = ClearingHouse.from_config(config, provider)

const [txSig, userPublickKey] = await driftClient.initializeUser(
  0,
  "toly"
);

# todo: cannot init with name
tx_sig = await drift_client.intialize_user(0)

const subaccountId = 0;

// set max 1x intiial leverage
await this.driftClient.updateUserCustomMarginRatio(
  MARGIN_PRECISION,
  subaccountId
);

// enable spot margin trading
await this.driftClient.updateUserMarginTradingEnabled(
  true,
  subaccountId
);

// add a delegate this user account
await this.driftClient.updateUserDelegate(
  new PublicKey('satoshi'),
  subaccountId
);

driftClient.switchActiveUser(
  1,
);

driftClient.deleteUser(
  1,
);

const marketIndex = 0; // USDC
const amount = driftClient.convertToSpotPrecision(marketIndex, 100); // $100
const associatedTokenAccount = await driftClient.getAssociatedTokenAccount(marketIndex);

driftClient.deposit(
  amount,
  marketIndex,
  associatedTokenAccount,
);

from driftpy.accounts import get_spot_market_account
from spl.token.instructions import get_associated_token_address

spot_market_index = 0 # USDC
spot_market = await get_spot_market_account(drift_client.program, spot_market_index)
user_token_account = get_associated_token_address(drift_client.authority, spot_market.mint)
amount = 100 * QUOTE_PRECISION # $100

tx_sig = await drift_client.deposit(amount, spot_market_index, user_token_account)

const marketIndex = 0;
const amount = driftClient.convertToSpotPrecision(marketIndex, 100);
const associatedTokenAccount = await driftClient.getAssociatedTokenAccount(marketIndex);

driftClient.withdraw(
  amount,
  marketIndex,
  associatedTokenAccount,
);

const marketIndex = 0;
const amount = driftClient.convertToSpotPrecision(marketIndex, 100);
const fromSubAccountId = 0;
const toSubAccountId = 1;

driftClient.transferDeposit(
  amount,
  marketIndex,
  fromSubAccountId,
  toSubAccountId,
);

// market buy for 100 SOL-PERP @ $21.20->$21.30 over 60 slots (~30 seconds)
// after 60 slots, market buy 100 SOL-PERP @ $21.35 until maxTs
const orderParams = {
  orderType: OrderType.MARKET,
  marketIndex: 0,
  direction: PositionDirection.LONG,
  baseAssetAmount: driftClient.convertToPerpPrecision(100),
  auctionStartPrice: driftClient.convertToPricePrecision(21.20),
  auctionEndPrice: driftClient.convertToPricePrecision(21.30),
  price: driftClient.convertToPricePrecision(21.35),
  auctionDuration: 60,
  maxTs: now + 100,
}
await driftClient.placePerpOrder(orderParams);

// bid for 100 SOL-PERP @ $21.23
const orderParams = {
  orderType: OrderType.LIMIT,
  marketIndex: 0,
  direction: PositionDirection.LONG,
  baseAssetAmount: driftClient.convertToPerpPrecision(100),
  price: driftClient.convertToPricePrecision(21.23),
}
await driftClient.placePerpOrder(orderParams);

// ask for 100 SOL-PERP @ ${OraclePrice} + .05
const orderParams = {
  orderType: OrderType.LIMIT,
  marketIndex: 0,
  direction: PositionDirection.SHORT,
  baseAssetAmount: driftClient.convertToPerpPrecision(100),
  oraclePriceOffset: driftClient.convertToPricePrecision(.05).toNumber(),
}
await driftClient.placePerpOrder(orderParams);

from driftpy.types import *
from driftpy.constants.numeric_constants import BASE_PRECISION, PRICE_PRECISION

subaccount_id = 0
market_index = 0

# place order to long 1 SOL-PERP @ $21.88 (post only)
bid_params = OrderParams(
            order_type=OrderType.LIMIT(),
            market_type=MarketType.PERP(),
            direction=PositionDirection.LONG(),
            user_order_id=0,
            base_asset_amount=int(1 * BASE_PRECISION),
            price=21.88 * PRICE_PRECISION,
            market_index=market_index,
            reduce_only=False,
            post_only=PostOnlyParams.TRY_POST_ONLY(),
            immediate_or_cancel=False,
            trigger_price=0,
            trigger_condition=OrderTriggerCondition.ABOVE(),
            oracle_price_offset=0,
            auction_duration=None,
            max_ts=None,
            auction_start_price=None,
            auction_end_price=None,
        )
await drift_client.get_place_perp_order(bid_order_params, subaccount_id)

const orderParams = {
  orderType: OrderType.LIMIT,
  marketIndex: 1,
  direction: PositionDirection.LONG,
  baseAssetAmount: driftClient.convertToSpotPrecision(1, 100),
  price: driftClient.convertToPricePrecision(100),
}

await driftClient.placeSpotOrder(orderParams);

const placeOrderParams = [
    {
     orderType: OrderType.LIMIT,
     marketIndex: 0,
     direction: PositionDirection.LONG,
     baseAssetAmount: driftClient.convertToPerpPrecision(100),
     price: driftClient.convertToPricePrecision(21.23),
   },
   {
     orderType: OrderType.LIMIT,
     marketIndex: 0,
     direction: PositionDirection.SHORT,
     baseAssetAmount: driftClient.convertToPerpPrecision(100),
     oraclePriceOffset: driftClient.convertToPricePrecision(.05).toNumber(),
   }
];

await driftClient.placeOrders(placeOrderParams);

const orderId = 1;
await driftClient.cancelOrder(orderId);

const userOrderId = 1;
await driftClient.cancelOrderByUserOrderId(userOrderId);

const marketType = MarketType.PERP;
const marketIndex = 0;
const direction = PositionDirection.LONG;
await driftClient.cancelOrders(marketType, marketIndex, direction);

subaccount_id = 0
await drift_client.cancel_orders(subaccount_id) # cancels all orders

const cancelOrderParams = {
   marketType: MarketType.PERP,
   marketIndex: 0,
};

const placeOrderParams = [
    {
     orderType: OrderType.LIMIT,
     marketIndex: 0,
     direction: PositionDirection.LONG,
     baseAssetAmount: driftClient.convertToPerpPrecision(100),
     price: driftClient.convertToPricePrecision(21.23),
   },
   {
     orderType: OrderType.LIMIT,
     marketIndex: 0,
     direction: PositionDirection.SHORT,
     baseAssetAmount: driftClient.convertToPerpPrecision(100),
     oraclePriceOffset: driftClient.convertToPricePrecision(.05).toNumber(),
   }
];

await driftClient.cancelAndPlaceOrders(cancelOrderParams, placeOrderParams);

const updateParams = {
  orderId: 1,
  newBaseAssetAmount: driftClient.convertToPerpPrecision(200),
}

await driftClient.modifyOrder(orderParams);

const updateParams = {
  userOrderId: 1,
  newBaseAssetAmount: driftClient.convertToPerpPrecision(200),
}

await driftClient.modifyOrder(orderParams);

const marketIndex = 0;
const user =  driftClient.getUser();
await driftClient.settlePNL(
   user.userAccountPublicKey,
   user.getUserAccount(),
   marketIndex
);

const marketIndex = 1;
const spotMarketAccount = driftClient.getSpotMarketAccount(marketIndex);

const marketIndex = 0;
const perpMarketAccount = driftClient.getPerpMarketAccount(marketIndex);

   const user = await driftClient.getUser();

const marketIndex = 0;

const tokenAmount = user.getTokenAmount(
  marketIndex,
);

const isDeposit = tokenAmount.gte(new BN(0));
const isBorrow = tokenAmount.lt(new BN(0));

const marketIndex = 0;

const baseAssetAmount = user.getPerpPosiiton(
  marketIndex,
)?.baseAssetAmount;

const isLong = baseAssetAmount.gte(new BN(0));
const isShort = baseAssetAmount.lt(new BN(0));

const orderId = 1;

const order = user.getOrder(
  orderId,
);

const userOrderId = 1;

const order = user.getOrderByUserOrderId(
  userOrderId,
);

const order = user.getOpenOrders();

  const pnl = await user.getUnrealizedPNL();

  const pnl = await user.getUnrealizedFundingPNL();

  const totalCollateral = await user.getTotalCollateral();

  const marginRequirement = await user.getMarginRequirement();

  const freeCollateral = await user.getFreeCollateral();

  const leverage = await user.getLeverage();

   import {Connection} from "@solana/web3.js";
   import {SlotSubscriber} from "@drift-labs/sdk";

   const connection = new Connection("https://api.mainnet-beta.solana.com");
   const slotSubscriber = new SlotSubscriber(connection);

   await slotSubscriber.subscribe();
   const slot = slotSubscriber.getSlot();

   slotSubscriber.eventEmitter.on('newSlot', async (slot) => {
      console.log('new slot', slot);
   });

   import {Connection} from "@solana/web3.js";
   import {DriftClient, UserMap, Wallet, loadKeypair} from "@drift-labs/sdk";

   const connection = new Connection("https://api.mainnet-beta.solana.com");

   const keyPairFile = '~/.config/solana/my-keypair.json';
   const wallet = new Wallet(loadKeypair(privateKeyFile))

   const driftClient = new DriftClient({
     connection,
     wallet,
     env: 'mainnet-beta',
   });

   await driftClient.subscribe();

   const includeIdleUsers = false;
   const userMap = new UserMap(driftClient, {type: 'websocket'}, false);
   await userMap.subscribe();

import {DLOBSubscriber} from "@drift-labs/sdk";

// on-chain subscription to users
const userMap = new UserMap(driftClient, {type: 'websocket'}, false);
await userMap.subscribe();

 const dlobSubscriber = new DLOBSubscriber({
    driftClient,
    dlobSource: userMap,
    slotSource: slotSubscriber,
    updateFrequency: 1000,
 });

await dlobSubscriber.subscribe();

import {DLOBApiClient, DLOBSubscriber} from "@drift-labs/sdk";

 // Polling from api
 const dlobApiClient = new DLOBApiClient({
   url: 'https://dlob.drift.trade/orders/idlWithSlot',
 });

 const dlobSubscriber = new DLOBSubscriber({
    driftClient,
    dlobSource: dlobApiClient,
    slotSource: slotSubscriber,
    updateFrequency: 1000,
 });

 await dlobSubscriber.subscribe();

const l2 = dlobSubscriber.getL2({
  marketName: 'SOL-PERP',
  depth: 50,
});

const l3 = dlobSubscriber.getL3({
  marketName: 'SOL-PERP',
});

import {Connection} from "@solana/web3.js";
import {Wallet, loadKeypair, DriftClient, EventSubscriber} from "@drift-labs/sdk";

const connection = new Connection('https://api.mainnet-beta.solana.com');

const keyPairFile = '~/.config/solana/my-keypair.json';
const wallet = new Wallet(loadKeypair(privateKeyFile))

const driftClient = new DriftClient({
  connection,
  wallet,
  env: 'mainnet-beta',
});

const options = {
  eventTypes: [
    'DepositRecord',
    'FundingPaymentRecord',
    'LiquidationRecord',
    'OrderRecord',
    'OrderActionRecord',
    'FundingRateRecord',
    'NewUserRecord',
    'SettlePnlRecord',
    'LPRecord',
    'InsuranceFundRecord',
    'SpotInterestRecord',
    'InsuranceFundStakeRecord',
    'CurveRecord',
  ],
  maxTx: 4096,
  maxEventsPerType: 4096,
  orderBy: 'blockchain',
  orderDir: 'asc',
  commitment: 'confirmed',
  logProviderConfig: {
    type: 'websocket',
  },
}

const eventSubscriber = new EventSubscriber(connection, driftClient.program, options);
await eventSubscriber.subscribe();

eventSubscriber.eventEmitter.on('newEvent', (event) => {
  console.log(event);
});

const marketIndex = 0;
const isPerpMarketFill = (event) => {
  if (event.eventType !== 'OrderActionRecord') {
    return false;
  }

  if (event.marketIndex !== marketIndex) {
    return false;
  }

  if (!isVariant(event.marketType, 'perp')) {
    return false;
  }

  if (!isVariant(event.action, 'fill')) {
    return false;
  }

  return true;
};

const fillCallback = (event) => {
  console.log(event);
}

eventSubscriber.eventEmitter.on('newEvent', (event) => {
  if (isPerpMarketFill(event)) {
    fillCallback(event);
  }
});

const eventType = 'OrderActionRecord';
const events = eventSubscriber.getEventsReceived(eventType);

const txSig = '3dq5PtQ3VnNTkQRrHhQ1nRACWZaFVvSBKs1RLXM8WvCqLHTzTuVGc7XER5awoLFLTdJ4kqZiNmo7e8b3pXaEGaoo';
const events = eventSubscriber.getEventsByTx(txSig);

const perpMarketIndex = 0; // SOL-PERP
const perpPosition = driftClient.getPerpPosition(perpMarketIndex);
console.log(convertToNumber(perpPosition.baseAssetAmount, BASE_PRECISION));

const spotMarketIndex = 0; // USDC
const spotConfig = SpotMarkets['mainnet-beta'][spotMarketIndex];
const spotMarket = driftClient.getSpotMarketAccount(spotMarketIndex);
const spotPosition = driftClient.getSpotPosition(spotMarketIndex);
const tokenAmount = getTokenAmount(spotPosition.scaledBalance, spotMarket, .spotPosition.balanceType);
console.log(convertToNumber(tokenAmount, spotConfig.precision));

import requests

outcsv = requets.get('https://drift-historical-data.s3.eu-west-1.amazonaws.com/program/dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH/user/2dy78vpWpquDgAoLB8w8Ewfns9WXYzQx4CGt3HSgZLEe/trades/2023/4')'

curl https://drift-historical-data.s3.eu-west-1.amazonaws.com/program/dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH/user/2dy78vpWpquDgAoLB8w8Ewfns9WXYzQx4CGt3HSgZLEe/trades/2023/4 --output out.csv.gz