@dripfi/drip-sdk 1.0.10 → 1.0.12

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,147 @@ 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. |
+| `getRewards(): Promise<UserRewards>` | YES | Fetches the current user's rewards points for each vault. |
+
+
+> [!IMPORTANT]
+> **You must authenticate once for every wallet you want to use**
+
+---
+
+# Examples
+
+### `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
+
+```typescript
+VAULT_ADDRESS = "0x...c167" --> Check vaults returned by getAllVaults() and get vault address like: vault.vaultAddress
+
+const txHash = await deposit(USDC_TOKEN_ADDRESS, VAULT_ADDRESS, '100')
+```
+
+> [!NOTE]
+> User will be prompted with 2 tx:
+> 1st to approve token usage
+> 2nd to deposit the funds in the vault
+
+> [!NOTE]
+> Allowance is calculated by the deposit method, based on the current allowance and the required
+
+> [!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)
+
+---
+
+### `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>`  
+
+I want to deposit 1.5ETH in a WETH vault:
+
+```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)
 
-- `getAllVaults(): Promise<Vault[]>`  
-  Fetches details of all Drip Vaults.
+```typescript
+const vaults = await getAllVaults()
+const vaultToWithdrawFrom = vaults[0]
 
-- `getVaultDetails(vaultAddress: string): Promise<Vault> `
-  Fetches details of a specific Drip Vault identified by its address.
+const txHash = await withdraw(vaultToWithdrawFrom, '100')
+```
 
-- `authenticate(): Promise<boolean>`  
-  Initiates the user authentication process and returns a boolean indicating success.
+if you want to withdraw all funds in the vault, don't specify the amountToWithdraw:
 
-- `isUserAuthenticated(): Promise<AuthenticationStatus>`  
-  Checks if the user is authenticated and returns authentication status along with relevant information.
+```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
 
-- `updateSigner(newSigner: Signer): Promise<void>`  
-  Updates the signer for the SDK instance.
+---
 
-- `getUserBalance(vault: Vault): Promise<UserBalance>`  
-  Fetches the user's balance for a specific Drip Vault.
+### `claimWithdraws(vaultAddress: string): Promise<string>`  
 
-- `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<void>`  
-  The deposit function allows you to deposit tokens into a specific vault.
+```typescript
+ const userBalanceObject = await getUserBalance()
+ const hasWithdrawsToClaim = userBalanceObject.hasWithdrawsToClaim
+```
+ if hasWithdrawsToClaim is true you have available funds to transfer to your address 
 
-- `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
+```typescript
+ const txHash = await claimWithdraws()
+```
+It will transfer all available funds withdrawn with withdraw() function, to your address
 
-- `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.
+### `fastWithdraw(vault: Vault, amountToWithdraw?: 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.
+```typescript
+ const userBalanceObject = await getUserBalance()
+ const balance = userBalanceObject.userbalance
+```
 
-## Types
+> [!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 +227,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 +240,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 +281,17 @@ type SwapInfo = {
   token: string
   swapCallData: any
 }
+
+type UserBalance = {
+  hasWithdrawsToClaim: boolean
+  userBalance: string
+  pendingUserBalance: string
+  pendingWithdrawalBalance: string
+  withdrawableBalance: string
+};
+
+type UserRewards = {
+   [key: string]: { [key: string]: number } 
+};
+
 ```

package/dist/DripApi.d.ts

@@ -2,6 +2,7 @@ import { BigNumber } from 'ethers';
 import { Vault } from './types/Vault';
 import { SwapInfo } from './types/SwapInfo';
 import { QLFastRedeem } from './types/QLFastRedeem';
+import { UserRewards } from './types/UserRewards';
 export default class DripApi {
     route: string;
     constructor(route: string);
@@ -17,4 +18,5 @@ export default class DripApi {
     fetchAllUserDNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]>;
     fetchAssetPerSvtAtBlock(vaultAddress: string, blocknumber: number, token: string): Promise<BigNumber>;
     fetchFastWithdrawNFTs(vaultAddress: string, walletAddress: string, token: string): Promise<QLFastRedeem[]>;
+    fetchUserRewards(walletAddress: string, token: string): Promise<UserRewards>;
 }

package/dist/DripApi.js

@@ -144,5 +144,16 @@ class DripApi {
             return data;
         });
     }
+    fetchUserRewards(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/user/rewards/${walletAddress}`, {
+                headers,
+            });
+            const data = yield res.json();
+            return data;
+        });
+    }
 }
 exports.default = DripApi;

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

