aiia-vault-sdk 1.0.1

package/dist/TradingVault.d.ts

@@ -0,0 +1,175 @@
+import { ethers } from "ethers";
+import { TradingVault } from "./contracts/TradingVault";
+import { AnyEvent, AnyEventRaw } from "./types";
+import { type SendTransactionMutateAsync } from "@wagmi/core/query";
+import { Config } from "@wagmi/core/dist/types/createConfig";
+export declare class TradingVaultSDK {
+    name: string;
+    private contract;
+    private providers;
+    private _currency;
+    private _rewardToken;
+    private _currencyDecimals;
+    private _rewardTokenDecimals;
+    private priceDecimals;
+    private contractAddress;
+    private isBootstrapped;
+    private configs;
+    private BASE_WEIGHT;
+    private BASE_PRICE;
+    constructor(rpcUrls: string | string[], contractAddress?: string);
+    private getRandomProvider;
+    private getContractWithRandomProvider;
+    bootstrap(): Promise<void>;
+    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;
+        };
+    }>;
+    buildCreatePositionTx(amount: number): Promise<ethers.ContractTransaction>;
+    buildCreatePositionForUserTx(user: string, amount: number): Promise<ethers.ContractTransaction>;
+    buildReducePositionTx(tokenId: bigint, amount: number): Promise<ethers.ContractTransaction>;
+    buildReducePositionsTx(tokenIds: bigint[], amounts: number[]): Promise<ethers.ContractTransaction>;
+    buildBorrowCurrencyTx(amount: number): Promise<ethers.ContractTransaction>;
+    buildRepayCurrencyTx(amount: number): Promise<ethers.ContractTransaction>;
+    buildSetPriceTx(newPrice: number, rewardAmount: number): Promise<ethers.ContractTransaction>;
+    buildClaimERC20Tx(token: string, amount: number): Promise<ethers.ContractTransaction>;
+    buildCreatePositionTxRaw(amount: bigint): Promise<ethers.ContractTransaction>;
+    buildCreatePositionForUserTxRaw(user: string, amount: bigint): Promise<ethers.ContractTransaction>;
+    buildReducePositionTxRaw(tokenId: bigint, amount: bigint): Promise<ethers.ContractTransaction>;
+    buildReducePositionsTxRaw(tokenIds: bigint[], amounts: bigint[]): Promise<ethers.ContractTransaction>;
+    buildBorrowCurrencyTxRaw(amount: bigint): Promise<ethers.ContractTransaction>;
+    buildRepayCurrencyTxRaw(amount: bigint): Promise<ethers.ContractTransaction>;
+    buildSetPriceTxRaw(newPrice: bigint, rewardAmount: bigint): Promise<ethers.ContractTransaction>;
+    buildSetCurrencyTxRaw(currency: string): Promise<ethers.ContractTransaction>;
+    buildSetRewardTokenTxRaw(rewardToken: string): Promise<ethers.ContractTransaction>;
+    buildSetTreasuryTxRaw(treasury: string): Promise<ethers.ContractTransaction>;
+    buildUpdateRewardConfigsTxRaw(configs: TradingVault.RewardConfigStruct[]): Promise<ethers.ContractTransaction>;
+    buildSetReduceEnabledTxRaw(enabled: boolean): Promise<ethers.ContractTransaction>;
+    buildClaimERC20TxRaw(token: string, amount: bigint): Promise<ethers.ContractTransaction>;
+    buildApproveERC20Tx(tokenAddress: string, spender: string, amount: number): Promise<ethers.ContractTransaction>;
+    buildApproveERC20TxRaw(tokenAddress: string, spender: string, amount: bigint): Promise<ethers.ContractTransaction>;
+    getAllowanceRaw(tokenAddress: string, owner: string, spender: string): Promise<bigint>;
+    getAllowance(tokenAddress: string, owner: string, spender: string): Promise<number>;
+    buildGrantOperatorRoleTxRaw(operator: string): Promise<ethers.ContractTransaction>;
+    getPrice(): Promise<number>;
+    getPriceRaw(): Promise<bigint>;
+    getCurrency(): Promise<string>;
+    getRewardToken(): Promise<string>;
+    getTreasury(): Promise<string>;
+    getTotalAmount(): Promise<number>;
+    getTotalAmountRaw(): Promise<bigint>;
+    getTotalBorrowed(): Promise<number>;
+    getTotalBorrowedRaw(): Promise<bigint>;
+    isReduceEnabled(): Promise<boolean>;
+    getPosition(tokenId: bigint): Promise<{
+        remainingAmount: number;
+        entryPrice: number;
+        outPrice: number;
+        openedAt: number;
+        closedAt: number;
+        rewardedAmount: number;
+        lossAmount: number;
+        initAmount: number;
+    }>;
+    getPositionRaw(tokenId: bigint): Promise<[bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint] & {
+        entryPrice: bigint;
+        outPrice: bigint;
+        remainingAmount: bigint;
+        initAmount: bigint;
+        openedAt: bigint;
+        closedAt: bigint;
+        rewardedAmount: bigint;
+        lossAmount: bigint;
+    }>;
+    getRewardConfig(index: number): Promise<[bigint, bigint] & {
+        weight: bigint;
+        duration: bigint;
+    }>;
+    getRewardConfigsLength(): Promise<bigint>;
+    getCurrencyDecimals(): Promise<number>;
+    getRewardTokenDecimals(): Promise<number>;
+    getContractAddress(): string;
+    getConfigs(): Array<{
+        weight: number;
+        duration: number;
+    }>;
+    getAllEvents(fromBlock: number, toBlock: number): Promise<AnyEventRaw[]>;
+    streamEvents(fromBlock: number, onEvent: (event: AnyEvent) => Promise<void>, saveLatestBlock: (blockNumber: number) => Promise<void>, batchSize?: number, sleepTime?: number): Promise<void>;
+    formatEventArgs: (event: AnyEventRaw) => AnyEvent;
+    estimateUnrealizedPnl({ price, entryPrice, initAmount, remainingAmount, }: {
+        price: number;
+        entryPrice: number;
+        initAmount: number;
+        remainingAmount: number;
+    }): {
+        pnl: number;
+        pnlPercentage: number;
+    };
+    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;
+    };
+    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;
+    };
+    private getRewardWeight;
+    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;
+    };
+}

