@xchainjs/xchain-mayachain-amm 2.0.10 → 2.0.12

package/README.md

@@ -1,70 +1,73 @@
-# `@xchainjs/xchain-mayachain-amm`
+<div align="center">
+  <h1 align="center">MAYAChain AMM</h1>
 
-## Modules
+  <p align="center">
+    <a href='https://www.npmjs.com/package/@xchainjs/xchain-mayachain-amm' target='_blank'>
+      <img alt="NPM Version" src="https://img.shields.io/npm/v/%40xchainjs%2Fxchain-mayachain-amm" />
+    </a>
+      <a href='https://www.npmjs.com/package/@xchainjs/xchain-mayachain-amm' target='_blank'>
+      <img alt="NPM Downloads" src="https://img.shields.io/npm/d18m/%40xchainjs%2Fxchain-mayachain-amm" />
+    </a>
+  </p>
+</div>
 
-Mayachain AMM module
+<br />
+
+
+MAYAChain AMM is a module that allows users and developers to interact with the MAYAChain protocol without having to worry about the underlining particularities of the protocol.
 
 ## Installation
 
-```
+```sh
 yarn add @xchainjs/xchain-mayachain-amm
 ```
 
-Following peer dependencies have to be installed into your project. These are not included in `@xchainjs/xchain-mayachain-amm`.
-
-```bash
-  "dependencies": {
-    "@cosmos-client/core": "0.46.1",
-    "@psf/bitcoincashjs-lib": "^4.0.3",
-    "@xchainjs/xchain-bitcoin": "^0.23.6",
-    "@xchainjs/xchain-client": "^0.15.4",
-    "@xchainjs/xchain-cosmos-sdk": "^0.1.3",
-    "@xchainjs/xchain-crypto": "^0.3.0",
-    "@xchainjs/xchain-dash": "^0.2.5",
-    "@xchainjs/xchain-ethereum": "^0.31.1",
-    "@xchainjs/xchain-mayanode": "^0.1.2",
-    "@xchainjs/xchain-mayachain-query": "^0.1.0",
-    "@xchainjs/xchain-evm": "^0.4.1",
-    "@xchainjs/xchain-kujira": "^0.1.2",
-    "@xchainjs/xchain-mayachain": "^0.2.10",
-    "@xchainjs/xchain-mayamidgard": "^0.1.0",
-    "@xchainjs/xchain-thorchain": "^0.28.13",
-    "@xchainjs/xchain-util": "^0.13.1",
-    "@xchainjs/xchain-utxo-providers": "^0.2.8",
-    "axios": "^1.3.6",
-    "axios-retry": "^3.2.5",
-    "bignumber.js": "^9.0.0",
-    "bitcoinjs-lib": "5.2.0",
-    "coininfo": "^5.1.0",
-    "coinselect": "^3.1.12",
-    "dotenv": "^16.0.0",
-    "ethers": "^5.6.6",
-    "wif": "^2.0.6"
-  }
+or 
 
-```
+```sh
+npm install @xchainjs/xchain-mayachain-amm
 
-## For live examples
+```
 
+## Initialization
 
-## Documentation
+Using Mayachain AMM, you can initialize the main class of the module in consultation mode if you do not provide any parameters, this means you could retrieve information from the protocol, but you will not be able to make actions the protocol needs you to sign.
 
+```ts
+  import { MayachainAMM } from '@xchainjs/xchain-mayachain-amm'
 
-## Compiler options
+  const mayachainAmm = new MayachainAMM()
+```
 
-tsconfig compiler options
+Otherwise, if you want to be able make actions the protocol needs you to sign, you will need to initialize the main class of the protocol as follows
 
 ```ts
