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', 'confirmed');

from solana.rpc.async_api import AsyncClient

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

drift-gateway https://api.mainnet-beta.solana.com --port 8080

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

const keyPairFile = `${process.env.HOME}/.config/solana/my-keypair.json`;
const wallet = new Wallet(loadKeypair(keyPairFile));

import os
from anchorpy import Wallet
from driftpy.keypair import load_keypair

keypair_file = os.path.expanduser('~/.config/solana/my-keypair.json')
keypair = load_keypair(keypair_file)
wallet = Wallet(keypair)

# use `DRIFT_GATEWAY_KEY` environment variable to configure the gateway wallet
# either path to .json keypair or base58 seed string
export DRIFT_GATEWAY_KEY="</path/to/my-keypair.json|<KEYPAIR_BASE58_SEED>"

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

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

const keyPairFile = `${process.env.HOME}/.config/solana/my-keypair.json`;
const wallet = new Wallet(loadKeypair(keyPairFile))

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

await driftClient.subscribe();

  from anchorpy import Wallet
  from driftpy.drift_client import DriftClient
  from solana.rpc.async_api import AsyncClient

  # set connection and wallet
  # ...
  drift_client = DriftClient(connection, wallet, "mainnet")

subAccountIds: [SUBACCOUNT_ID],  
activeSubAccountId: SUBACCOUNT_ID,  
authority: TARGET_AUTHORITY,  

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

tx_sig = await drift_client.initialize_user(sub_account_id=0, name="toly")

const subaccountId = 0;

// set max 1x intiial leverage
await driftClient.updateUserCustomMarginRatio([
    {
        'marginRatio': MARGIN_PRECISION,
        'subAccountId': subaccountId
    }
]);

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

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

driftClient.switchActiveUser(
  1,
);

drift_client.switch_active_user(sub_account_id=1)

curl http://localhost:8080/v2/<RESOURCE>?subAccountId=1

driftClient.deleteUser(
  1,
);

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

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

spot_market_index = 0 # USDC
amount = drift_client.convert_to_spot_precision(100, spot_market_index) # $100

tx_sig = await drift_client.deposit(amount, spot_market_index)

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

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

market_index = 0 # USDC
amount = drift_client.convert_to_spot_precision(100, market_index) # $100

# derive user ata to withdraw to
# ...

tx_sig = await drift_client.withdraw(amount, spot_market_index, ata_to_withdraw_to)

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

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

market_index = 0
amount = drift_client.convert_to_spot_precision(100, market_index)
from_sub_account_id = 0
to_sub_account_id = 0

await drift_client.transfer_deposit(
  amount,
  market_index,
  from_sub_account_id,
  to_sub_account_id,
)

// 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

market_index = 0

# place order to long 1 SOL-PERP @ $21.88 (post only)
order_params = OrderParams(
            order_type=OrderType.Limit(),
            base_asset_amount=drift_client.convert_to_perp_precision(1),
            market_index=market_index,
            direction=PositionDirection.Long(),
            price=drift_client.convert_to_price_precision(21.88),
            post_only=PostOnlyParams.TryPostOnly(),
        )
await drift_client.place_perp_order(order_params)

curl -X POST -H 'content-type: application/json' \
  -d '{
    "orders": [{
        "marketIndex": 0,
        "marketType": "perp",
        "amount": 1.23,
        "price": 80.0,
        "postOnly": true,
        "orderType": "limit",
        "immediateOrCancel": false,
        "reduceOnly": false
    }]
   }' \
localhost:8080/v2/orders

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

await driftClient.placeSpotOrder(orderParams);

market_index = 1

order_params = OrderParams(
            order_type=OrderType.Limit(),
            base_asset_amount=drift_client.convert_to_spot_precision(100, market_index),
            market_index=market_index,
            direction=PositionDirection.Long(),
            price=drift_client.convert_to_price_precision(100),
        )

await driftClient.place_spot_order(order_params);

curl -X POST -H 'content-type: application/json' \
  -d '{
    "orders": [{
        "marketIndex": 0,
        "marketType": "spot",
        "amount": -1.23,
        "price": 80.0,
        "postOnly": true,
        "orderType": "limit",
        "immediateOrCancel": false,
        "reduceOnly": false
    }]
   }' \
localhost:8080/v2/orders

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

