@dripfi/drip-sdk 1.2.5-dev.1 → 1.2.6

package/dist/DripApi.d.ts

@@ -7,24 +7,21 @@ import { VaultStats } from './types/VaultStats';
 import { UserBalance } from './types/UserBalance';
 import { VaultClaimData } from './types/VaultClaimData';
 import MyPerqData from './types/MyPerqData';
+import { LoyaltyCard } from './types/LoyaltyCard';
 import { BeansBalance } from './types/BeansBalance';
-import { MetaVault } from './types/MetaVault';
-import { MetaVaultClaimableFlushes } from '@spool.fi/spool-v2-sdk';
-import { UserMetaVaultBalance } from './types/UserMetaVaultBalance';
 import { PerqToBeansSwapInfo } from './types/PerqToBeansSwapInfo';
+import BeanEntry from './types/BeanEntry';
 export declare const IMPERSONATOR_HEADER = "impersonatorAddress";
 export default class DripApi {
     route: string;
     constructor(route: string);
     fetchAllVaults(): Promise<Vault[]>;
-    fetchAllMetaVaults(): Promise<MetaVault[]>;
     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[]>;
     fetchVaultStats(): Promise<VaultStats>;
     fetchVaultDetails(vaultAddress: string): Promise<Vault>;
-    fetchMetaVaultDetails(metaVaultAddress: string): Promise<MetaVault>;
     fetchRewardsPerHour(vaultAddress: string, token: string): Promise<number>;
     getSwapInfo(fromTokenAddress: string, toTokenAddress: string, amount: BigNumber, fromAddress: string): Promise<SwapInfo[]>;
     fetchUserSVTBalance(vaultAddress: string, walletAddress: string, token: string): Promise<BigNumber>;
@@ -38,7 +35,7 @@ export default class DripApi {
     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>;
-    fetchAllLoyaltyCards(): Promise<any>;
+    fetchAllLoyaltyCards(): Promise<LoyaltyCard[]>;
     fetchOwnedLoyaltyCards(token: string, headers?: Headers): Promise<{
         id: any;
         tier: any;
@@ -61,13 +58,8 @@ export default class DripApi {
         cost: number;
         boost: any;
     }>;
-    fetchUserMetaVaultBalance(userAddress: string, metaVaultAddress: string, token: string, headers?: Headers): Promise<any>;
     fetchMyPerqData(userAddress: string, token: string, headers?: Headers): Promise<MyPerqData>;
     getLoyaltyCardBoost(rewardId: string, token: string, headers?: Headers): Promise<number>;
-    fetchMyPerqMetaVaultsData(userAddress: string, token: string, headers?: Headers): Promise<MyPerqData>;
-    fetchAllUserMetaVaultBalance(userAddress: string, token: string, headers?: Headers): Promise<{
-        [metaVaultAddress: string]: UserMetaVaultBalance;
-    }>;
-    fetchClaimableFlushes(userAddress: string, metaVaultAddress: string, token: string, headers?: Headers): Promise<MetaVaultClaimableFlushes>;
     getSwapPerqForBeansInfo(): Promise<PerqToBeansSwapInfo>;
+    fetchBeansHistory(walletAddress: string, token: string, headers?: Headers): Promise<BeanEntry[]>;
 }

package/dist/DripApi.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IMPERSONATOR_HEADER = void 0;
 const ethers_1 = require("ethers");
 const DripConfig_1 = require("./DripConfig");
-const utils_1 = require("./utils");
 const WETH_TOKEN_ADDRESS = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
 exports.IMPERSONATOR_HEADER = 'impersonatorAddress';
 const AUTHORIZATION_HEADER = 'Authorization';
@@ -32,21 +31,6 @@ class DripApi {
             }
         });
     }