-{
-    "compilerOptions": {
-        "module":"commonjs",
-        "target": "es5",
-        "noEmitOnError": true,
-        "resolveJsonModule": true,
-        "esModuleInterop": true,
-        "lib": ["es6", "dom", "es2016", "es2017"]
-    }
-}
+  import { MayachainAMM } from '@xchainjs/xchain-mayachain-amm'
+  import { MayachainQuery } from '@xchainjs/xchain-mayachain-query'
+  import { Wallet } from '@xchainjs/xchain-wallet'
+
+  const mayaChainQuery = new MayachainQuery()
+  const wallet = new Wallet({
+    // Your XChainJS clients
+  })
+  const mayachainAmm = new MayachainAMM(mayaChainQuery, wallet)
 ```
 
-### Setting environment variables
+## Features
+
+Using MAYAChain AMM package, you could easily implement the following features
+
+### Swaps
+
+- Estimate swaps
+- Do swaps
+- Approve MAYAChain router to spend to be able to do ERC-20 swaps
+
+### MAYANames
+
+- Get MAYAName details
+- Get MAYANames by owner
+
+## Examples
+
+You can find examples using the MAYAChain AMM package in the [mayachain-amm](https://github.com/xchainjs/xchainjs-lib/tree/master/examples/mayachain-amm) examples folder.

package/lib/index.esm.js

@@ -1,14 +1,15 @@
-import { Client, defaultBTCParams } from '@xchainjs/xchain-bitcoin';
+import { AssetAETH, Client as Client$6, defaultArbParams } from '@xchainjs/xchain-arbitrum';
+import { BTCChain, Client as Client$5, defaultBTCParams } from '@xchainjs/xchain-bitcoin';
 import { Network } from '@xchainjs/xchain-client';
-import { Client as Client$2, defaultDashParams } from '@xchainjs/xchain-dash';
-import { Client as Client$1, defaultEthParams, AssetETH as AssetETH$1 } from '@xchainjs/xchain-ethereum';
+import { DASHChain, Client as Client$3, defaultDashParams } from '@xchainjs/xchain-dash';
+import { AssetETH as AssetETH$1, ETHChain, Client as Client$4, defaultEthParams } from '@xchainjs/xchain-ethereum';
 import 'crypto';
 import require$$0$4$1 from 'buffer';
 import { ethers } from 'ethers';
-import { Client as Client$3, defaultKujiParams } from '@xchainjs/xchain-kujira';
-import { Client as Client$5, MAYAChain } from '@xchainjs/xchain-mayachain';
+import { KUJIChain, Client as Client$2, defaultKujiParams, AssetKUJI } from '@xchainjs/xchain-kujira';
+import { MAYAChain, Client, AssetCacao, CACAO_DECIMAL } from '@xchainjs/xchain-mayachain';
 import { MayachainQuery } from '@xchainjs/xchain-mayachain-query';
-import { Client as Client$4 } from '@xchainjs/xchain-thorchain';
+import { THORChain, Client as Client$1, AssetRuneNative } from '@xchainjs/xchain-thorchain';
 import { Wallet as Wallet$1 } from '@xchainjs/xchain-wallet';
 
 /******************************************************************************
@@ -89526,6 +89527,148 @@ const abi = {
     erc20: erc20ABI, // ERC20 ABI
 };
 
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+const isProtocolEVMChain = (chain) => {
+    return [AssetETH$1.chain, AssetAETH.chain].includes(chain);
+};
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+const isProtocolERC20Asset = (asset) => {
+    return isProtocolEVMChain(asset.chain)
+        ? [AssetETH$1, AssetAETH].findIndex((nativeEVMAsset) => eqAsset(nativeEVMAsset, asset)) === -1 && !asset.synth
+        : false;
+};
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+const isProtocolBFTChain = (chain) => {
+    return [AssetKUJI.chain, AssetRuneNative.chain].includes(chain);
+};
+const validateAddress = (network, chain, address) => {
+    switch (chain) {
+        case BTCChain:
+            return new Client$5(Object.assign(Object.assign({}, defaultBTCParams), { network })).validateAddress(address);
+        case ETHChain:
+            return new Client$4(Object.assign(Object.assign({}, defaultEthParams), { network })).validateAddress(address);
+        case DASHChain:
+            return new Client$3(Object.assign(Object.assign({}, defaultDashParams), { network })).validateAddress(address);
+        case KUJIChain:
+            return new Client$2(Object.assign(Object.assign({}, defaultKujiParams), { network })).validateAddress(address);
+        case THORChain:
+            return new Client$1({ network }).validateAddress(address);
+        case MAYAChain:
+            return new Client({ network }).validateAddress(address);
+        default:
+            throw Error('Unsupported chain');
+    }
+};
+
+class MayachainAction {
+    static makeAction(actionParams) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            return this.isNonProtocolParams(actionParams)
+                ? this.makeNonProtocolAction(actionParams)
+                : this.makeProtocolAction(actionParams);
+        });
+    }
+    static makeProtocolAction({ wallet, assetAmount, memo }) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const hash = yield wallet.deposit({
+                chain: MAYAChain,
+                asset: assetAmount.asset,
+                amount: assetAmount.baseAmount,
+                memo,
+            });
+            return {
+                hash,
+                url: yield wallet.getExplorerTxUrl(MAYAChain, hash),
+            };
+        });
+    }
+    static makeNonProtocolAction({ wallet, assetAmount, recipient, memo, }) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            // Non EVM actions
+            if (!isProtocolEVMChain(assetAmount.asset.chain)) {
+                if (isProtocolBFTChain(assetAmount.asset.chain)) {
+                    const hash = yield wallet.transfer({
+                        asset: assetAmount.asset,
+                        amount: assetAmount.baseAmount,
+                        recipient,
+                        memo,
+                    });
+                    return {
+                        hash,
+                        url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+                    };
+                }
+                const feeRates = yield wallet.getFeeRates(assetAmount.asset.chain);
+                const hash = yield wallet.transfer({
+                    asset: assetAmount.asset,
+                    amount: assetAmount.baseAmount,
+                    recipient,
+                    memo,
+                    feeRate: feeRates.fast,
+                });
+                return {
+                    hash,
+                    url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+                };
+            }
+            // EVM actions
+            const mayachainQuery = new MayachainQuery();
+            const inboundDetails = yield mayachainQuery.getChainInboundDetails(assetAmount.asset.chain);
+            if (!inboundDetails.router)
+                throw Error(`Unknown router for ${assetAmount.asset.chain} chain`);
+            const isERC20 = isProtocolERC20Asset(assetAmount.asset);
+            const checkSummedContractAddress = isERC20
+                ? ethers.utils.getAddress(getContractAddressFromAsset(assetAmount.asset))
+                : ethers.constants.AddressZero;
+            const expiration = Math.floor(new Date(new Date().getTime() + 15 * 60000).getTime() / 1000);
+            const depositParams = [
+                recipient,
+                checkSummedContractAddress,
+                assetAmount.baseAmount.amount().toFixed(),
+                memo,
+                expiration,
+            ];
+            const routerContract = new ethers.Contract(inboundDetails.router, abi.router);
+            const gasPrices = yield wallet.getFeeRates(assetAmount.asset.chain);
+            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams);
+            const nativeAsset = wallet.getAssetInfo(assetAmount.asset.chain);
+            const hash = yield wallet.transfer({
+                asset: nativeAsset.asset,
+                amount: isERC20 ? baseAmount(0, nativeAsset.decimal) : assetAmount.baseAmount,
+                memo: unsignedTx.data,
+                recipient: inboundDetails.router,
+                gasPrice: gasPrices.fast,
+                isMemoEncoded: true,
+                gasLimit: ethers.BigNumber.from(160000),
+            });
+            return {
+                hash,
+                url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+            };
+        });
+    }
+    static isNonProtocolParams(params) {
+        if ((params.assetAmount.asset.chain === MAYAChain || params.assetAmount.asset.synth) &&
+            'address' in params &&
+            !!params.address) {
+            throw Error('Inconsistent params. Native actions do not support recipient');
+        }
+        return params.assetAmount.asset.chain !== MAYAChain && !params.assetAmount.asset.synth;
+    }
+}
+
 /**
  * Mayachain Automated Market Maker (AMM) class.
  * MAYAChainAMM class for interacting with THORChain.
@@ -89541,12 +89684,13 @@ class MayachainAMM {
      * @returns {MayachainAMM} Returns the MayachainAMM instance.
      */
     constructor(mayachainQuery = new MayachainQuery(), wallet = new Wallet$1({
-        BTC: new Client(Object.assign(Object.assign({}, defaultBTCParams), { network: Network.Mainnet })),
-        ETH: new Client$1(Object.assign(Object.assign({}, defaultEthParams), { network: Network.Mainnet })),
-        DASH: new Client$2(Object.assign(Object.assign({}, defaultDashParams), { network: Network.Mainnet })),
-        KUJI: new Client$3(Object.assign(Object.assign({}, defaultKujiParams), { network: Network.Mainnet })),
-        THOR: new Client$4({ network: Network.Mainnet }),
-        MAYA: new Client$5({ network: Network.Mainnet }),
+        BTC: new Client$5(Object.assign(Object.assign({}, defaultBTCParams), { network: Network.Mainnet })),
+        ETH: new Client$4(Object.assign(Object.assign({}, defaultEthParams), { network: Network.Mainnet })),
+        DASH: new Client$3(Object.assign(Object.assign({}, defaultDashParams), { network: Network.Mainnet })),
+        KUJI: new Client$2(Object.assign(Object.assign({}, defaultKujiParams), { network: Network.Mainnet })),
+        ARB: new Client$6(Object.assign(Object.assign({}, defaultArbParams), { network: Network.Mainnet })),
+        THOR: new Client$1({ network: Network.Mainnet }),
+        MAYA: new Client({ network: Network.Mainnet }),
     })) {
         this.mayachainQuery = mayachainQuery;
         this.wallet = wallet;
@@ -89613,12 +89757,12 @@ class MayachainAMM {
             const errors = [];
             // Validate destination address if provided
             if (destinationAddress &&
-                !this.wallet.validateAddress(destinationAsset.synth ? MAYAChain : destinationAsset.chain, destinationAddress)) {
+                !validateAddress(this.mayachainQuery.getNetwork(), destinationAsset.synth ? MAYAChain : destinationAsset.chain, destinationAddress)) {
                 errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
             }
             // Validate affiliate address if provided
             if (affiliateAddress) {
-                const isMayaAddress = this.wallet.validateAddress(MAYAChain, affiliateAddress);
+                const isMayaAddress = validateAddress(this.mayachainQuery.getNetwork(), MAYAChain, affiliateAddress);
                 const isMayaName = yield this.isMAYAName(affiliateAddress);
                 if (!(isMayaAddress || isMayaName))
                     errors.push(`affiliateAddress ${affiliateAddress} is not a valid MAYA address`);
@@ -89628,7 +89772,7 @@ class MayachainAMM {
                 errors.push(`affiliateBps ${affiliateBps} out of range [0 - 10000]`);
             }
             // Validate approval if asset is an ERC20 token and fromAddress is provided
-            if (this.isERC20Asset(fromAsset) && fromAddress) {
+            if (isProtocolERC20Asset(fromAsset) && fromAddress) {
                 const approveErrors = yield this.isRouterApprovedToSpend({
                     asset: fromAsset,
                     address: fromAddress,
@@ -89659,10 +89803,12 @@ class MayachainAMM {
             // Check if the swap can be performed
             if (!quoteSwap.canSwap)
                 throw Error(`Can not swap. ${quoteSwap.errors.join(' ')}`);
-            // Perform the swap based on the asset chain
-            return fromAsset.chain === MAYAChain || fromAsset.synth
-                ? this.doProtocolAssetSwap(amount, quoteSwap.memo)
-                : this.doNonProtocolAssetSwap(amount, quoteSwap.toAddress, quoteSwap.memo);
+            return MayachainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: amount,
+                memo: quoteSwap.memo,
+                recipient: `${quoteSwap.toAddress}`,
+            });
         });
     }
     /**
@@ -89705,107 +89851,147 @@ class MayachainAMM {
         });
     }
     /**
-     * Check if a name is a valid MAYAName
-     * @param {string} name MAYAName to check
-     * @returns {boolean} True if the name is registered as a MAYAName, otherwise false
+     * Get MAYAname details
+     * @param {string} MAYAName
+     * @returns {MAYANameDetails | undefined} MAYANames details or undefined it is does not exist
      */
-    isMAYAName(name) {
+    getMAYANameDetails(MAYAName) {
         return __awaiter$8(this, void 0, void 0, function* () {
-            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
+            return this.mayachainQuery.getMAYANameDetails(MAYAName);
         });
     }
     /**
-     * Perform a swap from a native protocol asset to any other asset
-     * @param {CryptoAmount} amount Amount to swap
-     * @param {string} memo Memo to add to the transaction
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     * Get the MAYANames owned by an address
+     * @param {Address} owner - Thorchain address
+     * @returns {MAYANameDetails[]} List of MAYANames owned by the address
      */
-    doProtocolAssetSwap(amount, memo) {
+    getMAYANamesByOwner(owner) {
         return __awaiter$8(this, void 0, void 0, function* () {
-            // Deposit the amount and return transaction hash and URL
-            const hash = yield this.wallet.deposit({ chain: MAYAChain, asset: amount.asset, amount: amount.baseAmount, memo });
-            return {
-                hash,
-                url: yield this.wallet.getExplorerTxUrl(MAYAChain, hash),
-            };
+            return this.mayachainQuery.getMAYANamesByOwner(owner);
         });
     }
     /**
-     * Perform a swap between assets
-     * @param {CryptoAmount} amount Amount to swap
-     * @param {string} memo Memo to add to the transaction to successfully make the swap
-     * @param {string} recipient inbound address to make swap transaction to
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     * Estimate the cost of a MAYAName registration
+     * @param {RegisterMAYAName} params Params to make the registration
+     * @returns {QuoteMAYAName} Memo to make the registration and the estimation of the operation
      */
-    doNonProtocolAssetSwap(amount, recipient, memo) {
+    estimateMAYANameRegistration(params) {
         return __awaiter$8(this, void 0, void 0, function* () {
-            // For non-EVM assets, perform a transfer and return transaction hash and URL
-            if (!this.isEVMChain(amount.asset.chain)) {
-                const hash = yield this.wallet.transfer({
-                    asset: amount.asset,
-                    amount: amount.baseAmount,
-                    recipient,
-                    memo,
-                });
+            const errors = [];
+            if (!validateAddress(this.mayachainQuery.getNetwork(), params.chain, params.chainAddress)) {
+                errors.push(`Invalid address ${params.chainAddress} for ${params.chain} chain`);
+            }
+            if (!validateAddress(this.mayachainQuery.getNetwork(), MAYAChain, params.owner)) {
+                errors.push(`Invalid owner ${params.owner} due it is not a MAYAChain address`);
+            }
+            if (errors.length) {
                 return {
-                    hash,
-                    url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
+                    memo: '',
+                    errors,
+                    value: new CryptoAmount(baseAmount(0, CACAO_DECIMAL), AssetCacao),
+                    allowed: false,
                 };
             }
-            // For EVM assets, perform a deposit with expiry and return transaction hash and URL
-            const inboundDetails = yield this.mayachainQuery.getChainInboundDetails(amount.asset.chain);
-            if (!inboundDetails.router)
-                throw Error(`Unknown router for ${amount.asset.chain} chain`);
-            const isERC20 = this.isERC20Asset(amount.asset);
-            const checkSummedContractAddress = isERC20
-                ? ethers.utils.getAddress(getContractAddressFromAsset(amount.asset))
-                : ethers.constants.AddressZero;
-            const expiration = Math.floor(new Date(new Date().getTime() + 15 * 60000).getTime() / 1000);
-            const depositParams = [
-                recipient,
-                checkSummedContractAddress,
-                amount.baseAmount.amount().toFixed(),
-                memo,
-                expiration,
-            ];
-            const routerContract = new ethers.Contract(inboundDetails.router, abi.router);
-            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams);
-            const gasPrices = yield this.wallet.getGasFeeRates(amount.asset.chain);
-            const nativeAsset = this.wallet.getAssetInfo(amount.asset.chain);
-            const hash = yield this.wallet.transfer({
-                asset: nativeAsset.asset,
-                amount: isERC20 ? baseAmount(0, nativeAsset.decimal) : amount.baseAmount,
-                memo: unsignedTx.data,
-                recipient: inboundDetails.router,
-                gasPrice: gasPrices.fast,
-                isMemoEncoded: true,
-                gasLimit: ethers.BigNumber.from(160000),
+            try {
+                const estimated = yield this.mayachainQuery.estimateMAYAName(Object.assign({}, params));
+                return Object.assign(Object.assign({}, estimated), { allowed: true, errors: [] });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                return {
+                    memo: '',
+                    errors: ['message' in e ? e.message : `Unknown error: ${e}`],
+                    value: new CryptoAmount(baseAmount(0, CACAO_DECIMAL), AssetCacao),
+                    allowed: false,
+                };
+            }
+        });
+    }
+    /**
+     * Estimate the cost of an update of a MAYAName
+     * @param {QuoteMAYANameParams} params Params to make the update
+     * @returns {QuoteMAYAName} Memo to make the update and the estimation of the operation
+     */
+    estimateMAYANameUpdate(params) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const errors = [];
+            if ((params.chain && !params.chainAddress) || (!params.chain && params.chainAddress)) {
+                errors.push(`Alias not provided correctly`);
+            }
+            if (params.chain &&
+                params.chainAddress &&
+                !validateAddress(this.mayachainQuery.getNetwork(), params.chain, params.chainAddress)) {
+                errors.push(`Invalid alias ${params.chainAddress} for ${params.chain} chain`);
+            }
+            if (params.owner && !validateAddress(this.mayachainQuery.getNetwork(), MAYAChain, params.owner)) {
+                errors.push(`Invalid owner ${params.owner} due it is not a MAYAChain address`);
+            }
+            if (errors.length) {
+                return {
+                    memo: '',
+                    errors,
+                    value: new CryptoAmount(baseAmount(0, CACAO_DECIMAL), AssetCacao),
+                    allowed: false,
+                };
+            }
+            try {
+                const estimated = yield this.mayachainQuery.estimateMAYAName(Object.assign(Object.assign({}, params), { isUpdate: true }));
+                return Object.assign(Object.assign({}, estimated), { allowed: true, errors: [] });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                return {
+                    memo: '',
+                    errors: ['message' in e ? e.message : `Unknown error: ${e}`],
+                    value: new CryptoAmount(baseAmount(0, CACAO_DECIMAL), AssetCacao),
+                    allowed: false,
+                };
+            }
+        });
+    }
+    /**
+     * Register a MAYAName
+     * @param {RegisterMAYAName} params Params to make the registration
+     * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
+     */
+    registerMAYAName(params) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const quote = yield this.estimateMAYANameRegistration(params);
+            if (!quote.allowed)
+                throw Error(`Can not register MAYAName. ${quote.errors.join(' ')}`);
+            return MayachainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
             });
-            return {
-                hash,
-                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
-            };
         });
     }
     /**
-     * Check if the asset is an ERC20 token
-     * @param {Asset} asset Asset to check
-     * @returns True if the asset is an ERC20 token, otherwise false
+     * Update a MAYAName
+     * @param {QuoteMAYANameParams} params Params to make the update
+     * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
      */
-    isERC20Asset(asset) {
-        // Check if the asset's chain is an EVM chain and if the symbol matches AssetETH.symbol
-        return this.isEVMChain(asset.chain)
-            ? [AssetETH$1].findIndex((nativeEVMAsset) => eqAsset(nativeEVMAsset, asset)) === -1 && !asset.synth
-            : false;
+    updateMAYAName(params) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const quote = yield this.estimateMAYANameUpdate(params);
+            if (!quote.allowed)
+                throw Error(`Can not update MAYAName. ${quote.errors.join(' ')}`);
+            return MayachainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
+            });
+        });
     }
     /**
-     * Check if the chain is an EVM (Ethereum Virtual Machine) chain
-     * @param {Chain} chain Chain to check
-     * @returns True if the chain is an EVM chain, otherwise false
+     * Check if a name is a valid MAYAName
+     * @param {string} name MAYAName to check
+     * @returns {boolean} True if the name is registered as a MAYAName, otherwise false
      */
-    isEVMChain(chain) {
-        // Check if the chain matches AssetETH.chain
-        return [AssetETH$1.chain].includes(chain);
+    isMAYAName(name) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
+        });
     }
 }
 

package/lib/index.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var xchainArbitrum = require('@xchainjs/xchain-arbitrum');
 var xchainBitcoin = require('@xchainjs/xchain-bitcoin');
 var xchainClient = require('@xchainjs/xchain-client');
 var xchainDash = require('@xchainjs/xchain-dash');
@@ -89534,6 +89535,148 @@ const abi = {
     erc20: erc20ABI, // ERC20 ABI
 };
 
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+const isProtocolEVMChain = (chain) => {
+    return [xchainEthereum.AssetETH.chain, xchainArbitrum.AssetAETH.chain].includes(chain);
+};
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+const isProtocolERC20Asset = (asset) => {
+    return isProtocolEVMChain(asset.chain)
+        ? [xchainEthereum.AssetETH, xchainArbitrum.AssetAETH].findIndex((nativeEVMAsset) => eqAsset(nativeEVMAsset, asset)) === -1 && !asset.synth
+        : false;
+};
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+const isProtocolBFTChain = (chain) => {
+    return [xchainKujira.AssetKUJI.chain, xchainThorchain.AssetRuneNative.chain].includes(chain);
+};
+const validateAddress = (network, chain, address) => {
+    switch (chain) {
+        case xchainBitcoin.BTCChain:
+            return new xchainBitcoin.Client(Object.assign(Object.assign({}, xchainBitcoin.defaultBTCParams), { network })).validateAddress(address);
+        case xchainEthereum.ETHChain:
+            return new xchainEthereum.Client(Object.assign(Object.assign({}, xchainEthereum.defaultEthParams), { network })).validateAddress(address);
+        case xchainDash.DASHChain:
+            return new xchainDash.Client(Object.assign(Object.assign({}, xchainDash.defaultDashParams), { network })).validateAddress(address);
+        case xchainKujira.KUJIChain:
+            return new xchainKujira.Client(Object.assign(Object.assign({}, xchainKujira.defaultKujiParams), { network })).validateAddress(address);
+        case xchainThorchain.THORChain:
+            return new xchainThorchain.Client({ network }).validateAddress(address);
+        case xchainMayachain.MAYAChain:
+            return new xchainMayachain.Client({ network }).validateAddress(address);
+        default:
+            throw Error('Unsupported chain');
+    }
+};
+
+class MayachainAction {
+    static makeAction(actionParams) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            return this.isNonProtocolParams(actionParams)
+                ? this.makeNonProtocolAction(actionParams)
+                : this.makeProtocolAction(actionParams);
+        });
+    }
+    static makeProtocolAction({ wallet, assetAmount, memo }) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const hash = yield wallet.deposit({
+                chain: xchainMayachain.MAYAChain,
+                asset: assetAmount.asset,
+                amount: assetAmount.baseAmount,
+                memo,
+            });
+            return {
+                hash,
+                url: yield wallet.getExplorerTxUrl(xchainMayachain.MAYAChain, hash),
+            };
+        });
+    }
+    static makeNonProtocolAction({ wallet, assetAmount, recipient, memo, }) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            // Non EVM actions
+            if (!isProtocolEVMChain(assetAmount.asset.chain)) {
+                if (isProtocolBFTChain(assetAmount.asset.chain)) {
+                    const hash = yield wallet.transfer({
+                        asset: assetAmount.asset,
+                        amount: assetAmount.baseAmount,
+                        recipient,
+                        memo,
+                    });
+                    return {
+                        hash,
+                        url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+                    };
+                }
+                const feeRates = yield wallet.getFeeRates(assetAmount.asset.chain);
+                const hash = yield wallet.transfer({
+                    asset: assetAmount.asset,
+                    amount: assetAmount.baseAmount,
+                    recipient,
+                    memo,
+                    feeRate: feeRates.fast,
+                });
+                return {
+                    hash,
+                    url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+                };
+            }
+            // EVM actions
+            const mayachainQuery = new xchainMayachainQuery.MayachainQuery();
+            const inboundDetails = yield mayachainQuery.getChainInboundDetails(assetAmount.asset.chain);
+            if (!inboundDetails.router)
+                throw Error(`Unknown router for ${assetAmount.asset.chain} chain`);
+            const isERC20 = isProtocolERC20Asset(assetAmount.asset);
+            const checkSummedContractAddress = isERC20
+                ? ethers.ethers.utils.getAddress(getContractAddressFromAsset(assetAmount.asset))
+                : ethers.ethers.constants.AddressZero;
+            const expiration = Math.floor(new Date(new Date().getTime() + 15 * 60000).getTime() / 1000);
+            const depositParams = [
+                recipient,
+                checkSummedContractAddress,
+                assetAmount.baseAmount.amount().toFixed(),
+                memo,
+                expiration,
+            ];
+            const routerContract = new ethers.ethers.Contract(inboundDetails.router, abi.router);
+            const gasPrices = yield wallet.getFeeRates(assetAmount.asset.chain);
+            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams);
+            const nativeAsset = wallet.getAssetInfo(assetAmount.asset.chain);
+            const hash = yield wallet.transfer({
+                asset: nativeAsset.asset,
+                amount: isERC20 ? baseAmount(0, nativeAsset.decimal) : assetAmount.baseAmount,
+                memo: unsignedTx.data,
+                recipient: inboundDetails.router,
+                gasPrice: gasPrices.fast,
+                isMemoEncoded: true,
+                gasLimit: ethers.ethers.BigNumber.from(160000),
+            });
+            return {
+                hash,
+                url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+            };
+        });
+    }
+    static isNonProtocolParams(params) {
+        if ((params.assetAmount.asset.chain === xchainMayachain.MAYAChain || params.assetAmount.asset.synth) &&
+            'address' in params &&
+            !!params.address) {
+            throw Error('Inconsistent params. Native actions do not support recipient');
+        }
+        return params.assetAmount.asset.chain !== xchainMayachain.MAYAChain && !params.assetAmount.asset.synth;
+    }
+}
+
 /**
  * Mayachain Automated Market Maker (AMM) class.
  * MAYAChainAMM class for interacting with THORChain.
@@ -89553,6 +89696,7 @@ class MayachainAMM {
         ETH: new xchainEthereum.Client(Object.assign(Object.assign({}, xchainEthereum.defaultEthParams), { network: xchainClient.Network.Mainnet })),
         DASH: new xchainDash.Client(Object.assign(Object.assign({}, xchainDash.defaultDashParams), { network: xchainClient.Network.Mainnet })),
         KUJI: new xchainKujira.Client(Object.assign(Object.assign({}, xchainKujira.defaultKujiParams), { network: xchainClient.Network.Mainnet })),
+        ARB: new xchainArbitrum.Client(Object.assign(Object.assign({}, xchainArbitrum.defaultArbParams), { network: xchainClient.Network.Mainnet })),
         THOR: new xchainThorchain.Client({ network: xchainClient.Network.Mainnet }),
         MAYA: new xchainMayachain.Client({ network: xchainClient.Network.Mainnet }),
     })) {
@@ -89621,12 +89765,12 @@ class MayachainAMM {
             const errors = [];
             // Validate destination address if provided
             if (destinationAddress &&
-                !this.wallet.validateAddress(destinationAsset.synth ? xchainMayachain.MAYAChain : destinationAsset.chain, destinationAddress)) {
+                !validateAddress(this.mayachainQuery.getNetwork(), destinationAsset.synth ? xchainMayachain.MAYAChain : destinationAsset.chain, destinationAddress)) {
                 errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
             }
             // Validate affiliate address if provided
             if (affiliateAddress) {
-                const isMayaAddress = this.wallet.validateAddress(xchainMayachain.MAYAChain, affiliateAddress);
+                const isMayaAddress = validateAddress(this.mayachainQuery.getNetwork(), xchainMayachain.MAYAChain, affiliateAddress);
                 const isMayaName = yield this.isMAYAName(affiliateAddress);
                 if (!(isMayaAddress || isMayaName))
                     errors.push(`affiliateAddress ${affiliateAddress} is not a valid MAYA address`);
@@ -89636,7 +89780,7 @@ class MayachainAMM {
                 errors.push(`affiliateBps ${affiliateBps} out of range [0 - 10000]`);
             }
             // Validate approval if asset is an ERC20 token and fromAddress is provided
-            if (this.isERC20Asset(fromAsset) && fromAddress) {
+            if (isProtocolERC20Asset(fromAsset) && fromAddress) {
                 const approveErrors = yield this.isRouterApprovedToSpend({
                     asset: fromAsset,
                     address: fromAddress,
@@ -89667,10 +89811,12 @@ class MayachainAMM {
             // Check if the swap can be performed
             if (!quoteSwap.canSwap)
                 throw Error(`Can not swap. ${quoteSwap.errors.join(' ')}`);
-            // Perform the swap based on the asset chain
-            return fromAsset.chain === xchainMayachain.MAYAChain || fromAsset.synth
-                ? this.doProtocolAssetSwap(amount, quoteSwap.memo)
-                : this.doNonProtocolAssetSwap(amount, quoteSwap.toAddress, quoteSwap.memo);
+            return MayachainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: amount,
+                memo: quoteSwap.memo,
+                recipient: `${quoteSwap.toAddress}`,
+            });
         });
     }
     /**
@@ -89713,107 +89859,147 @@ class MayachainAMM {
         });
     }
     /**
-     * Check if a name is a valid MAYAName
-     * @param {string} name MAYAName to check
-     * @returns {boolean} True if the name is registered as a MAYAName, otherwise false
+     * Get MAYAname details
+     * @param {string} MAYAName
+     * @returns {MAYANameDetails | undefined} MAYANames details or undefined it is does not exist
      */
-    isMAYAName(name) {
+    getMAYANameDetails(MAYAName) {
         return __awaiter$8(this, void 0, void 0, function* () {
-            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
+            return this.mayachainQuery.getMAYANameDetails(MAYAName);
         });
     }
     /**
-     * Perform a swap from a native protocol asset to any other asset
-     * @param {CryptoAmount} amount Amount to swap
-     * @param {string} memo Memo to add to the transaction
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     * Get the MAYANames owned by an address
+     * @param {Address} owner - Thorchain address
+     * @returns {MAYANameDetails[]} List of MAYANames owned by the address
      */
-    doProtocolAssetSwap(amount, memo) {
+    getMAYANamesByOwner(owner) {
         return __awaiter$8(this, void 0, void 0, function* () {
-            // Deposit the amount and return transaction hash and URL
-            const hash = yield this.wallet.deposit({ chain: xchainMayachain.MAYAChain, asset: amount.asset, amount: amount.baseAmount, memo });
-            return {
-                hash,
-                url: yield this.wallet.getExplorerTxUrl(xchainMayachain.MAYAChain, hash),
-            };
+            return this.mayachainQuery.getMAYANamesByOwner(owner);
         });
     }
     /**
-     * Perform a swap between assets
-     * @param {CryptoAmount} amount Amount to swap
-     * @param {string} memo Memo to add to the transaction to successfully make the swap
-     * @param {string} recipient inbound address to make swap transaction to
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     * Estimate the cost of a MAYAName registration
+     * @param {RegisterMAYAName} params Params to make the registration
+     * @returns {QuoteMAYAName} Memo to make the registration and the estimation of the operation
      */
-    doNonProtocolAssetSwap(amount, recipient, memo) {
+    estimateMAYANameRegistration(params) {
         return __awaiter$8(this, void 0, void 0, function* () {
-            // For non-EVM assets, perform a transfer and return transaction hash and URL
-            if (!this.isEVMChain(amount.asset.chain)) {
-                const hash = yield this.wallet.transfer({
-                    asset: amount.asset,
-                    amount: amount.baseAmount,
-                    recipient,
-                    memo,
-                });
+            const errors = [];
+            if (!validateAddress(this.mayachainQuery.getNetwork(), params.chain, params.chainAddress)) {
+                errors.push(`Invalid address ${params.chainAddress} for ${params.chain} chain`);
+            }
+            if (!validateAddress(this.mayachainQuery.getNetwork(), xchainMayachain.MAYAChain, params.owner)) {
+                errors.push(`Invalid owner ${params.owner} due it is not a MAYAChain address`);
+            }
+            if (errors.length) {
                 return {
-                    hash,
-                    url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
+                    memo: '',
+                    errors,
+                    value: new CryptoAmount(baseAmount(0, xchainMayachain.CACAO_DECIMAL), xchainMayachain.AssetCacao),
+                    allowed: false,
                 };
             }
-            // For EVM assets, perform a deposit with expiry and return transaction hash and URL
-            const inboundDetails = yield this.mayachainQuery.getChainInboundDetails(amount.asset.chain);
-            if (!inboundDetails.router)
-                throw Error(`Unknown router for ${amount.asset.chain} chain`);
-            const isERC20 = this.isERC20Asset(amount.asset);
-            const checkSummedContractAddress = isERC20
-                ? ethers.ethers.utils.getAddress(getContractAddressFromAsset(amount.asset))
-                : ethers.ethers.constants.AddressZero;
-            const expiration = Math.floor(new Date(new Date().getTime() + 15 * 60000).getTime() / 1000);
-            const depositParams = [
-                recipient,
-                checkSummedContractAddress,
-                amount.baseAmount.amount().toFixed(),
-                memo,
-                expiration,
-            ];
-            const routerContract = new ethers.ethers.Contract(inboundDetails.router, abi.router);
-            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams);
-            const gasPrices = yield this.wallet.getGasFeeRates(amount.asset.chain);
-            const nativeAsset = this.wallet.getAssetInfo(amount.asset.chain);
-            const hash = yield this.wallet.transfer({
-                asset: nativeAsset.asset,
-                amount: isERC20 ? baseAmount(0, nativeAsset.decimal) : amount.baseAmount,
-                memo: unsignedTx.data,
-                recipient: inboundDetails.router,
-                gasPrice: gasPrices.fast,
-                isMemoEncoded: true,
-                gasLimit: ethers.ethers.BigNumber.from(160000),
+            try {
+                const estimated = yield this.mayachainQuery.estimateMAYAName(Object.assign({}, params));
+                return Object.assign(Object.assign({}, estimated), { allowed: true, errors: [] });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                return {
+                    memo: '',
+                    errors: ['message' in e ? e.message : `Unknown error: ${e}`],
+                    value: new CryptoAmount(baseAmount(0, xchainMayachain.CACAO_DECIMAL), xchainMayachain.AssetCacao),
+                    allowed: false,
+                };
+            }
+        });
+    }
+    /**
+     * Estimate the cost of an update of a MAYAName
+     * @param {QuoteMAYANameParams} params Params to make the update
+     * @returns {QuoteMAYAName} Memo to make the update and the estimation of the operation
+     */
+    estimateMAYANameUpdate(params) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const errors = [];
+            if ((params.chain && !params.chainAddress) || (!params.chain && params.chainAddress)) {
+                errors.push(`Alias not provided correctly`);
+            }
+            if (params.chain &&
+                params.chainAddress &&
+                !validateAddress(this.mayachainQuery.getNetwork(), params.chain, params.chainAddress)) {
+                errors.push(`Invalid alias ${params.chainAddress} for ${params.chain} chain`);
+            }
+            if (params.owner && !validateAddress(this.mayachainQuery.getNetwork(), xchainMayachain.MAYAChain, params.owner)) {
+                errors.push(`Invalid owner ${params.owner} due it is not a MAYAChain address`);
+            }
+            if (errors.length) {
+                return {
+                    memo: '',
+                    errors,
+                    value: new CryptoAmount(baseAmount(0, xchainMayachain.CACAO_DECIMAL), xchainMayachain.AssetCacao),
+                    allowed: false,
+                };
+            }
+            try {
+                const estimated = yield this.mayachainQuery.estimateMAYAName(Object.assign(Object.assign({}, params), { isUpdate: true }));
+                return Object.assign(Object.assign({}, estimated), { allowed: true, errors: [] });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                return {
+                    memo: '',
+                    errors: ['message' in e ? e.message : `Unknown error: ${e}`],
+                    value: new CryptoAmount(baseAmount(0, xchainMayachain.CACAO_DECIMAL), xchainMayachain.AssetCacao),
+                    allowed: false,
+                };
+            }
+        });
+    }
+    /**
+     * Register a MAYAName
+     * @param {RegisterMAYAName} params Params to make the registration
+     * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
+     */
+    registerMAYAName(params) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const quote = yield this.estimateMAYANameRegistration(params);
+            if (!quote.allowed)
+                throw Error(`Can not register MAYAName. ${quote.errors.join(' ')}`);
+            return MayachainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
             });
-            return {
-                hash,
-                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
-            };
         });
     }
     /**
-     * Check if the asset is an ERC20 token
-     * @param {Asset} asset Asset to check
-     * @returns True if the asset is an ERC20 token, otherwise false
+     * Update a MAYAName
+     * @param {QuoteMAYANameParams} params Params to make the update
+     * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
      */
-    isERC20Asset(asset) {
-        // Check if the asset's chain is an EVM chain and if the symbol matches AssetETH.symbol
-        return this.isEVMChain(asset.chain)
-            ? [xchainEthereum.AssetETH].findIndex((nativeEVMAsset) => eqAsset(nativeEVMAsset, asset)) === -1 && !asset.synth
-            : false;
+    updateMAYAName(params) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            const quote = yield this.estimateMAYANameUpdate(params);
+            if (!quote.allowed)
+                throw Error(`Can not update MAYAName. ${quote.errors.join(' ')}`);
+            return MayachainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
+            });
+        });
     }
     /**
-     * Check if the chain is an EVM (Ethereum Virtual Machine) chain
-     * @param {Chain} chain Chain to check
-     * @returns True if the chain is an EVM chain, otherwise false
+     * Check if a name is a valid MAYAName
+     * @param {string} name MAYAName to check
+     * @returns {boolean} True if the name is registered as a MAYAName, otherwise false
      */
-    isEVMChain(chain) {
-        // Check if the chain matches AssetETH.chain
-        return [xchainEthereum.AssetETH.chain].includes(chain);
+    isMAYAName(name) {
+        return __awaiter$8(this, void 0, void 0, function* () {
+            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
+        });
     }
 }
 

package/lib/mayachain-action.d.ts

@@ -0,0 +1,21 @@
+import { Address, CryptoAmount } from '@xchainjs/xchain-util';
+import { Wallet } from '@xchainjs/xchain-wallet';
+import { TxSubmitted } from './types';
+export type NonProtocolActionParams = {
+    wallet: Wallet;
+    assetAmount: CryptoAmount;
+    recipient: Address;
+    memo: string;
+};
+export type ProtocolActionParams = {
+    wallet: Wallet;
+    assetAmount: CryptoAmount;
+    memo: string;
+};
+export type ActionParams = ProtocolActionParams | NonProtocolActionParams;
+export declare class MayachainAction {
+    static makeAction(actionParams: ActionParams): Promise<TxSubmitted>;
+    private static makeProtocolAction;
+    private static makeNonProtocolAction;
+    private static isNonProtocolParams;
+}

package/lib/mayachain-amm.d.ts

@@ -1,6 +1,7 @@
-import { MayachainQuery, QuoteSwap, QuoteSwapParams } from '@xchainjs/xchain-mayachain-query';
+import { MAYANameDetails, MayachainQuery, QuoteSwap, QuoteSwapParams, RegisterMAYAName, UpdateMAYAName } from '@xchainjs/xchain-mayachain-query';
+import { Address } from '@xchainjs/xchain-util';
 import { Wallet } from '@xchainjs/xchain-wallet';
-import { ApproveParams, IsApprovedParams, TxSubmitted } from './types';
+import { ApproveParams, IsApprovedParams, QuoteMAYAName, TxSubmitted } from './types';
 /**
  * Mayachain Automated Market Maker (AMM) class.
  * MAYAChainAMM class for interacting with THORChain.
@@ -51,36 +52,45 @@ export declare class MayachainAMM {
      */
     isRouterApprovedToSpend({ asset, amount, address }: IsApprovedParams): Promise<string[]>;
     /**
-     * Check if a name is a valid MAYAName
-     * @param {string} name MAYAName to check
-     * @returns {boolean} True if the name is registered as a MAYAName, otherwise false
+     * Get MAYAname details
+     * @param {string} MAYAName
+     * @returns {MAYANameDetails | undefined} MAYANames details or undefined it is does not exist
      */
-    private isMAYAName;
+    getMAYANameDetails(MAYAName: string): Promise<MAYANameDetails | undefined>;
     /**
-     * Perform a swap from a native protocol asset to any other asset
-     * @param {CryptoAmount} amount Amount to swap
-     * @param {string} memo Memo to add to the transaction
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     * Get the MAYANames owned by an address
+     * @param {Address} owner - Thorchain address
+     * @returns {MAYANameDetails[]} List of MAYANames owned by the address
      */
-    private doProtocolAssetSwap;
+    getMAYANamesByOwner(owner: Address): Promise<MAYANameDetails[]>;
     /**
-     * Perform a swap between assets
-     * @param {CryptoAmount} amount Amount to swap
-     * @param {string} memo Memo to add to the transaction to successfully make the swap
-     * @param {string} recipient inbound address to make swap transaction to
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     * Estimate the cost of a MAYAName registration
+     * @param {RegisterMAYAName} params Params to make the registration
+     * @returns {QuoteMAYAName} Memo to make the registration and the estimation of the operation
+     */
+    estimateMAYANameRegistration(params: RegisterMAYAName): Promise<QuoteMAYAName>;
+    /**
+     * Estimate the cost of an update of a MAYAName
+     * @param {QuoteMAYANameParams} params Params to make the update
+     * @returns {QuoteMAYAName} Memo to make the update and the estimation of the operation
      */
-    private doNonProtocolAssetSwap;
+    estimateMAYANameUpdate(params: UpdateMAYAName): Promise<QuoteMAYAName>;
     /**
-     * Check if the asset is an ERC20 token
-     * @param {Asset} asset Asset to check
-     * @returns True if the asset is an ERC20 token, otherwise false
+     * Register a MAYAName
+     * @param {RegisterMAYAName} params Params to make the registration
+     * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
      */
-    private isERC20Asset;
+    registerMAYAName(params: RegisterMAYAName): Promise<TxSubmitted>;
     /**
-     * Check if the chain is an EVM (Ethereum Virtual Machine) chain
-     * @param {Chain} chain Chain to check
-     * @returns True if the chain is an EVM chain, otherwise false
+     * Update a MAYAName
+     * @param {QuoteMAYANameParams} params Params to make the update
+     * @returns {QuoteMAYAName} Memo to make the update or the registration and the estimation of the operation
      */
-    private isEVMChain;
+    updateMAYAName(params: UpdateMAYAName): Promise<TxSubmitted>;
+    /**
+     * Check if a name is a valid MAYAName
+     * @param {string} name MAYAName to check
+     * @returns {boolean} True if the name is registered as a MAYAName, otherwise false
+     */
+    private isMAYAName;
 }

package/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { QuoteMAYAName as BaseQuoteMAYAName } from '@xchainjs/xchain-mayachain-query';
 import { Address, Asset, CryptoAmount } from '@xchainjs/xchain-util';
 export type TxSubmitted = {
     hash: string;
@@ -12,3 +13,16 @@ export type IsApprovedParams = {
     amount: CryptoAmount;
     address: Address;
 };
+/**
+ * MAYAName quote parameters
+ */
+export type QuoteMAYAName = BaseQuoteMAYAName & {
+    /**
+     * If the action can be or not can be done
+     */
+    allowed: boolean;
+    /**
+     * If any, list of errors with the reason the operation is not allowed
+     */
+    errors: string[];
+};

package/lib/utils.d.ts

@@ -0,0 +1,21 @@
+import { Network } from '@xchainjs/xchain-client';
+import { Address, Asset, Chain } from '@xchainjs/xchain-util';
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+export declare const isProtocolEVMChain: (chain: Chain) => boolean;
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+export declare const isProtocolERC20Asset: (asset: Asset) => boolean;
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+export declare const isProtocolBFTChain: (chain: Chain) => boolean;
+export declare const validateAddress: (network: Network, chain: Chain, address: Address) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-mayachain-amm",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "module that exposes estimating & swapping cryptocurrency assets on mayachain",
   "keywords": [
     "MAYAChain",
@@ -36,13 +36,14 @@
     "url": "https://github.com/xchainjs/xchainjs-lib/issues"
   },
   "dependencies": {
+    "@xchainjs/xchain-arbitrum": "0.1.14",
     "@xchainjs/xchain-bitcoin": "0.23.19",
     "@xchainjs/xchain-client": "0.16.8",
     "@xchainjs/xchain-dash": "0.3.6",
     "@xchainjs/xchain-ethereum": "0.32.6",
     "@xchainjs/xchain-kujira": "0.1.21",
     "@xchainjs/xchain-mayachain": "1.0.11",
-    "@xchainjs/xchain-mayachain-query": "0.1.17",
+    "@xchainjs/xchain-mayachain-query": "0.1.19",
     "@xchainjs/xchain-thorchain": "1.1.1",
     "@xchainjs/xchain-wallet": "0.1.19",
     "ethers": "5.7.2"