@kasufinance/kasu-sdk 1.0.1

package/dist/services/UserLending/user-lending.js

@@ -0,0 +1,490 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { authentication, createDirectus, readItems, rest, } from '@directus/sdk';
+import { BigNumber, ethers, } from 'ethers';
+import { defaultAbiCoder, formatEther, formatUnits, parseEther, parseUnits, } from 'ethers/lib/utils';
+import { GraphQLClient } from 'graphql-request';
+import { IClearingCoordinatorAbi__factory, IKasuAllowListAbi__factory, ILendingPoolAbi__factory, ILendingPoolManagerAbi__factory, ILendingPoolTrancheAbi__factory, ISystemVariablesAbi__factory, IUserLoyaltyRewardsAbi__factory, IUserManagerAbi__factory, } from '../../contracts';
+import { DataService } from '../DataService/data-service';
+import { mapUserRequestEventType } from './helper';
+import { currentEpochDepositedAmountQuery, currentEpochFtdAmountQuery, currentFtdBalanceQuery, lendingPoolUserDetailsQuery, portfolioUserTrancheDetailsQuery, totalUserLoyaltyRewardsQuery, trancheUserDetailsQuery, userRequestsQuery, } from './queries';
+export class UserLending {
+    constructor(_kasuConfig, signerOrProvider) {
+        this._kasuConfig = _kasuConfig;
+        this._signerOrProvider = signerOrProvider;
+        this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
+        this._userManagerAbi = IUserManagerAbi__factory.connect(_kasuConfig.contracts.UserManager, signerOrProvider);
+        this._lendingPoolManagerAbi = ILendingPoolManagerAbi__factory.connect(_kasuConfig.contracts.LendingPoolManager, signerOrProvider);
+        this._userLoyaltyRewardsAbi = IUserLoyaltyRewardsAbi__factory.connect(_kasuConfig.contracts.UserLoyaltyRewards, signerOrProvider);
+        this._clearingCoordinatorAbi = IClearingCoordinatorAbi__factory.connect(_kasuConfig.contracts.ClearingCoordinator, signerOrProvider);
+        this._systemVariablesAbi = ISystemVariablesAbi__factory.connect(_kasuConfig.contracts.SystemVariables, signerOrProvider);
+        this._dataService = new DataService(_kasuConfig, signerOrProvider);
+        this._directus = createDirectus(_kasuConfig.directusUrl)
+            .with(authentication())
+            .with(rest());
+    }
+    getUserTotalPendingAndActiveDepositedAmount(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._userManagerAbi.userTotalPendingAndActiveDepositedAmount(user);
+        });
+    }
+    getUserTotalPendingAndActiveDepositedAmountForCurrentEpoch(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._userManagerAbi.userTotalPendingAndActiveDepositedAmountForCurrentEpoch(user);
+        });
+    }
+    hasUserRKSU(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._userManagerAbi.hasUserRKSU(user);
+        });
+    }
+    buildKycSignatureParams(userAddress, chainId) {
+        const address = userAddress.toLowerCase();
+        return {
+            contractAbi: IKasuAllowListAbi__factory.abi,
+            contractAddress: this._kasuConfig.contracts.KasuAllowList.toLowerCase(),
+            functionName: 'verifyUserKyc',
+            args: [address],
+            userAddress: address,
+            chainId,
+        };
+    }
+    buildDepositSwapData(fromToken, fromAmount, routerAddress, swapCallData, minAmountOut) {
+        return defaultAbiCoder.encode([
+            'tuple(address[], uint256[], (address, address,bytes)[], uint256)',
+        ], [
+            [
+                [fromToken],
+                [fromAmount],
+                [[routerAddress, fromToken, swapCallData]],
+                minAmountOut,
+            ],
+        ]);
+    }
+    requestDepositWithKyc(lendingPool, tranche, maxAmount, swapData, fixedTermConfigId, depositData, kycData, ethValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.requestDepositWithKyc(lendingPool, tranche, maxAmount, swapData, fixedTermConfigId, depositData, kycData, {
+                value: ethValue,
+            });
+        });
+    }
+    requestDeposit(lendingPool, tranche, amount, swapData, fixedTermConfigId, depositData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.requestDeposit(lendingPool, tranche, amount, swapData, fixedTermConfigId, depositData);
+        });
+    }
+    withdrawAtExpiry(lendingPool, fixedTermDepositId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.requestFixedTermDepositWithdrawal(lendingPool, fixedTermDepositId);
+        });
+    }
+    lockDepositForFixedTerm(lendingPool, tranche, amount, fixedTermConfigId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trancheContract = ILendingPoolTrancheAbi__factory.connect(tranche, this._signerOrProvider);
+            const shareAmount = yield trancheContract.convertToShares(amount);
+            return yield this._lendingPoolManagerAbi.lockDepositForFixedTerm(lendingPool, tranche, shareAmount, fixedTermConfigId);
+        });
+    }
+    cancelDepositRequest(lendingPool, dNftID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.cancelDepositRequest(lendingPool, dNftID);
+        });
+    }
+    requestWithdrawal(lendingPool, tranche, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.requestWithdrawal(lendingPool, tranche, amount);
+        });
+    }
+    requestWithdrawalInUSDC(lendingPool, tranche, usdcAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trancheContract = ILendingPoolTrancheAbi__factory.connect(tranche, this._signerOrProvider);
+            const shareAmount = yield trancheContract.convertToShares(usdcAmount);
+            return yield this._lendingPoolManagerAbi.requestWithdrawal(lendingPool, tranche, shareAmount);
+        });
+    }
+    requestWithdrawalMax(lendingPool, tranche, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trancheContract = ILendingPoolTrancheAbi__factory.connect(tranche, this._signerOrProvider);
+            const userShares = yield trancheContract['balanceOf(address)'](user);
+            return yield this._lendingPoolManagerAbi.requestWithdrawal(lendingPool, tranche, userShares);
+        });
+    }
+    cancelWithdrawalRequest(lendingPool, dNftID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.cancelWithdrawalRequest(lendingPool, dNftID);
+        });
+    }
+    claimRepaidLoss(lendingPool, tranche, lossId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._lendingPoolManagerAbi.claimRepaidLoss(lendingPool, tranche, lossId);
+        });
+    }
+    getUserRequests(userAddress, epochId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const trancheNames = [
+                ['Senior'],
+                ['Junior', 'Senior'],
+                ['Junior', 'Mezzanine', 'Senior'],
+            ];
+            const [subgraphResult, directusResult] = yield Promise.all([
+                this._graph.request(userRequestsQuery, {
+                    userAddress: userAddress.toLowerCase(),
+                    unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                    epochId,
+                }),
+                this._directus.request(readItems('PoolOverview', {
+                    fields: ['id', 'poolName', 'subheading'],
+                })),
+            ]);
+            const retn = [];
+            for (const userRequest of subgraphResult.userRequests) {
+                const directusPool = directusResult.find(({ id }) => id === userRequest.lendingPool.id);
+                const trancheName = trancheNames[userRequest.lendingPool.tranches.length - 1][parseInt(userRequest.tranche.orderId)];
+                const events = [];
+                for (const event of userRequest.userRequestEvents) {
+                    let totalRequested = '0';
+                    let totalAccepted = '0';
+                    let totalRejected = '0';
+                    const eventTrancheId = event.tranche.id;
+                    const eventTrancheName = trancheNames[userRequest.lendingPool.tranches.length - 1][parseInt(event.tranche.orderId)];
+                    if (eventTrancheId !== userRequest.tranche.id) {
+                        event.type = 'DepositReallocated';
+                    }
+                    const assetAmount = (_a = event.assetAmount) !== null && _a !== void 0 ? _a : this.convertSharesToAssets(event.sharesAmount, userRequest.tranche.balance, userRequest.tranche.shares).toString();
+                    switch (event.type) {
+                        case 'DepositAccepted':
+                        case 'WithdrawalAccepted':
+                        case 'DepositReallocated':
+                        case 'ImmediateWithdrawalExecuted':
+                            totalAccepted = assetAmount;
+                            break;
+                        case 'DepositCancelled':
+                        case 'WithdrawalCancelled':
+                        case 'DepositRejected':
+                            totalRejected = assetAmount;
+                            break;
+                        case 'DepositInitiated':
+                        case 'WithdrawalInitiated':
+                        case 'DepositIncreased':
+                        case 'WithdrawalIncreased':
+                            totalRequested = assetAmount;
+                            break;
+                    }
+                    const eventTranche = userRequest.lendingPool.configuration.tranchesConfig.find((trancheConfig) => trancheConfig.id === event.tranche.id);
+                    // shouldn't be possible, just adding type checking here
+                    if (!eventTranche)
+                        continue;
+                    const interestRate = eventTranche
+                        .lendingPoolTrancheInterestRateUpdates.length
+                        ? eventTranche.lendingPoolTrancheInterestRateUpdates[0]
+                            .epochInterestRate
+                        : eventTranche.interestRate;
+                    const baseApy = this._dataService.calculateApyForTranche(interestRate);
+                    events.push({
+                        id: event.id,
+                        requestType: mapUserRequestEventType(event.type),
+                        timestamp: parseInt(event.createdOn),
+                        totalRequested,
+                        totalAccepted,
+                        totalRejected,
+                        assetAmount,
+                        index: parseInt(event.index),
+                        transactionHash: event.transactionHash,
+                        trancheName: eventTrancheName,
+                        trancheId: event.tranche.id,
+                        apy: baseApy.toString(),
+                        epochId: event.epochId,
+                    });
+                }
+                const tranche = userRequest.lendingPool.configuration.tranchesConfig.find((trancheConfig) => trancheConfig.id === userRequest.tranche.id);
+                // shouldn't be possible, just adding type checking here
+                if (!tranche)
+                    continue;
+                const interestRate = tranche.lendingPoolTrancheInterestRateUpdates
+                    .length
+                    ? tranche.lendingPoolTrancheInterestRateUpdates[0]
+                        .epochInterestRate
+                    : tranche.interestRate;
+                const baseApy = this._dataService.calculateApyForTranche(interestRate);
+                const ftdConfig = tranche.lendingPoolTrancheFixedTermConfigs.find((config) => config.configId === userRequest.fixedTermConfigId);
+                let fixedTermConfig;
+                if (ftdConfig) {
+                    const fixedTermApy = this._dataService.calculateApyForTranche(ftdConfig.epochInterestRate);
+                    fixedTermConfig = {
+                        configId: ftdConfig.configId,
+                        apy: fixedTermApy.toString(),
+                        epochLockDuration: ftdConfig.epochLockDuration,
+                        epochInterestRate: ftdConfig.epochInterestRate,
+                    };
+                }
+                const poolName = (_b = directusPool === null || directusPool === void 0 ? void 0 : directusPool.poolName) !== null && _b !== void 0 ? _b : userRequest.lendingPool.name;
+                const userRequestBase = {
+                    id: userRequest.id,
+                    userId: userRequest.user.id,
+                    lendingPool: {
+                        id: userRequest.lendingPool.id,
+                        name: (directusPool === null || directusPool === void 0 ? void 0 : directusPool.subheading)
+                            ? `${poolName} - ${directusPool.subheading}`
+                            : poolName,
+                        tranches: userRequest.lendingPool.tranches,
+                    },
+                    requestType: userRequest.type === 'DepositRequest'
+                        ? 'Deposit'
+                        : 'Withdrawal',
+                    trancheName: trancheName,
+                    trancheId: userRequest.tranche.id,
+                    requestedAmount: parseUnits(userRequest.tranche.shares).isZero()
+                        ? userRequest.amountRequested
+                        : this.convertSharesToAssets(userRequest.amountRequested, userRequest.tranche.balance, userRequest.tranche.shares).toString(),
+                    acceptedAmount: userRequest.amountAccepted,
+                    rejectedAmount: userRequest.amountRejected,
+                    status: userRequest.status,
+                    timestamp: parseInt(userRequest.createdOn),
+                    canCancel: yield this.isCancelable(userRequest.status, userRequest.lendingPool.id),
+                    nftId: userRequest.nftId,
+                    events: events,
+                    fixedTermConfig,
+                    apy: baseApy.toString(),
+                };
+                retn.push(userRequestBase);
+            }
+            return retn;
+        });
+    }
+    getCurrentEpoch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentEpochNumber = yield this._systemVariablesAbi.currentEpochNumber();
+            return currentEpochNumber.toString();
+        });
+    }
+    getCurrentFtdBalance(poolId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentFtdBalance = yield this._graph.request(currentFtdBalanceQuery, {
+                userId: userId.toLowerCase(),
+                poolId: poolId.toLowerCase(),
+            });
+            const trancheMap = new Map();
+            for (const userFTD of currentFtdBalance.userLendingPoolTrancheFixedTermDepositLocks) {
+                const ftdID = parseFloat(userFTD.lendingPoolTrancheFixedTermConfig.configId);
+                const trancheID = userFTD.lendingPoolTrancheFixedTermConfig.lendingPoolTranche.id.toLowerCase();
+                const totalSupply = userFTD.lendingPool.tranches.reduce((total, cur) => total.add(parseEther(cur.shares)), BigNumber.from(0));
+                const amount = this.convertSharesToAssets(userFTD.trancheShares, userFTD.lendingPool.balance, formatEther(totalSupply));
+                const item = (_a = trancheMap.get(trancheID)) !== null && _a !== void 0 ? _a : [];
+                if (item[ftdID]) {
+                    item[ftdID] += parseFloat(amount);
+                }
+                else {
+                    item[ftdID] = parseFloat(amount);
+                }
+                trancheMap.set(trancheID, item);
+            }
+            return trancheMap;
+        });
+    }
+    getCurrentEpochFtdAmount(poolIds, userId, currentEpoch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentEpochFtdAmountRes = yield this._graph.request(currentEpochFtdAmountQuery, {
+                userId: userId.toLowerCase(),
+                poolIds: poolIds.map((id) => id.toLowerCase()),
+                currentEpoch: parseFloat(currentEpoch),
+            });
+            const currentEpochFtdAmounts = new Map();
+            for (const userRequest of currentEpochFtdAmountRes.userRequests) {
+                const ftdID = parseFloat(userRequest.fixedTermConfigId);
+                const item = currentEpochFtdAmounts.get(userRequest.tranche.id);
+                const amountRequested = this.convertSharesToAssets(userRequest.amountRequested, userRequest.tranche.balance, userRequest.tranche.shares);
+                if (item) {
+                    const clonedItem = [...item];
+                    clonedItem[ftdID] = amountRequested;
+                    currentEpochFtdAmounts.set(userRequest.tranche.id, clonedItem);
+                    continue;
+                }
+                const ftdAmounts = [];
+                ftdAmounts[ftdID] = amountRequested;
+                currentEpochFtdAmounts.set(userRequest.tranche.id, ftdAmounts);
+            }
+            return currentEpochFtdAmounts;
+        });
+    }
+    getCurrentEpochDepositedAmount(lendingPoolIds, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentEpochDepositedAmountRes = yield this._graph.request(currentEpochDepositedAmountQuery, {
+                ids: lendingPoolIds.map((poolId) => `${poolId}-${userId}`),
+            });
+            const amountMap = new Map();
+            if (!((_a = currentEpochDepositedAmountRes.lendingPoolUserDetails_collection) === null || _a === void 0 ? void 0 : _a.length))
+                return amountMap;
+            const lendingPoolTrancheUserDetails = currentEpochDepositedAmountRes.lendingPoolUserDetails_collection.flatMap(({ lendingPoolTrancheUserDetails }) => lendingPoolTrancheUserDetails);
+            for (const { tranche, totalPendingDepositAmount, } of lendingPoolTrancheUserDetails) {
+                amountMap.set(tranche.id.toLowerCase(), totalPendingDepositAmount);
+            }
+            return amountMap;
+        });
+    }
+    convertSharesToAssets(sharesAmount, totalAssets, totalSupply) {
+        if (parseUnits(totalSupply).isZero())
+            return '0';
+        return formatUnits(parseUnits(sharesAmount)
+            .mul(parseUnits(totalAssets.toString()))
+            .div(parseUnits(totalSupply.toString())));
+    }
+    isClearingPending(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._clearingCoordinatorAbi.isLendingPoolClearingPending(poolId);
+        });
+    }
+    isCancelable(status, lendingPoolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (status === 'Processed')
+                return false;
+            const isClearingPending = yield this.isClearingPending(lendingPoolId);
+            return !isClearingPending;
+        });
+    }
+    getUserPoolBalance(user, poolIds, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const poolBalances = [];
+            for (const poolId of poolIds) {
+                const lendingPool = ILendingPoolAbi__factory.connect(poolId, provider !== null && provider !== void 0 ? provider : this._signerOrProvider);
+                if (this._kasuConfig.UNUSED_LENDING_POOL_IDS.includes(poolId.toLowerCase())) {
+                    console.error('This pool is no longer in used');
+                    continue;
+                }
+                poolBalances.push({
+                    poolId,
+                    balance: lendingPool.userBalance(user),
+                });
+            }
+            const [userDetailsSubgraph, balances] = yield Promise.all([
+                this._graph.request(lendingPoolUserDetailsQuery, {
+                    userAddress: user.toLowerCase(),
+                }),
+                Promise.all(poolBalances.map((_a) => __awaiter(this, [_a], void 0, function* ({ balance, poolId }) {
+                    return ({
+                        poolId,
+                        balance: yield balance,
+                    });
+                }))),
+            ]);
+            if (!((_a = userDetailsSubgraph.user) === null || _a === void 0 ? void 0 : _a.lendingPoolUserDetails)) {
+                return poolIds.map((poolId) => ({
+                    poolId,
+                    yieldEarned: 0,
+                    balance: BigNumber.from(0),
+                }));
+            }
+            return userDetailsSubgraph.user.lendingPoolUserDetails.map(({ lendingPool, totalAcceptedDeposits, totalAcceptedWithdrawnAmount, }) => {
+                var _a, _b;
+                const balance = (_b = (_a = balances.find(({ poolId }) => poolId.toLowerCase() ===
+                    lendingPool.id.toLowerCase())) === null || _a === void 0 ? void 0 : _a.balance) !== null && _b !== void 0 ? _b : BigNumber.from(0);
+                return {
+                    poolId: lendingPool.id,
+                    yieldEarned: parseFloat(ethers.utils.formatUnits(balance, 6)) -
+                        parseFloat(totalAcceptedDeposits) -
+                        -parseFloat(totalAcceptedWithdrawnAmount),
+                    balance,
+                };
+            });
+        });
+    }
+    getPortfolioUserTrancheBalances(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userDetails = yield this._graph.request(portfolioUserTrancheDetailsQuery, {
+                userAddress: user.toLowerCase(),
+            });
+            const mapper = new Map();
+            if (!userDetails.user)
+                return mapper;
+            for (const lendingPoolUserDetail of userDetails.user
+                .lendingPoolUserDetails) {
+                const tranches = [];
+                for (const trancheDetail of lendingPoolUserDetail.lendingPoolTrancheUserDetails) {
+                    let yieldEarned = 0;
+                    let userBalance = '0';
+                    if (trancheDetail) {
+                        userBalance = this.convertSharesToAssets(trancheDetail.shares, trancheDetail.tranche.balance, trancheDetail.tranche.shares);
+                        const totalAcceptedDeposits = parseFloat(trancheDetail.totalAcceptedDeposits);
+                        const totalAcceptedWithdrawals = parseFloat(trancheDetail.totalAcceptedWithdrawnAmount);
+                        yieldEarned =
+                            parseFloat(userBalance) -
+                                totalAcceptedDeposits -
+                                -totalAcceptedWithdrawals;
+                        tranches.push({
+                            trancheId: trancheDetail.tranche.id,
+                            yieldEarned,
+                            userBalance,
+                        });
+                    }
+                }
+                mapper.set(lendingPoolUserDetail.lendingPool.id, tranches);
+            }
+            return mapper;
+        });
+    }
+    getUserTrancheBalance(user, poolId, trancheId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tranche = ILendingPoolTrancheAbi__factory.connect(trancheId, this._signerOrProvider);
+            const [availableToWithdraw, userDetails] = yield Promise.all([
+                tranche.maxWithdraw(user),
+                this._graph.request(trancheUserDetailsQuery, {
+                    userAddress: `${poolId}-${user}-${trancheId}`,
+                }),
+            ]);
+            const userDetailsSubgraph = userDetails;
+            let yieldEarned = 0;
+            let userBalance = '0';
+            if (userDetailsSubgraph.lendingPoolTrancheUserDetails &&
+                !parseUnits(userDetailsSubgraph.lendingPoolTrancheUserDetails.tranche
+                    .shares).isZero()) {
+                userBalance = this.convertSharesToAssets(userDetailsSubgraph.lendingPoolTrancheUserDetails.shares, userDetailsSubgraph.lendingPoolTrancheUserDetails.tranche
+                    .balance, userDetailsSubgraph.lendingPoolTrancheUserDetails.tranche
+                    .shares);
+                const totalAcceptedDeposits = parseFloat(userDetailsSubgraph.lendingPoolTrancheUserDetails
+                    .totalAcceptedDeposits);
+                const totalAcceptedWithdrawals = parseFloat(userDetailsSubgraph.lendingPoolTrancheUserDetails
+                    .totalAcceptedWithdrawnAmount);
+                yieldEarned =
+                    parseFloat(userBalance) -
+                        totalAcceptedDeposits -
+                        -totalAcceptedWithdrawals;
+            }
+            return {
+                userId: user,
+                address: trancheId,
+                yieldEarned,
+                balance: userBalance,
+                availableToWithdraw,
+                trancheId,
+            };
+        });
+    }
+    getUserApyBonus(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subgraphResult = yield this._graph.request(totalUserLoyaltyRewardsQuery, {
+                userAddress: user,
+            });
+            if (!subgraphResult.user) {
+                return {
+                    balance: BigNumber.from(0),
+                    lifetime: 0,
+                };
+            }
+            const balance = yield this._userLoyaltyRewardsAbi.userRewards(user);
+            return {
+                balance: balance,
+                lifetime: parseFloat(subgraphResult.user.totalUserLoyaltyRewards),
+            };
+        });
+    }
+}