@@ -3,6 +3,7 @@ import { Signer } from 'ethers';
 import { DripConfig } from './DripConfig';
 import { UserBalance } from './types/UserBalance';
 import { AuthenticationStatus } from './types/AuthenticationStatus';
+import { UserRewards } from './types/UserRewards';
 export default class DripSdk {
     private dripApi;
     private spoolSdk?;
@@ -14,12 +15,13 @@ export default class DripSdk {
     authenticate(): Promise<boolean>;
     isUserAuthenticated(): Promise<AuthenticationStatus>;
     updateSigner(newSigner: Signer): void;
+    getRewards(): Promise<UserRewards>;
     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;

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); }), {
@@ -87,11 +88,22 @@ class DripSdk {
         this.signer = newSigner;
         this.spoolSdk = new spool_v2_sdk_1.SpoolSdk(this.dripConfig.internalConfig, newSigner);
     }
+    getRewards() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const authData = yield this.isUserAuthenticated();
+            if (!authData.isAuthenticated) {
+                throw Error(`User not authenticated: ${authData.message}`);
+            }
+            const userRewards = this.dripApi.fetchUserRewards(authData.address, authData.token);
+            return userRewards;
+        });
+    }
     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);
@@ -116,7 +128,7 @@ class DripSdk {
                 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)
@@ -135,46 +147,41 @@ class DripSdk {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated)
+            if (!authData.isAuthenticated) {
                 throw Error(`User not authenticated: ${authData.message}`);
-            if (!this.signer)
+            }
+            if (!this.signer) {
                 throw Error('No signer provided');
-            try {
-                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 redeemTxReceipt = yield redeemTx.wait();
             }
-            catch (error) {
-                console.log(error);
+            const redeemBagStruct = this.shouldUseNewWithdrawLogic(authData.address, vault)
+                ? yield this.generateNewRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw)
+                : yield this.generateOldRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw);
+            const currentBlockNumber = yield ((_a = this.signer.provider) === null || _a === void 0 ? void 0 : _a.getBlockNumber());
+            if (!currentBlockNumber) {
+                throw Error('Error fetching block number');
             }
+            const redeemTx = yield ((_b = this.spoolSdk) === null || _b === void 0 ? void 0 : _b.redeemFast(redeemBagStruct, authData.address, currentBlockNumber));
+            const txReceipt = yield redeemTx.wait();
+            return txReceipt.transactionHash;
         });
     }
     deposit(tokenAddress, vaultAddress, amount) {
         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)
+            if (!this.signer) {
                 throw Error('No signer provided');
+            }
             const currentTokenAllowance = yield this.getTokenAllowanceForDeposit(tokenAddress);
             const decimals = yield this.getERC20Precission(tokenAddress);
-            let amountToWithdrawFixedDecimals = parseFloat(amount).toFixed(decimals);
+            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)
+            if (!signerAddress) {
                 throw Error('Error fetching address');
+            }
             const depositBagStruct = {
                 smartVault: vaultAddress,
                 assets: [amountToDeposit],
@@ -183,81 +190,72 @@ class DripSdk {
                 doFlush: false,
             };
             const depositTx = yield this.spoolSdk.deposit(depositBagStruct);
-            yield depositTx.wait();
+            const txReceipt = yield depositTx.wait();
+            return txReceipt.transactionHash;
         });
     }
     swapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, ethAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated)
+            if (!authData.isAuthenticated) {
                 throw Error(`User not authenticated: ${authData.message}`);
-            if (!this.signer)
+            }
+            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);
+                const currentTokenAllowance = yield this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress, authData.address);
                 if (fromToken.gt(currentTokenAllowance)) {
                     yield this.approveTokenForSwapAndDepositContract(fromTokenAddress, fromToken.sub(currentTokenAllowance));
                 }
             }
-            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, signerAddress);
+            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, authData.address);
             const swapDepositBagStruct = {
                 inTokens: [fromTokenAddress],
                 inAmounts: [fromToken],
                 smartVault: vaultAddress,
                 swapInfo,
-                receiver: signerAddress,
+                receiver: authData.address,
                 referral: ethers_1.ethers.constants.AddressZero,
                 doFlush: false,
             };
