@xchainjs/xchain-mayachain-query 2.0.9 → 2.1.0

package/README.md

@@ -105,6 +105,36 @@ Estimation of Add Saver
 }
 ```
 
+## Trade Accounts
+
+Query trade account information and trade asset units:
+
+```ts
+import { MayachainQuery } from '@xchainjs/xchain-mayachain-query'
+import { assetFromStringEx, TradeAsset } from '@xchainjs/xchain-util'
+
+const mayachainQuery = new MayachainQuery()
+
+// Get trade asset units
+const tradeAsset = assetFromStringEx('ETH~ETH') as TradeAsset
+const units = await mayachainQuery.getTradeAssetUnits({ asset: tradeAsset })
+console.log(`Units: ${units.units.assetAmount.amount()}`)
+console.log(`Depth: ${units.depth.assetAmount.amount()}`)
+
+// Get all trade assets units
+const allUnits = await mayachainQuery.getTradeAssetsUnits()
+
+// Get trade accounts for an address
+const accounts = await mayachainQuery.getAddressTradeAccounts({ 
+  address: 'maya1...' 
+})
+
+// Get all accounts for a trade asset
+const assetAccounts = await mayachainQuery.getTradeAssetAccounts({ 
+  asset: tradeAsset 
+})
+```
+
 ## Documentation
 
 [`Overview `](https://dev.thorchain.org/thorchain-dev/xchainjs-integration-guide/query-package)

package/lib/index.esm.js

@@ -1,8 +1,8 @@
-import { assetFromStringEx, assetToString, baseAmount, CryptoAmount, CachedValue, AssetCryptoAmount, eqAsset, isSynthAsset, TRADE_ASSET_DELIMITER, SYNTH_ASSET_DELIMITER, TOKEN_ASSET_DELIMITER } from '@xchainjs/xchain-util';
+import { assetFromStringEx, assetToString, baseAmount, CryptoAmount, CachedValue, AssetCryptoAmount, eqAsset, isSynthAsset, TRADE_ASSET_DELIMITER, SYNTH_ASSET_DELIMITER, TradeCryptoAmount, TOKEN_ASSET_DELIMITER } from '@xchainjs/xchain-util';
 import { MidgardQuery } from '@xchainjs/xchain-mayamidgard-query';
 import BigNumber from 'bignumber.js';
 import { Network } from '@xchainjs/xchain-client';
-import { QuoteApi, Configuration, MimirApi, NetworkApi } from '@xchainjs/xchain-mayanode';
+import { QuoteApi, Configuration, MimirApi, NetworkApi, TradeUnitApi, TradeUnitsApi, TradeAccountApi, TradeAccountsApi } from '@xchainjs/xchain-mayanode';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
 
@@ -60,6 +60,10 @@ 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.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 })));
+        this.tradeAccountsApis = this.config.mayanodeBaseUrls.map((url) => new TradeAccountsApi(new Configuration({ basePath: url })));
         axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
     }
     /**
@@ -80,7 +84,9 @@ class Mayanode {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.quoteApis) {
                 try {
-                    return (yield api.quoteswap(height, fromAsset, toAsset, amount, destinationAddress, streamingInterval, streamingQuantity, toleranceBps, affiliateBps, affiliate)).data;
+                    return (yield api.quoteswap(height, fromAsset, toAsset, amount, destinationAddress, undefined, // refundAddress
+                    streamingInterval, streamingQuantity, toleranceBps, undefined, // liquidityToleranceBps
+                    affiliateBps === null || affiliateBps === void 0 ? void 0 : affiliateBps.toString(), affiliate)).data;
                 }
                 catch (e) { }
             }
@@ -134,6 +140,77 @@ class Mayanode {
             throw Error(`MAYANode not responding`);
         });
     }
+    /**
+     * Returns the total units and depth of a trade asset
+     * @param {string} asset Trade asset (e.g., ETH~ETH)
+     * @param {number} height Optional - Block height
+     * @returns Returns the total units and depth of a trade asset
+     */
+    getTradeAssetUnits(asset, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeUnitApis) {
+                try {
+                    const resp = (yield api.tradeUnit(asset, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get asset trade units`);
+        });
+    }
+    /**
+     * Returns the total units and depth for each trade asset
+     * @param {number} height Block height
+     * @returns Returns the total units and depth for each trade asset
+     */
+    getTradeAssetsUnits(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeUnitsApis) {
+                try {
+                    const resp = (yield api.tradeUnits(height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get trade units`);
+        });
+    }
+    /**
+     * Returns the units and depth of a trade account address
+     * @param {Address} address Maya address
+     * @param {number} height Optional - Block height
+     * @returns Returns the units and depth of a trade account
+     */
+    getTradeAssetAccount(address, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeAccountApis) {
+                try {
+                    const resp = (yield api.tradeAccount(address, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get trade asset account`);
+        });
+    }
+    /**
+     * Returns all trade accounts for an asset
+     * @param {string} asset Trade asset (e.g., ETH~ETH)
+     * @param {number} height Optional - Block height
+     * @returns Returns all trade accounts for an asset
+     */
+    getTradeAssetAccounts(asset, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeAccountsApis) {
+                try {
+                    const resp = (yield api.tradeAccounts(asset, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get trade asset accounts`);
+        });
+    }
 }
 
 const BtcAsset = assetFromStringEx('BTC.BTC');
@@ -322,6 +399,13 @@ class MayachainQuery {
         // Initialize MayachainCache instance
         this.mayachainCache = mayachainCache;
     }
+    /**
+     * Get the MayachainCache instance
+     * @returns MayachainCache instance
+     */
+    getMayachainCache() {
+        return this.mayachainCache;
+    }
     /**
      * Get the Mayachain network.
      * @returns
@@ -651,6 +735,81 @@ class MayachainQuery {
             };
         });
     }
+    /**
+     * Get trade asset units
+     * @param {TradeAssetUnitsParams} params Trade asset units params
+     * @returns {TradeAssetUnits} Trade asset units
+     */
+    getTradeAssetUnits(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ asset, height }) {
+            const assetString = assetToString(asset);
+            const response = yield this.mayachainCache.mayanode.getTradeAssetUnits(assetString, height);
+            return {
+                asset,
+                units: new TradeCryptoAmount(baseAmount(response.units), asset),
+                depth: new TradeCryptoAmount(baseAmount(response.depth), asset),
+            };
+        });
+    }
+    /**
+     * Get all trade assets units
+     * @param {TradeAssetsUnitsParams} params Trade assets units params
+     * @returns {TradeAssetUnits[]} Array of trade asset units
+     */
+    getTradeAssetsUnits() {
+        return __awaiter(this, arguments, void 0, function* ({ height } = {}) {
+            const response = yield this.mayachainCache.mayanode.getTradeAssetsUnits(height);
+            return response.map((item) => {
+                const asset = assetFromStringEx(item.asset);
+                return {
+                    asset,
+                    units: new TradeCryptoAmount(baseAmount(item.units), asset),
+                    depth: new TradeCryptoAmount(baseAmount(item.depth), asset),
+                };
+            });
+        });
+    }
+    /**
+     * Get trade accounts for an address
+     * @param {AddressTradeAccountsParams} params Address trade accounts params
+     * @returns {AddressTradeAccounts} Trade accounts for the address
+     */
+    getAddressTradeAccounts(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ address, height }) {
+            const response = yield this.mayachainCache.mayanode.getTradeAssetAccount(address, height);
+            return response.map((item) => {
+                const asset = assetFromStringEx(item.asset);
+                return {
+                    asset,
+                    units: new TradeCryptoAmount(baseAmount(item.units), asset),
+                    owner: item.owner,
+                    lastAddHeight: item.last_add_height,
+                    lastWithdrawHeight: item.last_withdraw_height,
+                };
+            });
+        });
+    }
+    /**
+     * Get all trade accounts for an asset
+     * @param {TradeAssetAccountsParams} params Trade asset accounts params
+     * @returns {TradeAssetAccounts} All trade accounts for the asset
+     */
+    getTradeAssetAccounts(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ asset, height }) {
+            const assetString = assetToString(asset);
+            const response = yield this.mayachainCache.mayanode.getTradeAssetAccounts(assetString, height);
+            return response.map((item) => {
+                const tradeAsset = assetFromStringEx(item.asset);
+                return {
+                    asset: tradeAsset,
+                    units: new TradeCryptoAmount(baseAmount(item.units), tradeAsset),
+                    owner: item.owner,
+                    lastAddHeight: item.last_add_height,
+                    lastWithdrawHeight: item.last_withdraw_height,
+                };
+            });
+        });
+    }
 }
 
 export { ArbAsset, ArbChain, BtcAsset, BtcChain, CacaoAsset, DEFAULT_MAYACHAIN_DECIMALS, DashAsset, DashChain, EthAsset, EthChain, KujiraAsset, KujiraChain, MayaChain, MayachainCache, MayachainQuery, Mayanode, RuneAsset, ThorChain, XdrAsset, XdrChain, ZecAsset, ZecChain, getBaseAmountWithDiffDecimals, getCryptoAmountWithNotation, isCacaoAsset };

package/lib/index.js

@@ -68,6 +68,10 @@ 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.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 })));
+        this.tradeAccountsApis = this.config.mayanodeBaseUrls.map((url) => new xchainMayanode.TradeAccountsApi(new xchainMayanode.Configuration({ basePath: url })));
         axiosRetry__default.default(axios__default.default, { retries: this.config.apiRetries, retryDelay: axiosRetry__default.default.exponentialDelay });
     }
     /**
@@ -88,7 +92,9 @@ class Mayanode {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.quoteApis) {
                 try {
-                    return (yield api.quoteswap(height, fromAsset, toAsset, amount, destinationAddress, streamingInterval, streamingQuantity, toleranceBps, affiliateBps, affiliate)).data;
+                    return (yield api.quoteswap(height, fromAsset, toAsset, amount, destinationAddress, undefined, // refundAddress
+                    streamingInterval, streamingQuantity, toleranceBps, undefined, // liquidityToleranceBps
+                    affiliateBps === null || affiliateBps === void 0 ? void 0 : affiliateBps.toString(), affiliate)).data;
                 }
                 catch (e) { }
             }
@@ -142,6 +148,77 @@ class Mayanode {
             throw Error(`MAYANode not responding`);
         });
     }
+    /**
+     * Returns the total units and depth of a trade asset
+     * @param {string} asset Trade asset (e.g., ETH~ETH)
+     * @param {number} height Optional - Block height
+     * @returns Returns the total units and depth of a trade asset
+     */
+    getTradeAssetUnits(asset, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeUnitApis) {
+                try {
+                    const resp = (yield api.tradeUnit(asset, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get asset trade units`);
+        });
+    }
+    /**
+     * Returns the total units and depth for each trade asset
+     * @param {number} height Block height
+     * @returns Returns the total units and depth for each trade asset
+     */
+    getTradeAssetsUnits(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeUnitsApis) {
+                try {
+                    const resp = (yield api.tradeUnits(height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get trade units`);
+        });
+    }
+    /**
+     * Returns the units and depth of a trade account address
+     * @param {Address} address Maya address
+     * @param {number} height Optional - Block height
+     * @returns Returns the units and depth of a trade account
+     */
+    getTradeAssetAccount(address, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeAccountApis) {
+                try {
+                    const resp = (yield api.tradeAccount(address, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get trade asset account`);
+        });
+    }
+    /**
+     * Returns all trade accounts for an asset
+     * @param {string} asset Trade asset (e.g., ETH~ETH)
+     * @param {number} height Optional - Block height
+     * @returns Returns all trade accounts for an asset
+     */
+    getTradeAssetAccounts(asset, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeAccountsApis) {
+                try {
+                    const resp = (yield api.tradeAccounts(asset, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`MAYANode not responding. Can not get trade asset accounts`);
+        });
+    }
 }
 
 const BtcAsset = xchainUtil.assetFromStringEx('BTC.BTC');
