@gauntlet-xyz/sdk 1.0.5 → 2.0.0

package/src/evm/aeraContracts/v2.ts

@@ -0,0 +1,466 @@
+import {
+  type Address,
+  type Client,
+  type GetContractReturnType,
+  type PublicClient,
+  getContract,
+} from 'viem';
+import { priceAndFeeCalculatorV2Abi } from '../abis/priceAndFeeCalculatorV2';
+import { provisionerV2Abi } from '../abis/provisionerV2';
+import {
+  Rounding,
+  convertTokenToUnitsIfActive,
+  convertUnitsToTokenIfActive,
+} from './priceAndFeeCalculator';
+import { MAX_BPS } from '../../constants';
+import { StalePriceError } from '../../errors';
+import type { ContractVersion } from '../types';
+
+export type PriceAndFeeCalculatorContract<T extends Client> = GetContractReturnType<
+  typeof priceAndFeeCalculatorV2Abi,
+  T,
+  Address
+>;
+
+export function getPriceAndFeeCalculator<T extends Client>(
+  client: T,
+  address: Address
+): PriceAndFeeCalculatorContract<T> {
+  return getContract({
+    address,
+    abi: priceAndFeeCalculatorV2Abi,
+    client,
+  });
+}
+
+function getProvisioner<T extends Client>(client: T, address: Address) {
+  return getContract({
+    address,
+    abi: provisionerV2Abi,
+    client,
+  });
+}
+
+async function getTokenDetails(client: PublicClient, provisioner: Address, token: Address) {
+  return getProvisioner(client, provisioner).read.tokensDetails([token]);
+}
+
+async function getDepositUnitsOut({
+  client,
+  provisioner,
+  feeCalculator,
+  feeCalculatorVersion,
+  vault,
+  token,
+  tokensIn,
+  multiplierIndex,
+}: {
+  client: PublicClient;
+  provisioner: Address;
+  feeCalculator: Address;
+  feeCalculatorVersion: ContractVersion;
+  vault: Address;
+  token: Address;
+  tokensIn: bigint;
+  multiplierIndex: 4 | 6;
+}): Promise<bigint> {
+  const tokenDetails = await getTokenDetails(client, provisioner, token);
+  const multiplier = BigInt(tokenDetails[multiplierIndex]);
+  const adjustedTokensIn = (tokensIn * multiplier) / MAX_BPS;
+
+  return convertTokenToUnitsIfActive(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    adjustedTokensIn,
+    Rounding.Floor
+  );
+}
+
+async function getRedeemTokenOut({
+  client,
+  provisioner,
+  feeCalculator,
+  feeCalculatorVersion,
+  vault,
+  token,
+  unitsIn,
+  multiplierIndex,
+}: {
+  client: PublicClient;
+  provisioner: Address;
+  feeCalculator: Address;
+  feeCalculatorVersion: ContractVersion;
+  vault: Address;
+  token: Address;
+  unitsIn: bigint;
+  multiplierIndex: 5 | 7;
+}): Promise<bigint> {
+  const [tokenDetails, tokensOut] = await Promise.all([
+    getTokenDetails(client, provisioner, token),
+    convertUnitsToTokenIfActive(
+      client,
+      feeCalculator,
+      feeCalculatorVersion,
+      vault,
+      token,
+      unitsIn,
+      Rounding.Floor
+    ),
+  ]);
+  const multiplier = BigInt(tokenDetails[multiplierIndex]);
+
+  return (tokensOut * multiplier) / MAX_BPS;
+}
+
+async function getWithdrawUnitsIn({
+  client,
+  provisioner,
+  feeCalculator,
+  feeCalculatorVersion,
+  vault,
+  token,
+  tokensOut,
+  multiplierIndex,
+}: {
+  client: PublicClient;
+  provisioner: Address;
+  feeCalculator: Address;
+  feeCalculatorVersion: ContractVersion;
+  vault: Address;
+  token: Address;
+  tokensOut: bigint;
+  multiplierIndex: 5 | 7;
+}): Promise<bigint> {
+  const tokenDetails = await getTokenDetails(client, provisioner, token);
+  const multiplier = BigInt(tokenDetails[multiplierIndex]);
+  const preMultiplierTokens = (tokensOut * MAX_BPS + multiplier - 1n) / multiplier;
+
+  return convertTokenToUnitsIfActive(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    preMultiplierTokens,
+    Rounding.Ceil
+  );
+}
+
+async function getSyncRedeemMultiplier(
+  client: PublicClient,
+  provisioner: Address,
+  vault: Address,
+  token: Address,
+  feeCalculator: Address
+): Promise<bigint> {
+  const [tokenDetails, syncRedeemDetails, anchorTimestamp] = await client.multicall({
+    contracts: [
+      {
+        address: provisioner,
+        abi: provisionerV2Abi,
+        functionName: 'tokensDetails',
+        args: [token],
+      },
+      {
+        address: provisioner,
+        abi: provisionerV2Abi,
+        functionName: 'getSyncRedeemDetails',
+      },
+      {
+        address: feeCalculator,
+        abi: priceAndFeeCalculatorV2Abi,
+        functionName: 'getAnchorTimestamp',
+        args: [vault],
+      },
+    ],
+    allowFailure: false,
+  });
+  const block = await client.getBlock();
+  const syncRedeemMultiplier = BigInt(tokenDetails[7]);
+  const maxPriceAge = BigInt(syncRedeemDetails[0]);
+  const maxDynamicPremiumBps = BigInt(syncRedeemDetails[2]);
+  const blockTimestamp = BigInt(block.timestamp);
+  const priceTimestamp = BigInt(anchorTimestamp);
+
+  if (priceTimestamp + maxPriceAge < blockTimestamp) {
+    throw new StalePriceError({
+      blockTimestamp,
+      maxPriceAge,
+      priceTimestamp,
+    });
+  }
+
+  const dynamicPremiumBps =
+    maxDynamicPremiumBps === 0n || maxPriceAge === 0n
+      ? 0n
+      : ((blockTimestamp - priceTimestamp) * maxDynamicPremiumBps + maxPriceAge - 1n) / maxPriceAge;
+
+  return syncRedeemMultiplier - dynamicPremiumBps;
+}
+
+export async function getSyncRedeemTokenOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  unitsIn: bigint
+): Promise<bigint> {
+  const [tokenAmount, multiplier] = await Promise.all([
+    convertUnitsToTokenIfActive(
+      client,
+      feeCalculator,
+      feeCalculatorVersion,
+      vault,
+      token,
+      unitsIn,
+      Rounding.Floor
+    ),
+    getSyncRedeemMultiplier(client, provisioner, vault, token, feeCalculator),
+  ]);
+
+  return (tokenAmount * multiplier) / MAX_BPS;
+}
+
+export async function getAsyncDepositUnitsOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensIn: bigint
+): Promise<bigint> {
+  return getDepositUnitsOut({
+    client,
+    provisioner,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    tokensIn,
+    multiplierIndex: 4,
+  });
+}
+
+export async function getSyncDepositUnitsOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensIn: bigint
+): Promise<bigint> {
+  return getDepositUnitsOut({
+    client,
+    provisioner,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    tokensIn,
+    multiplierIndex: 6,
+  });
+}
+
+export async function getAsyncRedeemTokenOut(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  unitsIn: bigint
+): Promise<bigint> {
+  return getRedeemTokenOut({
+    client,
+    provisioner,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    unitsIn,
+    multiplierIndex: 5,
+  });
+}
+
+export async function getAsyncWithdrawUnitsIn(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensOut: bigint
+): Promise<bigint> {
+  return getWithdrawUnitsIn({
+    client,
+    provisioner,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    tokensOut,
+    multiplierIndex: 5,
+  });
+}
+
+export async function getSyncWithdrawUnitsIn(
+  client: PublicClient,
+  provisioner: Address,
+  feeCalculator: Address,
+  feeCalculatorVersion: ContractVersion,
+  vault: Address,
+  token: Address,
+  tokensOut: bigint
+): Promise<bigint> {
+  const multiplier = await getSyncRedeemMultiplier(
+    client,
+    provisioner,
+    vault,
+    token,
+    feeCalculator
+  );
+  const prePremiumTokens = (tokensOut * MAX_BPS + multiplier - 1n) / multiplier;
+
+  return convertTokenToUnitsIfActive(
+    client,
+    feeCalculator,
+    feeCalculatorVersion,
+    vault,
+    token,
+    prePremiumTokens,
+    Rounding.Ceil
+  );
+}
+
+export function depositTxRequest(
+  provisioner: Address,
+  token: Address,
+  tokensIn: bigint,
+  minUnitsOut: bigint,
+  receiver: Address,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerV2Abi,
+    functionName: 'deposit' as const,
+    args: [token, tokensIn, minUnitsOut, receiver] as const,
+    account,
+  };
+}
+
+export function requestDepositTxRequest(
+  provisioner: Address,
+  token: Address,
+  tokensIn: bigint,
+  minUnitsOut: bigint,
+  solverTip: bigint,
+  deadline: bigint,
+  maxPriceAge: bigint,
+  isFixedPrice: boolean,
+  receiver: Address,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerV2Abi,
+    functionName: 'requestDeposit' as const,
+    args: [
+      token,
+      tokensIn,
+      minUnitsOut,
+      solverTip,
+      deadline,
+      maxPriceAge,
+      isFixedPrice,
+      receiver,
+    ] as const,
+    account,
+  };
+}
+
+export function setDepositReceiverApprovalTxRequest(
+  provisioner: Address,
+  depositor: Address,
+  approved: boolean,
+  receiver: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerV2Abi,
+    functionName: 'setDepositReceiverApproval' as const,
+    args: [depositor, approved] as const,
+    account: receiver,
+  };
+}
+
+export function requestRedeemTxRequest(
+  provisioner: Address,
+  token: Address,
+  unitsIn: bigint,
+  minTokenOut: bigint,
+  solverTip: bigint,
+  deadline: bigint,
+  maxPriceAge: bigint,
+  isFixedPrice: boolean,
+  receiver: Address,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerV2Abi,
+    functionName: 'requestRedeem' as const,
+    args: [
+      token,
+      unitsIn,
+      minTokenOut,
+      solverTip,
+      deadline,
+      maxPriceAge,
+      isFixedPrice,
+      receiver,
+    ] as const,
+    account,
+  };
+}
+
+export function redeemTxRequest(
+  provisioner: Address,
+  token: Address,
+  unitsIn: bigint,
+  minTokenOut: bigint,
+  receiver: Address,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerV2Abi,
+    functionName: 'redeem' as const,
+    args: [token, unitsIn, minTokenOut, receiver] as const,
+    account,
+  };
+}
+
+export function withdrawTxRequest(
+  provisioner: Address,
+  token: Address,
+  tokensOut: bigint,
+  maxUnitsIn: bigint,
+  receiver: Address,
+  account: Address
+) {
+  return {
+    address: provisioner,
+    abi: provisionerV2Abi,
+    functionName: 'withdraw' as const,
+    args: [token, tokensOut, maxUnitsIn, receiver] as const,
+    account,
+  };
+}

