@dripfi/drip-sdk 1.2.19 → 1.3.0

package/README.md

@@ -48,12 +48,9 @@ const dripSdk = new DripSdk(chain, signer);
 | `getVaultStats(): Promise<VaultStats>`| NO | Returns some overall drip stats |
 | `getTokenPrice(tokenName: string): Promise<number>`| NO | Returns the price for the given token (only works for weth at the moment) |
 | `updateSigner(newSigner: Signer): Promise<void>`| NO | Updates the signer for the SDK instance. |
-| `isUserAuthenticated(): Promise<AuthenticationStatus>` | NO | Checks if the user is authenticated and returns authentication status along with relevant information. |
-| `authenticate(): Promise<boolean>` | NO | Initiates the user authentication process and returns a boolean indicating success. |
 | `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>` | NO | The deposit function allows you to deposit tokens into a specific vault. Returns txHash. |
 | `getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>`| NO | Returns the expected amount of tokens to get from a swap |
 | `getUserBalance(): Promise<UserBalance>` | YES | Returns overall user balance information |
-| `getUserBoostedNfts(vaultAddress: string): Promise<string[]>` | YES | Returns an array of boosted nfts addresses owned by the user  |
 | `getRewardsPerHour(vaultAddress: string): Promise<string[]>` | YES | Returns an estimated amount of tokens the user will receive in 1 hour as reward. It considers boost nfts the user owns for the estimation. |
 | `getRewards(): Promise<UserRewards>` | YES | Fetches the current user's rewards points for each vault. |
 | `getUserVaultBalance(): Promise<UserVaultBalance>` | YES | Fetches the user's balance for a specific Drip Vault.  |
@@ -64,7 +61,7 @@ const dripSdk = new DripSdk(chain, signer);
 | `getTokenAllowanceForCurrency(tokenAddress: string): Promise<string>` | NO | This function retrieves the token allowance for a specific currency. |
 | `getTokenAllowanceForRecycler(tokenAddress: string): Promise<BigNumber>` | NO | This function retrieves the token allowance for the recycler contract. |
 | `getTokenAllowanceForSwapAndRecycler(tokenAddress: string): Promise<BigNumber>` | NO | This function retrieves the token allowance for the swap and recycler contract. |
-| `getUserBoostedNfts(vaultAddress: string, headers?: Headers): Promise<string[]>` | YES | This function retrieves an array of boosted NFT addresses owned by the user. |
+| `getUserBoostedNfts(vaultAddress: string): Promise<string[]>` | YES | This function retrieves an array of boosted NFT addresses owned by the user. |
 | `getRewardsPerHour(vaultAddress: string): Promise<number> ` | YES | This function returns an estimated amount of tokens the user will receive in one hour as a reward for the given vault |
 | `newDeposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>` | YES | This function allows for a new deposit without checking for allowance.
 | `newSwapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string> ` | YES | This function allows for a new swap and deposit without checking for allowance. |
@@ -72,19 +69,12 @@ const dripSdk = new DripSdk(chain, signer);
 | `getVestingStart(): Promise<string>` | YES | This function retrieves the start time of the vesting period. |
 | `getVestingEnd(): Promise<string>` | YES | This function retrieves the end time of the vesting period.
 | `getBeansHistory(): Promise<BeanEntry[]> ` | YES | This function retrieves the user's beans history of tx
-| `getBeansBalance(headers?: Headers): Promise<BeansBalance>  ` | YES | This function retrieves the user's beans balance.
-| `getMyPerqBalance(headers?: Headers): Promise<MyPerqData>` | YES | This function retrieves the user's Perq balance data.
-| `getVaultsClaimableData(headers?: Headers): Promise<VaultClaimData> ` | YES | This function fetches claimable data for the user's vaults.
-| `upgradeLoyaltyCard(): Promise<LoyaltyCard>` | YES | This function upgrades the user's loyalty card.
-| `getNextLoyaltyCard(headers?: Headers): Promise<LoyaltyCard> ` | YES |  This function fetches the next loyalty card for the authenticated user based on the currently owned one
-| `getOwnedLoyaltyCards(headers?: Headers): Promise<LoyaltyCard>` | YES |  This function fetches the next loyalty card for the authenticated user based on the currently owned one
+| `getBeansBalance(): Promise<BeansBalance>  ` | YES | This function retrieves the user's beans balance.
+| `getMyPerqBalance(): Promise<MyPerqData>` | YES | This function retrieves the user's Perq balance data.
+| `getVaultsClaimableData(): Promise<VaultClaimData> ` | YES | This function fetches claimable data for the user's vaults.
+| `upgradeLoyaltyCard(index: number): Promise<LoyaltyCard>` | YES | This function upgrades the user's loyalty card.
+| `getOwnedLoyaltyCard(): Promise<LoyaltyCard>` | YES |  This function fetches the currently owned loyalty card of the connected wallet.
 | `getAllLoyaltyCards(): Promise<LoyaltyCard[]>` | YES |  This function fetches all available loyalty cards.
-| `getLoyaltyCardBoost(rewardId: string, headers?: Headers): Promise<number>` | YES | This function retrieves the boost value for a specific loyalty card.
-
-
-
-> [!IMPORTANT]
-> **You must authenticate once for every wallet you want to use**
 
 ---
 
