@mento-protocol/mento-sdk 3.2.2 → 3.2.3

package/dist/esm/constants/tradablePairs.d.ts

@@ -0,0 +1,16 @@
+import { TradablePair } from '../mento';
+export interface TradablePairWithSpread extends TradablePair {
+    spreadData: {
+        totalSpreadPercent: number;
+        hops: Array<{
+            exchangeId: string;
+            spreadPercent: number;
+        }>;
+    };
+}
+/**
+ * Gets cached tradable pairs for a specific chain ID
+ * @param chainId - The chain ID to get cached pairs for
+ * @returns Promise resolving to the cached tradable pairs or undefined if not available
+ */
+export declare function getCachedTradablePairs(chainId: number): Promise<readonly (TradablePair | TradablePairWithSpread)[] | undefined>;

package/dist/esm/constants/tradablePairs.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/**
+ * Gets cached tradable pairs for a specific chain ID
+ * @param chainId - The chain ID to get cached pairs for
+ * @returns Promise resolving to the cached tradable pairs or undefined if not available
+ */
+export function getCachedTradablePairs(chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (chainId) {
+            case 42220:
+                return yield import('./tradablePairs.42220').then((module) => module.tradablePairs42220);
+            case 11142220:
+                return yield import('./tradablePairs.11142220').then((module) => module.tradablePairs11142220);
+            default:
+                return undefined;
+        }
+    });
+}

package/dist/esm/enums/chainId.d.ts

@@ -0,0 +1,4 @@
+export declare enum ChainId {
+    CELO = 42220,
+    CELO_SEPOLIA = 11142220
+}

package/dist/esm/{core/constants → enums}/chainId.js

@@ -2,6 +2,4 @@ export var ChainId;
 (function (ChainId) {
     ChainId[ChainId["CELO"] = 42220] = "CELO";
     ChainId[ChainId["CELO_SEPOLIA"] = 11142220] = "CELO_SEPOLIA";
-    ChainId[ChainId["MONAD_TESTNET"] = 10143] = "MONAD_TESTNET";
-    ChainId[ChainId["MONAD"] = 143] = "MONAD";
 })(ChainId || (ChainId = {}));

package/dist/esm/enums/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chainId';
+export * from './proposalState';
+export * from './tradingMode';

package/dist/esm/enums/index.js

@@ -0,0 +1,3 @@
+export * from './chainId';
+export * from './proposalState';
+export * from './tradingMode';

package/dist/esm/enums/proposalState.d.ts

@@ -0,0 +1,10 @@
+export declare enum ProposalState {
+    PENDING = 0,
+    ACTIVE = 1,
+    CANCELED = 2,
+    DEFEATED = 3,
+    SUCCEEDED = 4,
+    QUEUED = 5,
+    EXPIRED = 6,
+    EXECUTED = 7
+}

package/dist/esm/enums/proposalState.js

@@ -0,0 +1,11 @@
+export var ProposalState;
+(function (ProposalState) {
+    ProposalState[ProposalState["PENDING"] = 0] = "PENDING";
+    ProposalState[ProposalState["ACTIVE"] = 1] = "ACTIVE";
+    ProposalState[ProposalState["CANCELED"] = 2] = "CANCELED";
+    ProposalState[ProposalState["DEFEATED"] = 3] = "DEFEATED";
+    ProposalState[ProposalState["SUCCEEDED"] = 4] = "SUCCEEDED";
+    ProposalState[ProposalState["QUEUED"] = 5] = "QUEUED";
+    ProposalState[ProposalState["EXPIRED"] = 6] = "EXPIRED";
+    ProposalState[ProposalState["EXECUTED"] = 7] = "EXECUTED";
+})(ProposalState || (ProposalState = {}));

package/dist/esm/enums/tradingMode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Trading modes for rate feeds in the BreakerBox
+ */
+export declare enum TradingMode {
+    /**
+     * Bidirectional trading is enabled
+     */
+    BIDIRECTIONAL = 0,
+    /**
+     * Trading is temporarily halted (circuit breaker tripped)
+     */
+    HALTED = 1,
+    /**
+     * Trading is permanently disabled
+     */
+    DISABLED = 2
+}

package/dist/esm/enums/tradingMode.js