await driftClient.placeOrders(placeOrderParams);

place_order_params = [
    OrderParams(
    order_type=OrderType.Limit(),
    base_asset_amount=drift_client.convert_to_perp_precision(100),
    market_index=0,
    direction=PositionDirection.Long(),
    market_type=MarketType.Perp(),
    price=drift_client.convert_to_price_precision(21.23),
  ),
   OrderParams(
    order_type=OrderType.Limit(),
    base_asset_amount=drift_client.convert_to_perp_precision(100),
    market_index=0,
    direction=PositionDirection.Short(),
    market_type=MarketType.Perp(),
    oracle_price_offset=drift_client.convert_to_price_precision(.05),
  )
]

await drift_client.place_orders(place_order_params);

curl -X POST -H 'content-type: application/json' \
  -d '{
      "orders": [{
          "marketIndex": 0,
          "marketType": "spot",
          "amount": 1.23,
          "price": 80.0,
          "postOnly": true,
          "orderType": "limit",
          "immediateOrCancel": false,
          "reduceOnly": false
      },
      {
          "marketIndex": 2,
          "marketType": "perp",
          "amount": 0.1,
          "price": 10000.0,
          "orderType": "market",
      }]
    }' \
localhost:8080/v2/orders

const oraclePrice = driftClient.getOracleDataForPerpMarket(18).price;
const auctionStartPrice = oraclePrice.neg().divn(1000); // start auction 10bps below oracle
const auctionEndPrice = oraclePrice.divn(1000); // end auction 10bps above oracle
const oraclePriceOffset = oraclePrice.divn(500); // limit price after auction 20bps above oracle
const auctionDuration = 30; // 30 slots
const orderParams = {
  orderType: OrderType.ORACLE,
  baseAssetAmount: driftClient.convertToPerpPrecision(10),
  direction: PositionDirection.LONG,
  marketIndex: 18,
  auctionStartPrice: auctionStartPrice,
  auctionEndPrice: auctionEndPrice,
  oraclePriceOffset: oraclePriceOffset,
  auctionDuration: auctionDuration,
};
await driftClient.placePerpOrder(orderParams)

oracle_price = drift_client.get_oracle_price_data_for_perp_market(18).price
auction_start_price = -oracle_price // 1000 # start auction 10bps below oracle
auction_end_price = oracle_price // 1000 # end auction 10bps above oracle
oracle_price_offset = oracle_price // 500 # limit price after auction 20bps above oracle
auction_duration = 30 # 30 slots
order_params = OrderParams(
  order_type=OrderType.Oracle(),
  base_asset_amount=drift_client.convert_to_perp_precision(10),
  market_index=18,
  direction=PositionDirection.Long(),
  auction_start_price=auction_start_price,
  auction_end_price=auction_end_price,
  oracle_price_offset=oracle_price_offset,
  auction_duration=auction_duration
)
await drift_client.place_perp_order(order_params)

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

order_dd = 1;
await drift_client.cancel_order(order_id);

curl -X DELETE -H 'content-type: application/json' \
  -d '{ "ids": [1] }' \
  localhost:8080/v2/orders

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

const user_order_id = 1;
await drift_client.cancel_order_by_user_order_id(user_order_id);

curl -X DELETE -H 'content-type: application/json' \
  -d '{ "userIds": [1] }' \
  localhost:8080/v2/orders

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

market_type = MarketType.Perp()
market_index = 0
direction = PositionDirection.Long()
await drift_client.cancel_orders(market_type, market_index, direction) # cancel bids in perp market 0

await drift_client.cancel_orders() # cancels all orders

curl -X DELETE -H 'content-type: application/json' \
  -d '{ "marketIndex": 1, "marketType": "spot" }' \
  localhost:8080/v2/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);

canel_order_params = (MarketType.Perp(), 0, None) # cancel all orders in perp market 0
place_order_params = [
    OrderParams(
    order_type=OrderType.Limit(),
    base_asset_amount=drift_client.convert_to_perp_precision(100),
    market_index=0,
    direction=PositionDirection.Long(),
    market_type=MarketType.Perp(),
    price=drift_client.convert_to_price_precision(21.23),
  ),
   OrderParams(
    order_type=OrderType.Limit(),
    base_asset_amount=drift_client.convert_to_perp_precision(100),
    market_index=0,
    direction=PositionDirection.Short(),
    market_type=MarketType.Perp(),
    oracle_price_offset=drift_client.convert_to_price_precision(.05),
  )
]

