@gauntlet-xyz/sdk 1.0.5 → 2.0.0

package/src/evm/aeraContracts/priceAndFeeCalculator.ts

@@ -0,0 +1,223 @@
+import type { Address, PublicClient } from 'viem';
+import { UnsupportedFeatureError } from '../../errors';
+import { priceAndFeeCalculatorAbi } from '../abis/priceAndFeeCalculator';
+import { priceAndFeeCalculatorV2Abi } from '../abis/priceAndFeeCalculatorV2';
+import { ContractVersion } from '../types';
+
+const ROUNDING_FLOOR = 0;
+const ROUNDING_CEIL = 1;
+
+export interface NormalizedVaultPriceState {
+  paused: boolean;
+  unitPrice: bigint;
+  timestamp: number;
+}
+
+function toNumber(value: bigint | number): number {
+  return typeof value === 'bigint' ? Number(value) : value;
+}
+
+function normalizeVaultPriceState<
+  TState extends { paused: boolean } & (
+    | { unitPrice: bigint; timestamp: bigint | number }
+    | {
+        anchorPrice: bigint;
+        driftPrice: bigint;
+        anchorTimestamp: bigint | number;
+        driftTimestamp: bigint | number;
+      }
+  ),
+>(priceState: TState): TState & NormalizedVaultPriceState {
+  if ('unitPrice' in priceState) {
+    return {
+      ...priceState,
+      unitPrice: priceState.unitPrice,
+      timestamp: toNumber(priceState.timestamp),
+    } as TState & NormalizedVaultPriceState;
+  }
+
+  const anchorTimestamp = toNumber(priceState.anchorTimestamp);
+  const driftTimestamp = toNumber(priceState.driftTimestamp);
+  const useDriftPrice = driftTimestamp >= anchorTimestamp;
+
+  return {
+    ...priceState,
+    unitPrice: useDriftPrice ? priceState.driftPrice : priceState.anchorPrice,
+    timestamp: useDriftPrice ? driftTimestamp : anchorTimestamp,
+  } as TState & NormalizedVaultPriceState;
+}
+
+export async function convertTokenToUnitsIfActive(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokenAmount: bigint,
+  rounding: typeof ROUNDING_FLOOR | typeof ROUNDING_CEIL
+): Promise<bigint> {
+  if (feeCalculatorVersion === ContractVersion.V2) {
+    return client.readContract({
+      address: feeCalculator,
+      abi: priceAndFeeCalculatorV2Abi,
+      functionName: 'convertTokenToUnitsIfActive',
+      args: [vault, token, tokenAmount, rounding],
+    });
+  }
+
+  return client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorAbi,
+    functionName: 'convertTokenToUnitsIfActive',
+    args: [vault, token, tokenAmount, rounding],
+  });
+}
+
+export async function convertUnitsToTokenIfActive(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  unitsAmount: bigint,
+  rounding: typeof ROUNDING_FLOOR | typeof ROUNDING_CEIL
+): Promise<bigint> {
+  if (feeCalculatorVersion === ContractVersion.V2) {
+    return client.readContract({
+      address: feeCalculator,
+      abi: priceAndFeeCalculatorV2Abi,
+      functionName: 'convertUnitsToTokenIfActive',
+      args: [vault, token, unitsAmount, rounding],
+    });
+  }
+
+  return client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorAbi,
+    functionName: 'convertUnitsToTokenIfActive',
+    args: [vault, token, unitsAmount, rounding],
+  });
+}
+
+export async function convertTokenToUnits(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokenAmount: bigint
+): Promise<bigint> {
+  if (feeCalculatorVersion === ContractVersion.V2) {
+    return client.readContract({
+      address: feeCalculator,
+      abi: priceAndFeeCalculatorV2Abi,
+      functionName: 'convertTokenToUnits',
+      args: [vault, token, tokenAmount],
+    });
+  }
+
+  return client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorAbi,
+    functionName: 'convertTokenToUnits',
+    args: [vault, token, tokenAmount],
+  });
+}
+
+export async function convertUnitsToToken(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  unitsAmount: bigint
+): Promise<bigint> {
+  if (feeCalculatorVersion === ContractVersion.V2) {
+    return client.readContract({
+      address: feeCalculator,
+      abi: priceAndFeeCalculatorV2Abi,
+      functionName: 'convertUnitsToToken',
+      args: [vault, token, unitsAmount],
+    });
+  }
+
+  return client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorAbi,
+    functionName: 'convertUnitsToToken',
+    args: [vault, token, unitsAmount],
+  });
+}
+
+export async function getAnchorTimestamp(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address
+): Promise<number> {
+  if (feeCalculatorVersion !== ContractVersion.V2) {
+    throw new UnsupportedFeatureError('Aera: sync redeem requires V2 price and fee calculator');
+  }
+
+  return client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorV2Abi,
+    functionName: 'getAnchorTimestamp',
+    args: [vault],
+  });
+}
+
+export async function getVaultState(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address
+) {
+  if (feeCalculatorVersion === ContractVersion.V2) {
+    const [priceState, accruals] = await client.readContract({
+      address: feeCalculator,
+      abi: priceAndFeeCalculatorV2Abi,
+      functionName: 'getVaultState',
+      args: [vault],
+    });
+
+    return [normalizeVaultPriceState(priceState), accruals] as const;
+  }
+
+  const [priceState, accruals] = await client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorAbi,
+    functionName: 'getVaultState',
+    args: [vault],
+  });
+
+  return [normalizeVaultPriceState(priceState), accruals] as const;
+}
+
+export async function isVaultPaused(
+  client: PublicClient,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address
+): Promise<boolean> {
+  if (feeCalculatorVersion === ContractVersion.V2) {
+    return client.readContract({
+      address: feeCalculator,
+      abi: priceAndFeeCalculatorV2Abi,
+      functionName: 'isVaultPaused',
+      args: [vault],
+    });
+  }
+
+  return client.readContract({
+    address: feeCalculator,
+    abi: priceAndFeeCalculatorAbi,
+    functionName: 'isVaultPaused',
+    args: [vault],
+  });
+}
+
+export const Rounding = {
+  Floor: ROUNDING_FLOOR,
+  Ceil: ROUNDING_CEIL,
+} as const;

