@xchainjs/xchain-mayachain-amm 2.0.9 → 2.0.11

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 } 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';
 
 /******************************************************************************
@@ -8915,6 +8916,7 @@ var AssetCurrencySymbol;
     AssetCurrencySymbol["DASH"] = "\u0110";
     AssetCurrencySymbol["LTC"] = "\u0141";
     AssetCurrencySymbol["DOGE"] = "\u00D0";
+    AssetCurrencySymbol["CACAO"] = "\uD800\uDF02";
 })(AssetCurrencySymbol || (AssetCurrencySymbol = {}));
 /**
  * Formats an asset amount using its currency symbol
@@ -89525,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.
@@ -89540,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;
@@ -89612,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`);
@@ -89627,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,
@@ -89658,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}`,
+            });
         });
     }
     /**
@@ -89704,108 +89851,35 @@ 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
+     * 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
      */
-    doNonProtocolAssetSwap(amount, recipient, memo) {
+    isMAYAName(name) {
         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,
-                });
-                return {
-                    hash,
-                    url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
-                };
-            }
-            // 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),
-            });
-            return {
-                hash,
-                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
-            };
+            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
         });
     }
-    /**
-     * 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
-     */
-    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;
-    }
-    /**
-     * 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
-     */
-    isEVMChain(chain) {
-        // Check if the chain matches AssetETH.chain
-        return [AssetETH$1.chain].includes(chain);
-    }
 }
 
 export { MayachainAMM };

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');
@@ -8923,6 +8924,7 @@ var AssetCurrencySymbol;
     AssetCurrencySymbol["DASH"] = "\u0110";
     AssetCurrencySymbol["LTC"] = "\u0141";
     AssetCurrencySymbol["DOGE"] = "\u00D0";
+    AssetCurrencySymbol["CACAO"] = "\uD800\uDF02";
 })(AssetCurrencySymbol || (AssetCurrencySymbol = {}));
 /**
  * Formats an asset amount using its currency symbol
@@ -89533,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.
@@ -89552,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 }),
     })) {
@@ -89620,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`);
@@ -89635,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,
@@ -89666,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}`,
+            });
         });
     }
     /**
@@ -89712,108 +89859,35 @@ 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
+     * 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
      */
-    doNonProtocolAssetSwap(amount, recipient, memo) {
+    isMAYAName(name) {
         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,
-                });
-                return {
-                    hash,
-                    url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
-                };
-            }
-            // 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),
-            });
-            return {
-                hash,
-                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
-            };
+            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
         });
     }
-    /**
-     * 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
-     */
-    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;
-    }
-    /**
-     * 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
-     */
-    isEVMChain(chain) {
-        // Check if the chain matches AssetETH.chain
-        return [xchainEthereum.AssetETH.chain].includes(chain);
-    }
 }
 
 exports.MayachainAMM = MayachainAMM;

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,4 +1,5 @@
-import { MayachainQuery, QuoteSwap, QuoteSwapParams } from '@xchainjs/xchain-mayachain-query';
+import { MAYANameDetails, MayachainQuery, QuoteSwap, QuoteSwapParams } from '@xchainjs/xchain-mayachain-query';
+import { Address } from '@xchainjs/xchain-util';
 import { Wallet } from '@xchainjs/xchain-wallet';
 import { ApproveParams, IsApprovedParams, TxSubmitted } from './types';
 /**
@@ -51,36 +52,21 @@ 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
-     */
-    private isMAYAName;
-    /**
-     * 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 MAYAname details
+     * @param {string} MAYAName
+     * @returns {MAYANameDetails | undefined} MAYANames details or undefined it is does not exist
      */
-    private doProtocolAssetSwap;
+    getMAYANameDetails(MAYAName: string): Promise<MAYANameDetails | undefined>;
     /**
-     * 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
-     */
-    private doNonProtocolAssetSwap;
-    /**
-     * 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
+     * Get the MAYANames owned by an address
+     * @param {Address} owner - Thorchain address
+     * @returns {MAYANameDetails[]} List of MAYANames owned by the address
      */
-    private isERC20Asset;
+    getMAYANamesByOwner(owner: Address): Promise<MAYANameDetails[]>;
     /**
-     * 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
      */
-    private isEVMChain;
+    private isMAYAName;
 }

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.9",
+  "version": "2.0.11",
   "description": "module that exposes estimating & swapping cryptocurrency assets on mayachain",
   "keywords": [
     "MAYAChain",
@@ -36,15 +36,16 @@
     "url": "https://github.com/xchainjs/xchainjs-lib/issues"
   },
   "dependencies": {
-    "@xchainjs/xchain-bitcoin": "0.23.18",
-    "@xchainjs/xchain-client": "0.16.7",
-    "@xchainjs/xchain-dash": "0.3.5",
-    "@xchainjs/xchain-ethereum": "0.32.5",
-    "@xchainjs/xchain-kujira": "0.1.20",
-    "@xchainjs/xchain-mayachain": "1.0.10",
-    "@xchainjs/xchain-mayachain-query": "0.1.16",
-    "@xchainjs/xchain-thorchain": "1.1.0",
-    "@xchainjs/xchain-wallet": "0.1.18",
+    "@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.18",
+    "@xchainjs/xchain-thorchain": "1.1.1",
+    "@xchainjs/xchain-wallet": "0.1.19",
     "ethers": "5.7.2"
   },
   "devDependencies": {