@@ -330,6 +407,13 @@ class MayachainQuery {
         // Initialize MayachainCache instance
         this.mayachainCache = mayachainCache;
     }
+    /**
+     * Get the MayachainCache instance
+     * @returns MayachainCache instance
+     */
+    getMayachainCache() {
+        return this.mayachainCache;
+    }
     /**
      * Get the Mayachain network.
      * @returns
@@ -659,6 +743,81 @@ class MayachainQuery {
             };
         });
     }
+    /**
+     * Get trade asset units
+     * @param {TradeAssetUnitsParams} params Trade asset units params
+     * @returns {TradeAssetUnits} Trade asset units
+     */
+    getTradeAssetUnits(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ asset, height }) {
+            const assetString = xchainUtil.assetToString(asset);
+            const response = yield this.mayachainCache.mayanode.getTradeAssetUnits(assetString, height);
+            return {
+                asset,
+                units: new xchainUtil.TradeCryptoAmount(xchainUtil.baseAmount(response.units), asset),
+                depth: new xchainUtil.TradeCryptoAmount(xchainUtil.baseAmount(response.depth), asset),
+            };
+        });
+    }
+    /**
+     * Get all trade assets units
+     * @param {TradeAssetsUnitsParams} params Trade assets units params
+     * @returns {TradeAssetUnits[]} Array of trade asset units
+     */
+    getTradeAssetsUnits() {
+        return __awaiter(this, arguments, void 0, function* ({ height } = {}) {
+            const response = yield this.mayachainCache.mayanode.getTradeAssetsUnits(height);
+            return response.map((item) => {
+                const asset = xchainUtil.assetFromStringEx(item.asset);
+                return {
+                    asset,
+                    units: new xchainUtil.TradeCryptoAmount(xchainUtil.baseAmount(item.units), asset),
+                    depth: new xchainUtil.TradeCryptoAmount(xchainUtil.baseAmount(item.depth), asset),
+                };
+            });
+        });
+    }
+    /**
+     * Get trade accounts for an address
+     * @param {AddressTradeAccountsParams} params Address trade accounts params
+     * @returns {AddressTradeAccounts} Trade accounts for the address
+     */
+    getAddressTradeAccounts(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ address, height }) {
+            const response = yield this.mayachainCache.mayanode.getTradeAssetAccount(address, height);
+            return response.map((item) => {
+                const asset = xchainUtil.assetFromStringEx(item.asset);
+                return {
+                    asset,
+                    units: new xchainUtil.TradeCryptoAmount(xchainUtil.baseAmount(item.units), asset),
+                    owner: item.owner,
+                    lastAddHeight: item.last_add_height,
+                    lastWithdrawHeight: item.last_withdraw_height,
+                };
+            });
+        });
+    }
+    /**
+     * Get all trade accounts for an asset
+     * @param {TradeAssetAccountsParams} params Trade asset accounts params
+     * @returns {TradeAssetAccounts} All trade accounts for the asset
+     */
+    getTradeAssetAccounts(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ asset, height }) {
+            const assetString = xchainUtil.assetToString(asset);
+            const response = yield this.mayachainCache.mayanode.getTradeAssetAccounts(assetString, height);
+            return response.map((item) => {
+                const tradeAsset = xchainUtil.assetFromStringEx(item.asset);
+                return {
+                    asset: tradeAsset,
+                    units: new xchainUtil.TradeCryptoAmount(xchainUtil.baseAmount(item.units), tradeAsset),
+                    owner: item.owner,
+                    lastAddHeight: item.last_add_height,
+                    lastWithdrawHeight: item.last_withdraw_height,
+                };
+            });
+        });
+    }
 }
 
 exports.ArbAsset = ArbAsset;