package/src/evm/aeraContracts/v1.ts

@@ -0,0 +1,157 @@
+import {
+  type Address,
+  type Client,
+  type GetContractReturnType,
+  type PublicClient,
+  getContract,
+} from 'viem';
+import { priceAndFeeCalculatorAbi } from '../abis/priceAndFeeCalculator';
+import { provisionerAbi } from '../abis/provisioner';
+import {
+  Rounding,
+  convertTokenToUnitsIfActive,
+  convertUnitsToTokenIfActive,
+} from './priceAndFeeCalculator';
+import { MAX_BPS } from '../../constants';
+import type { ContractVersion } from '../types';
+
+export type PriceAndFeeCalculatorContract<T extends Client> = GetContractReturnType<
+  typeof priceAndFeeCalculatorAbi,
+  T,
+  Address
+>;
+
+export function getPriceAndFeeCalculator<T extends Client>(
+  client: T,
+  address: Address
+): PriceAndFeeCalculatorContract<T> {
+  return getContract({
+    address,
+    abi: priceAndFeeCalculatorAbi,
+    client,
+  });
+}
+
+function getProvisioner<T extends Client>(client: T, address: Address) {
+  return getContract({
+    address,
+    abi: provisionerAbi,
+    client,
+  });
+}
+
+async function getTokenDetails(client: PublicClient, provisioner: Address, token: Address) {
+  return getProvisioner(client, provisioner).read.tokensDetails([token]);
+}
+
+export async function getAsyncDepositUnitsOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensIn: bigint
+): Promise<bigint> {
+  const tokenDetails = await getTokenDetails(client, provisioner, token);
+  const depositMultiplier = BigInt(tokenDetails[3]);
+  const adjustedTokensIn = (tokensIn * depositMultiplier) / MAX_BPS;
+
+  return convertTokenToUnitsIfActive(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    adjustedTokensIn,
+    Rounding.Floor
+  );
+}
+
+export async function getAsyncRedeemTokenOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  unitsIn: bigint
+): Promise<bigint> {
+  const tokenDetails = await getTokenDetails(client, provisioner, token);
+  const redeemMultiplier = BigInt(tokenDetails[4]);
+  const tokensOut = await convertUnitsToTokenIfActive(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    unitsIn,
+    Rounding.Floor
+  );
+
+  return (tokensOut * redeemMultiplier) / MAX_BPS;
+}
+
+export async function getAsyncWithdrawUnitsIn(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensOut: bigint
+): Promise<bigint> {
+  const tokenDetails = await getTokenDetails(client, provisioner, token);
+  const redeemMultiplier = BigInt(tokenDetails[4]);
+  const preMultiplierTokensOut = (tokensOut * MAX_BPS + redeemMultiplier - 1n) / redeemMultiplier;
+
+  return convertTokenToUnitsIfActive(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    preMultiplierTokensOut,
+    Rounding.Ceil
+  );
+}
+
+export function requestDepositTxRequest(
+  provisioner: Address,
+  token: Address,
+  tokensIn: bigint,
+  minUnitsOut: bigint,
+  solverTip: bigint,
+  deadline: bigint,
+  maxPriceAge: bigint,
+  isFixedPrice: boolean,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerAbi,
+    functionName: 'requestDeposit' as const,
+    args: [token, tokensIn, minUnitsOut, solverTip, deadline, maxPriceAge, isFixedPrice] as const,
+    account,
+  };
+}
+
+export function requestRedeemTxRequest(
+  provisioner: Address,
+  token: Address,
+  unitsIn: bigint,
+  minTokenOut: bigint,
+  solverTip: bigint,
+  deadline: bigint,
+  maxPriceAge: bigint,
+  isFixedPrice: boolean,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerAbi,
+    functionName: 'requestRedeem' as const,
+    args: [token, unitsIn, minTokenOut, solverTip, deadline, maxPriceAge, isFixedPrice] as const,
+    account,
+  };
+}