@gauntlet-xyz/sdk 1.0.5 → 2.0.0

package/src/evm/adapters/aera.ts

@@ -1,14 +1,18 @@
 import { erc20Abi } from '../abis/erc20';
 import {
-  requestDepositTxRequest,
-  requestRedeemTxRequest,
   getMultiDepositorVault,
-  getPriceAndFeeCalculator,
+  applySlippageDown,
+  applySlippageUp,
+  resolveContractVersion,
+  type AeraRuntimeContracts,
 } from '../aeraContracts';
+import { convertTokenToUnits, convertUnitsToToken } from '../aeraContracts/priceAndFeeCalculator';
+import * as provisionerV1 from '../aeraContracts/v1';
+import * as provisionerV2 from '../aeraContracts/v2';
 import {
   InvalidWithdrawParamsError,
+  InvalidSolverTipError,
   UnimplementedFeatureError,
-  UnitConversionError,
   UnsupportedFeatureError,
 } from '../../errors';
 import type {
@@ -19,42 +23,45 @@ import type {
   AllowanceParams,
   ApprovalParams,
 } from './types';
-import { PublicClient, type Address } from 'viem';
+import type { Address, PublicClient } from 'viem';
 import { multiDepositorVaultAbi } from '../abis/multiDepositorVault';
-
-const SECOND = 1;
-const MINUTE = SECOND * 60;
-const HOUR = MINUTE * 60;
-const DAY = HOUR * 24;
-
-export const getAeraV3VaultUnits = async (
+import {
+  DEFAULT_BPS,
+  DAY,
+  DEFAULT_MAX_PRICE_AGE,
+  DEFAULT_REQUEST_DEADLINE_BUFFER,
+  DEFAULT_SOLVER_TIP,
+} from '../../constants';
+import { ContractVersion } from '../types';
+
+export const convertTokenAmountToUnits = async (
   publicClient: PublicClient,
-  tokenUnits: bigint,
+  tokenAmount: bigint,
   vaultAddress: Address,
   tokenAddress: Address
 ) => {
   const vaultContract = getMultiDepositorVault(publicClient, vaultAddress);
-
   if (vaultContract === undefined) return;
 
   const calculatorAddress = await vaultContract.read.feeCalculator();
-
   if (!calculatorAddress) return;
+  const calculatorVersion = await resolveContractVersion(publicClient, calculatorAddress);
 
-  const calculatorContract = getPriceAndFeeCalculator(publicClient, calculatorAddress);
-
-  const vaultUnits = await calculatorContract.read.convertTokenToUnits([
+  const unitsAmount = await convertTokenToUnits(
+    publicClient,
+    calculatorAddress,
+    calculatorVersion,
     vaultAddress,
     tokenAddress,
-    tokenUnits,
-  ]);
+    tokenAmount
+  );
 
-  return vaultUnits;
+  return unitsAmount;
 };
 
-export const getAeraV3TokenUnits = async (
+export const convertUnitsToTokenAmount = async (
   publicClient: PublicClient,
-  vaultUnits: bigint,
+  unitsAmount: bigint,
   vaultAddress: Address,
   tokenAddress: Address
 ) => {
@@ -63,59 +70,227 @@ export const getAeraV3TokenUnits = async (
 
   const calculatorAddress = await vaultContract.read.feeCalculator();
   if (!calculatorAddress) return;
+  const calculatorVersion = await resolveContractVersion(publicClient, calculatorAddress);
 
-  const calculatorContract = getPriceAndFeeCalculator(publicClient, calculatorAddress);
-
-  return calculatorContract.read.convertUnitsToToken([vaultAddress, tokenAddress, vaultUnits]);
+  return convertUnitsToToken(
+    publicClient,
+    calculatorAddress,
+    calculatorVersion,
+    vaultAddress,
+    tokenAddress,
+    unitsAmount
+  );
 };
 
+function subtractSolverTip(tokenAmount: bigint, solverTip: bigint): bigint {
+  if (solverTip === 0n) return tokenAmount;
+  if (solverTip >= tokenAmount) {
+    throw new InvalidSolverTipError(solverTip, tokenAmount);
+  }
+
+  return tokenAmount - solverTip;
+}
+
+function getRequestDeadline(expirationDays?: number): bigint {
+  const deadlineBuffer =
+    expirationDays === undefined ? DEFAULT_REQUEST_DEADLINE_BUFFER : DAY * expirationDays;
+  return BigInt(Math.ceil(new Date().getTime() / 1000) + deadlineBuffer);
+}
+
+async function getDepositUnitsOut({
+  publicClient,
+  runtime,
+  vault,
+  token,
+  tokensIn,
+  isAsync,
+}: {
+  publicClient: PublicClient;
+  runtime: AeraRuntimeContracts;
+  vault: Address;
+  token: Address;
+  tokensIn: bigint;
+  isAsync: boolean;
+}): Promise<bigint> {
+  if (runtime.provisioner.version === ContractVersion.V2) {
+    return isAsync
+      ? provisionerV2.getAsyncDepositUnitsOut(
+          publicClient,
+          runtime.provisioner.address,
+          runtime.feeCalculator.address,
+          runtime.feeCalculator.version,
+          vault,
+          token,
+          tokensIn
+        )
+      : provisionerV2.getSyncDepositUnitsOut(
+          publicClient,
+          runtime.provisioner.address,
+          runtime.feeCalculator.address,
+          runtime.feeCalculator.version,
+          vault,
+          token,
+          tokensIn
+        );
+  }
+
+  return provisionerV1.getAsyncDepositUnitsOut(
+    publicClient,
+    runtime.provisioner.address,
+    runtime.feeCalculator.address,
+    runtime.feeCalculator.version,
+    vault,
+    token,
+    tokensIn
+  );
+}
+
+function getAsyncRedeemTokenOut(
+  publicClient: PublicClient,
+  runtime: AeraRuntimeContracts,
+  vault: Address,
+  token: Address,
+  unitsIn: bigint
+): Promise<bigint> {
+  return runtime.provisioner.version === ContractVersion.V2
+    ? provisionerV2.getAsyncRedeemTokenOut(
+        publicClient,
+        runtime.provisioner.address,
+        runtime.feeCalculator.address,
+        runtime.feeCalculator.version,
+        vault,
+        token,
+        unitsIn
+      )
+    : provisionerV1.getAsyncRedeemTokenOut(
+        publicClient,
+        runtime.provisioner.address,
+        runtime.feeCalculator.address,
+        runtime.feeCalculator.version,
+        vault,
+        token,
+        unitsIn
+      );
+}
+
+function getAsyncWithdrawUnitsIn(
+  publicClient: PublicClient,
+  runtime: AeraRuntimeContracts,
+  vault: Address,
+  token: Address,
+  tokensOut: bigint
+): Promise<bigint> {
+  return runtime.provisioner.version === ContractVersion.V2
+    ? provisionerV2.getAsyncWithdrawUnitsIn(
+        publicClient,
+        runtime.provisioner.address,
+        runtime.feeCalculator.address,
+        runtime.feeCalculator.version,
+        vault,
+        token,
+        tokensOut
+      )
+    : provisionerV1.getAsyncWithdrawUnitsIn(
+        publicClient,
+        runtime.provisioner.address,
+        runtime.feeCalculator.address,
+        runtime.feeCalculator.version,
+        vault,
+        token,
+        tokensOut
+      );
+}
+
+function requireAeraRuntime(runtime: AeraRuntimeContracts | undefined): AeraRuntimeContracts {
+  if (!runtime) {
+    throw new UnsupportedFeatureError('Aera: runtime contracts were not resolved');
+  }
+
+  return runtime;
+}
+
 export const aeraAdapter: EvmProtocolAdapter = {
   async buildDeposit(params: AdapterDepositParams): Promise<EvmTxStep[]> {
-    const { vault, receiver, amount, account, publicClient, asset, async: isAsync, slippageBps = 100 } = params;
-
-    if (receiver !== account) {
-      throw new UnsupportedFeatureError('Aera: separate receiver address');
+    const {
+      vault,
+      receiver,
+      amount,
+      account,
+      publicClient,
+      asset,
+      async: isAsync,
+      slippageBps = DEFAULT_BPS,
+      solverTip = DEFAULT_SOLVER_TIP,
+      maxPriceAge = DEFAULT_MAX_PRICE_AGE,
+      aeraRuntime,
+    } = params;
+
+    const runtime = requireAeraRuntime(aeraRuntime);
+    const provisionerAddress = runtime.provisioner.address;
+    const isContractV2 = runtime.provisioner.version === ContractVersion.V2;
+    if (receiver !== account && !isContractV2) {
+      throw new UnsupportedFeatureError('Aera: separate receiver address on V1');
     }
 
-    if (!vault.provisionerAddress) {
-      // Not implemented because untested and clients won't need in V1
-      throw new UnimplementedFeatureError('Aera: single depositor vaults');
-      // single-depositor vault
-      /*return [
-        {
-          type: 'deposit',
-          // SDK only supports single asset deposit
-          ...depositTxRequest(vault.vaultAddress, [{ asset: asset.address, amount }], account),
-        },
-      ];*/
+    if (!isAsync && !isContractV2) {
+      throw new UnsupportedFeatureError('Aera: sync operations on V1');
     }
 
-    if (isAsync) {
-      const vaultUnits = await getAeraV3VaultUnits(
-        publicClient,
-        amount,
-        vault.vaultAddress,
-        asset.address
-      );
+    const tokensInForUnits = isAsync ? subtractSolverTip(amount, solverTip) : amount;
+    const vaultUnits = await getDepositUnitsOut({
+      publicClient,
+      runtime,
+      vault: vault.vaultAddress,
+      token: asset.address,
+      tokensIn: tokensInForUnits,
+      isAsync,
+    });
 
-      if (vaultUnits === undefined) {
-        throw new UnitConversionError(vault.vaultAddress);
-      }
+    const minUnitsOut = applySlippageDown(vaultUnits, slippageBps);
 
-      const deadline = BigInt(Math.ceil(new Date().getTime() / 1000) + DAY * 3);
-      // Request deposit
+    if (isAsync) {
+      const deadline = getRequestDeadline(vault.expirationDays);
       return [
         {
           type: 'requestDeposit',
-          ...requestDepositTxRequest(
-            vault.provisionerAddress,
+          ...(isContractV2
+            ? provisionerV2.requestDepositTxRequest(
+                provisionerAddress,
+                asset.address,
+                amount,
+                minUnitsOut,
+                solverTip,
+                deadline,
+                maxPriceAge,
+                false,
+                receiver,
+                account
+              )
+            : provisionerV1.requestDepositTxRequest(
+                provisionerAddress,
+                asset.address,
+                amount,
+                minUnitsOut,
+                solverTip,
+                deadline,
+                maxPriceAge,
+                false,
+                account
+              )),
+        },
+      ];
+    }
+
+    if (isContractV2) {
+      return [
+        {
+          type: 'deposit',
+          ...provisionerV2.depositTxRequest(
+            provisionerAddress,
             asset.address,
             amount,
-            (vaultUnits * BigInt(10000 - slippageBps)) / 10000n, // minUnitsOut
-            0n, // solvertip
-            deadline,
-            BigInt(DAY * 10),
-            false,
+            minUnitsOut,
+            receiver,
             account
           ),
         },
@@ -126,107 +301,214 @@ export const aeraAdapter: EvmProtocolAdapter = {
   },
 
   async buildWithdraw(params: AdapterWithdrawParams): Promise<EvmTxStep[]> {
-    const { vault, receiver, account, asset, publicClient, async: isAsync, slippageBps = 100 } = params;
-
-    if (receiver !== account) {
-      throw new UnsupportedFeatureError('Aera: separate receiver address');
+    const {
+      vault,
+      receiver,
+      account,
+      asset,
+      publicClient,
+      async: isAsync,
+      slippageBps = DEFAULT_BPS,
+      solverTip = DEFAULT_SOLVER_TIP,
+      maxPriceAge = DEFAULT_MAX_PRICE_AGE,
+      aeraRuntime,
+    } = params;
+
+    const runtime = requireAeraRuntime(aeraRuntime);
+    const provisionerAddress = runtime.provisioner.address;
+    const isContractV2 = runtime.provisioner.version === ContractVersion.V2;
+    if (receiver !== account && !isContractV2) {
+      throw new UnsupportedFeatureError('Aera: separate receiver address on V1');
     }
 
-    let shares: bigint;
-    let amount: bigint | undefined;
+    if (!isAsync && !isContractV2) {
+      throw new UnsupportedFeatureError('Aera: sync operations on V1');
+    }
 
-    if ('entireAmount' in params && params.entireAmount) {
-      shares = await publicClient.readContract({
-        address: vault.vaultAddress,
-        abi: multiDepositorVaultAbi,
-        functionName: 'balanceOf',
-        args: [account],
-      });
-      amount = await getAeraV3TokenUnits(publicClient, shares, vault.vaultAddress, asset.address);
-    } else if ('amount' in params && params.amount != null) {
-      const tempShares = await getAeraV3VaultUnits(
-        publicClient,
-        params.amount,
-        vault.vaultAddress,
-        asset.address
-      );
-      amount = params.amount;
-      if (tempShares === undefined) {
-        throw new UnitConversionError(vault.vaultAddress);
+    const isV2ExactTokenWithdraw =
+      isContractV2 && !isAsync && 'amount' in params && params.amount != null;
+    let minTokenOut: bigint;
+    let maxUnitsIn: bigint;
+    let shares: bigint | undefined;
+
+    if (isContractV2 && !isAsync) {
+      if ('entireAmount' in params && params.entireAmount) {
+        shares = await publicClient.readContract({
+          address: vault.vaultAddress,
+          abi: multiDepositorVaultAbi,
+          functionName: 'balanceOf',
+          args: [account],
+        });
+      } else if ('shares' in params && params.shares != null) {
+        shares = params.shares;
+      } else if (!('amount' in params && params.amount != null)) {
+        throw new InvalidWithdrawParamsError();
       }
-      shares = tempShares;
-    } else if ('shares' in params && params.shares != null) {
-      shares = params.shares;
-      amount = await getAeraV3TokenUnits(publicClient, shares, vault.vaultAddress, asset.address);
-    } else {
-      throw new InvalidWithdrawParamsError();
-    }
 
-    if (!vault.provisionerAddress) {
-      // Not implemented because untested and clients won't need in V1
-      throw new UnimplementedFeatureError('Aera: single depositor vaults');
-      //single-depositer vault
-      // TODO shares or amount ??
-      /*return [
-        {
-          type: 'withdraw',
-          // SDK only supports single asset deposit
-          ...withdrawTxRequest(
+      if (isV2ExactTokenWithdraw) {
+        minTokenOut = applySlippageDown(params.amount, slippageBps);
+        maxUnitsIn = applySlippageUp(
+          await provisionerV2.getSyncWithdrawUnitsIn(
+            publicClient,
+            provisionerAddress,
+            runtime.feeCalculator.address,
+            runtime.feeCalculator.version,
             vault.vaultAddress,
-            [{ asset: asset.address, amount: shares }],
-            account
+            asset.address,
+            params.amount
           ),
-        },
-      ];*/
-    }
-
-    const { sufficient } = await this.checkAllowance({
-      publicClient,
-      token: vault.vaultAddress,
-      owner: account,
-      spender: vault.provisionerAddress,
-      amount: shares,
-    });
-
-    const steps: EvmTxStep[] = [];
+          slippageBps
+        );
+      } else {
+        if (shares === undefined) {
+          throw new InvalidWithdrawParamsError();
+        }
+
+        minTokenOut = applySlippageDown(
+          await provisionerV2.getSyncRedeemTokenOut(
+            publicClient,
+            provisionerAddress,
+            runtime.feeCalculator.address,
+            runtime.feeCalculator.version,
+            vault.vaultAddress,
+            asset.address,
+            shares
+          ),
+          slippageBps
+        );
+        maxUnitsIn = applySlippageUp(shares, slippageBps);
+      }
+    } else {
+      if ('entireAmount' in params && params.entireAmount) {
+        shares = await publicClient.readContract({
+          address: vault.vaultAddress,
+          abi: multiDepositorVaultAbi,
+          functionName: 'balanceOf',
+          args: [account],
+        });
+      } else if ('amount' in params && params.amount != null) {
+        shares = await getAsyncWithdrawUnitsIn(
+          publicClient,
+          runtime,
+          vault.vaultAddress,
+          asset.address,
+          params.amount + solverTip
+        );
+      } else if ('shares' in params && params.shares != null) {
+        shares = params.shares;
+      } else {
+        throw new InvalidWithdrawParamsError();
+      }
 
-    if (!sufficient) {
-      steps.push(
-        this.buildApproval({
-          token: vault.vaultAddress,
-          spender: vault.provisionerAddress,
-          amount: shares,
-          account,
-        })
+      const tokenOutBeforeTip = await getAsyncRedeemTokenOut(
+        publicClient,
+        runtime,
+        vault.vaultAddress,
+        asset.address,
+        shares
       );
+      minTokenOut = applySlippageDown(subtractSolverTip(tokenOutBeforeTip, solverTip), slippageBps);
+      maxUnitsIn = shares;
     }
 
+    const steps: EvmTxStep[] = [];
+
     if (isAsync) {
-      // Request redeem
-      const deadline = BigInt(Math.ceil(new Date().getTime() / 1000) + DAY * 3);
-      if (amount === undefined) {
-        throw new UnitConversionError(vault.vaultAddress);
+      if (shares === undefined) {
+        throw new InvalidWithdrawParamsError();
       }
+
+      // Only async requestRedeem needs a vault unit allowance: the provisioner
+      // pulls units from the user. V2 sync redeem/withdraw exits through the
+      // vault and burns the caller's units directly, so no approval is needed.
+      const { sufficient } = await this.checkAllowance({
+        publicClient,
+        token: vault.vaultAddress,
+        owner: account,
+        spender: provisionerAddress,
+        amount: shares,
+      });
+
+      if (!sufficient) {
+        steps.push(
+          this.buildApproval({
+            token: vault.vaultAddress,
+            spender: provisionerAddress,
+            amount: shares,
+            account,
+          })
+        );
+      }
+
+      const deadline = getRequestDeadline(vault.expirationDays);
+
       return [
         ...steps,
         {
           type: 'requestRedeem',
-          ...requestRedeemTxRequest(
-            vault.provisionerAddress,
+          ...(isContractV2
+            ? provisionerV2.requestRedeemTxRequest(
+                provisionerAddress,
+                asset.address,
+                shares,
+                minTokenOut,
+                solverTip,
+                deadline,
+                maxPriceAge,
+                false,
+                receiver,
+                account
+              )
+            : provisionerV1.requestRedeemTxRequest(
+                provisionerAddress,
+                asset.address,
+                shares,
+                minTokenOut,
+                solverTip,
+                deadline,
+                maxPriceAge,
+                false,
+                account
+              )),
+        },
+      ];
+    }
+
+    if ('amount' in params && params.amount != null) {
+      return [
+        ...steps,
+        {
+          type: 'withdraw',
+          ...provisionerV2.withdrawTxRequest(
+            provisionerAddress,
             asset.address,
-            shares,
-            (amount * BigInt(10000 - slippageBps)) / 10000n, // minUnitsOut
-            0n, // solvertip
-            deadline,
-            BigInt(DAY * 10),
-            false,
+            params.amount,
+            maxUnitsIn,
+            receiver,
             account
           ),
         },
       ];
     }
 
-    throw new UnimplementedFeatureError('Aera Sync Operations');
+    if (shares === undefined) {
+      throw new InvalidWithdrawParamsError();
+    }
+
+    return [
+      ...steps,
+      {
+        type: 'redeem',
+        ...provisionerV2.redeemTxRequest(
+          provisionerAddress,
+          asset.address,
+          shares,
+          minTokenOut,
+          receiver,
+          account
+        ),
+      },
+    ];
   },
 
   async checkAllowance(params: AllowanceParams) {

package/src/evm/adapters/types.ts

@@ -1,8 +1,16 @@
 import type { Abi, Address, Hex, PublicClient } from 'viem';
+import type { AeraRuntimeContracts } from '../aeraContracts';
 import type { TokenInfo, VaultDeployment } from '../types';
 
 export interface EvmTxStep<TAbi extends Abi = Abi, TFunctionName extends string = string> {
-  type: 'approve' | 'deposit' | 'requestDeposit' | 'redeem' | 'requestRedeem' | 'withdraw';
+  type:
+    | 'approve'
+    | 'deposit'
+    | 'requestDeposit'
+    | 'redeem'
+    | 'requestRedeem'
+    | 'setDepositReceiverApproval'
+    | 'withdraw';
   address: Address;
   abi: TAbi;
   functionName: TFunctionName;
@@ -24,6 +32,11 @@ export interface AdapterDepositParams {
   publicClient: PublicClient;
   /** Slippage tolerance in basis points (e.g. 100 = 1%). Defaults to 100. */
   slippageBps?: number;
+  /** Solver tip passed to async Aera provisioner requests. Defaults to 0. */
+  solverTip?: bigint;
+  /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
+  maxPriceAge?: bigint;
+  aeraRuntime?: AeraRuntimeContracts;
 }
 
 export type AdapterWithdrawParams = {
@@ -35,6 +48,11 @@ export type AdapterWithdrawParams = {
   publicClient: PublicClient;
   /** Slippage tolerance in basis points (e.g. 100 = 1%). Defaults to 100. */
   slippageBps?: number;
+  /** Solver tip passed to async Aera provisioner requests. Defaults to 0. */
+  solverTip?: bigint;
+  /** Maximum price age passed to async Aera provisioner requests. Defaults to 10 days. */
+  maxPriceAge?: bigint;
+  aeraRuntime?: AeraRuntimeContracts;
 } & (
   | { shares: bigint; amount?: never; entireAmount?: never }
   | { amount: bigint; shares?: never; entireAmount?: never }