@lagoon-protocol/lagoon-mcp 0.1.0

package/dist/sdk/simulation-service.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Vault Simulation Service
+ *
+ * Provides vault simulation functionality using Lagoon SDK's simulate() function.
+ * Production patterns from frontend-dapp-v2.
+ *
+ * @module simulation-service
+ */
+import type { SimulationInput, SimulationResult, VersionOrLatest } from '@lagoon-protocol/v0-computation';
+import type { VaultData } from '../graphql/fragments/index.js';
+import type { APRHistoricalData } from './apr-service.js';
+/**
+ * Map vault data to SDK simulation format
+ *
+ * Transforms VaultData from GraphQL into the format expected by the SDK's simulate() function.
+ * Handles decimal offset calculations and fee rate conversions.
+ *
+ * @param vault - Vault data from GraphQL
+ * @param newTotalAssets - Proposed total assets for simulation (in wei)
+ * @returns Vault object in SDK format
+ *
+ * @example
+ * ```typescript
+ * const vaultForSimulation = mapVaultToSimulationFormat(vault, BigInt('1000000000000'));
+ * // Returns: { decimals, underlyingDecimals, newTotalAssets, totalSupply, ... }
+ * ```
+ */
+export declare function mapVaultToSimulationFormat(vault: VaultData, newTotalAssets: bigint): {
+    decimals: number;
+    underlyingDecimals: number;
+    newTotalAssets: bigint;
+    totalSupply: bigint;
+    totalAssets: bigint;
+    highWaterMark: bigint;
+    lastFeeTime: bigint;
+    feeRates: {
+        managementRate: number;
+        performanceRate: number;
+    };
+    version: VersionOrLatest;
+};
+/**
+ * Construct simulation input from vault state and parameters
+ *
+ * Builds the complete input object required by SDK's simulate() function,
+ * including pending balances, settlement data, and optional APR historical data.
+ *
+ * @param vault - Vault data from GraphQL
+ * @param newTotalAssets - Proposed total assets for simulation (in wei)
+ * @param aprData - Optional APR historical data for yield calculations
+ * @param settleDeposit - Whether to settle pending deposits (default: true)
+ * @returns Complete simulation input object
+ *
+ * @example
+ * ```typescript
+ * const input = constructSimulationInput(
+ *   vault,
+ *   BigInt('5000000000'),
+ *   aprData,
+ *   true
+ * );
+ * ```
+ */
+export declare function constructSimulationInput(vault: VaultData, newTotalAssets: bigint, aprData?: APRHistoricalData, settleDeposit?: boolean): SimulationInput;
+/**
+ * Simulate vault management with new total assets
+ *
+ * Main simulation function that orchestrates the complete simulation workflow:
+ * 1. Validates input parameters
+ * 2. Maps vault data to SDK format
+ * 3. Constructs simulation input
+ * 4. Executes SDK simulation
+ * 5. Returns detailed simulation results
+ *
+ * This function uses the Lagoon SDK's simulate() function which performs
+ * protocol-accurate calculations for:
+ * - Fee accruals (management and performance)
+ * - Share price changes
+ * - Settlement requirements
+ * - APR calculations (when historical data provided)
+ *
+ * @param vault - Vault data from GraphQL (required)
+ * @param newTotalAssets - Proposed total assets after deposit/withdrawal (required, must be > 0)
+ * @param aprData - Optional APR historical data for yield projections
+ * @param settleDeposit - Whether to settle pending deposits (default: true)
+ * @returns Detailed simulation results from SDK
+ * @throws {Error} If vault data is missing
+ * @throws {Error} If newTotalAssets is <= 0
+ * @throws {Error} If SDK simulation fails
+ *
+ * @example
+ * ```typescript
+ * // Simulate a deposit
+ * const result = await simulateVaultManagement(
+ *   vault,
+ *   BigInt('2000000000000'), // +1000 tokens
+ *   aprData,
+ *   true
+ * );
+ *
+ * console.log(result.totalSupply); // New share supply
+ * console.log(result.feesAccrued); // Fees charged
+ * ```
+ */
+export declare function simulateVaultManagement(vault: VaultData, newTotalAssets: bigint, aprData?: APRHistoricalData, settleDeposit?: boolean): SimulationResult;
+//# sourceMappingURL=simulation-service.d.ts.map

