@mento-protocol/mento-sdk 3.2.2-beta1 → 3.2.3

package/dist/esm/utils/tradingLimits.js

@@ -1,163 +0,0 @@
-import { pad, hexToBigInt, numberToHex } from 'viem';
-/** V2 trading limits use 15 decimals internally */
-const V2_INTERNAL_DECIMALS = 15;
-/** V2 L0 window is fixed at 5 minutes */
-const V2_L0_TIMESTEP = 5 * 60; // 300 seconds
-/** V2 L1 window is fixed at 1 day */
-const V2_L1_TIMESTEP = 24 * 60 * 60; // 86400 seconds
-/** Far future timestamp for global limits (year 2030) */
-const TIMESTAMP_FAR_FUTURE = 1893456000;
-/**
- * Compute limit ID for Broker (V1) trading limits.
- * limitId = exchangeId XOR bytes32(uint256(uint160(token)))
- *
- * @param exchangeId - The exchange ID (bytes32)
- * @param token - The token address
- * @returns The limit ID as hex string
- */
-export function computeLimitId(exchangeId, token) {
-    // Pad token address to 32 bytes (left-padded with zeros)
-    const tokenBytes32 = pad(token, { size: 32 });
-    // Convert both to BigInt for XOR operation
-    const exchangeIdBigInt = hexToBigInt(exchangeId);
-    const tokenBigInt = hexToBigInt(tokenBytes32);
-    // XOR operation
-    const limitIdBigInt = exchangeIdBigInt ^ tokenBigInt;
-    // Convert back to hex with proper padding
-    return pad(numberToHex(limitIdBigInt), { size: 32 });
-}
-/**
- * Calculate trading limits from V1 config and state (Broker/Virtual pools).
- * Returns human-friendly TradingLimit objects with maxIn/maxOut/until.
- *
- * @param config - V1 trading limits configuration
- * @param state - V1 trading limits state
- * @param asset - Token address
- * @param tokenDecimals - Token decimals for consumer reference
- * @returns Array of TradingLimit objects
- */
-export function calculateTradingLimitsV1(config, state, asset, tokenDecimals) {
-    const nowEpoch = Math.floor(Date.now() / 1000);
-    const limits = [];
-    // Check if L0 is enabled (bit 0 of flags)
-    const isL0Enabled = (config.flags & 0x01) !== 0;
-    // Check if L1 is enabled (bit 1 of flags)
-    const isL1Enabled = (config.flags & 0x02) !== 0;
-    // Check if LG is enabled (bit 2 of flags)
-    const isLGEnabled = (config.flags & 0x04) !== 0;
-    // Reset netflows if time windows have passed
-    const isL0Outdated = isL0Enabled && nowEpoch > state.lastUpdated0 + config.timestep0;
-    const isL1Outdated = isL1Enabled && nowEpoch > state.lastUpdated1 + config.timestep1;
-    const effectiveNetflow0 = isL0Outdated ? 0n : state.netflow0;
-    const effectiveNetflow1 = isL1Outdated ? 0n : state.netflow1;
-    const effectiveLastUpdated0 = isL0Outdated ? nowEpoch : state.lastUpdated0;
-    const effectiveLastUpdated1 = isL1Outdated ? nowEpoch : state.lastUpdated1;
-    // Add L0 limit if configured
-    if (isL0Enabled && config.limit0 > 0n) {
-        limits.push({
-            asset,
-            maxIn: config.limit0 - effectiveNetflow0,
-            maxOut: config.limit0 + effectiveNetflow0,
-            until: effectiveLastUpdated0 + config.timestep0,
-            decimals: tokenDecimals,
-        });
-    }
-    // Add L1 limit if configured
-    if (isL1Enabled && config.limit1 > 0n) {
-        limits.push({
-            asset,
-            maxIn: config.limit1 - effectiveNetflow1,
-            maxOut: config.limit1 + effectiveNetflow1,
-            until: effectiveLastUpdated1 + config.timestep1,
-            decimals: tokenDecimals,
-        });
-    }
-    // Add LG (global) limit if configured
-    if (isLGEnabled && config.limitGlobal > 0n) {
-        limits.push({
-            asset,
-            maxIn: config.limitGlobal - state.netflowGlobal,
-            maxOut: config.limitGlobal + state.netflowGlobal,
-            until: TIMESTAMP_FAR_FUTURE,
-            decimals: tokenDecimals,
-        });
-    }
-    // Apply cascading restrictions: limits with larger timeframes restrict smaller ones
-    // e.g., if maxIn is 0 in LG, it should also be 0 in L1 and L0
-    for (let i = limits.length - 1; i > 0; i--) {
-        if (limits[i - 1].maxIn > limits[i].maxIn) {
-            limits[i - 1] = { ...limits[i - 1], maxIn: limits[i].maxIn };
-        }
-        if (limits[i - 1].maxOut > limits[i].maxOut) {
-            limits[i - 1] = { ...limits[i - 1], maxOut: limits[i].maxOut };
-        }
-    }
-    return limits;
-}
-/**
- * Calculate trading limits from V2 config and state (FPMM pools).
- * V2 uses fixed timeframes: 5 min for L0, 1 day for L1.
- * Values are stored with 15 decimals precision.
- *
- * @param config - V2 trading limits configuration
- * @param state - V2 trading limits state
- * @param asset - Token address
- * @returns Array of TradingLimit objects
- */
-export function calculateTradingLimitsV2(config, state, asset) {
-    const nowEpoch = Math.floor(Date.now() / 1000);
-    const limits = [];
-    // Check if L0 is configured (limit0 > 0)
-    const isL0Enabled = config.limit0 > 0n;
-    // Check if L1 is configured (limit1 > 0)
-    const isL1Enabled = config.limit1 > 0n;
-    // Reset netflows if time windows have passed
-    const isL0Outdated = isL0Enabled && nowEpoch > state.lastUpdated0 + V2_L0_TIMESTEP;
-    const isL1Outdated = isL1Enabled && nowEpoch > state.lastUpdated1 + V2_L1_TIMESTEP;
-    const effectiveNetflow0 = isL0Outdated ? 0n : state.netflow0;
-    const effectiveNetflow1 = isL1Outdated ? 0n : state.netflow1;
-    const effectiveLastUpdated0 = isL0Outdated ? nowEpoch : state.lastUpdated0;
-    const effectiveLastUpdated1 = isL1Outdated ? nowEpoch : state.lastUpdated1;
-    // Add L0 limit if configured
-    if (isL0Enabled) {
-        limits.push({
-            asset,
-            maxIn: config.limit0 - effectiveNetflow0,
-            maxOut: config.limit0 + effectiveNetflow0,
-            until: effectiveLastUpdated0 + V2_L0_TIMESTEP,
-            decimals: V2_INTERNAL_DECIMALS, // V2 returns 15 decimal values
-        });
-    }
-    // Add L1 limit if configured
-    if (isL1Enabled) {
-        limits.push({
-            asset,
-            maxIn: config.limit1 - effectiveNetflow1,
-            maxOut: config.limit1 + effectiveNetflow1,
-            until: effectiveLastUpdated1 + V2_L1_TIMESTEP,
-            decimals: V2_INTERNAL_DECIMALS, // V2 returns 15 decimal values
-        });
-    }
-    // Apply cascading restrictions
-    for (let i = limits.length - 1; i > 0; i--) {
-        if (limits[i - 1].maxIn > limits[i].maxIn) {
-            limits[i - 1] = { ...limits[i - 1], maxIn: limits[i].maxIn };
-        }
-        if (limits[i - 1].maxOut > limits[i].maxOut) {
-            limits[i - 1] = { ...limits[i - 1], maxOut: limits[i].maxOut };
-        }
-    }
-    return limits;
-}
-/**
- * Check if any trading limits are configured (flags > 0 for V1, or limit0/limit1 > 0 for V2)
- */
-export function hasConfiguredLimitsV1(config) {
-    return config.flags > 0;
-}
-/**
- * Check if any trading limits are configured for V2
- */
-export function hasConfiguredLimitsV2(config) {
-    return config.limit0 > 0n || config.limit1 > 0n;
-}