package/dist/TradingVault.js

@@ -0,0 +1,521 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingVaultSDK = void 0;
+const ethers_1 = require("ethers");
+const TradingVault_json_1 = __importDefault(require("./abis/TradingVault.json"));
+const contracts_json_1 = __importDefault(require("./contracts.json"));
+const utils_1 = require("./utils");
+class TradingVaultSDK {
+    constructor(rpcUrls, contractAddress) {
+        this.name = "TradingVault";
+        this._currency = null;
+        this._rewardToken = null;
+        this._currencyDecimals = null;
+        this._rewardTokenDecimals = null;
+        this.priceDecimals = 6;
+        this.isBootstrapped = false;
+        this.configs = [];
+        this.BASE_WEIGHT = 10000;
+        this.BASE_PRICE = 100;
+        this.formatEventArgs = (event) => {
+            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
+            }
+        };
+        // 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_1.ethers.JsonRpcProvider(rpc));
+        // Get a random provider for initial setup
+        const initialProvider = (0, utils_1.getRandomProvider)(this.providers);
+        // Determine contract address based on RPC URL if not provided
+        this.contractAddress = (0, utils_1.resolveContractAddress)(rpcArray[0], this.name, contracts_json_1.default, contractAddress);
+        // Initialize contract with initial provider
+        this.contract = new ethers_1.ethers.Contract(this.contractAddress, TradingVault_json_1.default.abi, initialProvider);
+    }
+    getRandomProvider() {
+        return (0, utils_1.getRandomProvider)(this.providers);
+    }
+    getContractWithRandomProvider() {
+        return new ethers_1.ethers.Contract(this.contractAddress, TradingVault_json_1.default.abi, this.getRandomProvider());
+    }
+    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) => (0, utils_1.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, wallet, callbacks = {}) {
+        return (0, utils_1.signAndSendTransaction)(tx, wallet, () => this.getRandomProvider(), callbacks);
+    }
+    // Transaction builders
+    async buildCreatePositionTx(amount) {
+        const decimals = await this.getCurrencyDecimals();
+        const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+        return this.buildCreatePositionTxRaw(amountBigInt);
+    }
+    async buildCreatePositionForUserTx(user, amount) {
+        const decimals = await this.getCurrencyDecimals();
+        const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+        return this.buildCreatePositionForUserTxRaw(user, amountBigInt);
+    }
+    async buildReducePositionTx(tokenId, amount) {
+        const decimals = await this.getCurrencyDecimals();
+        const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+        return this.buildReducePositionTxRaw(tokenId, amountBigInt);
+    }
+    async buildReducePositionsTx(tokenIds, amounts) {
+        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) {
+        const decimals = await this.getCurrencyDecimals();
+        const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+        return this.buildBorrowCurrencyTxRaw(amountBigInt);
+    }
+    async buildRepayCurrencyTx(amount) {
+        const decimals = await this.getCurrencyDecimals();
+        const amountBigInt = BigInt(Math.floor(amount * Math.pow(10, decimals)));
+        return this.buildRepayCurrencyTxRaw(amountBigInt);
+    }
+    async buildSetPriceTx(newPrice, rewardAmount) {
+        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, amount) {
+        const tokenContract = new ethers_1.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) {
+        const tx = await this.contract.createPosition.populateTransaction(amount);
+        return tx;
+    }
+    async buildCreatePositionForUserTxRaw(user, amount) {
+        const tx = await this.contract.createPositionForUser.populateTransaction(user, amount);
+        return tx;
+    }
+    async buildReducePositionTxRaw(tokenId, amount) {
+        const tx = await this.contract.reducePosition.populateTransaction(tokenId, amount);
+        return tx;
+    }
+    async buildReducePositionsTxRaw(tokenIds, amounts) {
+        const tx = await this.contract.reducePositions.populateTransaction(tokenIds, amounts);
+        return tx;
+    }
+    async buildBorrowCurrencyTxRaw(amount) {
+        const tx = await this.contract.borrowCurrency.populateTransaction(amount);
+        return tx;
+    }
+    async buildRepayCurrencyTxRaw(amount) {
+        const tx = await this.contract.repayCurrency.populateTransaction(amount);
+        return tx;
+    }
+    async buildSetPriceTxRaw(newPrice, rewardAmount) {
+        const tx = await this.contract.setPrice.populateTransaction(newPrice, rewardAmount);
+        return tx;
+    }
+    async buildSetCurrencyTxRaw(currency) {
+        this._currency = null; // Reset cache when currency is about to change
+        const tx = await this.contract.setCurrency.populateTransaction(currency);
+        return tx;
+    }
+    async buildSetRewardTokenTxRaw(rewardToken) {
+        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) {
+        const tx = await this.contract.setTreasury.populateTransaction(treasury);
+        return tx;
+    }
+    async buildUpdateRewardConfigsTxRaw(configs) {
+        const tx = await this.contract.updateRewardConfigs.populateTransaction(configs);
+        return tx;
+    }
+    async buildSetReduceEnabledTxRaw(enabled) {
+        const tx = await this.contract.setReduceEnabled.populateTransaction(enabled);
+        return tx;
+    }
+    async buildClaimERC20TxRaw(token, amount) {
+        const tx = await this.contract.claimERC20.populateTransaction(token, amount);
+        return tx;
+    }
+    async buildApproveERC20Tx(tokenAddress, spender, amount) {
+        const tokenContract = new ethers_1.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, spender, amount) {
+        return await (0, utils_1.buildApproveERC20Tx)(tokenAddress, spender, amount, this.getRandomProvider());
+    }
+    async getAllowanceRaw(tokenAddress, owner, spender) {
+        return await (0, utils_1.getTokenAllowance)(tokenAddress, owner, spender, this.getRandomProvider());
+    }
+    async getAllowance(tokenAddress, owner, spender) {
+        const [allowanceRaw, decimals] = await Promise.all([
+            this.getAllowanceRaw(tokenAddress, owner, spender),
+            (0, utils_1.getTokenDecimals)(tokenAddress, this.getRandomProvider()),
+        ]);
+        return Number(allowanceRaw) / Math.pow(10, decimals);
+    }
+    async buildGrantOperatorRoleTxRaw(operator) {
+        const tx = await this.contract.grantOperatorRole.populateTransaction(operator);
+        return tx;
+    }
+    // Read methods
+    async getPrice() {
+        const priceRaw = await this.getPriceRaw();
+        const decimals = this.priceDecimals;
+        return Number(priceRaw) / Math.pow(10, decimals);
+    }
+    async getPriceRaw() {
+        return await this.contract.price();
+    }
+    async getCurrency() {
+        if (!this._currency) {
+            this._currency = await this.contract.currency();
+        }
+        return this._currency;
+    }
+    async getRewardToken() {
+        if (!this._rewardToken) {
+            this._rewardToken = await this.contract.rewardToken();
+        }
+        return this._rewardToken;
+    }
+    async getTreasury() {
+        return await this.contract.treasury();
+    }
+    async getTotalAmount() {
+        const totalAmountRaw = await this.getTotalAmountRaw();
+        const decimals = await this.getCurrencyDecimals();
+        return Number(totalAmountRaw) / Math.pow(10, decimals);
+    }
+    async getTotalAmountRaw() {
+        return await this.contract.totalAmount();
+    }
+    async getTotalBorrowed() {
+        const totalBorrowedRaw = await this.getTotalBorrowedRaw();
+        const decimals = await this.getCurrencyDecimals();
+        return Number(totalBorrowedRaw) / Math.pow(10, decimals);
+    }
+    async getTotalBorrowedRaw() {
+        return await this.contract.totalBorrowed();
+    }
+    async isReduceEnabled() {
+        return await this.contract.isReduceEnabled();
+    }
+    async getPosition(tokenId) {
+        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) {
+        return await this.contract.positions(tokenId);
+    }
+    async getRewardConfig(index) {
+        return await this.contract.rewardConfigs(index);
+    }
+    async getRewardConfigsLength() {
+        return await this.contract.getRewardConfigsLength();
+    }
+    async getCurrencyDecimals() {
+        if (this._currencyDecimals === null) {
+            const currency = await this.getCurrency();
+            const currencyContract = new ethers_1.ethers.Contract(currency, ["function decimals() view returns (uint8)"], this.getRandomProvider());
+            this._currencyDecimals = Number(await currencyContract.decimals());
+        }
+        return this._currencyDecimals;
+    }
+    async getRewardTokenDecimals() {
+        if (this._rewardTokenDecimals === null) {
+            const rewardToken = await this.getRewardToken();
+            const rewardTokenContract = new ethers_1.ethers.Contract(rewardToken, ["function decimals() view returns (uint8)"], this.getRandomProvider());
+            this._rewardTokenDecimals = Number(await rewardTokenContract.decimals());
+        }
+        return this._rewardTokenDecimals;
+    }
+    getContractAddress() {
+        return this.contractAddress;
+    }
+    getConfigs() {
+        return [...this.configs];
+    }
+    async getAllEvents(fromBlock, toBlock) {
+        await this.bootstrap();
+        return (0, utils_1.getAllEvents)(this.contract, () => this.getRandomProvider(), () => this.getContractWithRandomProvider(), fromBlock, toBlock);
+    }
+    async streamEvents(fromBlock, onEvent, saveLatestBlock, batchSize = 1000, sleepTime = 5000) {
+        await this.bootstrap();
+        return (0, utils_1.streamEvents)({
+            getProvider: () => this.getRandomProvider(),
+            getAllEvents: (fromBlock, toBlock) => this.getAllEvents(fromBlock, toBlock),
+            formatEvent: (event) => this.formatEventArgs(event),
+            onEvent,
+            saveLatestBlock,
+            fromBlock,
+            batchSize,
+            sleepTime,
+        });
+    }
+    estimateUnrealizedPnl({ price, entryPrice, initAmount, remainingAmount, }) {
+        // 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 = [], }) {
+        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 = [], }) {
+        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 });
+    }
+    getRewardWeight(duration, configs) {
+        return (0, utils_1.getRewardWeight)(duration, configs);
+    }
+    estimateUnrealizedPnls({ price, positions, }) {
+        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,
+        });
+    }
+}
+exports.TradingVaultSDK = TradingVaultSDK;