@xchainjs/xchain-mayachain-query 2.1.1 → 2.1.2

package/lib/index.esm.js

@@ -2,7 +2,7 @@ import { assetFromStringEx, assetToString, baseAmount, CryptoAmount, CachedValue
 import { MidgardQuery } from '@xchainjs/xchain-mayamidgard-query';
 import BigNumber from 'bignumber.js';
 import { Network } from '@xchainjs/xchain-client';
-import { QuoteApi, Configuration, MimirApi, NetworkApi, TradeUnitApi, TradeUnitsApi, TradeAccountApi, TradeAccountsApi } from '@xchainjs/xchain-mayanode';
+import { QuoteApi, Configuration, MimirApi, NetworkApi, PoolsApi, TradeUnitApi, TradeUnitsApi, TradeAccountApi, TradeAccountsApi } from '@xchainjs/xchain-mayanode';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
 
@@ -60,6 +60,7 @@ class Mayanode {
         this.quoteApis = this.config.mayanodeBaseUrls.map((url) => new QuoteApi(new Configuration({ basePath: url })));
         this.mimirApis = this.config.mayanodeBaseUrls.map((url) => new MimirApi(new Configuration({ basePath: url })));
         this.networkApis = this.config.mayanodeBaseUrls.map((url) => new NetworkApi(new Configuration({ basePath: url })));
+        this.poolsApis = this.config.mayanodeBaseUrls.map((url) => new PoolsApi(new Configuration({ basePath: url })));
         this.tradeUnitApis = this.config.mayanodeBaseUrls.map((url) => new TradeUnitApi(new Configuration({ basePath: url })));
         this.tradeUnitsApis = this.config.mayanodeBaseUrls.map((url) => new TradeUnitsApi(new Configuration({ basePath: url })));
         this.tradeAccountApis = this.config.mayanodeBaseUrls.map((url) => new TradeAccountApi(new Configuration({ basePath: url })));
@@ -211,6 +212,22 @@ class Mayanode {
             throw new Error(`MAYANode not responding. Can not get trade asset accounts`);
         });
     }
+    /**
+     * Get all available pools.
+     * @param height - optional MAYAChain height, default, latest block
+     * @returns pool data
+     */
+    getPools(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.poolsApis) {
+                try {
+                    return (yield api.pools(height)).data;
+                }
+                catch (_e) { }
+            }
+            throw new Error(`MAYANode not responding`);
+        });
+    }
 }
 
 const BtcAsset = assetFromStringEx('BTC.BTC');
@@ -245,6 +262,10 @@ const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
 const getCryptoAmountWithNotation = (amount, notation) => {
     const inputAmountBaseNotation = amount.baseAmount.amount();
     const decimalsDiff = notation - amount.baseAmount.decimal;
+    // Ensure we don't create negative decimals
+    if (notation < 0) {
+        throw new Error(`Invalid notation: ${notation}. Decimals cannot be negative.`);
+    }
     return new CryptoAmount(baseAmount(inputAmountBaseNotation.times(Math.pow(10, decimalsDiff)), notation), amount.asset);
 };
 
@@ -291,14 +312,29 @@ class MayachainCache {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.assetDecimalsCache)
                 throw Error(`Could not refresh assets decimals`);
-            return yield this.assetDecimalsCache.getValue();
+            try {
+                return yield this.assetDecimalsCache.getValue();
+            }
+            catch (error) {
+                // Fallback: if cache refresh fails (e.g., Mayamidgard is down), use static fallback
+                console.warn('Maya asset decimals cache refresh failed, using static fallback:', error);
+                return this.getFallbackAssetDecimals();
+            }
         });
     }
     getPools() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.poolsCache)
                 throw Error(`Could not refresh pools cache`);