@@ -215,7 +205,7 @@ type Vault = {
   depositToken: VaultDepositToken
   type: VaultType
   rewards: VaultReward[]
-  rewardType: RewardType 
+  rewardType: RewardType
   liveUntil: string
   liveFrom: string
   liveUntilFormatted: string
@@ -229,9 +219,15 @@ type Vault = {
   coingeckoId?: string
   depositTokenId: string
   expectedTge?: string
-  tokenPrice: number,
-  change24h: number,
-  volume24h: number,
+  tokenPrice: number
+  change24h: number
+  volume24h: number
+  projectFeatured: boolean
+  avgTvl: string
+  peakTvl: string
+  amountOfDepositors: number
+  boostedTvl: number
+  projectVAPY?: number
 };
 
 type VaultType = 'launch' | 'earn' | 'airdrop'
@@ -281,13 +277,6 @@ type Strategy = {
   lastDoHardWorkBlock: number | null
 }
 
-type AuthenticationStatus = {
-  isAuthenticated: boolean
-  address?: string
-  token?: string
-  message?: string
-}
-
 interface QLFastRedeem {
   assetsWithdrawn: {
     asset: {
@@ -379,38 +368,35 @@ enum ELoyaltyCardTier {
 
 export type MyPerqData = { 
     [key: string]: {
-        vaultAddress: string,
-        projectName: string,
-        projectType: string,
-        projectFeatured: boolean,
-        liveUntil: string,
-        coingeckoId?: string,
-        depositTokenId: 'WETH' | 'USDC' | 'DAI',
-        type: 'earn' | 'launch' | 'airdrop',
-        rewardType: 'points' | 'token' | 'pnode shards',
-        amountOfTokens?: number
-        vaultName: string,
-        protocols: string[],
-        apy: number,
-        tvr: number,
-        tokenPrice: number,
-        change24h: number,
-        volume24h: number,
-        rewards: CacheVaultRewards[]
-        strategies: Strategy[],
-        boosters: NFTBoost[],
-        depositToken: DepositToken
-        avgTvl: string
-        peakTvl: string
-		pendingDeposits: number;
-		currentlyDeposited: number;
-		pendingWithdraws: number;
-		claimable: number;
-		ethPrice: number;
-        tokenRewards: {[token_address: string]: Asset & { amount: number, rewardsPerHour: number }};
+      vaultAddress: string,
+      projectName: string,
+      projectType: string,
+      projectFeatured: boolean,
+      liveUntil: string,
+      coingeckoId?: string,
+      depositTokenId: 'WETH' | 'USDC' | 'DAI',
+      type: 'earn' | 'launch' | 'airdrop',
+      rewardType: 'points' | 'token' | 'pnode shards',
+      amountOfTokens?: number
+      vaultName: string,
+      protocols: string[],
+      apy: number,
+      tvr: number,
+      tokenPrice: number,
+      change24h: number,
+      volume24h: number,
+      rewards: CacheVaultRewards[]
+      strategies: Strategy[],
+      boosters: NFTBoost[],
+      depositToken: DepositToken
+      avgTvl: string
+      peakTvl: string
+		  pendingDeposits: number;
+		  currentlyDeposited: number;
+		  pendingWithdraws: number;
+		  claimable: number;
+		  ethPrice: number;
+      tokenRewards: {[token_address: string]: Asset & { amount: number, rewardsPerHour: number }};
 	}
 };
-
-
-
 ```

package/dist/DripApi.d.ts

@@ -11,57 +11,34 @@ import { LoyaltyCard } from './types/LoyaltyCard';
 import { BeansBalance } from './types/BeansBalance';
 import { PerqToBeansSwapInfo } from './types/PerqToBeansSwapInfo';
 import BeanEntry from './types/BeanEntry';
-import { AuthenticationStatus } from './types/AuthenticationStatus';
-export declare const IMPERSONATOR_HEADER = "impersonatorAddress";
+import { SignedPayload } from './types/SignedPayload';
+import { UpgradeLoyaltyCardPayload } from './types/UpgradeLoyaltyCardPayload';
 export default class DripApi {
     route: string;
     constructor(route: string);
     fetchAllVaults(): Promise<Vault[]>;
     fetchTokenPrice(tokenName: string): Promise<number>;
-    getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number, token: string): Promise<string>;
-    getUserBalance(walletAddress: string, token: string, headers?: Headers): Promise<UserBalance>;
-    getUserBoostedNfts(walletAddress: string, vaultAddress: string, token: string, headers?: Headers): Promise<string[]>;
+    getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>;
+    getUserBalance(walletAddress: string): Promise<UserBalance>;
+    getUserBoostedNfts(walletAddress: string, vaultAddress: string): Promise<string[]>;
     fetchVaultStats(): Promise<VaultStats>;
     fetchVaultDetails(vaultAddress: string): Promise<Vault>;
-    fetchRewardsPerHour(vaultAddress: string, token: string): Promise<number>;
+    fetchRewardsPerHour(walletAddress: string, vaultAddress: string): Promise<number>;
     getSwapInfo(fromTokenAddress: string, toTokenAddress: string, amount: BigNumber, fromAddress: string): Promise<SwapInfo[]>;
-    fetchUserSVTBalance(vaultAddress: string, walletAddress: string, token: string): Promise<BigNumber>;
-    fetchUserBalance(vaultAddress: string, walletAddress: string, token: string): Promise<Record<string, string>>;
-    fetchEnrichedUserDNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]>;
-    fetchEnrichedUserWNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]>;
-    fetchUserSVTFromNfts(vaultAddress: string, userAddress: string, dnfts: number[], token: string): Promise<BigNumber[]>;
-    fetchAllUserWNFTForVault(vaultAddress: string, walletAddress: string, token: string, headers?: Headers): Promise<any[]>;
-    fetchAllUserDNFTForVault(vaultAddress: string, walletAddress: string, token: string, headers?: Headers): Promise<any[]>;
-    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>;
+    fetchUserSVTBalance(vaultAddress: string, walletAddress: string): Promise<BigNumber>;
+    fetchUserBalance(vaultAddress: string, walletAddress: string): Promise<Record<string, string>>;
+    fetchEnrichedUserWNFTForVault(vaultAddress: string, walletAddress: string): Promise<any[]>;
+    fetchAllUserWNFTForVault(vaultAddress: string, walletAddress: string): Promise<any[]>;
+    fetchAllUserDNFTForVault(vaultAddress: string, walletAddress: string): Promise<any[]>;
+    fetchAssetPerSvtAtBlock(vaultAddress: string, blocknumber: number): Promise<BigNumber>;
+    fetchFastWithdrawNFTs(vaultAddress: string, walletAddress: string): Promise<QLFastRedeem[]>;
+    fetchUserRewards(walletAddress: string): Promise<UserRewards>;
+    fetchVaultsClaimableData(walletAddress: string): Promise<VaultClaimData>;
     fetchAllLoyaltyCards(): Promise<LoyaltyCard[]>;
-    fetchOwnedLoyaltyCards(token: string, headers?: Headers): Promise<{
-        id: any;
-        tier: any;
-        level: any;
-        cost: number;
-        boost: any;
-    }>;
-    fetchNextLoyaltyCard(token: string, headers?: Headers): Promise<{
-        id: any;
-        tier: any;
-        level: any;
-        cost: number;
-        boost: any;
-    }>;
-    fetchBeansBalance(token: string, headers?: Headers): Promise<BeansBalance>;
-    upgradeLoyaltyCard(token: string, headers?: Headers): Promise<{
-        id: any;
-        tier: any;
-        level: any;
-        cost: number;
-        boost: any;
-    }>;
-    fetchMyPerqData(userAddress: string, token: string, headers?: Headers): Promise<MyPerqData>;
-    getLoyaltyCardBoost(rewardId: string, token: string, headers?: Headers): Promise<number>;
+    fetchOwnedLoyaltyCard(walletAddress: string): Promise<LoyaltyCard>;
+    fetchBeansBalance(walletAddress: string): Promise<BeansBalance>;
+    upgradeLoyaltyCard(signedPayload: SignedPayload<UpgradeLoyaltyCardPayload>): Promise<LoyaltyCard>;
+    fetchMyPerqData(userAddress: string): Promise<MyPerqData>;
     getSwapPerqForBeansInfo(): Promise<PerqToBeansSwapInfo>;
-    fetchBeansHistory(walletAddress: string, token: string, headers?: Headers): Promise<BeanEntry[]>;
-    checkTokenStatus(token: string): Promise<AuthenticationStatus>;
+    fetchBeansHistory(walletAddress: string): Promise<BeanEntry[]>;
 }

package/dist/DripApi.js

@@ -9,13 +9,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMPERSONATOR_HEADER = void 0;
 const ethers_1 = require("ethers");
 const DripConfig_1 = require("./DripConfig");
-const AuthenticationStatus_1 = require("./types/AuthenticationStatus");
 const WETH_TOKEN_ADDRESS = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
-exports.IMPERSONATOR_HEADER = 'impersonatorAddress';
-const AUTHORIZATION_HEADER = 'Authorization';
 class DripApi {
     constructor(route) {
         this.route = route;
@@ -44,19 +40,15 @@ class DripApi {
             }
         });
     }
-    getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals, token) {
+    getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
             const parsedAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
             const queryParams = new URLSearchParams({
                 from: fromTokenAddress,
                 to: toTokenAddress,
                 amount: parsedAmount.toString(),
             });
-            const res = yield fetch(`${this.route}/api-be/api/1inch/swap?${queryParams}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/1inch/swap?${queryParams}`);
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -66,16 +58,9 @@ class DripApi {
             }
         });
     }
-    getUserBalance(walletAddress, token, headers) {
+    getUserBalance(walletAddress) {
         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/deposits/${walletAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/deposits`);
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -85,16 +70,9 @@ class DripApi {
             }
         });
     }
-    getUserBoostedNfts(walletAddress, vaultAddress, token, headers) {
+    getUserBoostedNfts(walletAddress, vaultAddress) {
         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/nftBoost/${walletAddress}/${vaultAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/nftBoost/${vaultAddress}`);
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -128,13 +106,9 @@ class DripApi {
             }
         });
     }
-    fetchRewardsPerHour(vaultAddress, token) {
+    fetchRewardsPerHour(walletAddress, vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/user/rewardsPerHour/${vaultAddress}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/rewardsPerHour/${vaultAddress}`);
             if (res.ok) {
                 const data = yield res.json();
                 return data.rewardsPerHour;
@@ -166,13 +140,9 @@ class DripApi {
             }
         });
     }
-    fetchUserSVTBalance(vaultAddress, walletAddress, token) {
+    fetchUserSVTBalance(vaultAddress, walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/spool/user/svtBalance/${walletAddress}/${vaultAddress}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/user/${walletAddress}/svtBalance/${vaultAddress}`);
             if (res.ok) {
                 const data = (yield res.json());
                 return data;
@@ -182,13 +152,9 @@ class DripApi {
             }
         });
     }
-    fetchUserBalance(vaultAddress, walletAddress, token) {
+    fetchUserBalance(vaultAddress, walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/spool/userBalance/${walletAddress}/${vaultAddress}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/user/${walletAddress}/balance/${vaultAddress}`);
             if (res.ok) {
                 const data = (yield res.json());
                 return data;
@@ -198,29 +164,9 @@ class DripApi {
             }
         });
     }
