@dripfi/drip-sdk 1.4.9 → 1.4.10

package/dist/subpackages/RecyclerPackage.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+class RecyclerPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getTokenAllowanceForRecycler(tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), this.perqSdk.perqTokenRecyclerContract.getContractAddress());
+        return allowance;
+    }
+    async getTokenAllowanceForSwapAndRecycler(tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), this.perqSdk.perqSwapAndRecyclerContract.getContractAddress());
+        return allowance;
+    }
+    async recycleTokens(tokenAddress = this.perqSdk.perqConfig.perqTokenAddress, amountToRecycle, beneficiary = ethers_1.ethers.constants.AddressZero, price, deadline, signature) {
+        if (this.perqSdk.perqConfig.perqTokenRecyclerAddress === ethers_1.ethers.constants.AddressZero) {
+            throw Error('Recycler contract address not defined');
+        }
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const amountWithDecimals = ethers_1.ethers.utils.parseUnits(amountToRecycle, decimals).toString();
+        const recycleTx = await this.perqSdk.perqTokenRecyclerContract.recycle(amountWithDecimals, beneficiary, price, deadline, signature);
+        const receipt = await recycleTx.wait();
+        return receipt.transactionHash;
+    }
+    async swapAndRecycleETH(beneficiary, path, minAmountOutWithDecimals, amountOfEth, price, deadline, signature) {
+        if (this.perqSdk.perqConfig.perqSwapAndRecyclerAddress === ethers_1.ethers.constants.AddressZero) {
+            throw Error('Recycler contract address not defined');
+        }
+        const swapAndRecycleTx = await this.perqSdk.perqSwapAndRecyclerContract.swapETHAndRecycle(beneficiary, path, minAmountOutWithDecimals, amountOfEth, price, deadline, signature);
+        const receipt = await swapAndRecycleTx.wait();
+        return receipt.transactionHash;
+    }
+    async swapAndRecycleERC20(beneficiary, path, minAmountOutWithDecimals, amountInWithDecimals, price, deadline, signature) {
+        if (this.perqSdk.perqConfig.perqSwapAndRecyclerAddress === ethers_1.ethers.constants.AddressZero) {
+            throw Error('Recycler contract address not defined');
+        }
+        const swapAndRecycleTx = await this.perqSdk.perqSwapAndRecyclerContract.swapAndRecycle(beneficiary, path, amountInWithDecimals, minAmountOutWithDecimals, price, deadline, signature);
+        const receipt = await swapAndRecycleTx.wait();
+        return receipt.transactionHash;
+    }
+    async approveTokenForRecycler(tokenAddress, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        if (this.perqSdk.perqConfig.perqTokenRecyclerAddress === ethers_1.ethers.constants.AddressZero) {
+            throw Error('Recycler contract address not defined');
+        }
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        return await tokenContract.approveToken(this.perqSdk.perqConfig.perqTokenRecyclerAddress, parsedAmount);
+    }
+    async approveTokenForSwapAndRecycler(tokenAddress, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        if (this.perqSdk.perqConfig.perqSwapAndRecyclerAddress === ethers_1.ethers.constants.AddressZero) {
+            throw Error('Recycler contract address not defined');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        return await tokenContract.approveToken(this.perqSdk.perqConfig.perqSwapAndRecyclerAddress, parsedAmount);
+    }
+}
+exports.default = RecyclerPackage;

package/dist/subpackages/SignHandlerPackage.d.ts

@@ -0,0 +1,8 @@
+import PerqSdk from '../PerqSdk';
+import { NonceEnrichedSignedPayload } from '../types';
+export default class SignHandlerPackage {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    private getEnrichedPayload;
+    signPayload<T>(payload: T): Promise<NonceEnrichedSignedPayload<T>>;
+}

