@steerprotocol/sdk 1.27.0 → 1.28.0

package/src/base/FeeManagerClient.ts

@@ -0,0 +1,711 @@
+import {
+  type Address,
+  type Hash,
+  type PublicClient,
+  type WalletClient,
+  isAddressEqual,
+} from 'viem';
+import type {
+  DefaultFeeManagerConfigParams,
+  Fee,
+  FeeManagerConfigParams,
+  FeeWithdrawalParams,
+  MultipleFeeWithdrawalParams,
+  MultiVaultFeeWithdrawalParams,
+  SteerResponse,
+} from '../types.js';
+import { FEE_MANAGER_ABI } from '../const/abis/feeManager.js';
+import { VAULT_FEES_ABI } from '../const/abis/vaultFees.js';
+import { SubgraphClient } from './SubgraphClient.js';
+
+export class FeeManagerClient extends SubgraphClient {
+  protected readonly publicClient: PublicClient;
+  protected readonly walletClient: WalletClient;
+  protected feeManagerAddress: Address;
+
+  public constructor(
+    feeManagerAddress: Address,
+    publicClient: PublicClient,
+    walletClient: WalletClient
+  ) {
+    super(publicClient as PublicClient & WalletClient);
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.feeManagerAddress = feeManagerAddress;
+  }
+
+  /**
+   * Overrides the FeeManager contract address.
+   * Useful when deployment addresses are not yet hardcoded or need custom targeting.
+   * @param address The new FeeManager contract address
+   */
+  public setFeeManagerAddress(address: Address): void {
+    this.feeManagerAddress = address;
+  }
+
+  public async getFees(vault: Address): Promise<SteerResponse<Fee[]>> {
+    try {
+      const fees = await this.publicClient.readContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'getFees',
+        args: [vault],
+      });
+
+      return {
+        data: fees as Fee[],
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async getTotalFees(vault: Address): Promise<SteerResponse<bigint>> {
+    try {
+      const totalFees = await this.publicClient.readContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'vaultTotalFees',
+        args: [vault],
+      });
+
+      return {
+        data: totalFees as bigint,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async getWithdrawer(
+    vault: Address,
+    feeIdentifier: string
+  ): Promise<SteerResponse<Address>> {
+    try {
+      const withdrawer = await this.publicClient.readContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'withdrawalPermissions',
+        args: [vault, feeIdentifier],
+      });
+
+      return {
+        data: withdrawer as Address,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async validateAdminPermission(): Promise<SteerResponse<boolean>> {
+    try {
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const owner = await this.publicClient.readContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'owner',
+      });
+
+      return {
+        data: isAddressEqual(owner as Address, accounts[0]),
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async validateWithdrawerPermission(
+    vault: Address,
+    feeIdentifier: string
+  ): Promise<SteerResponse<boolean>> {
+    try {
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const withdrawer = await this.publicClient.readContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'withdrawalPermissions',
+        args: [vault, feeIdentifier],
+      });
+
+      return {
+        data: isAddressEqual(withdrawer as Address, accounts[0]),
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async setFeeAndWithdrawalPermission(
+    params: FeeManagerConfigParams
+  ): Promise<SteerResponse<Hash>> {
+    try {
+      if (
+        params.feeIdentifiers.length !== params.feeValues.length ||
+        params.feeIdentifiers.length !== params.withdrawers.length
+      ) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'feeIdentifiers, feeValues, and withdrawers must have the same length',
+        };
+      }
+
+      const isAdmin = await this.validateAdminPermission();
+      if (!isAdmin.success) {
+        throw new Error(isAdmin.error ?? 'Unknown error occurred');
+      }
+      if (!isAdmin.data) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'Caller is not FeeManager owner',
+        };
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'setFeeAndWithdrawalPermission',
+        args: [params.vault, params.feeIdentifiers, params.feeValues, params.withdrawers],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async setDefaultFeeAndWithdrawalPermission(
+    params: DefaultFeeManagerConfigParams
+  ): Promise<SteerResponse<Hash>> {
+    try {
+      if (
+        params.feeIdentifiers.length !== params.feeValues.length ||
+        params.feeIdentifiers.length !== params.withdrawers.length
+      ) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'feeIdentifiers, feeValues, and withdrawers must have the same length',
+        };
+      }
+
+      const isAdmin = await this.validateAdminPermission();
+      if (!isAdmin.success) {
+        throw new Error(isAdmin.error ?? 'Unknown error occurred');
+      }
+      if (!isAdmin.data) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'Caller is not FeeManager owner',
+        };
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'setDefaultFeeAndWithdrawalPermission',
+        args: [
+          params.vault,
+          params.totalVaultFees,
+          params.feeIdentifiers,
+          params.feeValues,
+          params.withdrawers,
+        ],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async setMigratedVaultFeeAndWithdrawalPermission(): Promise<SteerResponse<Hash>> {
+    try {
+      const isAdmin = await this.validateAdminPermission();
+      if (!isAdmin.success) {
+        throw new Error(isAdmin.error ?? 'Unknown error occurred');
+      }
+      if (!isAdmin.data) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'Caller is not FeeManager owner',
+        };
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'setMigratedVaultFeeAndWithdrawalPermission',
+        args: [],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async setTotalFees(vault: Address, newTotalFees: bigint): Promise<SteerResponse<Hash>> {
+    try {
+      const isAdmin = await this.validateAdminPermission();
+      if (!isAdmin.success) {
+        throw new Error(isAdmin.error ?? 'Unknown error occurred');
+      }
+      if (!isAdmin.data) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'Caller is not FeeManager owner',
+        };
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'setTotalFees',
+        args: [vault, newTotalFees],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async changeFeeWithdrawer(
+    vault: Address,
+    feeIdentifier: string,
+    newWithdrawer: Address
+  ): Promise<SteerResponse<Hash>> {
+    try {
+      const isAdmin = await this.validateAdminPermission();
+      if (!isAdmin.success) {
+        throw new Error(isAdmin.error ?? 'Unknown error occurred');
+      }
+      if (!isAdmin.data) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'Caller is not FeeManager owner',
+        };
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'changeFeeWithdrawer',
+        args: [vault, feeIdentifier, newWithdrawer],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async withdrawFee(params: FeeWithdrawalParams): Promise<SteerResponse<Hash>> {
+    try {
+      const canWithdraw = await this.validateWithdrawerPermission(
+        params.vault,
+        params.feeIdentifier
+      );
+      if (!canWithdraw.success) {
+        throw new Error(canWithdraw.error ?? 'Unknown error occurred');
+      }
+      if (!canWithdraw.data) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'Caller is not authorized withdrawer',
+        };
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'withdrawFee',
+        args: [params.vault, params.feeIdentifier, params.amount0, params.amount1],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async withdrawMultipleFees(
+    params: MultipleFeeWithdrawalParams
+  ): Promise<SteerResponse<Hash>> {
+    try {
+      if (
+        params.feeIdentifiers.length !== params.amounts0.length ||
+        params.feeIdentifiers.length !== params.amounts1.length
+      ) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'feeIdentifiers, amounts0, and amounts1 must have the same length',
+        };
+      }
+
+      for (const feeIdentifier of params.feeIdentifiers) {
+        const canWithdraw = await this.validateWithdrawerPermission(params.vault, feeIdentifier);
+        if (!canWithdraw.success) {
+          throw new Error(canWithdraw.error ?? 'Unknown error occurred');
+        }
+        if (!canWithdraw.data) {
+          return {
+            data: null,
+            status: 400,
+            success: false,
+            error: `Caller is not authorized withdrawer for ${feeIdentifier}`,
+          };
+        }
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'withdrawMultipleFees',
+        args: [params.vault, params.feeIdentifiers, params.amounts0, params.amounts1],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  public async withdrawFeesFromMultipleVaults(
+    params: MultiVaultFeeWithdrawalParams
+  ): Promise<SteerResponse<Hash>> {
+    try {
+      if (
+        params.vaults.length !== params.feeIdentifiers.length ||
+        params.vaults.length !== params.amounts0.length ||
+        params.vaults.length !== params.amounts1.length
+      ) {
+        return {
+          data: null,
+          status: 400,
+          success: false,
+          error: 'vaults, feeIdentifiers, amounts0, and amounts1 must have the same length',
+        };
+      }
+
+      for (let i = 0; i < params.vaults.length; i++) {
+        const vault = params.vaults[i];
+        const identifiers = params.feeIdentifiers[i];
+        const amount0 = params.amounts0[i];
+        const amount1 = params.amounts1[i];
+
+        if (identifiers.length !== amount0.length || identifiers.length !== amount1.length) {
+          return {
+            data: null,
+            status: 400,
+            success: false,
+            error: 'feeIdentifiers[i], amounts0[i], and amounts1[i] must have the same length',
+          };
+        }
+
+        for (const feeIdentifier of identifiers) {
+          const canWithdraw = await this.validateWithdrawerPermission(vault, feeIdentifier);
+          if (!canWithdraw.success) {
+            throw new Error(canWithdraw.error ?? 'Unknown error occurred');
+          }
+          if (!canWithdraw.data) {
+            return {
+              data: null,
+              status: 400,
+              success: false,
+              error: `Caller is not authorized withdrawer for ${feeIdentifier}`,
+            };
+          }
+        }
+      }
+
+      const accounts = await this.walletClient.getAddresses();
+      if (!accounts[0]) {
+        throw new Error('No account found');
+      }
+
+      const { request } = await this.publicClient.simulateContract({
+        address: this.feeManagerAddress,
+        abi: FEE_MANAGER_ABI,
+        functionName: 'withdrawFeesFromMultipleVaults',
+        args: [params.vaults, params.feeIdentifiers, params.amounts0, params.amounts1],
+        account: accounts[0],
+      });
+
+      const hash = await this.walletClient.writeContract(request);
+
+      return {
+        data: hash,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  /**
+   * Gets the accrued revenue for a specific fee identifier in a vault
+   * @param vault The vault address
+   * @param feeIdentifier The fee identifier (e.g., 'STEER_FEES', 'STRATEGIST_FEES')
+   * @returns Promise resolving to the accrued amounts for token0 and token1
+   */
+  public async getAccruedRevenue(
+    vault: Address,
+    feeIdentifier: string
+  ): Promise<SteerResponse<{ amount0: bigint; amount1: bigint }>> {
+    try {
+      const [amount0, amount1] = await Promise.all([
+        this.publicClient.readContract({
+          address: vault,
+          abi: VAULT_FEES_ABI,
+          functionName: 'accruedFees0',
+          args: [feeIdentifier],
+        }),
+        this.publicClient.readContract({
+          address: vault,
+          abi: VAULT_FEES_ABI,
+          functionName: 'accruedFees1',
+          args: [feeIdentifier],
+        }),
+      ]);
+
+      return {
+        data: { amount0, amount1 },
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+
+  /**
+   * Gets a summary of accrued revenue for all configured fee identifiers in a vault
+   * @param vault The vault address
+   * @returns Promise resolving to a list of fee identifiers and their accrued amounts
+   */
+  public async getVaultRevenueSummary(
+    vault: Address
+  ): Promise<SteerResponse<{ feeIdentifier: string; amount0: bigint; amount1: bigint }[]>> {
+    try {
+      const feesResponse = await this.getFees(vault);
+      if (!feesResponse.success || !feesResponse.data) {
+        throw new Error(feesResponse.error || 'Failed to fetch vault fees configuration');
+      }
+
+      const summary = await Promise.all(
+        feesResponse.data.map(async (fee) => {
+          const revenue = await this.getAccruedRevenue(vault, fee.feeIdentifier);
+          return {
+            feeIdentifier: fee.feeIdentifier,
+            amount0: revenue.data?.amount0 ?? 0n,
+            amount1: revenue.data?.amount1 ?? 0n,
+          };
+        })
+      );
+
+      return {
+        data: summary,
+        status: 200,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      };
+    }
+  }
+}