@dripfi/drip-sdk 1.0.0

package/DripApi.ts

@@ -0,0 +1,133 @@
+import { BigNumber } from "ethers"
+import { Vault } from "./types/Vault"
+import { SwapInfo } from "./types/SwapInfo"
+import { QLFastRedeem } from "./types/QLFastRedeem"
+
+const WETH_TOKEN_ADDRESS = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+
+export default class DripApi {
+
+    route: string
+
+    constructor(route: string) {
+        this.route = route
+    }
+
+    async fetchAllVaults(): Promise<Vault[]> {
+        const res = await fetch(`${this.route}/api-be/api/vault`)
+        const data: Vault[] = await res.json() as Vault[]
+        return data
+    }
+
+    async fetchVaultDetails(vaultAddress: string): Promise<Vault> {
+        const res = await fetch(`${this.route}/api-be/api/vault/${vaultAddress}`)
+        const data: Vault = await res.json() as Vault
+        return data
+    }
+
+
+    async getSwapInfo(fromTokenAddress: string, toTokenAddress: string, amount: BigNumber, fromAddress: string,): Promise<SwapInfo[]> {
+        if (fromTokenAddress === toTokenAddress && fromTokenAddress === WETH_TOKEN_ADDRESS) {
+            return []
+        }
+
+        const url = `${this.route}/oneinch?getRequest=/swap/v5.2/1/swap?fromTokenAddress=${fromTokenAddress}%26toTokenAddress=${toTokenAddress}%26amount=${amount.toString()}%26fromAddress=${fromAddress}%26slippage=0.1%26disableEstimate=true%26allowPartialFill=false%26includeTokensInfo=true`
+        const res = await fetch(url)
+        const data = await res.json() as any
+        return [
+            {
+                swapTarget: data.tx.to,
+                token: data.fromToken.address,
+                swapCallData: data.tx.data,
+            }
+        ]
+    }
+
+    async fetchUserSVTBalance(vaultAddress: string, walletAddress: string, token: string): Promise<BigNumber> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/svtBalance/${walletAddress}/${vaultAddress}`, {
+            headers,
+        })
+
+        const data = await res.json() as BigNumber
+        return data
+    }
+
+    async fetchUserBalance(vaultAddress: string, walletAddress: string, token: string): Promise<Record<string, string>> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/userBalance/${walletAddress}/${vaultAddress}`, {
+            headers,
+        })
+        const data = await res.json() as Record<string, string>
+        return data
+    }
+
+    async fetchEnrichedUserDNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/dNft/${walletAddress}/${vaultAddress}`, {
+            headers,
+        })
+        const data = await res.json()
+        return data as any[]
+    }
+
+    async fetchUserSVTFromNfts(vaultAddress: string, userAddress: string, dnfts: number[], token: string): Promise<BigNumber[]> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/svtFromNft/${userAddress}/${vaultAddress}?dnfts=${dnfts.join(',')}`, {
+            headers: {
+                Authorization: token,
+            },
+        })
+
+        const data = await res.json() as BigNumber[]
+        return data
+    }
+
+    async fetchAllUserWNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/allWnft/${walletAddress}/${vaultAddress}`, {
+            headers
+        })
+        const data = await res.json() as any[]
+        return data
+    }
+
+    async fetchAllUserDNFTForVault(vaultAddress: string, walletAddress: string, token: string): Promise<any[]> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/allDnft/${walletAddress}/${vaultAddress}`,{
+            headers
+        })
+        const data = await res.json() as any[]
+        return data
+    }
+
+    async fetchAssetPerSvtAtBlock(vaultAddress: string, blocknumber: number, token: string): Promise<BigNumber> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/assetBalance/${blocknumber}/${vaultAddress}`, {
+            headers,
+        })
+        const data = await res.json() as BigNumber
+        return data
+    }
+
+    async fetchFastWithdrawNFTs(vaultAddress: string, walletAddress: string, token: string): Promise<QLFastRedeem[]> {
+        const headers = new Headers()
+        headers.append('Authorization', token)
+        const res = await fetch(`${this.route}/api-be/api/spool/user/fastWithdrawNft/${walletAddress}/${vaultAddress}`, {
+            headers,
+        })
+        const data = await res.json() as QLFastRedeem[]
+
+        return data
+    }
+
+}
+
+

package/DripConfig.ts

@@ -0,0 +1,38 @@
+import { ContractAddresses, SDKConfig } from "@spool.fi/spool-v2-sdk";
+import { Signer } from "ethers";
+
+export class DripConfig {
+
+    internalConfig: SDKConfig
+    dripRoute: string
+    swapAndDepositContractAddress: string | undefined
+    smartVaultManagerAddress: string | undefined
+
+    constructor(subgraphUrl: string, priceFeedApiUrl: string, rewardsUrl: string, fastRedeemApi: string, contracts: Record<number, ContractAddresses>, dripRoute: string) {
+        this.internalConfig = new SDKConfig(subgraphUrl, priceFeedApiUrl, rewardsUrl, fastRedeemApi, contracts)
+        this.dripRoute = dripRoute
+    }
+
+    async getSwapAndDepositContractAddress(signer: Signer): Promise<string> {
+        if (!signer) throw Error('No signer provided')
+
+        if (!this.swapAndDepositContractAddress) {
+            const contract = await this.internalConfig.getChainAddresses(signer)
+            this.swapAndDepositContractAddress = contract.IDepositSwap
+        }
+
+        return this.swapAndDepositContractAddress
+    }
+
+    async getSmartVaultManagerAddress(signer: Signer): Promise<string> {
+        if (!signer) throw Error('No signer provided')
+
+        if (!this.smartVaultManagerAddress) {
+            const contract = await this.internalConfig.getChainAddresses(signer)
+            this.smartVaultManagerAddress = contract.ISmartVaultManager
+        }
+
+        return this.smartVaultManagerAddress
+    }
+
+}

package/DripSdk.ts

@@ -0,0 +1,516 @@
+import { Vault } from "./types/Vault";
+import Web3Token from "web3-token";
+import { DepositBagStruct, ERC20, ERC20__factory, EnrichedWNFT, RedeemBagStruct, SDKConfig, SpoolSdk } from '@spool.fi/spool-v2-sdk'
+import { BigNumber, Bytes, Signer, ethers } from "ethers";
+import { DripConfig } from "./DripConfig";
+import { insertDot } from "./utils";
+import { UserBalance } from "./types/UserBalance";
+import DripApi from "./DripApi";
+
+const KASU_USDC_VAULT_ADDRESS = "0xd8aa8099a53eddebe6a49c98ca12746ff19aa502"
+
+export default class DripSdk {
+
+    private dripApi: DripApi
+    private spoolSdk?: SpoolSdk
+    private signer?: Signer
+    private dripConfig: DripConfig
+
+    constructor(dripConfig: DripConfig, signer?: Signer) {
+        this.signer = signer
+        this.dripConfig = dripConfig
+        if (signer) {
+            this.spoolSdk = new SpoolSdk(dripConfig.internalConfig, signer)
+        }
+        this.dripApi = new DripApi(dripConfig.dripRoute)
+
+    }
+
+    async getAllVaults(): Promise<Vault[]> {
+        return this.dripApi.fetchAllVaults()
+    }
+
+    async getVaultDetails(vaultAddress: string): Promise<Vault> {
+        return this.dripApi.fetchVaultDetails(vaultAddress)
+    }
+
+    async getUserBalance(vault: Vault): Promise<UserBalance> {
+        if (!this.signer) throw Error('No signer provided')
+        const userAddress = await this.signer.getAddress()
+
+        const token = await this.generateToken()
+        const dnfts = await this.dripApi.fetchAllUserDNFTForVault(vault.vaultAddress, userAddress, token)
+        const wnfts = await this.dripApi.fetchAllUserWNFTForVault(vault.vaultAddress, userAddress, token)
+        const decimals = await this.getERC20Precission(vault.depositToken.tokenAddress)
+
+        if (this.shouldUseNewWithdrawLogic(userAddress, vault)) {
+
+            const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance] = await this.calculateAllWithdrawalBalances(
+                wnfts,
+                vault.vaultAddress,
+                decimals,
+            )
+            const hasWithdrawsToClaim = this.checkIfUserHasWithdrawsToClaim(wnfts)
+
+            const pendingDeposits: BigNumber = this.calculatePendingDeposits(dnfts, decimals)
+
+            const userBalance: BigNumber = this.calculateAllDeposits(dnfts, decimals).sub(pendingDeposits)
+            return {
+                hasWithdrawsToClaim,
+                userBalance: ethers.utils.formatUnits(userBalance, decimals),
+                pendingUserBalance: ethers.utils.formatUnits(pendingDeposits, decimals),
+                pendingWithdrawalBalance: ethers.utils.formatUnits(estimatedPendingWithdrawalBalance, decimals),
+                withdrawableBalance: ethers.utils.formatUnits(estimatedWithdrawableBalance, decimals),
+            }
+        } else {
+            const allDeposits = this.calculateDepositsOld(dnfts, decimals)
+            const pendingDeposits = this.calculatePendingDepositsOld(dnfts, decimals)
+            const [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals] =
+                await this.calculateAllWithdrawalBalances(wnfts, vault.vaultAddress, decimals)
+            const fastWithdrawBalance = await 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.utils.formatUnits(balance, decimals),
+                pendingUserBalance: ethers.utils.formatUnits(pendingDeposits, decimals),
+                pendingWithdrawalBalance: ethers.utils.formatUnits(estimatedPendingWithdrawalBalance, decimals),
+                withdrawableBalance: ethers.utils.formatUnits(estimatedWithdrawableBalance, decimals),
+            }
+        }
+
+    }
+
+    private async fastWithdraw(vault: Vault, amountToWithdraw?: string) {
+        if (!this.signer) throw Error('No signer provided')
+        try {
+
+            const signerAddress = await this.signer.getAddress()
+            if (!signerAddress) throw Error('Error fetching address')
+
+            const redeemBagStruct: RedeemBagStruct = this.shouldUseNewWithdrawLogic(signerAddress, vault)
+                ? await this.generateNewRedeemBagStruct(vault, signerAddress, amountToWithdraw)
+                : await this.generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw)
+
+
+            const currentBlockNumber = await this.signer.provider?.getBlockNumber()
+
+            if (!currentBlockNumber) throw Error('Error fetching block number')
+
+            const redeemTx = await this.spoolSdk?.redeemFast(
+                redeemBagStruct,
+                signerAddress.toLowerCase(),
+                currentBlockNumber,
+            )
+
+            const redeemTxReceipt = await redeemTx!.wait()
+        } catch (error) {
+            console.log(error)
+        }
+    }
+
+    private async deposit(tokenAddress: string, vaultAddress: string, amount: string) {
+        if (!this.signer) throw Error('No signer provided')
+
+        const currentTokenAllowance = await this.getTokenAllowanceForDeposit(tokenAddress)
+        const decimals = await this.getERC20Precission(tokenAddress)
+        let amountToWithdrawFixedDecimals = parseFloat(amount).toFixed(decimals)
+        const amountToDeposit = ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals)
+
+        if (amountToDeposit.gt(currentTokenAllowance)) {
+            const requiredTokenAllowance = amountToDeposit.sub(currentTokenAllowance)
+            await this.approveTokenForDeposit(tokenAddress, requiredTokenAllowance)
+        }
+        const signerAddress = await this.signer.getAddress()
+
+        if (!signerAddress) throw Error('Error fetching address')
+
+        const depositBagStruct: DepositBagStruct = {
+            smartVault: vaultAddress,
+            assets: [amountToDeposit],
+            receiver: signerAddress,
+            referral: ethers.constants.AddressZero,
+            doFlush: false,
+        }
+
+        const depositTx = await this.spoolSdk!.deposit(depositBagStruct)
+
+        await depositTx.wait()
+    }
+
+
+    private async swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string) {
+        if (!this.signer) throw Error('No signer provided')
+
+
+        const decimals = await this.getERC20Precission(fromTokenAddress)
+        const amountToWithdrawFixedDecimals = parseFloat(fromTokenAmount).toFixed(decimals)
+        const fromToken = ethers.utils.parseUnits(amountToWithdrawFixedDecimals, decimals)
+
+        const signerAddress = await this.signer.getAddress()
+
+        if (fromToken.gt(BigNumber.from(0))) {
+            const currentTokenAllowance = await this.getTokenAllowanceForSwapAndDepositContractAddress(fromTokenAddress)
+
+            if (fromToken.gt(currentTokenAllowance)) {
+                await this.approveTokenForSwapAndDepositContract(fromTokenAddress, fromToken.sub(currentTokenAllowance))
+            }
+        }
+
+        const swapInfo = await this.dripApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, signerAddress)
+
+        const swapDepositBagStruct = {
+            inTokens: [fromTokenAddress],
+            inAmounts: [fromToken],
+            smartVault: vaultAddress,
+            swapInfo,
+            receiver: signerAddress,
+            referral: ethers.constants.AddressZero,
+            doFlush: false,
+        }
+
+        let swapAndDepositRequest: ethers.ContractTransaction | undefined
+
+        if (ethAmount) {
+            const eth = ethers.utils.parseEther(ethAmount)
+            swapAndDepositRequest = await this.spoolSdk?.swapAndDeposit(swapDepositBagStruct, { value: eth })
+        } else {
+            swapAndDepositRequest = await this.spoolSdk?.swapAndDeposit(swapDepositBagStruct)
+        }
+
+        await swapAndDepositRequest?.wait()
+    }
+
+    private async withdraw(vault: Vault, amountToWithdraw?: string) {
+        if (!this.signer) throw Error('No signer provided')
+
+        try {
+            const signerAddress = await this.signer.getAddress()
+
+            if (!signerAddress) throw Error('Error fetching address')
+
+            const redeemBagStruct: RedeemBagStruct = this.shouldUseNewWithdrawLogic(signerAddress, vault)
+                ? await this.generateNewRedeemBagStruct(vault, signerAddress, amountToWithdraw)
+                : await this.generateOldRedeemBagStruct(vault, signerAddress, amountToWithdraw)
+
+            const redeemTx = await this.spoolSdk!.redeem(redeemBagStruct, signerAddress.toLowerCase(), false)
+
+            const redeemTxReceipt = await redeemTx.wait()
+        } catch (error) {
+            console.log(error)
+        }
+    }
+
+
+    private async generateOldRedeemBagStruct(vault: Vault, signerAddress: string, amountToWithdraw?: string): Promise<RedeemBagStruct> {
+        const token = await this.generateToken()
+
+        const dnfts = await this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress, signerAddress, token)
+
+        const userBalance = await this.dripApi.fetchUserBalance(vault.vaultAddress, signerAddress, token)
+        const totalTokenBalance = BigNumber.from(userBalance[vault.depositToken.tokenAddress])
+        const totalSharesFetched = await this.dripApi.fetchUserSVTBalance(vault.vaultAddress, signerAddress, token)
+        const totalShares = BigNumber.from(totalSharesFetched)
+
+        const decimals = await this.getERC20Precission(vault.depositToken.tokenAddress)
+
+        let sharesToWithdraw = 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.utils
+                .parseUnits(amountToWithdrawFixedDecimals, decimals)
+                .mul(totalShares)
+                .div(totalTokenBalance)
+
+            if (sharesToWithdraw.gt(totalShares)) {
+                sharesToWithdraw = totalShares
+            }
+        }
+
+        const nftIds = dnfts
+            .filter((item) => !item.isBurned && BigNumber.from(item.shares).gt(BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.nftId.toString())
+        const nftAmounts = dnfts
+            .filter((item) => !item.isBurned && BigNumber.from(item.shares).gt(BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.shares.toString())
+
+        return {
+            smartVault: vault.vaultAddress,
+            shares: sharesToWithdraw,
+            nftIds,
+            nftAmounts,
+        }
+    }
+
+
+    private async generateNewRedeemBagStruct(vault: Vault, signerAddress: string, amountToWithdraw?: string): Promise<RedeemBagStruct> {
+        const token = await this.generateToken()
+        const decimals = await this.getERC20Precission(vault.depositToken.tokenAddress.toLowerCase())
+        const withdrawAll: boolean = (!amountToWithdraw)
+        const initialAmountToWithdraw: BigNumber = ethers.utils.parseUnits(amountToWithdraw || '0', decimals)
+        let totalAmountToWithdraw: BigNumber = initialAmountToWithdraw
+        let dnfts: any[] = await this.dripApi.fetchEnrichedUserDNFTForVault(vault.vaultAddress.toLowerCase(), signerAddress, token)
+        dnfts = await this.getAllSvts(vault.vaultAddress.toLowerCase(), signerAddress, dnfts)
+        let shares: BigNumber = BigNumber.from(0)
+        let nftIds: BigNumber[] = []
+        let nftAmounts: BigNumber[] = []
+        let index = 0
+
+        while (dnfts[index] && (totalAmountToWithdraw.gt(0) || withdrawAll)) {
+
+            const dnft: { nftId: BigNumber, shares: BigNumber, svts: BigNumber, assets: number[] } = dnfts[index]
+
+            const userBalance = this.calculateBalanceForDNFT(dnft, decimals)
+
+            if (userBalance.gt(0)) {
+
+                let amountToWithdraw: BigNumber = totalAmountToWithdraw
+                const userSvts = dnft.svts
+
+                let svtsToWithdraw = BigNumber.from(0)
+                let nftAmount = 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
+        }
+    }
+
+    private async getAllSvts(vaultAddress: string, userAddress: string, dnfts: any[]): Promise<{ nftId: BigNumber, shares: BigNumber, assets: number[], svts: BigNumber }[]> {
+        const token = await this.generateToken()
+        const svts: BigNumber[] = await 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
+    }
+
+    private async getERC20Precission(tokenAddress: string): Promise<number> {
+        if (!this.signer) throw Error('No signer provided')
+
+        const signerAddress = await this.signer.getAddress()
+
+        if (!signerAddress) throw Error('Error fetching address')
+
+        const erc20Instance: ERC20 = ERC20__factory.connect(tokenAddress, this.signer)
+
+        const decimals = await erc20Instance.decimals()
+
+        return decimals
+    }
+
+    private async calculateFastWithdrawBalancesOld(vaultAddress: string, userAddress: string, decimals: number) {
+        const token = await this.generateToken()
+        const fastWithdrawNFTs = await 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 = +insertDot(wnft.assetsWithdrawn[0].claimed, decimals)
+                fastWithdrawBalance += value
+            }
+        }
+        return ethers.utils.parseUnits(fastWithdrawBalance.toFixed(decimals), decimals)
+    }
+
+    private calculatePendingDepositsOld(dnfts: any[], decimals: number) {
+        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.utils.parseUnits(pendingDeposits.toString(), decimals)
+    }
+
+    private calculateDepositsOld(dnfts: any[], decimals: number): BigNumber {
+        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.utils.parseUnits(deposits.toString(), decimals)
+    }
+
+    private calculatePendingDeposits(dnfts: any[], decimals: number): BigNumber {
+        let pendingDeposits: BigNumber = BigNumber.from(0)
+        for (const nft of dnfts) {
+            if (nft['assets'] && nft['assets'][0] && !nft.isDHWFinished) {
+                pendingDeposits = pendingDeposits.add(ethers.utils.parseUnits(nft['assets'][0].toString(), decimals))
+            }
+        }
+
+        return pendingDeposits
+    }
+
+
+    private calculateAllDeposits(dnfts: any[], decimals: number): BigNumber {
+        let deposits: BigNumber = BigNumber.from(0)
+        for (const nft of dnfts) {
+            deposits = deposits.add(this.calculateBalanceForDNFT(nft, decimals))
+        }
+        return deposits
+    }
+
+    private calculateBalanceForDNFT(dnft: { assets: number[], shares: BigNumber }, decimals: number): BigNumber {
+
+        const assets = BigNumber.from(ethers.utils.parseUnits(dnft.assets[0]!.toString(), decimals))
+        const shares = BigNumber.from(dnft.shares)
+        if (shares.eq(0)) {
+            return BigNumber.from(0)
+        }
+        return assets.mul(shares).div(1000000)
+    }
+
+    private checkIfUserHasWithdrawsToClaim(withdrawNFTS: any[]): boolean {
+        const nftIds = withdrawNFTS
+            //! Shares come as Strings instead of BigNumber from our Backend
+            .filter((item) => !item.isBurned && BigNumber.from(item.shares).gt(BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.nftId.toString())
+
+        const nftAmounts = withdrawNFTS
+            .filter((item) => !item.isBurned && BigNumber.from(item.shares).gt(BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.shares.toString())
+
+        return nftIds.length !== 0 || nftAmounts.length !== 0
+    }
+    private shouldUseNewWithdrawLogic(userAddress: string, vault: Vault) {
+
+        // Users that already withdrew using the old approach should keep using the same
+        const usersWhoAlreadyWithdraw: { [walletAddress: string]: string } = {
+            '0x5ae62d2bc40e9119aee9cd4ed50e3d9378c9a191': KASU_USDC_VAULT_ADDRESS
+        }
+        if (usersWhoAlreadyWithdraw[userAddress.toLowerCase()] && usersWhoAlreadyWithdraw[userAddress.toLowerCase()] === vault.vaultAddress.toLowerCase()) {
+            return false
+        }
+        return vault.newWithdraw
+    }
+
+    private async generateToken(): Promise<string> {
+        if (!this.signer) throw Error('No signer provided')
+        const token: string = await Web3Token.sign(async (msg: string | Bytes) => await this.signer!.signMessage(msg), '1d');
+        return token
+    }
+
+    private async calculateAllWithdrawalBalances(wnfts: EnrichedWNFT[], vaultAddress: string, decimals: number) {
+        if (!this.signer) throw Error('No signer provided')
+        const userAddress = await this.signer.getAddress()
+
+        let estimatedPendingWithdrawalBalance = BigNumber.from(0)
+        let estimatedWithdrawableBalance = 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 = await this.generateToken()
+            const assetsPerSvtAtBlock = await this.dripApi.fetchAssetPerSvtAtBlock(vaultAddress, currentBlockNumber, token)
+            const estimatedValueOfNFT = BigNumber.from(
+                parseInt(ethers.utils.formatUnits(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.utils.parseUnits(withdrawals.toString(), decimals)
+        return [estimatedPendingWithdrawalBalance, estimatedWithdrawableBalance, estimatedWithdrawals]
+    }
+
+
+
+    private async getTokenAllowanceForSwapAndDepositContractAddress(tokenAddress: string): Promise<BigNumber> {
+        if (!this.signer) throw Error('No signer provided')
+
+        const signerAddress = await this.signer.getAddress()
+
+        if (!signerAddress) throw Error('Error fetching address')
+
+        const erc20Instance: ERC20 = ERC20__factory.connect(tokenAddress, this.signer)
+
+        const swapAndDepositAddress = await this.dripConfig.getSwapAndDepositContractAddress(this.signer)
+
+        const allowance = await erc20Instance.allowance(signerAddress, swapAndDepositAddress)
+
+        return allowance
+    }
+
+    private async approveTokenForSwapAndDepositContract(tokenAddress: string, amount: BigNumber) {
+        if (!this.signer) throw Error('No signer provided')
+
+        const swapAndDepositContractAddress = await this.dripConfig.getSwapAndDepositContractAddress(this.signer)
+
+        const erc20Instance: ERC20 = ERC20__factory.connect(tokenAddress, this.signer)
+        const approveTx = await erc20Instance.approve(swapAndDepositContractAddress, amount)
+
+        await approveTx.wait()
+    }
+
+    private async getTokenAllowanceForDeposit(tokenAddress: string): Promise<BigNumber> {
+        if (!this.signer) throw Error('No signer provided')
+
+        const signerAddress = await this.signer.getAddress()
+
+        if (!signerAddress) throw Error('Error fetching address')
+
+        const erc20Instance: ERC20 = ERC20__factory.connect(tokenAddress, this.signer)
+
+        const smartVaultManagerAddress = await this.dripConfig.getSmartVaultManagerAddress(this.signer)
+
+        const allowance = await erc20Instance.allowance(signerAddress, smartVaultManagerAddress)
+
+        return allowance
+    }
+
+    private async approveTokenForDeposit(tokenAddress: string, amount: BigNumber) {
+        if (!this.signer) throw Error('No signer provided')
+
+        const smartVaultManagerAddress = await this.dripConfig.getSmartVaultManagerAddress(this.signer)
+
+        const erc20Instance: ERC20 = ERC20__factory.connect(tokenAddress, this.signer)
+        const approveTx = await erc20Instance.approve(smartVaultManagerAddress, amount)
+
+        await approveTx.wait()
+    }
+
+}
+

package/index.ts

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

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@dripfi/drip-sdk",
+  "version": "1.0.0",
+  "description": "Drip SDK",
+  "main": "index.js",
+  "scripts": {
+    "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"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/types/QLFastRedeem.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/types/SwapInfo.ts

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

package/types/UserBalance.ts

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

package/types/Vault.ts

@@ -0,0 +1,68 @@
+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 // needs to be the block when rewards was deployed
+    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/utils.ts

@@ -0,0 +1,12 @@
+
+export function insertDot(numberString: string, decimals: number) {
+    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}`
+}
+