await drift_client.cancel_and_place_orders(canel_order_params, place_order_params);

curl -X POST -H 'content-type: application/json' \
-d '{
      "cancel": {
        "marketIndex": 0,
        "marketType": "perp"
      },
      "place": {
        "orders": [{
            "marketIndex": 0,
            "marketType": "perp",
            "amount": -1.23,
            "price": 80.0,
            "postOnly": true,
            "orderType": "limit",
            "immediateOrCancel": false,
            "reduceOnly": false
        }]
      }
   }' \
localhost:8080/v2/orders/cancelAndPlace

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

await driftClient.modifyOrder(orderParams);

order_id = 1

modify_order_params = ModifyOrderParams(
  base_asset_amount=drift_client.convert_to_perp_precision(1),
  price=drift_client.convert_to_price_precision(20),
)

await drift_client.modify_order(order_id, modify_order_params);

curl -X PATCH -H 'content-type: application/json' \
  -d '{
    "orders": [{
        "orderId": 32,
        "amount": 1.05,
        "price": 61.0
    }]
   }' \
localhost:8080/v2/orders

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

await driftClient.modifyOrderByUserOrderId(orderParams);

user_order_id = 1

modify_order_params = ModifyOrderParams(
  base_asset_amount=drift_client.convert_to_perp_precision(1),
  price=drift_client.convert_to_price_precision(20),
)

await drift_client.modify_order_by_user_id(user_order_id, modify_order_params);

curl -X PATCH -H 'content-type: application/json' \
  -d '{
    "orders": [{
        "userOrderId": 69,
        "amount": 1.05,
        "price": 61.0
    }]
   }' \
localhost:8080/v2/orders

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

market_index = 0
user =  drift_client.get_user()
await drift_client.settle_pnl(
   user.user_public_key,
   user.get_user_account(),
   market_index
)

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

market_index = 0;

spot_market_account = drift_client.get_spot_market_account(market_index);

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

market_index = 0;

perp_market_account = drift_client.get_perp_market_account(market_index);

const marketIndex = 0; // 0 = SOL-PERP market

const oracleInfo = driftClient.getOracleDataForPerpMarket(marketIndex);
const highPrice = oracleInfo.price.muln(101).divn(100);
const lowPrice = oracleInfo.price;

const orderParams = getMarketOrderParams({
    marketIndex: marketIndex,
    marketType: MarketType.PERP,
    direction: PositionDirection.LONG,
    baseAssetAmount: driftClient.convertToPerpPrecision(0.1), // 0.1 SOL,
    auctionStartPrice: isVariant(direction, 'long') ? lowPrice : highPrice,
        auctionEndPrice: isVariant(direction, 'long') ? highPrice : lowPrice,
        auctionDuration: 50,
});

market_index = 0
oracle_info = drift_client.get_oracle_price_data_for_perp_market(market_index)

high_price = oracle_info.price * 101 // 100
low_price = oracle_info.price

order_params = OrderParams(
    market_index=market_index,
    order_type=OrderType.Market(),
    market_type=MarketType.Perp(),
    direction=direction,
    base_asset_amount=drift_client.convert_to_perp_precision(0.1),
    auction_start_price=low_price if is_variant(direction, "short") else high_price,
    auction_end_price=high_price if is_variant(direction, "short") else low_price,
    auction_duration=50
)

const slot = await driftClient.connection.getSlot();

const orderMessage = {
    signedMsgOrderParams: orderParams,
    subAccountId: driftClient.activeSubAccountId,
    slot: new BN(slot),
    uuid: generateSignedMsgUuid(),
    stopLossOrderParams: null,
    takeProfitOrderParams: null,
};

// Sign the message
const signedOrder = driftClient.signSignedMsgOrderParamsMessage(orderMessage);
const message = Buffer.from(signedOrder.orderParams).toString('hex');
const signature = Buffer.from(signedOrder.signature).toString('base64');

