On-chain queries

import { PublicKey } from "@solana/web3.js";
import { getAccount } from "@solana/spl-token";
import {
  ata,
  borrowVaultPda,
  confirmedChainTime,
  pendingWithdrawalPda,
  type NestClient,
} from "./nest-client";

function bn(value: { toString(): string }) {
  return BigInt(value.toString());
}

async function tokenBalanceOrZero(
  client: NestClient,
  mint: PublicKey,
  owner: PublicKey,
  tokenProgram: PublicKey,
) {
  const address = ata(mint, owner, tokenProgram);
  const info = await client.connection.getAccountInfo(address, "confirmed");
  if (!info) return { address, amount: 0n };
  const account = await getAccount(
    client.connection,
    address,
    "confirmed",
    tokenProgram,
  );
  if (!account.owner.equals(owner) || !account.mint.equals(mint)) {
    throw new Error(`Unexpected token account data at ${address}`);
  }
  return { address, amount: account.amount };
}

export async function readBorrowPositions(client: NestClient, owner: PublicKey) {
  const coreProgram = new PublicKey(client.deployment.programs.nestCore);
  return Promise.all(client.deployment.collateral.map(async (market) => {
    const collateralConfig = new PublicKey(market.collateralConfig);
    const address = borrowVaultPda(coreProgram, owner, collateralConfig);
    const vault = await client.core.account.vault.fetchNullable(address);
    if (!vault) return null;

    if (
      !vault.owner.equals(owner)
      || !vault.collateralConfig.equals(collateralConfig)
    ) throw new Error(`Borrow vault identity mismatch at ${address}`);

    const principalDebtNusd6 = bn(vault.principalDebt);
    const storedFeeNusd6 = bn(vault.accruedFee);
    return {
      symbol: market.symbol,
      address,
      collateralConfig,
      collateralRaw: bn(vault.collateralRaw),
      principalDebtNusd6,
      storedFeeNusd6,
      storedDebtNusd6: principalDebtNusd6 + storedFeeNusd6,
      lastAccrualTs: bn(vault.lastAccrualTs),
    };
  })).then((positions) => positions.filter((position) => position !== null));
}

export async function readStakingPosition(client: NestClient, owner: PublicKey) {
  const stakeProgram = new PublicKey(client.deployment.programs.nestStake);
  const stakingStateAddress = new PublicKey(client.deployment.accounts.stakingState);
  const pendingAddress = pendingWithdrawalPda(
    stakeProgram,
    owner,
    stakingStateAddress,
  );
  const snusdMint = new PublicKey(client.deployment.mints.snusd);
  const snusdTokenProgram = new PublicKey(client.deployment.tokenPrograms.snusd);

  const [state, pending, snusd] = await Promise.all([
    client.stake.account.stakingState.fetch(stakingStateAddress),
    client.stake.account.pendingWithdrawalAccount.fetchNullable(pendingAddress),
    tokenBalanceOrZero(client, snusdMint, owner, snusdTokenProgram),
  ]);
  if (pending && (
    !pending.owner.equals(owner)
    || !pending.stakingState.equals(stakingStateAddress)
  )) throw new Error(`Pending withdrawal identity mismatch at ${pendingAddress}`);

  const totalShares = bn(state.totalShares);
  const redeemableNusd6 = bn(state.stakingVaultNusd) > bn(state.reservedPendingClaims)
    ? bn(state.stakingVaultNusd) - bn(state.reservedPendingClaims)
    : 0n;
  const walletValueNusd6 = totalShares === 0n
    ? 0n
    : snusd.amount * redeemableNusd6 / totalShares;

  return {
    stakingStateAddress,
    snusdAccount: snusd.address,
    walletSharesSnusd6: snusd.amount,
    estimatedWalletValueNusd6: walletValueNusd6,
    totalShares,
    redeemableNusd6,
    cooldownSeconds: bn(state.cooldownSeconds),
    pending: pending ? {
      address: pendingAddress,
      sharesSnusd6: bn(pending.shares),
      requestTs: bn(pending.requestTs),
      claimDeadlineTs: bn(pending.claimDeadlineTs),
    } : null,
  };
}

export async function readNestPortfolio(client: NestClient, owner: PublicKey) {
  const protocolAddress = new PublicKey(client.deployment.accounts.protocol);
  const nusdMint = new PublicKey(client.deployment.mints.nusd);
  const usdcMint = new PublicKey(client.deployment.mints.usdc);
  const nusdTokenProgram = new PublicKey(client.deployment.tokenPrograms.nusd);
  const usdcTokenProgram = new PublicKey(client.deployment.tokenPrograms.usdc);

  const [chainTime, protocol, borrowPositions, staking, nusd, usdc] =
    await Promise.all([
      confirmedChainTime(client.connection),
      client.core.account.protocol.fetch(protocolAddress),
      readBorrowPositions(client, owner),
      readStakingPosition(client, owner),
      tokenBalanceOrZero(client, nusdMint, owner, nusdTokenProgram),
      tokenBalanceOrZero(client, usdcMint, owner, usdcTokenProgram),
    ]);

  return {
    owner,
    chainTime,
    protocol: {
      address: protocolAddress,
      paused: protocol.paused,
      badDebtNusd6: bn(protocol.badDebtNusd),
      totalDebtNusd6: bn(protocol.totalDebt),
      stabilityFeeAprBps: bn(protocol.stabilityFeeAprBps),
      psmSwapInFeeBps: bn(protocol.psmSwapInFeeBps),
      psmSwapOutFeeBps: bn(protocol.psmSwapOutFeeBps),
    },
    balances: {
      nusd6: nusd.amount,
      snusd6: staking.walletSharesSnusd6,
      usdc6: usdc.amount,
    },
    borrowPositions,
    staking,
  };
}

export async function readCurrentMarket(client: NestClient, config: string) {
  const address = new PublicKey(config);
  const account = await client.core.account.collateralConfig.fetch(address);
  if (!account.protocol.equals(new PublicKey(client.deployment.accounts.protocol))) {
    throw new Error("Collateral config belongs to another protocol account");
  }
  return { address, account };
}