package/lib/mayachain-query.d.ts

@@ -2,7 +2,7 @@ import { Network } from '@xchainjs/xchain-client';
 import { PoolDetail } from '@xchainjs/xchain-mayamidgard';
 import { Address, AssetCryptoAmount } from '@xchainjs/xchain-util';
 import { MayachainCache } from './mayachain-cache';
-import { CompatibleAsset, InboundDetail, MAYANameDetails, QuoteMAYAName, QuoteMAYANameParams, QuoteSwap, QuoteSwapParams, SwapHistoryParams, SwapsHistory } from './types';
+import { AddressTradeAccounts, AddressTradeAccountsParams, CompatibleAsset, InboundDetail, MAYANameDetails, QuoteMAYAName, QuoteMAYANameParams, QuoteSwap, QuoteSwapParams, SwapHistoryParams, SwapsHistory, TradeAssetAccounts, TradeAssetAccountsParams, TradeAssetUnits, TradeAssetUnitsParams, TradeAssetsUnitsParams } from './types';
 /**
  * MAYAChain Class for interacting with MAYAChain.
  * Recommended main class to use for swapping with MAYAChain
@@ -17,6 +17,11 @@ export declare class MayachainQuery {
      * @returns MayachainAMM
      */
     constructor(mayachainCache?: MayachainCache);