-    fetchEnrichedUserDNFTForVault(vaultAddress, walletAddress, token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/spool/user/dNft/${walletAddress}/${vaultAddress}`, {
-                headers,
-            });
-            if (res.ok) {
-                const data = yield res.json();
-                return data;
-            }
-            else {
-                throw Error(`${yield res.text()}`);
-            }
-        });
-    }
-    fetchEnrichedUserWNFTForVault(vaultAddress, walletAddress, token) {
+    fetchEnrichedUserWNFTForVault(vaultAddress, walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/spool/user/wNft/${walletAddress}/${vaultAddress}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/user/${walletAddress}/wNft/${vaultAddress}`);
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -230,13 +176,9 @@ class DripApi {
             }
         });
     }
-    fetchUserSVTFromNfts(vaultAddress, userAddress, dnfts, token) {
+    fetchAllUserWNFTForVault(vaultAddress, walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/spool/user/svtFromNft/${userAddress}/${vaultAddress}?dnfts=${dnfts.join(',')}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/user/${walletAddress}/allWnft/${vaultAddress}`);
             if (res.ok) {
                 const data = (yield res.json());
                 return data;
@@ -246,16 +188,9 @@ class DripApi {
             }
         });
     }
-    fetchAllUserWNFTForVault(vaultAddress, walletAddress, token, headers) {
+    fetchAllUserDNFTForVault(vaultAddress, walletAddress) {
         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/spool/user/allWnft/${walletAddress}/${vaultAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/user/${walletAddress}/allDnft/${vaultAddress}`);
             if (res.ok) {
                 const data = (yield res.json());
                 return data;
@@ -265,16 +200,9 @@ class DripApi {
             }
         });
     }
