@mento-protocol/mento-sdk 3.2.7 → 3.3.0-beta.0

package/dist/esm/core/errors/router.js

@@ -0,0 +1,18 @@
+import { MentoError } from './base';
+/**
+ * Error thrown when no tradable route exists between two tokens.
+ */
+export class RouteNotFoundError extends MentoError {
+    constructor(tokenIn, tokenOut) {
+        super(`No route found for tokens ${tokenIn} and ${tokenOut}. They may not have a tradable path.`);
+    }
+}
+/**
+ * Error thrown when no executable zap-out route exists for the requested amount.
+ */
+export class ZapOutRouteNotViableError extends MentoError {
+    constructor(poolAddress, tokenOut) {
+        super(`No viable zap-out route for pool ${poolAddress} to ${tokenOut}. ` +
+            'Try reducing the amount or removing liquidity in balanced mode.');
+    }
+}

package/dist/esm/core/types/borrow.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/contractAddresses.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/index.js

@@ -0,0 +1,9 @@
+export * from './contractAddresses';
+export * from './transaction';
+export * from './token';
+export * from './route';
+export * from './pool';
+export * from './tradingMode';
+export * from './tradingLimits';
+export * from './liquidity';
+export * from './borrow';

package/dist/esm/core/types/liquidity.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/pool.js

@@ -0,0 +1,10 @@
+/**
+ * Types of liquidity pools supported in the Mento protocol
+ */
+export var PoolType;
+(function (PoolType) {
+    /** FPMM (Fixed Product Market Maker) pools - v3 native pools */
+    PoolType["FPMM"] = "FPMM";
+    /** Virtual pools - wrapper around v2 BiPoolManager exchanges */
+    PoolType["Virtual"] = "Virtual";
+})(PoolType || (PoolType = {}));

package/dist/esm/core/types/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/route.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/token.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/tradingLimits.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/types/tradingMode.js

@@ -0,0 +1,26 @@
+/**
+ * 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 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 || (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)
+ */
+export function isTradingEnabled(mode) {
+    return mode === TradingMode.BIDIRECTIONAL;
+}

package/dist/esm/core/types/transaction.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.js

@@ -0,0 +1,139 @@
+import { createPublicClient, http } from 'viem';
+import { ChainId } from './core/constants/chainId';
+import { getContractAddress } from './core/constants/addresses';
+import { getDefaultRpcUrl, getChainConfig } from './utils/chainConfig';
+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';
+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) }
+ *              );
+ */
+export 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).filter((v) => typeof v === 'number');
+        if (!supportedChainIds.includes(chainId)) {
+            throw new Error(`ChainId ${chainId} is not supported. ` +
+                `Supported chains: ${supportedChainIds.map((id) => `${id} (${ChainId[id]})`).join(', ')}`);
+        }
+        let publicClient;
+        if (rpcUrlOrClient && typeof rpcUrlOrClient !== 'string') {
+            publicClient = rpcUrlOrClient;
+        }
+        else {
+            const transport = http(rpcUrlOrClient || getDefaultRpcUrl(chainId), {
+                batch: options?.httpBatch === false
+                    ? false
+                    : {
+                        ...DEFAULT_HTTP_BATCH_OPTIONS,
+                        ...(options?.httpBatch ?? {}),
+                    },
+            });
+            publicClient = createPublicClient({
+                batch: {
+                    multicall: options?.multicallBatch === false
+                        ? false
+                        : {
+                            ...DEFAULT_MULTICALL_BATCH_OPTIONS,
+                            ...(options?.multicallBatch ?? {}),
+                        },
+                },
+                chain: getChainConfig(chainId),
+                transport,
+            });
+        }
+        const tokenService = new TokenService(publicClient, chainId);
+        const poolService = new PoolService(publicClient, chainId);
+        const routeService = new RouteService(publicClient, chainId, poolService);
+        const quoteService = new QuoteService(publicClient, chainId, routeService);
+        const swapService = new SwapService(publicClient, chainId, routeService, quoteService);
+        const tradingService = new TradingService(publicClient, chainId, routeService);
+        const liquidityService = new LiquidityService(publicClient, chainId, poolService, routeService);
+        const borrowService = new 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 getContractAddress(this.chainId, contractName);
+    }
+}
+export * from './core/constants';
+export * from './core/errors';
+export * from './core/types';
+export * from './core/abis';
+export * from './services';
+export * from './utils';

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}