slot_response = json.loads((await drift_client.connection.get_slot()).to_json())
slot = slot_response["result"]

order_message = SignedMsgOrderParamsMessage(
    signed_msg_order_params=order_params,
    sub_account_id=drift_client.active_sub_account_id,
    slot=slot,
    uuid=generate_signed_msg_uuid(),
    stop_loss_order_params=None,
    take_profit_order_params=None
)

# Sign the message
signed_msg = drift_client.sign_signed_msg_order_params_message(swift_message)
message = signed_msg.order_params
signature = signed_msg.signature

const swiftUrl = 'https://swift.drift.trade/orders';

const response = await axios.default.post(swiftUrl, {
    market_index: marketIndex,
    market_type: 'perp',
    message: message,
    signature: signature,
    taker_authority: driftClient.wallet.publicKey.toBase58(),
}, {
    headers: { 'Content-Type': 'application/json' }
});

console.log("Order response:", response.data);

payload = {
    "market_index": market_index,
    "market_type": "perp",
    "message": message.decode("utf-8"),
    "signature": base64.b64encode(signature).decode("utf-8"),
    "taker_authority": str(drift_client.wallet.public_key),
}

response = requests.post(
    f"{swift_url}/orders",
    json=payload,
    headers={"Content-Type": "application/json"},
)
print(f"Order response: {response.text}")

   const user = driftClient.getUser();

  user = drift_client.get_user();

const marketIndex = 0;

const tokenAmount = user.getTokenAmount(
  marketIndex,
);

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

market_index = 0

token_amount = user.get_token_amount(marketIndex)

is_deposit = token_amount > 0
is_borrow = token_amount < 0

 curl -X GET \
  -H 'content-type: application/json' \
  -d '{"marketIndex":0,"marketType":"spot"}' \
localhost:8080/v2/positions

const marketIndex = 0;

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

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

market_index = 0

perp_position = user.get_perp_position(market_index)

base_asset_amount = perp_position.base_asset_amount if perp_position is not None else 0

is_long = base_asset_amount > 0
is_short = base_asset_amount < 0

curl -X GET \
  -H 'content-type: application/json' \
  -d '{"marketIndex":0,"marketType":"perp"}' \
localhost:8080/v2/positions

const orderId = 1;

const order = user.getOrder(
  orderId,
);

order_id = 1

order = user.get_order(order_id)

const userOrderId = 1;

const order = user.getOrderByUserOrderId(
  userOrderId,
);

user_order_id = 1

order = user.get_order_by_user_order_id(user_order_id)

const orders = user.getOpenOrders();

orders = user.get_open_orders()

curl localhost:8080/v2/orders

  const pnl = user.getUnrealizedPNL();

  pnl = user.get_unrealized_pnl()

  const pnl = user.getUnrealizedFundingPNL();

  pnl = user.get_unrealized_funding_pnl()

  const totalCollateral = user.getTotalCollateral();

  total_collateral = user.get_total_collateral()

  const marginRequirement = user.getMarginRequirement();

  margin_requirement = user.get_margin_requirement()

  const freeCollateral = user.getFreeCollateral();

  free_collateral = user.get_free_collateral()

  const leverage = user.getLeverage();

  leverage = user.get_leverage()

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

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);
});

from driftpy.events.event_subscriber import EventSubscriber
from driftpy.events.types import WrappedEvent, EventSubscriptionOptions, WebsocketLogProviderConfig

options = EventSubscriptionOptions(
    event_types = (
        'DepositRecord',
        'FundingPaymentRecord',
        'LiquidationRecord',
        'OrderRecord',
        'OrderActionRecord',
        'FundingRateRecord',
        'NewUserRecord',
        'SettlePnlRecord',
        'LPRecord',
        'InsuranceFundRecord',
        'SpotInterestRecord',
        'InsuranceFundStakeRecord',
        'CurveRecord',
    ),
    max_tx= 4096,
    max_events_per_type=4096,
    order_by="blockchain",
    order_dir="asc",
    commitment="processed",
    log_provider_config=WebsocketLogProviderConfig()
)

event_subscriber = EventSubscriber(connection, drift_client.program, options)
event_subscriber.subscribe()

