@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/base/StakingClient.ts

@@ -0,0 +1,917 @@
+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'
+      };
+    }
+  }
+}