Lagoon SDKs

The Lagoon SDKs are a collection of TypeScript libraries designed to simplify interactions with Lagoon Vaults. They offer modular, framework-agnostic core functionality that makes it easy to integrate Vault operations into any application.

Their architecture is inspired by Morpho’s SDK design principles, combining clean abstractions with specialized modules for popular web3 libraries to streamline development workflows

Overview

The SDK consists of two main packages:

  • @lagoon-protocol/v0-core - Framework-agnostic vault entities and utilities

  • @lagoon-protocol/v0-viem - Viem-based extensions for seamless blockchain interactions

This library will evolve in the near future. We are actively listening to emerging integration needs and are open to discussions around external contributions.

Features

The SDKs have a modular architecture that cleanly separates core logic from blockchain interaction layers, enabling seamless integration across diverse environments, from frontend applications to backend services.

The core package provides:

  • Vault class for vault state management

  • Token class for ERC20 token handling

  • VaultUtils for common calculations

  • Chain addresses and configuration constants

The Viem integration package provides:

  • Blockchain data fetching capabilities

  • Seamless integration with Viem clients

Quick Start

Installation

Choose the package that fits your needs:

# For Viem integration (recommanded)
npm install @lagoon-protocol/v0-viem

# For framework-agnostic usage
npm install @lagoon-protocol/v0-core

Example: Calculate Vault APR

import { Vault } from "@lagoon-protocol/v0-viem";
import { VaultUtils } from "@lagoon-protocol/v0-core";
import { Address, createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

async function fetchVault(address: Address, blockNumber: bigint) {
  const vault = await Vault.fetch(address, client, { blockNumber });
  if (!vault) {
    throw new Error("Vault not found")
  }
  return vault
}

async function calculateVaultAPR({
  vaultAddress,
  startBlockNumber,
  endBlockNumber,
}: { vaultAddress: Address, startBlockNumber: bigint, endBlockNumber: bigint }) {
  const startBlock = await client.getBlock({ blockNumber: startBlockNumber });
  const endBlock = await client.getBlock({ blockNumber: endBlockNumber });

  const vaultStart = await fetchVault(vaultAddress, startBlock.number);
  const vaultEnd = await fetchVault(vaultAddress, endBlock.number);

  const basePrice = vaultStart.convertToAssets(VaultUtils.ONE_SHARE);
  const currentPrice = vaultEnd.convertToAssets(VaultUtils.ONE_SHARE);

  const periodSeconds = endBlock.timestamp - startBlock.timestamp;

  const SECONDS_PER_YEAR = 365n * 24n * 60n * 60n;
  const BASIS_POINTS = 10_000n;

  const periodYield = ((currentPrice - basePrice) * BASIS_POINTS) / basePrice;
  return (periodYield * SECONDS_PER_YEAR) / periodSeconds;
}

const block = await client.getBlock({ blockTag: 'latest' })
const vaultApr = await calculateVaultAPR({ vaultAddress: '0x...', startBlockNumber: 21137095n, endBlockNumber: block.number })

console.log(`vault APR: ${Number(vaultApr) / 100}%`);

Resources

PreviousKey Data Structures and Epoch mechanismNextIntegration

Last updated