@xchainjs/xchain-mayachain-amm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 THORChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# `@xchainjs/xchain-mayachain-amm`
+
+## Modules
+
+Mayachain AMM module
+
+## Installation
+
+```
+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"
+  }
+
+```
+
+## For live examples
+
+
+## Documentation
+
+
+## Compiler options
+
+tsconfig compiler options
+
+```ts
+{
+    "compilerOptions": {
+        "module":"commonjs",
+        "target": "es5",
+        "noEmitOnError": true,
+        "resolveJsonModule": true,
+        "esModuleInterop": true,
+        "lib": ["es6", "dom", "es2016", "es2017"]
+    }
+}
+```
+
+### Setting environment variables

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './wallet';
+export * from './mayachain-amm';
+export * from './types';

package/lib/index.esm.js

@@ -0,0 +1,402 @@
+import { Client, defaultBTCParams, BTCChain } from '@xchainjs/xchain-bitcoin';
+import { Client as Client$2, defaultDashParams, DASHChain } from '@xchainjs/xchain-dash';
+import { Client as Client$1, defaultEthParams, ETHChain, AssetETH } from '@xchainjs/xchain-ethereum';
+import { isApproved, abi } from '@xchainjs/xchain-evm';
+import { Client as Client$3, defaultKujiParams, KUJIChain } from '@xchainjs/xchain-kujira';
+import { Client as Client$5, MAYAChain } from '@xchainjs/xchain-mayachain';
+import { Client as Client$4, THORChain } from '@xchainjs/xchain-thorchain';
+import { assetToString, getContractAddressFromAsset, CryptoAmount, baseAmount } from '@xchainjs/xchain-util';
+import { Network } from '@xchainjs/xchain-client';
+import { MayachainQuery } from '@xchainjs/xchain-mayachain-query';
+import { ethers } from 'ethers';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class Wallet {
+    /**
+     * Constructor to create a Wallet
+     *
+     * @param {string} phrase - mnemonic phrase
+     * @param {Network} network - mnemonic phrase
+     * @param {ChainConfigs} chainConfigs - Config by chain. If it isn not set, each client uses its default params
+     * @returns Wallet
+     */
+    constructor(phrase, network, chainConfigs = {}) {
+        const settings = { network, phrase };
+        this.clients = {
+            BTC: new Client(Object.assign(Object.assign(Object.assign({}, defaultBTCParams), chainConfigs[BTCChain]), settings)),
+            ETH: new Client$1(Object.assign(Object.assign(Object.assign({}, defaultEthParams), chainConfigs[ETHChain]), settings)),
+            DASH: new Client$2(Object.assign(Object.assign(Object.assign({}, defaultDashParams), chainConfigs[DASHChain]), settings)),
+            KUJI: new Client$3(Object.assign(Object.assign(Object.assign({}, defaultKujiParams), chainConfigs[KUJIChain]), settings)),
+            THOR: new Client$4(Object.assign(Object.assign({}, chainConfigs[THORChain]), settings)),
+            MAYA: new Client$5(Object.assign(Object.assign({}, chainConfigs[MAYAChain]), settings)),
+        };
+    }
+    /**
+     * Get chain address
+     * @param {Chain} chain
+     * @returns the chain address
+     */
+    getAddress(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(chain);
+            return client.getAddressAsync();
+        });
+    }
+    /**
+     * Check if address is valid
+     * @param {Chain} chain in which the address has to be valid
+     * @param {string} address to validate
+     * @returns true if it is a valid address, otherwise, false
+     */
+    validateAddress(chain, address) {
+        const client = this.getChainClient(chain);
+        return client.validateAddress(address);
+    }
+    /**
+     * Make a transaction
+     * @param {TxParams} txParams to make the transfer
+     * @returns the transaction hash
+     */
+    transfer({ asset, amount, recipient, memo, walletIndex }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(asset.chain);
+            return client.transfer({
+                walletIndex,
+                asset,
+                amount,
+                recipient,
+                memo,
+            });
+        });
+    }
+    /**
+     * Make a deposit
+     * @param {DepositParam} depositParams
+     * @returns the hash of the deposit
+     * @throws {Error} if can not make deposit with the asset
+     */
+    deposit({ asset, amount, memo }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(asset.chain);
+            if (!('deposit' in client))
+                throw Error(`Can not deposit with ${asset.chain} client`);
+            return client.deposit({ asset, amount, memo });
+        });
+    }
+    /**
+     * Check if an spenderAddress is allowed to spend in name of another address certain asset amount
+     * @param {Asset} asset to check
+     * @param {BaseAmount} amount to check
+     * @param {string} fromAddress owner of the amount asset
+     * @param {string} spenderAddress spender to check if it is allowed to spend
+     * @returns true if the spenderAddress is allowed to spend the amount, otherwise, false
+     * @throws {Error} if asset is a non ERC20 asset
+     */
+    isApproved(asset, amount, fromAddress, spenderAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(asset.chain);
+            if (!this.isERC20Asset(asset))
+                throw Error(`${assetToString(asset)} is not an ERC20 token`);
+            const contractAddress = getContractAddressFromAsset(asset);
+            return isApproved({
+                provider: client.getProvider(),
+                amount,
+                spenderAddress,
+                contractAddress,
+                fromAddress,
+            });
+        });
+    }
+    /**
+     * Get transaction url
+     * @param {Chain} chain of the transaction
+     * @param {string} hash of the transaction
+     * @returns the transaction url
+     */
+    getExplorerTxUrl(chain, hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(chain);
+            return client.getExplorerTxUrl(hash);
+        });
+    }
+    /**
+     * Get feeRates
+     * @param {Chain} chain of which return the feeRates
+     * @returns the gas fee rates
+     * @throws {Error} if gas fee rates can not be returned from the chain
+     */
+    getGasFeeRates(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(chain);
+            if (!('estimateGasPrices' in client))
+                throw Error(`Can not get gas with ${chain} client`);
+            return client.estimateGasPrices();
+        });
+    }
+    /**
+     * Get chain wallet
+     * @param {Chain} chain of which return the wallet
+     * @returns the chain wallet
+     * @throws {Error} wallet can not be retrieve from chain
+     */
+    getChainWallet(chain) {
+        const client = this.getChainClient(chain);
+        if (!('getWallet' in client))
+            throw Error(`Can not get wallet of ${chain} client`);
+        return client.getWallet();
+    }
+    /**
+     * Get chain client
+     * @param {Chain} chain of which return the client
+     * @returns the chain client
+     * @throws {Error} if client does not exist
+     */
+    getChainClient(chain) {
+        const client = this.clients[chain];
+        if (!client)
+            throw Error(`Client not found for ${chain} chain`);
+        return client;
+    }
+    /**
+     * Check if asset is ERC20
+     * @param {Asset} asset to check
+     * @returns true if asset is ERC20, otherwise, false
+     */
+    isERC20Asset(asset) {
+        const isGasAsset = [AssetETH.symbol].includes(asset.symbol);
+        return this.isEVMChain(asset.chain) && !isGasAsset;
+    }
+    /**
+     * Check if asset chain is EVM
+     * @param {Chain} chain to check
+     * @returns true if chain is EVM, otherwise, false
+     */
+    isEVMChain(chain) {
+        return [AssetETH.chain].includes(chain);
+    }
+}
+
+/**
+ * MAYAChainAMM class for interacting with THORChain.
+ * Recommended main class to use for swapping with MAYAChain
+ * Has access to Midgard and MayaNode data
+ */
+class MayachainAMM {
+    /**
+     * Constructor to create a MayachainAMM
+     * @param mayachainQuery - an instance of the MayachainQuery
+     * @returns MayachainAMM
+     */
+    constructor(mayachainQuery = new MayachainQuery(), wallet = new Wallet('', Network.Mainnet)) {
+        this.mayachainQuery = mayachainQuery;
+        this.wallet = wallet;
+    }
+    /**
+     * Estimate swap validating the swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {QuoteSwap} Quote swap. If swap can not be done, it returns an empty QuoteSwap with the reasons the swap can not be done
+     */
+    estimateSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = yield this.validateSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+            });
+            if (errors.length > 0) {
+                return {
+                    toAddress: ``,
+                    memo: ``,
+                    expectedAmount: new CryptoAmount(baseAmount(0), destinationAsset),
+                    dustThreshold: this.mayachainQuery.getChainDustValue(fromAsset.chain),
+                    fees: {
+                        asset: destinationAsset,
+                        affiliateFee: new CryptoAmount(baseAmount(0), destinationAsset),
+                        outboundFee: new CryptoAmount(baseAmount(0), destinationAsset),
+                    },
+                    outboundDelayBlocks: 0,
+                    outboundDelaySeconds: 0,
+                    inboundConfirmationSeconds: 0,
+                    inboundConfirmationBlocks: 0,
+                    canSwap: false,
+                    errors,
+                    slipBasisPoints: 0,
+                    totalSwapSeconds: 0,
+                    warning: '',
+                };
+            }
+            return this.mayachainQuery.quoteSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+                toleranceBps,
+            });
+        });
+    }
+    /**
+     * Validate swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {string[]} the reasons the swap can not be done. If it is empty there are no reason to avoid the swap
+     */
+    validateSwap({ fromAsset, fromAddress, destinationAsset, destinationAddress, amount, affiliateAddress, affiliateBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (destinationAddress && !this.wallet.validateAddress(destinationAsset.chain, destinationAddress)) {
+                errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
+            }
+            if (affiliateAddress) {
+                const isMayaAddress = this.wallet.validateAddress(MAYAChain, affiliateAddress);
+                const isMayaName = yield this.isMAYAName(affiliateAddress);
+                if (!(isMayaAddress || isMayaName))
+                    errors.push(`affiliateAddress ${affiliateAddress} is not a valid MAYA address`);
+            }
+            if (affiliateBps && (affiliateBps < 0 || affiliateBps > 10000)) {
+                errors.push(`affiliateBps ${affiliateBps} out of range [0 - 10000]`);
+            }
+            if (this.wallet.isERC20Asset(fromAsset) && fromAddress) {
+                const inboundDetails = yield this.mayachainQuery.getChainInboundDetails(fromAsset.chain);
+                if (!inboundDetails.router)
+                    throw Error(`Unknown router address for ${fromAsset.chain}`);
+                const isApprovedResult = yield this.wallet.isApproved(fromAsset, amount.baseAmount, fromAddress, inboundDetails.router);
+                if (!isApprovedResult)
+                    errors.push('Maya router has not been approved to spend this amount');
+            }
+            return errors;
+        });
+    }
+    /**
+     * Do swap between assets
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {TxSubmitted} the swap transaction hash and url
+     */
+    doSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quoteSwap = yield this.estimateSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+                toleranceBps,
+            });
+            if (!quoteSwap.canSwap)
+                throw Error(`Can not swap. ${quoteSwap.errors.join(' ')}`);
+            return fromAsset.chain === MAYAChain || fromAsset.synth
+                ? this.doProtocolAssetSwap(amount, quoteSwap.memo)
+                : this.doNonProtocolAssetSwap(amount, quoteSwap.toAddress, quoteSwap.memo);
+        });
+    }
+    /**
+     * Check if a name is a valid MAYAName
+     * @param {string} name MAYAName
+     * @returns {boolean} true if is a registered MAYAName, otherwise, false
+     */
+    isMAYAName(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
+        });
+    }
+    /**
+     * Do swap from native protocol asset to any other asset
+     * @param {CryptoAmount} amount Amount to swap
+     * @param {string} memo Memo to add to the transaction to successfully make the swap
+     * @returns {TxSubmitted} the swap transaction hash and url
+     */
+    doProtocolAssetSwap(amount, memo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hash = yield this.wallet.deposit({ asset: amount.asset, amount: amount.baseAmount, memo });
+            return {
+                hash,
+                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
+            };
+        });
+    }
+    /**
+     * Do 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} the swap transaction hash and url
+     */
+    doNonProtocolAssetSwap(amount, recipient, memo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Non ERC20 swaps
+            if (!this.wallet.isERC20Asset(amount.asset)) {
+                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),
+                };
+            }
+            // ERC20 swaps
+            const inboundDetails = yield this.mayachainQuery.getChainInboundDetails(amount.asset.chain);
+            if (!inboundDetails.router)
+                throw Error(`Unknown router for ${amount.asset.chain} chain`);
+            const contractAddress = getContractAddressFromAsset(amount.asset);
+            const checkSummedContractAddress = ethers.utils.getAddress(contractAddress);
+            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 wallet = this.wallet.getChainWallet(amount.asset.chain);
+            const gasPrices = yield this.wallet.getGasFeeRates(amount.asset.chain);
+            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams, {
+                from: this.wallet.getAddress(amount.asset.chain),
+                value: 0,
+                gasPrice: gasPrices.fast.amount().toFixed(),
+                gasLimit: '160000',
+            });
+            const { hash } = yield wallet.sendTransaction(unsignedTx);
+            return {
+                hash,
+                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
+            };
+        });
+    }
+}
+
+export { MayachainAMM, Wallet };

