@kasufinance/kasu-sdk 1.0.4 → 2.1.0

package/src/services/DataService/data-service.ts

@@ -38,7 +38,6 @@ import {
     getAllTrancheConfigurationsQuery,
     getAllTranchesQuery,
     getLendingPoolWithdrawalAndDepositsQuery,
-    getPlumeTvl,
     getPoolNameQuery,
     getPoolOverviewQuery,
 } from './queries';
@@ -47,7 +46,6 @@ import {
     LendingPoolSubgraph,
     LendingPoolSubgraphReturn,
     LendingPoolWithdrawalAndDepositSubgraph,
-    PlumeSubgraphReturn,
     TrancheConfigurationSubgraphResult,
     TrancheSubgraphResult,
 } from './subgraph-types';
@@ -67,13 +65,11 @@ import {
 
 export class DataService {
     private readonly _graph: GraphQLClient;
-    private readonly _plumeGraph: GraphQLClient;
     private readonly _externalTvlAbi: KasuPoolExternalTVLAbi;
     private readonly _directus: DirectusClient<DirectusSchema> &
         AuthenticationClient<DirectusSchema> &
         RestClient<DirectusSchema>;
     private _directusPoolOverview: PoolOverviewDirectus[] | undefined;
-    private _plumeTvl = new Map<string, string>();
 
     constructor(
         private _kasuConfig: SdkConfig,
@@ -84,17 +80,39 @@ export class DataService {
             signerOrProvider,
         );
         this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
-        this._plumeGraph = new GraphQLClient(_kasuConfig.plumeSubgraphUrl);
 
-        this._directus = createDirectus<DirectusSchema>(_kasuConfig.directusUrl)
-            .with(authentication())
-            .with(rest());
+        if (_kasuConfig.directusUrl) {
+            this._directus = createDirectus<DirectusSchema>(
+                _kasuConfig.directusUrl,
+            )
+                .with(authentication())
+                .with(rest());
+        } else {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+            this._directus = null as any;
+        }
     }
 
     private getUrlFromFile(fileName: string): string {
         return `${this._kasuConfig.directusUrl}assets/${fileName}`;
     }
 
+    /**
+     * Maps a pool ID to its metadata source pool ID.
+     * Used for chains (XDC, Plume) that share Directus metadata with Base pools.
+     */
+    private getMetadataPoolId(poolId: string): string {
+        const normalizedId = poolId.toLowerCase();
+        return this._kasuConfig.poolMetadataMapping[normalizedId] ?? normalizedId;
+    }
+
+    /**
+     * Maps an array of pool IDs to their metadata source pool IDs.
+     */
+    private getMetadataPoolIds(poolIds: string[]): string[] {
+        return poolIds.map((id) => this.getMetadataPoolId(id));
+    }
+
     calculatePoolCapacity(
         poolCapacities: number[],
         poolCapacityPercentages: number[],
@@ -206,25 +224,28 @@ export class DataService {
                 epochId,
             });
 
-        if (!this._plumeTvl.size) {
-            const plumeResults: PlumeSubgraphReturn =
-                await this._plumeGraph.request(getPlumeTvl);
-
-            for (const pool of plumeResults.lendingPools) {
-                this._plumeTvl.set(pool.id, pool.balance);
-            }
-        }
-
         if (!this._directusPoolOverview) {
-            this._directusPoolOverview = await this._directus.request(
-                readItems('PoolOverview', {
-                    filter: {
-                        enabled: {
-                            _eq: true,
-                        },
-                    },
-                }),
-            );
+            if (this._kasuConfig.directusUrl) {
+                try {
+                    this._directusPoolOverview = await this._directus.request(
+                        readItems('PoolOverview', {
+                            filter: {
+                                enabled: {
+                                    _eq: true,
+                                },
+                            },
+                        }),
+                    );
+                } catch (error) {
+                    console.warn(
+                        'Directus fetch failed, falling back to on-chain data only:',
+                        error,
+                    );
+                    this._directusPoolOverview = [];
+                }
+            } else {
+                this._directusPoolOverview = [];
+            }
         }
 
         const offchainTvlMap = await this.getOffChainTvl(
@@ -233,9 +254,14 @@ export class DataService {
 
         const retn: PoolOverview[] = [];
         for (const lendingPoolSubgraph of poolOverviewResults.lendingPools) {
+            // Use metadata mapping if available (for XDC/Plume pools that share metadata with Base)
+            const metadataPoolId =
+                this._kasuConfig.poolMetadataMapping[lendingPoolSubgraph.id] ??
+                lendingPoolSubgraph.id;
+
             const lendingPoolDirectus: PoolOverviewDirectus | undefined =
                 this._directusPoolOverview.find(
-                    (r) => r.id.toLowerCase() == lendingPoolSubgraph.id,
+                    (r) => r.id.toLowerCase() === metadataPoolId,
                 );
 
             const lendingPoolConfig = lendingPoolSubgraph.configuration;
@@ -244,8 +270,12 @@ export class DataService {
                 console.warn(
                     "Couldn't find directus pool for id: ",
                     lendingPoolSubgraph.id,
+                    metadataPoolId !== lendingPoolSubgraph.id
+                        ? `(mapped from ${metadataPoolId})`
+                        : '',
                 );
-                continue;
+                // When Directus is unavailable or pool has no CMS entry,
+                // use a fallback so the pool is still returned with on-chain data.
             }
             const poolCapacities = this.calculatePoolCapacity(
                 [],
@@ -380,57 +410,56 @@ export class DataService {
                 averageApy += parseFloat(trancheData.averageApy) * weight;
             }
 
-            const plumeTvl =
-                lendingPoolDirectus.plumeStrategy &&
-                this._plumeTvl.has(lendingPoolDirectus.plumeStrategy)
-                    ? this._plumeTvl.get(lendingPoolDirectus.plumeStrategy) ??
-                      '0'
-                    : '0';
-
             const offChainTvl =
                 offchainTvlMap.get(lendingPoolSubgraph.id) ?? '0';
 
             const poolOverview: PoolOverview = {
                 id: lendingPoolSubgraph.id,
-                security: lendingPoolDirectus.security,
-                enabled: lendingPoolDirectus.enabled,
-                isOversubscribed: lendingPoolDirectus.oversubscribed,
+                security: lendingPoolDirectus?.security ?? [],
+                enabled: lendingPoolDirectus?.enabled ?? true,
+                isOversubscribed:
+                    lendingPoolDirectus?.oversubscribed ?? false,
                 apy: averageApy,
-                description: lendingPoolDirectus.description,
-                liteDescription: lendingPoolDirectus.liteDescription,
-                thumbnailImageUrl: this.getUrlFromFile(
-                    lendingPoolDirectus.thumbnailImage,
-                ),
-                bannerImageUrl: this.getUrlFromFile(
-                    lendingPoolDirectus.bannerImage,
-                ),
-                strategyDeckUrl: this.getUrlFromFile(
-                    lendingPoolDirectus.strategyDeck,
-                ),
-                assetClass: lendingPoolDirectus.assetClass,
-                industryExposure: lendingPoolDirectus.industryExposure,
-                poolApyStructure: lendingPoolDirectus.poolApyStructure,
-                apyExpiryDate: lendingPoolDirectus.apyExpiryDate,
-                poolInvestmentTerm: lendingPoolDirectus.poolInvestmentTerm,
-                loanStructure: lendingPoolDirectus.loanStructure,
+                description: lendingPoolDirectus?.description ?? '',
+                liteDescription: lendingPoolDirectus?.liteDescription ?? '',
+                thumbnailImageUrl: lendingPoolDirectus?.thumbnailImage
+                    ? this.getUrlFromFile(lendingPoolDirectus.thumbnailImage)
+                    : '',
+                bannerImageUrl: lendingPoolDirectus?.bannerImage
+                    ? this.getUrlFromFile(lendingPoolDirectus.bannerImage)
+                    : '',
+                strategyDeckUrl: lendingPoolDirectus?.strategyDeck
+                    ? this.getUrlFromFile(lendingPoolDirectus.strategyDeck)
+                    : '',
+                assetClass: lendingPoolDirectus?.assetClass ?? '',
+                industryExposure:
+                    lendingPoolDirectus?.industryExposure ?? '',
+                poolApyStructure:
+                    lendingPoolDirectus?.poolApyStructure ?? 'Variable',
+                apyExpiryDate:
+                    lendingPoolDirectus?.apyExpiryDate ?? null,
+                poolInvestmentTerm:
+                    lendingPoolDirectus?.poolInvestmentTerm ?? '',
+                loanStructure: lendingPoolDirectus?.loanStructure ?? '',
                 poolName:
-                    lendingPoolDirectus.poolName ?? lendingPoolSubgraph.name,
-                subheading: lendingPoolDirectus.subheading,
+                    lendingPoolDirectus?.poolName ??
+                    lendingPoolSubgraph.name,
+                subheading: lendingPoolDirectus?.subheading,
                 totalValueLocked: {
                     total: (
                         parseFloat(lendingPoolSubgraph.balance) +
-                        parseFloat(plumeTvl) +
                         parseFloat(offChainTvl)
                     ).toString(),
                     offchain: offChainTvl,
-                    plume: plumeTvl,
                 },
-                loansUnderManagement: lendingPoolDirectus.loansUnderManagement,
+                loansUnderManagement:
+                    lendingPoolDirectus?.loansUnderManagement ?? '0',
                 yieldEarned: lendingPoolSubgraph.totalUserInterestAmount,
                 poolCapacity: poolCapacitySum.toString(),
                 poolCapacityPercentage: poolCapacityPercentageSum.toString(),
-                activeLoans: lendingPoolDirectus.activeLoans,
-                loanFundsOriginated: lendingPoolDirectus.loanFundsOriginated,
+                activeLoans: lendingPoolDirectus?.activeLoans ?? '0',
+                loanFundsOriginated:
+                    lendingPoolDirectus?.loanFundsOriginated ?? '0',
                 tranches: tranches,
                 isActive: !lendingPoolSubgraph.isStopped,
                 requestEpochsInAdvance:
@@ -438,7 +467,8 @@ export class DataService {
                         .lendingPoolWithdrawalConfig.requestEpochsInAdvance,
             };
 
-            // show only enabled pools from cms
+            // When Directus is available, show only enabled pools.
+            // When Directus is unavailable, include all pools.
             if (poolOverview.enabled) {
                 retn.push(poolOverview);
             }
@@ -797,9 +827,14 @@ export class DataService {
             );
         const retn: PoolRepayment[] = [];
         for (const data of poolRepaymentDirectus) {
+            // Find subgraph pool that maps to this Directus pool
+            // On non-Base chains, subgraph pool IDs are different from Directus poolIdFK
+            // Use getMetadataPoolId to map subgraph pool ID -> Directus/Base pool ID
             const lendingPoolSubgraph =
                 lendingPoolsWithdrawalsAndDepositsSubgraph.lendingPools.find(
-                    (pool) => pool.id == data.poolIdFK,
+                    (pool) =>
+                        this.getMetadataPoolId(pool.id) ===
+                        data.poolIdFK.toLowerCase(),
                 );
 
             if (lendingPoolSubgraph === undefined) {
@@ -949,14 +984,19 @@ export class DataService {
             retn.totalYieldEarned += parseFloat(poolOverview.yieldEarned);
         }
         for (const poolOverview of poolOverviews) {
+            // Map to metadata pool ID for Directus lookup (XDC pools → Base pools)
+            const metadataPoolId = this.getMetadataPoolId(poolOverview.id);
             const riskManagement = riskManagements.find(
                 (rm) =>
-                    rm.poolIdFK.toLowerCase() === poolOverview.id.toLowerCase(),
+                    rm.poolIdFK.toLowerCase() === metadataPoolId.toLowerCase(),
             );
             if (!riskManagement) {
                 console.warn(
                     "Couldn't find risk management for id: ",
                     poolOverview.id,
+                    metadataPoolId !== poolOverview.id
+                        ? `(mapped to ${metadataPoolId})`
+                        : '',
                 );
                 continue;
             }

package/src/services/DataService/queries.ts

@@ -1,14 +1,5 @@
 import { gql } from 'graphql-request';
 
-export const getPlumeTvl = gql`
-    {
-        lendingPools {
-            id
-            balance
-        }
-    }
-`;
-
 export const getPoolOverviewQuery = (ids?: string[]): string => gql`
     query getAllPoolOverview($epochId: String!, $unusedPools: [String]!) {
         lendingPools(

package/src/services/DataService/subgraph-types.ts

@@ -16,13 +16,6 @@ export interface LendingPoolSubgraph {
     configuration: LendingPoolConfigurationSubgraph;
 }
 
-export interface PlumeSubgraphReturn {
-    lendingPools: {
-        id: string;
-        balance: string;
-    }[];
-}
-
 export interface LendingPoolSubgraphReturn {
     lendingPools: LendingPoolSubgraph[];
 }

package/src/services/DataService/types.ts

@@ -19,7 +19,6 @@ export interface PoolOverview {
     totalValueLocked: {
         total: string;
         offchain: string;
-        plume: string;
     };
     loansUnderManagement: string;
     yieldEarned: string;

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,6 +271,10 @@ export class KSULocking {
     }
 
     async getUserLocks(userAddress: string): Promise<UserLock[]> {
+        if (this._isLiteDeployment) {
+            return [];
+        }
+
         const result: GQLUserLocks = await this._graph.request(userLocksQuery, {
             userAddress: userAddress.toLowerCase(),
         });
@@ -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;
 
@@ -322,6 +371,11 @@ export class KSULocking {
         loyaltyLevel: number;
         apyBonus: number;
     } {
+        // On Lite deployments, always return level 0 with no bonus
+        if (this._isLiteDeployment) {
+            return { loyaltyLevel: 0, apyBonus: 0 };
+        }
+
         if (rKSUtoUSDCRatio < 0.01) {
             return { loyaltyLevel: 0, apyBonus: this.apyBonuses[0] };
         } else if (rKSUtoUSDCRatio < 0.05) {
@@ -334,6 +388,10 @@ export class KSULocking {
         rKSUAmount: string,
         userAddress: string,
     ): Promise<number> {
+        if (this._isLiteDeployment) {
+            return 0;
+        }
+
         const [depositedAmount, pendingAmount]: [BigNumber, BigNumber] =
             await this._userManagerAbi.userTotalPendingAndActiveDepositedAmountForCurrentEpoch(
                 userAddress,
@@ -357,6 +415,9 @@ export class KSULocking {
     }
 
     async getClaimableRewards(userAddress: string): Promise<BigNumber> {
+        if (this._isLiteDeployment) {
+            return BigNumber.from(0);
+        }
         const result = await this._contractAbi.rewards(userAddress);
         return result;
     }
@@ -364,6 +425,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 +449,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 +474,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 +492,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 +509,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 +527,10 @@ export class KSULocking {
     }
 
     async getUserTotalBonusAmount(userAddress: string): Promise<string> {
+        if (this._isLiteDeployment) {
+            return '0';
+        }
+
         const result: GQLTotalBonusAmountForAddress = await this._graph.request(
             userTotalBonusAmountQuery,
             {
@@ -465,6 +547,13 @@ export class KSULocking {
     async getLockingRewards(
         userAddress: string,
     ): Promise<{ claimableRewards: string; lifeTimeRewards: string }> {
+        if (this._isLiteDeployment) {
+            return {
+                claimableRewards: '0',
+                lifeTimeRewards: '0',
+            };
+        }
+
         const rewardDecimals = 6;
 
         const claimableRewards = await this.getClaimableRewards(userAddress);
@@ -486,18 +575,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 +623,10 @@ export class KSULocking {
     }
 
     async getActiveLockPeriods(): Promise<LockPeriod[]> {
+        if (this._isLiteDeployment) {
+            return [];
+        }
+
         const data: GQLGetLockingPeriods =
             await this._graph.request(lockingPeriodsQuery);
         return data.lockPeriods;

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);
     }
 
@@ -293,6 +298,11 @@ export class Portfolio {
     }
 
     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());