@mento-protocol/mento-sdk 1.18.0 → 1.19.0

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/enums/chainId.js

@@ -0,0 +1,5 @@
+export var ChainId;
+(function (ChainId) {
+    ChainId[ChainId["CELO"] = 42220] = "CELO";
+    ChainId[ChainId["CELO_SEPOLIA"] = 11142220] = "CELO_SEPOLIA";
+})(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

@@ -0,0 +1,7 @@
+/* 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/IChainClient.js

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

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/tradingLimit.js

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

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/tradingLimitsConfig.js

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

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/interfaces/tradingLimitsState.js

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

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;

package/dist/esm/limits.js

@@ -0,0 +1,123 @@
+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 { strict as assert } from 'assert';
+import { utils } from 'ethers';
+/**
+ * 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 function getLimitsConfig(broker, exchangeId, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limitId = getLimitId(exchangeId, asset);
+        const cfg = yield broker.tradingLimitsConfig(limitId);
+        return {
+            asset,
+            timestep0: cfg['timestep0'],
+            timestep1: cfg['timestep1'],
+            limit0: cfg['limit0'],
+            limit1: cfg['limit1'],
+            limitGlobal: cfg['limitGlobal'],
+            flags: cfg['flags'],
+        };
+    });
+}
+/**
+ * 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 function getLimitsState(broker, exchangeId, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limitId = getLimitId(exchangeId, asset);
+        const [cfg, state] = yield Promise.all([
+            getLimitsConfig(broker, exchangeId, asset),
+            broker.tradingLimitsState(limitId),
+        ]);
+        const isL0Enabled = cfg.timestep0 > 0;
+        const isL1Enabled = cfg.timestep1 > 0;
+        const nowEpoch = Math.floor(Date.now() / 1000);
+        const isL0Outdated = isL0Enabled && nowEpoch > state['lastUpdated0'] + cfg.timestep0;
+        const isL1Outdated = isL1Enabled && nowEpoch > state['lastUpdated1'] + cfg.timestep1;
+        return {
+            asset,
+            lastUpdated0: isL0Outdated ? nowEpoch : state['lastUpdated0'],
+            lastUpdated1: isL1Outdated ? nowEpoch : state['lastUpdated1'],
+            netflow0: isL0Outdated ? 0 : state['netflow0'],
+            netflow1: isL1Outdated ? 0 : state['netflow1'],
+            netflowGlobal: state['netflowGlobal'],
+        };
+    });
+}
+/**
+ * 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 function getLimits(broker, exchangeId, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [cfg, state] = yield Promise.all([
+            getLimitsConfig(broker, exchangeId, asset),
+            getLimitsState(broker, exchangeId, asset),
+        ]);
+        const limits = [];
+        if (cfg.limit0 > 0) {
+            limits.push({
+                asset: asset,
+                maxIn: cfg.limit0 - state.netflow0,
+                maxOut: cfg.limit0 + state.netflow0,
+                until: state.lastUpdated0 + cfg.timestep0,
+            });
+        }
+        if (cfg.limit1 > 0) {
+            limits.push({
+                asset: asset,
+                maxIn: cfg.limit1 - state.netflow1,
+                maxOut: cfg.limit1 + state.netflow1,
+                until: state.lastUpdated1 + cfg.timestep1,
+            });
+        }
+        if (cfg.limitGlobal > 0) {
+            const timestampIn2030 = 1893456000; // a far away timestamp
+            limits.push({
+                asset: asset,
+                maxIn: cfg.limitGlobal - state.netflowGlobal,
+                maxOut: cfg.limitGlobal + state.netflowGlobal,
+                until: timestampIn2030,
+            });
+        }
+        // Limits with a smaller timeframe are restricted by the ones with a larger one
+        // 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--) {
+            limits[i - 1].maxIn = Math.min(limits[i - 1].maxIn, limits[i].maxIn);
+            limits[i - 1].maxOut = Math.min(limits[i - 1].maxOut, limits[i].maxOut);
+        }
+        return limits;
+    });
+}
+/**
+ * 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 function getLimitId(exchangeId, asset) {
+    const assetBytes32 = utils.zeroPad(asset, 32);
+    const exchangeIdBytes = utils.arrayify(exchangeId);
+    const assetBytes = utils.arrayify(assetBytes32);
+    assert(exchangeIdBytes.length === assetBytes.length, 'exchangeId and asset0 must be the same length');
+    return utils.hexlify(exchangeIdBytes.map((b, i) => b ^ assetBytes[i]));
+}