package/lib/index.js

@@ -0,0 +1,407 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var xchainBitcoin = require('@xchainjs/xchain-bitcoin');
+var xchainDash = require('@xchainjs/xchain-dash');
+var xchainEthereum = require('@xchainjs/xchain-ethereum');
+var xchainEvm = require('@xchainjs/xchain-evm');
+var xchainKujira = require('@xchainjs/xchain-kujira');
+var xchainMayachain = require('@xchainjs/xchain-mayachain');
+var xchainThorchain = require('@xchainjs/xchain-thorchain');
+var xchainUtil = require('@xchainjs/xchain-util');
+var xchainClient = require('@xchainjs/xchain-client');
+var xchainMayachainQuery = require('@xchainjs/xchain-mayachain-query');
+var ethers = require('ethers');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class Wallet {
+    /**
+     * Constructor to create a Wallet
+     *
+     * @param {string} phrase - mnemonic phrase
+     * @param {Network} network - mnemonic phrase
+     * @param {ChainConfigs} chainConfigs - Config by chain. If it isn not set, each client uses its default params
+     * @returns Wallet
+     */
+    constructor(phrase, network, chainConfigs = {}) {
+        const settings = { network, phrase };
+        this.clients = {
+            BTC: new xchainBitcoin.Client(Object.assign(Object.assign(Object.assign({}, xchainBitcoin.defaultBTCParams), chainConfigs[xchainBitcoin.BTCChain]), settings)),
+            ETH: new xchainEthereum.Client(Object.assign(Object.assign(Object.assign({}, xchainEthereum.defaultEthParams), chainConfigs[xchainEthereum.ETHChain]), settings)),
+            DASH: new xchainDash.Client(Object.assign(Object.assign(Object.assign({}, xchainDash.defaultDashParams), chainConfigs[xchainDash.DASHChain]), settings)),
+            KUJI: new xchainKujira.Client(Object.assign(Object.assign(Object.assign({}, xchainKujira.defaultKujiParams), chainConfigs[xchainKujira.KUJIChain]), settings)),
+            THOR: new xchainThorchain.Client(Object.assign(Object.assign({}, chainConfigs[xchainThorchain.THORChain]), settings)),
+            MAYA: new xchainMayachain.Client(Object.assign(Object.assign({}, chainConfigs[xchainMayachain.MAYAChain]), settings)),
+        };
+    }
+    /**
+     * Get chain address
+     * @param {Chain} chain
+     * @returns the chain address
+     */
+    getAddress(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(chain);
+            return client.getAddressAsync();
+        });
+    }
+    /**
+     * Check if address is valid
+     * @param {Chain} chain in which the address has to be valid
+     * @param {string} address to validate
+     * @returns true if it is a valid address, otherwise, false
+     */
+    validateAddress(chain, address) {
+        const client = this.getChainClient(chain);
+        return client.validateAddress(address);
+    }
+    /**
+     * Make a transaction
+     * @param {TxParams} txParams to make the transfer
+     * @returns the transaction hash
+     */
+    transfer({ asset, amount, recipient, memo, walletIndex }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(asset.chain);
+            return client.transfer({
+                walletIndex,
+                asset,
+                amount,
+                recipient,
+                memo,
+            });
+        });
+    }
+    /**
+     * Make a deposit
+     * @param {DepositParam} depositParams
+     * @returns the hash of the deposit
+     * @throws {Error} if can not make deposit with the asset
+     */
+    deposit({ asset, amount, memo }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(asset.chain);
+            if (!('deposit' in client))
+                throw Error(`Can not deposit with ${asset.chain} client`);
+            return client.deposit({ asset, amount, memo });
+        });
+    }
+    /**
+     * Check if an spenderAddress is allowed to spend in name of another address certain asset amount
+     * @param {Asset} asset to check
+     * @param {BaseAmount} amount to check
+     * @param {string} fromAddress owner of the amount asset
+     * @param {string} spenderAddress spender to check if it is allowed to spend
+     * @returns true if the spenderAddress is allowed to spend the amount, otherwise, false
+     * @throws {Error} if asset is a non ERC20 asset
+     */
+    isApproved(asset, amount, fromAddress, spenderAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(asset.chain);
+            if (!this.isERC20Asset(asset))
+                throw Error(`${xchainUtil.assetToString(asset)} is not an ERC20 token`);
+            const contractAddress = xchainUtil.getContractAddressFromAsset(asset);
+            return xchainEvm.isApproved({
+                provider: client.getProvider(),
+                amount,
+                spenderAddress,
+                contractAddress,
+                fromAddress,
+            });
+        });
+    }
+    /**
+     * Get transaction url
+     * @param {Chain} chain of the transaction
+     * @param {string} hash of the transaction
+     * @returns the transaction url
+     */
+    getExplorerTxUrl(chain, hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(chain);
+            return client.getExplorerTxUrl(hash);
+        });
+    }
+    /**
+     * Get feeRates
+     * @param {Chain} chain of which return the feeRates
+     * @returns the gas fee rates
+     * @throws {Error} if gas fee rates can not be returned from the chain
+     */
+    getGasFeeRates(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.getChainClient(chain);
+            if (!('estimateGasPrices' in client))
+                throw Error(`Can not get gas with ${chain} client`);
+            return client.estimateGasPrices();
+        });
+    }
+    /**
+     * Get chain wallet
+     * @param {Chain} chain of which return the wallet
+     * @returns the chain wallet
+     * @throws {Error} wallet can not be retrieve from chain
+     */
+    getChainWallet(chain) {
+        const client = this.getChainClient(chain);
+        if (!('getWallet' in client))
+            throw Error(`Can not get wallet of ${chain} client`);
+        return client.getWallet();
+    }
+    /**
+     * Get chain client
+     * @param {Chain} chain of which return the client
+     * @returns the chain client
+     * @throws {Error} if client does not exist
+     */
+    getChainClient(chain) {
+        const client = this.clients[chain];
+        if (!client)
+            throw Error(`Client not found for ${chain} chain`);
+        return client;
+    }
+    /**
+     * Check if asset is ERC20
+     * @param {Asset} asset to check
+     * @returns true if asset is ERC20, otherwise, false
+     */
+    isERC20Asset(asset) {
+        const isGasAsset = [xchainEthereum.AssetETH.symbol].includes(asset.symbol);
+        return this.isEVMChain(asset.chain) && !isGasAsset;
+    }
+    /**
+     * Check if asset chain is EVM
+     * @param {Chain} chain to check
+     * @returns true if chain is EVM, otherwise, false
+     */
+    isEVMChain(chain) {
+        return [xchainEthereum.AssetETH.chain].includes(chain);
+    }
+}
+
+/**
+ * MAYAChainAMM class for interacting with THORChain.
+ * Recommended main class to use for swapping with MAYAChain
+ * Has access to Midgard and MayaNode data
+ */
+class MayachainAMM {
+    /**
+     * Constructor to create a MayachainAMM
+     * @param mayachainQuery - an instance of the MayachainQuery
+     * @returns MayachainAMM
+     */
+    constructor(mayachainQuery = new xchainMayachainQuery.MayachainQuery(), wallet = new Wallet('', xchainClient.Network.Mainnet)) {
+        this.mayachainQuery = mayachainQuery;
+        this.wallet = wallet;
+    }
+    /**
+     * Estimate swap validating the swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {QuoteSwap} Quote swap. If swap can not be done, it returns an empty QuoteSwap with the reasons the swap can not be done
+     */
+    estimateSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = yield this.validateSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+            });
+            if (errors.length > 0) {
+                return {
+                    toAddress: ``,
+                    memo: ``,
+                    expectedAmount: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0), destinationAsset),
+                    dustThreshold: this.mayachainQuery.getChainDustValue(fromAsset.chain),
+                    fees: {
+                        asset: destinationAsset,
+                        affiliateFee: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0), destinationAsset),
+                        outboundFee: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0), destinationAsset),
+                    },
+                    outboundDelayBlocks: 0,
+                    outboundDelaySeconds: 0,
+                    inboundConfirmationSeconds: 0,
+                    inboundConfirmationBlocks: 0,
+                    canSwap: false,
+                    errors,
+                    slipBasisPoints: 0,
+                    totalSwapSeconds: 0,
+                    warning: '',
+                };
+            }
+            return this.mayachainQuery.quoteSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+                toleranceBps,
+            });
+        });
+    }
+    /**
+     * Validate swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {string[]} the reasons the swap can not be done. If it is empty there are no reason to avoid the swap
+     */
+    validateSwap({ fromAsset, fromAddress, destinationAsset, destinationAddress, amount, affiliateAddress, affiliateBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (destinationAddress && !this.wallet.validateAddress(destinationAsset.chain, destinationAddress)) {
+                errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
+            }
+            if (affiliateAddress) {
+                const isMayaAddress = this.wallet.validateAddress(xchainMayachain.MAYAChain, affiliateAddress);
+                const isMayaName = yield this.isMAYAName(affiliateAddress);
+                if (!(isMayaAddress || isMayaName))
+                    errors.push(`affiliateAddress ${affiliateAddress} is not a valid MAYA address`);
+            }
+            if (affiliateBps && (affiliateBps < 0 || affiliateBps > 10000)) {
+                errors.push(`affiliateBps ${affiliateBps} out of range [0 - 10000]`);
+            }
+            if (this.wallet.isERC20Asset(fromAsset) && fromAddress) {
+                const inboundDetails = yield this.mayachainQuery.getChainInboundDetails(fromAsset.chain);
+                if (!inboundDetails.router)
+                    throw Error(`Unknown router address for ${fromAsset.chain}`);
+                const isApprovedResult = yield this.wallet.isApproved(fromAsset, amount.baseAmount, fromAddress, inboundDetails.router);
+                if (!isApprovedResult)
+                    errors.push('Maya router has not been approved to spend this amount');
+            }
+            return errors;
+        });
+    }
+    /**
+     * Do swap between assets
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {TxSubmitted} the swap transaction hash and url
+     */
+    doSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quoteSwap = yield this.estimateSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+                toleranceBps,
+            });
+            if (!quoteSwap.canSwap)
+                throw Error(`Can not swap. ${quoteSwap.errors.join(' ')}`);
+            return fromAsset.chain === xchainMayachain.MAYAChain || fromAsset.synth
+                ? this.doProtocolAssetSwap(amount, quoteSwap.memo)
+                : this.doNonProtocolAssetSwap(amount, quoteSwap.toAddress, quoteSwap.memo);
+        });
+    }
+    /**
+     * Check if a name is a valid MAYAName
+     * @param {string} name MAYAName
+     * @returns {boolean} true if is a registered MAYAName, otherwise, false
+     */
+    isMAYAName(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this.mayachainQuery.getMAYANameDetails(name));
+        });
+    }
+    /**
+     * Do swap from native protocol asset to any other asset
+     * @param {CryptoAmount} amount Amount to swap
+     * @param {string} memo Memo to add to the transaction to successfully make the swap
+     * @returns {TxSubmitted} the swap transaction hash and url
+     */
+    doProtocolAssetSwap(amount, memo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hash = yield this.wallet.deposit({ asset: amount.asset, amount: amount.baseAmount, memo });
+            return {
+                hash,
+                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
+            };
+        });
+    }
+    /**
+     * Do 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} the swap transaction hash and url
+     */
+    doNonProtocolAssetSwap(amount, recipient, memo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Non ERC20 swaps
+            if (!this.wallet.isERC20Asset(amount.asset)) {
+                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),
+                };
+            }
+            // ERC20 swaps
+            const inboundDetails = yield this.mayachainQuery.getChainInboundDetails(amount.asset.chain);
+            if (!inboundDetails.router)
+                throw Error(`Unknown router for ${amount.asset.chain} chain`);
+            const contractAddress = xchainUtil.getContractAddressFromAsset(amount.asset);
+            const checkSummedContractAddress = ethers.ethers.utils.getAddress(contractAddress);
+            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, xchainEvm.abi.router);
+            const wallet = this.wallet.getChainWallet(amount.asset.chain);
+            const gasPrices = yield this.wallet.getGasFeeRates(amount.asset.chain);
+            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams, {
+                from: this.wallet.getAddress(amount.asset.chain),
+                value: 0,
+                gasPrice: gasPrices.fast.amount().toFixed(),
+                gasLimit: '160000',
+            });
+            const { hash } = yield wallet.sendTransaction(unsignedTx);
+            return {
+                hash,
+                url: yield this.wallet.getExplorerTxUrl(amount.asset.chain, hash),
+            };
+        });
+    }
+}
+
+exports.MayachainAMM = MayachainAMM;
+exports.Wallet = Wallet;