event_subscriber.event_emitter.new_event += lambda event: print(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);
  }
});

market_index = 0

def fill_callback(event: WrappedEvent):
    if event.event_type != "OrderActionRecord":
        return

    if event.data.market_index != market_index:
        return

    if not is_variant(event.data.market_type, "Perp"):
        return

    if not is_variant(event.data.action, "Fill"):
        return

    print(event)


event_subscriber.event_emitter.new_event += fill_callback

options = EventSubscriptionOptions(
    address=drift_client.get_user_account_public_key(),
)

event_subscriber = EventSubscriber(connection, drift_client.program, options)
event_subscriber.subscribe()

def fill_callback(event: WrappedEvent):
    if event.event_type != "OrderActionRecord":
        return

    if not is_variant(event.data.action, "Fill"):
        return

    is_taker = event.data.taker == drift_client.get_user_account_public_key()
    is_maker = event.data.taker == drift_client.get_user_account_public_key()
    if not is_taker and not is_maker:
        return

    print(event)


event_subscriber.event_emitter.new_event += fill_callback

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

event_type = 'OrderActionRecord'
events = event_subscriber.get_events_array(event_type)

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

tx_sig = '3dq5PtQ3VnNTkQRrHhQ1nRACWZaFVvSBKs1RLXM8WvCqLHTzTuVGc7XER5awoLFLTdJ4kqZiNmo7e8b3pXaEGaoo'
events = event_subscriber.get_events_by_tx(tx_sig)

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

perp_market_index = 0 # SOL-PERP
perp_position = drift_client.get_perp_position(market_index)
print(convert_to_number(perp_position.base_asset_amount, 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));

spot_market_index = 0 # USDC
spot_market = drift_client.get_spot_market_account(spot_market_index)
spot_position = drift_client.get_spot_position(spot_market_index)
token_amount = get_token_amount(spot_psoition.scaled_balance, spot_market, spot_position.balance_type)
print(convert_to_number(token_amount, (10 ** spot_market.decimals)))

git clone git@github.com:drift-labs/drift-vaults.git
cd ts/sdk
yarn
yarn cli --help

//This creates a new vault that takes SOL, with a redeem-period of 3600 seconds, max vault capacity of 10000 SOL, 2% management fee, 20% //profit share fee, is permissioned (whitelist required), and has a min deposit of 1 SOL.

yarn cli init-vault \
--name "test vault" \
--market-index 1 \
--redeem-period 3600 \
--max-tokens 10000 \
--management-fee 2 \
--profit-share 20 \
--permissioned \
--min-deposit-amount 1 \
--url <your RPC url> \
--keypair ~/.config/solana/keypair.json

yarn cli manager-update-vault \
--vault-address <vault_address> \
--redeem-period 1000 \
--max-tokens 200000 \
--management-fee 0 \
--profit-share 0 \
--url <your RPC url> \
--keypair ~/.config/solana/keypair.json

yarn cli manager-update-margin-trading-enabled --vault-address=<VAULT_ADDRESS> --enabled=<true|false>

yarn cli manager-deposit --vault-address=<VAULT_ADDRESS> --amount=<DEPOSIT_AMOUNT>

yarn cli manager-request-withdraw --vault-address=<VAULT_ADDRESS> --amount=<SHARES>

yarn cli manager-withdraw --vault-address=<VAULT_ADDRESS>

yarn cli init-vault-depositor --vault-address=<VAULT_ADDRESS> --deposit-authority=<AUTHORITY_TO_ALLOW_DEPOSIT>

yarn cli deposit --vault-address=<VAULT_ADDRESS> --deposit-authority=<DEPOSIT_AUTHORITY> --amount=<DEPOSIT_AMOUNT>

yarn cli deposit --vault-depositor-address=<VAULT_DEPOSITOR_ADDRESS> --amount=<DEPOSIT_AMOUNT>

yarn cli request-withdraw --vault-address=<VAULT_ADDRESS> --authority=<AUTHORITY> --amount=<WITHDRAW_AMOUNT>

yarn cli withdraw --vault-address=<VAULT_ADDRESS> --authority=<AUTHORITY>

yarn cli view-vault --vault-address=<VAULT_ADDRESS>

