@mento-protocol/mento-sdk 1.17.1-beta.0 → 1.19.0

package/dist/cjs/mento.d.ts

@@ -254,7 +254,7 @@ export declare class Mento {
     getRateFeedTradingMode(rateFeedId: Address): Promise<TradingMode>;
     /**
      * Checks if a trading pair is currently tradable (i.e., all rate feeds in the path are in BIDIRECTIONAL mode)
-     * For multi-hop routes (e.g., CELO → cUSD → USDT), checks that all intermediate rate feeds are tradable
+     * For multi-hop routes (e.g., CELO → USDm → USDT), checks that all intermediate rate feeds are tradable
      * @param tokenIn the address of the token to sell
      * @param tokenOut the address of the token to buy
      * @returns true if the pair is tradable (all rate feeds in BIDIRECTIONAL mode), false otherwise

package/dist/cjs/mento.js

@@ -610,7 +610,7 @@ class Mento {
     }
     /**
      * Checks if a trading pair is currently tradable (i.e., all rate feeds in the path are in BIDIRECTIONAL mode)
-     * For multi-hop routes (e.g., CELO → cUSD → USDT), checks that all intermediate rate feeds are tradable
+     * For multi-hop routes (e.g., CELO → USDm → USDT), checks that all intermediate rate feeds are tradable
      * @param tokenIn the address of the token to sell
      * @param tokenOut the address of the token to buy
      * @returns true if the pair is tradable (all rate feeds in BIDIRECTIONAL mode), false otherwise

package/dist/cjs/routeUtils.d.ts

@@ -33,15 +33,15 @@ interface ExchangeDetails {
  *
  * CONCRETE EXAMPLE:
  * Given these direct trading pairs:
- * - cUSD ↔ CELO (direct exchange exists)
- * - CELO ↔ cEUR (direct exchange exists)
- * - cUSD ↔ cREAL (direct exchange exists)
+ * - USDm ↔ CELO (direct exchange exists)
+ * - CELO ↔ EURm (direct exchange exists)
+ * - USDm ↔ BRLm (direct exchange exists)
  *
  * How route finding works:
- * - Direct route: cUSD → cEUR? Check token graph: cUSD connects to [CELO, cREAL], none is cEUR → No direct route
- * - Two-hop route: cUSD → ? → cEUR?
- *   - cUSD connects to CELO, CELO connects to cEUR → Found route: cUSD → CELO → cEUR
- *   - cUSD connects to cREAL, cREAL connects to [cUSD] → No route via cREAL
+ * - Direct route: USDm → EURm? Check token graph: USDm connects to [CELO, BRLm], none is EURm → No direct route
+ * - Two-hop route: USDm → ? → EURm?
+ *   - USDm connects to CELO, CELO connects to EURm → Found route: USDm → CELO → EURm
+ *   - USDm connects to BRLm, BRLm connects to [USDm] → No route via BRLm
  *
  * The "connectivity" part means we can quickly traverse the network of
  * token connections to find all possible trading paths.
@@ -50,31 +50,31 @@ export interface ConnectivityData {
     /** Maps token address to symbol for efficient lookups
      *
      *    ```
-     *    '0x765D...' → 'cUSD'
+     *    '0x765D...' → 'USDm'
      *    '0x471E...' → 'CELO'
-     *    '0xD876...' → 'cEUR'
+     *    '0xD876...' → 'EURm'
      *    ```
      */
     addrToSymbol: Map<Address, TokenSymbol>;
     /** Adjacency list mapping which tokens connect to which
      * Used for finding two-hop routes by traversing token → neighbor → neighbor.
      *
-     * Example for a cUSD => cEUR swap: First we find cUSD → [CELO, cKES, ...]
-     * Then we find CELO → [cUSD, cEUR, ...] = found route via cUSD → CELO → cEUR
+     * Example for a USDm => EURm swap: First we find USDm → [CELO, KESm, ...]
+     * Then we find CELO → [USDm, EURm, ...] = found route via USDm → CELO → EURm
      *
      *    ```
-     *    'cUSD_addr' → Set(['CELO_addr', 'cKES_addr'])  // cUSD connects to CELO and cKES
-     *    'CELO_addr' → Set(['cUSD_addr', 'cEUR_addr'])  // CELO connects to cUSD and cEUR
-     *    'cEUR_addr' → Set(['CELO_addr'])               // cEUR connects to CELO
-     *    'cKES_addr' → Set(['cUSD_addr'])               // cKES connects to cUSD
+     *    'USDm_addr' → Set(['CELO_addr', 'KESm_addr'])  // USDm connects to CELO and KESm
+     *    'CELO_addr' → Set(['USDm_addr', 'EURm_addr'])  // CELO connects to USDm and EURm
+     *    'EURm_addr' → Set(['CELO_addr'])               // EURm connects to CELO
+     *    'KESm_addr' → Set(['USDm_addr'])               // KESm connects to USDm
      *    ```
      */
     tokenGraph: Map<Address, Set<Address>>;
     /** Maps sorted token address pairs to their direct exchange hop details
      *    ```
-     *    'CELO_addr-cEUR_addr' → { exchange details for CELO ↔ cEUR }
-     *    'CELO_addr-cUSD_addr' → { exchange details for CELO ↔ cUSD }
-     *    'cUSD_addr-cKES_addr' → { exchange details for cUSD ↔ cKES }
+     *    'CELO_addr-EURm_addr' → { exchange details for CELO ↔ EURm }
+     *    'CELO_addr-USDm_addr' → { exchange details for CELO ↔ USDm }
+     *    'USDm_addr-KESm_addr' → { exchange details for USDm ↔ KESm }
      *    ```
      */
     directPathMap: Map<TradablePairID, ExchangeDetails>;
@@ -91,23 +91,23 @@ export interface ConnectivityData {
  *
  * ```
  * Input: TradablePairs = [
- *   { id: 'cUSD-CELO', assets: [cUSD, CELO], path: [exchange1_CELO_cUSD] },
- *   { id: 'CELO-cEUR', assets: [CELO, cEUR], path: [exchange2_CELO_cEUR] }
+ *   { id: 'USDm-CELO', assets: [USDm, CELO], path: [exchange1_CELO_USDm] },
+ *   { id: 'CELO-EURm', assets: [CELO, EURm], path: [exchange2_CELO_EURm] }
  * ]
  *
  * Step 1 - Build addrToSymbol map:
- *   cUSD.address → 'cUSD'
+ *   USDm.address → 'USDm'
  *   CELO.address → 'CELO'
- *   cEUR.address → 'cEUR'
+ *   EURm.address → 'EURm'
  *
  * Step 2 - Build directPathMap (sorted alphabetically for consistency):
- *   'CELO_addr-cEUR_addr' → exchange2_CELO_cEUR
- *   'CELO_addr-cUSD_addr' → exchange1_CELO_cUSD
+ *   'CELO_addr-EURm_addr' → exchange2_CELO_EURm
+ *   'CELO_addr-USDm_addr' → exchange1_CELO_USDm
  *
  * Step 3 - Build bidirectional tokenGraph:
- *   cUSD.address → Set([CELO.address])
- *   CELO.address → Set([cUSD.address, cEUR.address])
- *   cEUR.address → Set([CELO.address])
+ *   USDm.address → Set([CELO.address])
+ *   CELO.address → Set([USDm.address, EURm.address])
+ *   EURm.address → Set([CELO.address])
  * ```
  *
  * **Result**: We can now efficiently answer:
@@ -121,17 +121,17 @@ export interface ConnectivityData {
  * @example
  * ```typescript
  * const directPairs = [
- *   { id: 'cUSD-CELO', assets: [cUSD, CELO], path: [exchange1] },
- *   { id: 'CELO-cEUR', assets: [CELO, cEUR], path: [exchange2] }
+ *   { id: 'USDm-CELO', assets: [USDm, CELO], path: [exchange1] },
+ *   { id: 'CELO-EURm', assets: [CELO, EURm], path: [exchange2] }
  * ]
  *
  * const connectivityData = buildConnectivityStructures(directPairs)
  *
  * // Now we can efficiently find routes:
- * // 1. Check if cUSD connects to anything: connectivityData.tokenGraph.get(cUSD.address) → [CELO.address]
- * // 2. Check if CELO connects to cEUR: connectivityData.tokenGraph.get(CELO.address) → [cUSD.address, cEUR.address] ✓
- * // 3. Get exchange details: connectivityData.directPathMap.get('CELO_addr-cEUR_addr') → exchange2_CELO_cEUR
- * // Result: Found route cUSD → CELO → cEUR with exchange details
+ * // 1. Check if USDm connects to anything: connectivityData.tokenGraph.get(USDm.address) → [CELO.address]
+ * // 2. Check if CELO connects to EURm: connectivityData.tokenGraph.get(CELO.address) → [USDm.address, EURm.address] ✓
+ * // 3. Get exchange details: connectivityData.directPathMap.get('CELO_addr-EURm_addr') → exchange2_CELO_EURm
+ * // Result: Found route USDm → CELO → EURm with exchange details
  * ```
  */
 export declare function buildConnectivityStructures(directPairs: TradablePair[]): ConnectivityData;
@@ -151,21 +151,21 @@ export declare function buildConnectivityStructures(directPairs: TradablePair[])
  * the best one based on spread data or heuristics.
  *
  * **Canonical Pair IDs**: All pairs use alphabetically sorted symbols
- * (e.g., 'cEUR-cUSD' not 'cUSD-cEUR') for consistent identification.
+ * (e.g., 'EURm-USDm' not 'USDm-EURm') for consistent identification.
  *
  * @param connectivityData - The connectivity data from buildConnectivityStructures()
  * @returns Map of pair ID -> array of possible routes for that pair
  *
  * @example
  * ```typescript
- * // Given direct pairs: cUSD-CELO, CELO-cEUR, cUSD-USDC
+ * // Given direct pairs: USDm-CELO, CELO-EURm, USDm-USDC
  * const allRoutes = generateAllRoutes(connectivityData)
  *
  * // Results might include:
- * // 'cUSD-CELO' -> [{ path: [cUSD->CELO] }] // direct route
- * // 'cEUR-cUSD' -> [
- * //   { path: [cUSD->USDC, USDC->cEUR] } // two-hop via USDC
- * //   { path: [cUSD->CELO, CELO->cEUR] } // two-hop via CELO
+ * // 'USDm-CELO' -> [{ path: [USDm->CELO] }] // direct route
+ * // 'EURm-USDm' -> [
+ * //   { path: [USDm->USDC, USDC->EURm] } // two-hop via USDC
+ * //   { path: [USDm->CELO, CELO->EURm] } // two-hop via CELO
  * // ]
  * ```
  */
@@ -193,22 +193,22 @@ export declare function generateAllRoutes(connectivityData: ConnectivityData): M
  *
  * @example
  * ```typescript
- * // Create route: cUSD -> CELO -> cEUR
+ * // Create route: USDm -> CELO -> EURm
  * const pair = createTwoHopPair(
- *   '0x765D...', // cUSD address
+ *   '0x765D...', // USDm address
  *   '0x471E...', // CELO address
- *   '0xD876...', // cEUR address
+ *   '0xD876...', // EURm address
  *   addrToSymbol,
  *   directPathMap
  * )
  *
  * // Result:
  * // {
- * //   id: 'cEUR-cUSD',           // alphabetical order
- * //   assets: [cEUR, cUSD],     // alphabetical order
+ * //   id: 'EURm-USDm',           // alphabetical order
+ * //   assets: [EURm, USDm],     // alphabetical order
  * //   path: [                   // actual routing path
- * //     { cUSD->CELO exchange },
- * //     { CELO->cEUR exchange }
+ * //     { USDm->CELO exchange },
+ * //     { CELO->EURm exchange }
  * //   ]
  * // }
  * ```
@@ -239,17 +239,17 @@ export declare function createTwoHopPair(startToken: Address, intermediateToken:
  *
  * @example
  * ```typescript
- * // Multiple routes for cUSD-cEUR pair
+ * // Multiple routes for USDm-EURm pair
  * const candidates = new Map([
- *   ['cEUR-cUSD', [
- *     { path: [cUSD->CELO->cEUR], spreadData: { totalSpreadPercent: 0.5 } },
- *     { path: [cUSD->cREAL->cEUR], spreadData: { totalSpreadPercent: 0.3 } },
- *     { path: [cUSD->cEUR] } // direct route, no spread data
+ *   ['EURm-USDm', [
+ *     { path: [USDm->CELO->EURm], spreadData: { totalSpreadPercent: 0.5 } },
+ *     { path: [USDm->BRLm->EURm], spreadData: { totalSpreadPercent: 0.3 } },
+ *     { path: [USDm->EURm] } // direct route, no spread data
  *   ]]
  * ])
  *
  * const optimal = selectOptimalRoutes(candidates, false, assetMap)
- * // Returns the cUSD->cREAL->cEUR route (lowest spread: 0.3%)
+ * // Returns the USDm->BRLm->EURm route (lowest spread: 0.3%)
  * ```
  */
 export declare function selectOptimalRoutes(allRoutes: Map<TradablePairID, TradablePair[]>, returnAllRoutes: boolean, addrToSymbol: Map<Address, TokenSymbol>): (TradablePair | TradablePairWithSpread)[];
@@ -270,7 +270,7 @@ export declare function selectOptimalRoutes(allRoutes: Map<TradablePairID, Trada
  *
  * **Tier 3 - Major Stablecoin Preference** (Final Fallback):
  * - For two-hop routes, prefer those going through major stablecoins
- * - Major FX currencies like cUSD and cEUR typically have better liquidity
+ * - Major FX currencies like USDm and EURm typically have better liquidity
  *
  * **Tier 4 - First Available** (Last Resort):
  * - If no other heuristics apply, use the first route found

package/dist/cjs/routeUtils.js

@@ -11,23 +11,23 @@ exports.hasSpreadData = exports.getIntermediateToken = exports.selectBestRoute =
  *
  * ```
  * Input: TradablePairs = [
- *   { id: 'cUSD-CELO', assets: [cUSD, CELO], path: [exchange1_CELO_cUSD] },
- *   { id: 'CELO-cEUR', assets: [CELO, cEUR], path: [exchange2_CELO_cEUR] }
+ *   { id: 'USDm-CELO', assets: [USDm, CELO], path: [exchange1_CELO_USDm] },
+ *   { id: 'CELO-EURm', assets: [CELO, EURm], path: [exchange2_CELO_EURm] }
  * ]
  *
  * Step 1 - Build addrToSymbol map:
- *   cUSD.address → 'cUSD'
+ *   USDm.address → 'USDm'
  *   CELO.address → 'CELO'
- *   cEUR.address → 'cEUR'
+ *   EURm.address → 'EURm'
  *
  * Step 2 - Build directPathMap (sorted alphabetically for consistency):
- *   'CELO_addr-cEUR_addr' → exchange2_CELO_cEUR
- *   'CELO_addr-cUSD_addr' → exchange1_CELO_cUSD
+ *   'CELO_addr-EURm_addr' → exchange2_CELO_EURm
+ *   'CELO_addr-USDm_addr' → exchange1_CELO_USDm
  *
  * Step 3 - Build bidirectional tokenGraph:
- *   cUSD.address → Set([CELO.address])
- *   CELO.address → Set([cUSD.address, cEUR.address])
- *   cEUR.address → Set([CELO.address])
+ *   USDm.address → Set([CELO.address])
+ *   CELO.address → Set([USDm.address, EURm.address])
+ *   EURm.address → Set([CELO.address])
  * ```
  *
  * **Result**: We can now efficiently answer:
@@ -41,17 +41,17 @@ exports.hasSpreadData = exports.getIntermediateToken = exports.selectBestRoute =
  * @example
  * ```typescript
  * const directPairs = [
- *   { id: 'cUSD-CELO', assets: [cUSD, CELO], path: [exchange1] },
- *   { id: 'CELO-cEUR', assets: [CELO, cEUR], path: [exchange2] }
+ *   { id: 'USDm-CELO', assets: [USDm, CELO], path: [exchange1] },
+ *   { id: 'CELO-EURm', assets: [CELO, EURm], path: [exchange2] }
  * ]
  *
  * const connectivityData = buildConnectivityStructures(directPairs)
  *
  * // Now we can efficiently find routes:
- * // 1. Check if cUSD connects to anything: connectivityData.tokenGraph.get(cUSD.address) → [CELO.address]
- * // 2. Check if CELO connects to cEUR: connectivityData.tokenGraph.get(CELO.address) → [cUSD.address, cEUR.address] ✓
- * // 3. Get exchange details: connectivityData.directPathMap.get('CELO_addr-cEUR_addr') → exchange2_CELO_cEUR
- * // Result: Found route cUSD → CELO → cEUR with exchange details
+ * // 1. Check if USDm connects to anything: connectivityData.tokenGraph.get(USDm.address) → [CELO.address]
+ * // 2. Check if CELO connects to EURm: connectivityData.tokenGraph.get(CELO.address) → [USDm.address, EURm.address] ✓
+ * // 3. Get exchange details: connectivityData.directPathMap.get('CELO_addr-EURm_addr') → exchange2_CELO_EURm
+ * // Result: Found route USDm → CELO → EURm with exchange details
  * ```
  */
 function buildConnectivityStructures(directPairs) {
@@ -99,21 +99,21 @@ exports.buildConnectivityStructures = buildConnectivityStructures;
  * the best one based on spread data or heuristics.
  *
  * **Canonical Pair IDs**: All pairs use alphabetically sorted symbols
- * (e.g., 'cEUR-cUSD' not 'cUSD-cEUR') for consistent identification.
+ * (e.g., 'EURm-USDm' not 'USDm-EURm') for consistent identification.
  *
  * @param connectivityData - The connectivity data from buildConnectivityStructures()
  * @returns Map of pair ID -> array of possible routes for that pair
  *
  * @example
  * ```typescript
- * // Given direct pairs: cUSD-CELO, CELO-cEUR, cUSD-USDC
+ * // Given direct pairs: USDm-CELO, CELO-EURm, USDm-USDC
  * const allRoutes = generateAllRoutes(connectivityData)
  *
  * // Results might include:
- * // 'cUSD-CELO' -> [{ path: [cUSD->CELO] }] // direct route
- * // 'cEUR-cUSD' -> [
- * //   { path: [cUSD->USDC, USDC->cEUR] } // two-hop via USDC
- * //   { path: [cUSD->CELO, CELO->cEUR] } // two-hop via CELO
+ * // 'USDm-CELO' -> [{ path: [USDm->CELO] }] // direct route
+ * // 'EURm-USDm' -> [
+ * //   { path: [USDm->USDC, USDC->EURm] } // two-hop via USDC
+ * //   { path: [USDm->CELO, CELO->EURm] } // two-hop via CELO
  * // ]
  * ```
  */
@@ -129,23 +129,23 @@ function generateAllRoutes(connectivityData) {
     }
     // Step 2: Generate two-hop pairs using graph traversal
     // Algorithm: For each token, explore all paths of length 2
-    // OUTER LOOP: "For each starting token..." (e.g., cUSD, CELO, cEUR, etc.)
+    // OUTER LOOP: "For each starting token..." (e.g., USDm, CELO, EURm, etc.)
     for (const [start, neighbors] of tokenGraph.entries()) {
         // MIDDLE LOOP: "Where can I go from the starting token?" (first hop)
-        // Example: If start = cUSD, neighbors might be [CELO, USDC, cKES]
+        // Example: If start = USDm, neighbors might be [CELO, USDC, KESm]
         for (const intermediate of neighbors) {
             // Get all tokens reachable from this intermediate token (second hop destinations)
             const secondHopNeighbors = tokenGraph.get(intermediate);
             if (!secondHopNeighbors)
                 continue;
             // INNER LOOP: "From the intermediate token, where can I go?" (second hop)
-            // Example: If intermediate = CELO, secondHopNeighbors might be [cUSD, cEUR, cBRL]
+            // Example: If intermediate = CELO, secondHopNeighbors might be [USDm, EURm, BRLm]
             for (const end of secondHopNeighbors) {
-                // Skip circular routes like cUSD → CELO → cUSD (pointless)
+                // Skip circular routes like USDm → CELO → USDm (pointless)
                 if (end === start)
                     continue;
                 // At this point we have a potential route: start → intermediate → end
-                // Example: cUSD → CELO → cEUR
+                // Example: USDm → CELO → EURm
                 // Try to create a valid two-hop trading pair from this route
                 const twoHopPair = createTwoHopPair(start, intermediate, end, addrToSymbol, directPathMap);
                 // If we successfully created the pair, add it to our collection
@@ -184,22 +184,22 @@ exports.generateAllRoutes = generateAllRoutes;
  *
  * @example
  * ```typescript
- * // Create route: cUSD -> CELO -> cEUR
+ * // Create route: USDm -> CELO -> EURm
  * const pair = createTwoHopPair(
- *   '0x765D...', // cUSD address
+ *   '0x765D...', // USDm address
  *   '0x471E...', // CELO address
- *   '0xD876...', // cEUR address
+ *   '0xD876...', // EURm address
  *   addrToSymbol,
  *   directPathMap
  * )
  *
  * // Result:
  * // {
- * //   id: 'cEUR-cUSD',           // alphabetical order
- * //   assets: [cEUR, cUSD],     // alphabetical order
+ * //   id: 'EURm-USDm',           // alphabetical order
+ * //   assets: [EURm, USDm],     // alphabetical order
  * //   path: [                   // actual routing path
- * //     { cUSD->CELO exchange },
- * //     { CELO->cEUR exchange }
+ * //     { USDm->CELO exchange },
+ * //     { CELO->EURm exchange }
  * //   ]
  * // }
  * ```
@@ -255,17 +255,17 @@ exports.createTwoHopPair = createTwoHopPair;
  *
  * @example
  * ```typescript
- * // Multiple routes for cUSD-cEUR pair
+ * // Multiple routes for USDm-EURm pair
  * const candidates = new Map([
- *   ['cEUR-cUSD', [
- *     { path: [cUSD->CELO->cEUR], spreadData: { totalSpreadPercent: 0.5 } },
- *     { path: [cUSD->cREAL->cEUR], spreadData: { totalSpreadPercent: 0.3 } },
- *     { path: [cUSD->cEUR] } // direct route, no spread data
+ *   ['EURm-USDm', [
+ *     { path: [USDm->CELO->EURm], spreadData: { totalSpreadPercent: 0.5 } },
+ *     { path: [USDm->BRLm->EURm], spreadData: { totalSpreadPercent: 0.3 } },
+ *     { path: [USDm->EURm] } // direct route, no spread data
  *   ]]
  * ])
  *
  * const optimal = selectOptimalRoutes(candidates, false, assetMap)
- * // Returns the cUSD->cREAL->cEUR route (lowest spread: 0.3%)
+ * // Returns the USDm->BRLm->EURm route (lowest spread: 0.3%)
  * ```
  */
 function selectOptimalRoutes(allRoutes, returnAllRoutes, addrToSymbol) {
@@ -307,7 +307,7 @@ exports.selectOptimalRoutes = selectOptimalRoutes;
  *
  * **Tier 3 - Major Stablecoin Preference** (Final Fallback):
  * - For two-hop routes, prefer those going through major stablecoins
- * - Major FX currencies like cUSD and cEUR typically have better liquidity
+ * - Major FX currencies like USDm and EURm typically have better liquidity
  *
  * **Tier 4 - First Available** (Last Resort):
  * - If no other heuristics apply, use the first route found
@@ -341,7 +341,7 @@ function selectBestRoute(candidates, addrToSymbol) {
     if (directRoute)
         return directRoute;
     // Tier 3: Prefer routes through major stablecoins (better liquidity)
-    const stablecoins = ['cUSD', 'cEUR', 'USDC', 'USDT'];
+    const stablecoins = ['USDm', 'EURm', 'USDC', 'USDT'];
     const routeWithStablecoin = candidates.find((candidate) => {
         const intermediateToken = getIntermediateToken(candidate);
         if (!intermediateToken)

package/dist/esm/constants/tokens.11142220.js

@@ -1,5 +1,5 @@
 // This file is auto-generated. Do not edit manually.
-// Generated on 2025-12-10T13:15:03.083Z
+// Generated on 2025-12-16T15:12:28.475Z
 import { TokenSymbol } from '../mento';
 export const tokens11142220 = [
     {

package/dist/esm/constants/tokens.42220.js

@@ -1,7 +1,13 @@
 // This file is auto-generated. Do not edit manually.
-// Generated on 2025-11-06T15:50:03.777Z
+// Generated on 2025-12-16T15:12:19.767Z
 import { TokenSymbol } from '../mento';
 export const tokens42220 = [
+    {
+        address: '0x7175504C455076F15c04A2F90a8e352281F492F9',
+        symbol: TokenSymbol.AUDm,
+        name: 'Mento Australian Dollar',
+        decimals: 18,
+    },
     {
         address: '0x061cc5a2C863E0C1Cb404006D559dB18A34C762d',
         symbol: TokenSymbol.axlEUROC,
@@ -15,99 +21,75 @@ export const tokens42220 = [
         decimals: 6,
     },
     {
-        address: '0x7175504C455076F15c04A2F90a8e352281F492F9',
-        symbol: TokenSymbol.cAUD,
-        name: 'Celo Australian Dollar',
+        address: '0xe8537a3d056DA446677B9E9d6c5dB704EaAb4787',
+        symbol: TokenSymbol.BRLm,
+        name: 'Mento Brazilian Real',
         decimals: 18,
     },
     {
         address: '0xff4Ab19391af240c311c54200a492233052B6325',
-        symbol: TokenSymbol.cCAD,
-        name: 'Celo Canadian Dollar',
+        symbol: TokenSymbol.CADm,
+        name: 'Mento Canadian Dollar',
         decimals: 18,
     },
     {
-        address: '0xb55a79F398E759E43C95b979163f30eC87Ee131D',
-        symbol: TokenSymbol.cCHF,
-        name: 'Celo Swiss Franc',
+        address: '0x471EcE3750Da237f93B8E339c536989b8978a438',
+        symbol: TokenSymbol.CELO,
+        name: 'Celo native asset',
         decimals: 18,
     },
     {
-        address: '0x8A567e2aE79CA692Bd748aB832081C45de4041eA',
-        symbol: TokenSymbol.cCOP,
-        name: 'Celo Colombian Peso',
+        address: '0xb55a79F398E759E43C95b979163f30eC87Ee131D',
+        symbol: TokenSymbol.CHFm,
+        name: 'Mento Swiss Franc',
         decimals: 18,
     },
     {
-        address: '0x471EcE3750Da237f93B8E339c536989b8978a438',
-        symbol: TokenSymbol.CELO,
-        name: 'Celo native asset',
+        address: '0x8A567e2aE79CA692Bd748aB832081C45de4041eA',
+        symbol: TokenSymbol.COPm,
+        name: 'Mento Colombian Peso',
         decimals: 18,
     },
     {
         address: '0xD8763CBa276a3738E6DE85b4b3bF5FDed6D6cA73',
-        symbol: TokenSymbol.cEUR,
-        name: 'Celo Euro',
+        symbol: TokenSymbol.EURm,
+        name: 'Mento Euro',
         decimals: 18,
     },
     {
         address: '0xCCF663b1fF11028f0b19058d0f7B674004a40746',
-        symbol: TokenSymbol.cGBP,
-        name: 'Celo British Pound',
+        symbol: TokenSymbol.GBPm,
+        name: 'Mento British Pound',
         decimals: 18,
     },
     {
         address: '0xfAeA5F3404bbA20D3cc2f8C4B0A888F55a3c7313',
-        symbol: TokenSymbol.cGHS,
-        name: 'Celo Ghanaian Cedi',
+        symbol: TokenSymbol.GHSm,
+        name: 'Mento Ghanaian Cedi',
         decimals: 18,
     },
     {
         address: '0xc45eCF20f3CD864B32D9794d6f76814aE8892e20',
-        symbol: TokenSymbol.cJPY,
-        name: 'Celo Japanese Yen',
+        symbol: TokenSymbol.JPYm,
+        name: 'Mento Japanese Yen',
         decimals: 18,
     },
     {
         address: '0x456a3D042C0DbD3db53D5489e98dFb038553B0d0',
-        symbol: TokenSymbol.cKES,
-        name: 'Celo Kenyan Shilling',
+        symbol: TokenSymbol.KESm,
+        name: 'Mento Kenyan Shilling',
         decimals: 18,
     },
     {
         address: '0xE2702Bd97ee33c88c8f6f92DA3B733608aa76F71',
-        symbol: TokenSymbol.cNGN,
-        name: 'Celo Nigerian Naira',
-        decimals: 18,
-    },
-    {
-        address: '0xe8537a3d056DA446677B9E9d6c5dB704EaAb4787',
-        symbol: TokenSymbol.cREAL,
-        name: 'Celo Brazilian Real',
-        decimals: 18,
-    },
-    {
-        address: '0x765DE816845861e75A25fCA122bb6898B8B1282a',
-        symbol: TokenSymbol.cUSD,
-        name: 'Celo Dollar',
-        decimals: 18,
-    },
-    {
-        address: '0x4c35853A3B4e647fD266f4de678dCc8fEC410BF6',
-        symbol: TokenSymbol.cZAR,
-        name: 'Celo South African Rand',
-        decimals: 18,
-    },
-    {
-        address: '0x73F93dcc49cB8A239e2032663e9475dd5ef29A08',
-        symbol: TokenSymbol.eXOF,
-        name: 'ECO CFA',
+        symbol: TokenSymbol.NGNm,
+        name: 'Mento Nigerian Naira',
         decimals: 18,
     },
     {
         address: '0x105d4A9306D2E55a71d2Eb95B81553AE1dC20d7B',
-        symbol: TokenSymbol.PUSO,
-        name: 'PUSO',
+        symbol: TokenSymbol.PHPm,
+        name: 'Mento Philippine Peso',
         decimals: 18,
     },
     {
@@ -122,4 +104,22 @@ export const tokens42220 = [
         name: 'USDC',
         decimals: 6,
     },
+    {
+        address: '0x765DE816845861e75A25fCA122bb6898B8B1282a',
+        symbol: TokenSymbol.USDm,
+        name: 'Mento Dollar',
+        decimals: 18,
+    },
+    {
+        address: '0x73F93dcc49cB8A239e2032663e9475dd5ef29A08',
+        symbol: TokenSymbol.XOFm,
+        name: 'Mento West African CFA franc',
+        decimals: 18,
+    },
+    {
+        address: '0x4c35853A3B4e647fD266f4de678dCc8fEC410BF6',
+        symbol: TokenSymbol.ZARm,
+        name: 'Mento South African Rand',
+        decimals: 18,
+    },
 ];

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

@@ -33,28 +33,13 @@ export declare enum TokenSymbol {
     KESm = "KESm",
     NGNm = "NGNm",
     PHPm = "PHPm",
-    PUSO = "PUSO",
     USDC = "USDC",
     USDm = "USDm",
     USD_ = "USD\u20AE",
     XOFm = "XOFm",
     ZARm = "ZARm",
     axlEUROC = "axlEUROC",
-    axlUSDC = "axlUSDC",
-    cAUD = "cAUD",
-    cCAD = "cCAD",
-    cCHF = "cCHF",
-    cCOP = "cCOP",
-    cEUR = "cEUR",
-    cGBP = "cGBP",
-    cGHS = "cGHS",
-    cJPY = "cJPY",
-    cKES = "cKES",
-    cNGN = "cNGN",
-    cREAL = "cREAL",
-    cUSD = "cUSD",
-    cZAR = "cZAR",
-    eXOF = "eXOF"
+    axlUSDC = "axlUSDC"
 }
 /**
  * Token addresses mapped by chain ID and symbol