@mento-protocol/mento-sdk 3.2.6 → 3.2.7

package/dist/utils/sortUtils.d.ts

@@ -1,24 +0,0 @@
-import { Address } from 'viem';
-/**
- * Sorts two token addresses to match the smart contract's _sortTokens behavior.
- * Compares addresses as numeric values (BigInt), matching Solidity's address comparison.
- *
- * Solidity reference:
- * ```solidity
- * function _sortTokens(address a, address b) private pure returns (address, address) {
- *   return (a < b) ? (a, b) : (b, a);
- * }
- * ```
- */
-export declare function sortTokenAddresses(tokenA: Address, tokenB: Address): [Address, Address];
-/**
- * Creates a canonical route ID from two addresses.
- * Uses numeric address comparison to match contract behavior.
- */
-export declare function canonicalAddressKey(addressA: Address, addressB: Address, separator?: string): string;
-/**
- * Creates a canonical pair key from two symbols.
- * Uses standard string comparison for human-readable IDs.
- */
-export declare function canonicalSymbolKey(symbolA: string, symbolB: string, separator?: string): string;
-//# sourceMappingURL=sortUtils.d.ts.map

package/dist/utils/sortUtils.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortTokenAddresses = sortTokenAddresses;
-exports.canonicalAddressKey = canonicalAddressKey;
-exports.canonicalSymbolKey = canonicalSymbolKey;
-/**
- * Sorts two token addresses to match the smart contract's _sortTokens behavior.
- * Compares addresses as numeric values (BigInt), matching Solidity's address comparison.
- *
- * Solidity reference:
- * ```solidity
- * function _sortTokens(address a, address b) private pure returns (address, address) {
- *   return (a < b) ? (a, b) : (b, a);
- * }
- * ```
- */
-function sortTokenAddresses(tokenA, tokenB) {
-    return BigInt(tokenA) < BigInt(tokenB)
-        ? [tokenA, tokenB]
-        : [tokenB, tokenA];
-}
-/**
- * Creates a canonical route ID from two addresses.
- * Uses numeric address comparison to match contract behavior.
- */
-function canonicalAddressKey(addressA, addressB, separator = '-') {
-    const [first, second] = sortTokenAddresses(addressA, addressB);
-    return `${first}${separator}${second}`;
-}
-/**
- * Creates a canonical pair key from two symbols.
- * Uses standard string comparison for human-readable IDs.
- */
-function canonicalSymbolKey(symbolA, symbolB, separator = '-') {
-    return symbolA < symbolB
-        ? `${symbolA}${separator}${symbolB}`
-        : `${symbolB}${separator}${symbolA}`;
-}
-//# sourceMappingURL=sortUtils.js.map

package/dist/utils/tokens.d.ts

@@ -1,2 +0,0 @@
-export { TokenSymbol, cachedTokens, getCachedTokens, getCachedTokensSync, getTokenAddress, findTokenBySymbol, TOKEN_ADDRESSES_BY_CHAIN, } from '../cache/tokens';
-//# sourceMappingURL=tokens.d.ts.map

package/dist/utils/tokens.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOKEN_ADDRESSES_BY_CHAIN = exports.findTokenBySymbol = exports.getTokenAddress = exports.getCachedTokensSync = exports.getCachedTokens = exports.cachedTokens = exports.TokenSymbol = void 0;
-// Re-export from consolidated cache
-var tokens_1 = require("../cache/tokens");
-Object.defineProperty(exports, "TokenSymbol", { enumerable: true, get: function () { return tokens_1.TokenSymbol; } });
-Object.defineProperty(exports, "cachedTokens", { enumerable: true, get: function () { return tokens_1.cachedTokens; } });
-Object.defineProperty(exports, "getCachedTokens", { enumerable: true, get: function () { return tokens_1.getCachedTokens; } });
-Object.defineProperty(exports, "getCachedTokensSync", { enumerable: true, get: function () { return tokens_1.getCachedTokensSync; } });
-Object.defineProperty(exports, "getTokenAddress", { enumerable: true, get: function () { return tokens_1.getTokenAddress; } });
-Object.defineProperty(exports, "findTokenBySymbol", { enumerable: true, get: function () { return tokens_1.findTokenBySymbol; } });
-Object.defineProperty(exports, "TOKEN_ADDRESSES_BY_CHAIN", { enumerable: true, get: function () { return tokens_1.TOKEN_ADDRESSES_BY_CHAIN; } });
-//# sourceMappingURL=tokens.js.map

package/dist/utils/tradingLimits.d.ts

@@ -1,41 +0,0 @@
-import type { TradingLimit, TradingLimitsConfigV1, TradingLimitsStateV1, TradingLimitsConfigV2, TradingLimitsStateV2 } from '../core/types';
-/**
- * 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 declare function computeLimitId(exchangeId: string, token: string): `0x${string}`;
-/**
- * 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 declare function calculateTradingLimitsV1(config: TradingLimitsConfigV1, state: TradingLimitsStateV1, asset: string, tokenDecimals: number): TradingLimit[];
-/**
- * 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 declare function calculateTradingLimitsV2(config: TradingLimitsConfigV2, state: TradingLimitsStateV2, asset: string): TradingLimit[];
-/**
- * Check if any trading limits are configured (flags > 0 for V1, or limit0/limit1 > 0 for V2)
- */
-export declare function hasConfiguredLimitsV1(config: TradingLimitsConfigV1): boolean;
-/**
- * Check if any trading limits are configured for V2
- */
-export declare function hasConfiguredLimitsV2(config: TradingLimitsConfigV2): boolean;
-//# sourceMappingURL=tradingLimits.d.ts.map

package/dist/utils/tradingLimits.js

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeLimitId = computeLimitId;
-exports.calculateTradingLimitsV1 = calculateTradingLimitsV1;
-exports.calculateTradingLimitsV2 = calculateTradingLimitsV2;
-exports.hasConfiguredLimitsV1 = hasConfiguredLimitsV1;
-exports.hasConfiguredLimitsV2 = hasConfiguredLimitsV2;
-const viem_1 = require("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
- */
-function computeLimitId(exchangeId, token) {
-    // Pad token address to 32 bytes (left-padded with zeros)
-    const tokenBytes32 = (0, viem_1.pad)(token, { size: 32 });
-    // Convert both to BigInt for XOR operation
-    const exchangeIdBigInt = (0, viem_1.hexToBigInt)(exchangeId);
-    const tokenBigInt = (0, viem_1.hexToBigInt)(tokenBytes32);
-    // XOR operation
-    const limitIdBigInt = exchangeIdBigInt ^ tokenBigInt;
-    // Convert back to hex with proper padding
-    return (0, viem_1.pad)((0, viem_1.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
- */
-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
- */
-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)
- */
-function hasConfiguredLimitsV1(config) {
-    return config.flags > 0;
-}
-/**
- * Check if any trading limits are configured for V2
- */
-function hasConfiguredLimitsV2(config) {
-    return config.limit0 > 0n || config.limit1 > 0n;
-}
-//# sourceMappingURL=tradingLimits.js.map

package/dist/utils/validation.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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 declare function validateAddress(address: string, paramName?: string): address is `0x${string}`;
-//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAddress = validateAddress;
-const viem_1 = require("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"
- * ```
- */
-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 (!(0, viem_1.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;
-}
-//# sourceMappingURL=validation.js.map