package/dist/subpackages/SignHandlerPackage.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SignHandlerPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getEnrichedPayload(payload) {
+        return this.perqSdk.perqApi.getNonceEnrichedPayload(payload.payload);
+    }
+    async signPayload(payload) {
+        if (!this.perqSdk.signer) {
+            throw new Error('No signer provided');
+        }
+        // Wrap the payload in a Basepayload to enrich it later on
+        const basePayload = {
+            payload,
+        };
+        const signerAddress = await this.perqSdk.signer.getAddress();
+        // Get enriched payload with nonce before signing
+        const enrichedPayload = await this.getEnrichedPayload(basePayload);
+        // Create message to sign
+        const message = JSON.stringify(enrichedPayload);
+        // Sign the message
+        const signature = await this.perqSdk.signer.signMessage(message);
+        return {
+            signature,
+            signerAddress,
+            payload: enrichedPayload,
+        };
+    }
+}
+exports.default = SignHandlerPackage;

package/dist/subpackages/TokenUtilsPackage.d.ts

@@ -0,0 +1,13 @@
+import { BigNumber } from 'ethers';
+import PerqSdk from '../PerqSdk';
+export default class TokenUtilsPackage {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getTokenPrice(tokenName: string): Promise<number>;
+    getAllowance(tokenAddress: string, spender: string): Promise<string>;
+    approveAllowance(tokenAddress: string, amount: string, spenderAddress: string): Promise<string>;
+    transferErc20Token(tokenAddress: string, amount: string, receiver: string): Promise<string>;
+    wrapEther(amount: string, tokenAddress: string): Promise<string>;
+    getERC20TokenAllowance(spender: string, tokenAddress: string): Promise<BigNumber>;
+    getPerqTokenContractAddress(): string;
+}

package/dist/subpackages/TokenUtilsPackage.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+const WethTokenAbi_json_1 = __importDefault(require("../abi/WethTokenAbi.json"));
+class TokenUtilsPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getTokenPrice(tokenName) {
+        return this.perqSdk.perqApi.fetchTokenPrice(tokenName);
+    }
+    async getAllowance(tokenAddress, spender) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), spender);
+        return allowance.toString();
+    }
+    async approveAllowance(tokenAddress, amount, spenderAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmount = ethers_1.ethers.utils.parseUnits(parseFloat(amount).toFixed(decimals), decimals);
+        return await tokenContract.approveToken(spenderAddress, parsedAmount.toString());
+    }
+    async transferErc20Token(tokenAddress, amount, receiver) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const txHash = await tokenContract.transfer(receiver, ethers_1.ethers.utils.parseUnits(amount, decimals).toString());
+        return txHash;
+    }
+    async wrapEther(amount, tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const wethContract = new ethers_1.ethers.Contract(tokenAddress, WethTokenAbi_json_1.default, this.perqSdk.signer);
+        const decimals = await wethContract.decimals();
+        const amountWithDecimals = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        const depositTx = await wethContract.deposit({ value: amountWithDecimals });
+        const receipt = await depositTx.wait();
+        return receipt.transactionHash;
+    }
+    async getERC20TokenAllowance(spender, tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const allowance = tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), spender);
+        return allowance;
+    }
+    getPerqTokenContractAddress() {
+        return this.perqSdk.perqConfig.perqTokenAddress;
+    }
+}
+exports.default = TokenUtilsPackage;

package/dist/subpackages/UserPackage.d.ts

@@ -0,0 +1,10 @@
+import PerqSdk from '../PerqSdk';
+import { Earnings, LinkedPodWallets } from '../types';
+export default class UserPackage {
+    private perqSdk;
+    constructor(perqSdk: PerqSdk);
+    getEarnings(projectName: string): Promise<Earnings>;
+    linkSuiWalletWithEthWallet(suiWalletAddress: string): Promise<boolean>;
+    linkNearWalletWithEthWallet(nearWalletAddress: string): Promise<boolean>;
+    getLinkedPodWallets(): Promise<LinkedPodWallets>;
+}

