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

package/dist/DripApi.d.ts

@@ -8,18 +8,23 @@ import { UserBalance } from './types/UserBalance';
 import { VaultClaimData } from './types/VaultClaimData';
 import MyPerqData from './types/MyPerqData';
 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';
 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>;
@@ -56,7 +61,13 @@ 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>;
 }

package/dist/DripApi.js

@@ -12,6 +12,7 @@ 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';
@@ -31,6 +32,21 @@ 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}`);
@@ -127,6 +143,18 @@ 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();
@@ -446,6 +474,20 @@ 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();
@@ -481,6 +523,53 @@ class DripApi {
             }
         });
     }
+    fetchMyPerqMetaVaultsData(userAddress, token, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reqHeaders = headers ? headers : new Headers();
+            reqHeaders.append(AUTHORIZATION_HEADER, token);
+            if (reqHeaders.has(exports.IMPERSONATOR_HEADER)) {
+                userAddress = reqHeaders.get(exports.IMPERSONATOR_HEADER);
+            }
+            const res = yield fetch(`${this.route}/api-be/api/myperq/metavaults/${userAddress}`, {
+                headers: reqHeaders,
+            });
+            if (res.ok) {
+                const data = yield res.json();
+                return data;
+            }
+            else {
+                throw Error(`${yield res.text()}`);
+            }
+        });
+    }
+    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) {
+        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/metavault/claimableFlushes/${metaVaultAddress}/${userAddress}`, {
+                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`, {});

package/dist/DripSdk.d.ts

@@ -11,6 +11,8 @@ 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';
 export default class DripSdk {
     private dripApi;
     private dripTokenContract;
@@ -20,6 +22,7 @@ export default class DripSdk {
     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>;
@@ -28,6 +31,7 @@ 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>;
@@ -37,12 +41,20 @@ export default class DripSdk {
     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>;
@@ -57,6 +69,7 @@ export default class DripSdk {
     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;
@@ -67,5 +80,5 @@ export default class DripSdk {
     private getTokenAllowanceForDeposit;
     private getTokenAllowanceForSwapAndDeposit;
     private getERC20TokenAllowance;
-    private approveToken;
+    approveToken(tokenAddress: string, amount: string, spender: string): Promise<string>;
 }

package/dist/DripSdk.js

@@ -36,6 +36,11 @@ class DripSdk {
             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);
@@ -116,6 +121,23 @@ 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) {
@@ -212,6 +234,14 @@ 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();
@@ -235,6 +265,38 @@ 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;
@@ -268,6 +330,31 @@ 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();
@@ -320,6 +407,47 @@ 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();
@@ -456,6 +584,14 @@ 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/index.d.ts

@@ -9,9 +9,11 @@ import { SwapInfo } from './types/SwapInfo';
 import { VaultDepositToken } from './types/VaultDepositToken';
 import { VaultType } from './types/VaultType';
 import { UserVaultBalance } from './types/UserVaultBalance';
+import { UserMetaVaultBalance } from './types/UserMetaVaultBalance';
 import { UserBalance } from './types/UserBalance';
 import { VaultStats } from './types/VaultStats';
 import { Chain } from './DripConfig';
 import MyPerqData from './types/MyPerqData';
 import ELoyaltyCardTier from './types/ELoyaltyCardTier';
-export { Vault, VaultReward, DripSdk, UserVaultBalance, UserBalance, VaultStats, AuthenticationStatus, NFTBoost, Strategy, StretchGoal, SwapInfo, VaultDepositToken, VaultType, MyPerqData, Chain, ELoyaltyCardTier };
+import { MetaVault } from './types/MetaVault';
+export { Vault, VaultReward, DripSdk, UserVaultBalance, UserBalance, VaultStats, AuthenticationStatus, NFTBoost, Strategy, StretchGoal, SwapInfo, VaultDepositToken, VaultType, MetaVault, MyPerqData, Chain, UserMetaVaultBalance, ELoyaltyCardTier };

package/dist/test.js

@@ -16,10 +16,11 @@ exports.signer = void 0;
 const ethers_1 = require("ethers");
 const DripConfig_1 = require("./DripConfig");
 const DripSdk_1 = __importDefault(require("./DripSdk"));
+const spool_v2_sdk_1 = require("@spool.fi/spool-v2-sdk");
 // This is script to test locally the drip sdk methods
 const account2 = '0x9E9B6899Ea314dD553A99f4F49440d2CeD2b2848'; // privKey 92eb90257aa76cc56ead18dd52dd3433689712ebe7356a70308b760bfcbdd787
-// const privKey: string = '6ffc226f7b7769e27124317372c9dbb579a324e67e97bf07131bf2f59ec0f4fe';
-const privKey = '92eb90257aa76cc56ead18dd52dd3433689712ebe7356a70308b760bfcbdd787';
+const privKey = '6ffc226f7b7769e27124317372c9dbb579a324e67e97bf07131bf2f59ec0f4fe'; // Deployer
+// const privKey: string = '92eb90257aa76cc56ead18dd52dd3433689712ebe7356a70308b760bfcbdd787';
 const testConfigParams = {
     subgraphUrl: 'https://subgraph.satsuma-prod.com/49eb322da234/solidant/spool-v2-sepolia/api',
     priceFeedApiUrl: 'https://pricefeed.dev.spool.fi/',
@@ -34,6 +35,7 @@ const testConfigParams = {
             IRewardManager: '0xcE7F66BD505a80129Ef25b06207Ac49620A55522',
             IStrategyRegistry: '0xf978853Db777d00b1130Ea21d8d98E8710b0Bc56',
             ISpoolLens: '0x33Df6cf08Fbb10047e318989fE687294CD45A7B4',
+            IMetaVaultFactory: '0x28a3a4f4D469Fb33601639Db40a800ca6776A3d0',
         }
     },
     dripContracts: {
@@ -41,7 +43,7 @@ const testConfigParams = {
         DripTokenRecyclerAddress: '0xe943A1320402fcf41cDc04275e842654165dAB78' // Sepolia contract address
     }
 };
-const configParams = {
+const sepoliaConfigParams = {
     subgraphUrl: 'https://subgraph.satsuma-prod.com/49eb322da234/solidant/spool-v2-sepolia/api',
     priceFeedApiUrl: 'https://pricefeed.dev.spool.fi/',
     rewardsUrl: 'https://rewards.dev.spool.fi/sepolia',
@@ -55,6 +57,7 @@ const configParams = {
             IRewardManager: '0xcE7F66BD505a80129Ef25b06207Ac49620A55522',
             IStrategyRegistry: '0xf978853Db777d00b1130Ea21d8d98E8710b0Bc56',
             ISpoolLens: '0x33Df6cf08Fbb10047e318989fE687294CD45A7B4',
+            IMetaVaultFactory: '0xe07a896CFD8FEdFb6d7515480853c5D5ED30EBFE',
         },
     },
     dripContracts: {
@@ -62,6 +65,24 @@ const configParams = {
         DripTokenRecyclerAddress: '0xe943A1320402fcf41cDc04275e842654165dAB78' // Sepolia contract address
     }
 };
+const mainnetConfigParams = {
+    subgraphUrl: 'https://subgraph.satsuma-prod.com/49eb322da234/solidant/spool-v2/api',
+    priceFeedApiUrl: 'https://pricefeed.v2.spool.fi/',
+    rewardsUrl: 'https://rewards.v2.spool.fi/',
+    fastRedeemApi: 'https://fastwithdraw.v2.spool.fi/',
+    contracts: {
+        1: {
+            ISmartVaultManager: '0x23Daf34e2b9Af02A74dC19cB52Af727B19403874',
+            IDepositSwap: '0xd8534197Bd587F8226d12E0C864ef2CaE6f82f5C',
+            ISmartVaultFactory: '0x362599Cdc123e3FFEB7c0812d769128D180667E8',
+            IDepositManager: '0x823Ba38992825FF37E72B6c3D669a09173B8F7bf',
+            IRewardManager: '0xd8d2C1C3C7982272e3e12dEC5aF681433fdcf003',
+            IStrategyRegistry: '0x554c6bCB54656390aca0a0af38CA954dbE653F15',
+            ISpoolLens: '0x8aa6174333F75421903b2B5c70DdF8DA5D84f74F',
+            IMetaVaultFactory: '0x28a3a4f4D469Fb33601639Db40a800ca6776A3d0'
+        },
+    }
+};
 const provider = new ethers_1.ethers.providers.StaticJsonRpcProvider('https://rpc.ankr.com/eth_sepolia', 11155111);
 exports.signer = new ethers_1.ethers.Wallet(privKey, provider);
 // const random_address = '0x25dFcFB061956c6f33B1ee032cc33837d0b83257';
@@ -70,21 +91,30 @@ const daiVaultPerq = '0x1977efe478ba17da8be6e93fdfadbd3055d30111'; // DAI PERQ S
 const usdcVaultPerq = '0xf9795bfbf7c40981c372d0fb25a87e0b694c4fcd'; // USDC PERQ SEPOLIA
 const daiTokenAddress = '0x2a3a3872c242c35093a8fc48dac838c4b2d24a03'; // DAI TOKEN
 const usdcTokenAddress = '0xa6b92fcd4ee124353c8a6acf1edb574f46f3f8df'; // USDC TOKEN
+const dripConfig = new DripConfig_1.DripConfig(DripConfig_1.Chain.SEPOLIA, 'http://localhost:3000');
 const dripSdk = new DripSdk_1.default(DripConfig_1.Chain.SEPOLIA, exports.signer, 'https://localhost:3000');
 // 0x689Baa4821865Cb328F5E847fB6133DEB315A832
 // 0x9E9B6899Ea314dD553A99f4F49440d2CeD2b2848
+const usdcMetaVaultAddress = '0x89845afce65a62a4411c7ed9d0729e06147b47ca'.toLowerCase();
+const wethMetaVautlAddress = '0xecf5325ccd0cf71b9d400ebbefd84f70b76a56f2';
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            // const res = await dripSdk.deposit(usdcTokenAddress,usdcVaultPerq, '1000');
-            // const res = await dripSdk.withdraw(usdcVaultPerq, '1');
-            // await dripSdk.authenticate()
-            // const res = await dripSdk.getDripTokenBalance(account2)
-            // const res = await dripSdk.getNextLoyaltyCard()
-            // const res = await dripSdk.getOwnedLoyaltyCards()
-            // const res = await dripSdk.getBeansBalance()
-            // const res = await dripSdk.recycleTokens()
-            // const res = await dripSdk.upgradeLoyaltyCard()
+            // ==================================================
+            const spoolSdk = new spool_v2_sdk_1.SpoolSdk(dripConfig.internalConfig, exports.signer);
+            // const res = await spoolSdk.getOffchainRewards('drip_s');
+            // console.log(JSON.stringify(res, null, 2));
+            // ==================================================
+            const metavaultQuery = {
+                metaVaultAddress: '0x89845afce65a62a4411c7ed9d0729e06147b47ca'.toLowerCase(),
+                userAddress: '0x689Baa4821865Cb328F5E847fB6133DEB315A832'.toLowerCase()
+            };
+            const res = yield spoolSdk.metaVaultDeposit(usdcMetaVaultAddress, '10000000');
+            console.log(JSON.stringify(res, null, 2));
+            // const res = await dripSdk.getUserMetaVaultBalance('0x89845afce65a62a4411c7ed9d0729e06147b47ca');
+            // const res = await dripSdk.approveTokenForMetaVaultDeposit('0x88b25a14dae46c33ae3eef2b45a5ec758d9a5ec6', wethMetaVautlAddress, '0.002');
+            // const res = await dripSdk.depositMetaVault(wethMetaVautlAddress, '0.002');
+            // console.log(res);
         }
         catch (error) {
             console.log(`Main error: ${error}`);

package/dist/types/DeployedMetaVault.d.ts

@@ -0,0 +1,6 @@
+export type DeployedMetaVault = {
+    address: string;
+    liveUntil: string;
+    liveFrom: string;
+    depositTokenId: string;
+};

package/dist/types/DeployedMetaVault.js

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

package/dist/types/MetaVault.d.ts

@@ -0,0 +1,17 @@
+import { VaultDepositToken } from './VaultDepositToken';
+type VaultAllocation = {
+    address: string;
+    name: string;
+    allocation: number;
+};
+export type MetaVault = {
+    name: string;
+    address: string;
+    depositToken: VaultDepositToken;
+    liveUntil: string;
+    liveUntilFormatted: string;
+    liveFrom: string;
+    hasPoolEnded: boolean;
+    allocations: VaultAllocation[];
+};
+export {};

package/dist/types/MetaVault.js

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

package/dist/types/UserMetaVaultBalance.d.ts

@@ -0,0 +1,6 @@
+export type UserMetaVaultBalance = {
+    userBalance: string;
+    pendingUserBalance: string;
+    pendingWithdrawalBalance: string;
+    claimable: string;
+};

package/dist/types/UserMetaVaultBalance.js

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

package/dist/utils.d.ts

@@ -1 +1,3 @@
 export declare function insertDot(numberString: string, decimals: number): string;
+export declare function getMonthDayUTCTimeString(dateString: string | number): string;
+export declare const hasPoolEnded: (date: string) => boolean;

package/dist/utils.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPoolEnded = void 0;
 exports.insertDot = insertDot;
+exports.getMonthDayUTCTimeString = getMonthDayUTCTimeString;
 function insertDot(numberString, decimals) {
     if (numberString.length < decimals + 1) {
         numberString = '0'.repeat(decimals + 1 - numberString.length) + numberString;
@@ -11,3 +13,48 @@ function insertDot(numberString, decimals) {
     const afterDecimal = numberString.slice(indexToInsertDot);
     return `${beforeDecimal}.${afterDecimal}`;
 }
+function getMonthDayUTCTimeString(dateString) {
+    // Parse the input string into a Date object
+    const date = new Date(typeof dateString === 'number' ? dateString * 1000 : dateString);
+    if (isNaN(date.getTime())) {
+        return 'Unknown Date';
+    }
+    // Options for formatting time (12-hour with AM/PM)
+    const options = {
+        month: 'long', // Full month name
+        day: 'numeric', // Day of the month
+        hour: 'numeric', // Hour (12-hour format)
+        minute: '2-digit', // Minute with leading zero
+        hour12: true, // 12-hour time format
+    };
+    // Format the date and time to US format using the previous options
+    const localeTimeString = date.toLocaleString('en-US', options);
+    // localeTimeString will look like this: May 8 at 8:00 PM
+    // Format the date and time to US format using the previous options
+    const [monthDay, time] = localeTimeString.split(' at ');
+    const [month, day] = monthDay.split(' ');
+    const dayNum = parseInt(day, 10);
+    const daySuffix = getDaySuffix(dayNum);
+    return `${month} ${day}${daySuffix}, ${time}`;
+}
+function getDaySuffix(day) {
+    if (day >= 11 && day <= 13) {
+        return 'th';
+    }
+    switch (day % 10) {
+        case 1:
+            return 'st';
+        case 2:
+            return 'nd';
+        case 3:
+            return 'rd';
+        default:
+            return 'th';
+    }
+}
+const hasPoolEnded = (date) => {
+    const endDate = new Date(date).getTime();
+    const currentDate = new Date().getTime();
+    return endDate <= currentDate;
+};
+exports.hasPoolEnded = hasPoolEnded;

package/package.json

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