@dripfi/drip-sdk v1.2.2

Drip SDK

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.

Table of Contents

• Installation
• Usage
• Methods
• Examples
• Types

Installation

To use the Drip SDK in your project, you can install it via npm or yarn:

npm i @dripfi/drip-sdk

Usage

import DripSdk from '@drip/sdk'
import { DripConfig, Chain } from '@dripfi/drip-sdk'

Initialize the SDK with your Drip configuration and an optional signer:

const chain: Chain = Chain.MAINNET // if targeting ethereum mainnet

const chain: Chain = Chain.SEPOLIA // if targeting sepolia testnet

const signer: ethers.Signer = /* your Signer instance */;

const dripSdk = new DripSdk(chain, signer);

Methods

!IMPORTANT You must authenticate once for every wallet you want to use

Examples

deposit(tokenAddress: string, vaultAddress: string, amount: string): Promise<string>

I want to deposit 100 USDC in a USDC vault:

USDC_TOKEN_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"    --> USDC contract address in tenderly environment

you can get vault token address from the vault.depositToken.tokenAddress

VAULT_ADDRESS = "0x...c167" --> Check vaults returned by getAllVaults() and get vault address like: vault.vaultAddress

const txHash = await deposit(USDC_TOKEN_ADDRESS, VAULT_ADDRESS, '100')

!NOTE User will be prompted with 2 tx: 1st to approve token usage 2nd to deposit the funds in the vault

!NOTE Allowance is calculated by the deposit method, based on the current allowance and the required

!IMPORTANT Amount should be formatted, not parsed. In the example we want to deposit 100 USDC so we just input that value instead of adding 6 decimals (100000000)

swapAndDeposit(fromTokenAddress: string, toTokenAddress: string, fromTokenAmount: string, vaultAddress: string, ethAmount?: string): Promise<string>

I want to deposit 1.5ETH in a WETH vault:

WETH_TOKEN_ADDRESS = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"    --> WETH contract address in tenderly environment

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 ethAmount and fromTokenAmount should be formatted, not parsed. In the example we want to deposit 1.5 WETH so we just input that value instead of adding 18 decimals (1500000000000000000)

withdraw(vault: Vault, amountToWithdraw?: string): Promise<string>

 const userBalanceObject = await getUserBalance()
 const balance = userBalanceObject.userbalance

!NOTE If i check balance, that is the max amount I can withdraw

I want to withdraw 100 USDC from the 1st vault fetched. ---> Let's assume the first vault is a USDC vault for simplicity Fetch vaults returned by getAllVault() and pass the vault you want to withdraw from, and the amount to withdraw (100 in this example)

const vaults = await getAllVaults()
const vaultToWithdrawFrom = vaults[0]

const txHash = await withdraw(vaultToWithdrawFrom, '100')

if you want to withdraw all funds in the vault, don't specify the amountToWithdraw:

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>

 const userBalanceObject = await getUserBalance()
 const hasWithdrawsToClaim = userBalanceObject.hasWithdrawsToClaim

if hasWithdrawsToClaim is true you have available funds to transfer to your address

 const txHash = await claimWithdraws()

It will transfer all available funds withdrawn with withdraw() function, to your address

fastWithdraw(vault: Vault, amountToWithdraw?: string): Promise<string>

 const userBalanceObject = await getUserBalance()
 const balance = userBalanceObject.userbalance

!NOTE If i check balance, that is the max amount I can withdraw

I want to withdraw 3.55 WETH from the 1st vault fetched. ---> Let's assume the first vault is a WETH vault for simplicity Fetch vaults returned by getAllVault() and pass the vault you want to withdraw from, and the amount to withdraw (3.55 in this example)

const vaults = await getAllVaults()
const vaultToWithdrawFrom = vaults[0]

const txHash = await fastWithdraw(vaultToWithdrawFrom, '3.55')

if you want to withdraw all funds in the vault, don't specify the amountToWithdraw, like:

const txHash = await fastWithdraw(vaultToWithdrawFrom)

Types

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,
};

type VaultType = 'launch' | 'earn' | 'airdrop'

type VaultDepositToken = {
  name: string
  symbol: string
  roundingDecimals: number
  precisionDecimals: number
  tokenAddress: string
}

type VaultReward = {
  type: 'token' | 'points';
  name: string;
  symbol: string;
  decimals: number;
  tokenAddress: string;
  monthlyEmissionRate: number;
  blockNumber: number;
  rewardRate: number;
  timestamp: number;
  endTime: number;
};

type NFTBoost = {
  url: string
  tokenAddress: string
  multiplier: number
  nftAddress: string
  network: string
  initialBlock: number
  imagePath: string
}

interface StretchGoal {
  threshhold: number
  threshholdDescription: string
  rewardTooltip: string
  rewardDescription: string
  amountOfTokens: number
}

type Strategy = {
  address: string
  lastDoHardWorkTime: number | null
  lastDoHardWorkBlock: number | null
}

type AuthenticationStatus = {
  isAuthenticated: boolean
  address?: string
  token?: string
  message?: string
}

interface QLFastRedeem {
  assetsWithdrawn: {
    asset: {
      decimals: number
      id: string
      name: string
      symbol: string
    }
    claimed: string
    id: string
  }[]
  blockNumber: number
  id: string
  svtWithdrawn: string
}

type SwapInfo = {
  swapTarget: any
  token: string
  swapCallData: any
}

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 UserVaultBalance = {
  hasWithdrawsToClaim: boolean
  userBalance: string
  pendingUserBalance: string
  pendingWithdrawalBalance: string
  withdrawableBalance: string
};


type UserRewards = {
   [vaultAddress: string]: { [rewardPointsName: string]: number } 
};

type VaultStats = {
    totalTVL: number
    totalUsers: number
    activeVaults: number
  };