-    fetchAllUserDNFTForVault(vaultAddress, walletAddress, token, headers) {
+    fetchAssetPerSvtAtBlock(vaultAddress, blocknumber) {
         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/spool/user/allDnft/${walletAddress}/${vaultAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/assetBalance/${blocknumber}/${vaultAddress}`);
             if (res.ok) {
                 const data = (yield res.json());
                 return data;
@@ -284,13 +212,9 @@ class DripApi {
             }
         });
     }
-    fetchAssetPerSvtAtBlock(vaultAddress, blocknumber, token) {
+    fetchFastWithdrawNFTs(vaultAddress, walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const headers = new Headers();
-            headers.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/spool/user/assetBalance/${blocknumber}/${vaultAddress}`, {
-                headers,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/spool/user/${walletAddress}/fastWithdrawNft/${vaultAddress}`);
             if (res.ok) {
                 const data = (yield res.json());
                 return data;
@@ -300,18 +224,11 @@ class DripApi {
             }
         });
     }
-    fetchFastWithdrawNFTs(vaultAddress, walletAddress, token, headers) {
+    fetchUserRewards(walletAddress) {
         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/spool/user/fastWithdrawNft/${walletAddress}/${vaultAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/rewards`);
             if (res.ok) {
-                const data = (yield res.json());
+                const data = yield res.json();
                 return data;
             }
             else {
@@ -319,16 +236,9 @@ class DripApi {
             }
         });
     }
-    fetchUserRewards(walletAddress, token, headers) {
+    fetchVaultsClaimableData(walletAddress) {
         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/rewards/${walletAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/claimableVaults`);
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -338,45 +248,27 @@ class DripApi {
             }
         });
     }
-    fetchVaultsClaimableData(walletAddress, token, headers) {
+    fetchAllLoyaltyCards() {
         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 res = yield fetch(`${this.route}/api-be/api/loyaltyCards/all`);
             if (res.ok) {
                 const data = yield res.json();
-                return data;
+                return data.map((card) => ({
+                    id: card.id,
+                    tier: card.tier,
+                    level: card.level,
+                    cost: parseFloat(ethers_1.ethers.utils.formatUnits(card.cost.toString(), DripConfig_1.PERQ_TOKEN_DECIMALS)),
+                    boost: card.boost
+                }));
             }
             else {
                 throw Error(`${yield res.text()}`);
             }
         });
     }
-    fetchAllLoyaltyCards() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(`${this.route}/api-be/api/loyaltyCards/all`);
-            const data = yield res.json();
-            return data.map((card) => ({
-                id: card.id,
-                tier: card.tier,
-                level: card.level,
-                cost: parseFloat(ethers_1.ethers.utils.formatUnits(card.cost.toString(), DripConfig_1.DRIP_TOKEN_DECIMALS)),
-                boost: card.boost
-            }));
-        });
-    }
-    fetchOwnedLoyaltyCards(token, headers) {
+    fetchOwnedLoyaltyCard(walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const reqHeaders = headers ? headers : new Headers();
-            reqHeaders.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/loyaltyCards/owned`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/loyaltyCards/owned`);
             if (res.status === 204) {
                 return {};
             }
@@ -386,7 +278,7 @@ class DripApi {
                     id: data.id,
                     tier: data.tier,
                     level: data.level,
-                    cost: parseFloat(ethers_1.ethers.utils.formatUnits(data.cost.toString(), DripConfig_1.DRIP_TOKEN_DECIMALS)),
+                    cost: parseFloat(ethers_1.ethers.utils.formatUnits(data.cost.toString(), DripConfig_1.PERQ_TOKEN_DECIMALS)),
                     boost: data.boost
                 };
             }
@@ -395,81 +287,50 @@ class DripApi {
             }
         });
     }
-    fetchNextLoyaltyCard(token, headers) {
+    fetchBeansBalance(walletAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const reqHeaders = headers ? headers : new Headers();
-            reqHeaders.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/loyaltyCards/next`, {
-                headers: reqHeaders,
-            });
-            const data = yield res.json();
-            return {
-                id: data.id,
-                tier: data.tier,
-                level: data.level,
-                cost: parseFloat(ethers_1.ethers.utils.formatUnits(data.cost.toString(), DripConfig_1.DRIP_TOKEN_DECIMALS)),
-                boost: data.boost
-            };
-        });
-    }
-    fetchBeansBalance(token, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reqHeaders = headers ? headers : new Headers();
-            reqHeaders.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/beans/balance`, {
-                headers: reqHeaders,
-            });
-            const data = yield res.json();
-            return {
-                balance: ethers_1.ethers.utils.formatUnits(data.balance, DripConfig_1.DRIP_TOKEN_DECIMALS),
-                bonusesClaimed: data.bonusesClaimed
-            };
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/beans/balance`);
+            if (res.ok) {
+                const data = yield res.json();
+                const beansBalance = {
+                    balance: ethers_1.ethers.utils.formatUnits(data.balance, DripConfig_1.PERQ_TOKEN_DECIMALS),
+                    bonusesClaimed: data.bonusesClaimed
+                };
+                return beansBalance;
+            }
+            else {
+                throw Error(`${yield res.text()}`);
+            }
         });
     }
