aiia-vault-sdk 1.0.1

package/TradingVault.ts

@@ -0,0 +1,863 @@
+import { ethers } from "ethers";
+import { TradingVault } from "./contracts/TradingVault";
+import TradingVaultABI from "./abis/TradingVault.json";
+import contracts from "./contracts.json";
+import { AnyEvent, AnyEventRaw, EventTypes } from "./types";
+import { type SendTransactionMutateAsync } from "@wagmi/core/query";
+import { Config } from "@wagmi/core/dist/types/createConfig";
+import {
+  getRandomProvider,
+  checkRpcHealth,
+  getTransactionStatus,
+  getTokenDecimals,
+  getTokenAllowance,
+  buildApproveERC20Tx,
+  getRewardWeight,
+  resolveContractAddress,
+  streamEvents,
+  getAllEvents,
+  signAndSendTransaction,
+} from "./utils";
+
+export class TradingVaultSDK {
+  name = "TradingVault";
+  private contract: TradingVault;
+  private providers: ethers.Provider[];
+  private _currency: string | null = null;
+  private _rewardToken: string | null = null;
+  private _currencyDecimals: number | null = null;
+  private _rewardTokenDecimals: number | null = null;
+  private priceDecimals: number = 6;
+  private contractAddress: string;
+  private isBootstrapped: boolean = false;
+  private configs: Array<{ weight: number; duration: number }> = [];
+  private BASE_WEIGHT = 10_000;
+  private BASE_PRICE = 100;
+
+  constructor(rpcUrls: string | string[], contractAddress?: string) {
+    // Convert single RPC to array if needed
+    const rpcArray = Array.isArray(rpcUrls) ? rpcUrls : [rpcUrls];
+
+    // Create providers for each RPC
+    this.providers = rpcArray.map((rpc) => new ethers.JsonRpcProvider(rpc));
+
+    // Get a random provider for initial setup
+    const initialProvider = getRandomProvider(this.providers);
+
+    // Determine contract address based on RPC URL if not provided
+    this.contractAddress = resolveContractAddress(
+      rpcArray[0],
+      this.name,
+      contracts,
+      contractAddress
+    );
+
+    // Initialize contract with initial provider
+    this.contract = new ethers.Contract(
+      this.contractAddress,
+      TradingVaultABI.abi,
+      initialProvider
+    ) as unknown as TradingVault;
+  }
+
+  private getRandomProvider(): ethers.Provider {
+    return getRandomProvider(this.providers);
+  }
+
+  private getContractWithRandomProvider(): TradingVault {
+    return new ethers.Contract(
+      this.contractAddress,
+      TradingVaultABI.abi,
+      this.getRandomProvider()
+    ) as unknown as TradingVault;
+  }
+
+  async bootstrap() {
+    if (this.isBootstrapped) {
+      return;
+    }
+
+    // Check health of all RPCs and remove inactive ones
+    const healthChecks = await Promise.all(
+      this.providers.map((provider, index) => checkRpcHealth(provider, index))
+    );
+
+    // Filter out inactive providers
+    this.providers = this.providers.filter((_, index) => healthChecks[index]);
+
+    if (this.providers.length === 0) {
+      throw new Error("No active RPC providers available");
+    }
+
+    await Promise.all([
+      this.getCurrencyDecimals(),
+      this.getRewardTokenDecimals(),
+      (async () => {
+        const configLength = await this.getRewardConfigsLength();
+        const configPromises = [];
+        for (let i = 0; i < configLength; i++) {
+          configPromises.push(this.getRewardConfig(i));
+        }
+        const configs = await Promise.all(configPromises);
+        this.configs = configs.map((config) => ({
+          weight: Number(config.weight) / this.BASE_WEIGHT,
+          duration: Number(config.duration),
+        }));
+      })(),
+    ]);
+    this.isBootstrapped = true;
+  }
+
+  async signAndSendTransaction(
+    tx: ethers.ContractTransaction,
+    wallet: ethers.Wallet | SendTransactionMutateAsync<Config, any>,
+    callbacks: {
+      onSubmit?: (tx: string) => void | Promise<void>;
+      onFinally?: (status: {
+        status: boolean | null;
+        confirmations: number;
+        txHash: string;
+        isCompleted: boolean;
+        attempts: number;
+      }) => void | Promise<void>;
+      onError?: (error: Error) => void | Promise<void>;
+    } = {}
+  ): Promise<{
+    transaction: {
+      hash: string;
+    };
+    status: {
+      status: boolean | null;
+      confirmations: number;
+      isCompleted: boolean;
+      attempts: number;
+    };
+  }> {
+    return signAndSendTransaction(
+      tx,
+      wallet,
+      () => this.getRandomProvider(),
+      callbacks
+    );
+  }
+
+  // Transaction builders
+  async buildCreatePositionTx(amount: number) {
+    const decimals = await this.getCurrencyDecimals();
+    const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+    return this.buildCreatePositionTxRaw(amountBigInt);
+  }
+
+  async buildCreatePositionForUserTx(user: string, amount: number) {
+    const decimals = await this.getCurrencyDecimals();
+    const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+    return this.buildCreatePositionForUserTxRaw(user, amountBigInt);
+  }
+
+  async buildReducePositionTx(tokenId: bigint, amount: number) {
+    const decimals = await this.getCurrencyDecimals();
+    const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+    return this.buildReducePositionTxRaw(tokenId, amountBigInt);
+  }
+
+  async buildReducePositionsTx(tokenIds: bigint[], amounts: number[]) {
+    const decimals = await this.getCurrencyDecimals();
+    const amountsBigInt = amounts.map((amount) =>
+      BigInt(Math.floor(amount * Math.pow(10, decimals)))
+    );
+    return this.buildReducePositionsTxRaw(tokenIds, amountsBigInt);
+  }
+
+  async buildBorrowCurrencyTx(amount: number) {
+    const decimals = await this.getCurrencyDecimals();
+    const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+    return this.buildBorrowCurrencyTxRaw(amountBigInt);
+  }
+
+  async buildRepayCurrencyTx(amount: number) {
+    const decimals = await this.getCurrencyDecimals();
+    const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+    return this.buildRepayCurrencyTxRaw(amountBigInt);
+  }
+
+  async buildSetPriceTx(newPrice: number, rewardAmount: number) {
+    const decimals = this.priceDecimals;
+    const rewardDecimals = await this.getRewardTokenDecimals();
+    const priceBigInt = BigInt(Math.floor(newPrice * Math.pow(10, decimals)));
+    const rewardAmountBigInt = BigInt(
+      Math.floor(rewardAmount * Math.pow(10, rewardDecimals))
+    );
+    return this.buildSetPriceTxRaw(priceBigInt, rewardAmountBigInt);
+  }
+
+  async buildClaimERC20Tx(token: string, amount: number) {
+    const tokenContract = new ethers.Contract(
+      token,
+      ["function decimals() view returns (uint8)"],
+      this.getRandomProvider()
+    );
+    const decimals = await tokenContract.decimals();
+    const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+    return this.buildClaimERC20TxRaw(token, amountBigInt);
+  }
+
+  async buildCreatePositionTxRaw(amount: bigint) {
+    const tx = await this.contract.createPosition.populateTransaction(amount);
+    return tx;
+  }
+
+  async buildCreatePositionForUserTxRaw(user: string, amount: bigint) {
+    const tx = await this.contract.createPositionForUser.populateTransaction(
+      user,
+      amount
+    );
+    return tx;
+  }
+
+  async buildReducePositionTxRaw(tokenId: bigint, amount: bigint) {
+    const tx = await this.contract.reducePosition.populateTransaction(
+      tokenId,
+      amount
+    );
+    return tx;
+  }
+
+  async buildReducePositionsTxRaw(tokenIds: bigint[], amounts: bigint[]) {
+    const tx = await this.contract.reducePositions.populateTransaction(
+      tokenIds,
+      amounts
+    );
+    return tx;
+  }
+
+  async buildBorrowCurrencyTxRaw(amount: bigint) {
+    const tx = await this.contract.borrowCurrency.populateTransaction(amount);
+    return tx;
+  }
+
+  async buildRepayCurrencyTxRaw(amount: bigint) {
+    const tx = await this.contract.repayCurrency.populateTransaction(amount);
+    return tx;
+  }
+
+  async buildSetPriceTxRaw(newPrice: bigint, rewardAmount: bigint) {
+    const tx = await this.contract.setPrice.populateTransaction(
+      newPrice,
+      rewardAmount
+    );
+    return tx;
+  }
+
+  async buildSetCurrencyTxRaw(currency: string) {
+    this._currency = null; // Reset cache when currency is about to change
+    const tx = await this.contract.setCurrency.populateTransaction(currency);
+    return tx;
+  }
+
+  async buildSetRewardTokenTxRaw(rewardToken: string) {
+    this._rewardToken = null; // Reset cache when reward token is about to change
+    const tx = await this.contract.setRewardToken.populateTransaction(
+      rewardToken
+    );
+    return tx;
+  }
+
+  async buildSetTreasuryTxRaw(treasury: string) {
+    const tx = await this.contract.setTreasury.populateTransaction(treasury);
+    return tx;
+  }
+
+  async buildUpdateRewardConfigsTxRaw(
+    configs: TradingVault.RewardConfigStruct[]
+  ) {
+    const tx = await this.contract.updateRewardConfigs.populateTransaction(
+      configs
+    );
+    return tx;
+  }
+
+  async buildSetReduceEnabledTxRaw(enabled: boolean) {
+    const tx = await this.contract.setReduceEnabled.populateTransaction(
+      enabled
+    );
+    return tx;
+  }
+
+  async buildClaimERC20TxRaw(token: string, amount: bigint) {
+    const tx = await this.contract.claimERC20.populateTransaction(
+      token,
+      amount
+    );
+    return tx;
+  }
+
+  async buildApproveERC20Tx(
+    tokenAddress: string,
+    spender: string,
+    amount: number
+  ) {
+    const tokenContract = new ethers.Contract(
+      tokenAddress,
+      ["function decimals() view returns (uint8)"],
+      this.getRandomProvider()
+    );
+    const decimals = await tokenContract.decimals();
+    const amountBigInt = BigInt(
+      Math.floor(amount * Math.pow(10, Number(decimals)))
+    );
+    return this.buildApproveERC20TxRaw(tokenAddress, spender, amountBigInt);
+  }
+
+  async buildApproveERC20TxRaw(
+    tokenAddress: string,
+    spender: string,
+    amount: bigint
+  ) {
+    return await buildApproveERC20Tx(
+      tokenAddress,
+      spender,
+      amount,
+      this.getRandomProvider()
+    );
+  }
+
+  async getAllowanceRaw(
+    tokenAddress: string,
+    owner: string,
+    spender: string
+  ): Promise<bigint> {
+    return await getTokenAllowance(
+      tokenAddress,
+      owner,
+      spender,
+      this.getRandomProvider()
+    );
+  }
+
+  async getAllowance(
+    tokenAddress: string,
+    owner: string,
+    spender: string
+  ): Promise<number> {
+    const [allowanceRaw, decimals] = await Promise.all([
+      this.getAllowanceRaw(tokenAddress, owner, spender),
+      getTokenDecimals(tokenAddress, this.getRandomProvider()),
+    ]);
+    return Number(allowanceRaw) / Math.pow(10, decimals);
+  }
+
+  async buildGrantOperatorRoleTxRaw(operator: string) {
+    const tx = await this.contract.grantOperatorRole.populateTransaction(
+      operator
+    );
+    return tx;
+  }
+
+  // Read methods
+  async getPrice(): Promise<number> {
+    const priceRaw = await this.getPriceRaw();
+    const decimals = this.priceDecimals;
+    return Number(priceRaw) / Math.pow(10, decimals);
+  }
+
+  async getPriceRaw(): Promise<bigint> {
+    return await this.contract.price();
+  }
+
+  async getCurrency(): Promise<string> {
+    if (!this._currency) {
+      this._currency = await this.contract.currency();
+    }
+    return this._currency;
+  }
+
+  async getRewardToken(): Promise<string> {
+    if (!this._rewardToken) {
+      this._rewardToken = await this.contract.rewardToken();
+    }
+    return this._rewardToken;
+  }
+
+  async getTreasury(): Promise<string> {
+    return await this.contract.treasury();
+  }
+
+  async getTotalAmount(): Promise<number> {
+    const totalAmountRaw = await this.getTotalAmountRaw();
+    const decimals = await this.getCurrencyDecimals();
+    return Number(totalAmountRaw) / Math.pow(10, decimals);
+  }
+
+  async getTotalAmountRaw(): Promise<bigint> {
+    return await this.contract.totalAmount();
+  }
+
+  async getTotalBorrowed(): Promise<number> {
+    const totalBorrowedRaw = await this.getTotalBorrowedRaw();
+    const decimals = await this.getCurrencyDecimals();
+    return Number(totalBorrowedRaw) / Math.pow(10, decimals);
+  }
+
+  async getTotalBorrowedRaw(): Promise<bigint> {
+    return await this.contract.totalBorrowed();
+  }
+
+  async isReduceEnabled(): Promise<boolean> {
+    return await this.contract.isReduceEnabled();
+  }
+
+  async getPosition(tokenId: bigint): Promise<{
+    remainingAmount: number;
+    entryPrice: number;
+    outPrice: number;
+    openedAt: number;
+    closedAt: number;
+    rewardedAmount: number;
+    lossAmount: number;
+    initAmount: number;
+  }> {
+    const positionRaw = await this.getPositionRaw(tokenId);
+    const currencyDecimals = await this.getCurrencyDecimals();
+    const rewardTokenDecimals = await this.getRewardTokenDecimals();
+    const priceDecimals = this.priceDecimals;
+    return {
+      remainingAmount:
+        Number(positionRaw.remainingAmount) / Math.pow(10, currencyDecimals),
+      entryPrice: Number(positionRaw.entryPrice) / Math.pow(10, priceDecimals),
+      outPrice: Number(positionRaw.outPrice) / Math.pow(10, priceDecimals),
+      openedAt: Number(positionRaw.openedAt),
+      closedAt: Number(positionRaw.closedAt),
+      rewardedAmount:
+        Number(positionRaw.rewardedAmount) / Math.pow(10, rewardTokenDecimals),
+      lossAmount:
+        Number(positionRaw.lossAmount) / Math.pow(10, currencyDecimals),
+      initAmount:
+        Number(positionRaw.initAmount) / Math.pow(10, currencyDecimals),
+    };
+  }
+
+  async getPositionRaw(tokenId: bigint) {
+    return await this.contract.positions(tokenId);
+  }
+
+  async getRewardConfig(index: number) {
+    return await this.contract.rewardConfigs(index);
+  }
+
+  async getRewardConfigsLength(): Promise<bigint> {
+    return await this.contract.getRewardConfigsLength();
+  }
+
+  async getCurrencyDecimals(): Promise<number> {
+    if (this._currencyDecimals === null) {
+      const currency = await this.getCurrency();
+      const currencyContract = new ethers.Contract(
+        currency,
+        ["function decimals() view returns (uint8)"],
+        this.getRandomProvider()
+      );
+      this._currencyDecimals = Number(await currencyContract.decimals());
+    }
+    return this._currencyDecimals!;
+  }
+
+  async getRewardTokenDecimals(): Promise<number> {
+    if (this._rewardTokenDecimals === null) {
+      const rewardToken = await this.getRewardToken();
+      const rewardTokenContract = new ethers.Contract(
+        rewardToken,
+        ["function decimals() view returns (uint8)"],
+        this.getRandomProvider()
+      );
+      this._rewardTokenDecimals = Number(await rewardTokenContract.decimals());
+    }
+    return this._rewardTokenDecimals!;
+  }
+
+  getContractAddress(): string {
+    return this.contractAddress;
+  }
+
+  getConfigs(): Array<{ weight: number; duration: number }> {
+    return [...this.configs];
+  }
+
+  async getAllEvents(
+    fromBlock: number,
+    toBlock: number
+  ): Promise<AnyEventRaw[]> {
+    await this.bootstrap();
+    return getAllEvents<AnyEventRaw, TradingVault>(
+      this.contract,
+      () => this.getRandomProvider(),
+      () => this.getContractWithRandomProvider(),
+      fromBlock,
+      toBlock
+    );
+  }
+
+  async streamEvents(
+    fromBlock: number,
+    onEvent: (event: AnyEvent) => Promise<void>,
+    saveLatestBlock: (blockNumber: number) => Promise<void>,
+    batchSize: number = 1000,
+    sleepTime: number = 5000
+  ) {
+    await this.bootstrap();
+
+    return streamEvents<AnyEventRaw, AnyEvent>({
+      getProvider: () => this.getRandomProvider(),
+      getAllEvents: (fromBlock, toBlock) =>
+        this.getAllEvents(fromBlock, toBlock),
+      formatEvent: (event) => this.formatEventArgs(event),
+      onEvent,
+      saveLatestBlock,
+      fromBlock,
+      batchSize,
+      sleepTime,
+    });
+  }
+
+  formatEventArgs = (event: AnyEventRaw): AnyEvent => {
+    const currencyDecimals = this._currencyDecimals!;
+    const rewardTokenDecimals = this._rewardTokenDecimals!;
+    const { eventName, args } = event;
+
+    switch (eventName) {
+      case "PositionCreated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            user: args.user.toLowerCase(),
+            amount: Number(args.amount) / Math.pow(10, currencyDecimals),
+            entryPrice:
+              Number(args.entryPrice) / Math.pow(10, this.priceDecimals),
+            tokenId: Number(args.tokenId),
+            openedAt: Number(args.openedAt),
+          },
+        };
+
+      case "PositionReduced":
+        return {
+          ...event,
+          args: {
+            ...args,
+            user: args.user.toLowerCase(),
+            reducedAmount:
+              Number(args.reducedAmount) / Math.pow(10, currencyDecimals),
+            remainingAmount:
+              Number(args.remainingAmount) / Math.pow(10, currencyDecimals),
+            totalReward:
+              Number(args.totalReward) / Math.pow(10, rewardTokenDecimals),
+            userReward:
+              Number(args.userReward) / Math.pow(10, rewardTokenDecimals),
+            treasuryReward:
+              Number(args.treasuryReward) / Math.pow(10, rewardTokenDecimals),
+            rewardedAmount:
+              Number(args.rewardedAmount) / Math.pow(10, rewardTokenDecimals),
+            weight: Number(args.weight),
+            tokenId: Number(args.tokenId),
+            lossAmount:
+              Number(args.lossAmount) / Math.pow(10, currencyDecimals),
+            price: Number(args.price) / Math.pow(10, this.priceDecimals),
+            loss: Number(args.loss) / Math.pow(10, currencyDecimals),
+          },
+        };
+
+      case "CurrencyBorrowed":
+      case "CurrencyRepaid":
+        return {
+          ...event,
+          args: {
+            ...args,
+            amount: Number(args.amount) / Math.pow(10, currencyDecimals),
+            borrower: args.borrower.toLowerCase(),
+          },
+        };
+
+      case "PriceUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            oldPrice: Number(args.oldPrice) / Math.pow(10, this.priceDecimals),
+            newPrice: Number(args.newPrice) / Math.pow(10, this.priceDecimals),
+            requiredReward:
+              Number(args.requiredReward) / Math.pow(10, rewardTokenDecimals),
+          },
+        };
+
+      case "TotalAmountUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            newTotalAmount:
+              Number(args.newTotalAmount) / Math.pow(10, currencyDecimals),
+          },
+        };
+
+      case "CurrencyUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            oldCurrency: args.oldCurrency.toLowerCase(),
+            newCurrency: args.newCurrency.toLowerCase(),
+          },
+        };
+
+      case "RewardTokenUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            oldRewardToken: args.oldRewardToken.toLowerCase(),
+            newRewardToken: args.newRewardToken.toLowerCase(),
+          },
+        };
+
+      case "ReduceEnabledUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            enabled: args.enabled,
+          },
+        };
+
+      case "TreasuryUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+            oldTreasury: args.oldTreasury.toLowerCase(),
+            newTreasury: args.newTreasury.toLowerCase(),
+          },
+        };
+
+      case "RewardConfigsUpdated":
+        return {
+          ...event,
+          args: {
+            ...args,
+          },
+        };
+
+      case "TotalRewardsUpdated": {
+        return {
+          ...event,
+          args: {
+            ...args,
+            oldAmount:
+              Number(args.oldAmount) / Math.pow(10, rewardTokenDecimals),
+            newAmount:
+              Number(args.newAmount) / Math.pow(10, rewardTokenDecimals),
+          },
+        };
+      }
+
+      case "TotalRewardsHarvestedUpdated": {
+        return {
+          ...event,
+          args: {
+            ...args,
+            oldAmount:
+              Number(args.oldAmount) / Math.pow(10, rewardTokenDecimals),
+            newAmount:
+              Number(args.newAmount) / Math.pow(10, rewardTokenDecimals),
+          },
+        };
+      }
+
+      default:
+        return event; // Return unformatted args for unknown events
+    }
+  };
+
+  estimateUnrealizedPnl({
+    price,
+    entryPrice,
+    initAmount,
+    remainingAmount,
+  }: {
+    price: number;
+    entryPrice: number;
+    initAmount: number;
+    remainingAmount: number;
+  }): {
+    pnl: number;
+    pnlPercentage: number;
+  } {
+    // Calculate PNL using the formula: amount * (price - entryPrice) / BASE_PRICE + rewardedAmount - lossAmount
+    const pnl = (remainingAmount * (price - entryPrice)) / this.BASE_PRICE;
+
+    // Calculate PNL percentage relative to the initial amount
+    const pnlPercentage = (pnl / initAmount) * 100;
+
+    return {
+      pnl,
+      pnlPercentage,
+    };
+  }
+
+  estReducePosition({
+    amount,
+    price,
+    entryPrice,
+    openedAt,
+    configs = [],
+  }: {
+    amount: number;
+    price: number;
+    entryPrice: number;
+    openedAt: number;
+    configs: Array<{ weight: number; duration: number }>;
+  }): {
+    amount: number;
+    totalReward: number;
+    userReward: number;
+    treasuryReward: number;
+    weight: number;
+  } {
+    const BASE_PRICE = this.BASE_PRICE;
+    const BASE_WEIGHT = this.BASE_WEIGHT;
+    let returnAmount = amount;
+    let totalReward = 0;
+    let userReward = 0;
+    let treasuryReward = 0;
+    let weight = 0;
+
+    // If price is less than entry price, user is at a loss
+    if (price < entryPrice) {
+      // Calculate loss amount
+      const priceDiff = entryPrice - price;
+      const loss = (amount * priceDiff) / 100;
+      returnAmount = amount - loss;
+
+      // No rewards when at a loss
+      return {
+        amount: returnAmount,
+        totalReward: 0,
+        userReward: 0,
+        treasuryReward: 0,
+        weight: 0,
+      };
+    }
+
+    // Calculate rewards if price is higher than entry price
+    if (price >= entryPrice) {
+      totalReward = (amount * (price - entryPrice)) / BASE_PRICE;
+
+      // Get weight based on duration
+      const duration = Math.floor(Date.now() / 1000) - openedAt;
+      weight = this.getRewardWeight(duration, configs);
+
+      // Calculate user and treasury rewards based on weight
+      userReward = totalReward * weight;
+      treasuryReward = totalReward - userReward;
+    }
+
+    return {
+      amount: returnAmount,
+      totalReward,
+      userReward,
+      treasuryReward,
+      weight,
+    };
+  }
+
+  estReducePositions({
+    positions,
+    price,
+    configs = [],
+  }: {
+    positions: Array<{
+      amount: number;
+      entryPrice: number;
+      openedAt: number;
+    }>;
+    price: number;
+    configs: Array<{ weight: number; duration: number }>;
+  }): {
+    amount: number;
+    totalReward: number;
+    userReward: number;
+    treasuryReward: number;
+  } {
+    const results = positions.map((position) =>
+      this.estReducePosition({
+        amount: position.amount,
+        price,
+        entryPrice: position.entryPrice,
+        openedAt: position.openedAt,
+        configs,
+      })
+    );
+
+    return results.reduce(
+      (acc, curr) => ({
+        amount: acc.amount + curr.amount,
+        totalReward: acc.totalReward + curr.totalReward,
+        userReward: acc.userReward + curr.userReward,
+        treasuryReward: acc.treasuryReward + curr.treasuryReward,
+      }),
+      { amount: 0, totalReward: 0, userReward: 0, treasuryReward: 0 }
+    );
+  }
+
+  private getRewardWeight(
+    duration: number,
+    configs: Array<{ weight: number; duration: number }>
+  ): number {
+    return getRewardWeight(duration, configs);
+  }
+
+  estimateUnrealizedPnls({
+    price,
+    positions,
+  }: {
+    price: number;
+    positions: Array<{
+      entryPrice: number;
+      initAmount: number;
+      remainingAmount: number;
+      rewardedAmount: number;
+      lossAmount: number;
+    }>;
+  }): {
+    totalInitAmount: number;
+    totalRemainingAmount: number;
+    totalRewardedAmount: number;
+    totalLossAmount: number;
+    totalPnl: number;
+  } {
+    return positions.reduce(
+      (acc, position) => {
+        const { pnl } = this.estimateUnrealizedPnl({
+          price,
+          ...position,
+        });
+
+        return {
+          totalInitAmount: acc.totalInitAmount + position.initAmount,
+          totalRemainingAmount:
+            acc.totalRemainingAmount + position.remainingAmount,
+          totalRewardedAmount:
+            acc.totalRewardedAmount + position.rewardedAmount,
+          totalLossAmount: acc.totalLossAmount + position.lossAmount,
+          totalPnl: acc.totalPnl + pnl,
+        };
+      },
+      {
+        totalInitAmount: 0,
+        totalRemainingAmount: 0,
+        totalRewardedAmount: 0,
+        totalLossAmount: 0,
+        totalPnl: 0,
+      }
+    );
+  }
+}
+