-            return yield this.poolsCache.getValue();
+            try {
+                return yield this.poolsCache.getValue();
+            }
+            catch (error) {
+                // If pools cache fails to refresh (e.g., Mayamidgard is down), throw the error
+                // The calling code should handle this gracefully with optimistic fallbacks
+                console.warn('Maya pools cache refresh failed:', error);
+                throw error;
+            }
         });
     }
     /**
@@ -356,29 +392,117 @@ class MayachainCache {
      */
     refreshAssetDecimalsCache() {
         return __awaiter(this, void 0, void 0, function* () {
-            // Implementation details for refreshing the asset decimals cache
-            // TODO: As soon as Mayachain returns native decimals from any endpoint of its API, refactor the function
-            return {
-                'BTC.BTC': 8,
-                'ETH.ETH': 18,
-                'DASH.DASH': 8,
-                'KUJI.KUJI': 6,
-                'THOR.RUNE': 8,
-                'MAYA.CACAO': 10,
-                'ETH.USDT-0xdAC17F958D2ee523a2206206994597C13D831ec7': 6,
-                'ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 6,
-                'ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0': 18,
-                'KUJI.USK': 6,
-            };
+            try {
+                // Try to get pool data and extract decimals if available
+                const pools = yield this.midgardQuery.getPools();
+                const decimals = {};
+                for (const pool of pools) {
+                    if (pool.nativeDecimal) {
+                        const decimal = Number(pool.nativeDecimal);
+                        // Only use the decimal value if it's a valid positive number
+                        if (decimal >= 0) {
+                            decimals[pool.asset] = decimal;
+                        }
+                    }
+                }
+                // Merge with fallback data for assets that don't have native decimals specified
+                return Object.assign(Object.assign({}, this.getFallbackAssetDecimals()), decimals);
+            }
+            catch (error) {
+                console.warn('Failed to refresh Maya asset decimals from pools, using fallback:', error);
+                return this.getFallbackAssetDecimals();
+            }
         });
     }
+    /**
+     * Provides fallback decimal values for Maya assets when Mayamidgard is unavailable.
+     * Data sourced from https://mayanode.mayachain.info/mayachain/pools
+     * Updated with live pool data as of latest fetch
+     */
+    getFallbackAssetDecimals() {
+        return {
+            // Current Maya pools with verified decimals from Mayanode
+            'BTC.BTC': 8,
+            'ARB.USDC-0xaf88d065e77c8cC2239327C5EDb3A432268e5831': 6,
+            'ARB.USDT-0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9': 6,
+            'ARB.LEO-0x5985D2Dc68E67aeE82F4e30e8e74F1ea8e532a3c': 3,
+            'ARB.TGT-0X429FED88F10285E61B12BDF00848315FBDFCC341': 18,
+            'ARB.TGT-0x429FED88F10285E61B12BDF00848315FBDFCC341': 18,
+            'ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 6,
+            'ETH.USDT-0xdAC17F958D2ee523a2206206994597C13D831ec7': 6,
+            'KUJI.KUJI': 6,
+            'KUJI.USK': 6,
+            'THOR.RUNE': 8,
+            // Chain defaults for native assets
+            'ETH.ETH': 18,
+            'ARB.ETH': 18,
+            'MAYA.CACAO': 10,
+            // Additional pool assets (using chain defaults where decimals not specified)
+            'DASH.DASH': 8,
+            'XDR.XDR': 18,
+            'ZEC.ZEC': 8,
+            // Legacy mappings for backward compatibility
+            'ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0': 18,
+        };
+    }
     /**
      * Refreshes the Pools cache
      * @returns {PoolDetail[]} the list of pools
      */
     refreshPoolsCache() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.midgardQuery.getPools();
