@dripfi/drip-sdk 1.1.5 → 1.1.7

package/dist/DripApi.d.ts

@@ -5,6 +5,7 @@ import { QLFastRedeem } from './types/QLFastRedeem';
 import { UserRewards } from './types/UserRewards';
 import { VaultStats } from './types/VaultStats';
 import { UserBalance } from './types/UserBalance';
+import { VaultClaimData } from './types/VaultClaimData';
 export declare const IMPERSONATOR_HEADER = "impersonatorAddress";
 export default class DripApi {
     route: string;
@@ -28,4 +29,5 @@ export default class DripApi {
     fetchAssetPerSvtAtBlock(vaultAddress: string, blocknumber: number, token: string): Promise<BigNumber>;
     fetchFastWithdrawNFTs(vaultAddress: string, walletAddress: string, token: string, headers?: Headers): Promise<QLFastRedeem[]>;
     fetchUserRewards(walletAddress: string, token: string, headers?: Headers): Promise<UserRewards>;
+    fetchVaultsClaimableData(walletAddress: string, token: string, headers?: Headers): Promise<VaultClaimData>;
 }

package/dist/DripApi.js

@@ -252,5 +252,19 @@ class DripApi {
             return data;
         });
     }
+    fetchVaultsClaimableData(walletAddress, token, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reqHeaders = headers ? headers : new Headers();
+            reqHeaders.append(AUTHORIZATION_HEADER, token);
+            if (reqHeaders.has(exports.IMPERSONATOR_HEADER)) {
+                walletAddress = reqHeaders.get(exports.IMPERSONATOR_HEADER);
+            }
+            const res = yield fetch(`${this.route}/api-be/api/user/claimableVaults/${walletAddress}`, {
+                headers: reqHeaders,
+            });
+            const data = yield res.json();
+            return data;
+        });
+    }
 }
 exports.default = DripApi;

package/dist/DripSdk.d.ts

@@ -5,6 +5,7 @@ import { UserRewards } from './types/UserRewards';
 import { VaultStats } from './types/VaultStats';
 import { UserBalance } from './types/UserBalance';
 import { UserVaultBalance } from './types/UserVaultBalance';
+import { VaultClaimData } from './types/VaultClaimData';
 import { Vault } from './types/Vault';
 export default class DripSdk {
     private dripApi;
@@ -30,6 +31,7 @@ export default class DripSdk {
     swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>;
     withdraw(vaultAddress: string, amountToWithdraw?: string): Promise<string>;
     claimWithdraws(vaultAddress: string): Promise<string>;
+    getVaultsClaimableData(headers?: Headers): Promise<VaultClaimData>;
     private generateOldRedeemBagStruct;
     private generateNewRedeemBagStruct;
     private getAllSvts;

package/dist/DripSdk.js

@@ -155,63 +155,55 @@ class DripSdk {
     }
     getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals, authData.token);
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
+            return this.dripApi.getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals, userAddress);
         });
     }
     getUserBalance(headers) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.getUserBalance(authData.address, authData.token, headers);
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
+            return this.dripApi.getUserBalance(userAddress, authData.token, headers);
         });
     }
     getUserBoostedNfts(vaultAddress, headers) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.getUserBoostedNfts(authData.address, vaultAddress, authData.token, headers);
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
+            return this.dripApi.getUserBoostedNfts(userAddress, vaultAddress, authData.token, headers);
         });
     }
     getRewardsPerHour(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             return this.dripApi.fetchRewardsPerHour(vaultAddress, authData.token);
         });
     }
     getRewards(headers) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            const userRewards = this.dripApi.fetchUserRewards(authData.address, authData.token, headers);
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
+            const userRewards = this.dripApi.fetchUserRewards(userAddress, authData.token, headers);
             return userRewards;
         });
     }
     getUserVaultBalance(vaultAddress, headers) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             const vault = yield this.getVaultDetails(vaultAddress);
-            const userAddress = authData.address;
             const token = authData.token;
             const dnfts = yield this.dripApi.fetchAllUserDNFTForVault(vaultAddress, userAddress, token, headers);
             const wnfts = yield this.dripApi.fetchAllUserWNFTForVault(vaultAddress, userAddress, token, headers);
             const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress);
-            if (this.shouldUseNewWithdrawLogic(headers && headers.has(DripApi_1.IMPERSONATOR_HEADER) ? headers.get(DripApi_1.IMPERSONATOR_HEADER) : authData.address, vault)) {
+            if (this.shouldUseNewWithdrawLogic(headers && headers.has(DripApi_1.IMPERSONATOR_HEADER) ? headers.get(DripApi_1.IMPERSONATOR_HEADER) : userAddress, vault)) {
                 const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = yield this.calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals, token);
                 const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts);
                 const pendingDeposits = this.calculatePendingDeposits(dnfts, decimals);