package/dist/esm/utils/validation.js

@@ -1,30 +0,0 @@
-import { isAddress } from 'viem';
-/**
- * Validates an Ethereum address format using viem's isAddress utility
- *
- * @param address - The address string to validate
- * @param paramName - Optional parameter name for better error messages
- * @returns True if valid (type guard for `0x${string}`)
- * @throws Error if address is invalid
- *
- * @example
- * ```typescript
- * validateAddress('0x765DE816845861e75A25fCA122bb6898B8B1282a')
- * // Returns true
- *
- * validateAddress('invalid', 'tokenIn')
- * // Throws: "Invalid address for tokenIn: invalid"
- * ```
- */
-export function validateAddress(address, paramName) {
-    if (typeof address !== 'string') {
-        const param = paramName ? ` for ${paramName}` : '';
-        throw new Error(`Address${param} must be a string, got ${typeof address}`);
-    }
-    // Use viem's isAddress with strict: false to allow both checksummed and non-checksummed addresses
-    if (!isAddress(address, { strict: false })) {
-        const param = paramName ? ` for ${paramName}` : '';
-        throw new Error(`Invalid address${param}: ${address}. Expected 0x followed by 40 hex characters`);
-    }
-    return true;
-}

package/dist/index.d.ts

@@ -1,101 +0,0 @@
-import { type PublicClient } from 'viem';
-import { ContractAddresses } from './core/types';
-import { TokenService } from './services/tokens';
-import { PoolService } from './services/pools';
-import { RouteService } from './services/routes';
-import { QuoteService } from './services/quotes';
-import { SwapService } from './services/swap';
-import { TradingService } from './services/trading';
-import { LiquidityService } from './services/liquidity';
-import { BorrowService } from './services/borrow';
-export interface MentoBatchOptions {
-    batchSize?: number;
-    wait?: number;
-}
-export interface MentoClientOptions {
-    httpBatch?: MentoBatchOptions | false;
-    multicallBatch?: MentoBatchOptions | false;
-}
-/**
- * @class Mento
- * @description The main class for the Mento SDK. Initializes a viem PublicClient internally
- *              and provides a public API for interacting with the Mento Protocol.
- * @dev         example usage:
- *              const mento = await Mento.create(ChainId.CELO);
- *              // or with custom RPC URL
- *              const mento = await Mento.create(ChainId.CELO, 'https://custom-rpc-url.com');
- *              // or with an existing viem PublicClient
- *              const mento = await Mento.create(ChainId.CELO, myPublicClient);
- *
- *              // Get all stable tokens
- *              const stableTokens = await mento.tokens.getStableTokens();
- *
- *              // Get all collateral assets
- *              const collateralAssets = await mento.tokens.getCollateralAssets();
- *
- *              // Get all pools
- *              const pools = await mento.pools.getPools();
- *
- *              // Find a route between tokens
- *              const route = await mento.routes.findRoute(USDm, CELO);
- *
- *              // Get a quote for a swap
- *              const amountOut = await mento.quotes.getAmountOut(USDm, CELO, amountIn);
- *
- *              // Build swap parameters
- *              const swapDetails = await mento.swap.buildSwapParams(USDm, CELO, amountIn, recipient, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) });
- *
- *              // Check if a pair is tradable (circuit breaker check)
- *              const isTradable = await mento.trading.isPairTradable(USDm, CELO);
- *
- *              // Get trading limits for a pool
- *              const limits = await mento.trading.getPoolTradingLimits(pool);
- *
- *              // Get full tradability status (circuit breaker + limits)
- *              const status = await mento.trading.getPoolTradabilityStatus(pool);
- *
- *              // Add liquidity to a pool
- *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
- *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
- *
- *              // Add liquidity using a single token (zap in)
- *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
- *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
- */
-export declare class Mento {
-    private chainId;
-    tokens: TokenService;
-    pools: PoolService;
-    routes: RouteService;
-    quotes: QuoteService;
-    swap: SwapService;
-    trading: TradingService;
-    liquidity: LiquidityService;
-    borrow: BorrowService;
-    private constructor();
-    /**
-     * Create a new Mento SDK instance
-     * @param chainId - The chain ID (e.g., ChainId.CELO, ChainId.CELO_SEPOLIA)
-     * @param rpcUrlOrClient - Optional RPC URL string or an existing viem PublicClient.
-     *                         If not provided, uses the default RPC URL for the chain.
-     * @param options - Optional batching configuration used only when the SDK creates the PublicClient internally.
-     * @returns A new Mento instance
-     */
-    static create(chainId: number): Promise<Mento>;
-    static create(chainId: number, rpcUrlOrClient: string | PublicClient, options?: MentoClientOptions): Promise<Mento>;
-    /**
-     * Get the address of a contract for the current chain
-     * @param contractName - The contract name
-     * @returns The contract address
-     */
-    getContractAddress(contractName: keyof ContractAddresses): string;
-}
-export * from './core/constants';
-export * from './core/errors';
-export * from './core/types';
-export * from './core/abis';
-export * from './services';
-export * from './utils';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,158 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mento = void 0;
-const viem_1 = require("viem");
-const chainId_1 = require("./core/constants/chainId");
-const addresses_1 = require("./core/constants/addresses");
-const chainConfig_1 = require("./utils/chainConfig");
-const tokens_1 = require("./services/tokens");
-const pools_1 = require("./services/pools");
-const routes_1 = require("./services/routes");
-const quotes_1 = require("./services/quotes");
-const swap_1 = require("./services/swap");
-const trading_1 = require("./services/trading");
-const liquidity_1 = require("./services/liquidity");
-const borrow_1 = require("./services/borrow");
-const DEFAULT_HTTP_BATCH_OPTIONS = {
-    batchSize: 1000,
-    wait: 8,
-};
-const DEFAULT_MULTICALL_BATCH_OPTIONS = {
-    batchSize: 1024,
-    wait: 8,
-};
-/**
- * @class Mento
- * @description The main class for the Mento SDK. Initializes a viem PublicClient internally
- *              and provides a public API for interacting with the Mento Protocol.
- * @dev         example usage:
- *              const mento = await Mento.create(ChainId.CELO);
- *              // or with custom RPC URL
- *              const mento = await Mento.create(ChainId.CELO, 'https://custom-rpc-url.com');
- *              // or with an existing viem PublicClient
- *              const mento = await Mento.create(ChainId.CELO, myPublicClient);
- *
- *              // Get all stable tokens
- *              const stableTokens = await mento.tokens.getStableTokens();
- *
- *              // Get all collateral assets
- *              const collateralAssets = await mento.tokens.getCollateralAssets();
- *
- *              // Get all pools
- *              const pools = await mento.pools.getPools();
- *
- *              // Find a route between tokens
- *              const route = await mento.routes.findRoute(USDm, CELO);
- *
- *              // Get a quote for a swap
- *              const amountOut = await mento.quotes.getAmountOut(USDm, CELO, amountIn);
- *
- *              // Build swap parameters
- *              const swapDetails = await mento.swap.buildSwapParams(USDm, CELO, amountIn, recipient, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) });
- *
- *              // Check if a pair is tradable (circuit breaker check)
- *              const isTradable = await mento.trading.isPairTradable(USDm, CELO);
- *
- *              // Get trading limits for a pool
- *              const limits = await mento.trading.getPoolTradingLimits(pool);
- *
- *              // Get full tradability status (circuit breaker + limits)
- *              const status = await mento.trading.getPoolTradabilityStatus(pool);
- *
- *              // Add liquidity to a pool
- *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
- *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
- *
- *              // Add liquidity using a single token (zap in)
- *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
- *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
- */
-class Mento {
-    constructor(chainId, tokens, pools, routes, quotes, swap, trading, liquidity, borrow) {
-        this.chainId = chainId;
-        this.tokens = tokens;
-        this.pools = pools;
-        this.routes = routes;
-        this.quotes = quotes;
-        this.swap = swap;
-        this.trading = trading;
-        this.liquidity = liquidity;
-        this.borrow = borrow;
-    }
-    static async create(chainId, rpcUrlOrClient, options) {
-        // Validate chainId is supported
-        const supportedChainIds = Object.values(chainId_1.ChainId).filter((v) => typeof v === 'number');
-        if (!supportedChainIds.includes(chainId)) {
-            throw new Error(`ChainId ${chainId} is not supported. ` +
-                `Supported chains: ${supportedChainIds.map((id) => `${id} (${chainId_1.ChainId[id]})`).join(', ')}`);
-        }
-        let publicClient;
-        if (rpcUrlOrClient && typeof rpcUrlOrClient !== 'string') {
-            publicClient = rpcUrlOrClient;
-        }
-        else {
-            const transport = (0, viem_1.http)(rpcUrlOrClient || (0, chainConfig_1.getDefaultRpcUrl)(chainId), {
-                batch: options?.httpBatch === false
-                    ? false
-                    : {
-                        ...DEFAULT_HTTP_BATCH_OPTIONS,
-                        ...(options?.httpBatch ?? {}),
-                    },
-            });
-            publicClient = (0, viem_1.createPublicClient)({
-                batch: {
-                    multicall: options?.multicallBatch === false
-                        ? false
-                        : {
-                            ...DEFAULT_MULTICALL_BATCH_OPTIONS,
-                            ...(options?.multicallBatch ?? {}),
-                        },
-                },
-                chain: (0, chainConfig_1.getChainConfig)(chainId),
-                transport,
-            });
-        }
-        const tokenService = new tokens_1.TokenService(publicClient, chainId);
-        const poolService = new pools_1.PoolService(publicClient, chainId);
-        const routeService = new routes_1.RouteService(publicClient, chainId, poolService);
-        const quoteService = new quotes_1.QuoteService(publicClient, chainId, routeService);
-        const swapService = new swap_1.SwapService(publicClient, chainId, routeService, quoteService);
-        const tradingService = new trading_1.TradingService(publicClient, chainId, routeService);
-        const liquidityService = new liquidity_1.LiquidityService(publicClient, chainId, poolService, routeService);
-        const borrowService = new borrow_1.BorrowService(publicClient, chainId);
-        // Return new mento
-        return new Mento(chainId, tokenService, poolService, routeService, quoteService, swapService, tradingService, liquidityService, borrowService);
-    }
-    /**
-     * Get the address of a contract for the current chain
-     * @param contractName - The contract name
-     * @returns The contract address
-     */
-    getContractAddress(contractName) {
-        return (0, addresses_1.getContractAddress)(this.chainId, contractName);
-    }
-}
-exports.Mento = Mento;
-__exportStar(require("./core/constants"), exports);
-__exportStar(require("./core/errors"), exports);
-__exportStar(require("./core/types"), exports);
-__exportStar(require("./core/abis"), exports);
-__exportStar(require("./services"), exports);
-__exportStar(require("./utils"), exports);
-//# sourceMappingURL=index.js.map