+            try {
+                // Try Mayanode first (like THORChain uses Thornode first)
+                const mayanodePools = yield this.mayanode.getPools();
+                return this.convertMayanodePoolsToMidgardFormat(mayanodePools);
+            }
+            catch (error) {
+                console.warn('Mayanode pools unavailable, falling back to Mayamidgard:', error);
+                // Fallback to Midgard like before
+                return this.midgardQuery.getPools();
+            }
+        });
+    }
+    /**
+     * Convert Mayanode pool format to Midgard PoolDetail format
+     * @param pools - Pools from Mayanode API
+     * @returns PoolDetail array compatible with Midgard format
+     */
+    convertMayanodePoolsToMidgardFormat(pools) {
+        return pools.map((pool) => {
+            var _a;
+            // Get the fallback decimal for this asset if available
+            const fallbackDecimals = this.getFallbackAssetDecimals();
+            const nativeDecimal = ((_a = fallbackDecimals[pool.asset]) === null || _a === void 0 ? void 0 : _a.toString()) || '8';
+            // Calculate units from liquidityUnits and synthUnits
+            const liquidityUnits = pool.LP_units;
+            const synthUnits = '0';
+            return {
+                // Core pool data from Mayanode
+                asset: pool.asset,
+                assetDepth: pool.balance_asset,
+                runeDepth: pool.balance_cacao,
+                liquidityUnits,
+                status: 'available', // Assume available if returned by Mayanode
+                // Calculated fields
+                assetPrice: pool.balance_cacao && pool.balance_asset
+                    ? (parseFloat(pool.balance_cacao) / parseFloat(pool.balance_asset)).toString()
+                    : '0',
+                // Required fields with appropriate defaults
+                annualPercentageRate: '0',
+                assetPriceUSD: '0',
+                nativeDecimal,
+                poolAPY: '0',
+                saversAPR: '0',
+                saversDepth: '0',
+                saversUnits: '0',
+                synthSupply: '0',
+                synthUnits,
+                totalCollateral: '0',
+                totalDebtTor: '0',
+                units: new BigNumber(liquidityUnits || '0').plus(new BigNumber(synthUnits)).toString(),
+                volume24h: '0',
+            };
         });
     }
 }
@@ -572,12 +696,41 @@ class MayachainQuery {
             if (isSynthAsset(asset))
                 return DEFAULT_MAYACHAIN_DECIMALS;
             const assetNotation = assetToString(asset);
-            const assetsDecimals = yield this.mayachainCache.getAssetDecimals();
-            if (!assetsDecimals[assetNotation])
-                throw Error(`Can not get decimals for ${assetNotation}`);
-            return assetsDecimals[assetNotation];
+            try {
+                const assetsDecimals = yield this.mayachainCache.getAssetDecimals();
+                if (assetsDecimals[assetNotation]) {
+                    return assetsDecimals[assetNotation];
+                }
+                // Fallback for unknown assets: use chain defaults
+                console.warn(`No decimal mapping found for ${assetNotation}, using chain default`);
+                return this.getChainDefaultDecimals(asset.chain);
+            }
+            catch (error) {
+                // Fallback if asset decimals cache fails entirely
+                console.warn(`Failed to get asset decimals for ${assetNotation}, using chain default:`, error);
+                return this.getChainDefaultDecimals(asset.chain);
+            }
         });
     }