-    upgradeLoyaltyCard(token, headers) {
+    upgradeLoyaltyCard(signedPayload) {
         return __awaiter(this, void 0, void 0, function* () {
-            const reqHeaders = headers ? headers : new Headers();
-            reqHeaders.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}/api-be/api/loyaltyCards/upgrade`, {
+            const { signerAddress } = signedPayload;
+            const res = yield fetch(`${this.route}/api-be/api/user/${signerAddress}/loyaltyCards/upgrade`, {
                 method: 'POST',
-                headers: reqHeaders,
-            });
-            const data = yield res.json();
-            return {
-                id: data.id,
-                tier: data.tier,
-                level: data.level,
-                cost: parseFloat(ethers_1.ethers.utils.formatUnits(data.cost.toString(), DripConfig_1.DRIP_TOKEN_DECIMALS)),
-                boost: data.boost
-            };
-        });
-    }
-    fetchMyPerqData(userAddress, 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)) {
-                userAddress = reqHeaders.get(exports.IMPERSONATOR_HEADER);
-            }
-            const res = yield fetch(`${this.route}/api-be/api/myperq/${userAddress}`, {
-                headers: reqHeaders,
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(signedPayload)
             });
             if (res.ok) {
                 const data = yield res.json();
-                return data;
+                return {
+                    id: data.id,
+                    tier: data.tier,
+                    level: data.level,
+                    cost: parseFloat(ethers_1.ethers.utils.formatUnits(data.cost.toString(), DripConfig_1.PERQ_TOKEN_DECIMALS)),
+                    boost: data.boost
+                };
             }
             else {
                 throw Error(`${yield res.text()}`);
             }
         });
     }
-    getLoyaltyCardBoost(rewardId, token, headers) {
+    fetchMyPerqData(userAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const reqHeaders = headers ? headers : new Headers();
-            reqHeaders.append(AUTHORIZATION_HEADER, token);
-            const res = yield fetch(`${this.route}api/loyaltyCards/boost/${rewardId}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${userAddress}/myperq`);
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -491,17 +352,9 @@ class DripApi {
             }
         });
     }
-    fetchBeansHistory(walletAddress, token, headers) {
+    fetchBeansHistory(walletAddress) {
         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/beans/history/${walletAddress}`, {
-                method: 'GET',
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/user/${walletAddress}/beans/history`);
             if (res.ok) {
                 const data = yield res.json();
                 const result = data.map((element) => {
@@ -525,23 +378,5 @@ class DripApi {
             }
         });
     }
-    checkTokenStatus(token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const reqHeaders = new Headers();
-                reqHeaders.append(AUTHORIZATION_HEADER, token);
-                const res = yield fetch(`${this.route}/api-be/auth/validateToken`, {
-                    method: 'GET',
-                    headers: reqHeaders,
-                });
-                const data = yield res.json();
-                return res.ok ? new AuthenticationStatus_1.ValidStatus(data.address, token) : new AuthenticationStatus_1.ErrorStatus(data.error);
-            }
-            catch (error) {
-                console.log(error);
-                return new AuthenticationStatus_1.ErrorStatus(error === null || error === void 0 ? void 0 : error.message);
-            }
-        });
-    }
 }
 exports.default = DripApi;

package/dist/DripConfig.d.ts

@@ -1,7 +1,7 @@
 import { SDKConfig } from '@spool.fi/spool-v2-sdk';
 import { Signer } from 'ethers';
 export declare const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
-export declare const DRIP_TOKEN_DECIMALS = 18;
+export declare const PERQ_TOKEN_DECIMALS = 18;
 export declare enum Chain {
     MAINNET = "mainnet",
     SEPOLIA = "sepolia"

package/dist/DripConfig.js

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DripConfig = exports.Chain = exports.DRIP_TOKEN_DECIMALS = exports.NULL_ADDRESS = void 0;
+exports.DripConfig = exports.Chain = exports.PERQ_TOKEN_DECIMALS = exports.NULL_ADDRESS = void 0;
 const spool_v2_sdk_1 = require("@spool.fi/spool-v2-sdk");
 exports.NULL_ADDRESS = '0x0000000000000000000000000000000000000000';
-exports.DRIP_TOKEN_DECIMALS = 18;
+exports.PERQ_TOKEN_DECIMALS = 18;
 var Chain;
 (function (Chain) {
     Chain["MAINNET"] = "mainnet";

package/dist/DripSdk.d.ts

@@ -12,7 +12,7 @@ import { BeansBalance } from './types/BeansBalance';
 import { PerqToBeansSwapInfo } from './types/PerqToBeansSwapInfo';
 import BeanEntry from './types/BeanEntry';
 import { VestingInfo } from './types/VestingInfo';
-import { AuthenticationStatus } from './types/AuthenticationStatus';
+import { SignedPayload } from './types/SignedPayload';
 export default class DripSdk {
     private dripApi;
     private dripTokenContract;
@@ -28,8 +28,6 @@ export default class DripSdk {
     getVaultStats(): Promise<VaultStats>;
     getTokenPrice(tokenName: string): Promise<number>;
     updateSigner(newSigner: Signer): void;
-    isUserAuthenticated(): Promise<AuthenticationStatus>;
-    authenticate(): Promise<boolean>;
     newDeposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
     deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
     private doDeposit;
@@ -37,29 +35,27 @@ export default class DripSdk {
     getTokenAllowanceForRecycler(tokenAddress: string): Promise<BigNumber>;
     getTokenAllowanceForSwapAndRecycler(tokenAddress: string): Promise<BigNumber>;
     getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>;
-    getUserBalance(headers?: Headers): Promise<UserBalance>;
-    getUserBoostedNfts(vaultAddress: string, headers?: Headers): Promise<string[]>;
+    getUserBalance(): Promise<UserBalance>;
+    getUserBoostedNfts(vaultAddress: string): Promise<string[]>;
     getRewardsPerHour(vaultAddress: string): Promise<number>;
-    getRewards(headers?: Headers): Promise<UserRewards>;
-    getMyPerqBalance(headers?: Headers): Promise<MyPerqData>;
-    getUserVaultBalance(vaultAddress: string, headers?: Headers): Promise<UserVaultBalance>;
+    getRewards(): Promise<UserRewards>;
+    getMyPerqBalance(): Promise<MyPerqData>;
+    getUserVaultBalance(vaultAddress: string): Promise<UserVaultBalance>;
     fastWithdraw(vaultAddress: string, amountToWithdraw?: string): Promise<string>;
     swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>;
     newSwapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>;
     private doSwapAndDeposit;
     withdraw(vaultAddress: string, amountToWithdraw?: string): Promise<string>;
     claimWithdraws(vaultAddress: string): Promise<string>;
-    getVaultsClaimableData(headers?: Headers): Promise<VaultClaimData>;
-    getBeansBalance(headers?: Headers): Promise<BeansBalance>;
-    getBeansHistory(headers?: Headers): Promise<BeanEntry[]>;
+    getVaultsClaimableData(): Promise<VaultClaimData>;
+    getBeansBalance(): Promise<BeansBalance>;
+    getBeansHistory(): Promise<BeanEntry[]>;
     recycleTokens(tokenAddress: string | undefined, amountToRecycle: string, beneficiary: string | undefined, price: string, deadline: string, signature: string): Promise<string>;
     swapAndRecycleETH(beneficiary: string, path: string[], minAmountOutWithDecimals: string, amountOfEth: string, price: string, deadline: string, signature: string): Promise<string>;
     swapAndRecycleERC20(beneficiary: string, path: string[], minAmountOutWithDecimals: string, amountInWithDecimals: string, price: string, deadline: string, signature: string): Promise<string>;
-    upgradeLoyaltyCard(): Promise<LoyaltyCard>;
-    getNextLoyaltyCard(headers?: Headers): Promise<LoyaltyCard>;
-    getOwnedLoyaltyCards(headers?: Headers): Promise<LoyaltyCard>;
+    upgradeLoyaltyCard(index: number): Promise<LoyaltyCard>;
+    getOwnedLoyaltyCard(): Promise<LoyaltyCard>;
     getAllLoyaltyCards(): Promise<LoyaltyCard[]>;
-    getLoyaltyCardBoost(rewardId: string, headers?: Headers): Promise<number>;
     approveTokenForRecycler(tokenAddress: string, amount: string): Promise<string>;
     approveTokenForSwapAndRecycler(tokenAddress: string, amount: string): Promise<string>;
     approveTokenForSwapAndDeposit(tokenAddress: string, amount: string): Promise<string>;
@@ -76,6 +72,7 @@ export default class DripSdk {
     getAllVestingInfo(beneficiaryAddress: string): Promise<VestingInfo>;
     claimVestedPerq(amount: string): Promise<string>;
     burnVestedPerq(amount: string, price: string, deadline: string, signature: string): Promise<string>;
+    signPayload<T extends Record<string, unknown>>(payload: T): Promise<SignedPayload<T>>;
     private generateRedeemBagStruct;
     private getERC20Precission;
     private calculatePendingDeposits;

package/dist/DripSdk.js

@@ -12,18 +12,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const web3_token_1 = __importDefault(require("web3-token"));
 const spool_v2_sdk_1 = require("@spool.fi/spool-v2-sdk");
 const ethers_1 = require("ethers");
 const DripConfig_1 = require("./DripConfig");
 const DripApi_1 = __importDefault(require("./DripApi"));
-const js_cookie_1 = __importDefault(require("js-cookie"));
 const DripTokenContract_1 = __importDefault(require("./contracts/DripTokenContract"));
 const DripTokenRecyclerContract_1 = __importDefault(require("./contracts/DripTokenRecyclerContract"));
 const DripSwapAndRecyclerContract_1 = __importDefault(require("./contracts/DripSwapAndRecyclerContract"));
 const PerqVestingContract_1 = __importDefault(require("./contracts/PerqVestingContract"));
 const utils_1 = require("ethers/lib/utils");
-const AuthenticationStatus_1 = require("./types/AuthenticationStatus");
 const WethTokenAbi_json_1 = __importDefault(require("./contracts/abi/WethTokenAbi.json"));
 class DripSdk {
     constructor(chain, signer, dripRoute) {
@@ -64,52 +61,6 @@ class DripSdk {
         this.dripTokenContract.updateSigner(newSigner);
         this.dripTokenRecyclerContract.updateSigner(newSigner);
     }
-    isUserAuthenticated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer) {
-                return { isAuthenticated: false, message: 'Signer not provided' };
-            }
-            const userAddress = yield this.signer.getAddress();
-            const cookieName = `auth_${userAddress.toLowerCase()}`;
-            const authToken = js_cookie_1.default.get(cookieName);
-            return !authToken ? new AuthenticationStatus_1.ErrorStatus('Auth token not found') : yield this.dripApi.checkTokenStatus(authToken);
-        });
-    }
-    authenticate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.signer) {
-                    throw Error('No signer provided');
-                }
-                const address = yield this.signer.getAddress();
-                const cookieName = `auth_${address.toLowerCase()}`;
-                const token = yield web3_token_1.default.sign((message) => __awaiter(this, void 0, void 0, function* () { return yield this.signer.signMessage(message); }), {
-                    statement: JSON.stringify({ address, message: 'Please sign in into Perq' }),
-                    expires_in: '30d',
-                });
-                const response = yield fetch(`${this.dripConfig.dripRoute}/api-be/auth/verify`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({ token }),
-                });
-                const result = yield response.json();
-                if (result.success) {
-                    js_cookie_1.default.set(cookieName, result.auth, { expires: 30 });
-                }
-                else {
-                    js_cookie_1.default.remove(cookieName);
-                    return false;
-                }
-                return true;
-            }
-            catch (error) {
-                console.error('Error obtaining token:', error);
-            }
-            return false;
-        });
-    }
     newDeposit(tokenAddress, vaultAddress, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.doDeposit(tokenAddress, vaultAddress, amount, false);
@@ -179,63 +130,49 @@ class DripSdk {
     }
     getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userAddress = yield this.signer.getAddress();
-            yield this.isUserAuthenticated();
-            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
-            return this.dripApi.getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals, userAddress);
+            return this.dripApi.getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals);
         });
     }
-    getUserBalance(headers) {
+    getUserBalance() {
         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(userAddress, authData.token, headers);
+            return this.dripApi.getUserBalance(userAddress);
         });
     }
-    getUserBoostedNfts(vaultAddress, headers) {
+    getUserBoostedNfts(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}`);}
-            return this.dripApi.getUserBoostedNfts(userAddress, vaultAddress, authData.token, headers);
+            return this.dripApi.getUserBoostedNfts(userAddress, vaultAddress);
         });
     }
     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}`);}
-            return this.dripApi.fetchRewardsPerHour(vaultAddress, authData.token);
+            const userAddress = yield this.signer.getAddress();
+            return this.dripApi.fetchRewardsPerHour(userAddress, vaultAddress);
         });
     }
-    getRewards(headers) {
+    getRewards() {
         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(userAddress, authData.token, headers);
+            const userRewards = this.dripApi.fetchUserRewards(userAddress);
             return userRewards;
         });
     }
-    getMyPerqBalance(headers) {
+    getMyPerqBalance() {
         return __awaiter(this, void 0, void 0, function* () {
             const userAddress = yield this.signer.getAddress();
-            const authData = yield this.isUserAuthenticated();
-            const myPerqBalance = this.dripApi.fetchMyPerqData(userAddress, authData.token, headers);
+            const myPerqBalance = this.dripApi.fetchMyPerqData(userAddress);
             return myPerqBalance;
         });
     }
-    getUserVaultBalance(vaultAddress, headers) {
+    getUserVaultBalance(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}`);}
             const vault = yield this.getVaultDetails(vaultAddress);