yarn cli view-vault-depositor --vault-depositor-address=<VAULT_DEPOSITOR_ADDRESS>

/**
 * Making a Place And Take with atomic "fill-or-kill" flag to ensure the transaction only succeeds if the entire order is filled
 * 
 **/

import {
    decodeUser,
    PublicKey,
    MarketType,
    BASE_PRECISION,
    PlaceAndTakeOrderSuccessCondition,
    UserAccount,
    isVariant,
    PositionDirection,
    DriftClient,
    getUserStatsAccountPublicKey,
    BN,
    OrderType,
} from '@drift-labs/sdk';

// Method to fetch the current top makers taking advantage of Drift's off-chain infra which can provide these. You may eventually want to keep track of the state of on-chain makers yourself.
async function getTopMakersForPlaceAndTake({
    marketIndex,
    marketType,
    side,
}: {
    marketIndex: number;
    marketType: MarketType;
    side: 'bid' | 'ask';
}): Promise<
    {
        userAccountPubKey: PublicKey;
        userAccount: UserAccount;
    }[]
> {
    const dlobServerUrl = `https://dlob.drift.trade/`;
    const marketTypeStr = isVariant(marketType, 'perp') ? 'perp' : 'spot';
    const limit = 4; // NOTE: This parameter controls the number of top makers that will be returned. It is suggested not to use more than 4, in our current testing the size of the transaction will larger than the current limits if you pass more than 4 makers in.

    const queryParams = `marketIndex=${marketIndex}&marketType=${marketTypeStr}&side=${side}&limit=${limit}&includeAccounts=true`;

    const result = await new Promise<
        {
            userAccountPubKey: string;
            accountBase64: string;
        }[]
    >((res) => {
        fetch(`${dlobServerUrl}/topMakers?${queryParams}`)
            .then(async (response) => {
                if (!response.ok) {
                    // Handle failure
                    return;
                }
                res(await response.json());
            })
            .catch((err) => {
                // Handle failure
            });
    });

    return result.map(
        (value: { userAccountPubKey: string; accountBase64: string }) => {
            return {
                userAccountPubKey: new PublicKey(value.userAccountPubKey),
                userAccount: decodeUser(Buffer.from(value.accountBase64, 'base64')),
            };
        }
    );

    return [];
}

// Fetch and process the top makers result into params for a place and take order
async function getMakerInfoForPlaceAndTake(
    orderDirection: PositionDirection,
    orderMarketIndex: number,
    orderMarketType: MarketType,
    driftClient: DriftClient
) {
    const topMakers = await getTopMakersForPlaceAndTake({
        marketIndex: orderMarketIndex,
        marketType: orderMarketType,
        side: isVariant(orderDirection, 'long') ? 'ask' : 'bid', // If we're going LONG, we want the makers on the ASK side, and vice-versa
    });

    const makerAccountKeys = topMakers.map((maker) => maker.userAccountPubKey);
    const makerStatsAccountKeys = topMakers.map((makerAccount) =>
        getUserStatsAccountPublicKey(
            driftClient.program.programId,
            makerAccount.userAccount.authority
        )
    );
    const makerAccounts = topMakers.map((maker) => maker.userAccount);

    return makerAccountKeys.map((makerUserAccountKey, index) => {
        return {
            maker: makerUserAccountKey,
            makerUserAccount: makerAccounts[index],
            makerStats: makerStatsAccountKeys[index],
        };
    });
}

// Create a PlaceAndTake Instruction. DriftClient also has a `placeAndTakePerpOrder` If you want DriftClient to create+sign+send the transaction if you don't want to manually handle the instruction.
async function makePlaceAndTakePerpOrderIx(
    orderDirection: PositionDirection,
    orderMarketIndex: number,
    orderSizeBase: BN,
    successCondition: PlaceAndTakeOrderSuccessCondition,
    driftClient: DriftClient
) {
    const makerInfos = await getMakerInfoForPlaceAndTake(
        orderDirection,
        orderMarketIndex,
        MarketType.PERP,
        driftClient
    );

    const placeAndTakeIx = await driftClient.getPlaceAndTakePerpOrderIx(
        {
            direction: orderDirection,
            baseAssetAmount: orderSizeBase,
            marketIndex: orderMarketIndex,
            marketType: MarketType.PERP,
            orderType: OrderType.MARKET,
        },
        makerInfos,
        undefined,
        successCondition
    );

    return placeAndTakeIx;
}