+    /**
+     * Get default decimal places for a chain when specific asset data is unavailable
+     * @param chain - The chain to get default decimals for
+     * @returns Default decimal places for the chain
+     */
+    getChainDefaultDecimals(chain) {
+        const chainDefaults = {
+            BTC: 8,
+            ETH: 18,
+            ARB: 18,
+            KUJI: 6,
+            THOR: 8,
+            MAYA: 10,
+            DASH: 8,
+            XDR: 18,
+            ZEC: 8,
+        };
+        return chainDefaults[chain] || 8; // Ultimate fallback to 8 decimals
+    }
     /**
      * Get pools details
      * @returns {PoolDetail[]} pools details
@@ -603,10 +756,12 @@ class MayachainQuery {
             const poolDetails = yield this.mayachainCache.getPools();
             const getCryptoAmount = (assetDecimals, asset, amount) => {
                 const decimals = asset in assetDecimals ? assetDecimals[asset] : DEFAULT_MAYACHAIN_DECIMALS;
+                // Ensure decimals is valid (not negative or undefined)
+                const validDecimals = typeof decimals === 'number' && decimals >= 0 ? decimals : DEFAULT_MAYACHAIN_DECIMALS;
                 const assetFormatted = assetFromStringEx(asset);
-                return decimals === DEFAULT_MAYACHAIN_DECIMALS || eqAsset(CacaoAsset, assetFormatted)
-                    ? new CryptoAmount(baseAmount(amount, decimals), assetFormatted)
-                    : getCryptoAmountWithNotation(new CryptoAmount(baseAmount(amount), assetFormatted), decimals);
+                return validDecimals === DEFAULT_MAYACHAIN_DECIMALS || eqAsset(CacaoAsset, assetFormatted)
+                    ? new CryptoAmount(baseAmount(amount, validDecimals), assetFormatted)
+                    : getCryptoAmountWithNotation(new CryptoAmount(baseAmount(amount), assetFormatted), validDecimals);
             };
             return {
                 count: actionsResume.count ? Number(actionsResume.count) : 0,

package/lib/index.js

@@ -68,6 +68,7 @@ class Mayanode {
         this.quoteApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.QuoteApi(new xchainMayanode.Configuration({ basePath: url })));
         this.mimirApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.MimirApi(new xchainMayanode.Configuration({ basePath: url })));
         this.networkApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.NetworkApi(new xchainMayanode.Configuration({ basePath: url })));
+        this.poolsApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.PoolsApi(new xchainMayanode.Configuration({ basePath: url })));
         this.tradeUnitApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.TradeUnitApi(new xchainMayanode.Configuration({ basePath: url })));
         this.tradeUnitsApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.TradeUnitsApi(new xchainMayanode.Configuration({ basePath: url })));
         this.tradeAccountApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.TradeAccountApi(new xchainMayanode.Configuration({ basePath: url })));
@@ -219,6 +220,22 @@ class Mayanode {
             throw new Error(`MAYANode not responding. Can not get trade asset accounts`);
         });
     }
+    /**
+     * Get all available pools.
+     * @param height - optional MAYAChain height, default, latest block
+     * @returns pool data
+     */
+    getPools(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.poolsApis) {
+                try {
+                    return (yield api.pools(height)).data;
+                }
+                catch (_e) { }
+            }
+            throw new Error(`MAYANode not responding`);
+        });
+    }
 }
 
 const BtcAsset = xchainUtil.assetFromStringEx('BTC.BTC');
@@ -253,6 +270,10 @@ const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
 const getCryptoAmountWithNotation = (amount, notation) => {
     const inputAmountBaseNotation = amount.baseAmount.amount();
     const decimalsDiff = notation - amount.baseAmount.decimal;
+    // Ensure we don't create negative decimals
+    if (notation < 0) {
+        throw new Error(`Invalid notation: ${notation}. Decimals cannot be negative.`);
+    }
     return new xchainUtil.CryptoAmount(xchainUtil.baseAmount(inputAmountBaseNotation.times(Math.pow(10, decimalsDiff)), notation), amount.asset);
 };
 
@@ -299,14 +320,29 @@ class MayachainCache {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.assetDecimalsCache)
                 throw Error(`Could not refresh assets decimals`);
-            return yield this.assetDecimalsCache.getValue();
+            try {
+                return yield this.assetDecimalsCache.getValue();
+            }
+            catch (error) {
+                // Fallback: if cache refresh fails (e.g., Mayamidgard is down), use static fallback
+                console.warn('Maya asset decimals cache refresh failed, using static fallback:', error);
+                return this.getFallbackAssetDecimals();
+            }
         });
     }
     getPools() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.poolsCache)
                 throw Error(`Could not refresh pools cache`);
