Native SOL collateral

import {
  buildNativeSolDepositFlow,
  type Authority, type PhoenixInstructionClient,
} from "@ellipsis-labs/rise";

export async function nativeSolDeposit(
  client: PhoenixInstructionClient,
  owner: Authority,
  lamports = 10_000_000n, // 0.01 SOL
) {
  if (lamports <= 0n || lamports > 0xffff_ffff_ffff_ffffn) {
    throw new Error("Deposit must fit a positive u64");
  }
  return buildNativeSolDepositFlow({
    authority: owner, traderPdaIndex: 0, subaccountIndex: 0, lamports,
  }, client);
}

use phoenix_rise::core::{PhoenixMetadata, TraderKey};
use phoenix_rise::ix::native_sol::{
    create_deposit_native_sol_ixs, SyncNativeParams,
};
use solana_instruction::Instruction;
use solana_pubkey::Pubkey;

pub fn native_sol_deposit(
    metadata: &PhoenixMetadata,
    owner: Pubkey,
    lamports: u64, // pass 10_000_000 for 0.01 SOL
) -> Result<(Pubkey, Vec<Instruction>), Box<dyn std::error::Error>> {
    let trader = TraderKey::new(owner).pda();
    let keys = metadata.keys();
    let sync = SyncNativeParams::builder()
        .trader_account(trader)
        .global_trader_index(keys.global_trader_index.iter()
            .map(|key| key.parse()).collect::<Result<_, _>>()?)
        .active_trader_buffer(keys.active_trader_buffer.iter()
            .map(|key| key.parse()).collect::<Result<_, _>>()?)
        .build()?;
    let instructions = create_deposit_native_sol_ixs(owner, owner, lamports, sync)?;
    Ok((trader, instructions.into_iter().map(Into::into).collect()))
}

import {
  MarginMarketParamsStore,
  type PhoenixClient, type TraderMarginInputs,
} from "@ellipsis-labs/rise";

export async function apiSolMargin(
  client: PhoenixClient,
  inputs: TraderMarginInputs, // resource.marginInputs(); includes spot balances
) {
  const params = new MarginMarketParamsStore({ client: client.api });
  // Fetches market configuration, prices, and collateral metadata.
  const calculator = await params.getCalculator();
  const margin = calculator.computeTraderMarginFromInputs(inputs);
  console.log("margin (quote lots)", margin.subaccounts);
  return margin;
}

use phoenix_rise::api::{PhoenixHttpClient, PhoenixMetadata, SubaccountState};
use phoenix_rise::math::TraderPortfolioMargin;

pub async fn api_sol_margin(
    http: &PhoenixHttpClient,
    subaccount: &SubaccountState, // current trader-state API snapshot
) -> Result<TraderPortfolioMargin, Box<dyn std::error::Error>> {
    // Exchange snapshot includes collateral parameters; stats supply prices.
    let mut metadata = PhoenixMetadata::from_snapshot(http.get_exchange_snapshot().await?)?;
    for row in http.markets().get_latest_markets_stats().await?.markets {
        if metadata.get_market(&row.symbol).is_some() {
            metadata.apply_market_stats_v2(&row.into())?;
        }
    }
    let portfolio = subaccount.to_trader_portfolio_with_metadata(&metadata)?;
    let margin = portfolio.compute_margin(&metadata)?;
    println!("margin (quote lots): {margin:#?}");
    Ok(margin)
}

import { decodeTrader, type PhoenixClient, type TraderAddress } from "@ellipsis-labs/rise";

export async function printSolMargin(client: PhoenixClient, traderAccount: TraderAddress) {
  const account = await client.rpc.accounts.fetchAccount(traderAccount);
  const trader = decodeTrader(account.data);
  const result = await client.rpc.hawkeye.viewMargin({ traderAccount });
  if (result.err || !result.returnData) throw new Error("Hawkeye margin simulation failed");
  console.log("accounted SOL lamports", trader.nativeSolCollateral.toString());
  console.log("quote collateral", trader.state.quoteLotCollateral.toString());
  console.log("margin (quote lots)", result.returnData.decoded);
}

use phoenix_rise::accounts::trader::Trader;
use phoenix_rise::core::PhoenixHawkeyeClient;
use solana_pubkey::Pubkey;
use solana_rpc_client::nonblocking::rpc_client::RpcClient;

pub async fn print_sol_margin(
    rpc: &RpcClient,
    hawkeye: &PhoenixHawkeyeClient<'_>,
    trader: Pubkey,
) -> Result<(), Box<dyn std::error::Error>> {
    let account = rpc.get_account(&trader).await?;
    let decoded = Trader::try_from_account_bytes(&account.data)?;
    println!("accounted SOL lamports: {}", decoded.native_sol_collateral());
    println!("quote collateral: {}", decoded.header().trader_state.quote_lot_collateral.as_inner());
    println!("margin (quote lots): {:#?}", hawkeye.view_margin_for_trader(trader).await?.value);
    Ok(())
}