@mento-protocol/mento-sdk 3.2.3 → 3.2.4

package/dist/core/types/tradingLimits.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Human-friendly representation of a trading limit.
+ * Used by frontends to display limit status and calculate remaining capacity.
+ */
+export interface TradingLimit {
+    /** Token address this limit applies to */
+    asset: string;
+    /** Maximum amount that can flow IN (raw value - V1: 0 decimals, V2: 15 decimals) */
+    maxIn: bigint;
+    /** Maximum amount that can flow OUT (raw value - V1: 0 decimals, V2: 15 decimals) */
+    maxOut: bigint;
+    /** Unix timestamp when this limit window resets */
+    until: number;
+    /** Token decimals for consumer scaling */
+    decimals: number;
+}
+/**
+ * Trading limits configuration for V1 (Broker/Virtual pools).
+ * Uses configurable timeframes and 0 decimal precision.
+ */
+export interface TradingLimitsConfigV1 {
+    /** Time window in seconds for L0 limit */
+    timestep0: number;
+    /** Time window in seconds for L1 limit */
+    timestep1: number;
+    /** L0 limit value (0 decimal precision) */
+    limit0: bigint;
+    /** L1 limit value (0 decimal precision) */
+    limit1: bigint;
+    /** Global limit value (0 decimal precision) */
+    limitGlobal: bigint;
+    /** Flags bitmap: bit 0=L0, bit 1=L1, bit 2=LG */
+    flags: number;
+}
+/**
+ * Trading limits state for V1 (Broker/Virtual pools).
+ */
+export interface TradingLimitsStateV1 {
+    /** Timestamp of last L0 window reset */
+    lastUpdated0: number;
+    /** Timestamp of last L1 window reset */
+    lastUpdated1: number;
+    /** Current netflow for L0 (0 decimal precision) */
+    netflow0: bigint;
+    /** Current netflow for L1 (0 decimal precision) */
+    netflow1: bigint;
+    /** Current global netflow (0 decimal precision) */
+    netflowGlobal: bigint;
+}
+/**
+ * Trading limits configuration for V2 (FPMM pools).
+ * Uses fixed timeframes (5 min for L0, 1 day for L1) and 15 decimal precision.
+ */
+export interface TradingLimitsConfigV2 {
+    /** L0 limit value (15 decimal precision) */
+    limit0: bigint;
+    /** L1 limit value (15 decimal precision) */
+    limit1: bigint;
+    /** Token decimals */
+    decimals: number;
+}
+/**
+ * Trading limits state for V2 (FPMM pools).
+ */
+export interface TradingLimitsStateV2 {
+    /** Timestamp of last L0 window reset */
+    lastUpdated0: number;
+    /** Timestamp of last L1 window reset */
+    lastUpdated1: number;
+    /** Current netflow for L0 (15 decimal precision) */
+    netflow0: bigint;
+    /** Current netflow for L1 (15 decimal precision) */
+    netflow1: bigint;
+}
+/**
+ * Combined tradability status for a pool.
+ * Separates circuit breaker and trading limits for distinct UI messaging.
+ */
+export interface PoolTradabilityStatus {
+    /** Overall tradability (circuitBreakerOk AND limitsOk) */
+    tradable: boolean;
+    /** Circuit breaker status - true if not tripped */
+    circuitBreakerOk: boolean;
+    /** Raw trading mode value (0 = BIDIRECTIONAL, non-zero = suspended) */
+    tradingMode: number;
+    /** Trading limits status - true if limits not exhausted */
+    limitsOk: boolean;
+    /** Detailed limit info for UI display */
+    limits: TradingLimit[];
+}
+//# sourceMappingURL=tradingLimits.d.ts.map

package/dist/core/types/tradingLimits.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tradingLimits.js.map

package/dist/core/types/tradingMode.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Trading modes for rate feeds in the BreakerBox circuit breaker.
+ *
+ * The BreakerBox uses a bitmask approach where multiple breakers can
+ * contribute to the final trading mode. In practice:
+ * - 0 = Bidirectional (trading enabled)
+ * - Any non-zero value = Trading suspended
+ *
+ * For SDK consumers, use isTradingEnabled() helper to check if trading
+ * is allowed.
+ */
+export declare enum TradingMode {
+    /** Bidirectional trading is enabled (normal operation) */
+    BIDIRECTIONAL = 0,
+    /** Trading is suspended (circuit breaker tripped) - any non-zero value */
+    SUSPENDED = 1
+}
+/**
+ * Check if trading is enabled for a given trading mode.
+ * @param mode - The trading mode value from BreakerBox
+ * @returns true if trading is enabled (mode === 0)
+ */
+export declare function isTradingEnabled(mode: number): boolean;
+//# sourceMappingURL=tradingMode.d.ts.map

package/dist/core/types/tradingMode.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingMode = void 0;
+exports.isTradingEnabled = isTradingEnabled;
+/**
+ * Trading modes for rate feeds in the BreakerBox circuit breaker.
+ *
+ * The BreakerBox uses a bitmask approach where multiple breakers can
+ * contribute to the final trading mode. In practice:
+ * - 0 = Bidirectional (trading enabled)
+ * - Any non-zero value = Trading suspended
+ *
+ * For SDK consumers, use isTradingEnabled() helper to check if trading
+ * is allowed.
+ */
+var TradingMode;
+(function (TradingMode) {
+    /** Bidirectional trading is enabled (normal operation) */
+    TradingMode[TradingMode["BIDIRECTIONAL"] = 0] = "BIDIRECTIONAL";
+    /** Trading is suspended (circuit breaker tripped) - any non-zero value */
+    TradingMode[TradingMode["SUSPENDED"] = 1] = "SUSPENDED";
+})(TradingMode || (exports.TradingMode = TradingMode = {}));
+/**
+ * Check if trading is enabled for a given trading mode.
+ * @param mode - The trading mode value from BreakerBox
+ * @returns true if trading is enabled (mode === 0)
+ */
+function isTradingEnabled(mode) {
+    return mode === TradingMode.BIDIRECTIONAL;
+}
+//# sourceMappingURL=tradingMode.js.map

package/dist/core/types/transaction.d.ts

@@ -0,0 +1,45 @@
+export interface ContractCallOptions {
+    address: string;
+    abi: string[] | unknown[];
+    functionName: string;
+    args?: unknown[];
+}
+/**
+ * Contract write options for building call parameters
+ *
+ * Configuration for building transaction call parameters for write operations.
+ * These parameters can be used by consumers to execute transactions themselves.
+ */
+export interface ContractWriteOptions extends ContractCallOptions {
+    /**
+     * Optional gas limit override
+     * If not provided, will be estimated automatically
+     */
+    gasLimit?: bigint;
+    /**
+     * Transaction value in wei
+     * For payable functions only
+     */
+    value?: bigint;
+}
+/**
+ * Call parameters for executing a contract transaction
+ *
+ * Contains all the data needed to execute a contract call.
+ * Consumers can use these parameters with their own wallet/signer to execute transactions.
+ */
+export interface CallParams {
+    /**
+     * Contract address to call
+     */
+    to: string;
+    /**
+     * Encoded function call data (hex string)
+     */
+    data: string;
+    /**
+     * Transaction value in wei (hex string with 0x prefix)
+     */
+    value: string;
+}
+//# sourceMappingURL=transaction.d.ts.map

package/dist/core/types/transaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transaction.js.map