-    fetchAllMetaVaults() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(`${this.route}/api-be/api/metavault`);
-            if (res.ok) {
-                const data = yield res.json();
-                const metaVaults = data.map((metaVault) => {
-                    return Object.assign(Object.assign({}, metaVault), { liveUntilFormatted: (0, utils_1.getMonthDayUTCTimeString)(metaVault.liveUntil), hasPoolEnded: (0, utils_1.hasPoolEnded)(metaVault.liveUntil) });
-                });
-                return metaVaults;
-            }
-            else {
-                throw Error(`${yield res.text()}`);
-            }
-        });
-    }
     fetchTokenPrice(tokenName) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield fetch(`${this.route}/api-be/api/tokenPrice?tokenName=${tokenName}`);
@@ -143,18 +127,6 @@ class DripApi {
             }
         });
     }
-    fetchMetaVaultDetails(metaVaultAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(`${this.route}/api-be/api/metavault/${metaVaultAddress}`);
-            if (res.ok) {
-                const data = (yield res.json());
-                return data;
-            }
-            else {
-                throw Error(`${yield res.text()}`);
-            }
-        });
-    }
     fetchRewardsPerHour(vaultAddress, token) {
         return __awaiter(this, void 0, void 0, function* () {
             const headers = new Headers();
@@ -386,18 +358,15 @@ class DripApi {
     }
     fetchAllLoyaltyCards() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(`${this.route}/api-be/api/loyaltyCards`);
+            const res = yield fetch(`${this.route}/api-be/api/loyaltyCards/all`);
             const data = yield res.json();
-            const mappedData = data.map((element) => {
-                return {
-                    id: element.id,
-                    tier: element.tier,
-                    level: element.level,
-                    cost: parseFloat(ethers_1.ethers.utils.formatUnits(element.cost.toString(), DripConfig_1.DRIP_TOKEN_DECIMALS)),
-                    boost: element.boost
-                };
-            });
-            return mappedData;
+            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) {
@@ -474,20 +443,6 @@ class DripApi {
             };
         });
     }
-    fetchUserMetaVaultBalance(userAddress, metaVaultAddress, 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/user/metavault/balance/${userAddress}/${metaVaultAddress}`, {
-                headers: reqHeaders,
-            });
-            const data = yield res.json();
-            return data;
-        });
-    }
     fetchMyPerqData(userAddress, token, headers) {
         return __awaiter(this, void 0, void 0, function* () {
             const reqHeaders = headers ? headers : new Headers();
@@ -523,16 +478,9 @@ class DripApi {
             }
         });
     }
-    fetchMyPerqMetaVaultsData(userAddress, token, headers) {
+    getSwapPerqForBeansInfo() {
         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/metavaults/${userAddress}`, {
-                headers: reqHeaders,
-            });
+            const res = yield fetch(`${this.route}/api-be/api/swap/price`, {});
             if (res.ok) {
                 const data = yield res.json();
                 return data;
@@ -542,40 +490,34 @@ class DripApi {
             }
         });
     }