// Example: Make a LONG order for 1 SOL-PERP which will "fill-or-kill" if the entire order isn't filled atomically. 
const driftClient = DRIFT_CLIENT; // Assume you have a Drift Client set up and ready to go, see https://drift-labs.github.io/v2-teacher/#client-initialization
const sizeInSol = 1;
await makePlaceAndTakePerpOrderIx(
    PositionDirection.LONG,
    0, // SOL-PERP's market index is 0
    new BN(sizeInSol).mul(BASE_PRECISION),
    PlaceAndTakeOrderSuccessCondition.FullFill, // This ensures the order is completely filled, or the tx fails.
    driftClient,
)

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", 'confirmed');

const keyPairFile = `${process.env.HOME}/.config/solana/my-keypair.json`;
const wallet = new Wallet(loadKeypair(keyPairFile))

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

// polling keep users updated with periodic calls to getProgramAccounts
// websocket keep users updated via programSubscribe
const subscriptionConfig:
  | {
    type: 'polling';
    frequency: number;
    commitment?: Commitment;
  } | {
    type: 'websocket';
    resubTimeoutMs?: number;
    commitment?: Commitment;
  } = {
    type: 'websocket',
    resubTimeoutMs: 30_000,
    commitment: stateCommitment,
  };

const userMap = new UserMap({
  driftClient,
  connection,
  subscriptionConfig,
  skipInitialLoad: false, // skips initial load of user accounts
  includeIdle: false, // filters out idle users
});

await userMap.subscribe();

from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from anchorpy import Wallet
from driftpy.drift_client import DriftClient
from driftpy.keypair import load_keypair
from driftpy.user_map.user_map import UserMap
from driftpy.user_map.user_map_config import UserMapConfig, WebsocketConfig

connection = AsyncClient("https://api.mainnet-beta.solana.com")  # switch for your own rpc

keypair_file = ""  # path to keypair file

wallet = Wallet(load_keypair(keypair_file))

drift_client = DriftClient(
  connection,
  wallet,
  "mainnet"
)

await drift_client.subscribe()

user_map_config = UserMapConfig(drift_client, WebsocketConfig())
user_map = UserMap(user_map_config)

await user_map.subscribe()

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

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

const keyPairFile = `${process.env.HOME}/.config/solana/my-keypair.json`;
const wallet = new Wallet(loadKeypair(keyPairFile))

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

const subscriptionConfig:
  | {
    type: 'polling',
    frequency: ORDERBOOK_UPDATE_INTERVAL,
    commitment: stateCommitment,
  }
  | {
    type: 'websocket',
    commitment: stateCommitment,
    resyncIntervalMs: WS_FALLBACK_FETCH_INTERVAL,
  } = {
    type: 'websocket',
    commitment: stateCommitment,
    resyncIntervalMs: WS_FALLBACK_FETCH_INTERVAL, // periodically resyncs the orders in case of missed websocket messages
  };

const orderSubscriber = new OrderSubscriber({
  driftClient,
  subscriptionConfig,
});

await orderSubscriber.subscribe();

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

 const dlobSubscriber = new DLOBSubscriber({
    driftClient,
    dlobSource: orderSubscriber, // or UserMap
    slotSource: orderSubscriber, // or UserMap
    updateFrequency: 1000,
 });

await dlobSubscriber.subscribe();

from driftpy.dlob.dlob_subscriber import DLOBSubscriber
from driftpy.dlob.client_types import DLOBClientConfig
from driftpy.slot.slot_subscriber import SlotSubscriber

slot_subscriber = SlotSubscriber(drift_client)

config = DLOBClientConfig(drift_client, user_map, slot_subscriber, 1)
dlob_subscriber = DLOBSubscriber(config = config)

await dlob_subscriber.subscribe()

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

l2 = dlob_subscriber.get_l2_orderbook_sync("SOL-PERP")

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

l3 = dlob_subscriber.get_l3_orderbook_sync("SOL-PERP")