@dripfi/drip-sdk 1.0.9 → 1.0.11

package/.eslintrc.json

@@ -0,0 +1,38 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "plugins": [
+    "@typescript-eslint"
+  ],
+  "rules": {
+    "quotes": [
+      "error",
+      "single"
+    ],
+    "semi": "off",
+    "@typescript-eslint/semi": "error",
+    "@typescript-eslint/no-explicit-any": "off",
+    "curly": "error"
+  },
+  "overrides": [
+    {
+      "files": [
+        "tests/**/*"
+      ],
+      "env": {
+        "jest": true
+      }
+    }
+  ]
+}

package/.vscode/settings.json

@@ -0,0 +1,17 @@
+{
+    "editor.defaultFormatter": "dbaeumer.vscode-eslint",
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit"
+    },
+    "editor.formatOnSave": true,
+    "[javascript]": {
+      "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+    },
+    "[typescript]": {
+      "editor.defaultFormatter": "dbaeumer.vscode-eslint"
+    },
+    "eslint.workingDirectories": [
+      {"directory": "./src", "changeProcessCWD": true},
+    ]
+  }
+  

package/README.md

@@ -4,7 +4,14 @@
 
 The Drip SDK is a TypeScript library designed to interact with the Drip protocol. It provides methods to retrieve information about Drip Vaults, manage user authentication, and fetch user balances.
 
