@dripfi/drip-sdk 1.0.0 → 1.0.3

package/dist/DripSdk.js

@@ -0,0 +1,457 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_token_1 = __importDefault(require("web3-token"));
+const spool_v2_sdk_1 = require("@spool.fi/spool-v2-sdk");
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+const DripApi_1 = __importDefault(require("./DripApi"));
+const KASU_USDC_VAULT_ADDRESS = "0xd8aa8099a53eddebe6a49c98ca12746ff19aa502";
+class DripSdk {
+    constructor(dripConfig, signer) {
+        this.signer = signer;
+        this.dripConfig = dripConfig;
+        if (signer) {
+            this.spoolSdk = new spool_v2_sdk_1.SpoolSdk(dripConfig.internalConfig, signer);
+        }
+        this.dripApi = new DripApi_1.default(dripConfig.dripRoute);
+    }
+    getAllVaults() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dripApi.fetchAllVaults();
+        });
+    }
+    getVaultDetails(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dripApi.fetchVaultDetails(vaultAddress);
+        });
+    }
+    getUserBalance(vault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer)
+                throw Error('No signer provided');
+            const userAddress = yield this.signer.getAddress();
+            const token = yield this.generateToken();
+            const dnfts = yield this.dripApi.fetchAllUserDNFTForVault(vault.vaultAddress, userAddress, token);
+            const wnfts = yield this.dripApi.fetchAllUserWNFTForVault(vault.vaultAddress, userAddress, token);
+            const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress);
+            if (this.shouldUseNewWithdrawLogic(userAddress, vault)) {
+                const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = yield this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals);
+                const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts);
+                const pendingDeposits = this.calculatePendingDeposits(dnfts, decimals);
+                const userBalance = this.calculateAllDeposits(dnfts, decimals).sub(pendingDeposits);
+                return {
+                    hasWithdrawsToClaim,
+                    userBalance: ethers_1.ethers.utils.formatUnits(userBalance, decimals),
+                    pendingUserBalance: ethers_1.ethers.utils.formatUnits(pendingDeposits, decimals),
+                    pendingWithdrawalBalance: ethers_1.ethers.utils.formatUnits(estimatedPendingWithdrawalBalance, decimals),
+                    withdrawableBalance: ethers_1.ethers.utils.formatUnits(estimatedWithdrawableBalance, decimals),
+                };
+            }
+            else {
+                const allDeposits = this.calculateDepositsOld(dnfts, decimals);
+                const pendingDeposits = this.calculatePendingDepositsOld(dnfts, decimals);
+                const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals] = yield this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals);
+                const fastWithdrawBalance = yield this.calculateFastWithdrawBalancesOld(vault.vaultAddress, userAddress, decimals);
+                const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts);
+                let balance = allDeposits
+                    .sub(estimatedWithdrawals)
+                    .sub(estimatedWithdrawableBalance)
+                    .sub(estimatedPendingWithdrawalBalance)
+                    .sub(fastWithdrawBalance);
+                return {
+                    hasWithdrawsToClaim,
+                    userBalance: ethers_1.ethers.utils.formatUnits(balance, decimals),
+                    pendingUserBalance: ethers_1.ethers.utils.formatUnits(pendingDeposits, decimals),
+                    pendingWithdrawalBalance: ethers_1.ethers.utils.formatUnits(estimatedPendingWithdrawalBalance, decimals),
+                    withdrawableBalance: ethers_1.ethers.utils.formatUnits(estimatedWithdrawableBalance, decimals),
+                };
+            }
+        });
+    }
+    fastWithdraw(vault, amountToWithdraw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            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(vault, signerAddress, amountToWithdraw)
+                    : yield this.generateOldRedeemBagStruct(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);
+            }
+        });
+    }
+    deposit(tokenAddress, vaultAddress, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 amountToDeposit = ethers_1.ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals);
+            if (amountToDeposit.gt(currentTokenAllowance)) {
+                const requiredTokenAllowance = amountToDeposit.sub(currentTokenAllowance);
+                yield this.approveTokenForDeposit(tokenAddress, requiredTokenAllowance);
+            }
+            const signerAddress = yield this.signer.getAddress();
+            if (!signerAddress)
+                throw Error('Error fetching address');
+            const depositBagStruct = {
+                smartVault: vaultAddress,
+                assets: [amountToDeposit],
+                receiver: signerAddress,
+                referral: ethers_1.ethers.constants.AddressZero,
+                doFlush: false,
+            };
+            const depositTx = yield this.spoolSdk.deposit(depositBagStruct);
+            yield depositTx.wait();
+        });
+    }
+    swapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, ethAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.signer)
+                throw Error('No signer provided');
+            const decimals = yield this.getERC20Precission(fromTokenAddress);
+            const amountToWithdrawFixedDecimals = parseFloat(fromTokenAmount).toFixed(decimals);
+            const fromToken = ethers_1.ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals);
+            const signerAddress = yield this.signer.getAddress();
+            if (fromToken.gt(ethers_1.BigNumber.from(0))) {
+                const currentTokenAllowance = yield this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress);
+                if (fromToken.gt(currentTokenAllowance)) {
+                    yield this.approveTokenForSwapAndDepositContract(fromTokenAddress, fromToken.sub(currentTokenAllowance));
+                }
+            }
+            const swapInfo = yield this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, signerAddress);
+            const swapDepositBagStruct = {
+                inTokens: [fromTokenAddress],
+                inAmounts: [fromToken],
+                smartVault: vaultAddress,
+                swapInfo,
+                receiver: signerAddress,
+                referral: ethers_1.ethers.constants.AddressZero,
+                doFlush: false,
+            };
+            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());
+        });
+    }
+    withdraw(vault, amountToWithdraw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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(vault, signerAddress, amountToWithdraw)
+                    : yield this.generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw);
+                const redeemTx = yield this.spoolSdk.redeem(redeemBagStruct, signerAddress.toLowerCase(), false);
+                const redeemTxReceipt = yield redeemTx.wait();
+            }
+            catch (error) {
+                console.log(error);
+            }
+        });
+    }
+    generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.generateToken();
+            const dnfts = yield this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress, signerAddress, token);
+            const userBalance = yield this.dripApi.fetchUserBalance(vault.vaultAddress, signerAddress, token);
+            const totalTokenBalance = ethers_1.BigNumber.from(userBalance[vault.depositToken.tokenAddress]);
+            const totalSharesFetched = yield this.dripApi.fetchUserSVTBalance(vault.vaultAddress, signerAddress, token);
+            const totalShares = ethers_1.BigNumber.from(totalSharesFetched);
+            const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress);
+            let sharesToWithdraw = ethers_1.BigNumber.from(0);
+            if (!amountToWithdraw) {
+                sharesToWithdraw = totalShares;
+            }
+            else {
+                //! Not a MAX Withdraw (calculate the shares to withdraw)
+                let amountToWithdrawFixedDecimals = parseFloat(amountToWithdraw).toFixed(decimals);
+                sharesToWithdraw = ethers_1.ethers.utils
+                    .parseUnits(amountToWithdrawFixedDecimals, decimals)
+                    .mul(totalShares)
+                    .div(totalTokenBalance);
+                if (sharesToWithdraw.gt(totalShares)) {
+                    sharesToWithdraw = totalShares;
+                }
+            }
+            const nftIds = dnfts
+                .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
+                .map((item) => item.nftId.toString());
+            const nftAmounts = dnfts
+                .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
+                .map((item) => item.shares.toString());
+            return {
+                smartVault: vault.vaultAddress,
+                shares: sharesToWithdraw,
+                nftIds,
+                nftAmounts,
+            };
+        });
+    }
+    generateNewRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.generateToken();
+            const decimals = yield this.getERC20Precission(vault.depositToken.tokenAddress.toLowerCase());
+            const withdrawAll = (!amountToWithdraw);
+            const initialAmountToWithdraw = ethers_1.ethers.utils.parseUnits(amountToWithdraw || '0', decimals);
+            let totalAmountToWithdraw = initialAmountToWithdraw;
+            let dnfts = yield this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress.toLowerCase(), signerAddress, token);
+            dnfts = yield this.getAllSvts(vault.vaultAddress.toLowerCase(), signerAddress, dnfts);
+            let shares = ethers_1.BigNumber.from(0);
+            let nftIds = [];
+            let 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 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)
+                            totalAmountToWithdraw = totalAmountToWithdraw.sub(userBalance);
+                    }
+                    else {
+                        nftAmount = amountToWithdraw.mul(dnft.shares).div(userBalance);
+                        svtsToWithdraw = nftAmount.mul(userSvts).div(dnft.shares);
+                        totalAmountToWithdraw = totalAmountToWithdraw.sub(amountToWithdraw);
+                    }
+                    shares = shares.add(svtsToWithdraw);
+                    nftIds.push(dnft.nftId);
+                    nftAmounts.push(nftAmount);
+                }
+                index++;
+            }
+            return {
+                smartVault: vault.vaultAddress.toLowerCase(),
+                shares: shares,
+                nftIds,
+                nftAmounts
+            };
+        });
+    }
+    getAllSvts(vaultAddress, userAddress, dnfts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.generateToken();
+            const svts = yield this.dripApi.fetchUserSVTFromNfts(vaultAddress, userAddress, dnfts.map((element) => parseInt(element.nftId)), token);
+            const result = dnfts.map((element, index) => { return { nftId: element.nftId, assets: element.assets, shares: element.shares, svts: svts[index] }; });
+            return result;
+        });
+    }
+    getERC20Precission(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
+    }
+    calculateFastWithdrawBalancesOld(vaultAddress, userAddress, decimals) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.generateToken();
+            const fastWithdrawNFTs = yield this.dripApi.fetchFastWithdrawNFTs(vaultAddress, userAddress, token);
+            let fastWithdrawBalance = 0;
+            for (const wnft of fastWithdrawNFTs) {
+                if (wnft.assetsWithdrawn[0].asset && wnft.assetsWithdrawn[0].claimed) {
+                    const value = +(0, utils_1.insertDot)(wnft.assetsWithdrawn[0].claimed, decimals);
+                    fastWithdrawBalance += value;
+                }
+            }
+            return ethers_1.ethers.utils.parseUnits(fastWithdrawBalance.toFixed(decimals), decimals);
+        });
+    }
+    calculatePendingDepositsOld(dnfts, decimals) {
+        let pendingDeposits = 0;
+        for (const nft of dnfts) {
+            if (nft['assets'] && nft['assets'][0] && !nft.isDHWFinished) {
+                pendingDeposits += nft['assets'][0];
+            }
+        }
+        pendingDeposits = +pendingDeposits.toFixed(decimals);
+        return ethers_1.ethers.utils.parseUnits(pendingDeposits.toString(), decimals);
+    }
+    calculateDepositsOld(dnfts, decimals) {
+        let deposits = 0;
+        for (const nft of dnfts) {
+            if (nft['assets'] && nft['assets'][0] && nft.isDHWFinished) {
+                deposits += nft['assets'][0];
+            }
+        }
+        deposits = +deposits.toFixed(decimals);
+        return ethers_1.ethers.utils.parseUnits(deposits.toString(), decimals);
+    }
+    calculatePendingDeposits(dnfts, decimals) {
+        let pendingDeposits = ethers_1.BigNumber.from(0);
+        for (const nft of dnfts) {
+            if (nft['assets'] && nft['assets'][0] && !nft.isDHWFinished) {
+                pendingDeposits = pendingDeposits.add(ethers_1.ethers.utils.parseUnits(nft['assets'][0].toString(), decimals));
+            }
+        }
+        return pendingDeposits;
+    }
+    calculateAllDeposits(dnfts, decimals) {
+        let deposits = ethers_1.BigNumber.from(0);
+        for (const nft of dnfts) {
+            deposits = deposits.add(this.calculateBalanceForDNFT(nft, decimals));
+        }
+        return deposits;
+    }
+    calculateBalanceForDNFT(dnft, decimals) {
+        const assets = ethers_1.BigNumber.from(ethers_1.ethers.utils.parseUnits(dnft.assets[0].toString(), decimals));
+        const shares = ethers_1.BigNumber.from(dnft.shares);
+        if (shares.eq(0)) {
+            return ethers_1.BigNumber.from(0);
+        }
+        return assets.mul(shares).div(1000000);
+    }
+    checkIfUserHasWithdrawsToClaim(withdrawNFTS) {
+        const nftIds = withdrawNFTS
+            //! Shares come as Strings instead of BigNumber from our Backend
+            .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.nftId.toString());
+        const nftAmounts = withdrawNFTS
+            .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.shares.toString());
+        return nftIds.length !== 0 || nftAmounts.length !== 0;
+    }
+    shouldUseNewWithdrawLogic(userAddress, vault) {
+        // Users that already withdrew using the old approach should keep using the same
+        const usersWhoAlreadyWithdraw = {
+            '0x5ae62d2bc40e9119aee9cd4ed50e3d9378c9a191': KASU_USDC_VAULT_ADDRESS
+        };
+        if (usersWhoAlreadyWithdraw[userAddress.toLowerCase()] && usersWhoAlreadyWithdraw[userAddress.toLowerCase()] === vault.vaultAddress.toLowerCase()) {
+            return false;
+        }
+        return vault.newWithdraw;
+    }
+    generateToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer)
+                throw Error('No signer provided');
+            const token = yield web3_token_1.default.sign((msg) => __awaiter(this, void 0, void 0, function* () { return yield this.signer.signMessage(msg); }), '1d');
+            return token;
+        });
+    }
+    calculateAllWithdrawalBalances(wnfts, vaultAddress, decimals) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+            for (const wnft of wnfts) {
+                // Handle burned NFTs (already withdrawn by the user)
+                if (wnft.assets && wnft.assets[0] && wnft.isBurned) {
+                    withdrawals += wnft.assets[0].amount;
+                    continue;
+                }
+                const currentBlockNumber = wnft.blockNumber - 1;
+                const token = yield this.generateToken();
+                const assetsPerSvtAtBlock = yield this.dripApi.fetchAssetPerSvtAtBlock(vaultAddress, currentBlockNumber, token);
+                const estimatedValueOfNFT = ethers_1.BigNumber.from(parseInt(ethers_1.ethers.utils.formatUnits(ethers_1.BigNumber.from(wnft.svtWithdrawn).mul(assetsPerSvtAtBlock), 36)).toString());
+                if (wnft.isDHWFinished) {
+                    // Processed and Withdrawable
+                    estimatedWithdrawableBalance = estimatedWithdrawableBalance.add(estimatedValueOfNFT);
+                }
+                else {
+                    // Not processed, no DHW was ran => pending
+                    estimatedPendingWithdrawalBalance = estimatedPendingWithdrawalBalance.add(estimatedValueOfNFT);
+                }
+            }
+            // return all values as BigNumber
+            withdrawals = +withdrawals.toFixed(decimals);
+            const estimatedWithdrawals = ethers_1.ethers.utils.parseUnits(withdrawals.toString(), decimals);
+            return [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals];
+        });
+    }
+    getTokenAllowanceForSwapAndDepositContractAddress(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            return allowance;
+        });
+    }
+    approveTokenForSwapAndDepositContract(tokenAddress, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            yield approveTx.wait();
+        });
+    }
+    getTokenAllowanceForDeposit(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 smartVaultManagerAddress = yield this.dripConfig.getSmartVaultManagerAddress(this.signer);
+            const allowance = yield erc20Instance.allowance(signerAddress, smartVaultManagerAddress);
+            return allowance;
+        });
+    }
+    approveTokenForDeposit(tokenAddress, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            yield approveTx.wait();
+        });
+    }
+}
+exports.default = DripSdk;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import DripSdk from './DripSdk';
+import { Vault, Strategy } from './types/Vault';
+import { DripConfig } from './DripConfig';
+export { Vault, Strategy, DripSdk, DripConfig };

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DripConfig = exports.DripSdk = void 0;
+const DripSdk_1 = __importDefault(require("./DripSdk"));
+exports.DripSdk = DripSdk_1.default;
+const DripConfig_1 = require("./DripConfig");
+Object.defineProperty(exports, "DripConfig", { enumerable: true, get: function () { return DripConfig_1.DripConfig; } });