-            return yield this.poolsCache.getValue();
+            try {
+                return yield this.poolsCache.getValue();
+            }
+            catch (error) {
+                // If pools cache fails to refresh (e.g., Mayamidgard is down), throw the error
+                // The calling code should handle this gracefully with optimistic fallbacks
+                console.warn('Maya pools cache refresh failed:', error);
+                throw error;
+            }
         });
     }
     /**
@@ -364,29 +400,117 @@ class MayachainCache {
      */
     refreshAssetDecimalsCache() {
         return __awaiter(this, void 0, void 0, function* () {
-            // Implementation details for refreshing the asset decimals cache
-            // TODO: As soon as Mayachain returns native decimals from any endpoint of its API, refactor the function
-            return {
-                'BTC.BTC': 8,
-                'ETH.ETH': 18,
-                'DASH.DASH': 8,
-                'KUJI.KUJI': 6,
-                'THOR.RUNE': 8,
-                'MAYA.CACAO': 10,
-                'ETH.USDT-0xdAC17F958D2ee523a2206206994597C13D831ec7': 6,
-                'ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 6,
-                'ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0': 18,
-                'KUJI.USK': 6,
-            };
+            try {
+                // Try to get pool data and extract decimals if available
+                const pools = yield this.midgardQuery.getPools();
+                const decimals = {};
+                for (const pool of pools) {
+                    if (pool.nativeDecimal) {
+                        const decimal = Number(pool.nativeDecimal);
+                        // Only use the decimal value if it's a valid positive number
+                        if (decimal >= 0) {
+                            decimals[pool.asset] = decimal;
+                        }
+                    }
+                }
+                // Merge with fallback data for assets that don't have native decimals specified
+                return Object.assign(Object.assign({}, this.getFallbackAssetDecimals()), decimals);
+            }
+            catch (error) {
+                console.warn('Failed to refresh Maya asset decimals from pools, using fallback:', error);
+                return this.getFallbackAssetDecimals();
+            }
         });
     }
+    /**
+     * Provides fallback decimal values for Maya assets when Mayamidgard is unavailable.
+     * Data sourced from https://mayanode.mayachain.info/mayachain/pools
+     * Updated with live pool data as of latest fetch
+     */
+    getFallbackAssetDecimals() {
+        return {
+            // Current Maya pools with verified decimals from Mayanode
+            'BTC.BTC': 8,
+            'ARB.USDC-0xaf88d065e77c8cC2239327C5EDb3A432268e5831': 6,
+            'ARB.USDT-0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9': 6,
+            'ARB.LEO-0x5985D2Dc68E67aeE82F4e30e8e74F1ea8e532a3c': 3,
+            'ARB.TGT-0X429FED88F10285E61B12BDF00848315FBDFCC341': 18,
+            'ARB.TGT-0x429FED88F10285E61B12BDF00848315FBDFCC341': 18,
+            'ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': 6,
+            'ETH.USDT-0xdAC17F958D2ee523a2206206994597C13D831ec7': 6,
+            'KUJI.KUJI': 6,
+            'KUJI.USK': 6,
+            'THOR.RUNE': 8,
+            // Chain defaults for native assets
+            'ETH.ETH': 18,
+            'ARB.ETH': 18,
+            'MAYA.CACAO': 10,
+            // Additional pool assets (using chain defaults where decimals not specified)
+            'DASH.DASH': 8,
+            'XDR.XDR': 18,
+            'ZEC.ZEC': 8,
+            // Legacy mappings for backward compatibility
+            'ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0': 18,
+        };
+    }
     /**
      * Refreshes the Pools cache
      * @returns {PoolDetail[]} the list of pools
      */
     refreshPoolsCache() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.midgardQuery.getPools();