package/src/evm/aeraContracts.ts

@@ -1,11 +1,82 @@
-/**
- *  CODE PULLED FROM AERA-V3-TS-SDK in gauntlet/apps/packages/aera-v3-ts-sdk
- *  pulled in here with the goal to have this SDK replace the previous
- */
-import { type Address, type Client, type GetContractReturnType, getContract } from 'viem';
+import {
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  type Address,
+  type Client,
+  type GetContractReturnType,
+  type PublicClient,
+  getContract,
+  zeroAddress,
+} from 'viem';
+import { UnimplementedFeatureError, UnsupportedFeatureError } from '../errors';
 import { multiDepositorVaultAbi } from './abis/multiDepositorVault';
-import { priceAndFeeCalculatorAbi } from './abis/priceAndFeeCalculator';
 import { provisionerAbi } from './abis/provisioner';
+import { provisionerV2Abi } from './abis/provisionerV2';
+import { MAX_BPS } from '../constants';
+import { ContractVersion, type EvmVaultDeployment } from './types';
+
+const contractVersionCache = new Map<string, ContractVersion>();
+
+const contractVersionAbi = [
+  {
+    type: 'function',
+    inputs: [],
+    name: 'version',
+    outputs: [{ name: '', internalType: 'string', type: 'string' }],
+    stateMutability: 'view',
+  },
+] as const;
+
+export interface AeraRuntimeContracts {
+  provisioner: {
+    address: Address;
+    version: ContractVersion;
+  };
+  feeCalculator: {
+    address: Address;
+    version: ContractVersion;
+  };
+}
+
+export interface AeraTokenModeSupport {
+  asyncDeposit: boolean;
+  asyncRedeem: boolean;
+  syncDeposit: boolean;
+  syncRedeem: boolean;
+}
+
+export function applySlippageDown(amount: bigint, slippageBps: number): bigint {
+  return (amount * (MAX_BPS - BigInt(slippageBps))) / MAX_BPS;
+}
+
+export function applySlippageUp(amount: bigint, slippageBps: number): bigint {
+  return (amount * (MAX_BPS + BigInt(slippageBps)) + MAX_BPS - 1n) / MAX_BPS;
+}
+
+function contractVersionCacheKey(client: PublicClient, address: Address): string {
+  return `${client.chain?.id ?? 'unknown'}:${address.toLowerCase()}`;
+}
+
+function isVersionUnavailableError(error: unknown): boolean {
+  if (!(error instanceof ContractFunctionExecutionError) || error.functionName !== 'version') {
+    return false;
+  }
+
+  if (error.cause instanceof ContractFunctionRevertedError) {
+    const hasDecodedError =
+      error.cause.signature !== undefined ||
+      error.cause.data !== undefined ||
+      (error.cause.raw !== undefined && error.cause.raw !== '0x');
+
+    return (
+      !hasDecodedError &&
+      (error.cause.reason === undefined || error.cause.reason === 'execution reverted')
+    );
+  }
+
+  return error.cause instanceof ContractFunctionZeroDataError;
+}
 
 export type MultiDepositorVaultContract<T extends Client> = GetContractReturnType<
   typeof multiDepositorVaultAbi,