package/lib/mayachain-amm.d.ts

@@ -0,0 +1,57 @@
+import { MayachainQuery, QuoteSwap, QuoteSwapParams } from '@xchainjs/xchain-mayachain-query';
+import { TxSubmitted } from './types';
+import { Wallet } from './wallet';
+/**
+ * MAYAChainAMM class for interacting with THORChain.
+ * Recommended main class to use for swapping with MAYAChain
+ * Has access to Midgard and MayaNode data
+ */
+export declare class MayachainAMM {
+    private mayachainQuery;
+    private wallet;
+    /**
+     * Constructor to create a MayachainAMM
+     * @param mayachainQuery - an instance of the MayachainQuery
+     * @returns MayachainAMM
+     */
+    constructor(mayachainQuery?: MayachainQuery, wallet?: Wallet);
+    /**
+     * Estimate swap validating the swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {QuoteSwap} Quote swap. If swap can not be done, it returns an empty QuoteSwap with the reasons the swap can not be done
+     */
+    estimateSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }: QuoteSwapParams): Promise<QuoteSwap>;
+    /**
+     * Validate swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {string[]} the reasons the swap can not be done. If it is empty there are no reason to avoid the swap
+     */
+    validateSwap({ fromAsset, fromAddress, destinationAsset, destinationAddress, amount, affiliateAddress, affiliateBps, }: QuoteSwapParams): Promise<string[]>;
+    /**
+     * Do swap between assets
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {TxSubmitted} the swap transaction hash and url
+     */
+    doSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }: QuoteSwapParams): Promise<TxSubmitted>;
+    /**
+     * Check if a name is a valid MAYAName
+     * @param {string} name MAYAName
+     * @returns {boolean} true if is a registered MAYAName, otherwise, false
+     */
+    private isMAYAName;
+    /**
+     * Do swap from native protocol asset to any other asset
+     * @param {CryptoAmount} amount Amount to swap
+     * @param {string} memo Memo to add to the transaction to successfully make the swap
+     * @returns {TxSubmitted} the swap transaction hash and url
+     */
+    private doProtocolAssetSwap;
+    /**
+     * Do 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} the swap transaction hash and url
+     */
+    private doNonProtocolAssetSwap;
+}