+    /**
+     * Get the MayachainCache instance
+     * @returns MayachainCache instance
+     */
+    getMayachainCache(): MayachainCache;
     /**
      * Get the Mayachain network.
      * @returns
@@ -87,4 +92,28 @@ export declare class MayachainQuery {
      * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
      */
     estimateMAYAName({ name, owner, isUpdate, expiry, chain, chainAddress, }: QuoteMAYANameParams): Promise<QuoteMAYAName>;
+    /**
+     * Get trade asset units
+     * @param {TradeAssetUnitsParams} params Trade asset units params
+     * @returns {TradeAssetUnits} Trade asset units
+     */
+    getTradeAssetUnits({ asset, height }: TradeAssetUnitsParams): Promise<TradeAssetUnits>;
+    /**
+     * Get all trade assets units
+     * @param {TradeAssetsUnitsParams} params Trade assets units params
+     * @returns {TradeAssetUnits[]} Array of trade asset units
+     */
+    getTradeAssetsUnits({ height }?: TradeAssetsUnitsParams): Promise<TradeAssetUnits[]>;
+    /**
+     * Get trade accounts for an address
+     * @param {AddressTradeAccountsParams} params Address trade accounts params
+     * @returns {AddressTradeAccounts} Trade accounts for the address
+     */
+    getAddressTradeAccounts({ address, height }: AddressTradeAccountsParams): Promise<AddressTradeAccounts>;
+    /**
+     * Get all trade accounts for an asset
+     * @param {TradeAssetAccountsParams} params Trade asset accounts params
+     * @returns {TradeAssetAccounts} All trade accounts for the asset
+     */
+    getTradeAssetAccounts({ asset, height }: TradeAssetAccountsParams): Promise<TradeAssetAccounts>;
 }

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import { TxHash } from '@xchainjs/xchain-client';
-import { Address, Asset, AssetCryptoAmount, Chain, CryptoAmount, SynthAsset, TokenAsset } from '@xchainjs/xchain-util';
+import { Address, Asset, AssetCryptoAmount, Chain, CryptoAmount, SynthAsset, TokenAsset, TradeAsset, TradeCryptoAmount } from '@xchainjs/xchain-util';
 import type BigNumber from 'bignumber.js';
 export type CompatibleAsset = Asset | TokenAsset | SynthAsset;
 /**
@@ -239,3 +239,101 @@ export type QuoteMAYAName = {
      */
     value: AssetCryptoAmount;
 };
