@steerprotocol/sdk 1.31.0 → 2.0.1

package/src/base/StakingClient.ts

@@ -1,917 +0,0 @@
-import type { Address, Hash, PublicClient, WalletClient } from 'viem';
-import { SteerResponse } from '../types.js';
-import { SubgraphClient } from './SubgraphClient.js';
-import { VaultWithdrawClient } from './vault/withdraw/index.js';
-import { StakingProtocol, isValidStakingProtocol, normalizeProtocol } from '../const/protocol.js';
-import { Decimal } from 'decimal.js';
-
-// Interfaces for staking pool data from API
-export interface StakingPool {
-  allSymbols?: string
-  rewardToken: Address
-  rewardTokenDetail?: Reward
-  rewardTokenA: Address
-  rewardTokenADetail: Reward
-  rewardTokenB?: Address
-  rewardTokenBDetail?: Reward
-  dailyEmissionRewardA: number
-  dailyEmissionRewardB?: number
-  chainId: number
-  stakingPool: string
-  stakingToken: string
-  protocol: string
-  staking: Staking
-  reward: Reward
-  isSteerVault: boolean
-  beaconName?: string
-  vaultTokens?: VaultTokens
-  periodFinish: string
-  isDualFactory?: boolean
-  feeTier?: string
-  rewardsDuration: string
-  strategyId?:string
-  isActive?:boolean
-  postGeneratedTotalStaked?:number
-  postGeneratedApr?: number
-  stakedAmount?:bigint,
-  locked?:boolean
-}
-
-
-export interface VaultTokens {
-  token0: Token0
-  token1: Token1
-}
-
-export interface Token0 {
-  name: string
-  address: Address
-  symbol: string
-}
-
-export interface Token1 {
-  name: string
-  address: Address
-  symbol: string
-}
-
-export interface Reward {
-  symbol: string
-  name: string
-  address: Address,
-  decimals: number
-}
-
-export interface Staking {
-  symbol: string
-  name: string
-  address: Address
-  decimals: number
-}
-
-export interface StakingPoolFilter {
-  chainId?: number;
-  protocol?: StakingProtocol;
-  isLive?: boolean;
-  includeExpired?: boolean;
-  minDailyEmissionA?: number;
-  minDailyEmissionB?: number;
-  isDualRewards?: boolean;
-}
-
-// Interfaces for contract parameters
-export interface StakeParams {
-  stakingPool: Address;
-  amount: bigint;
-}
-
-export interface WithdrawParams {
-  stakingPool: Address;
-  amount: bigint;
-}
-
-export interface GetRewardParams {
-  stakingPool: Address;
-}
-
-export interface TokenValueParams {
-  stakingPool: StakingPool;
-  amount: bigint;
-  token0UsdPrice: number;
-  token1UsdPrice: number;
-}
-
-export interface TokenValueResponse {
-  totalValueUsd: number;
-  token0Value?: number;
-  token1Value?: number;
-  tokenValue?: number;
-}
-
-// Add type definition for raw pool data
-interface RawStakingPool {
-  allSymbols?: string
-  rewardToken: Address
-  rewardTokenDetail?: Reward
-  rewardTokenA: Address
-  rewardTokenADetail: Reward
-  rewardTokenB?: Address
-  rewardTokenBDetail?: Reward
-  dailyEmissionRewardA: number
-  dailyEmissionRewardB?: number
-  chainId: number
-  stakingPool: string
-  stakingToken: string
-  protocol: StakingProtocol
-  staking: Staking
-  reward: Reward
-  isSteerVault: boolean
-  beaconName?: string
-  vaultTokens?: VaultTokens
-  periodFinish: string
-  isDualFactory?: boolean
-  feeTier?: string
-  rewardsDuration: string
-  strategyId?:string
-  isActive?:boolean
-  postGeneratedTotalStaked?:number
-  postGeneratedApr?: number
-  stakedAmount?:bigint,
-  locked?:boolean
-}
-
-// ABIs for staking contracts
-const SINGLE_REWARD_ABI = [
-  {
-    "inputs": [],
-    "name": "lastTimeRewardApplicable",
-    "outputs": [{"type": "uint256"}],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [{"type": "address"}],
-    "name": "earned",
-    "outputs": [{"type": "uint256"}],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "totalSupply",
-    "outputs": [{"type": "uint256"}],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [{"type": "address"}],
-    "name": "balanceOf",
-    "outputs": [{"type": "uint256"}],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [{"type": "uint256"}],
-    "name": "stake",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [{"type": "uint256"}],
-    "name": "withdraw",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "getReward",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "exit",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  }
-] as const;
-
-const DUAL_REWARD_ABI = [
-  ...SINGLE_REWARD_ABI,
-  {
-    "inputs": [{"type": "address"}],
-    "name": "earnedA",
-    "outputs": [{"type": "uint256"}],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [{"type": "address"}],
-    "name": "earnedB",
-    "outputs": [{"type": "uint256"}],
-    "stateMutability": "view",
-    "type": "function"
-  }
-] as const;
-
-const ERC20_ABI = [
-  {
-    "inputs": [],
-    "name": "decimals",
-    "outputs": [{"type": "uint8"}],
-    "stateMutability": "view",
-    "type": "function"
-  }
-] as const;
-
-export class StakingClient extends SubgraphClient {
-  protected readonly publicClient: PublicClient;
-  protected readonly walletClient: WalletClient;
-  private readonly stakingPoolsEndpoint = 'https://9i52h964s3.execute-api.us-east-1.amazonaws.com/dev/staking-pools';
-  private readonly withdrawClient: VaultWithdrawClient;
-
-  constructor(client: PublicClient & WalletClient) {
-    super(client);
-    this.publicClient = client;
-    this.walletClient = client;
-    this.withdrawClient = new VaultWithdrawClient(client, client);
-  }
-
-  /**
-   * Fetches and filters staking pools based on provided criteria
-   * @param filter Optional filter object to filter the pools
-   */
-  public async getStakingPools(
-    filter?: StakingPoolFilter
-  ): Promise<SteerResponse<StakingPool[]>> {
-    try {
-      const response = await fetch(this.stakingPoolsEndpoint);
-      if (!response.ok) {
-        throw new Error('Failed to fetch staking pools');
-      }
-
-      const rawPools: RawStakingPool[] = (await response.json()).pools;
-
-      // Convert and validate protocols in the response
-      let pools: StakingPool[] = rawPools
-        .filter((pool) => isValidStakingProtocol(pool.protocol))
-        .map((pool) => ({
-          ...pool,
-          protocol: normalizeProtocol(pool.protocol)
-        }));
-
-      // Apply filters if provided
-      if (filter) {
-        pools = this.filterPools(pools, filter);
-      }
-
-      return {
-        data: pools,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets only currently active staking pools
-   * @param chainId Optional chain ID to filter pools
-   * @param protocol Optional protocol name to filter pools
-   */
-  public async getLiveStakingPools(chainId?: number, protocol?: StakingProtocol): Promise<SteerResponse<StakingPool[]>> {
-    return this.getStakingPools({
-      chainId,
-      protocol,
-      isLive: true,
-      includeExpired: false
-    });
-  }
-
-  /**
-   * Gets all dual rewards staking pools
-   * @param chainId Optional chain ID to filter pools
-   * @param protocol Optional protocol name to filter pools
-   * @param isLive Optional flag to only get live pools
-   */
-  public async getDualRewardsStakingPools(
-    chainId?: number,
-    protocol?: StakingProtocol,
-    isLive?: boolean
-  ): Promise<SteerResponse<StakingPool[]>> {
-    return this.getStakingPools({
-      chainId,
-      protocol,
-      isLive,
-      isDualRewards: true
-    });
-  }
-
-  /**
-   * Gets high yield staking pools based on minimum daily emissions
-   * @param minDailyEmissionA Minimum daily emission for reward A
-   * @param minDailyEmissionB Optional minimum daily emission for reward B
-   * @param chainId Optional chain ID to filter pools
-   */
-  public async getHighYieldStakingPools(
-    minDailyEmissionA: number,
-    minDailyEmissionB?: number,
-    chainId?: number
-  ): Promise<SteerResponse<StakingPool[]>> {
-    return this.getStakingPools({
-      chainId,
-      minDailyEmissionA,
-      minDailyEmissionB,
-      isLive: true
-    });
-  }
-
-  /**
-   * Internal helper to filter pools based on criteria
-   */
-  private filterPools(pools: StakingPool[], filter: StakingPoolFilter): StakingPool[] {
-    return pools.filter(pool => {
-      // Chain ID filter
-      if (filter.chainId !== undefined && pool.chainId !== filter.chainId) {
-        return false;
-      }
-
-      // Protocol filter
-      if (filter.protocol !== undefined && pool.protocol !== filter.protocol) {
-        return false;
-      }
-
-      // Dual rewards filter
-      if (filter.isDualRewards !== undefined && pool.isDualFactory !== filter.isDualRewards) {
-        return false;
-      }
-
-      // Daily emission filters
-      if (filter.minDailyEmissionA !== undefined && pool.dailyEmissionRewardA < filter.minDailyEmissionA) {
-        return false;
-      }
-      if (filter.minDailyEmissionB !== undefined && pool.dailyEmissionRewardB !== undefined && pool.dailyEmissionRewardB < filter.minDailyEmissionB) {
-        return false;
-      }
-
-      // Live/Expired filter
-      if (filter.isLive !== undefined) {
-        const now = Math.floor(Date.now() / 1000);
-        const periodFinish = parseInt(pool.periodFinish);
-        const isPoolLive = periodFinish > now;
-
-        if (filter.isLive && !isPoolLive) {
-          return false;
-        }
-
-        if (!filter.includeExpired && !isPoolLive) {
-          return false;
-        }
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Stakes tokens in a staking pool
-   * @param params The staking parameters
-   */
-  public async stake(params: StakeParams): Promise<SteerResponse<Hash>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      const { request } = await this.publicClient.simulateContract({
-        address: params.stakingPool,
-        abi: SINGLE_REWARD_ABI,
-        functionName: 'stake',
-        args: [params.amount],
-        account: account[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',
-      };
-    }
-  }
-
-  /**
-   * Withdraws tokens from a staking pool
-   * @param params The withdrawal parameters
-   */
-  public async withdraw(params: WithdrawParams): Promise<SteerResponse<Hash>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      const { request } = await this.publicClient.simulateContract({
-        address: params.stakingPool,
-        abi: SINGLE_REWARD_ABI,
-        functionName: 'withdraw',
-        args: [params.amount],
-        account: account[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',
-      };
-    }
-  }
-
-  /**
-   * Claims rewards from a staking pool
-   * @param params The reward claim parameters
-   */
-  public async getReward(params: GetRewardParams): Promise<SteerResponse<Hash>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      const { request } = await this.publicClient.simulateContract({
-        address: params.stakingPool,
-        abi: SINGLE_REWARD_ABI,
-        functionName: 'getReward',
-        args: [],
-        account: account[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 earned rewards for an account in a staking pool
-   * @param stakingPool The staking pool address
-   * @param account The account to check rewards for
-   */
-  public async earned(stakingPool: Address, account: Address): Promise<SteerResponse<{ rewardA: bigint; rewardB?: bigint }>> {
-    try {
-      // First try to read as single reward
-      try {
-        const reward = await this.publicClient.readContract({
-          address: stakingPool,
-          abi: SINGLE_REWARD_ABI,
-          functionName: 'earned',
-          args: [account],
-        });
-
-        return {
-          data: { rewardA: reward },
-          status: 200,
-          success: true,
-        };
-      } catch {
-        // If single reward fails, try dual rewards
-        const [rewardA, rewardB] = await Promise.all([
-          this.publicClient.readContract({
-            address: stakingPool,
-            abi: DUAL_REWARD_ABI,
-            functionName: 'earnedA',
-            args: [account],
-          }),
-          this.publicClient.readContract({
-            address: stakingPool,
-            abi: DUAL_REWARD_ABI,
-            functionName: 'earnedB',
-            args: [account],
-          }),
-        ]);
-
-        return {
-          data: { rewardA, rewardB },
-          status: 200,
-          success: true,
-        };
-      }
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the total supply of staked tokens in a pool
-   * @param stakingPool The staking pool address
-   */
-  public async totalSupply(stakingPool: Address): Promise<SteerResponse<bigint>> {
-    try {
-      const totalSupply = await this.publicClient.readContract({
-        address: stakingPool,
-        abi: SINGLE_REWARD_ABI,
-        functionName: 'totalSupply',
-      });
-
-      return {
-        data: totalSupply,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the staked balance of an account in a pool
-   * @param stakingPool The staking pool address
-   * @param account The account to check balance for
-   */
-  public async balanceOf(stakingPool: Address, account: Address): Promise<SteerResponse<bigint>> {
-    try {
-      const balance = await this.publicClient.readContract({
-        address: stakingPool,
-        abi: SINGLE_REWARD_ABI,
-        functionName: 'balanceOf',
-        args: [account],
-      });
-
-      return {
-        data: balance,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Calculates the APR for a staking pool
-   * @param pool The staking pool data
-   * @param rewardTokenPriceUSD The price of the reward token in USD
-   * @param totalStakedUSD The total value staked in USD
-   */
-  public calculateAPR(
-    pool: StakingPool,
-    rewardTokenPriceUSD: number,
-    totalStakedUSD: number
-  ): number {
-    if (totalStakedUSD === 0) {
-      return 0;
-    }
-
-    const dailyRewardUSD = pool.dailyEmissionRewardA * rewardTokenPriceUSD;
-    let apr = (dailyRewardUSD * 365 * 100) / totalStakedUSD;
-
-    if (pool.isDualFactory && pool.dailyEmissionRewardB) {
-      const dailyRewardBUSD = pool.dailyEmissionRewardB * rewardTokenPriceUSD;
-      apr += (dailyRewardBUSD * 365 * 100) / totalStakedUSD;
-    }
-
-    return apr;
-  }
-
-  /**
-   * Calculates the USD value of tokens in a staking pool
-   * Handles both regular staking pools and Steer vaults
-   * @param params Parameters for token value calculation
-   */
-  public async getSteerLpTokenValue(params: TokenValueParams): Promise<SteerResponse<TokenValueResponse>> {
-    try {
-      // First, get the staking pool details
-      const pool = params.stakingPool;
-      
-      const chainId = await this.publicClient.getChainId();
-      if (chainId !== pool.chainId) {
-        throw new Error(`Chain ID mismatch| expected ${pool.chainId} but got ${chainId}`);
-      }
-
-      // Handle Steer vault staking pools
-      if (pool.isSteerVault && pool.staking) {
-        if (!pool.vaultTokens) {
-          throw new Error('Vault tokens information not found');
-        }
-
-        // Get underlying token amounts from LP token
-        const tokensResponse = await this.withdrawClient.getTokensFromLp(
-          pool.staking.address,
-          params.amount
-        );
-
-        if (!tokensResponse.success || !tokensResponse.data) {
-          throw new Error('Failed to get token amounts from LP');
-        }
-
-        // Get decimals for both tokens
-        const [token0Decimals, token1Decimals] = await Promise.all([
-          this.publicClient.readContract({
-            address: pool.vaultTokens.token0.address,
-            abi: ERC20_ABI,
-            functionName: 'decimals'
-          }),
-          this.publicClient.readContract({
-            address: pool.vaultTokens.token1.address,
-            abi: ERC20_ABI,
-            functionName: 'decimals'
-          })
-        ]);
-
-        // Use Decimal.js for precise calculations
-        const token0Amount = new Decimal(tokensResponse.data.token0Val.toString())
-          .div(new Decimal(10).pow(token0Decimals))
-          .mul(params.token0UsdPrice);
-
-        const token1Amount = new Decimal(tokensResponse.data.token1Val.toString())
-          .div(new Decimal(10).pow(token1Decimals))
-          .mul(params.token1UsdPrice);
-
-        const totalValueUsd = token0Amount.plus(token1Amount).toNumber();
-        const token0ValueUsd = token0Amount.toNumber();
-        const token1ValueUsd = token1Amount.toNumber();
-
-        return {
-          data: {
-            totalValueUsd,
-            token0Value: token0ValueUsd,
-            token1Value: token1ValueUsd
-          },
-          status: 200,
-          success: true
-        };
-      }
-
-      // Handle regular staking pools (non-Steer vault)
-      const stakingDecimals = await this.publicClient.readContract({
-        address: pool.staking.address,
-        abi: ERC20_ABI,
-        functionName: 'decimals'
-      });
-
-      const tokenValueUsd = new Decimal(params.amount.toString())
-        .div(new Decimal(10).pow(stakingDecimals))
-        .mul(params.token0UsdPrice)
-        .toNumber();
-
-      return {
-        data: {
-          totalValueUsd: tokenValueUsd,
-          tokenValue: tokenValueUsd
-        },
-        status: 200,
-        success: true
-      };
-
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Gets the total staking amount in USD for a pool
-   * @param stakingPool The staking pool
-   * @param token0UsdPrice Price of token0 in USD
-   * @param token1UsdPrice Price of token1 in USD (required for Steer vaults)
-   */
-  public async getTotalStakingAmountInUsd(
-    stakingPool: StakingPool,
-    token0UsdPrice: number,
-    token1UsdPrice?: number
-  ): Promise<SteerResponse<number>> {
-    try {
-      // Get total supply
-      const totalSupplyResponse = await this.totalSupply(stakingPool.stakingPool as `0x${string}`);
-      if (!totalSupplyResponse.success || !totalSupplyResponse.data) {
-        throw new Error('Failed to get total supply');
-      }
-
-      // Get value using getSteerLpTokenValue
-      const valueResponse = await this.getSteerLpTokenValue({
-        stakingPool,
-        amount: totalSupplyResponse.data,
-        token0UsdPrice,
-        token1UsdPrice: token1UsdPrice || token0UsdPrice
-      });
-
-      if (!valueResponse.success || !valueResponse.data) {
-        throw new Error('Failed to calculate token value');
-      }
-
-      return {
-        data: valueResponse.data.totalValueUsd,
-        status: 200,
-        success: true
-      };
-
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Prepares the transaction data for staking tokens without executing it
-   * @param params The staking parameters
-   */
-  public async prepareStakeTx(params: StakeParams): Promise<SteerResponse<{
-    address: Address;
-    abi: {
-      type: string;
-      inputs: {
-        name: string;
-        internalType: string;
-        type: string;
-      }[];
-      name: string;
-      outputs: never[];
-      stateMutability: string;
-    }[];
-    functionName: string;
-    args: readonly [bigint];
-  }>> {
-    try {
-
-      return {
-        data: {
-          address: params.stakingPool,
-          abi: [{
-            type: 'function',
-            inputs: [
-              { name: 'amount', internalType: 'uint256', type: 'uint256' }
-            ],
-            name: 'stake',
-            outputs: [],
-            stateMutability: 'nonpayable'
-          }],
-          functionName: 'stake',
-          args: [params.amount] as const
-        },
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Prepares the transaction data for withdrawing tokens without executing it
-   * @param params The withdrawal parameters
-   */
-  public async prepareWithdrawTx(params: WithdrawParams): Promise<SteerResponse<{
-    address: Address;
-    abi: {
-      type: string;
-      inputs: {
-        name: string;
-        internalType: string;
-        type: string;
-      }[];
-      name: string;
-      outputs: never[];
-      stateMutability: string;
-    }[];
-    functionName: string;
-    args: readonly [bigint];
-  }>> {
-    try {
-
-      return {
-        data: {
-          address: params.stakingPool,
-          abi: [{
-            type: 'function',
-            inputs: [
-              { name: 'amount', internalType: 'uint256', type: 'uint256' }
-            ],
-            name: 'withdraw',
-            outputs: [],
-            stateMutability: 'nonpayable'
-          }],
-          functionName: 'withdraw',
-          args: [params.amount] as const
-        },
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Prepares the transaction data for claiming rewards without executing it
-   * @param params The reward claim parameters
-   */
-  public async prepareGetRewardTx(params: GetRewardParams): Promise<SteerResponse<{
-    address: Address;
-    abi: {
-      type: string;
-      inputs: {
-        name: string;
-        internalType: string;
-        type: string;
-      }[];
-      name: string;
-      outputs: never[];
-      stateMutability: string;
-    }[];
-    functionName: string;
-    args: readonly [];
-  }>> {
-    try {
-
-      return {
-        data: {
-          address: params.stakingPool,
-          abi: [{
-            type: 'function',
-            inputs: [],
-            name: 'getReward',
-            outputs: [],
-            stateMutability: 'nonpayable'
-          }],
-          functionName: 'getReward',
-          args: [] as const
-        },
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-}