-## Installation
+## Table of Contents
+- [Installation](#installation)
+- [Usage](#usage)
+- [Methods](#methods)
+- [Examples](#examples)
+- [Types](#types)
+
+# Installation
 
 To use the Drip SDK in your project, you can install it via npm or yarn:
 
@@ -12,7 +19,7 @@ To use the Drip SDK in your project, you can install it via npm or yarn:
 npm i @dripfi/drip-sdk
 ```
 
-## Usage
+# Usage
 
 ```typescript
 import DripSdk from '@drip/sdk'
@@ -32,44 +39,146 @@ const signer: ethers.Signer = /* your Signer instance */;
 const dripSdk = new DripSdk(dripConfig, signer);
 ```
 
-## Methods
+# Methods
+
+| Name | Requires authentication | Description |
+| ------ | ------ | ----------- |
+| `getAllVaults(): Promise<Vault[]>`| No | Fetches details of all Drip Vaults. |
+| `getVaultDetails(vaultAddress: string): Promise<Vault>` | NO | Fetches details of a specific Drip Vault identified by its address. |
+| `authenticate(): Promise<boolean>` | NO | Initiates the user authentication process and returns a boolean indicating success. |
+| `isUserAuthenticated(): Promise<AuthenticationStatus>` | NO | Checks if the user is authenticated and returns authentication status along with relevant information. |
+| `updateSigner(newSigner: Signer): Promise<void>`| NO | Updates the signer for the SDK instance. |
+| `getUserBalance(vault: Vault): Promise<UserBalance>` | YES | Fetches the user's balance for a specific Drip Vault. |
+| `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>` | NO | The deposit function allows you to deposit tokens into a specific vault. Returns txHash. |
+| `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>` | YES | The swapAndDeposit function allows you to deposit a different token or ether and it will take care of swapping to the correct token before making the deposit. Returns txHash. |
+| `withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>` | YES | Withdraws tokens from a vault. After withdrawing, you must wait for the withdrawal to be processed by the 'DoHardWork' function, and then you can claim those tokens using claimWithdraws(). Returns txHash. |
+| `claimWithdraws(vaultAddress: string): Promise<string>` | YES | After the withdrawal has been processed by the 'DoHardWork' function, the 'claimWithdraws' function transfers the withdrawn tokens to their personal account. Returns txHash. |
+| `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>` | YES | For users who prefer not to wait for withdrawals to be processed, there is a Fast Withdrawal method. While this approach is more gas-intensive, as users bear the cost of executing the withdrawal process themselves, it allows for instant access to the withdrawn tokens. When utilizing Fast Withdrawal, users immediately receive the tokens, eliminating the need to initiate the 'claimWithdrawal' process separately. Returns txHash. |
+
+
+> [!IMPORTANT]
+> **You must authenticate once for every wallet you want to use**
 
-- `getAllVaults(): Promise<Vault[]>`  
-  Fetches details of all Drip Vaults.
+---
 
-- `getVaultDetails(vaultAddress: string): Promise<Vault> `
-  Fetches details of a specific Drip Vault identified by its address.
+# Examples
 
-- `authenticate(): Promise<boolean>`  
-  Initiates the user authentication process and returns a boolean indicating success.
+### `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>`  
+
+I want to deposit 100 USDC in a USDC vault:
+```typescript
+USDC_TOKEN_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"    --> USDC contract address in tenderly environment
+```
+you can get vault token address from the vault.depositToken.tokenAddress
 
-- `isUserAuthenticated(): Promise<AuthenticationStatus>`  
-  Checks if the user is authenticated and returns authentication status along with relevant information.
+```typescript
+VAULT_ADDRESS = "0x...c167" --> Check vaults returned by getAllVaults() and get vault address like: vault.vaultAddress
 
-- `updateSigner(newSigner: Signer): Promise<void>`  
-  Updates the signer for the SDK instance.
+const txHash = await deposit(USDC_TOKEN_ADDRESS, VAULT_ADDRESS, '100')
+```
 
-- `getUserBalance(vault: Vault): Promise<UserBalance>`  
-  Fetches the user's balance for a specific Drip Vault.
+> [!NOTE]
+> User will be prompted with 2 tx:
+> 1st to approve token usage
+> 2nd to deposit the funds in the vault
 
-- `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<void>`  
-  The deposit function allows you to deposit tokens into a specific vault.
+> [!NOTE]
+> Allowance is calculated by the deposit method, based on the current allowance and the required
 
-- `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<void>`  
-  The swapAndDeposit function allows you to deposit a different token or ether and it will take care of swapping to the correct token before making the deposit
+> [!IMPORTANT]
+> Amount should be formatted, not parsed. In the example we want to deposit 100 USDC so we just input that value instead of adding 6 decimals (100000000)
 
-- `withdraw(vault: Vault, amountToWithdraw?: string): Promise<void>`  
-  Withdraws tokens from a vault. After withdrawing, you must wait for the withdrawal to be processed by the 'DoHardWork' function, and then you can claim those tokens using claimWithdraws()
+---
 
-- `claimWithdraws(vaultAddress: string): Promise<void>`  
-  After the withdrawal has been processed by the 'DoHardWork' function, the 'claimWithdraws' function transfers the withdrawn tokens to their personal account.
+### `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>`  
 
-- `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<void>`  
-  For users who prefer not to wait for withdrawals to be processed, there is a Fast Withdrawal method. While this approach is more gas-intensive, as users bear the cost of executing the withdrawal process themselves, it allows for instant access to the withdrawn tokens. When utilizing Fast Withdrawal, users immediately receive the tokens, eliminating the need to initiate the 'claimWithdrawal' process separately.
+I want to deposit 1.5ETH in a WETH vault:
 
-## Types
+```typescript
+WETH_TOKEN_ADDRESS = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"    --> WETH contract address in tenderly environment
 
+const txHash = await swapAndDeposit(WETH_TOKEN_ADDRESS, WETH_TOKEN_ADDRESS, '0', vaultAddress, '1.5')
 ```
+you can get vault token address from the vault.depositToken.tokenAddress
+
+> [!IMPORTANT]
+> ethAmount and fromTokenAmount should be formatted, not parsed. In the example we want to deposit 1.5 WETH so we just input that value instead of adding 18 decimals (1500000000000000000)
+
+---
+
+### `withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`  
+
+```typescript
+ const userBalanceObject = await getUserBalance()
+ const balance = userBalanceObject.userbalance
+```
+> [!NOTE]
+> If i check balance, that is the max amount I can withdraw
+
+I want to withdraw 100 USDC from the 1st vault fetched. ---> Let's assume the first vault is a USDC vault for simplicity
+Fetch vaults returned by getAllVault() and pass the vault you want to withdraw from, and the amount to withdraw (100 in this example)
+
+```typescript
+const vaults = await getAllVaults()
+const vaultToWithdrawFrom = vaults[0]
+
+const txHash = await withdraw(vaultToWithdrawFrom, '100')
+```
+
+if you want to withdraw all funds in the vault, don't specify the amountToWithdraw:
+
+```typescript
+const txHash = await withdraw(vaultToWithdrawFrom)
+```
+> [!IMPORTANT]
+> you will have to claim your withdraws after DHW is processed to transfer the withdrawn funds to your wallet
+
+---
+
+### `claimWithdraws(vaultAddress: string): Promise<string>`  
+
+```typescript
+ const userBalanceObject = await getUserBalance()
+ const hasWithdrawsToClaim = userBalanceObject.hasWithdrawsToClaim
+```
+ if hasWithdrawsToClaim is true you have available funds to transfer to your address 
+
+```typescript
+ const txHash = await claimWithdraws()
+```
+It will transfer all available funds withdrawn with withdraw() function, to your address
+
+---
+
+### `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`  
+
+```typescript
+ const userBalanceObject = await getUserBalance()
+ const balance = userBalanceObject.userbalance
+```
+
+> [!NOTE]
+> If i check balance, that is the max amount I can withdraw
+
+I want to withdraw 3.55 WETH from the 1st vault fetched. ---> Let's assume the first vault is a WETH vault for simplicity
+Fetch vaults returned by getAllVault() and pass the vault you want to withdraw from, and the amount to withdraw (3.55 in this example)
+
+```typescript
+const vaults = await getAllVaults()
+const vaultToWithdrawFrom = vaults[0]
+
+const txHash = await fastWithdraw(vaultToWithdrawFrom, '3.55')
+```
+
+if you want to withdraw all funds in the vault, don't specify the amountToWithdraw, like:
+
+```typescript
+const txHash = await fastWithdraw(vaultToWithdrawFrom)
+```
+
+# Types
+
+```typescript
 type Vault = {
   vaultName: string
   vaultAddress: string
@@ -117,7 +226,7 @@ type NFTBoost = {
   multiplier: number
   nftAddress: string
   network: string
-  initialBlock: number // needs to be the block when rewards was deployed
+  initialBlock: number
   imagePath: string
 }
 
@@ -130,7 +239,11 @@ interface StretchGoal {
 }
 
 type RewardsInformation = {
-  [tokenAddress: string]: { blockNumber: string; rewardrate: string; timestamp: string; endTime: string }
+  [tokenAddress: string]: { 
+    blockNumber: string; 
+    rewardrate: string; 
+    timestamp: string; 
+    endTime: string }
 }
 
 type Strategy = {
@@ -167,4 +280,13 @@ type SwapInfo = {
   token: string
   swapCallData: any
 }
+
+type UserBalance = {
+  hasWithdrawsToClaim: boolean
+  userBalance: string
+  pendingUserBalance: string
+  pendingWithdrawalBalance: string
+  withdrawableBalance: string
+};
+
 ```

package/dist/DripApi.d.ts

@@ -11,6 +11,7 @@ export default class DripApi {
     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): Promise<any[]>;
     fetchAllUserDNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]>;

package/dist/DripApi.js

@@ -78,6 +78,17 @@ class DripApi {
             return data;
         });
     }
+    fetchEnrichedUserWNFTForVault(vaultAddress, walletAddress, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = new Headers();
+            headers.append('Authorization', token);
+            const res = yield fetch(`/api-be/api/spool/user/wNft/${walletAddress}/${vaultAddress}`, {
+                headers,
+            });
+            const data = yield res.json();
+            return data;
+        });
+    }
     fetchUserSVTFromNfts(vaultAddress, userAddress, dnfts, token) {
         return __awaiter(this, void 0, void 0, function* () {
             const headers = new Headers();

package/dist/DripConfig.js

@@ -18,8 +18,9 @@ class DripConfig {
     }
     getSwapAndDepositContractAddress(signer) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!signer)
+            if (!signer) {
                 throw Error('No signer provided');
+            }
             if (!this.swapAndDepositContractAddress) {
                 const contract = yield this.internalConfig.getChainAddresses(signer);
                 this.swapAndDepositContractAddress = contract.IDepositSwap;
@@ -29,8 +30,9 @@ class DripConfig {
     }
     getSmartVaultManagerAddress(signer) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!signer)
+            if (!signer) {
                 throw Error('No signer provided');
+            }
             if (!this.smartVaultManagerAddress) {
                 const contract = yield this.internalConfig.getChainAddresses(signer);
                 this.smartVaultManagerAddress = contract.ISmartVaultManager;

package/dist/DripSdk.d.ts

@@ -15,11 +15,11 @@ export default class DripSdk {
     isUserAuthenticated(): Promise<AuthenticationStatus>;
     updateSigner(newSigner: Signer): void;
     getUserBalance(vault: Vault): Promise<UserBalance>;
-    fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<void>;
-    deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<void>;
-    swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<void>;
-    withdraw(vault: Vault, amountToWithdraw?: string): Promise<void>;
-    claimWithdraws(vaultAddress: string): Promise<void>;
+    fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>;
+    deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
+    swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>;
+    withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>;
+    claimWithdraws(vaultAddress: string): Promise<string>;
     private generateOldRedeemBagStruct;
     private generateNewRedeemBagStruct;
     private getAllSvts;
@@ -32,7 +32,6 @@ export default class DripSdk {
     private calculateBalanceForDNFT;
     private checkIfUserHasWithdrawsToClaim;
     private shouldUseNewWithdrawLogic;
-    private generateToken;
     private calculateAllWithdrawalBalances;
     private getTokenAllowanceForSwapAndDepositContractAddress;
     private approveTokenForSwapAndDepositContract;

package/dist/DripSdk.js

@@ -41,8 +41,9 @@ class DripSdk {
     authenticate() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.signer)
+                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((msg) => __awaiter(this, void 0, void 0, function* () { return yield this.signer.signMessage(msg); }), {
@@ -90,15 +91,16 @@ class DripSdk {
     getUserBalance(vault) {
         return __awaiter(this, void 0, void 0, function* () {
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated)
+            if (!authData.isAuthenticated) {
                 throw Error(`User not authenticated: ${authData.message}`);
+            }
             const userAddress = authData.address;
             const token = authData.token;
             const dnfts = yield this.dripApi.fetchAllUserDNFTForVault(vault.vaultAddress, userAddress, token);
             const wnfts = yield this.dripApi.fetchAllUserWNFTForVault(vault.vaultAddress, userAddress, token);
             const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress);
             if (this.shouldUseNewWithdrawLogic(userAddress, vault)) {
-                const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = yield this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals);
+                const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = yield this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals, token);
                 const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts);
                 const pendingDeposits = this.calculatePendingDeposits(dnfts, decimals);
                 const userBalance = this.calculateAllDeposits(dnfts, decimals).sub(pendingDeposits);
@@ -113,10 +115,10 @@ class DripSdk {
             else {
                 const allDeposits = this.calculateDepositsOld(dnfts, decimals);
                 const pendingDeposits = this.calculatePendingDepositsOld(dnfts, decimals);
-                const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals] = yield this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals);
-                const fastWithdrawBalance = yield this.calculateFastWithdrawBalancesOld(vault.vaultAddress, userAddress, decimals);
+                const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals] = yield this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals, token);
+                const fastWithdrawBalance = yield this.calculateFastWithdrawBalancesOld(authData.token, vault.vaultAddress, userAddress, decimals);
                 const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts);
-                let balance = allDeposits
+                const balance = allDeposits
                     .sub(estimatedWithdrawals)
                     .sub(estimatedWithdrawableBalance)
                     .sub(estimatedPendingWithdrawalBalance)
@@ -133,105 +135,144 @@ class DripSdk {
     }
     fastWithdraw(vault, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
-            // if (!this.signer) throw Error('No signer provided')
-            // try {
-            //     const signerAddress = await this.signer.getAddress()
-            //     if (!signerAddress) throw Error('Error fetching address')
-            //     const redeemBagStruct: RedeemBagStruct = this.shouldUseNewWithdrawLogic(signerAddress, vault)
-            //         ? await this.generateNewRedeemBagStruct(vault, signerAddress, amountToWithdraw)
-            //         : await this.generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw)
-            //     const currentBlockNumber = await this.signer.provider?.getBlockNumber()
-            //     if (!currentBlockNumber) throw Error('Error fetching block number')
-            //     const redeemTx = await this.spoolSdk?.redeemFast(
-            //         redeemBagStruct,
-            //         signerAddress.toLowerCase(),
-            //         currentBlockNumber,
-            //     )
-            //     const redeemTxReceipt = await redeemTx!.wait()
-            // } catch (error) {
-            //     console.log(error)
-            // }
+            var _a, _b;
+            const authData = yield this.isUserAuthenticated();
+            if (!authData.isAuthenticated) {
+                throw Error(`User not authenticated: ${authData.message}`);
+            }
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            const signerAddress = yield this.signer.getAddress();
+            if (!signerAddress) {
+                throw Error('Error fetching address');
+            }
+            const redeemBagStruct = this.shouldUseNewWithdrawLogic(signerAddress, vault)
+                ? yield this.generateNewRedeemBagStruct(authData.token, vault, signerAddress, amountToWithdraw)
+                : yield this.generateOldRedeemBagStruct(authData.token, vault, signerAddress, 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, signerAddress.toLowerCase(), currentBlockNumber));
+            const txReceipt = yield redeemTx.wait();
+            return txReceipt.transactionHash;
         });
     }
     deposit(tokenAddress, vaultAddress, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            // if (!this.signer) throw Error('No signer provided')
-            // const currentTokenAllowance = await this.getTokenAllowanceForDeposit(tokenAddress)
-            // const decimals = await this.getERC20Precission(tokenAddress)
-            // let amountToWithdrawFixedDecimals = parseFloat(amount).toFixed(decimals)
-            // const amountToDeposit = ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals)
-            // if (amountToDeposit.gt(currentTokenAllowance)) {
-            //     const requiredTokenAllowance = amountToDeposit.sub(currentTokenAllowance)
-            //     await this.approveTokenForDeposit(tokenAddress, requiredTokenAllowance)
-            // }
-            // const signerAddress = await this.signer.getAddress()
-            // if (!signerAddress) throw Error('Error fetching address')
-            // const depositBagStruct: DepositBagStruct = {
-            //     smartVault: vaultAddress,
-            //     assets: [amountToDeposit],
-            //     receiver: signerAddress,
-            //     referral: ethers.constants.AddressZero,
-            //     doFlush: false,
-            // }
-            // const depositTx = await this.spoolSdk!.deposit(depositBagStruct)
-            // await depositTx.wait()
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            const currentTokenAllowance = yield this.getTokenAllowanceForDeposit(tokenAddress);
+            const decimals = yield this.getERC20Precission(tokenAddress);
+            const amountToWithdrawFixedDecimals = parseFloat(amount).toFixed(decimals);
+            const amountToDeposit = ethers_1.ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals);
+            if (amountToDeposit.gt(currentTokenAllowance)) {
+                const requiredTokenAllowance = amountToDeposit.sub(currentTokenAllowance);
+                yield this.approveTokenForDeposit(tokenAddress, requiredTokenAllowance);
+            }
+            const signerAddress = yield this.signer.getAddress();
+            if (!signerAddress) {
+                throw Error('Error fetching address');
+            }
+            const depositBagStruct = {
+                smartVault: vaultAddress,
+                assets: [amountToDeposit],
+                receiver: signerAddress,
+                referral: ethers_1.ethers.constants.AddressZero,
+                doFlush: false,
+            };
+            const depositTx = yield this.spoolSdk.deposit(depositBagStruct);
+            const txReceipt = yield depositTx.wait();
+            return txReceipt.transactionHash;
         });
     }
     swapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, ethAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            // if (!this.signer) throw Error('No signer provided')
-            // const decimals = await this.getERC20Precission(fromTokenAddress)
-            // const amountToWithdrawFixedDecimals = parseFloat(fromTokenAmount).toFixed(decimals)
-            // const fromToken = ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals)
-            // const signerAddress = await this.signer.getAddress()
-            // if (fromToken.gt(BigNumber.from(0))) {
-            //     const currentTokenAllowance = await this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress)
-            //     if (fromToken.gt(currentTokenAllowance)) {
-            //         await this.approveTokenForSwapAndDepositContract(fromTokenAddress, fromToken.sub(currentTokenAllowance))
-            //     }
-            // }
-            // const swapInfo = await this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, signerAddress)
-            // const swapDepositBagStruct = {
-            //     inTokens: [fromTokenAddress],
-            //     inAmounts: [fromToken],
-            //     smartVault: vaultAddress,
-            //     swapInfo,
-            //     receiver: signerAddress,
-            //     referral: ethers.constants.AddressZero,
-            //     doFlush: false,
-            // }
-            // let swapAndDepositRequest: ethers.ContractTransaction | undefined
-            // if (ethAmount) {
-            //     const eth = ethers.utils.parseEther(ethAmount)
-            //     swapAndDepositRequest = await this.spoolSdk?.swapAndDeposit(swapDepositBagStruct, { value: eth })
-            // } else {
-            //     swapAndDepositRequest = await this.spoolSdk?.swapAndDeposit(swapDepositBagStruct)
-            // }
-            // await swapAndDepositRequest?.wait()
+            const authData = yield this.isUserAuthenticated();
+            if (!authData.isAuthenticated) {
+                throw Error(`User not authenticated: ${authData.message}`);
+            }
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            const decimals = yield this.getERC20Precission(fromTokenAddress);
+            const amountToWithdrawFixedDecimals = parseFloat(fromTokenAmount).toFixed(decimals);
+            const fromToken = ethers_1.ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals);
+            const signerAddress = yield this.signer.getAddress();
+            if (fromToken.gt(ethers_1.BigNumber.from(0))) {
+                const currentTokenAllowance = yield this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress);
+                if (fromToken.gt(currentTokenAllowance)) {
+                    yield this.approveTokenForSwapAndDepositContract(fromTokenAddress, fromToken.sub(currentTokenAllowance));
+                }
+            }
+            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, signerAddress);
+            const swapDepositBagStruct = {
+                inTokens: [fromTokenAddress],
+                inAmounts: [fromToken],
+                smartVault: vaultAddress,
+                swapInfo,
+                receiver: signerAddress,
+                referral: ethers_1.ethers.constants.AddressZero,
+                doFlush: false,
+            };
+            const swapAndDepositRequest = ethAmount
+                ? yield this.spoolSdk.swapAndDeposit(swapDepositBagStruct, { value: ethers_1.ethers.utils.parseEther(ethAmount) })
+                : yield this.spoolSdk.swapAndDeposit(swapDepositBagStruct);
+            const txReceipt = yield swapAndDepositRequest.wait();
+            return txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionHash;
         });
     }
     withdraw(vault, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
-            // if (!this.signer) throw Error('No signer provided')
-            // try {
-            //     const signerAddress = await this.signer.getAddress()
-            //     if (!signerAddress) throw Error('Error fetching address')
-            //     const redeemBagStruct: RedeemBagStruct = this.shouldUseNewWithdrawLogic(signerAddress, vault)
-            //         ? await this.generateNewRedeemBagStruct(vault, signerAddress, amountToWithdraw)
-            //         : await this.generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw)
-            //     const redeemTx = await this.spoolSdk!.redeem(redeemBagStruct, signerAddress.toLowerCase(), false)
-            //     const redeemTxReceipt = await redeemTx.wait()
-            // } catch (error) {
-            //     console.log(error)
-            // }
+            const authData = yield this.isUserAuthenticated();
+            if (!authData.isAuthenticated) {
+                throw Error(`User not authenticated: ${authData.message}`);
+            }
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            const signerAddress = yield this.signer.getAddress();
+            if (!signerAddress) {
+                throw Error('Error fetching address');
+            }
+            const redeemBagStruct = this.shouldUseNewWithdrawLogic(signerAddress, vault)
+                ? yield this.generateNewRedeemBagStruct(authData.token, vault, signerAddress, amountToWithdraw)
+                : yield this.generateOldRedeemBagStruct(authData.token, vault, signerAddress, amountToWithdraw);
+            const redeemTx = yield this.spoolSdk.redeem(redeemBagStruct, signerAddress.toLowerCase(), false);
+            const redeemTxReceipt = yield redeemTx.wait();
+            return redeemTxReceipt.transactionHash;
         });
     }
     claimWithdraws(vaultAddress) {
-        return __awaiter(this, void 0, void 0, function* () { });
+        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');
+            }
+            const signerAddress = yield this.signer.getAddress();
+            if (!signerAddress) {
+                throw Error('Error fetching address');
+            }
+            const wnfts = yield this.dripApi.fetchEnrichedUserWNFTForVault(vaultAddress, signerAddress, 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)
+                .map((item) => item.nftId.toString());
+            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, signerAddress.toLowerCase());
+            const txReceipt = yield claimWithdrawTx.wait();
+            return txReceipt.transactionHash;
+        });
     }
-    generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
+    generateOldRedeemBagStruct(token, vault, signerAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.generateToken();
             const dnfts = yield this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress, signerAddress, token);
             const userBalance = yield this.dripApi.fetchUserBalance(vault.vaultAddress, signerAddress, token);
             const totalTokenBalance = ethers_1.BigNumber.from(userBalance[vault.depositToken.tokenAddress]);
@@ -244,7 +285,7 @@ class DripSdk {
             }
             else {
                 //! Not a MAX Withdraw (calculate the shares to withdraw)
-                let amountToWithdrawFixedDecimals = parseFloat(amountToWithdraw).toFixed(decimals);
+                const amountToWithdrawFixedDecimals = parseFloat(amountToWithdraw).toFixed(decimals);
                 sharesToWithdraw = ethers_1.ethers.utils
                     .parseUnits(amountToWithdrawFixedDecimals, decimals)
                     .mul(totalShares)
@@ -267,32 +308,32 @@ class DripSdk {
             };
         });
     }
-    generateNewRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
+    generateNewRedeemBagStruct(token, vault, signerAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.generateToken();
             const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress.toLowerCase());
             const withdrawAll = !amountToWithdraw;
             const initialAmountToWithdraw = ethers_1.ethers.utils.parseUnits(amountToWithdraw || '0', decimals);
             let totalAmountToWithdraw = initialAmountToWithdraw;
             let dnfts = yield this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress.toLowerCase(), signerAddress, token);
-            dnfts = yield this.getAllSvts(vault.vaultAddress.toLowerCase(), signerAddress, dnfts);
+            dnfts = yield this.getAllSvts(vault.vaultAddress.toLowerCase(), signerAddress, dnfts, token);
             let shares = ethers_1.BigNumber.from(0);
-            let nftIds = [];
-            let nftAmounts = [];
+            const nftIds = [];
+            const nftAmounts = [];
             let index = 0;
             while (dnfts[index] && (totalAmountToWithdraw.gt(0) || withdrawAll)) {
                 const dnft = dnfts[index];
                 const userBalance = this.calculateBalanceForDNFT(dnft, decimals);
                 if (userBalance.gt(0)) {
-                    let amountToWithdraw = totalAmountToWithdraw;
+                    const amountToWithdraw = totalAmountToWithdraw;
                     const userSvts = dnft.svts;
                     let svtsToWithdraw = ethers_1.BigNumber.from(0);
                     let nftAmount = ethers_1.BigNumber.from(0);
                     if (amountToWithdraw.gte(userBalance) || withdrawAll) {
                         nftAmount = dnft.shares;
                         svtsToWithdraw = userSvts;
-                        if (!withdrawAll)
+                        if (!withdrawAll) {
                             totalAmountToWithdraw = totalAmountToWithdraw.sub(userBalance);
+                        }
                     }
                     else {
                         nftAmount = amountToWithdraw.mul(dnft.shares).div(userBalance);
@@ -313,9 +354,8 @@ class DripSdk {
             };
         });
     }
-    getAllSvts(vaultAddress, userAddress, dnfts) {
+    getAllSvts(vaultAddress, userAddress, dnfts, token) {
         return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.generateToken();
             const svts = yield this.dripApi.fetchUserSVTFromNfts(vaultAddress, userAddress, dnfts.map((element) => parseInt(element.nftId)), token);
             const result = dnfts.map((element, index) => {
                 return { nftId: element.nftId, assets: element.assets, shares: element.shares, svts: svts[index] };
@@ -325,19 +365,20 @@ class DripSdk {
     }
     getERC20Precission(tokenAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
+            if (!this.signer) {
                 throw Error('No signer provided');
+            }
             const signerAddress = yield this.signer.getAddress();
-            if (!signerAddress)
+            if (!signerAddress) {
                 throw Error('Error fetching address');
+            }
             const erc20Instance = spool_v2_sdk_1.ERC20__factory.connect(tokenAddress, this.signer);
             const decimals = yield erc20Instance.decimals();
             return decimals;
         });
     }
-    calculateFastWithdrawBalancesOld(vaultAddress, userAddress, decimals) {
+    calculateFastWithdrawBalancesOld(token, vaultAddress, userAddress, decimals) {
         return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.generateToken();
             const fastWithdrawNFTs = yield this.dripApi.fetchFastWithdrawNFTs(vaultAddress, userAddress, token);
             let fastWithdrawBalance = 0;
             for (const wnft of fastWithdrawNFTs) {
@@ -414,19 +455,11 @@ class DripSdk {
         }
         return vault.newWithdraw;
     }
-    generateToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
-                throw Error('No signer provided');
-            const token = yield web3_token_1.default.sign((msg) => __awaiter(this, void 0, void 0, function* () { return yield this.signer.signMessage(msg); }), '1d');
-            return token;
-        });
-    }
-    calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals) {
+    calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals, token) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
+            if (!this.signer) {
                 throw Error('No signer provided');
-            const userAddress = yield this.signer.getAddress();
+            }
             let estimatedPendingWithdrawalBalance = ethers_1.BigNumber.from(0);
             let estimatedWithdrawableBalance = ethers_1.BigNumber.from(0);
             let withdrawals = 0;
@@ -437,7 +470,6 @@ class DripSdk {
                     continue;
                 }
                 const currentBlockNumber = wnft.blockNumber - 1;
-                const token = yield this.generateToken();
                 const assetsPerSvtAtBlock = yield this.dripApi.fetchAssetPerSvtAtBlock(vaultAddress, currentBlockNumber, token);
                 const estimatedValueOfNFT = ethers_1.BigNumber.from(parseInt(ethers_1.ethers.utils.formatUnits(ethers_1.BigNumber.from(wnft.svtWithdrawn).mul(assetsPerSvtAtBlock), 36)).toString());
                 if (wnft.isDHWFinished) {
@@ -457,11 +489,13 @@ class DripSdk {
     }
     getTokenAllowanceForSwapAndDepositContractAddress(tokenAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
+            if (!this.signer) {
                 throw Error('No signer provided');
+            }
             const signerAddress = yield this.signer.getAddress();
-            if (!signerAddress)
+            if (!signerAddress) {
                 throw Error('Error fetching address');
+            }
             const erc20Instance = spool_v2_sdk_1.ERC20__factory.connect(tokenAddress, this.signer);
             const swapAndDepositAddress = yield this.dripConfig.getSwapAndDepositContractAddress(this.signer);
             const allowance = yield erc20Instance.allowance(signerAddress, swapAndDepositAddress);
@@ -470,8 +504,9 @@ class DripSdk {
     }
     approveTokenForSwapAndDepositContract(tokenAddress, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
+            if (!this.signer) {
                 throw Error('No signer provided');
+            }
             const swapAndDepositContractAddress = yield this.dripConfig.getSwapAndDepositContractAddress(this.signer);
             const erc20Instance = spool_v2_sdk_1.ERC20__factory.connect(tokenAddress, this.signer);
             const approveTx = yield erc20Instance.approve(swapAndDepositContractAddress, amount);
@@ -480,11 +515,13 @@ class DripSdk {
     }
     getTokenAllowanceForDeposit(tokenAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
+            if (!this.signer) {
                 throw Error('No signer provided');
+            }
             const signerAddress = yield this.signer.getAddress();
-            if (!signerAddress)
+            if (!signerAddress) {
                 throw Error('Error fetching address');
+            }
             const erc20Instance = spool_v2_sdk_1.ERC20__factory.connect(tokenAddress, this.signer);
             const smartVaultManagerAddress = yield this.dripConfig.getSmartVaultManagerAddress(this.signer);
             const allowance = yield erc20Instance.allowance(signerAddress, smartVaultManagerAddress);
@@ -493,8 +530,9 @@ class DripSdk {
     }
     approveTokenForDeposit(tokenAddress, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
+            if (!this.signer) {
                 throw Error('No signer provided');
+            }
             const smartVaultManagerAddress = yield this.dripConfig.getSmartVaultManagerAddress(this.signer);
             const erc20Instance = spool_v2_sdk_1.ERC20__factory.connect(tokenAddress, this.signer);
             const approveTx = yield erc20Instance.approve(smartVaultManagerAddress, amount);

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@dripfi/drip-sdk",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Drip SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "prepublish": "npm run build",
     "build": "tsc",
-    "format": "prettier --write .",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
     "@spool.fi/spool-v2-sdk": "1.0.14",
     "ethers": "^5.7.2",
-    "web3-token": "^1.0.6",
-    "js-cookie": "^3.0.5"
+    "js-cookie": "^3.0.5",
+    "web3-token": "^1.0.6"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "typescript": "^5.4.5",
     "@types/js-cookie": "^3.0.6",
-    "prettier": "3.2.5",
-    "prettier-plugin-tailwindcss": "^0.5.12"
+    "@typescript-eslint/eslint-plugin": "^7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
+    "eslint": "^8.57.0",
+    "typescript": "^5.4.5"
   }
 }

package/.prettierignore

@@ -1,2 +0,0 @@
-dist/
-node_modules/

package/.prettierrc

@@ -1,11 +0,0 @@
-{
-  "printWidth": 120,
-  "useTabs": false,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "jsxSingleQuote": true,
-  "semi": false,
-  "trailingComma": "all",
-  "arrowParens": "always",
-  "plugins": ["prettier-plugin-tailwindcss"]
-}

package/dist/test.d.ts

@@ -1,2 +0,0 @@
-import { ethers } from 'ethers';
-export declare const signer: ethers.Wallet;

package/dist/test.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.signer = void 0;
-const ethers_1 = require("ethers");
-const _1 = require(".");
-const dripProdConfig = new _1.DripConfig('https://subgraph.satsuma-prod.com/49eb322da234/solidant/spool-v2/api', 'https://pricefeed.v2.spool.fi/', 'https://rewards.v2.spool.fi/', 'https://fastwithdraw.v2.spool.fi/', {
-    1: {
-        ISmartVaultManager: '0x23Daf34e2b9Af02A74dC19cB52Af727B19403874',
-        IDepositSwap: '0xd8534197Bd587F8226d12E0C864ef2CaE6f82f5C',
-        ISmartVaultFactory: '0x8049Fc710D4a1Deea6a6bCeF772C166CEd7A82F5',
-        IDepositManager: '0x823Ba38992825FF37E72B6c3D669a09173B8F7bf',
-        IRewardManager: '0xd8d2C1C3C7982272e3e12dEC5aF681433fdcf003',
-        IStrategyRegistry: '0x554c6bCB54656390aca0a0af38CA954dbE653F15',
-        ISpoolLens: '0x8aa6174333F75421903b2B5c70DdF8DA5D84f74F',
-    },
-}, 'http://localhost:7070');
-const provider = new ethers_1.ethers.providers.StaticJsonRpcProvider('https://mainnet.infura.io/v3/fa1bf2cea12147559c9634e80be76d61', 1);
-exports.signer = new ethers_1.ethers.Wallet('6ffc226f7b7769e27124317372c9dbb579a324e67e97bf07131bf2f59ec0f4fe', provider);
-const dripSdk = new _1.DripSdk(dripProdConfig, exports.signer);
-// dripSdk.isUserAuthenticated().then((result) => {
-//     console.log(result)
-// }).catch((error) => {
-//     console.log(error)
-// })