-            let swapAndDepositRequest;
-            if (ethAmount) {
-                const eth = ethers_1.ethers.utils.parseEther(ethAmount);
-                swapAndDepositRequest = yield ((_a = this.spoolSdk) === null || _a === void 0 ? void 0 : _a.swapAndDeposit(swapDepositBagStruct, { value: eth }));
-            }
-            else {
-                swapAndDepositRequest = yield ((_b = this.spoolSdk) === null || _b === void 0 ? void 0 : _b.swapAndDeposit(swapDepositBagStruct));
-            }
-            yield (swapAndDepositRequest === null || swapAndDepositRequest === void 0 ? void 0 : swapAndDepositRequest.wait());
+            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* () {
             const authData = yield this.isUserAuthenticated();
-            if (!authData.isAuthenticated)
+            if (!authData.isAuthenticated) {
                 throw Error(`User not authenticated: ${authData.message}`);
-            if (!this.signer)
-                throw Error('No signer provided');
-            try {
-                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();
             }
-            catch (error) {
-                console.log(error);
+            if (!this.signer) {
+                throw Error('No signer provided');
             }
+            const redeemBagStruct = this.shouldUseNewWithdrawLogic(authData.address, vault)
+                ? yield this.generateNewRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw)
+                : yield this.generateOldRedeemBagStruct(authData.token, vault, authData.address, amountToWithdraw);
+            const redeemTx = yield this.spoolSdk.redeem(redeemBagStruct, authData.address, false);
+            const redeemTxReceipt = yield redeemTx.wait();
+            return redeemTxReceipt.transactionHash;
         });
     }
     claimWithdraws(vaultAddress) {
         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}`);
-            if (!this.signer)
+            }
+            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);
+            }
+            const wnfts = yield this.dripApi.fetchEnrichedUserWNFTForVault(vaultAddress, authData.address, 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)
@@ -265,8 +263,9 @@ class DripSdk {
             const nftAmounts = wnfts
                 .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
                 .map((item) => item.shares.toString());
-            const claimWithdrawTx = yield this.spoolSdk.claimWithdrawal(vaultAddress, nftIds, nftAmounts, signerAddress.toLowerCase());
-            yield claimWithdrawTx.wait();
+            const claimWithdrawTx = yield this.spoolSdk.claimWithdrawal(vaultAddress, nftIds, nftAmounts, authData.address);
+            const txReceipt = yield claimWithdrawTx.wait();
+            return txReceipt.transactionHash;
         });
     }
     generateOldRedeemBagStruct(token, vault, signerAddress, amountToWithdraw) {
@@ -283,7 +282,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)
@@ -315,22 +314,23 @@ class DripSdk {
             let dnfts = yield this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress.toLowerCase(), signerAddress, token);
             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);
@@ -362,11 +362,9 @@ 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)
-                throw Error('Error fetching address');
+            }
             const erc20Instance = spool_v2_sdk_1.ERC20__factory.connect(tokenAddress, this.signer);
             const decimals = yield erc20Instance.decimals();
             return decimals;
@@ -452,9 +450,9 @@ class DripSdk {
     }
     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;
@@ -482,23 +480,22 @@ class DripSdk {
             return [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals];
         });
     }
-    getTokenAllowanceForSwapAndDepositContractAddress(tokenAddress) {
+    getTokenAllowanceForSwapAndDepositContractAddress(tokenAddress, userAddress) {
         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)
-                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);
+            const allowance = yield erc20Instance.allowance(userAddress, swapAndDepositAddress);
             return allowance;
         });
     }
     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);
@@ -507,11 +504,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);
@@ -520,8 +519,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/dist/types/UserRewards.d.ts

@@ -0,0 +1,5 @@
+export type UserRewards = {
+    [key: string]: {
+        [key: string]: number;
+    };
+};

package/dist/types/UserRewards.js

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

package/package.json

@@ -1,27 +1,28 @@
 {
   "name": "@dripfi/drip-sdk",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Drip SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "prepublish": "npm run build",
     "build": "tsc",
-    "format": "prettier --write .",
+    "publish": "npm publish --access public",
     "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)
-// })