package/dist/subpackages/UserPackage.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class UserPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getEarnings(projectName) {
+        if (!this.perqSdk.signer) {
+            throw new Error('No signer provided');
+        }
+        return this.perqSdk.perqApi.fetchEarnings(await this.perqSdk.signer.getAddress(), projectName);
+    }
+    async linkSuiWalletWithEthWallet(suiWalletAddress) {
+        const payload = {
+            suiWalletAddr: suiWalletAddress,
+        };
+        const signedPayload = await this.perqSdk.signHandler.signPayload(payload);
+        return this.perqSdk.perqApi.linkSuiWalletWithEthWallet(signedPayload);
+    }
+    async linkNearWalletWithEthWallet(nearWalletAddress) {
+        const payload = {
+            nearWalletAddr: nearWalletAddress,
+        };
+        const signedPayload = await this.perqSdk.signHandler.signPayload(payload);
+        return this.perqSdk.perqApi.linkNearWalletWithEthWallet(signedPayload);
+    }
+    async getLinkedPodWallets() {
+        if (!this.perqSdk.signer) {
+            throw new Error('No signer provided');
+        }
+        const walletAddr = await this.perqSdk.signer.getAddress();
+        return this.perqSdk.perqApi.getPodWallets(walletAddr);
+    }
+}
+exports.default = UserPackage;

package/dist/subpackages/V2Package.d.ts

@@ -0,0 +1,24 @@
+import { UserVaultBalance, VaultData } from '../types';
+import PerqSdk from '../PerqSdk';
+export default class V2Package {
+    perqSdk: PerqSdk;
+    constructor(perqSdk: PerqSdk);
+    getPoolDetails(vaultAddress: string): Promise<VaultData>;
+    newDeposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
+    deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>;
+    private doDeposit;
+    getSwapAndDepositTokenAllowanceForCurrency(tokenAddress: string): Promise<string>;
+    getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>;
+    getUserPoolBalance(vaultAddress: string): Promise<UserVaultBalance>;
+    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>;
+    private doSwapAndDeposit;
+    withdraw(vaultAddress: string, amountToWithdraw?: string): Promise<string>;
+    claimWithdraws(vaultAddress: string): Promise<string>;
+    approveTokenForSwapAndDeposit(tokenAddress: string, amount: string): Promise<string>;
+    approveTokenForDeposit(tokenAddress: string, amount: string): Promise<string>;
+    private generateRedeemBagStruct;
+    private getTokenAllowanceForDeposit;
+    getTokenAllowanceForCurrency(tokenAddress: string): Promise<string>;
+}