@@ -0,0 +1,18 @@
+/**
+ * Trading modes for rate feeds in the BreakerBox
+ */
+export var TradingMode;
+(function (TradingMode) {
+    /**
+     * Bidirectional trading is enabled
+     */
+    TradingMode[TradingMode["BIDIRECTIONAL"] = 0] = "BIDIRECTIONAL";
+    /**
+     * Trading is temporarily halted (circuit breaker tripped)
+     */
+    TradingMode[TradingMode["HALTED"] = 1] = "HALTED";
+    /**
+     * Trading is permanently disabled
+     */
+    TradingMode[TradingMode["DISABLED"] = 2] = "DISABLED";
+})(TradingMode || (TradingMode = {}));

package/dist/esm/governance.d.ts

@@ -0,0 +1,62 @@
+import { BigNumberish, Signer, providers } from 'ethers';
+import { MentoGovernor } from '@mento-protocol/mento-core-ts';
+import { IChainClient } from './interfaces';
+export declare class Governance {
+    private chainClient;
+    constructor(chainClient: IChainClient);
+    constructor(signerOrProvider: Signer | providers.Provider);
+    /**
+     * This function retrieves the MentoGovernor contract.
+     * @returns The MentoGovernor contract.
+     */
+    getGovernorContract(): Promise<MentoGovernor>;
+    /**
+     * Generates a transaction that submits a proposal to be created to the Mento Governor contract using the specified values.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     * @returns The transaction request.
+     */
+    createProposal(targets: string[], values: BigNumberish[], calldatas: string[], description: string): Promise<providers.TransactionRequest>;
+    /**
+     * Generates a transaction that will queue the proposal with the specified id to be executed.
+     * @param proposalId The id of the proposal to queue.
+     * @returns The transaction request.
+     */
+    queueProposal(proposalId: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Executes the proposal with the specified id.
+     * @param proposalId The id of the proposal to execute.
+     * @returns The transaction request.
+     */
+    executeProposal(proposalId: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Submits a vote to the Mento Governor contract for the specified proposal.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    castVote(proposalId: BigNumberish, support: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Cancels the proposal with the specified id.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    cancelProposal(proposalId: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Returns the state of the proposal with the specified id.
+     * @param proposalId The id of the proposal to get the state of.
+     * @returns The state of the proposal.
+     */
+    getProposalState(proposalId: BigNumberish): Promise<string>;
+    /**
+     * This function validates the args that are to be used in the createProposal function.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values  The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     */
+    private validateProposalArgs;
+}

package/dist/esm/governance.js

@@ -0,0 +1,147 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Signer, providers } from 'ethers';
+import { MentoGovernor__factory, } from '@mento-protocol/mento-core-ts';
+import { ChainClient } from './ChainClient';
+import { TestChainClient } from './TestChainClient';
+import { ProposalState } from './enums';
+import { addresses } from './constants';
+export class Governance {
+    constructor(arg) {
+        // TODO: Remove use of TestChainClient in future this is only meant for testing
+        if (arg instanceof ChainClient || arg instanceof TestChainClient) {
+            this.chainClient = arg;
+        }
+        else if (Signer.isSigner(arg) || providers.Provider.isProvider(arg)) {
+            this.chainClient = new ChainClient(arg);
+        }
+        else {
+            throw new Error('Invalid constructor argument');
+        }
+    }
+    /**
+     * This function retrieves the MentoGovernor contract.
+     * @returns The MentoGovernor contract.
+     */
+    getGovernorContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chainId = yield this.chainClient.getChainId();
+            const contracts = addresses[chainId];
+            if (!contracts) {
+                throw new Error(`Contracts not deployed on network with chain id ${chainId}`);
+            }
+            const mentoGovernorAddress = contracts.MentoGovernor;
+            return MentoGovernor__factory.connect(mentoGovernorAddress, yield this.chainClient.getSigner());
+        });
+    }
+    /**
+     * Generates a transaction that submits a proposal to be created to the Mento Governor contract using the specified values.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     * @returns The transaction request.
+     */
+    createProposal(targets, values, calldatas, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.validateProposalArgs(targets, values, calldatas, description);
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction['propose(address[],uint256[],bytes[],string)'](targets, values, calldatas, description);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Generates a transaction that will queue the proposal with the specified id to be executed.
+     * @param proposalId The id of the proposal to queue.
+     * @returns The transaction request.
+     */
+    queueProposal(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction['queue(uint256)'](proposalId);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Executes the proposal with the specified id.
+     * @param proposalId The id of the proposal to execute.
+     * @returns The transaction request.
+     */
+    executeProposal(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction['execute(uint256)'](proposalId);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Submits a vote to the Mento Governor contract for the specified proposal.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    castVote(proposalId, support) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction.castVote(proposalId, support);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Cancels the proposal with the specified id.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    cancelProposal(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction.cancel(proposalId);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Returns the state of the proposal with the specified id.
+     * @param proposalId The id of the proposal to get the state of.
+     * @returns The state of the proposal.
+     */
+    getProposalState(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const state = (yield governor.functions.state(proposalId))[0];
+            return ProposalState[state];
+        });
+    }
+    /**
+     * This function validates the args that are to be used in the createProposal function.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values  The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     */
+    validateProposalArgs(targets, values, calldatas, description) {
+        if (!targets || targets.length === 0) {
+            throw new Error('Targets must be specified');
+        }
+        if (!values || values.length === 0) {
+            throw new Error('Values must be specified');
+        }
+        if (!calldatas || calldatas.length === 0) {
+            throw new Error('Calldatas must be specified');
+        }
+        if (!description) {
+            throw new Error('Description must be specified');
+        }
+        if (targets.length !== values.length ||
+            targets.length !== calldatas.length) {
+            throw new Error('Targets, values, and calldatas must all have the same length');
+        }
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from './constants';
+export * from './enums';
+export * from './governance';
+export * from './mento';
+export * from './routeUtils';
+export { ContractAddresses } from './types';
+export * from './utils';

package/dist/esm/index.js

@@ -1,139 +1,7 @@
-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';
+/* istanbul ignore file */
+export * from './constants';
+export * from './enums';
+export * from './governance';
+export * from './mento';
+export * from './routeUtils';
 export * from './utils';

package/dist/esm/interfaces/IChainClient.d.ts

@@ -0,0 +1,6 @@
+import { ethers, providers } from 'ethers';
+export interface IChainClient {
+    getSigner(): Promise<ethers.Signer | providers.Provider>;
+    getChainId(): Promise<number>;
+    populateTransaction(tx: ethers.PopulatedTransaction): Promise<providers.TransactionRequest>;
+}

package/dist/esm/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tradingLimit';
+export * from './tradingLimitsConfig';
+export * from './tradingLimitsState';
+export * from './IChainClient';

package/dist/esm/interfaces/index.js

@@ -0,0 +1,4 @@
+export * from './tradingLimit';
+export * from './tradingLimitsConfig';
+export * from './tradingLimitsState';
+export * from './IChainClient';

package/dist/esm/interfaces/tradingLimit.d.ts

@@ -0,0 +1,7 @@
+export type Address = string;
+export interface TradingLimit {
+    asset: Address;
+    maxIn: number;
+    maxOut: number;
+    until: number;
+}

package/dist/esm/interfaces/tradingLimitsConfig.d.ts

@@ -0,0 +1,10 @@
+import { Address } from './tradingLimit';
+export interface TradingLimitsConfig {
+    asset: Address;
+    timestep0: number;
+    timestep1: number;
+    limit0: number;
+    limit1: number;
+    limitGlobal: number;
+    flags: number;
+}

package/dist/esm/interfaces/tradingLimitsState.d.ts

@@ -0,0 +1,9 @@
+import { Address } from './tradingLimit';
+export interface TradingLimitsState {
+    asset: Address;
+    lastUpdated0: number;
+    lastUpdated1: number;
+    netflow0: number;
+    netflow1: number;
+    netflowGlobal: number;
+}

package/dist/esm/limits.d.ts

@@ -0,0 +1,33 @@
+import { Address, TradingLimit, TradingLimitsConfig, TradingLimitsState } from './interfaces';
+import { Broker } from '@mento-protocol/mento-core-ts';
+/**
+ * Returns the limit configuration in the broker for the given exchange and asset
+ * @param broker an instance of the broker
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the limited asset
+ * @returns the limit configuration
+ */
+export declare function getLimitsConfig(broker: Broker, exchangeId: string, asset: Address): Promise<TradingLimitsConfig>;
+/**
+ * Returns the limit state in the broker for the given exchange and asset
+ * @param broker an instance of the broker
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the limited asset
+ * @returns the limit state
+ */
+export declare function getLimitsState(broker: Broker, exchangeId: string, asset: Address): Promise<TradingLimitsState>;
+/**
+ * Returns a human-friendly representation of the limits for the given exchange and asset
+ * @param broker an instance of the broker
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the asset with the limit
+ * @returns a list of TradingLimit objects
+ */
+export declare function getLimits(broker: Broker, exchangeId: string, asset: Address): Promise<TradingLimit[]>;
+/**
+ * Returns the limit id for the given exchange and asset
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the asset with the limit
+ * @returns the limit id
+ */
+export declare function getLimitId(exchangeId: string, asset: Address): string;