+            try {
+                // Try Mayanode first (like THORChain uses Thornode first)
+                const mayanodePools = yield this.mayanode.getPools();
+                return this.convertMayanodePoolsToMidgardFormat(mayanodePools);
+            }
+            catch (error) {
+                console.warn('Mayanode pools unavailable, falling back to Mayamidgard:', error);
+                // Fallback to Midgard like before
+                return this.midgardQuery.getPools();
+            }
+        });
+    }
+    /**
+     * Convert Mayanode pool format to Midgard PoolDetail format
+     * @param pools - Pools from Mayanode API
+     * @returns PoolDetail array compatible with Midgard format
+     */
+    convertMayanodePoolsToMidgardFormat(pools) {
+        return pools.map((pool) => {
+            var _a;
+            // Get the fallback decimal for this asset if available
+            const fallbackDecimals = this.getFallbackAssetDecimals();
+            const nativeDecimal = ((_a = fallbackDecimals[pool.asset]) === null || _a === void 0 ? void 0 : _a.toString()) || '8';
+            // Calculate units from liquidityUnits and synthUnits
+            const liquidityUnits = pool.LP_units;
+            const synthUnits = '0';
+            return {
+                // Core pool data from Mayanode
+                asset: pool.asset,
+                assetDepth: pool.balance_asset,
+                runeDepth: pool.balance_cacao,
+                liquidityUnits,
+                status: 'available', // Assume available if returned by Mayanode
+                // Calculated fields
+                assetPrice: pool.balance_cacao && pool.balance_asset
+                    ? (parseFloat(pool.balance_cacao) / parseFloat(pool.balance_asset)).toString()
+                    : '0',
+                // Required fields with appropriate defaults
+                annualPercentageRate: '0',
+                assetPriceUSD: '0',
+                nativeDecimal,
+                poolAPY: '0',
+                saversAPR: '0',
+                saversDepth: '0',
+                saversUnits: '0',
+                synthSupply: '0',
+                synthUnits,
+                totalCollateral: '0',
+                totalDebtTor: '0',
+                units: new BigNumber__default.default(liquidityUnits || '0').plus(new BigNumber__default.default(synthUnits)).toString(),
+                volume24h: '0',
+            };
         });
     }
 }
@@ -580,12 +704,41 @@ class MayachainQuery {
             if (xchainUtil.isSynthAsset(asset))
                 return DEFAULT_MAYACHAIN_DECIMALS;
             const assetNotation = xchainUtil.assetToString(asset);
-            const assetsDecimals = yield this.mayachainCache.getAssetDecimals();
-            if (!assetsDecimals[assetNotation])
-                throw Error(`Can not get decimals for ${assetNotation}`);
-            return assetsDecimals[assetNotation];
+            try {
+                const assetsDecimals = yield this.mayachainCache.getAssetDecimals();
+                if (assetsDecimals[assetNotation]) {
+                    return assetsDecimals[assetNotation];
+                }
+                // Fallback for unknown assets: use chain defaults
+                console.warn(`No decimal mapping found for ${assetNotation}, using chain default`);
+                return this.getChainDefaultDecimals(asset.chain);
+            }
+            catch (error) {
+                // Fallback if asset decimals cache fails entirely
+                console.warn(`Failed to get asset decimals for ${assetNotation}, using chain default:`, error);
+                return this.getChainDefaultDecimals(asset.chain);
+            }
         });
     }
+    /**
+     * Get default decimal places for a chain when specific asset data is unavailable
+     * @param chain - The chain to get default decimals for
+     * @returns Default decimal places for the chain
+     */
+    getChainDefaultDecimals(chain) {
+        const chainDefaults = {
+            BTC: 8,
+            ETH: 18,
+            ARB: 18,
+            KUJI: 6,
+            THOR: 8,
+            MAYA: 10,
+            DASH: 8,
+            XDR: 18,
+            ZEC: 8,
+        };
+        return chainDefaults[chain] || 8; // Ultimate fallback to 8 decimals
+    }
     /**
      * Get pools details
      * @returns {PoolDetail[]} pools details
@@ -611,10 +764,12 @@ class MayachainQuery {
             const poolDetails = yield this.mayachainCache.getPools();
             const getCryptoAmount = (assetDecimals, asset, amount) => {
                 const decimals = asset in assetDecimals ? assetDecimals[asset] : DEFAULT_MAYACHAIN_DECIMALS;
+                // Ensure decimals is valid (not negative or undefined)
+                const validDecimals = typeof decimals === 'number' && decimals >= 0 ? decimals : DEFAULT_MAYACHAIN_DECIMALS;
                 const assetFormatted = xchainUtil.assetFromStringEx(asset);
-                return decimals === DEFAULT_MAYACHAIN_DECIMALS || xchainUtil.eqAsset(CacaoAsset, assetFormatted)
-                    ? new xchainUtil.CryptoAmount(xchainUtil.baseAmount(amount, decimals), assetFormatted)
-                    : getCryptoAmountWithNotation(new xchainUtil.CryptoAmount(xchainUtil.baseAmount(amount), assetFormatted), decimals);
+                return validDecimals === DEFAULT_MAYACHAIN_DECIMALS || xchainUtil.eqAsset(CacaoAsset, assetFormatted)
+                    ? new xchainUtil.CryptoAmount(xchainUtil.baseAmount(amount, validDecimals), assetFormatted)
+                    : getCryptoAmountWithNotation(new xchainUtil.CryptoAmount(xchainUtil.baseAmount(amount), assetFormatted), validDecimals);
             };
             return {
                 count: actionsResume.count ? Number(actionsResume.count) : 0,

package/lib/mayachain-cache.d.ts

@@ -46,9 +46,21 @@ export declare class MayachainCache {
      * Refreshes the number of decimals of the supported Mayachain tokens.
      */
     private refreshAssetDecimalsCache;
