@mento-protocol/mento-sdk 3.2.2 → 3.2.3

package/dist/esm/utils.js

@@ -0,0 +1,162 @@
+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 { Contract, ethers, providers, Signer } from 'ethers';
+import { getCachedTokensSync, TOKEN_ADDRESSES_BY_CHAIN } from './constants/tokens';
+/**
+ * Gets the chain ID from a signer or provider
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the chain ID
+ */
+export function getChainId(signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const provider = Signer.isSigner(signerOrProvider)
+            ? signerOrProvider.provider
+            : signerOrProvider;
+        return (yield provider.getNetwork()).chainId;
+    });
+}
+/**
+ * Ensures that given signer is truly a a connected signer
+ * @param signer an ethers signer
+ * @throws if signer is invalid or not connected
+ */
+export function validateSigner(signer) {
+    if (!Signer.isSigner(signer)) {
+        throw new Error('A valid signer must be provided');
+    }
+    if (!providers.Provider.isProvider(signer.provider)) {
+        throw new Error('Signer must be connected to a provider');
+    }
+}
+/**
+ * Ensures that given signerOrProvider is truly a provider or a connected signer
+ * @param signerOrProvider an ethers provider or signer
+ * @throws if signerOrProvider is invalid or not connected
+ */
+export function validateSignerOrProvider(signerOrProvider) {
+    const isSigner = Signer.isSigner(signerOrProvider);
+    const isProvider = providers.Provider.isProvider(signerOrProvider);
+    if (!isSigner && !isProvider) {
+        throw new Error('A valid signer or provider must be provided');
+    }
+    if (isSigner && !providers.Provider.isProvider(signerOrProvider.provider)) {
+        throw new Error('Signer must be connected to a provider');
+    }
+}
+/**
+ * Returns the symbol of an erc20 token
+ * @param tokenAddr the address of the erc20 token
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the symbol of the erc20 token
+ */
+export function getSymbolFromTokenAddress(tokenAddr, signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const erc20Abi = ['function symbol() external view returns (string memory)'];
+        const contract = new Contract(tokenAddr, erc20Abi, signerOrProvider);
+        return contract.symbol();
+    });
+}
+/**
+ * Returns the name of an erc20 token
+ * @param tokenAddr the address of the erc20 token
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the name of the erc20 token
+ */
+export function getNameFromTokenAddress(tokenAddr, signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const erc20Abi = ['function name() external view returns (string memory)'];
+        const contract = new Contract(tokenAddr, erc20Abi, signerOrProvider);
+        return contract.name();
+    });
+}
+/**
+ * Returns the decimals of an erc20 token
+ * @param tokenAddr the address of the erc20 token
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the decimals of the erc20 token
+ */
+export function getDecimalsFromTokenAddress(tokenAddr, signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const erc20Abi = ['function decimals() external view returns (uint8)'];
+        const contract = new Contract(tokenAddr, erc20Abi, signerOrProvider);
+        return contract.decimals();
+    });
+}
+/**
+ * Returns a populated tx obj for increasing the allowance of a spender for a given erc20 token by a given amount
+ * @param tokenAddr the address of the erc20 token
+ * @param spender the address of the spender
+ * @param amount the amount to increase the allowance by
+ * @param signerOrProvider an ethers signer or provider
+ * @returns the populated TransactionRequest object
+ */
+export function increaseAllowance(tokenAddr, spender, amount, signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const abi = [
+            'function increaseAllowance(address spender, uint256 value) external returns (bool)',
+        ];
+        // TODO, not all ERC-20 contracts support increaseAllowance
+        // Add a check for that here
+        const contract = new Contract(tokenAddr, abi, signerOrProvider);
+        return yield contract.populateTransaction.increaseAllowance(spender, amount);
+    });
+}
+/**
+ * Find a token address by its symbol from tradable pairs
+ * @param pairs array of tradable pairs to search through
+ * @param symbol the token symbol to find (case-insensitive)
+ * @returns the token address if found, null otherwise
+ */
+export function findTokenAddressBySymbolInTradablePairs(symbol, pairs) {
+    var _a, _b;
+    return ((_b = (_a = pairs
+        .flatMap((pair) => pair.assets)
+        .find((asset) => asset.symbol.toLowerCase() === symbol.toLowerCase())) === null || _a === void 0 ? void 0 : _a.address) !== null && _b !== void 0 ? _b : null);
+}
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+} /**
+ * Helper function to get token address by symbol for a specific chain
+ * @param symbol - The token symbol
+ * @param chainId - The chain ID
+ * @returns The token address or undefined if not found
+ */
+export function getTokenAddress(symbol, chainId) {
+    var _a;
+    return (_a = TOKEN_ADDRESSES_BY_CHAIN[chainId]) === null || _a === void 0 ? void 0 : _a[symbol];
+}
+/**
+ * Helper function to find a token by symbol in the cached tokens
+ * @param symbol - The token symbol to search for
+ * @param chainId - The chain ID
+ * @returns The token object or undefined if not found
+ */
+export function findTokenBySymbol(symbol, chainId) {
+    const tokens = getCachedTokensSync(chainId);
+    return tokens.find((token) => token.symbol === symbol);
+}
+/**
+ * Computes the rate feed ID from a rate feed identifier string.
+ * This follows the Solidity formula: address(uint160(uint256(keccak256(abi.encodePacked(rateFeed)))))
+ * @param rateFeed the rate feed identifier string (e.g., "EURUSD", "relayed:COPUSD")
+ * @returns the computed rate feed address
+ */
+export function toRateFeedId(rateFeed) {
+    // 1. Calculate keccak256 hash
+    const hashedBytes = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(rateFeed));
+    // 2. Convert to BigInt (equivalent to uint256)
+    const hashAsBigInt = BigInt(hashedBytes);
+    // 3. Mask to 160 bits (equivalent to uint160)
+    const maskedToUint160 = hashAsBigInt & ((BigInt(1) << BigInt(160)) - BigInt(1));
+    // 4. Convert to address (hex string)
+    const addressHex = '0x' + maskedToUint160.toString(16).padStart(40, '0');
+    // 5. Return calculated rate feed ID
+    return addressHex;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mento-protocol/mento-sdk",
   "description": "Official SDK for interacting with the Mento Protocol",
-  "version": "3.2.2",
+  "version": "3.2.3",
   "license": "MIT",
   "author": "Mento Labs",
   "keywords": [

package/dist/cache/routes.d.ts

@@ -1,13 +0,0 @@
-import type { RouteWithCost } from '../core/types';
-/**
- * Cached routes indexed by chain ID
- * Routes that don't exist for a chain will return an empty array
- */
-export declare const cachedRoutes: Record<number, RouteWithCost[]>;
-/**
- * Get cached routes for a specific chain
- * @param chainId - The chain ID
- * @returns The cached routes array, or empty array if not available
- */
-export declare function getCachedRoutes(chainId: number): RouteWithCost[];
-//# sourceMappingURL=routes.d.ts.map