package/dist/services/shared.d.ts

@@ -0,0 +1 @@
+export declare function filterArray<T>(array: T[], id_in?: string[]): T[];

package/dist/services/shared.js

@@ -0,0 +1,11 @@
+export function filterArray(array, id_in) {
+    if (!id_in) {
+        return array;
+    }
+    else {
+        return array.filter(data => {
+            const { id } = data;
+            return id_in.includes(id);
+        });
+    }
+}

package/dist/tests/sample.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sample.test.js

@@ -0,0 +1,32 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as ethers from 'ethers';
+import { KasuSdk } from '..';
+import { SdkConfig } from '../sdk-config';
+test('subgraphCall', () => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = new ethers.providers.JsonRpcProvider('https://sepolia.base.org');
+    const wallet = new ethers.Wallet('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', provider);
+    const config = new SdkConfig('https://api.studio.thegraph.com/query/63245/kasu-wip-sepolia/version/latest', 'https://api.goldsky.com/api/public/project_cm9t3064xeuyn01tgctdo3c17/subgraphs/kasu-plume/prod/gn', {
+        IKSULocking: '0x529A81c11ab6176c5E88670d293BB771800066a2',
+        IKSULockBonus: '0xBBfFd5F744156FFc526df12F5e09dC7b208Be740',
+        KSUToken: '0xa0f698Feb9Bc2BeA6E85eb071D5E3F59dc5bC56b',
+        UserManager: '0xA788e9223fDd7c9Db91Ef133BbeB73515c174773',
+        LendingPoolManager: '0xc074Aaf2565aae18db2c7498ee1387610a809F40',
+        KasuAllowList: '0xaE94F9D187c9eA649ADd4966340831F7cc62B69c',
+        SystemVariables: '0xB174a3240B23e595e90bC2736A5b8ec674Cba73A',
+        UserLoyaltyRewards: '0x259631CE76FD9F65296549Cd81232aa59D53Dd0c',
+        KsuPrice: '0x2027192aCFB4810Ad734A212F19d7030F698aCE3',
+        ClearingCoordinator: '0x2027192aCFB4810Ad734A212F19d7030F698aCE3',
+        KasuNFTs: '0x0000000000000000000000000000000000000000',
+        ExternalTVL: '0x0000000000000000000000000000000000000000',
+    }, 'https://kasu-finance.directus.app', ['']);
+    const sdk = new KasuSdk(config, wallet);
+    console.log(yield sdk.UserLending.getUserApyBonus('0xef38c432682ab49095e00442aaa354e955ac03a5'));
+}));

