@dripfi/drip-sdk 1.3.10 → 1.3.12

package/README.md

@@ -2,9 +2,10 @@
 
 ## Introduction
 
-The Drip SDK is a TypeScript library designed to interact with the Drip protocol. It provides methods to retrieve information about Drip Vaults, manage user authentication, and fetch user balances.
+The Drip SDK is a TypeScript library designed to interact with the Perq protocol. It provides methods to retrieve information about Perq Vaults, manage user authentication, and fetch user balances.
 
 ## Table of Contents
+
 - [Installation](#installation)
 - [Usage](#usage)
 - [Methods](#methods)
@@ -23,8 +24,8 @@ npm i @dripfi/drip-sdk
 # Usage
 
 ```typescript
-import DripSdk from '@drip/sdk'
-import { DripConfig, Chain } from '@dripfi/drip-sdk'
+import DripSdk from '@drip/sdk';
+import { DripConfig, Chain } from '@dripfi/drip-sdk';
 ```
 
 Initialize the SDK with your Drip configuration and an optional signer:
@@ -42,51 +43,51 @@ const dripSdk = new DripSdk(chain, signer);
 
 # Methods
 
-| Name | Requires authentication | Description |
-| ------ | ------ | ----------- |
-| `getAllVaults(): Promise<Vault[]>`| NO | Fetches details of all Drip Vaults. |
-| `getVaultDetails(vaultAddress: string): Promise<Vault>` | NO | Fetches details of a specific Drip Vault identified by its address. |
-| `getVaultStats(): Promise<VaultStats>`| NO | Returns some overall drip stats |
-| `getTokenPrice(tokenName: string): Promise<number>`| NO | Returns the price for the given token (only works for weth at the moment) |
-| `updateSigner(newSigner: Signer): Promise<void>`| NO | Updates the signer for the SDK instance. |
-| `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>` | NO | The deposit function allows you to deposit tokens into a specific vault. Returns txHash. |
-| `getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>`| NO | Returns the expected amount of tokens to get from a swap |
-| `getUserBalance(): Promise<UserBalance>` | YES | Returns overall user balance information |
-| `getRewardsPerHour(vaultAddress: string): Promise<string[]>` | YES | Returns an estimated amount of tokens the user will receive in 1 hour as reward. It considers boost nfts the user owns for the estimation. |
-| `getRewards(): Promise<UserRewards>` | YES | Fetches the current user's rewards points for each vault. |
-| `getUserVaultBalance(): Promise<UserVaultBalance>` | YES | Fetches the user's balance for a specific Drip Vault.  |
-| `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>` | YES | For users who prefer not to wait for withdrawals to be processed, there is a Fast Withdrawal method. While this approach is more gas-intensive, as users bear the cost of executing the withdrawal process themselves, it allows for instant access to the withdrawn tokens. When utilizing Fast Withdrawal, users immediately receive the tokens, eliminating the need to initiate the 'claimWithdrawal' process separately. Returns txHash. |
-| `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>` | YES | The swapAndDeposit function allows you to deposit a different token or ether and it will take care of swapping to the correct token before making the deposit. Returns txHash. |
-| `withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>` | YES | Withdraws tokens from a vault. After withdrawing, you must wait for the withdrawal to be processed by the 'DoHardWork' function, and then you can claim those tokens using claimWithdraws(). Returns txHash. |
-| `claimWithdraws(vaultAddress: string): Promise<string>` | YES | After the withdrawal has been processed by the 'DoHardWork' function, the 'claimWithdraws' function transfers the withdrawn tokens to their personal account. Returns txHash. |
-| `getTokenAllowanceForCurrency(tokenAddress: string): Promise<string>` | NO | This function retrieves the token allowance for a specific currency. |
-| `getTokenAllowanceForRecycler(tokenAddress: string): Promise<BigNumber>` | NO | This function retrieves the token allowance for the recycler contract. |
-| `getTokenAllowanceForSwapAndRecycler(tokenAddress: string): Promise<BigNumber>` | NO | This function retrieves the token allowance for the swap and recycler contract. |
-| `getUserBoostedNfts(vaultAddress: string): Promise<string[]>` | YES | This function retrieves an array of boosted NFT addresses owned by the user. |
-| `getRewardsPerHour(vaultAddress: string): Promise<number> ` | YES | This function returns an estimated amount of tokens the user will receive in one hour as a reward for the given vault |
-| `newDeposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>` | YES | This function allows for a new deposit without checking for allowance.
-| `newSwapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string> ` | YES | This function allows for a new swap and deposit without checking for allowance. |
-| `getAllVestingInfo(beneficiaryAddress: string): Promise<VestingInfo>` | YES | This function retrieves all vesting information for a specified beneficiary. |
-| `getVestingStart(): Promise<string>` | YES | This function retrieves the start time of the vesting period. |
-| `getVestingEnd(): Promise<string>` | YES | This function retrieves the end time of the vesting period.
-| `getBeansHistory(): Promise<BeanEntry[]> ` | YES | This function retrieves the user's beans history of tx
-| `getBeansBalance(): Promise<BeansBalance>  ` | YES | This function retrieves the user's beans balance.
-| `getMyPerqBalance(): Promise<MyPerqData>` | YES | This function retrieves the user's Perq balance data.
-| `getVaultsClaimableData(): Promise<VaultClaimData> ` | YES | This function fetches claimable data for the user's vaults.
-| `upgradeLoyaltyCard(index: number): Promise<LoyaltyCard>` | YES | This function upgrades the user's loyalty card.
-| `getOwnedLoyaltyCard(): Promise<LoyaltyCard>` | YES |  This function fetches the currently owned loyalty card of the connected wallet.
-| `getAllLoyaltyCards(): Promise<LoyaltyCard[]>` | YES |  This function fetches all available loyalty cards.
+| Name                                                                                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `getAllVaults(): Promise<Vault[]>`                                                                                                                         | Fetches details of all Perq Vaults.                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `getVaultDetails(vaultAddress: string): Promise<Vault>`                                                                                                    | Fetches details of a specific Perq Vault identified by its address.                                                                                                                                                                                                                                                                                                                                                                           |
+| `getVaultStats(): Promise<VaultStats>`                                                                                                                     | Returns some overall Perq stats                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `getTokenPrice(tokenName: string): Promise<number>`                                                                                                        | Returns the price for the given token (only works for weth at the moment)                                                                                                                                                                                                                                                                                                                                                                     |
+| `updateSigner(newSigner: Signer): Promise<void>`                                                                                                           | Updates the signer for the SDK instance.                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>`                                                                     | The deposit function allows you to deposit tokens into a specific vault. Returns txHash.                                                                                                                                                                                                                                                                                                                                                      |
+| `getExpectedSwapResult(fromTokenAddress: string, toTokenAddress: string, amount: string, decimals: number): Promise<string>`                               | Returns the expected amount of tokens to get from a swap                                                                                                                                                                                                                                                                                                                                                                                      |
+| `getRewardsPerHour(vaultAddress: string): Promise<string[]>`                                                                                               | Returns an estimated amount of tokens the user will receive in 1 hour as reward. It considers boost nfts the user owns for the estimation.                                                                                                                                                                                                                                                                                                    |
+| `getRewards(): Promise<UserRewards>`                                                                                                                       | Fetches the current user's rewards points for each vault.                                                                                                                                                                                                                                                                                                                                                                                     |
+| `getUserVaultBalance(): Promise<UserVaultBalance>`                                                                                                         | Fetches the user's balance for a specific Perq Vault.                                                                                                                                                                                                                                                                                                                                                                                         |
+| `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`                                                                                   | For users who prefer not to wait for withdrawals to be processed, there is a Fast Withdrawal method. While this approach is more gas-intensive, as users bear the cost of executing the withdrawal process themselves, it allows for instant access to the withdrawn tokens. When utilizing Fast Withdrawal, users immediately receive the tokens, eliminating the need to initiate the 'claimWithdrawal' process separately. Returns txHash. |
+| `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>`     | The swapAndDeposit function allows you to deposit a different token or ether and it will take care of swapping to the correct token before making the deposit. Returns txHash.                                                                                                                                                                                                                                                                |
+| `withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`                                                                                       | Withdraws tokens from a vault. After withdrawing, you must wait for the withdrawal to be processed by the 'DoHardWork' function, and then you can claim those tokens using claimWithdraws(). Returns txHash.                                                                                                                                                                                                                                  |
+| `claimWithdraws(vaultAddress: string): Promise<string>`                                                                                                    | After the withdrawal has been processed by the 'DoHardWork' function, the 'claimWithdraws' function transfers the withdrawn tokens to their personal account. Returns txHash.                                                                                                                                                                                                                                                                 |
+| `getTokenAllowanceForCurrency(tokenAddress: string): Promise<string>`                                                                                      | Retrieves the token allowance for a specific currency.                                                                                                                                                                                                                                                                                                                                                                                        |
+| `getTokenAllowanceForRecycler(tokenAddress: string): Promise<BigNumber>`                                                                                   | Retrieves the token allowance for the recycler contract.                                                                                                                                                                                                                                                                                                                                                                                      |
+| `getTokenAllowanceForSwapAndRecycler(tokenAddress: string): Promise<BigNumber>`                                                                            | Retrieves the token allowance for the swap and recycler contract.                                                                                                                                                                                                                                                                                                                                                                             |
+| `getUserBoostedNfts(vaultAddress: string): Promise<string[]>`                                                                                              | Retrieves an array of boosted NFT addresses owned by the user.                                                                                                                                                                                                                                                                                                                                                                                |
+| `getRewardsPerHour(vaultAddress: string): Promise<number> `                                                                                                | Returns an estimated amount of tokens the user will receive in one hour as a reward for the given vault                                                                                                                                                                                                                                                                                                                                       |
+| `newDeposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>`                                                                  | Allows for a new deposit without checking for allowance.                                                                                                                                                                                                                                                                                                                                                                                      |
+| `newSwapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string> ` | Allows for a new swap and deposit without checking for allowance.                                                                                                                                                                                                                                                                                                                                                                             |
+| `getAllVestingInfo(beneficiaryAddress: string): Promise<VestingInfo>`                                                                                      | Retrieves all vesting information for a specified beneficiary.                                                                                                                                                                                                                                                                                                                                                                                |
+| `getVestingStart(): Promise<string>`                                                                                                                       | Retrieves the start time of the vesting period.                                                                                                                                                                                                                                                                                                                                                                                               |
+| `getVestingEnd(): Promise<string>`                                                                                                                         | Retrieves the end time of the vesting period.                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `getBeansHistory(): Promise<BeanEntry[]> `                                                                                                                 | Retrieves the user's beans history of tx                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `getBeansBalance(): Promise<BeansBalance>  `                                                                                                               | Retrieves the user's beans balance.                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `getMyPerqBalance(): Promise<MyPerqData>`                                                                                                                  | Retrieves the user's Perq balance data.                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `upgradeLoyaltyCard(index: number): Promise<LoyaltyCard>`                                                                                                  | Upgrades the user's loyalty card.                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `getOwnedLoyaltyCard(): Promise<LoyaltyCard>`                                                                                                              | Fetches the currently owned loyalty card of the connected wallet.                                                                                                                                                                                                                                                                                                                                                                             |
+| `getAllLoyaltyCards(): Promise<LoyaltyCard[]>`                                                                                                             | Fetches all available loyalty cards.                                                                                                                                                                                                                                                                                                                                                                                                          |
 
 ---
 
 # Examples
 
-### `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>`  
+### `deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>`
 
 I want to deposit 100 USDC in a USDC vault:
+
 ```typescript
 USDC_TOKEN_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"    --> USDC contract address in tenderly environment
 ```
+
 you can get vault token address from the vault.depositToken.tokenAddress
 
 ```typescript
@@ -108,7 +109,7 @@ const txHash = await deposit(USDC_TOKEN_ADDRESS, VAULT_ADDRESS, '100')
 
 ---
 
-### `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>`  
+### `swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>`
 
 I want to deposit 1.5ETH in a WETH vault:
 
@@ -117,6 +118,7 @@ WETH_TOKEN_ADDRESS = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"    --> WETH co
 
 const txHash = await swapAndDeposit(WETH_TOKEN_ADDRESS, WETH_TOKEN_ADDRESS, '0', vaultAddress, '1.5')
 ```
+
 you can get vault token address from the vault.depositToken.tokenAddress
 
 > [!IMPORTANT]
@@ -124,12 +126,13 @@ you can get vault token address from the vault.depositToken.tokenAddress
 
 ---
 
-### `withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`  
+### `withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`
 
 ```typescript
- const userBalanceObject = await getUserBalance()
- const balance = userBalanceObject.userbalance
+const userBalanceObject = await getUserBalance();
+const balance = userBalanceObject.userbalance;
 ```
+
 > [!NOTE]
 > If i check balance, that is the max amount I can withdraw
 
@@ -137,42 +140,45 @@ I want to withdraw 100 USDC from the 1st vault fetched. ---> Let's assume the fi
 Fetch vaults returned by getAllVault() and pass the vault you want to withdraw from, and the amount to withdraw (100 in this example)
 
 ```typescript
-const vaults = await getAllVaults()
-const vaultToWithdrawFrom = vaults[0]
+const vaults = await getAllVaults();
+const vaultToWithdrawFrom = vaults[0];
 
-const txHash = await withdraw(vaultToWithdrawFrom, '100')
+const txHash = await withdraw(vaultToWithdrawFrom, '100');
 ```
 
 if you want to withdraw all funds in the vault, don't specify the amountToWithdraw:
 
 ```typescript
-const txHash = await withdraw(vaultToWithdrawFrom)
+const txHash = await withdraw(vaultToWithdrawFrom);
 ```
+
 > [!IMPORTANT]
 > you will have to claim your withdraws after DHW is processed to transfer the withdrawn funds to your wallet
 
 ---
 
-### `claimWithdraws(vaultAddress: string): Promise<string>`  
+### `claimWithdraws(vaultAddress: string): Promise<string>`
 
 ```typescript
- const userBalanceObject = await getUserBalance()
- const hasWithdrawsToClaim = userBalanceObject.hasWithdrawsToClaim
+const userBalanceObject = await getUserBalance();
+const hasWithdrawsToClaim = userBalanceObject.hasWithdrawsToClaim;
 ```
- if hasWithdrawsToClaim is true you have available funds to transfer to your address 
+
+if hasWithdrawsToClaim is true you have available funds to transfer to your address
 
 ```typescript
- const txHash = await claimWithdraws()
+const txHash = await claimWithdraws();
 ```
+
 It will transfer all available funds withdrawn with withdraw() function, to your address
 
 ---
 
-### `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`  
+### `fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>`
 
 ```typescript
- const userBalanceObject = await getUserBalance()
- const balance = userBalanceObject.userbalance
+const userBalanceObject = await getUserBalance();
+const balance = userBalanceObject.userbalance;
 ```
 
 > [!NOTE]
@@ -182,236 +188,304 @@ I want to withdraw 3.55 WETH from the 1st vault fetched. ---> Let's assume the f
 Fetch vaults returned by getAllVault() and pass the vault you want to withdraw from, and the amount to withdraw (3.55 in this example)
 
 ```typescript
-const vaults = await getAllVaults()
-const vaultToWithdrawFrom = vaults[0]
+const vaults = await getAllVaults();
+const vaultToWithdrawFrom = vaults[0];
 
-const txHash = await fastWithdraw(vaultToWithdrawFrom, '3.55')
+const txHash = await fastWithdraw(vaultToWithdrawFrom, '3.55');
 ```
 
 if you want to withdraw all funds in the vault, don't specify the amountToWithdraw, like:
 
 ```typescript
-const txHash = await fastWithdraw(vaultToWithdrawFrom)
+const txHash = await fastWithdraw(vaultToWithdrawFrom);
 ```
 
 # Types
 
 ```typescript
-type Vault = {
-  vaultName: string
-  vaultAddress: string
-  apy: number
-  tvr: number
-  protocols: string[]
-  depositToken: VaultDepositToken
-  type: VaultType
-  rewards: VaultReward[]
-  rewardType: RewardType
-  liveUntil: string
-  liveFrom: string
-  liveUntilFormatted: string
-  hasPoolEnded: boolean
-  boosters: NFTBoost[]
-  strategies: Strategy[]
-  tgePrice?: number
-  maxAmountOfTokens?: number
-  project: DeployedProject
-  projectId: number
-  coingeckoId?: string
-  depositTokenId: string
-  expectedTge?: string
-  tokenPrice: number
-  change24h: number
-  volume24h: number
-  projectFeatured: boolean
-  avgTvl: string
-  peakTvl: string
-  amountOfDepositors: number
-  boostedTvl: number
-  projectVAPY?: number
+type Asset = {
+	decimals: number;
+	symbol: string;
+};
+
+type BeanEntry = {
+	address: string;
+	reason: string;
+	recycledAmount: string;
+	beansAmount: string;
+	beansSum: string;
+	amountDepositedInUsd: string;
+	createdAt: string;
+	chainId: number;
+	nonce: number;
 };
 
-type VaultType = 'launch' | 'earn' | 'airdrop'
+type BeansBalance = {
+	balance: string;
+	bonusesClaimed: string[];
+};
 
-type VaultDepositToken = {
-  name: string
-  symbol: string
-  roundingDecimals: number
-  precisionDecimals: number
-  tokenAddress: string
+enum Chain {
+	MAINNET = 'mainnet',
+	SEPOLIA = 'sepolia',
 }
 
-type VaultReward = {
-  type: 'token' | 'points';
-  name: string;
-  symbol: string;
-  decimals: number;
-  tokenAddress: string;
-  monthlyEmissionRate: number;
-  blockNumber: number;
-  rewardRate: number;
-  timestamp: number;
-  endTime: number;
+type DeployedProject = {
+	id: number | undefined;
+	projectName: string;
+	owners: string[];
+	logo: string;
+	telegramLink: string;
+	twitterLink: string;
+	mediumLink: string;
+	deckLink: string;
+	roadmapLink: string;
+	economicsLink: string;
+	discordLink: string;
+	docsLink: string;
+	whitepaperLink: string;
+	litepaperLink: string;
+	websiteLink: string;
+	supplyAtLaunch: number;
+	fdv: number;
+	latestRoundPriceInUsd: number;
+	totalSupply: number;
+	disabledTgePrice: boolean;
+	backers: ProjectBacker[];
+	networks: string[];
+	content: string;
+	tgeDate?: string;
+	tgePrice?: number;
+	vAPY?: number;
+	wikiLink: string;
+	youTubeLink: string;
+	tikTokLink: string;
+	stretchGoals: StretchGoal[];
+	projectInfoText: string;
+	projectRewardText: string;
+	coingeckoId?: string;
+	projectType: string;
+	isFeatured: boolean;
+	yelayVersion: YelayVersion;
+	bannerImage?: string;
+	rewardImage?: string;
 };
 
-type NFTBoost = {
-  url: string
-  tokenAddress: string
-  multiplier: number
-  nftAddress: string
-  network: string
-  initialBlock: number
-  imagePath: string
-}
+type DeployedVault = {
+	projectId: number;
+	vaultAddress: string;
+	liveUntil: string;
+	liveFrom: string;
+	type: VaultType;
+	depositTokenId: string;
+	rewards: VaultReward[];
+	project?: DeployedProject;
+	coingeckoId?: string;
+	expectedTge?: string;
+};
 
-interface StretchGoal {
-  threshhold: number
-  threshholdDescription: string
-  rewardTooltip: string
-  rewardDescription: string
-  amountOfTokens: number
-}
+type DepositToken = {
+	name: string;
+	symbol: string;
+	roundingDecimals: number;
+	precisionDecimals: number;
+	tokenAddress: string;
+};
 
-type Strategy = {
-  address: string
-  lastDoHardWorkTime: number | null
-  lastDoHardWorkBlock: number | null
+enum ELoyaltyCardTier {
+	White = 'White',
+	Ivory = 'Ivory',
+	Dune = 'Dune',
+	Amber = 'Amber',
+	Sienna = 'Sienna',
+	Umber = 'Umber',
+	Black = 'Black',
 }
 
-interface QLFastRedeem {
-  assetsWithdrawn: {
-    asset: {
-      decimals: number
-      id: string
-      name: string
-      symbol: string
-    }
-    claimed: string
-    id: string
-  }[]
-  blockNumber: number
-  id: string
-  svtWithdrawn: string
-}
+type LoyaltyCard = {
+	id: string;
+	tier: ELoyaltyCardTier;
+	level: number;
+	cost: number;
+	boost: number;
+};
 
-type SwapInfo = {
-  swapTarget: any
-  token: string
-  swapCallData: any
-}
+type MyPerqData = Vault & {
+	claimable: number;
+	pendingDeposits: number;
+	pendingWithdraws: number;
+	currentlyDeposited: number;
+	ethPrice: number;
+	tokenRewards: { [token_address: string]: Asset & { amount: number; rewardsPerHour?: number } };
+};
 
-type UserBalance = {
-    assets: {
-            asset: string,
-            dripping: string,
-            deposits: number,
-            depositsUSD: number,
-            tvr: number,
-            apy: number,
-            decimals: number,
-            reward: number
-    }[],
-    available: { [symbol: string] : number},
-    claimed: { [symbol: string] : number},
+type NFTBoost = {
+	url: string;
+	tokenAddress: string;
+	multiplier: number;
+	nftAddress: string;
+	network: string;
+	initialBlock: number;
+	imagePath: string;
 };
 
+export type BasePayload<T> = {
+	payload: T;
+};
 
-type UserVaultBalance = {
-  hasWithdrawsToClaim: boolean
-  userBalance: string
-  pendingUserBalance: string
-  pendingWithdrawalBalance: string
-  claimableBalance: string
+export type NonceEnrichedPayload<T> = T & {
+	deadline: number;
+	signature: string;
+};
+
+export type NonceEnrichedSignedPayload<T> = {
+	signature: string;
+	signerAddress: string;
+	payload: NonceEnrichedPayload<T>;
+};
+
+type PerqToBeansSwapInfo = {
+	perqPrice: number;
+	price: number;
+	priceInFloat: number;
+	deadline: number;
+	signature: string;
+};
+
+type ProjectBacker = {
+	name: string;
+	image: string;
+	link: string;
+};
+
+type QLFastRedeem = {
+	assetsWithdrawn: {
+		asset: {
+			decimals: number;
+			id: string;
+			name: string;
+			symbol: string;
+		};
+		claimed: string;
+		id: string;
+	}[];
+	blockNumber: number;
+	id: string;
+	svtWithdrawn: string;
+};
+
+type Strategy = {
+	address: string;
+	lastDoHardWorkTime: number | null;
+	lastDoHardWorkBlock: number | null;
+	name: string;
+	assetGroupId: number;
+	apy: number;
+};
+
+interface StretchGoal {
+	threshhold: number;
+	amountOfTokens: number;
+}
+
+type SwapInfo = {
+	swapTarget: any;
+	token: string;
+	swapCallData: any;
 };
 
+type UpgradeLoyaltyCardPayload = {
+	index: number;
+};
 
 type UserRewards = {
-   [vaultAddress: string]: { [rewardPointsName: string]: number } 
+	// vaultAddress => pointsName => rewardsAmount
+	[vaultAddress: string]: { [rewardPointsName: string]: number };
 };
 
-type VaultStats = {
-    totalTVL: number
-    totalUsers: number
-    activeVaults: number
-  };
+type UserVaultBalance = {
+	hasWithdrawsToClaim: boolean;
+	userBalance: string;
+	pendingUserBalance: string;
+	pendingWithdrawalBalance: string;
+	claimableBalance: string;
+};
 
-type BeanEntry = {
-    address: string
-    reason: string
-    recycledAmount: string
-    beansAmount: string
-    beansSum: string
-    amountDepositedInUsd: string
-    createdAt: string
-    chainId: number
-    nonce: number
+type Vault = {
+	vaultName: string;
+	vaultAddress: string;
+	apy: number;
+	tvr: number;
+	protocols: string[];
+	depositToken: DepositToken;
+	type: VaultType;
+	rewards: VaultReward[];
+	rewardType: RewardType;
+	liveUntil: string;
+	liveFrom: string;
+	liveUntilFormatted: string;
+	hasPoolEnded: boolean;
+	boosters: NFTBoost[];
+	strategies: Strategy[];
+	tgePrice?: number;
+	maxAmountOfTokens?: number;
+	project: DeployedProject;
+	projectId: number;
+	coingeckoId?: string;
+	depositTokenId: string;
+	expectedTge?: string;
+	tokenPrice: number;
+	change24h: number;
+	volume24h: number;
+	projectFeatured: boolean;
+	avgTvl: string;
+	peakTvl: string;
+	amountOfDepositors: number;
+	boostedTvl: number;
+	projectVAPY?: number;
 };
 
-export type BeansBalance = {
-    balance: string
-    bonusesClaimed: string[]
+type VaultReward = {
+	id: number | undefined;
+	type: RewardType;
+	name: string;
+	symbol: string;
+	decimals: number;
+	tokenAddress: string;
+	monthlyEmissionRate: number;
+	blockNumber: number;
+	rewardRate: number;
+	timestamp: number;
+	endTime: number;
 };
 
-enum Chain {
-  MAINNET = 'mainnet',
-  SEPOLIA = 'sepolia'
-}
+type VaultStats = {
+	totalTVL: number;
+	totalUsers: number;
+	activeVaults: number;
+};
 
-enum ELoyaltyCardTier {
-    White = 'White',
-    Ivory = 'Ivory',  
-    Dune = 'Dune',  
-    Amber = 'Amber',  
-    Sienna = 'Sienna', 
-    Umber = 'Umber',  
-    Black = 'Black'
-}
+type VaultType = 'launch' | 'earn' | 'airdrop';
 
-export type MyPerqData = { 
-    [key: string]: {
-      vaultAddress: string,
-      projectName: string,
-      projectType: string,
-      projectFeatured: boolean,
-      liveUntil: string,
-      coingeckoId?: string,
-      depositTokenId: 'WETH' | 'USDC' | 'DAI',
-      type: 'earn' | 'launch' | 'airdrop',
-      rewardType: 'points' | 'token' | 'pnode shards',
-      amountOfTokens?: number
-      vaultName: string,
-      protocols: string[],
-      apy: number,
-      tvr: number,
-      tokenPrice: number,
-      change24h: number,
-      volume24h: number,
-      rewards: CacheVaultRewards[]
-      strategies: Strategy[],
-      boosters: NFTBoost[],
-      depositToken: DepositToken
-      avgTvl: string
-      peakTvl: string
-		  pendingDeposits: number;
-		  currentlyDeposited: number;
-		  pendingWithdraws: number;
-		  claimable: number;
-		  ethPrice: number;
-      tokenRewards: {[token_address: string]: Asset & { amount: number, rewardsPerHour: number }};
-	}
+type VestingInfo = {
+	startTimestamp: string;
+	endTimestamp: string;
+	vested: string;
+	releasable: string;
+	releasableTotal: string;
 };
+
+type YelayVersion = 'v2' | 'lite';
 ```
 
 # Abis
 
- - DRIP_SWAP_AND_RECYCLER_ABI
-
- - WETH_TOKEN_ABI
-
- - DRIP_TOKEN_ABI
+- DRIP_SWAP_AND_RECYCLER_ABI
 
- - TOKEN_RECYCLER_ABI
+- WETH_TOKEN_ABI
 
- - PERQ_VESTING_ABI
+- DRIP_TOKEN_ABI
 
+- TOKEN_RECYCLER_ABI
 
+- PERQ_VESTING_ABI