@@ -24,59 +95,109 @@ export function getMultiDepositorVault<T extends Client>(
   });
 }
 
-export type PriceAndFeeCalculatorContract<T extends Client> = GetContractReturnType<
-  typeof priceAndFeeCalculatorAbi,
-  T,
-  Address
->;
-
-export function getPriceAndFeeCalculator<T extends Client>(
-  client: T,
+export async function resolveContractVersion(
+  client: PublicClient,
   address: Address
-): PriceAndFeeCalculatorContract<T> {
-  return getContract({
-    address,
-    abi: priceAndFeeCalculatorAbi,
-    client,
-  });
+): Promise<ContractVersion> {
+  const cacheKey = contractVersionCacheKey(client, address);
+  const cached = contractVersionCache.get(cacheKey);
+  if (cached) return cached;
+
+  try {
+    const versionString = await client.readContract({
+      address,
+      abi: contractVersionAbi,
+      functionName: 'version',
+    });
+    const version = versionString.startsWith('2.') ? ContractVersion.V2 : ContractVersion.V1;
+    contractVersionCache.set(cacheKey, version);
+
+    return version;
+  } catch (error) {
+    if (!isVersionUnavailableError(error)) throw error;
+
+    contractVersionCache.set(cacheKey, ContractVersion.V1);
+    return ContractVersion.V1;
+  }
 }
 
-export function requestDepositTxRequest(
-  provisioner: Address,
-  token: Address,
-  tokensIn: bigint,
-  minUnitsOut: bigint,
-  solverTip: bigint,
-  deadline: bigint,
-  maxPriceAge: bigint,
-  isFixedPrice: boolean,
-  account: Address
-) {
+export async function resolveAeraRuntimeContracts(
+  client: PublicClient,
+  vault: EvmVaultDeployment
+): Promise<AeraRuntimeContracts> {
+  if (vault.vaultType !== 'multi-depositor') {
+    throw new UnimplementedFeatureError('Aera: single depositor vaults');
+  }
+
+  const [provisionerAddress, feeCalculatorAddress] = await Promise.all([
+    client.readContract({
+      address: vault.vaultAddress,
+      abi: multiDepositorVaultAbi,
+      functionName: 'provisioner',
+    }),
+    client.readContract({
+      address: vault.vaultAddress,
+      abi: multiDepositorVaultAbi,
+      functionName: 'feeCalculator',
+    }),
+  ]);
+
+  if (provisionerAddress === zeroAddress) {
+    throw new UnsupportedFeatureError('Aera: vault without provisioner');
+  }
+  if (feeCalculatorAddress === zeroAddress) {
+    throw new UnsupportedFeatureError('Aera: vault without price and fee calculator');
+  }
+
+  const [provisionerVersion, feeCalculatorVersion] = await Promise.all([
+    resolveContractVersion(client, provisionerAddress),
+    resolveContractVersion(client, feeCalculatorAddress),
+  ]);
+
   return {
-    address: provisioner,
-    abi: provisionerAbi,
-    functionName: 'requestDeposit' as const,
-    args: [token, tokensIn, minUnitsOut, solverTip, deadline, maxPriceAge, isFixedPrice] as const,
-    account,
+    provisioner: {
+      address: provisionerAddress,
+      version: provisionerVersion,
+    },
+    feeCalculator: {
+      address: feeCalculatorAddress,
+      version: feeCalculatorVersion,
+    },
   };
 }
 
-export function requestRedeemTxRequest(
-  provisioner: Address,
-  token: Address,
-  unitsIn: bigint,
-  minTokenOut: bigint,
-  solverTip: bigint,
-  deadline: bigint,
-  maxPriceAge: bigint,
-  isFixedPrice: boolean,
-  account: Address
-) {
-  return {
-    address: provisioner,
+export async function resolveAeraTokenModeSupport(
+  client: PublicClient,
+  runtime: AeraRuntimeContracts,
+  token: Address
+): Promise<AeraTokenModeSupport> {
+  if (runtime.provisioner.version === ContractVersion.V2) {
+    const tokenDetails = await client.readContract({
+      address: runtime.provisioner.address,
+      abi: provisionerV2Abi,
+      functionName: 'tokensDetails',
+      args: [token],
+    });
+
+    return {
+      asyncDeposit: Boolean(tokenDetails[0]),
+      asyncRedeem: Boolean(tokenDetails[1]),
+      syncDeposit: Boolean(tokenDetails[2]),
+      syncRedeem: Boolean(tokenDetails[3]),
+    };
+  }
+
+  const tokenDetails = await client.readContract({
+    address: runtime.provisioner.address,
     abi: provisionerAbi,
-    functionName: 'requestRedeem' as const,
-    args: [token, unitsIn, minTokenOut, solverTip, deadline, maxPriceAge, isFixedPrice] as const,
-    account,
+    functionName: 'tokensDetails',
+    args: [token],
+  });
+
+  return {
+    asyncDeposit: Boolean(tokenDetails[0]),
+    asyncRedeem: Boolean(tokenDetails[1]),
+    syncDeposit: false,
+    syncRedeem: false,
   };
 }