package/index.ts

@@ -0,0 +1,2 @@
+// exlude from eslint
+export * from './src';

package/jest-config.ts

@@ -0,0 +1,9 @@
+
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['**/*.test.ts'],
+    testTimeout: 50000,
+  };
+  

package/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    moduleFileExtensions: ['ts', 'js'],
+    testMatch: ['**/*.test.ts'],
+    testTimeout: 600 * 1000,
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@kasufinance/kasu-sdk",
+    "version": "1.0.1",
+    "description": "",
+    "main": "dist/bundle.cjs.js",
+    "module": "dist/bundle.esm.js",
+    "types": "dist/types/index.d.ts",
+    "scripts": {
+        "test": "jest --config=jest-config.ts",
+        "build-tc": "typechain --target ethers-v5 --out-dir src/contracts './abis/*.json'",
+        "build": "eslint . && tsc --build --force tsconfig.json",
+        "rollup-build": "rollup -c",
+        "lint": "eslint . --fix"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "author": "",
+    "license": "ISC",
+    "devDependencies": {
+        "@rollup/plugin-node-resolve": "^15.2.3",
+        "@rollup/plugin-typescript": "^11.1.6",
+        "@types/jest": "^29.5.11",
+        "@types/node": "^22.15.29",
+        "@typescript-eslint/eslint-plugin": "^6.19.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-import": "^2.29.1",
+        "graphql": "^16.8.1",
+        "prettier": "^3.2.2",
+        "rollup": "^4.14.3",
+        "ts-jest": "^29.1.2",
+        "typechain": "^8.3.2",
+        "typescript": "^5.8.3"
+    },
+    "dependencies": {
+        "@directus/sdk": "^16.1.0",
+        "@rollup/plugin-commonjs": "^25.0.7",
+        "@typechain/ethers-v5": "^11.1.2",
+        "@typescript-eslint/parser": "^6.0.0",
+        "axios": "^1.7.0",
+        "eslint": "^8.56.0",
+        "ethers": "^5.7.2",
+        "graphql-request": "^6.1.0",
+        "jest": "^29.7.0",
+        "ts-node": "^10.9.2",
+        "tslib": "^2.6.2"
+    }
+}