package/lib/types.d.ts

@@ -0,0 +1,4 @@
+export type TxSubmitted = {
+    hash: string;
+    url: string;
+};

package/lib/wallet.d.ts

@@ -0,0 +1,112 @@
+import { BTCChain } from '@xchainjs/xchain-bitcoin';
+import { Network, TxParams, UtxoClientParams, XChainClient, XChainClientParams } from '@xchainjs/xchain-client';
+import { CosmosSdkClientParams } from '@xchainjs/xchain-cosmos-sdk';
+import { DASHChain } from '@xchainjs/xchain-dash';
+import { ETHChain } from '@xchainjs/xchain-ethereum';
+import { EVMClientParams, GasPrices } from '@xchainjs/xchain-evm';
+import { KUJIChain } from '@xchainjs/xchain-kujira';
+import { DepositParam, MAYAChain, MayachainClientParams } from '@xchainjs/xchain-mayachain';
+import { THORChain, ThorchainClientParams } from '@xchainjs/xchain-thorchain';
+import { Asset, BaseAmount, Chain } from '@xchainjs/xchain-util';
+import { ethers } from 'ethers';
+export type NodeUrls = Record<Network, string>;
+export type ChainConfigs = Partial<{
+    [BTCChain]: Partial<Omit<UtxoClientParams, 'phrase' | 'network'>>;
+    [ETHChain]: Partial<Omit<EVMClientParams, 'phrase' | 'network'>>;
+    [DASHChain]: Partial<Omit<UtxoClientParams, 'phrase' | 'network'>>;
+    [KUJIChain]: Partial<Omit<CosmosSdkClientParams, 'phrase' | 'network'>>;
+    [THORChain]: Omit<XChainClientParams & ThorchainClientParams, 'phrase' | 'network'>;
+    [MAYAChain]: Omit<XChainClientParams & MayachainClientParams, 'phrase' | 'network'>;
+}>;
+export declare class Wallet {
+    clients: Record<string, XChainClient>;
+    /**
+     * Constructor to create a Wallet
+     *
+     * @param {string} phrase - mnemonic phrase
+     * @param {Network} network - mnemonic phrase
+     * @param {ChainConfigs} chainConfigs - Config by chain. If it isn not set, each client uses its default params
+     * @returns Wallet
+     */
+    constructor(phrase: string, network: Network, chainConfigs?: ChainConfigs);
+    /**
+     * Get chain address
+     * @param {Chain} chain
+     * @returns the chain address
+     */
+    getAddress(chain: Chain): Promise<string>;
+    /**
+     * Check if address is valid
+     * @param {Chain} chain in which the address has to be valid
+     * @param {string} address to validate
+     * @returns true if it is a valid address, otherwise, false
+     */
+    validateAddress(chain: Chain, address: string): boolean;
+    /**
+     * Make a transaction
+     * @param {TxParams} txParams to make the transfer
+     * @returns the transaction hash
+     */
+    transfer({ asset, amount, recipient, memo, walletIndex }: TxParams & {
+        asset: Asset;
+    }): Promise<string>;
+    /**
+     * Make a deposit
+     * @param {DepositParam} depositParams
+     * @returns the hash of the deposit
+     * @throws {Error} if can not make deposit with the asset
+     */
+    deposit({ asset, amount, memo }: DepositParam & {
+        asset: Asset;
+    }): Promise<string>;
+    /**
+     * Check if an spenderAddress is allowed to spend in name of another address certain asset amount
+     * @param {Asset} asset to check
+     * @param {BaseAmount} amount to check
+     * @param {string} fromAddress owner of the amount asset
+     * @param {string} spenderAddress spender to check if it is allowed to spend
+     * @returns true if the spenderAddress is allowed to spend the amount, otherwise, false
+     * @throws {Error} if asset is a non ERC20 asset
+     */
+    isApproved(asset: Asset, amount: BaseAmount, fromAddress: string, spenderAddress: string): Promise<boolean>;
+    /**
+     * Get transaction url
+     * @param {Chain} chain of the transaction
+     * @param {string} hash of the transaction
+     * @returns the transaction url
+     */
+    getExplorerTxUrl(chain: Chain, hash: string): Promise<string>;
+    /**
+     * Get feeRates
+     * @param {Chain} chain of which return the feeRates
+     * @returns the gas fee rates
+     * @throws {Error} if gas fee rates can not be returned from the chain
+     */
+    getGasFeeRates(chain: Chain): Promise<GasPrices>;
+    /**
+     * Get chain wallet
+     * @param {Chain} chain of which return the wallet
+     * @returns the chain wallet
+     * @throws {Error} wallet can not be retrieve from chain
+     */
+    getChainWallet(chain: Chain): ethers.Wallet;
+    /**
+     * Get chain client
+     * @param {Chain} chain of which return the client
+     * @returns the chain client
+     * @throws {Error} if client does not exist
+     */
+    private getChainClient;
+    /**
+     * Check if asset is ERC20
+     * @param {Asset} asset to check
+     * @returns true if asset is ERC20, otherwise, false
+     */
+    isERC20Asset(asset: Asset): boolean;
+    /**
+     * Check if asset chain is EVM
+     * @param {Chain} chain to check
+     * @returns true if chain is EVM, otherwise, false
+     */
+    isEVMChain(chain: string): boolean;
+}

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@xchainjs/xchain-mayachain-amm",
+  "version": "0.1.0",
+  "description": "module that exposes estimating & swapping cryptocurrency assets on mayachain",
+  "keywords": [
+    "MAYAChain",
+    "XChain"
+  ],
+  "author": "MAYAChain",
+  "homepage": "https://github.com/xchainjs/xchainjs-lib#readme",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "module": "lib/index.esm.js",
+  "typings": "lib/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "files": [
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:xchainjs/xchainjs-lib.git"
+  },
+  "scripts": {
+    "clean": "rimraf lib/**",
+    "build": "yarn clean && rollup -c",
+    "test": "jest",
+    "e2e": "jest --config jest.config.e2e.js",
+    "lint": "eslint \"{src,__tests__}/**/*.ts\" --fix --max-warnings 0",
+    "prepublishOnly": "yarn build",
+    "postversion": "git push --follow-tags"
+  },
+  "bugs": {
+    "url": "https://github.com/xchainjs/xchainjs-lib/issues"
+  },
+  "devDependencies": {
+    "@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.6",
+    "@xchainjs/xchain-ethereum": "^0.31.1",
+    "@xchainjs/xchain-mayanode": "^0.1.2",
+    "@xchainjs/xchain-mayachain-query": "^0.1.1",
+    "@xchainjs/xchain-evm": "^0.4.1",
+    "@xchainjs/xchain-kujira": "^0.1.3",
+    "@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"
+  },
+  "peerDependencies": {
+    "@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.6",
+    "@xchainjs/xchain-ethereum": "^0.31.1",
+    "@xchainjs/xchain-mayanode": "^0.1.2",
+    "@xchainjs/xchain-mayachain-query": "^0.1.1",
+    "@xchainjs/xchain-evm": "^0.4.1",
+    "@xchainjs/xchain-kujira": "^0.1.3",
+    "@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"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}