+/**
+ * Trade asset units parameters
+ */
+export type TradeAssetUnitsParams = {
+    /**
+     * Trade asset to get units for
+     */
+    asset: TradeAsset;
+    /**
+     * Optional block height
+     */
+    height?: number;
+};
+/**
+ * Trade asset units response
+ */
+export type TradeAssetUnits = {
+    /**
+     * Trade asset
+     */
+    asset: TradeAsset;
+    /**
+     * Total units of the trade asset
+     */
+    units: TradeCryptoAmount;
+    /**
+     * Total depth of the trade asset
+     */
+    depth: TradeCryptoAmount;
+};
+/**
+ * Trade assets units parameters
+ */
+export type TradeAssetsUnitsParams = {
+    /**
+     * Optional block height
+     */
+    height?: number;
+};
+/**
+ * Address trade accounts parameters
+ */
+export type AddressTradeAccountsParams = {
+    /**
+     * Maya address to get trade accounts for
+     */
+    address: Address;
+    /**
+     * Optional block height
+     */
+    height?: number;
+};
+/**
+ * Address trade account
+ */
+export type AddressTradeAccount = {
+    /**
+     * Trade asset
+     */
+    asset: TradeAsset;
+    /**
+     * Units of trade asset belonging to this owner
+     */
+    units: TradeCryptoAmount;
+    /**
+     * Maya address of trade account owner
+     */
+    owner: Address;
+    /**
+     * Last mayachain height trade assets were added
+     */
+    lastAddHeight?: number;
+    /**
+     * Last mayachain height trade assets were withdrawn
+     */
+    lastWithdrawHeight?: number;
+};
+/**
+ * Address trade accounts response
+ */
+export type AddressTradeAccounts = AddressTradeAccount[];
+/**
+ * Trade asset accounts parameters
+ */
+export type TradeAssetAccountsParams = {
+    /**
+     * Trade asset to get accounts for
+     */
+    asset: TradeAsset;
+    /**
+     * Optional block height
+     */
+    height?: number;
+};
+/**
+ * Trade asset accounts response
+ */
+export type TradeAssetAccounts = AddressTradeAccount[];