package/dist/sdk/simulation-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-service.d.ts","sourceRoot":"","sources":["../../src/sdk/simulation-service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,eAAe,EAChB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,cAAc,EAAE,MAAM,GACrB;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE;QACR,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,OAAO,EAAE,eAAe,CAAC;CAC1B,CAkBA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,iBAAiB,EAC3B,aAAa,GAAE,OAAc,GAC5B,eAAe,CAgBjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,iBAAiB,EAC3B,aAAa,GAAE,OAAc,GAC5B,gBAAgB,CAwBlB"}

package/dist/sdk/simulation-service.js

@@ -0,0 +1,143 @@
+/**
+ * Vault Simulation Service
+ *
+ * Provides vault simulation functionality using Lagoon SDK's simulate() function.
+ * Production patterns from frontend-dapp-v2.
+ *
+ * @module simulation-service
+ */
+import { simulate } from '@lagoon-protocol/v0-computation';
+/**
+ * Map vault data to SDK simulation format
+ *
+ * Transforms VaultData from GraphQL into the format expected by the SDK's simulate() function.
+ * Handles decimal offset calculations and fee rate conversions.
+ *
+ * @param vault - Vault data from GraphQL
+ * @param newTotalAssets - Proposed total assets for simulation (in wei)
+ * @returns Vault object in SDK format
+ *
+ * @example
+ * ```typescript
+ * const vaultForSimulation = mapVaultToSimulationFormat(vault, BigInt('1000000000000'));
+ * // Returns: { decimals, underlyingDecimals, newTotalAssets, totalSupply, ... }
+ * ```
+ */
+export function mapVaultToSimulationFormat(vault, newTotalAssets) {
+    const vaultDecimals = Number(vault.decimals ?? 18);
+    const assetDecimals = Number(vault.asset.decimals);
+    return {
+        decimals: vaultDecimals,
+        underlyingDecimals: assetDecimals,
+        newTotalAssets,
+        totalSupply: BigInt(vault.state.totalSupply),
+        totalAssets: BigInt(vault.state.totalAssets),
+        highWaterMark: BigInt(vault.state.highWaterMark),
+        lastFeeTime: BigInt(vault.state.lastFeeTime),
+        feeRates: {
+            managementRate: Number(vault.state.managementFee),
+            performanceRate: Number(vault.state.performanceFee),
+        },
+        version: vault.state.version || 'latest',
+    };
+}
+/**
+ * Construct simulation input from vault state and parameters
+ *
+ * Builds the complete input object required by SDK's simulate() function,
+ * including pending balances, settlement data, and optional APR historical data.
+ *
+ * @param vault - Vault data from GraphQL
+ * @param newTotalAssets - Proposed total assets for simulation (in wei)
+ * @param aprData - Optional APR historical data for yield calculations
+ * @param settleDeposit - Whether to settle pending deposits (default: true)
+ * @returns Complete simulation input object
+ *
+ * @example
+ * ```typescript
+ * const input = constructSimulationInput(
+ *   vault,
+ *   BigInt('5000000000'),
+ *   aprData,
+ *   true
+ * );
+ * ```
+ */
+export function constructSimulationInput(vault, newTotalAssets, aprData, settleDeposit = true) {
+    return {
+        totalAssetsForSimulation: newTotalAssets,
+        assetsInSafe: BigInt(vault.state.safeAssetBalance ?? '0'),
+        pendingSiloBalances: {
+            assets: BigInt(vault.state.pendingSiloBalances?.assets ?? '0'),
+            shares: BigInt(vault.state.pendingSiloBalances?.shares ?? '0'),
+        },
+        pendingSettlement: {
+            assets: BigInt(vault.state.pendingSettlement?.assets ?? '0'),
+            shares: BigInt(vault.state.pendingSettlement?.shares ?? '0'),
+        },
+        settleDeposit,
+        inception: aprData?.inception,
+        thirtyDay: aprData?.thirtyDay,
+    };
+}
+/**
+ * Simulate vault management with new total assets
+ *
+ * Main simulation function that orchestrates the complete simulation workflow:
+ * 1. Validates input parameters
+ * 2. Maps vault data to SDK format
+ * 3. Constructs simulation input
+ * 4. Executes SDK simulation
+ * 5. Returns detailed simulation results
+ *
+ * This function uses the Lagoon SDK's simulate() function which performs
+ * protocol-accurate calculations for:
+ * - Fee accruals (management and performance)
+ * - Share price changes
+ * - Settlement requirements
+ * - APR calculations (when historical data provided)
+ *
+ * @param vault - Vault data from GraphQL (required)
+ * @param newTotalAssets - Proposed total assets after deposit/withdrawal (required, must be > 0)
+ * @param aprData - Optional APR historical data for yield projections
+ * @param settleDeposit - Whether to settle pending deposits (default: true)
+ * @returns Detailed simulation results from SDK
+ * @throws {Error} If vault data is missing
+ * @throws {Error} If newTotalAssets is <= 0
+ * @throws {Error} If SDK simulation fails
+ *
+ * @example
+ * ```typescript
+ * // Simulate a deposit
+ * const result = await simulateVaultManagement(
+ *   vault,
+ *   BigInt('2000000000000'), // +1000 tokens
+ *   aprData,
+ *   true
+ * );
+ *
+ * console.log(result.totalSupply); // New share supply
+ * console.log(result.feesAccrued); // Fees charged
+ * ```
+ */
+export function simulateVaultManagement(vault, newTotalAssets, aprData, settleDeposit = true) {
+    // Validation
+    if (!vault) {
+        throw new Error('Vault data is required for simulation');
+    }
+    if (newTotalAssets <= 0n) {
+        throw new Error('New total assets must be positive');
+    }
+    // Map vault to SDK format
+    const vaultForSimulation = mapVaultToSimulationFormat(vault, newTotalAssets);
+    // Construct simulation input
+    const simulationInput = constructSimulationInput(vault, newTotalAssets, aprData, settleDeposit);
+    // Execute simulation
+    try {
+        return simulate(vaultForSimulation, simulationInput);
+    }
+    catch (error) {
+        throw new Error(`Simulation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+//# sourceMappingURL=simulation-service.js.map

package/dist/sdk/simulation-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-service.js","sourceRoot":"","sources":["../../src/sdk/simulation-service.ts"],"names":[],"mappings":"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"}

package/dist/sdk/vault-utils.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Vault Utilities
+ *
+ * Internal wrapper utilities for Lagoon SDK VaultUtils.
+ * Production-validated patterns from frontend-dapp-v2 for share/asset conversions.
+ *
+ * @module sdk/vault-utils
+ */
+/**
+ * Vault state for conversions
+ */
+export interface VaultState {
+    totalAssets: bigint;
+    totalSupply: bigint;
+    decimalsOffset: bigint;
+}
+/**
+ * Calculate price per share
+ *
+ * Internal utility for computing current vault share price.
+ * Used by simulation and performance tools internally.
+ *
+ * Production pattern from pricePerShareCalculations.ts - handles edge cases:
+ * - Zero total supply (returns 1:1 ratio)
+ * - Decimal offset mismatches
+ * - Rounding modes for safety
+ *
+ * @param totalAssets - Total assets under management (in asset decimals)
+ * @param totalSupply - Total shares outstanding (in vault decimals)
+ * @param vaultDecimals - Vault token decimals (typically 18)
+ * @param assetDecimals - Underlying asset decimals (e.g., 6 for USDC)
+ * @returns Price per share in asset decimals (1 share = X assets)
+ *
+ * @example
+ * ```typescript
+ * // Vault with 1000 USDC (6 decimals) and 950 shares (18 decimals)
+ * const pricePerShare = calculatePricePerShare(
+ *   1000000000n,  // 1000 USDC in 6 decimals
+ *   950000000000000000000n,  // 950 shares in 18 decimals
+ *   18,
+ *   6
+ * );
+ * // => ~1052631n (1.052631 USDC per share)
+ * ```
+ */
+export declare function calculatePricePerShare(totalAssets: bigint, totalSupply: bigint, vaultDecimals: number, assetDecimals: number): bigint;
+/**
+ * Convert shares to assets
+ *
+ * Internal utility for calculating asset amount from shares.
+ * Uses SDK's VaultUtils.convertToAssets with proper rounding.
+ *
+ * @param shares - Share amount to convert (in vault decimals)
+ * @param totalAssets - Current total assets (in asset decimals)
+ * @param totalSupply - Current total supply (in vault decimals)
+ * @param decimalsOffset - Vault decimals - asset decimals
+ * @param roundingMode - Rounding direction ('Up' for user favorable, 'Down' for protocol favorable)
+ * @returns Asset amount (in asset decimals)
+ *
+ * @example
+ * ```typescript
+ * // Convert 10 shares to USDC
+ * const assets = convertSharesToAssets(
+ *   10000000000000000000n,  // 10 shares (18 decimals)
+ *   1000000000n,            // 1000 USDC total (6 decimals)
+ *   950000000000000000000n, // 950 shares total (18 decimals)
+ *   12,                     // 18 - 6 = 12
+ *   'Down'                  // Conservative for withdrawals
+ * );
+ * // => ~10526315n (~10.526315 USDC)
+ * ```
+ */
+export declare function convertSharesToAssets(shares: bigint, totalAssets: bigint, totalSupply: bigint, decimalsOffset: number, roundingMode?: 'Up' | 'Down'): bigint;
+/**
+ * Convert assets to shares
+ *
+ * Internal utility for calculating share amount from assets.
+ * Uses SDK's VaultUtils.convertToShares with proper rounding.
+ *
+ * @param assets - Asset amount to convert (in asset decimals)
+ * @param totalAssets - Current total assets (in asset decimals)
+ * @param totalSupply - Current total supply (in vault decimals)
+ * @param decimalsOffset - Vault decimals - asset decimals
+ * @param roundingMode - Rounding direction ('Up' for protocol favorable, 'Down' for user favorable)
+ * @returns Share amount (in vault decimals)
+ *
+ * @example
+ * ```typescript
+ * // Convert 100 USDC to shares
+ * const shares = convertAssetsToShares(
+ *   100000000n,             // 100 USDC (6 decimals)
+ *   1000000000n,            // 1000 USDC total (6 decimals)
+ *   950000000000000000000n, // 950 shares total (18 decimals)
+ *   12,                     // 18 - 6 = 12
+ *   'Up'                    // Conservative for deposits
+ * );
+ * // => ~95000000000000000000n (~95 shares)
+ * ```
+ */
+export declare function convertAssetsToShares(assets: bigint, totalAssets: bigint, totalSupply: bigint, decimalsOffset: number, roundingMode?: 'Up' | 'Down'): bigint;
+/**
+ * Build vault state object
+ *
+ * Convenience helper to construct VaultState from raw values.
+ * Validates inputs and handles type conversions.
+ *
+ * @param totalAssets - Total assets (can be bigint or string)
+ * @param totalSupply - Total supply (can be bigint or string)
+ * @param vaultDecimals - Vault decimals
+ * @param assetDecimals - Asset decimals
+ * @returns Validated vault state object
+ *
+ * @example
+ * ```typescript
+ * const state = buildVaultState(
+ *   "1000000000",
+ *   "950000000000000000000",
+ *   18,
+ *   6
+ * );
+ * // => { totalAssets: 1000000000n, totalSupply: 950...n, decimalsOffset: 12n }
+ * ```
+ */
+export declare function buildVaultState(totalAssets: bigint | string, totalSupply: bigint | string, vaultDecimals: number, assetDecimals: number): VaultState;
+//# sourceMappingURL=vault-utils.d.ts.map

package/dist/sdk/vault-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-utils.d.ts","sourceRoot":"","sources":["../../src/sdk/vault-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,MAAM,CAyBR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,YAAY,GAAE,IAAI,GAAG,MAAe,GACnC,MAAM,CAUR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,YAAY,GAAE,IAAI,GAAG,MAAa,GACjC,MAAM,CAUR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,UAAU,CAmBZ"}

package/dist/sdk/vault-utils.js

@@ -0,0 +1,165 @@
+/**
+ * Vault Utilities
+ *
+ * Internal wrapper utilities for Lagoon SDK VaultUtils.
+ * Production-validated patterns from frontend-dapp-v2 for share/asset conversions.
+ *
+ * @module sdk/vault-utils
+ */
+import * as LagoonCore from '@lagoon-protocol/v0-core';
+/**
+ * Calculate price per share
+ *
+ * Internal utility for computing current vault share price.
+ * Used by simulation and performance tools internally.
+ *
+ * Production pattern from pricePerShareCalculations.ts - handles edge cases:
+ * - Zero total supply (returns 1:1 ratio)
+ * - Decimal offset mismatches
+ * - Rounding modes for safety
+ *
+ * @param totalAssets - Total assets under management (in asset decimals)
+ * @param totalSupply - Total shares outstanding (in vault decimals)
+ * @param vaultDecimals - Vault token decimals (typically 18)
+ * @param assetDecimals - Underlying asset decimals (e.g., 6 for USDC)
+ * @returns Price per share in asset decimals (1 share = X assets)
+ *
+ * @example
+ * ```typescript
+ * // Vault with 1000 USDC (6 decimals) and 950 shares (18 decimals)
+ * const pricePerShare = calculatePricePerShare(
+ *   1000000000n,  // 1000 USDC in 6 decimals
+ *   950000000000000000000n,  // 950 shares in 18 decimals
+ *   18,
+ *   6
+ * );
+ * // => ~1052631n (1.052631 USDC per share)
+ * ```
+ */
+export function calculatePricePerShare(totalAssets, totalSupply, vaultDecimals, assetDecimals) {
+    // Validate inputs
+    if (vaultDecimals < 0 || assetDecimals < 0) {
+        throw new Error('Decimals must be non-negative');
+    }
+    const decimalsOffset = vaultDecimals - assetDecimals;
+    try {
+        // Calculate price for 1 share (1e18 in wei)
+        return LagoonCore.VaultUtils.convertToAssets(BigInt(1e18), // 1 share in wei (18 decimals)
+        {
+            totalAssets,
+            totalSupply,
+            decimalsOffset: BigInt(decimalsOffset),
+        }, 'Down' // Round down for safety (conservative pricing)
+        );
+    }
+    catch (error) {
+        // Graceful fallback: 1:1 ratio if calculation fails
+        // This happens for new vaults with zero supply
+        console.warn('Price per share calculation failed, using 1:1 ratio:', error);
+        return BigInt(10 ** assetDecimals);
+    }
+}
+/**
+ * Convert shares to assets
+ *
+ * Internal utility for calculating asset amount from shares.
+ * Uses SDK's VaultUtils.convertToAssets with proper rounding.
+ *
+ * @param shares - Share amount to convert (in vault decimals)
+ * @param totalAssets - Current total assets (in asset decimals)
+ * @param totalSupply - Current total supply (in vault decimals)
+ * @param decimalsOffset - Vault decimals - asset decimals
+ * @param roundingMode - Rounding direction ('Up' for user favorable, 'Down' for protocol favorable)
+ * @returns Asset amount (in asset decimals)
+ *
+ * @example
+ * ```typescript
+ * // Convert 10 shares to USDC
+ * const assets = convertSharesToAssets(
+ *   10000000000000000000n,  // 10 shares (18 decimals)
+ *   1000000000n,            // 1000 USDC total (6 decimals)
+ *   950000000000000000000n, // 950 shares total (18 decimals)
+ *   12,                     // 18 - 6 = 12
+ *   'Down'                  // Conservative for withdrawals
+ * );
+ * // => ~10526315n (~10.526315 USDC)
+ * ```
+ */
+export function convertSharesToAssets(shares, totalAssets, totalSupply, decimalsOffset, roundingMode = 'Down') {
+    if (shares < 0n || totalAssets < 0n || totalSupply < 0n) {
+        throw new Error('Values must be non-negative');
+    }
+    return LagoonCore.VaultUtils.convertToAssets(shares, { totalAssets, totalSupply, decimalsOffset: BigInt(decimalsOffset) }, roundingMode);
+}
+/**
+ * Convert assets to shares
+ *
+ * Internal utility for calculating share amount from assets.
+ * Uses SDK's VaultUtils.convertToShares with proper rounding.
+ *
+ * @param assets - Asset amount to convert (in asset decimals)
+ * @param totalAssets - Current total assets (in asset decimals)
+ * @param totalSupply - Current total supply (in vault decimals)
+ * @param decimalsOffset - Vault decimals - asset decimals
+ * @param roundingMode - Rounding direction ('Up' for protocol favorable, 'Down' for user favorable)
+ * @returns Share amount (in vault decimals)
+ *
+ * @example
+ * ```typescript
+ * // Convert 100 USDC to shares
+ * const shares = convertAssetsToShares(
+ *   100000000n,             // 100 USDC (6 decimals)
+ *   1000000000n,            // 1000 USDC total (6 decimals)
+ *   950000000000000000000n, // 950 shares total (18 decimals)
+ *   12,                     // 18 - 6 = 12
+ *   'Up'                    // Conservative for deposits
+ * );
+ * // => ~95000000000000000000n (~95 shares)
+ * ```
+ */
+export function convertAssetsToShares(assets, totalAssets, totalSupply, decimalsOffset, roundingMode = 'Up') {
+    if (assets < 0n || totalAssets < 0n || totalSupply < 0n) {
+        throw new Error('Values must be non-negative');
+    }
+    return LagoonCore.VaultUtils.convertToShares(assets, { totalAssets, totalSupply, decimalsOffset: BigInt(decimalsOffset) }, roundingMode);
+}
+/**
+ * Build vault state object
+ *
+ * Convenience helper to construct VaultState from raw values.
+ * Validates inputs and handles type conversions.
+ *
+ * @param totalAssets - Total assets (can be bigint or string)
+ * @param totalSupply - Total supply (can be bigint or string)
+ * @param vaultDecimals - Vault decimals
+ * @param assetDecimals - Asset decimals
+ * @returns Validated vault state object
+ *
+ * @example
+ * ```typescript
+ * const state = buildVaultState(
+ *   "1000000000",
+ *   "950000000000000000000",
+ *   18,
+ *   6
+ * );
+ * // => { totalAssets: 1000000000n, totalSupply: 950...n, decimalsOffset: 12n }
+ * ```
+ */
+export function buildVaultState(totalAssets, totalSupply, vaultDecimals, assetDecimals) {
+    const assets = typeof totalAssets === 'string' ? BigInt(totalAssets) : totalAssets;
+    const supply = typeof totalSupply === 'string' ? BigInt(totalSupply) : totalSupply;
+    if (assets < 0n || supply < 0n) {
+        throw new Error('Vault state values must be non-negative');
+    }
+    if (vaultDecimals < 0 || assetDecimals < 0) {
+        throw new Error('Decimals must be non-negative');
+    }
+    const decimalsOffset = BigInt(vaultDecimals - assetDecimals);
+    return {
+        totalAssets: assets,
+        totalSupply: supply,
+        decimalsOffset,
+    };
+}
+//# sourceMappingURL=vault-utils.js.map

package/dist/sdk/vault-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-utils.js","sourceRoot":"","sources":["../../src/sdk/vault-utils.ts"],"names":[],"mappings":"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"}

package/dist/server.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Lagoon MCP Server
+ *
+ * Modern implementation using McpServer API for:
+ * - Automatic capability management
+ * - Clean tool/resource/prompt registration
+ * - Future-proof architecture
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create and configure the MCP server instance
+ *
+ * Uses modern McpServer API for automatic capability management
+ * and clean registration patterns.
+ */
+export declare function createServer(): McpServer;
+/**
+ * Run the MCP server
+ */
+export declare function runServer(): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAyBpE;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,SAAS,CA2NxC;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CA8B/C"}