package/rollup.config.js

@@ -0,0 +1,45 @@
+// This plugin allows Rollup to process TypeScript files.
+const typescript = require('@rollup/plugin-typescript');
+
+// This plugin allows Rollup to resolve modules in 'node_modules'.
+const nodeResolve = require('@rollup/plugin-node-resolve').nodeResolve;
+
+// This plugin allows Rollup to convert CommonJS modules to ES6 modules.
+const commonjs = require('@rollup/plugin-commonjs');
+
+// Export the configuration object for Rollup.
+module.exports = {
+  // The entry point file of library, from which Rollup will start bundling.
+  input: 'src/index.ts',
+  
+  // Array of output configurations - defines how the build outputs should be written.
+  output: [
+    {
+      // Output path and filename for the CommonJS version of your library.
+      file: 'dist/bundle.cjs.js',
+      // Output format set to CommonJS, suitable for Node.js and other systems that support require().
+      format: 'cjs'
+    },
+    {
+      // Output path and filename for the ES Module version of your library.
+      file: 'dist/bundle.esm.js',
+      // Output format set to ES Module, suitable for use in modern browsers and ES Module-supporting environments.
+      format: 'esm'
+    }
+  ],
+
+  // Plugins to be used in the build process.
+  plugins: [
+    // Configuration for the nodeResolve plugin. This setup helps resolve third-party dependencies found in 'node_modules'.
+    nodeResolve({
+      // Specifies that the resolver should prefer built-in modules (like 'fs' or 'path') over npm-installed ones. False here because in browsers there are no built-ins.
+      browser: true, 
+      preferBuiltins: false
+    }),
+    commonjs({
+      include: /node_modules/  // Include all CommonJS modules from node_modules to be converted
+    }),
+    typescript({ tsconfig: './tsconfig.json' }),
+  ],
+  external: ['ethers', 'ethers/lib/utils'], // Do not bundle these dependencies cus they are already bundled in frontend app
+};