package/dist/types/QLFastRedeem.d.ts

@@ -0,0 +1,15 @@
+export interface QLFastRedeem {
+    assetsWithdrawn: {
+        asset: {
+            decimals: number;
+            id: string;
+            name: string;
+            symbol: string;
+        };
+        claimed: string;
+        id: string;
+    }[];
+    blockNumber: number;
+    id: string;
+    svtWithdrawn: string;
+}

package/dist/types/QLFastRedeem.js

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

package/dist/types/SwapInfo.d.ts

@@ -0,0 +1,5 @@
+export type SwapInfo = {
+    swapTarget: any;
+    token: string;
+    swapCallData: any;
+};

package/dist/types/SwapInfo.js

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

package/dist/types/UserBalance.d.ts

@@ -0,0 +1,7 @@
+export type UserBalance = {
+    hasWithdrawsToClaim: boolean;
+    userBalance: string;
+    pendingUserBalance: string;
+    pendingWithdrawalBalance: string;
+    withdrawableBalance: string;
+};

package/dist/types/UserBalance.js

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

package/dist/types/Vault.d.ts

@@ -0,0 +1,66 @@
+export type Vault = {
+    vaultName: string;
+    vaultAddress: string;
+    apy: number;
+    tvr: number;
+    protocols: string[];
+    projectName: string;
+    depositToken: VaultDepositToken;
+    type: VaultType;
+    rewards: VaultReward[];
+    liveUntil: string;
+    liveUntilFormatted: string;
+    hasPoolEnded: boolean;
+    boosters: NFTBoost[];
+    stretchGoals: StretchGoal[];
+    strategies: Strategy[];
+    newWithdraw: boolean;
+    tgePrice?: number;
+    maxAmountOfTokens?: number;
+    rewardsInformation: RewardsInformation;
+};
+export type VaultType = 'launch' | 'earn' | 'airdrop';
+export type VaultDepositToken = {
+    name: string;
+    symbol: string;
+    roundingDecimals: number;
+    precisionDecimals: number;
+    tokenAddress: string;
+};
+export type VaultReward = {
+    type: 'token' | 'points';
+    name: string;
+    symbol: string;
+    decimals: number;
+    tokenAddress: string;
+    monthlyEmissionRate?: number;
+};
+export type NFTBoost = {
+    url: string;
+    tokenAddress: string;
+    multiplier: number;
+    nftAddress: string;
+    network: string;
+    initialBlock: number;
+    imagePath: string;
+};
+export interface StretchGoal {
+    threshhold: number;
+    threshholdDescription: string;
+    rewardTooltip: string;
+    rewardDescription: string;
+    amountOfTokens: number;
+}
+export type RewardsInformation = {
+    [tokenAddress: string]: {
+        blockNumber: string;
+        rewardrate: string;
+        timestamp: string;
+        endTime: string;
+    };
+};
+export type Strategy = {
+    address: string;
+    lastDoHardWorkTime: number | null;
+    lastDoHardWorkBlock: number | null;
+};

package/dist/types/Vault.js

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

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function insertDot(numberString: string, decimals: number): string;

package/dist/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertDot = void 0;
+function insertDot(numberString, decimals) {
+    if (numberString.length < decimals + 1) {
+        numberString = '0'.repeat(decimals + 1 - numberString.length) + numberString;
+    }
+    const indexToInsertDot = numberString.length - decimals;
+    // Ensure there is a part before the dot, even if it's 0
+    const beforeDecimal = indexToInsertDot > 0 ? numberString.slice(0, indexToInsertDot) : '0';
+    const afterDecimal = numberString.slice(indexToInsertDot);
+    return `${beforeDecimal}.${afterDecimal}`;
+}
+exports.insertDot = insertDot;

package/package.json

@@ -1,16 +1,22 @@
 {
   "name": "@dripfi/drip-sdk",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Drip SDK",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
+    "prepublish": "npm run build",
+    "build": "tsc",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
     "@spool.fi/spool-v2-sdk": "1.0.14",
-    "web3-token": "^1.0.6",
-    "ethers": "^5.7.2"
+    "ethers": "^5.7.2",
+    "web3-token": "^1.0.6"
   },
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^5.4.5"
+  }
 }