-            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 dnfts = yield this.dripApi.fetchAllUserDNFTForVault(vaultAddress, userAddress);
+            const wnfts = yield this.dripApi.fetchAllUserWNFTForVault(vaultAddress, userAddress);
             const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress);
-            const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = yield this.calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals, token);
+            const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = yield this.calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals);
             const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts);
             const pendingDeposits = this.calculatePendingDeposits(dnfts, decimals);
             const userBalance = this.calculateAllDeposits(dnfts, decimals).sub(pendingDeposits);
@@ -255,8 +192,6 @@ class DripSdk {
                 throw Error('No signer provided');
             }
             const userAddress = yield this.signer.getAddress();
-            // const authData = await this.isUserAuthenticated();
-            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
@@ -284,8 +219,6 @@ class DripSdk {
     doSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, checkAllowance, ethAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAddress = yield this.signer.getAddress();
-            yield this.isUserAuthenticated();
-            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
@@ -321,8 +254,6 @@ class DripSdk {
                 throw Error('No signer provided');
             }
             const userAddress = yield this.signer.getAddress();
-            // const authData = await this.isUserAuthenticated();
-            // if (!authData.isAuthenticated) {throw Error(`User not authenticated: ${authData.message}`);}
             if (!this.signer) {
                 throw Error('No signer provided');
             }
@@ -336,12 +267,10 @@ class DripSdk {
     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 (!this.signer) {
                 throw Error('No signer provided');
             }
-            const wnfts = yield this.dripApi.fetchEnrichedUserWNFTForVault(vaultAddress, userAddress, authData.token);
+            const wnfts = yield this.dripApi.fetchEnrichedUserWNFTForVault(vaultAddress, userAddress);
             //! 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)
@@ -354,42 +283,29 @@ class DripSdk {
             return txReceipt.transactionHash;
         });
     }