-    fetchAllUserMetaVaultBalance(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/user/metavault/balance/${userAddress}`, {
-                headers: reqHeaders,
-            });
-            const data = yield res.json();
-            return data;
-        });
-    }
-    fetchClaimableFlushes(userAddress, metaVaultAddress, token, headers) {
+    fetchBeansHistory(walletAddress, token, headers) {
         return __awaiter(this, void 0, void 0, function* () {
             const reqHeaders = headers ? headers : new Headers();
             reqHeaders.append(AUTHORIZATION_HEADER, token);
             if (reqHeaders.has(exports.IMPERSONATOR_HEADER)) {
-                userAddress = reqHeaders.get(exports.IMPERSONATOR_HEADER);
+                walletAddress = reqHeaders.get(exports.IMPERSONATOR_HEADER);
             }
-            const res = yield fetch(`${this.route}/api-be/api/metavault/claimableFlushes/${metaVaultAddress}/${userAddress}`, {
+            const res = yield fetch(`${this.route}/api-be/api/beans/history/${walletAddress}`, {
+                method: 'GET',
                 headers: reqHeaders,
             });
-            const data = yield res.json();
-            return data;
-        });
-    }
-    getSwapPerqForBeansInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(`${this.route}/api-be/api/swap/price`, {});
             if (res.ok) {
                 const data = yield res.json();
-                return data;
+                const result = data.map((element) => {
+                    const newBeanEntry = {
+                        address: element.address,
+                        reason: element.reason,
+                        recycledAmount: element.recycledAmount,
+                        beansAmount: element.beansAmount,
+                        beansSum: element.beansSum,
+                        amountDepositedInUsd: element.amountDepositedInUsd,
+                        chainId: element.chainId,
+                        nonce: element.nonce,
+                        createdAt: element.createdAt
+                    };
+                    return newBeanEntry;
+                });
+                return result;
             }
             else {
                 throw Error(`${yield res.text()}`);

package/dist/DripConfig.d.ts

@@ -13,6 +13,7 @@ export declare class DripConfig {
     smartVaultManagerAddress: string | undefined;
     dripTokenAddress: string;
     dripTokenRecyclerAddress: string;
+    dripSwapAndRecyclerAddress: string;
     constructor(chain: Chain, dripRoute?: string);
     getSwapAndDepositContractAddress(signer: Signer): Promise<string>;
     getSmartVaultManagerAddress(signer: Signer): Promise<string>;

package/dist/DripConfig.js

@@ -20,10 +20,12 @@ var Chain;
 })(Chain || (exports.Chain = Chain = {}));
 const SUBGRAPH_URL_SEPOLIA = 'https://subgraph.satsuma-prod.com/49eb322da234/solidant/spool-v2-sepolia/api';
 const RECYCLER_ADDRESS_SEPOLIA = '0x07F2264E199D62afe07E8288eC9D36d155fc3f24';
+const SWAP_AND_RECYCLER_ADDRESS_SEPOLIA = '0xA4ed357FF233731860Ec8D0446FD95756d564014';
 const DRIP_TOKEN_ADDRESS_SEPOLIA = '0x707B4Cc05645713d8Ea04FBC7192A0f2c1503d6E';
 const SUBGRAPH_URL_MAINNET = 'https://subgraph.satsuma-prod.com/49eb322da234/solidant/spool-v2/api';
 // const RECYCLER_ADDRESS_MAINNET = '';
-// const DRIP_TOKEN_ADDRESS_MAINNET = '';
+// const SWAP_AND_RECYCLER_ADDRESS_MAINNET = '0xA4ed357FF233731860Ec8D0446FD95756d564014';
+const DRIP_TOKEN_ADDRESS_MAINNET = '0x2a414884a549ef5716bc1a4e648d3dc03f08b2cf';
 const DEV_BACKEND_ROUTE = 'https://dev.drip.fi.io';
 const PROD_BACKEND_ROUTE = 'https://perq.finance';
 class DripConfig {
@@ -32,14 +34,16 @@ class DripConfig {
             case Chain.MAINNET:
                 this.internalConfig = (0, spool_v2_sdk_1.getMainnetConfig)(SUBGRAPH_URL_MAINNET);
                 this.dripRoute = dripRoute !== undefined ? dripRoute : PROD_BACKEND_ROUTE;
-                this.dripTokenAddress = exports.NULL_ADDRESS;
+                this.dripTokenAddress = DRIP_TOKEN_ADDRESS_MAINNET;
                 this.dripTokenRecyclerAddress = exports.NULL_ADDRESS;
+                this.dripSwapAndRecyclerAddress = exports.NULL_ADDRESS;
                 break;
             case Chain.SEPOLIA:
                 this.internalConfig = (0, spool_v2_sdk_1.getSepoliaConfig)(SUBGRAPH_URL_SEPOLIA);
                 this.dripRoute = dripRoute !== undefined ? dripRoute : DEV_BACKEND_ROUTE;
                 this.dripTokenAddress = DRIP_TOKEN_ADDRESS_SEPOLIA;
                 this.dripTokenRecyclerAddress = RECYCLER_ADDRESS_SEPOLIA;
+                this.dripSwapAndRecyclerAddress = SWAP_AND_RECYCLER_ADDRESS_SEPOLIA;
                 break;
         }
     }

package/dist/DripSdk.d.ts

@@ -11,18 +11,17 @@ import MyPerqData from './types/MyPerqData';
 import { Chain } from './DripConfig';
 import { BeansBalance } from './types/BeansBalance';
 import { PerqToBeansSwapInfo } from './types/PerqToBeansSwapInfo';
-import { MetaVault } from './types/MetaVault';
-import { UserMetaVaultBalance } from './types/UserMetaVaultBalance';
+import BeanEntry from './types/BeanEntry';
 export default class DripSdk {
     private dripApi;
     private dripTokenContract;
     private dripTokenRecyclerContract;
+    private dripSwapAndRecyclerContract;
     private spoolSdk?;
     private signer?;
     private dripConfig;
     constructor(chain: Chain, signer?: Signer, dripRoute?: string);
     getAllVaults(): Promise<Vault[]>;
-    getAllMetaVaults(): Promise<MetaVault[]>;
     getVaultDetails(vaultAddress: string): Promise<Vault>;
     getVaultStats(): Promise<VaultStats>;
     getTokenPrice(tokenName: string): Promise<number>;
@@ -31,45 +30,40 @@ export default class DripSdk {
     authenticate(): Promise<boolean>;
     newDeposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
     deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
-    depositMetaVault(metaVaultAddress: string, amount: string): Promise<string>;
     private doDeposit;
     getTokenAllowanceForCurrency(tokenAddress: string): Promise<string>;
     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[]>;
     getRewardsPerHour(vaultAddress: string): Promise<number>;
     getRewards(headers?: Headers): Promise<UserRewards>;
     getMyPerqBalance(headers?: Headers): Promise<MyPerqData>;
-    getMyPerqMetaVaultsBalance(headers?: Headers): Promise<MyPerqData>;
     getUserVaultBalance(vaultAddress: string, headers?: Headers): Promise<UserVaultBalance>;
-    getUserMetaVaultBalance(metaVaultAddress: string, headers?: Headers): Promise<UserMetaVaultBalance>;
-    getAllUserMetaVaultBalance(headers?: Headers): Promise<{
-        [metaVaultAddress: string]: UserMetaVaultBalance;
-    }>;
     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>;
-    swapAndDepositMetaVault(metaVaultAddress: string, fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string): Promise<void>;
     private doSwapAndDeposit;
     withdraw(vaultAddress: string, amountToWithdraw?: string): Promise<string>;
-    withdrawMetavault(metaVaultAddress: string, amount?: string): Promise<string>;
-    claimWithdrawsMetaVault(metaVaultAddress: string): Promise<string>;
     claimWithdraws(vaultAddress: string): Promise<string>;
     getVaultsClaimableData(headers?: Headers): Promise<VaultClaimData>;
     getBeansBalance(headers?: Headers): Promise<BeansBalance>;
+    getBeansHistory(headers?: Headers): 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>;
     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>;
     approveTokenForDeposit(tokenAddress: string, amount: string): Promise<string>;
     getDripTokenContractAddress(): string;
     getSwapPerqForBeansInfo(): Promise<PerqToBeansSwapInfo>;
-    approveTokenForMetaVaultDeposit(tokenAddress: string, metaVaultAddress: string, amount: string): Promise<string>;
     private generateRedeemBagStruct;
     private getERC20Precission;
     private calculatePendingDeposits;
@@ -80,5 +74,5 @@ export default class DripSdk {
     private getTokenAllowanceForDeposit;
     private getTokenAllowanceForSwapAndDeposit;
     private getERC20TokenAllowance;
-    approveToken(tokenAddress: string, amount: string, spender: string): Promise<string>;
+    private approveToken;
 }

package/dist/DripSdk.js

@@ -20,6 +20,7 @@ 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"));
 class DripSdk {
     constructor(chain, signer, dripRoute) {
         this.signer = signer;
@@ -30,17 +31,13 @@ class DripSdk {
         this.dripApi = new DripApi_1.default(this.dripConfig.dripRoute);
         this.dripTokenContract = new DripTokenContract_1.default(this.dripConfig.dripTokenAddress, signer);
         this.dripTokenRecyclerContract = new DripTokenRecyclerContract_1.default(this.dripConfig.dripTokenRecyclerAddress, signer);
+        this.dripSwapAndRecyclerContract = new DripSwapAndRecyclerContract_1.default(this.dripConfig.dripSwapAndRecyclerAddress, signer);
     }
     getAllVaults() {
         return __awaiter(this, void 0, void 0, function* () {
             return this.dripApi.fetchAllVaults();
         });
     }
-    getAllMetaVaults() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.dripApi.fetchAllMetaVaults();
-        });
-    }
     getVaultDetails(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.dripApi.fetchVaultDetails(vaultAddress);
@@ -121,23 +118,6 @@ class DripSdk {
             return this.doDeposit(tokenAddress, vaultAddress, amount, true);
         });
     }
-    depositMetaVault(metaVaultAddress, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer) {
-                throw Error('No signer provided');
-            }
-            const metavault = yield this.dripApi.fetchMetaVaultDetails(metaVaultAddress);
-            if (!metavault) {
-                throw Error('Metavault not found');
-            }
-            const decimals = yield this.getERC20Precission(metavault.depositToken.tokenAddress);
-            const amountWithDecimals = parseFloat(parseFloat(amount).toFixed(decimals));
-            const amountToDeposit = ethers_1.ethers.utils.parseUnits(amountWithDecimals.toString(), decimals);
-            const depositTx = yield this.spoolSdk.metaVaultDeposit(metaVaultAddress.toLowerCase(), amountToDeposit);
-            const txReceipt = yield depositTx.wait();
-            return txReceipt.transactionHash;
-        });
-    }
     doDeposit(tokenAddress, vaultAddress, amount, checkAllowance) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.signer) {
@@ -186,6 +166,15 @@ class DripSdk {
             return allowance;
         });
     }
+    getTokenAllowanceForSwapAndRecycler(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            const allowance = yield this.getERC20TokenAllowance(this.dripSwapAndRecyclerContract.getContractAddress(), tokenAddress);
+            return allowance;
+        });
+    }
     getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAddress = yield this.signer.getAddress();
@@ -234,14 +223,6 @@ class DripSdk {
             return myPerqBalance;
         });
     }
-    getMyPerqMetaVaultsBalance(headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAddress = yield this.signer.getAddress();
-            const authData = yield this.isUserAuthenticated();
-            const myPerqMetaVaultsBalance = this.dripApi.fetchMyPerqMetaVaultsData(userAddress, authData.token, headers);
-            return myPerqMetaVaultsBalance;
-        });
-    }
     getUserVaultBalance(vaultAddress, headers) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAddress = yield this.signer.getAddress();
@@ -265,38 +246,6 @@ class DripSdk {
             };
         });
     }
-    getUserMetaVaultBalance(metaVaultAddress, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            const balance = yield this.dripApi.fetchUserMetaVaultBalance(authData.address, metaVaultAddress, authData.token, headers);
-            return {
-                userBalance: balance.userBalance,
-                pendingUserBalance: balance.pendingUserBalance,
-                pendingWithdrawalBalance: balance.pendingWithdrawalBalance,
-                claimable: balance.claimable
-            };
-        });
-    }
-    getAllUserMetaVaultBalance(headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authData = yield this.isUserAuthenticated();
-            const balances = yield this.dripApi.fetchAllUserMetaVaultBalance(authData.address, authData.token, headers);
-            const addressArray = Object.keys(balances);
-            const result = {};
-            for (const address of addressArray) {
-                if (result[address]) {
-                    continue;
-                }
-                result[address] = {
-                    userBalance: balances[address].userBalance,
-                    pendingUserBalance: balances[address].pendingUserBalance,
-                    pendingWithdrawalBalance: balances[address].pendingWithdrawalBalance,
-                    claimable: balances[address].claimable
-                };
-            }
-            return result;
-        });
-    }
     fastWithdraw(vaultAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -330,31 +279,6 @@ class DripSdk {
             return this.doSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, false, ethAmount);
         });
     }
-    swapAndDepositMetaVault(metaVaultAddress, fromTokenAddress, toTokenAddress, fromTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (parseFloat(fromTokenAmount) <= 0) {
-                throw Error('fromTokenAmount must be bigger than 0');
-            }
-            // parse from token amount according to decimals
-            const decimals = yield this.getERC20Precission(fromTokenAddress);
-            const parsedAmount = ethers_1.ethers.utils.parseUnits(fromTokenAmount, decimals);
-            const tokenAllowance = yield this.getTokenAllowanceForSwapAndDeposit(fromTokenAddress);
-            if (tokenAllowance.lt(parsedAmount)) {
-                throw Error(`current allowance: ${tokenAllowance} is less than required: ${parsedAmount}`);
-            }
-            const userAddress = yield this.signer.getAddress();
-            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, parsedAmount, userAddress);
-            const swapAndDepositBag = {
-                metaVault: metaVaultAddress,
-                inTokens: [fromTokenAddress],
-                inAmounts: [parsedAmount],
-                swapInfo
-            };
-            console.log(`swapAndDepositBag: ${JSON.stringify(swapAndDepositBag, null, 2)}`);
-            yield ((_a = this.spoolSdk) === null || _a === void 0 ? void 0 : _a.metaVaultSwapAndDeposit(swapAndDepositBag));
-        });
-    }
     doSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, checkAllowance, ethAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAddress = yield this.signer.getAddress();
@@ -407,47 +331,6 @@ class DripSdk {
             return redeemTxReceipt.transactionHash;
         });
     }
-    withdrawMetavault(metaVaultAddress, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer) {
-                throw Error('No signer provided');
-            }
-            const authData = yield this.isUserAuthenticated();
-            const balance = yield this.dripApi.fetchUserMetaVaultBalance(authData.address, metaVaultAddress, authData.token);
-            if (0 == balance.userBalance || (amount !== undefined && parseFloat(amount) > balance.userBalance)) {
-                throw Error('Not enough funds to withdraw');
-            }
-            if (amount !== undefined && parseFloat(amount) === 0) {
-                throw Error('Amount to withdraw must be bigger than 0');
-            }
-            //If amount is undefined means user wants to withdraw all funds
-            const sharesToWithdraw = amount !== undefined ? ((parseFloat(amount) * balance.userBalanceShares) / balance.userBalance).toFixed(0) : balance.userBalanceShares;
-            const depositTx = yield this.spoolSdk.metaVaultRedeem(metaVaultAddress, sharesToWithdraw, balance.userClaimableFlushIndexes);
-            const txReceipt = yield depositTx.wait();
-            return txReceipt.transactionHash;
-        });
-    }
-    claimWithdrawsMetaVault(metaVaultAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer) {
-                throw Error('No signer provided');
-            }
-            const authData = yield this.isUserAuthenticated();
-            const metaVaultClaimableFlushes = yield this.dripApi.fetchClaimableFlushes(authData.address.toLowerCase(), metaVaultAddress.toLowerCase(), authData.token);
-            const flushIndexes = metaVaultClaimableFlushes.unclaimedWithdraws.reduce((acc, item) => {
-                if (item.isFlushed) {
-                    acc.push(item.flushIndex.toString());
-                }
-                return acc;
-            }, []);
-            if (flushIndexes.length === 0) {
-                throw Error('No funds to claim');
-            }
-            const metaVaultWithdrawTx = yield this.spoolSdk.metaVaultWithdraw(metaVaultAddress, flushIndexes);
-            const txReceipt = yield metaVaultWithdrawTx.wait();
-            return txReceipt.transactionHash;
-        });
-    }
     claimWithdraws(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAddress = yield this.signer.getAddress();
@@ -490,6 +373,15 @@ class DripSdk {
             return this.dripApi.fetchBeansBalance(authData.token, headers);
         });
     }
+    getBeansHistory(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.fetchBeansHistory(authData.address, authData.token, headers);
+        });
+    }
     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();
@@ -506,6 +398,43 @@ class DripSdk {
             return receipt.transactionHash;
         });
     }
+    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');
+            }
+            const swapAndRecycleTx = yield this.dripSwapAndRecyclerContract.swapETHAndRecycle(beneficiary, path, minAmountOutWithDecimals, amountOfEth, price, deadline, signature);
+            const receipt = yield swapAndRecycleTx.wait();
+            return receipt.transactionHash;
+        });
+    }
+    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');
+            }
+            console.log("swap and recycle ERC-20 with this: ", {
+                beneficiary,
+                path,
+                amountInWithDecimals,
+                minAmountOutWithDecimals,
+                price,
+                deadline,
+                signature
+            });
+            const swapAndRecycleTx = yield this.dripSwapAndRecyclerContract.swapAndRecycle(beneficiary, path, amountInWithDecimals, minAmountOutWithDecimals, price, deadline, signature);
+            const receipt = yield swapAndRecycleTx.wait();
+            return receipt.transactionHash;
+        });
+    }
     upgradeLoyaltyCard() {
         return __awaiter(this, void 0, void 0, function* () {
             const authData = yield this.isUserAuthenticated();
@@ -558,6 +487,17 @@ class DripSdk {
             return yield this.approveToken(tokenAddress, amount, this.dripConfig.dripTokenRecyclerAddress);
         });
     }
+    approveTokenForSwapAndRecycler(tokenAddress, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer) {
+                throw Error('No signer provided');
+            }
+            if (this.dripConfig.dripSwapAndRecyclerAddress === DripConfig_1.NULL_ADDRESS) {
+                throw Error('Recycler contract address not defined');
+            }
+            return yield this.approveToken(tokenAddress, amount, this.dripConfig.dripSwapAndRecyclerAddress);
+        });
+    }
     approveTokenForSwapAndDeposit(tokenAddress, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.signer) {
@@ -584,14 +524,6 @@ class DripSdk {
             return this.dripApi.getSwapPerqForBeansInfo();
         });
     }
-    approveTokenForMetaVaultDeposit(tokenAddress, metaVaultAddress, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer) {
-                throw Error('No signer provided');
-            }
-            return yield this.approveToken(tokenAddress, amount, metaVaultAddress);
-        });
-    }
     generateRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.spoolSdk) {

package/dist/contracts/DripSwapAndRecyclerContract.d.ts

@@ -0,0 +1,7 @@
+import { ContractTransaction, ethers } from 'ethers';
+import BaseDripContract from './BaseDripContract';
+export default class DripSwapAndRecyclerContract extends BaseDripContract {
+    constructor(address: string, signer?: ethers.Signer);
+    swapAndRecycle(beneficiary: string | undefined, path: string[], amountInWithDecimals: string, minAmountOutWithDecimals: string, price: string, deadline: string, signature: string): Promise<ContractTransaction>;
+    swapETHAndRecycle(beneficiary: string | undefined, path: string[], minAmountOutWithDecimals: string, amountInEth: string, price: string, deadline: string, signature: string): Promise<ContractTransaction>;
+}