Leverage positions: a leveraged account per user, opened in one call

import { Sodax, sizeLeverageBorrow, projectLeverageLeg, type LeverageLegRequest } from '@sodax/sdk';
import { parseUnits } from 'viem';

const sodax = new Sodax();

// The partner fee a new position carries is borrowed on top of the trade, so it belongs in the sizing.
const fee = sodax.leverageYield.getEffectivePositionFee();
if (!fee.ok) throw fee.error;

const request: LeverageLegRequest = {
  side: 'collateral',
  deposit: parseUnits('1', 18),
  depositDecimals: 18,
  collateralPriceUsd: Number(collateralReserve.priceInUSD),
  borrowPriceUsd: Number(borrowReserve.priceInUSD),
  borrowDecimals: borrowReserve.decimals,
  leverage: 3,
  feeBps: fee.value.feeBps,
};

// 1. Oracle sizing: what to borrow, and what the solver will be asked to trade.
const { borrowAmount, intentInput } = sizeLeverageBorrow(request);

// 2. Ask solvers what that trade really returns.
const leg = await sodax.leverageYield.getPositionLegQuote({
  inputHubToken: borrowReserve.underlyingAsset,
  outputHubToken: collateralReserve.underlyingAsset,
  amount: intentInput,
});
if (!leg.ok) throw leg.error;

// 3. Project the position from the quote, with 1% slippage.
const p = projectLeverageLeg(
  request,
  { quotedCollateral: leg.value.quotedAmount, collateralDecimals: 18 },
  risk, // { ltv, liquidationThreshold } as fractions, from the reserve or its eMode category
  1,
);
if (p.exceedsMaxLtv) {
  throw new Error(`Too much leverage at this price. Max is about ${p.usableMaxLeverage.toFixed(2)}x`);
}
console.log(`Exposure ${p.exposureLeverage.toFixed(2)}x, health factor ${p.healthFactor.toFixed(2)}`);

import { ChainKeys } from '@sodax/types';

const funding = { srcChainKey: ChainKeys.SONIC_MAINNET, srcAddress: userAddress, token: collateralToken, amount: request.deposit };
const allowed = await sodax.leverageYield.isPositionFundingAllowanceValid(funding);
if (!allowed.ok) throw allowed.error;
if (!allowed.value) {
  const approved = await sodax.leverageYield.approvePositionFunding({ ...funding, walletProvider });
  if (!approved.ok) throw approved.error;
}

const opened = await sodax.leverageYield.openLeveragePosition({
  side: 'collateral',
  params: {
    srcChainKey: ChainKeys.SONIC_MAINNET,
    srcAddress: userAddress,
    token: collateralToken,
    amount: request.deposit,
    eModeCategory,
    borrowToken: borrowReserve.underlyingAsset,
    borrowAmount,
    minCollateralOut: p.minCollateralOut,
  },
  walletProvider,
});
if (!opened.ok) throw opened.error;

// The intent is live. `notified: false` means no solver was told about it yet.
if (!opened.value.notified) console.warn('Solver notification failed:', opened.value.notifyError);

const list = await sodax.leverageYield.listPositionsForUser(ChainKeys.SONIC_MAINNET, userAddress);
if (!list.ok) throw list.error;

for (const position of list.value) {
  const account = await sodax.leverageYield.getPositionAccount(position);
  const pending = await sodax.leverageYield.getPositionPendingState(position);
  if (!account.ok || !pending.ok) continue;

  const { healthFactor, totalCollateralBase, totalDebtBase, ltv } = account.value;
  const hf = Number(healthFactor) / 1e18; // WAD
  const currentLtv = totalCollateralBase > 0n ? (Number(totalDebtBase) / Number(totalCollateralBase)) * 100 : 0;
  const maxLtv = Number(ltv) / 100; // basis points -> %, the borrowing ceiling, not the position's own LTV
  console.log(position, { hf, currentLtv, maxLtv, inFlight: pending.value.isLive, needsSettle: pending.value.needsSettle });
}

const info = await sodax.leverageYield.getPositionInfo(position);
if (!info.ok) throw info.error;

// Leverage up: borrow more and have a solver turn it into collateral.
const addTx = sodax.leverageYield.buildAddLeverage({
  from: info.value.owner,
  position,
  borrowAmount: moreBorrow,
  minCollateralOut,
});
const added = await sodax.leverageYield.submitLeveragePositionIntent({
  params: { srcChainKey: ChainKeys.SONIC_MAINNET, srcAddress: userAddress, calls: [addTx] },
  walletProvider,
});
if (!added.ok) throw added.error;

const settleTx = sodax.leverageYield.buildSettlePosition({ from: info.value.owner, position });
const settled = await sodax.leverageYield.runLeveragePositionOperation({
  params: { srcChainKey: ChainKeys.SONIC_MAINNET, srcAddress: userAddress, calls: [settleTx] },
  walletProvider,
});
if (!settled.ok) throw settled.error;

import { useOpenLeveragePosition, useLeveragePositionsForUser, useLeveragePositionAccount } from '@sodax/dapp-kit';
import { ChainKeys } from '@sodax/types';

export function Positions() {
  const { data: positions } = useLeveragePositionsForUser({
    params: { spokeChainKey: ChainKeys.SONIC_MAINNET, spokeAddress: userAddress },
  });
  const { mutateAsync: openPosition, isPending } = useOpenLeveragePosition();
  // openPosition({ side: 'collateral', params: { ... }, walletProvider }) takes the same input as the SDK call
  // ...
}

export function PositionHealth({ position }: { position: `0x${string}` }) {
  const { data: account } = useLeveragePositionAccount({ params: { position } });
  const hf = account ? Number(account.healthFactor) / 1e18 : undefined;
  // ...
}