-    getVaultsClaimableData(headers) {
+    getVaultsClaimableData() {
         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);
+            const userAddress = yield this.signer.getAddress();
+            return yield this.dripApi.fetchVaultsClaimableData(userAddress);
         });
     }
-    getBeansBalance(headers) {
+    getBeansBalance() {
         return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.fetchBeansBalance(authData.token, headers);
+            const userAddress = yield this.signer.getAddress();
+            return this.dripApi.fetchBeansBalance(userAddress);
         });
     }
-    getBeansHistory(headers) {
+    getBeansHistory() {
         return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.fetchBeansHistory(authData.address, authData.token, headers);
+            const userAddress = yield this.signer.getAddress();
+            return this.dripApi.fetchBeansHistory(userAddress);
         });
     }
     recycleTokens() {
         return __awaiter(this, arguments, void 0, function* (tokenAddress = this.dripConfig.dripTokenAddress, amountToRecycle, beneficiary = DripConfig_1.NULL_ADDRESS, price, deadline, signature) {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
             if (this.dripConfig.dripTokenRecyclerAddress === DripConfig_1.NULL_ADDRESS) {
                 throw Error('Recycler contract address not defined');
             }
@@ -402,10 +318,6 @@ class DripSdk {
     }
     swapAndRecycleETH(beneficiary, path, minAmountOutWithDecimals, amountOfEth, price, deadline, signature) {
         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.dripConfig.dripSwapAndRecyclerAddress === DripConfig_1.NULL_ADDRESS) {
                 throw Error('Recycler contract address not defined');
             }
@@ -416,10 +328,6 @@ class DripSdk {
     }
     swapAndRecycleERC20(beneficiary, path, minAmountOutWithDecimals, amountInWithDecimals, price, deadline, signature) {
         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.dripConfig.dripSwapAndRecyclerAddress === DripConfig_1.NULL_ADDRESS) {
                 throw Error('Recycler contract address not defined');
             }
@@ -437,31 +345,17 @@ class DripSdk {
             return receipt.transactionHash;
         });
     }
-    upgradeLoyaltyCard() {
+    upgradeLoyaltyCard(index) {
         return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.upgradeLoyaltyCard(authData.token);
+            const payload = { index };
+            const signedPayload = yield this.signPayload(payload);
+            return this.dripApi.upgradeLoyaltyCard(signedPayload);
         });
     }
-    getNextLoyaltyCard(headers) {
+    getOwnedLoyaltyCard() {
         return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.fetchNextLoyaltyCard(authData.token, headers);
-        });
-    }
-    getOwnedLoyaltyCards(headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.fetchOwnedLoyaltyCards(authData.token, headers);
+            const signerAddress = yield this.signer.getAddress();
+            return this.dripApi.fetchOwnedLoyaltyCard(signerAddress);
         });
     }
     getAllLoyaltyCards() {
@@ -469,15 +363,6 @@ class DripSdk {
             return this.dripApi.fetchAllLoyaltyCards();
         });
     }
