@kasufinance/kasu-sdk 1.0.4 → 2.2.0

package/src/services/Locking/locking.ts

@@ -57,29 +57,37 @@ import {
 
 export class KSULocking {
     private readonly _contractAbi: IKSULockingAbi;
-    private readonly _kasuToken: IERC20MetadataAbi;
+    private readonly _kasuToken: IERC20MetadataAbi | null;
     private readonly _kasuBonusAddress: string;
     private readonly _graph: GraphQLClient;
     private readonly _userManagerAbi: IUserManagerAbi;
     private readonly _systemVariablesAbi: ISystemVariablesAbi;
     private readonly _ksuPriceAbi: IKsuPriceAbi;
     private readonly _userLoyaltyRewardsAbi: IUserLoyaltyRewardsAbi;
+    private readonly _isLiteDeployment: boolean;
     private readonly apyBonuses: number[] = [0, 0.001, 0.002];
-    /**
-     *
-     */
+
     constructor(
         private _kasuConfig: SdkConfig,
         signerOrProvider: Signer | Provider,
     ) {
+        this._isLiteDeployment = _kasuConfig.isLiteDeployment;
+
         this._contractAbi = IKSULockingAbi__factory.connect(
             _kasuConfig.contracts.IKSULocking,
             signerOrProvider,
         );
-        this._kasuToken = IERC20MetadataAbi__factory.connect(
-            _kasuConfig.contracts.KSUToken,
-            signerOrProvider,
-        );
+
+        // Only initialize KSU token contract if not a Lite deployment and address is provided
+        if (!this._isLiteDeployment && _kasuConfig.contracts.KSUToken) {
+            this._kasuToken = IERC20MetadataAbi__factory.connect(
+                _kasuConfig.contracts.KSUToken,
+                signerOrProvider,
+            );
+        } else {
+            this._kasuToken = null;
+        }
+
         this._userManagerAbi = IUserManagerAbi__factory.connect(
             _kasuConfig.contracts.UserManager,
             signerOrProvider,
@@ -100,10 +108,20 @@ export class KSULocking {
         );
     }
 
+    /**
+     * Check if this is a Lite deployment (no KSU token functionality)
+     */
+    get isLiteDeployment(): boolean {
+        return this._isLiteDeployment;
+    }
+
     async lockKSUTokens(
         amount: BigNumber,
         lockPeriod: BigNumber,
     ): Promise<ContractTransaction> {
+        if (this._isLiteDeployment) {
+            throw new Error('Locking is not available on Lite deployments');
+        }
         return this._contractAbi.lock(amount, lockPeriod);
     }
 
@@ -112,6 +130,10 @@ export class KSULocking {
         lockPeriod: number,
         permit: RSVDeadlineValue,
     ): Promise<ContractTransaction> {
+        if (this._isLiteDeployment) {
+            throw new Error('Locking is not available on Lite deployments');
+        }
+
         const amountBN = BigNumber.from(amount);
         const lockPeriodBN = BigNumber.from(lockPeriod);
 
@@ -134,13 +156,27 @@ export class KSULocking {
         amount: BigNumber,
         userLockId: BigNumber,
     ): Promise<ContractTransaction> {
+        if (this._isLiteDeployment) {
+            throw new Error('Locking is not available on Lite deployments');
+        }
         return this._contractAbi.unlock(amount, userLockId);
     }
 
     async claimFees(): Promise<ContractTransaction> {
+        if (this._isLiteDeployment) {
+            throw new Error('Fee claiming is not available on Lite deployments');
+        }
         return await this._contractAbi.claimFees();
     }
+
     async lockDetails(lockPeriod: BigNumber): Promise<LockPeriodInterface> {
+        if (this._isLiteDeployment) {
+            return {
+                rKsuMultiplier: 0,
+                ksuBonusMultiplier: 0,
+                isActive: false,
+            };
+        }
         const result = await this._contractAbi.lockDetails(lockPeriod);
         return {
             rKsuMultiplier: result[0].toNumber(),
@@ -150,6 +186,9 @@ export class KSULocking {
     }
 
     async userTotalDeposits(userAddress: string): Promise<BigNumber> {
+        if (this._isLiteDeployment) {
+            return BigNumber.from(0);
+        }
         return await this._contractAbi.userTotalDeposits(userAddress);
     }
 
@@ -158,7 +197,7 @@ export class KSULocking {
         KSULocked: number,
         lockPeriod: BigNumber,
     ): Promise<number> {
-        if (KSULocked === 0) {
+        if (this._isLiteDeployment || KSULocked === 0) {
             return 0;
         }
 
@@ -232,22 +271,26 @@ export class KSULocking {
     }
 
     async getUserLocks(userAddress: string): Promise<UserLock[]> {
+        if (this._isLiteDeployment) {
+            return [];
+        }
+
         const result: GQLUserLocks = await this._graph.request(userLocksQuery, {
             userAddress: userAddress.toLowerCase(),
         });
         const resultPromises = result.userLocks.map(async (userLock) => {
             const [, id] = userLock.id.split('-');
-            const rKSUtoUSDCRatio = await this.getRKSUvsUSDCRatio(
+            const rKSUtoStableRatio = await this.getRKSUvsStableRatio(
                 userLock.rKSUAmount,
                 userAddress,
             );
             const loyaltyStatus =
-                this.getLoyaltyLevelAndApyBonusFromRatio(rKSUtoUSDCRatio);
+                this.getLoyaltyLevelAndApyBonusFromRatio(rKSUtoStableRatio);
             return {
                 id: BigNumber.from(id),
                 lockedAmount: userLock.ksuAmount,
                 rKSUAmount: userLock.rKSUAmount,
-                rKSUtoUSDCRatio: rKSUtoUSDCRatio,
+                rKSUtoStableRatio: rKSUtoStableRatio,
                 apyBonus: loyaltyStatus.apyBonus,
                 loyaltyLevel: loyaltyStatus.loyaltyLevel,
                 startTime: parseFloat(userLock.startTimestamp),
@@ -261,8 +304,14 @@ export class KSULocking {
     }
 
     async getUserBonusData(userAddress: string): Promise<UserBonusData> {
-        // TODO this userLocks query is kinda bad -> change to userLocksDepositInfo as u never need user locks by themselves
-        // whole function takes between 500 - 800ms
+        if (this._isLiteDeployment) {
+            return {
+                ksuBonusAndRewards: '0',
+                ksuBonusAndRewardsLifetime: '0',
+                protocolFeesEarned: '0',
+                totalLockedAmount: '0',
+            };
+        }
 
         const DECIMALS = 18;
 
@@ -318,22 +367,31 @@ export class KSULocking {
         };
     }
 
-    getLoyaltyLevelAndApyBonusFromRatio(rKSUtoUSDCRatio: number): {
+    getLoyaltyLevelAndApyBonusFromRatio(rKSUtoStableRatio: number): {
         loyaltyLevel: number;
         apyBonus: number;
     } {
-        if (rKSUtoUSDCRatio < 0.01) {
+        // On Lite deployments, always return level 0 with no bonus
+        if (this._isLiteDeployment) {
+            return { loyaltyLevel: 0, apyBonus: 0 };
+        }
+
+        if (rKSUtoStableRatio < 0.01) {
             return { loyaltyLevel: 0, apyBonus: this.apyBonuses[0] };
-        } else if (rKSUtoUSDCRatio < 0.05) {
+        } else if (rKSUtoStableRatio < 0.05) {
             return { loyaltyLevel: 1, apyBonus: this.apyBonuses[1] };
         }
         return { loyaltyLevel: 2, apyBonus: this.apyBonuses[2] };
     }
 
-    async getRKSUvsUSDCRatio(
+    async getRKSUvsStableRatio(
         rKSUAmount: string,
         userAddress: string,
     ): Promise<number> {
+        if (this._isLiteDeployment) {
+            return 0;
+        }
+
         const [depositedAmount, pendingAmount]: [BigNumber, BigNumber] =
             await this._userManagerAbi.userTotalPendingAndActiveDepositedAmountForCurrentEpoch(
                 userAddress,
@@ -345,18 +403,31 @@ export class KSULocking {
             18,
         );
 
-        const totalUserUsdcAmount =
+        const totalUserStableAmount =
             depositedAmount.toNumber() + pendingAmount.toNumber();
 
-        const rKSUInUSDC = rKSUAmountBignumber
+        // Convert rKSU value to stable asset units: rKSU * ksuPrice / 1e18 / 1e(18 - stableDecimals)
+        const decimalDiff = 18 - this._kasuConfig.stableAssetDecimals;
+        const rKSUInStable = rKSUAmountBignumber
             .mul(ksuPrice)
             .div(ethers.utils.parseUnits('1', 18))
-            .div(ethers.utils.parseUnits('1', 12));
+            .div(ethers.utils.parseUnits('1', decimalDiff));
+
+        return rKSUInStable.toNumber() / totalUserStableAmount;
+    }
 
-        return rKSUInUSDC.toNumber() / totalUserUsdcAmount;
+    /** @deprecated Use `getRKSUvsStableRatio` instead. */
+    async getRKSUvsUSDCRatio(
+        rKSUAmount: string,
+        userAddress: string,
+    ): Promise<number> {
+        return this.getRKSUvsStableRatio(rKSUAmount, userAddress);
     }
 
     async getClaimableRewards(userAddress: string): Promise<BigNumber> {
+        if (this._isLiteDeployment) {
+            return BigNumber.from(0);
+        }
         const result = await this._contractAbi.rewards(userAddress);
         return result;
     }
@@ -364,6 +435,7 @@ export class KSULocking {
     async getKasuTokenPrice(): Promise<{ price: BigNumber; decimals: number }> {
         const decimals = 18;
 
+        // Price can still be queried on Lite deployments (set to 0 or configured value)
         return Promise.resolve({
             price: await this._ksuPriceAbi.ksuTokenPrice(),
             decimals,
@@ -387,6 +459,10 @@ export class KSULocking {
         rewardDecimals: number,
         claimableRewards?: BigNumber,
     ): Promise<BigNumber> {
+        if (this._isLiteDeployment) {
+            return BigNumber.from(0);
+        }
+
         const result: GQLClaimedFeesForAddress = await this._graph.request(
             claimedFeesQuery,
             {
@@ -408,6 +484,10 @@ export class KSULocking {
         bonusMultiplier: number,
         bonusTokensLeft: BigNumber,
     ): BigNumber {
+        if (this._isLiteDeployment) {
+            return BigNumber.from(0);
+        }
+
         const bonusMultiplierBN = ethers.utils.parseUnits(
             bonusMultiplier.toFixed(2),
             2,
@@ -422,6 +502,10 @@ export class KSULocking {
     }
 
     async getUserStakedKsu(userAddress: string): Promise<string> {
+        if (this._isLiteDeployment) {
+            return '0';
+        }
+
         const result: GQLStakedAmountForAddress = await this._graph.request(
             userStakedKsuQuery,
             {
@@ -435,6 +519,10 @@ export class KSULocking {
     }
 
     async getUserEarnedrKsu(userAddress: string): Promise<string> {
+        if (this._isLiteDeployment) {
+            return '0';
+        }
+
         const result: GQLEarnedRKsuForAddress = await this._graph.request(
             userEarnedrKsuQuery,
             {
@@ -449,6 +537,10 @@ export class KSULocking {
     }
 
     async getUserTotalBonusAmount(userAddress: string): Promise<string> {
+        if (this._isLiteDeployment) {
+            return '0';
+        }
+
         const result: GQLTotalBonusAmountForAddress = await this._graph.request(
             userTotalBonusAmountQuery,
             {
@@ -465,7 +557,14 @@ export class KSULocking {
     async getLockingRewards(
         userAddress: string,
     ): Promise<{ claimableRewards: string; lifeTimeRewards: string }> {
-        const rewardDecimals = 6;
+        if (this._isLiteDeployment) {
+            return {
+                claimableRewards: '0',
+                lifeTimeRewards: '0',
+            };
+        }
+
+        const rewardDecimals = this._kasuConfig.stableAssetDecimals;
 
         const claimableRewards = await this.getClaimableRewards(userAddress);
 
@@ -486,18 +585,26 @@ export class KSULocking {
     }
 
     async getAvailableKsuBonus(): Promise<string> {
-        const amount = await this._kasuToken.balanceOf(this._kasuBonusAddress);
+        if (this._isLiteDeployment || !this._kasuToken) {
+            return '0';
+        }
 
+        const amount = await this._kasuToken.balanceOf(this._kasuBonusAddress);
         return formatEther(amount);
     }
 
     async getUserKsuBalance(userAddress: string): Promise<string> {
+        if (this._isLiteDeployment || !this._kasuToken) {
+            return '0';
+        }
+
         const balance = await this._kasuToken.balanceOf(
             userAddress.toLowerCase(),
         );
 
         return formatEther(balance);
     }
+
     async getNextEpochDate(): Promise<EpochTimeStamp> {
         return (
             await this._systemVariablesAbi.nextEpochStartTimestamp()
@@ -526,6 +633,10 @@ export class KSULocking {
     }
 
     async getActiveLockPeriods(): Promise<LockPeriod[]> {
+        if (this._isLiteDeployment) {
+            return [];
+        }
+
         const data: GQLGetLockingPeriods =
             await this._graph.request(lockingPeriodsQuery);
         return data.lockPeriods;
@@ -535,7 +646,12 @@ export class KSULocking {
         return '10.00';
     }
 
-    getProjectedUSDC(): string {
+    getProjectedStableAmount(): string {
         return '20.00';
     }
+
+    /** @deprecated Use `getProjectedStableAmount` instead. */
+    getProjectedUSDC(): string {
+        return this.getProjectedStableAmount();
+    }
 }

package/src/services/Locking/types.ts

@@ -25,7 +25,7 @@ export interface UserLock {
     id: BigNumber;
     lockedAmount: string;
     rKSUAmount: string;
-    rKSUtoUSDCRatio: number;
+    rKSUtoStableRatio: number;
     apyBonus: number;
     startTime: EpochTimeStamp;
     endTime: EpochTimeStamp;

package/src/services/Portfolio/portfolio.ts

@@ -11,6 +11,7 @@ import {
     IUserLoyaltyRewardsAbi__factory,
 } from '../../contracts';
 import { SdkConfig } from '../../sdk-config';
+import { isLiteDeployment } from '../../utils/deployment-mode';
 import { DataService } from '../DataService/data-service';
 import {
     getAllTrancheConfigurationsQuery,
@@ -53,8 +54,9 @@ export class Portfolio {
     private _userLoyaltyRewardsAbi: ReturnType<
         typeof IUserLoyaltyRewardsAbi__factory.connect
     >;
-    private _kasuNftContract: IKasuNFTsAbi;
+    private _kasuNftContract: IKasuNFTsAbi | null;
     readonly _signerOrProvider: Signer | Provider;
+    private _isLiteDeployment: boolean;
 
     constructor(
         private _kasuConfig: SdkConfig,
@@ -75,10 +77,13 @@ export class Portfolio {
             _kasuConfig,
             signerOrProvider,
         );
-        this._kasuNftContract = IKasuNFTsAbi__factory.connect(
-            _kasuConfig.contracts.KasuNFTs,
-            signerOrProvider,
-        );
+        this._isLiteDeployment = isLiteDeployment(_kasuConfig);
+        this._kasuNftContract = _kasuConfig.contracts.KasuNFTs
+            ? IKasuNFTsAbi__factory.connect(
+                  _kasuConfig.contracts.KasuNFTs,
+                  signerOrProvider,
+              )
+            : null;
         this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
     }
 
@@ -155,8 +160,8 @@ export class Portfolio {
     }
 
     /**
-     * Calculate the user's weekly protocol fee share (USDC) given tranche balances/configs,
-     * system variables and locking summary. All inputs are expected to be pre-fetched.
+     * Calculate the user's weekly protocol fee share (in stable asset units) given tranche
+     * balances/configs, system variables and locking summary. All inputs are expected to be pre-fetched.
      */
     public calculateWeeklyProtocolFees(params: {
         trancheBalances: TrancheSubgraphResult;
@@ -240,13 +245,13 @@ export class Portfolio {
 
         if (totalUserDeposits.isZero()) return 0;
 
-        const rKSUtoUSDCRatio = await this._lockingService.getRKSUvsUSDCRatio(
+        const rKSUtoStableRatio = await this._lockingService.getRKSUvsStableRatio(
             userRksuAmount,
             userAddress,
         );
         const { loyaltyLevel } =
             this._lockingService.getLoyaltyLevelAndApyBonusFromRatio(
-                rKSUtoUSDCRatio,
+                rKSUtoStableRatio,
             );
 
         const loyaltyRewardRate =
@@ -284,15 +289,20 @@ export class Portfolio {
             },
             protocolFees: {
                 claimableBalance: {
-                    usdcAmount: lockingRewards.claimableRewards,
+                    stableAmount: lockingRewards.claimableRewards,
                 },
-                lifeTime: { usdcAmount: lockingRewards.lifeTimeRewards },
+                lifeTime: { stableAmount: lockingRewards.lifeTimeRewards },
             },
             ksuLaunchBonus: { lifeTime: { ksuAmount: ksuLaunchBonus } },
         };
     }
 
     async getUserNfts(userAddress: string): Promise<number[]> {
+        // NFTs are not available on Lite deployments
+        if (this._isLiteDeployment || !this._kasuNftContract) {
+            return [];
+        }
+
         const usernfts = await this._kasuNftContract.tokensOfOwner(userAddress);
 
         return usernfts.map((nft) => nft.toNumber());

package/src/services/Portfolio/types.ts

@@ -16,10 +16,10 @@ export interface PortfolioRewards {
     };
     protocolFees: {
         claimableBalance: {
-            usdcAmount: string;
+            stableAmount: string;
         };
         lifeTime: {
-            usdcAmount: string;
+            stableAmount: string;
         };
     };
 }

package/src/services/UserLending/user-lending.ts

@@ -287,17 +287,17 @@ export class UserLending {
         );
     }
 
-    async requestWithdrawalInUSDC(
+    async requestWithdrawalInAsset(
         lendingPool: string,
         tranche: string,
-        usdcAmount: BigNumberish,
+        assetAmount: BigNumberish,
     ): Promise<ContractTransaction> {
         const trancheContract: ILendingPoolTrancheAbi =
             ILendingPoolTrancheAbi__factory.connect(
                 tranche,
                 this._signerOrProvider,
             );
-        const shareAmount = await trancheContract.convertToShares(usdcAmount);
+        const shareAmount = await trancheContract.convertToShares(assetAmount);
 
         return await this._lendingPoolManagerAbi.requestWithdrawal(
             lendingPool,
@@ -306,6 +306,15 @@ export class UserLending {
         );
     }
 
+    /** @deprecated Use `requestWithdrawalInAsset` instead. */
+    async requestWithdrawalInUSDC(
+        lendingPool: string,
+        tranche: string,
+        amount: BigNumberish,
+    ): Promise<ContractTransaction> {
+        return this.requestWithdrawalInAsset(lendingPool, tranche, amount);
+    }
+
     async requestWithdrawalMax(
         lendingPool: string,
         tranche: string,
@@ -775,7 +784,7 @@ export class UserLending {
                 return {
                     poolId: lendingPool.id,
                     yieldEarned:
-                        parseFloat(ethers.utils.formatUnits(balance, 6)) -
+                        parseFloat(ethers.utils.formatUnits(balance, this._kasuConfig.stableAssetDecimals)) -
                         parseFloat(totalAcceptedDeposits) -
                         -parseFloat(totalAcceptedWithdrawnAmount),
                     balance,