+    /**
+     * Provides fallback decimal values for Maya assets when Mayamidgard is unavailable.
+     * Data sourced from https://mayanode.mayachain.info/mayachain/pools
+     * Updated with live pool data as of latest fetch
+     */
+    private getFallbackAssetDecimals;
     /**
      * Refreshes the Pools cache
      * @returns {PoolDetail[]} the list of pools
      */
     private refreshPoolsCache;
+    /**
+     * Convert Mayanode pool format to Midgard PoolDetail format
+     * @param pools - Pools from Mayanode API
+     * @returns PoolDetail array compatible with Midgard format
+     */
+    private convertMayanodePoolsToMidgardFormat;
 }

package/lib/mayachain-query.d.ts

@@ -67,6 +67,12 @@ export declare class MayachainQuery {
      * @throws {Error} if the asset is not supported in Mayachain
      */
     getAssetDecimals(asset: CompatibleAsset): Promise<number>;
+    /**
+     * Get default decimal places for a chain when specific asset data is unavailable
+     * @param chain - The chain to get default decimals for
+     * @returns Default decimal places for the chain
+     */
+    private getChainDefaultDecimals;
     /**
      * Get pools details
      * @returns {PoolDetail[]} pools details

package/lib/utils/mayanode.d.ts

@@ -1,5 +1,5 @@
 import { Network } from '@xchainjs/xchain-client';
-import { InboundAddress, LastBlock, MimirResponse, QuoteSwapResponse, TradeAccountsResponse, TradeUnitResponse, TradeUnitsResponse } from '@xchainjs/xchain-mayanode';
+import { InboundAddress, LastBlock, MimirResponse, PoolsResponse, QuoteSwapResponse, TradeAccountsResponse, TradeUnitResponse, TradeUnitsResponse } from '@xchainjs/xchain-mayanode';
 import { Address } from '@xchainjs/xchain-util';
 export type MayanodeConfig = {
     apiRetries: number;
@@ -11,6 +11,7 @@ export declare class Mayanode {
     private quoteApis;
     private mimirApis;
     private networkApis;
+    private poolsApis;
     private tradeUnitApis;
     private tradeUnitsApis;
     private tradeAccountApis;
@@ -74,4 +75,10 @@ export declare class Mayanode {
      * @returns Returns all trade accounts for an asset
      */
     getTradeAssetAccounts(asset: string, height?: number): Promise<TradeAccountsResponse>;
+    /**
+     * Get all available pools.
+     * @param height - optional MAYAChain height, default, latest block
+     * @returns pool data
+     */
+    getPools(height?: number): Promise<PoolsResponse>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-mayachain-query",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "license": "MIT",
   "description": "Mayachain query module that is responsible for estimating swap calculations and add/remove liquidity for thorchain",
   "keywords": [