-    getLoyaltyCardBoost(rewardId, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated) {
-                throw Error(`User not authenticated: ${authData.message}`);
-            }
-            return this.dripApi.getLoyaltyCardBoost(rewardId, authData.token, headers);
-        });
-    }
     approveTokenForRecycler(tokenAddress, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.signer) {
@@ -669,6 +554,23 @@ class DripSdk {
             }
         });
     }
+    signPayload(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            const signerAddress = yield this.signer.getAddress();
+            // Create message to sign
+            const message = JSON.stringify(payload);
+            // Sign the message
+            const signature = yield this.signer.signMessage(message);
+            return {
+                signature,
+                signerAddress,
+                payload,
+            };
+        });
+    }
     generateRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.spoolSdk) {
@@ -734,7 +636,7 @@ class DripSdk {
             .map((item) => item.shares.toString());
         return nftIds.length !== 0 || nftAmounts.length !== 0;
     }
-    calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals, token) {
+    calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.signer) {
                 throw Error('No signer provided');
@@ -749,7 +651,7 @@ class DripSdk {
                     continue;
                 }
                 const currentBlockNumber = wnft.blockNumber - 1;
-                const assetsPerSvtAtBlock = yield this.dripApi.fetchAssetPerSvtAtBlock(vaultAddress.toLowerCase(), currentBlockNumber, token);
+                const assetsPerSvtAtBlock = yield this.dripApi.fetchAssetPerSvtAtBlock(vaultAddress.toLowerCase(), currentBlockNumber);
                 const estimatedValueOfNFT = ethers_1.BigNumber.from(ethers_1.ethers.utils.formatUnits(ethers_1.BigNumber.from(wnft.svtWithdrawn).mul(assetsPerSvtAtBlock), 36).split('.')[0].toString());
                 if (wnft.isDHWFinished) {
                     // Processed and Withdrawable

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import DripSdk from './DripSdk';
 import { Vault } from './types/Vault';
 import { VaultReward } from './types/VaultReward';
-import { AuthenticationStatus } from './types/AuthenticationStatus';
 import { NFTBoost } from './types/NFTBoost';
 import { Strategy } from './types/Strategy';
 import { StretchGoal } from './types/StretchGoal';
@@ -15,4 +14,4 @@ import { Chain } from './DripConfig';
 import MyPerqData from './types/MyPerqData';
 import ELoyaltyCardTier from './types/ELoyaltyCardTier';
 import BeanEntry from './types/BeanEntry';
-export { Vault, VaultReward, DripSdk, UserVaultBalance, UserBalance, VaultStats, AuthenticationStatus, NFTBoost, Strategy, StretchGoal, SwapInfo, VaultDepositToken, VaultType, MyPerqData, Chain, ELoyaltyCardTier, BeanEntry };
+export { Vault, VaultReward, DripSdk, UserVaultBalance, UserBalance, VaultStats, NFTBoost, Strategy, StretchGoal, SwapInfo, VaultDepositToken, VaultType, MyPerqData, Chain, ELoyaltyCardTier, BeanEntry };

package/dist/test.js

@@ -78,10 +78,8 @@ function main() {
         try {
             // const res = await dripSdk.deposit(usdcTokenAddress,usdcVaultPerq, '1000');
             // const res = await dripSdk.withdraw(usdcVaultPerq, '1');
-            // await dripSdk.authenticate()
             // const res = await dripSdk.getDripTokenBalance(account2)
-            // const res = await dripSdk.getNextLoyaltyCard()
-            // const res = await dripSdk.getOwnedLoyaltyCards()
+            // const res = await dripSdk.getOwnedLoyaltyCard()
             // const res = await dripSdk.getBeansBalance()
             // const res = await dripSdk.recycleTokens()
             // const res = await dripSdk.upgradeLoyaltyCard()

package/dist/types/SignedPayload.d.ts

@@ -0,0 +1,5 @@
+export type SignedPayload<T> = {
+    signature: string;
+    signerAddress: string;
+    payload: T;
+};

package/dist/types/SignedPayload.js

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

package/dist/types/UpgradeLoyaltyCardPayload.d.ts

@@ -0,0 +1,3 @@
+export type UpgradeLoyaltyCardPayload = {
+    index: number;
+};

package/dist/types/UpgradeLoyaltyCardPayload.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.2.19",
+  "version": "1.3.0",
   "description": "Drip SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,14 +12,11 @@
   },
   "dependencies": {
     "@spool.fi/spool-v2-sdk": "2.0.31",
-    "ethers": "^5.7.2",
-    "js-cookie": "^3.0.5",
-    "web3-token": "^1.0.6"
+    "ethers": "^5.7.2"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@types/js-cookie": "^3.0.6",
     "@typescript-eslint/eslint-plugin": "^7.12.0",
     "@typescript-eslint/parser": "^7.12.0",
     "eslint": "^8.57.0",

package/dist/types/AuthenticationStatus.d.ts

@@ -1,18 +0,0 @@
-export interface AuthenticationStatus {
-    message: string;
-    isAuthenticated: boolean;
-    address?: string;
-    token?: string;
-}
-export declare class ValidStatus implements AuthenticationStatus {
-    message: string;
-    isAuthenticated: boolean;
-    address: string;
-    token: string;
-    constructor(address: string, token: string);
-}
-export declare class ErrorStatus implements AuthenticationStatus {
-    message: string;
-    isAuthenticated: boolean;
-    constructor(message: string);
-}

package/dist/types/AuthenticationStatus.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorStatus = exports.ValidStatus = void 0;
-class ValidStatus {
-    constructor(address, token) {
-        this.message = 'Valid Token';
-        this.isAuthenticated = true;
-        this.address = address;
-        this.token = token;
-    }
-}
-exports.ValidStatus = ValidStatus;
-class ErrorStatus {
-    constructor(message) {
-        this.isAuthenticated = false;
-        this.message = message;
-    }
-}
-exports.ErrorStatus = ErrorStatus;