@@ -248,32 +240,30 @@ class DripSdk {
     fastWithdraw(vaultAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
             const vault = yield this.getVaultDetails(vaultAddress);
-            const redeemBagStruct = this.shouldUseNewWithdrawLogic(authData.address, vault)
-                ? yield this.generateNewRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw)
-                : yield this.generateOldRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw);
+            const redeemBagStruct = this.shouldUseNewWithdrawLogic(userAddress, vault)
+                ? yield this.generateNewRedeemBagStruct(authData.token, vault, userAddress, amountToWithdraw)
+                : yield this.generateOldRedeemBagStruct(authData.token, vault, userAddress, amountToWithdraw);
             const currentBlockNumber = yield ((_a = this.signer.provider) === null || _a === void 0 ? void 0 : _a.getBlockNumber());
             if (!currentBlockNumber) {
                 throw Error('Error fetching block number');
             }
-            const redeemTx = yield ((_b = this.spoolSdk) === null || _b === void 0 ? void 0 : _b.redeemFast(redeemBagStruct, authData.address, currentBlockNumber));
+            const redeemTx = yield ((_b = this.spoolSdk) === null || _b === void 0 ? void 0 : _b.redeemFast(redeemBagStruct, userAddress, currentBlockNumber));
             const txReceipt = yield redeemTx.wait();
             return txReceipt.transactionHash;
         });
     }
     swapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, ethAmount) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
@@ -281,18 +271,18 @@ class DripSdk {
             const amountToWithdrawFixedDecimals = parseFloat(fromTokenAmount).toFixed(decimals);
             const fromToken = ethers_1.ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals);
             if (fromToken.gt(ethers_1.BigNumber.from(0))) {
-                const currentTokenAllowance = yield this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress, authData.address);
+                const currentTokenAllowance = yield this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress, userAddress);
                 if (fromToken.gt(currentTokenAllowance)) {
                     yield this.approveTokenForSwapAndDepositContract(fromTokenAddress, fromToken.sub(currentTokenAllowance));
                 }
             }
-            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, authData.address);
+            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, userAddress);
             const swapDepositBagStruct = {
                 inTokens: [fromTokenAddress],
                 inAmounts: [fromToken],
                 smartVault: vaultAddress,
                 swapInfo,
-                receiver: authData.address,
+                receiver: userAddress,
                 referral: ethers_1.ethers.constants.AddressZero,
                 doFlush: false,
             };
@@ -305,32 +295,30 @@ class DripSdk {
     }
     withdraw(vaultAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
             const vault = yield this.getVaultDetails(vaultAddress);
-            const redeemBagStruct = this.shouldUseNewWithdrawLogic(authData.address, vault)
-                ? yield this.generateNewRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw)
-                : yield this.generateOldRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw);
-            const redeemTx = yield this.spoolSdk.redeem(redeemBagStruct, authData.address, false);
+            const redeemBagStruct = this.shouldUseNewWithdrawLogic(userAddress, vault)
+                ? yield this.generateNewRedeemBagStruct(authData.token, vault, userAddress, amountToWithdraw)
+                : yield this.generateOldRedeemBagStruct(authData.token, vault, userAddress, amountToWithdraw);
+            const redeemTx = yield this.spoolSdk.redeem(redeemBagStruct, userAddress, false);
             const redeemTxReceipt = yield redeemTx.wait();
             return redeemTxReceipt.transactionHash;
         });
     }
     claimWithdraws(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
+            const userAddress = yield this.signer.getAddress();
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
+            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
-            const wnfts = yield this.dripApi.fetchEnrichedUserWNFTForVault(vaultAddress, authData.address, authData.token);
+            const wnfts = yield this.dripApi.fetchEnrichedUserWNFTForVault(vaultAddress, userAddress, authData.token);
             //! Shares come as Strings instead of BigNumber from our Backend
             const nftIds = wnfts
                 .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
@@ -338,11 +326,23 @@ class DripSdk {
             const nftAmounts = wnfts
                 .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
                 .map((item) => item.shares.toString());
-            const claimWithdrawTx = yield this.spoolSdk.claimWithdrawal(vaultAddress, nftIds, nftAmounts, authData.address);
+            const claimWithdrawTx = yield this.spoolSdk.claimWithdrawal(vaultAddress, nftIds, nftAmounts, userAddress);
             const txReceipt = yield claimWithdrawTx.wait();
             return txReceipt.transactionHash;
         });
     }
+    getVaultsClaimableData(headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const authData = yield this.isUserAuthenticated();
+            if (!authData.isAuthenticated) {
+                throw Error(`User not authenticated: ${authData.message}`);
+            }
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            return yield this.dripApi.fetchVaultsClaimableData(authData.address, authData.token, headers);
+        });
+    }
     generateOldRedeemBagStruct(token, vault, signerAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
             const dnfts = yield this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress, signerAddress, token);

package/dist/types/VaultClaimData.d.ts

@@ -0,0 +1,6 @@
+export type VaultClaimData = {
+    vaultAddress: string;
+    asset: string;
+    dripping: string;
+    claimable: number;
+}[];

package/dist/types/VaultClaimData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dripfi/drip-sdk",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Drip SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",