package/lib/utils/mayanode.d.ts

@@ -1,5 +1,6 @@
 import { Network } from '@xchainjs/xchain-client';
-import { InboundAddress, LastBlock, MimirResponse, QuoteSwapResponse } from '@xchainjs/xchain-mayanode';
+import { InboundAddress, LastBlock, MimirResponse, QuoteSwapResponse, TradeAccountsResponse, TradeUnitResponse, TradeUnitsResponse } from '@xchainjs/xchain-mayanode';
+import { Address } from '@xchainjs/xchain-util';
 export type MayanodeConfig = {
     apiRetries: number;
     mayanodeBaseUrls: string[];
@@ -10,6 +11,10 @@ export declare class Mayanode {
     private quoteApis;
     private mimirApis;
     private networkApis;
+    private tradeUnitApis;
+    private tradeUnitsApis;
+    private tradeAccountApis;
+    private tradeAccountsApis;
     constructor(network?: Network, config?: MayanodeConfig);
     /**
      * TODO
@@ -42,4 +47,31 @@ export declare class Mayanode {
      * @returns - last block data or block data pertaining to that height number
      */
     getLatestBlock(height?: number): Promise<LastBlock[]>;
+    /**
+     * Returns the total units and depth of a trade asset
+     * @param {string} asset Trade asset (e.g., ETH~ETH)
+     * @param {number} height Optional - Block height
+     * @returns Returns the total units and depth of a trade asset
+     */
+    getTradeAssetUnits(asset: string, height?: number): Promise<TradeUnitResponse>;
+    /**
+     * Returns the total units and depth for each trade asset
+     * @param {number} height Block height
+     * @returns Returns the total units and depth for each trade asset
+     */
+    getTradeAssetsUnits(height?: number): Promise<TradeUnitsResponse>;
+    /**
+     * Returns the units and depth of a trade account address
+     * @param {Address} address Maya address
+     * @param {number} height Optional - Block height
+     * @returns Returns the units and depth of a trade account
+     */
+    getTradeAssetAccount(address: Address, height?: number): Promise<TradeAccountsResponse>;
+    /**
+     * Returns all trade accounts for an asset
+     * @param {string} asset Trade asset (e.g., ETH~ETH)
+     * @param {number} height Optional - Block height
+     * @returns Returns all trade accounts for an asset
+     */
+    getTradeAssetAccounts(asset: string, height?: number): Promise<TradeAccountsResponse>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-mayachain-query",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "license": "MIT",
   "description": "Mayachain query module that is responsible for estimating swap calculations and add/remove liquidity for thorchain",
   "keywords": [
@@ -33,10 +33,10 @@
     "postversion": "git push --follow-tags"
   },
   "dependencies": {
-    "@xchainjs/xchain-client": "2.0.7",
+    "@xchainjs/xchain-client": "2.0.8",
     "@xchainjs/xchain-mayamidgard": "1.0.4",
-    "@xchainjs/xchain-mayamidgard-query": "1.0.8",
-    "@xchainjs/xchain-mayanode": "1.0.4",
+    "@xchainjs/xchain-mayamidgard-query": "1.0.9",
+    "@xchainjs/xchain-mayanode": "1.1.0",
     "@xchainjs/xchain-util": "2.0.4",
     "axios": "1.8.4",
     "axios-retry": "3.2.5",