Reading Earn vault totals onchain

npm install @privy-io/node viem

import {PrivyClient} from '@privy-io/node';

const privy = new PrivyClient({
  appId: 'insert-your-app-id',
  appSecret: 'insert-your-app-secret'
});

export async function getVaultAndWallet({vaultId, walletId}: {vaultId: string; walletId: string}) {
  const [vault, wallet] = await Promise.all([
    privy.wallets().earn().ethereum().vaultDetails(vaultId),
    privy.wallets().get(walletId)
  ]);

  return {
    vaultAddress: vault.vault_address as `0x${string}`,
    caip2: vault.caip2,
    assetDecimals: vault.asset.decimals,
    walletAddress: wallet.address as `0x${string}`
  };
}

import {type Address, createPublicClient, erc4626Abi, http} from 'viem';

// Use an RPC URL for the vault's chain.
const publicClient = createPublicClient({transport: http('insert-your-rpc-url')});

export async function getPosition({
  vaultAddress,
  walletAddress,
  blockNumber
}: {
  vaultAddress: Address;
  walletAddress: Address;
  blockNumber?: bigint;
}) {
  const sharesInVault = await publicClient.readContract({
    address: vaultAddress,
    abi: erc4626Abi,
    functionName: 'balanceOf',
    args: [walletAddress],
    blockNumber
  });

  const assetsInVault =
    sharesInVault > 0n
      ? await publicClient.readContract({
          address: vaultAddress,
          abi: erc4626Abi,
          functionName: 'convertToAssets',
          args: [sharesInVault],
          blockNumber
        })
      : 0n;

  return {sharesInVault, assetsInVault};
}

import {type Address, createPublicClient, erc4626Abi, http} from 'viem';

// Use an RPC URL for the vault's chain.
const publicClient = createPublicClient({transport: http('insert-your-rpc-url')});

// Set this to the `eth_getLogs` block range limit of your RPC provider.
const MAX_BLOCK_RANGE = 10_000n;

export async function getEarnTotals({
  vaultAddress,
  walletAddress,
  fromBlock,
  toBlock
}: {
  vaultAddress: Address;
  walletAddress: Address;
  fromBlock: bigint;
  toBlock: bigint;
}) {
  let totalDeposited = 0n;
  let totalWithdrawn = 0n;

  for (let start = fromBlock; start <= toBlock; start += MAX_BLOCK_RANGE) {
    const end = start + MAX_BLOCK_RANGE - 1n < toBlock ? start + MAX_BLOCK_RANGE - 1n : toBlock;

    const [deposits, withdrawals] = await Promise.all([
      publicClient.getContractEvents({
        address: vaultAddress,
        abi: erc4626Abi,
        eventName: 'Deposit',
        args: {receiver: walletAddress},
        fromBlock: start,
        toBlock: end
      }),
      publicClient.getContractEvents({
        address: vaultAddress,
        abi: erc4626Abi,
        eventName: 'Withdraw',
        args: {owner: walletAddress},
        fromBlock: start,
        toBlock: end
      })
    ]);

    for (const log of deposits) {
      totalDeposited += log.args.assets ?? 0n;
    }
    for (const log of withdrawals) {
      totalWithdrawn += log.args.assets ?? 0n;
    }
  }

  return {totalDeposited, totalWithdrawn};
}

type EarnTotalsCheckpoint = {
  totalDeposited: bigint;
  totalWithdrawn: bigint;
  lastScannedBlock: bigint;
};

// Number of block confirmations to wait before counting events. The most recent blocks stay
// unscanned, so that a chain reorganization is unlikely to change counted events.
// This value is an approximation. Some chains, such as Base, have no fixed number of blocks
// after which a block is final. Increase this value for a stronger guarantee.
const CONFIRMATIONS = 12n;

export async function syncEarnTotals({
  vaultAddress,
  walletAddress,
  checkpoint
}: {
  vaultAddress: Address;
  walletAddress: Address;
  checkpoint: EarnTotalsCheckpoint;
}): Promise<EarnTotalsCheckpoint> {
  const toBlock = (await publicClient.getBlockNumber()) - CONFIRMATIONS;
  if (toBlock <= checkpoint.lastScannedBlock) {
    return checkpoint;
  }

  const newTotals = await getEarnTotals({
    vaultAddress,
    walletAddress,
    fromBlock: checkpoint.lastScannedBlock + 1n,
    toBlock
  });

  return {
    totalDeposited: checkpoint.totalDeposited + newTotals.totalDeposited,
    totalWithdrawn: checkpoint.totalWithdrawn + newTotals.totalWithdrawn,
    lastScannedBlock: toBlock
  };
}

const initialCheckpoint: EarnTotalsCheckpoint = {
  totalDeposited: 0n,
  totalWithdrawn: 0n,
  lastScannedBlock: vaultDeploymentBlock - 1n
};

const checkpoint = await syncEarnTotals({
  vaultAddress,
  walletAddress,
  checkpoint: storedCheckpoint
});

const {assetsInVault} = await getPosition({
  vaultAddress,
  walletAddress,
  blockNumber: checkpoint.lastScannedBlock
});

const earnedYield = assetsInVault - (checkpoint.totalDeposited - checkpoint.totalWithdrawn);