package/dist/subpackages/V2Package.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const ERC20TokenContract_1 = __importDefault(require("../contracts/ERC20TokenContract"));
+const ChainId_1 = require("../types/ChainId");
+class V2Package {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getPoolDetails(vaultAddress) {
+        return this.perqSdk.perqApi.fetchPoolV2Details(vaultAddress);
+    }
+    async newDeposit(tokenAddress, vaultAddress, amount) {
+        return this.doDeposit(tokenAddress, vaultAddress, amount, false);
+    }
+    async deposit(tokenAddress, vaultAddress, amount) {
+        return this.doDeposit(tokenAddress, vaultAddress, amount, true);
+    }
+    async doDeposit(tokenAddress, vaultAddress, amount, checkAllowance) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const amountWithDecimals = parseFloat(parseFloat(amount).toFixed(decimals));
+        if (checkAllowance) {
+            const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), this.perqSdk.perqConfig.smartVaultManagerContractAddress);
+            const currentTokenAllowance = parseFloat(ethers_1.ethers.utils.formatUnits(allowance, decimals));
+            if (amountWithDecimals > currentTokenAllowance) {
+                await this.approveTokenForDeposit(tokenAddress, amountWithDecimals.toString());
+            }
+        }
+        const amountToDeposit = ethers_1.ethers.utils.parseUnits(amountWithDecimals.toString(), decimals);
+        const signerAddress = await this.perqSdk.signer.getAddress();
+        if (!signerAddress) {
+            throw Error('Error fetching address');
+        }
+        const depositBagStruct = {
+            smartVault: vaultAddress.toLowerCase(),
+            assets: [amountToDeposit],
+            receiver: signerAddress,
+            referral: ethers_1.ethers.constants.AddressZero,
+            doFlush: false,
+        };
+        const depositTx = await this.perqSdk.spoolSdk.deposit(depositBagStruct);
+        const txReceipt = await depositTx.wait();
+        return txReceipt.transactionHash;
+    }
+    async getSwapAndDepositTokenAllowanceForCurrency(tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), this.perqSdk.perqConfig.swapAndDepositContractAddress);
+        return allowance.toString();
+    }
+    async getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals) {
+        return this.perqSdk.perqApi.getExpectedSwapResult(fromTokenAddress, toTokenAddress, amount, decimals, ChainId_1.ETHEREUM_CHAIN_ID.toString());
+    }
+    async getUserPoolBalance(vaultAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        return await this.perqSdk.perqApi.fetchV2PoolUserBalance(userAddress.toLowerCase(), vaultAddress.toLowerCase());
+    }
+    async fastWithdraw(vaultAddress, amountToWithdraw) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        const vault = await this.getPoolDetails(vaultAddress);
+        const redeemBagStruct = await this.generateRedeemBagStruct(vault, userAddress, amountToWithdraw);
+        const currentBlockNumber = await this.perqSdk.signer.provider?.getBlockNumber();
+        if (!currentBlockNumber) {
+            throw Error('Error fetching block number');
+        }
+        const redeemTx = await this.perqSdk.spoolSdk?.redeemFast(redeemBagStruct, userAddress, currentBlockNumber);
+        const txReceipt = await redeemTx.wait();
+        return txReceipt.transactionHash;
+    }
+    async swapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, ethAmount) {
+        return this.doSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, true, ethAmount);
+    }
+    async newSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, ethAmount) {
+        return this.doSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, false, ethAmount);
+    }
+    async doSwapAndDeposit(fromTokenAddress, toTokenAddress, fromTokenAmount, vaultAddress, checkAllowance, ethAmount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        const tokenContract = new ERC20TokenContract_1.default(fromTokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const amountWithDecimals = parseFloat(parseFloat(fromTokenAmount).toFixed(decimals));
+        if (amountWithDecimals > 0 && checkAllowance) {
+            const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), this.perqSdk.perqConfig.swapAndDepositContractAddress);
+            const currentTokenAllowance = parseFloat(ethers_1.ethers.utils.formatUnits(allowance, decimals));
+            if (amountWithDecimals > currentTokenAllowance) {
+                await this.approveTokenForSwapAndDeposit(fromTokenAddress, amountWithDecimals.toString());
+            }
+        }
+        const fromToken = ethers_1.ethers.utils.parseUnits(amountWithDecimals.toString(), decimals);
+        const swapInfo = await this.perqSdk.perqApi.getSwapInfo(fromTokenAddress, toTokenAddress, fromToken, this.perqSdk.perqConfig.ethereumSwapperAddress, ChainId_1.ETHEREUM_CHAIN_ID);
+        const swapDepositBagStruct = {
+            inTokens: [fromTokenAddress],
+            inAmounts: [fromToken],
+            smartVault: vaultAddress.toLowerCase(),
+            swapInfo,
+            receiver: userAddress,
+            referral: ethers_1.ethers.constants.AddressZero,
+            doFlush: false,
+        };
+        const swapAndDepositRequest = ethAmount
+            ? await this.perqSdk.spoolSdk.swapAndDeposit(swapDepositBagStruct, {
+                value: ethers_1.ethers.utils.parseEther(ethAmount),
+            })
+            : await this.perqSdk.spoolSdk.swapAndDeposit(swapDepositBagStruct);
+        const txReceipt = await swapAndDepositRequest.wait();
+        return txReceipt?.transactionHash;
+    }
+    async withdraw(vaultAddress, amountToWithdraw) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        const vault = await this.getPoolDetails(vaultAddress);
+        const redeemBagStruct = await this.generateRedeemBagStruct(vault, userAddress, amountToWithdraw);
+        const redeemTx = await this.perqSdk.spoolSdk.redeem(redeemBagStruct, userAddress, false);
+        const redeemTxReceipt = await redeemTx.wait();
+        return redeemTxReceipt.transactionHash;
+    }
+    async claimWithdraws(vaultAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const userAddress = await this.perqSdk.signer.getAddress();
+        const wnfts = await this.perqSdk.perqApi.fetchEnrichedUserWNFTForPool(vaultAddress, userAddress);
+        //! Shares come as Strings instead of BigNumber from our Backend
+        const nftIds = wnfts
+            .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.nftId.toString());
+        const nftAmounts = wnfts
+            .filter((item) => !item.isBurned && ethers_1.BigNumber.from(item.shares).gt(ethers_1.BigNumber.from('0')) && item.isDHWFinished)
+            .map((item) => item.shares.toString());
+        const claimWithdrawTx = await this.perqSdk.spoolSdk.claimWithdrawal(vaultAddress.toLowerCase(), nftIds, nftAmounts, userAddress);
+        const txReceipt = await claimWithdrawTx.wait();
+        return txReceipt.transactionHash;
+    }
+    async approveTokenForSwapAndDeposit(tokenAddress, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        return await tokenContract.approveToken(this.perqSdk.perqConfig.swapAndDepositContractAddress, parsedAmount);
+    }
+    async approveTokenForDeposit(tokenAddress, amount) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const decimals = await tokenContract.getPrecission();
+        const parsedAmount = ethers_1.ethers.utils.parseUnits(amount, decimals);
+        return await tokenContract.approveToken(this.perqSdk.perqConfig.smartVaultManagerContractAddress, parsedAmount);
+    }
+    async generateRedeemBagStruct(vault, signerAddress, amountToWithdraw) {
+        if (!this.perqSdk.spoolSdk) {
+            throw Error('No spool sdk provided');
+        }
+        const isFullWithdraw = !amountToWithdraw;
+        if (isFullWithdraw) {
+            return this.perqSdk.spoolSdk.views.userInfo.getMaxRedeemBag({
+                userAddress: signerAddress.toLowerCase(),
+                vaultAddress: vault.vaultAddress.toLowerCase(),
+            });
+        }
+        else {
+            return this.perqSdk.spoolSdk.views.userInfo.getMinimumBurnRedeemBag({
+                userAddress: signerAddress.toLowerCase(),
+                vaultAddress: vault.vaultAddress.toLowerCase(),
+                assetsToWithdraw: [Number(amountToWithdraw)],
+            });
+        }
+    }
+    async getTokenAllowanceForDeposit(tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const tokenContract = new ERC20TokenContract_1.default(tokenAddress, this.perqSdk.signer);
+        const allowance = await tokenContract.getAllowance(await this.perqSdk.signer.getAddress(), this.perqSdk.perqConfig.smartVaultManagerContractAddress);
+        return allowance;
+    }
+    async getTokenAllowanceForCurrency(tokenAddress) {
+        if (!this.perqSdk.signer) {
+            throw Error('No signer provided');
+        }
+        const currentTokenAllowance = await this.getTokenAllowanceForDeposit(tokenAddress);
+        return currentTokenAllowance.toString();
+    }
+}
+exports.default = V2Package;

package/dist/subpackages/VestingPackage.d.ts

@@ -0,0 +1,14 @@
+import { VestingInfo } from '../types';
+import PerqSdk from '../PerqSdk';
+export default class VestingPackage {
+    perqSdk: PerqSdk;
+    constructor(perqSdk: PerqSdk);
+    getVestingStart(): Promise<string>;
+    getVestingEnd(): Promise<string>;
+    getVestedAmount(beneficiary: string): Promise<string>;
+    getReleasableAmount(beneficiary: string): Promise<string>;
+    getReleasableTotalAmount(beneficiary: string): Promise<string>;
+    claimVestedPerq(amount: string): Promise<string>;
+    burnVestedPerq(amount: string, price: string, deadline: string, signature: string): Promise<string>;
+    getAllVestingInfo(beneficiaryAddress: string): Promise<VestingInfo>;
+}

package/dist/subpackages/VestingPackage.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("ethers/lib/utils");
+class VestingPackage {
+    perqSdk;
+    constructor(perqSdk) {
+        this.perqSdk = perqSdk;
+    }
+    async getVestingStart() {
+        try {
+            const startBigNumber = await this.perqSdk.perqVestingContract.start();
+            return startBigNumber.toString();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get vesting start time: ${error.message}`);
+            }
+            throw new Error('Failed to get vesting start time: Unknown error');
+        }
+    }
+    async getVestingEnd() {
+        try {
+            const endBigNumber = await this.perqSdk.perqVestingContract.end();
+            return endBigNumber.toString();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get vesting end time: ${error.message}`);
+            }
+            throw new Error('Failed to get vesting end time: Unknown error');
+        }
+    }
+    async getVestedAmount(beneficiary) {
+        try {
+            const vestedAmount = await this.perqSdk.perqVestingContract.vested(beneficiary);
+            return (0, utils_1.formatUnits)(vestedAmount, 18);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get vested amount: ${error.message}`);
+            }
+            throw new Error('Failed to get vested amount: Unknown error');
+        }
+    }
+    async getReleasableAmount(beneficiary) {
+        try {
+            const releasableAmount = await this.perqSdk.perqVestingContract.releasable(beneficiary);
+            return (0, utils_1.formatUnits)(releasableAmount, 18);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get releasable amount: ${error.message}`);
+            }
+            throw new Error('Failed to get releasable amount: Unknown error');
+        }
+    }
+    async getReleasableTotalAmount(beneficiary) {
+        try {
+            const releasableTotalAmount = await this.perqSdk.perqVestingContract.releasableTotal(beneficiary);
+            return (0, utils_1.formatUnits)(releasableTotalAmount, 18);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get total releasable amount: ${error.message}`);
+            }
+            throw new Error('Failed to get total releasable amount: Unknown error');
+        }
+    }
+    async claimVestedPerq(amount) {
+        try {
+            const claimTx = await this.perqSdk.perqVestingContract.claim(amount);
+            const txReceipt = await claimTx.wait();
+            return txReceipt.transactionHash;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get total releasable amount: ${error.message}`);
+            }
+            throw new Error('Failed to get total releasable amount: Unknown error');
+        }
+    }
+    async burnVestedPerq(amount, price, deadline, signature) {
+        try {
+            const burnTx = await this.perqSdk.perqVestingContract.burn(amount, price, deadline, signature);
+            const txReceipt = await burnTx.wait();
+            return txReceipt.transactionHash;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to get total releasable amount: ${error.message}`);
+            }
+            throw new Error('Failed to get total releasable amount: Unknown error');
+        }
+    }
+    async getAllVestingInfo(beneficiaryAddress) {
+        const [startTimestamp, endTimestamp, vested, releasable, releasableTotal] = await Promise.all([
+            this.getVestingStart(),
+            this.getVestingEnd(),
+            this.getVestedAmount(beneficiaryAddress),
+            this.getReleasableAmount(beneficiaryAddress),
+            this.getReleasableTotalAmount(beneficiaryAddress),
+        ]);
+        return {
+            startTimestamp,
+            endTimestamp,
+            vested,
+            releasable,
+            releasableTotal,
+        };
+    }
+}
+exports.default = VestingPackage;

package/dist/types/ChainId.d.ts

@@ -0,0 +1,5 @@
+export declare const BASE_CHAIN_ID = 8453;
+export declare const ETHEREUM_CHAIN_ID = 1;
+export declare const ETHEREUM_SEPOLIA_CHAIN_ID = 11155111;
+export declare const ARBITRUM_CHAIN_ID = 42161;
+export type ChainId = typeof BASE_CHAIN_ID | typeof ETHEREUM_CHAIN_ID | typeof ETHEREUM_SEPOLIA_CHAIN_ID | typeof ARBITRUM_CHAIN_ID;

package/dist/types/ChainId.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARBITRUM_CHAIN_ID = exports.ETHEREUM_SEPOLIA_CHAIN_ID = exports.ETHEREUM_CHAIN_ID = exports.BASE_CHAIN_ID = void 0;
+exports.BASE_CHAIN_ID = 8453;
+exports.ETHEREUM_CHAIN_ID = 1;
+exports.ETHEREUM_SEPOLIA_CHAIN_ID = 11155111;
+exports.ARBITRUM_CHAIN_ID = 42161;

package/dist/types/DeployedProject.d.ts

@@ -39,6 +39,9 @@ type DeployedProject = {
     bannerImage?: string;
     rewardImage?: string;
     rewardTooltipName?: string;
+    liveUntil: string;
+    liveFrom: string;
+    distributionType: string;
 };
 export default DeployedProject;
 export type ProjectBacker = {