@xchainjs/xchain-aggregator 0.2.0 → 0.2.2

package/lib/aggregator.d.ts

@@ -1,8 +1,20 @@
-import { Wallet } from '@xchainjs/xchain-wallet';
-import { Protocol, QuoteSwap, QuoteSwapParams, SwapHistory, SwapHistoryParams, TxSubmitted } from './types';
+import { Config, Protocol, QuoteSwap, QuoteSwapParams, SwapHistory, SwapHistoryParams, TxSubmitted } from './types';
 export declare class Aggregator {
     private protocols;
-    constructor(wallet?: Wallet);
+    private config;
+    constructor(config?: Config);
+    /**
+     * Get the current Aggregator configuration
+     * @returns {Omit<Config, 'wallet'>} the current Aggregator configuration
+     */
+    getConfiguration(): Omit<Config & {
+        protocols: Protocol[];
+    }, 'wallet'>;
+    /**
+     * Update the Aggregator configuration
+     * @param {Configuration} config
+     */
+    setConfiguration(config: Config): void;
     /**
      * Estimate swap
      * @param {QuoteSwapParams} params Swap parameters
@@ -24,4 +36,5 @@ export declare class Aggregator {
      * @returns the swap history
      */
     getSwapHistory(params: SwapHistoryParams): Promise<SwapHistory>;
+    private verifyConfig;
 }

package/lib/const.d.ts

@@ -0,0 +1,3 @@
+import { Config, Protocol } from './types';
+export declare const SupportedProtocols: Protocol[];
+export declare const DEFAULT_CONFIG: Required<Omit<Config, 'wallet' | 'affiliate'>>;

package/lib/index.d.ts

@@ -1,2 +1,2 @@
 export { Aggregator } from './aggregator';
-export { IProtocol, QuoteSwapParams, QuoteSwap, TxSubmitted, SwapHistory, SwapHistoryParams, SwapResume } from './types';
+export { IProtocol, QuoteSwapParams, QuoteSwap, TxSubmitted, SwapHistory, SwapHistoryParams, SwapResume, Config, } from './types';

package/lib/index.esm.js

@@ -1,11 +1,10 @@
-import { eqAsset, assetFromStringEx, assetToString, CachedValue, isSynthAsset, CryptoAmount, baseAmount } from '@xchainjs/xchain-util';
+import { CachedValue, isSynthAsset, CryptoAmount, baseAmount, eqAsset, assetFromStringEx, assetToString } from '@xchainjs/xchain-util';
 import { AssetCacao, MAYAChain } from '@xchainjs/xchain-mayachain';
 import { MayachainAMM } from '@xchainjs/xchain-mayachain-amm';
 import { MayachainQuery } from '@xchainjs/xchain-mayachain-query';
 import { AssetRuneNative, THORChain } from '@xchainjs/xchain-thorchain';
 import { ThorchainAMM } from '@xchainjs/xchain-thorchain-amm';
 import { ThorchainQuery } from '@xchainjs/xchain-thorchain-query';
-import { Wallet } from '@xchainjs/xchain-wallet';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -32,171 +31,10 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-class MayachainProtocol {
-    constructor(wallet) {
-        this.name = 'Mayachain';
-        this.mayachainQuery = new MayachainQuery();
-        this.mayachainAmm = new MayachainAMM(this.mayachainQuery, wallet);
-    }
-    /**
-     * Check if an asset is supported in the protocol
-     * @param {Asset} asset Asset to check if it is supported
-     * @returns {boolean} True if the asset is supported, otherwise false
-     */
-    isAssetSupported(asset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (eqAsset(asset, AssetCacao))
-                return true;
-            const pools = yield this.mayachainQuery.getPools();
-            return (pools.findIndex((pool) => pool.status === 'available' && eqAsset(asset, assetFromStringEx(pool.asset))) !== -1);
-        });
-    }
-    /**
-     * Retrieve the supported chains by the protocol
-     * @returns {Chain[]} the supported chains by the protocol
-     */
-    getSupportedChains() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inboundDetails = yield this.mayachainQuery.getInboundDetails();
-            return [MAYAChain, ...Object.values(inboundDetails).map((inboundAddress) => inboundAddress.chain)];
-        });
-    }
-    /**
-     * Estimate swap by validating the swap parameters.
-     *
-     * @param {QuoteSwapParams} quoteSwapParams Swap parameters.
-     * @returns {QuoteSwap} Quote swap result. If swap cannot be done, it returns an empty QuoteSwap with reasons.
-     */
-    estimateSwap(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const estimatedSwap = yield this.mayachainAmm.estimateSwap(params);
-            return {
-                protocol: this.name,
-                toAddress: estimatedSwap.toAddress,
-                memo: estimatedSwap.memo,
-                expectedAmount: estimatedSwap.expectedAmount,
-                dustThreshold: estimatedSwap.dustThreshold,
-                fees: estimatedSwap.fees,
-                totalSwapSeconds: estimatedSwap.inboundConfirmationSeconds || 0 + estimatedSwap.outboundDelaySeconds,
-                slipBasisPoints: estimatedSwap.slipBasisPoints,
-                canSwap: estimatedSwap.canSwap,
-                errors: estimatedSwap.errors,
-                warning: estimatedSwap.warning,
-            };
-        });
-    }
-    /**
-     * Perform a swap operation between assets.
-     * @param {QuoteSwapParams} quoteSwapParams Swap parameters
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
-     */
-    doSwap(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mayachainAmm.doSwap(params);
-        });
-    }
-    /**
-     * Get historical swaps
-     * @param {Address[]} addresses Addresses of which return their swap history
-     * @returns the swap history
-     */
-    getSwapHistory({ chainAddresses }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const swapHistory = yield this.mayachainQuery.getSwapHistory({
-                addresses: Array.from(new Set(chainAddresses.map((chainAddresses) => chainAddresses.address))),
-            });
-            return {
-                count: swapHistory.count,
-                swaps: swapHistory.swaps.map((swap) => {
-                    return Object.assign({ protocol: this.name }, swap);
-                }),
-            };
-        });
-    }
-}
-
-class ThorchainProtocol {
-    constructor(wallet) {
-        this.name = 'Thorchain';
-        this.thorchainQuery = new ThorchainQuery();
-        this.thorchainAmm = new ThorchainAMM(this.thorchainQuery, wallet);
-    }
-    /**
-     * Check if an asset is supported in the protocol
-     * @param {Asset} asset Asset to check if it is supported
-     * @returns {boolean} True if the asset is supported, otherwise false
-     */
-    isAssetSupported(asset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (eqAsset(asset, AssetRuneNative))
-                return true;
-            const pools = yield this.thorchainQuery.thorchainCache.getPools();
-            return (Object.values(pools).findIndex((pool) => pool.isAvailable() && assetToString(asset) === pool.assetString) !== -1);
-        });
-    }
-    /**
-     * Retrieve the supported chains by the protocol
-     * @returns {Chain[]} the supported chains by the protocol
-     */
-    getSupportedChains() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inboundDetails = yield this.thorchainQuery.thorchainCache.getInboundDetails();
-            return [THORChain, ...Object.values(inboundDetails).map((inboundAddress) => inboundAddress.chain)];
-        });
-    }
-    /**
-     * Estimate swap by validating the swap parameters.
-     *
-     * @param {QuoteSwapParams} quoteSwapParams Swap parameters.
-     * @returns {QuoteSwap} Quote swap result. If swap cannot be done, it returns an empty QuoteSwap with reasons.
-     */
-    estimateSwap(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const estimatedSwap = yield this.thorchainAmm.estimateSwap(params);
-            return {
-                protocol: this.name,
-                toAddress: estimatedSwap.toAddress,
-                memo: estimatedSwap.memo,
-                expectedAmount: estimatedSwap.txEstimate.netOutput,
-                dustThreshold: estimatedSwap.dustThreshold,
-                fees: estimatedSwap.txEstimate.totalFees,
-                totalSwapSeconds: estimatedSwap.txEstimate.inboundConfirmationSeconds || 0 + estimatedSwap.txEstimate.outboundDelaySeconds,
-                slipBasisPoints: estimatedSwap.txEstimate.slipBasisPoints,
-                canSwap: estimatedSwap.txEstimate.canSwap,
-                errors: estimatedSwap.txEstimate.errors,
-                warning: estimatedSwap.txEstimate.warning,
-            };
-        });
-    }
-    /**
-     * Perform a swap operation between assets.
-     * @param {QuoteSwapParams} quoteSwapParams Swap parameters
-     * @returns {TxSubmitted} Transaction hash and URL of the swap
-     */
-    doSwap(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.thorchainAmm.doSwap(params);
-        });
-    }
-    /**x
-     * Get historical swaps
-     * @param {Address[]} addresses Addresses of which return their swap history
-     * @returns the swap history
-     */
-    getSwapHistory({ chainAddresses }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const swapHistory = yield this.thorchainQuery.getSwapHistory({
-                addresses: Array.from(new Set(chainAddresses.map((chainAddresses) => chainAddresses.address))),
-            });
-            return {
-                count: swapHistory.count,
-                swaps: swapHistory.swaps.map((swap) => {
-                    return Object.assign({ protocol: this.name }, swap);
-                }),
-            };
-        });
-    }
-}
+const SupportedProtocols = ['Thorchain', 'Mayachain', 'Chainflip'];
+const DEFAULT_CONFIG = {
+    protocols: SupportedProtocols,
+};
 
 /** @internal Last-resort "this", if it gets here it probably would fail anyway */
 function evaluateThis(fn) {
@@ -25575,12 +25413,12 @@ const xAssetToCAsset = (asset) => {
  * Chainflip protocol
  */
 class ChainflipProtocol {
-    constructor(wallet = new Wallet({})) {
+    constructor(configuration) {
         this.name = 'Chainflip';
         this.sdk = new SwapSDK({
             network: 'mainnet',
         });
-        this.wallet = wallet;
+        this.wallet = configuration === null || configuration === void 0 ? void 0 : configuration.wallet;
         this.assetsData = new CachedValue(() => {
             return this.sdk.getAssets();
         }, 24 * 60 * 60 * 1000);
@@ -25697,6 +25535,8 @@ class ChainflipProtocol {
             if (!quoteSwap.canSwap) {
                 throw Error(`Can not make swap. ${quoteSwap.errors.join('\n')}`);
             }
+            if (!this.wallet)
+                throw Error('Wallet not configured. Can not do swap');
             const hash = yield this.wallet.transfer({
                 recipient: quoteSwap.toAddress,
                 amount: params.amount.baseAmount,
@@ -25741,10 +25581,222 @@ class ChainflipProtocol {
     }
 }
 
+class MayachainProtocol {
+    constructor(configuration) {
+        this.name = 'Mayachain';
+        this.mayachainQuery = new MayachainQuery();
+        this.mayachainAmm = new MayachainAMM(this.mayachainQuery, configuration === null || configuration === void 0 ? void 0 : configuration.wallet);
+        this.configuration = configuration;
+    }
+    /**
+     * Check if an asset is supported in the protocol
+     * @param {Asset} asset Asset to check if it is supported
+     * @returns {boolean} True if the asset is supported, otherwise false
+     */
+    isAssetSupported(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (eqAsset(asset, AssetCacao))
+                return true;
+            const pools = yield this.mayachainQuery.getPools();
+            return (pools.findIndex((pool) => pool.status === 'available' && eqAsset(asset, assetFromStringEx(pool.asset))) !== -1);
+        });
+    }
+    /**
+     * Retrieve the supported chains by the protocol
+     * @returns {Chain[]} the supported chains by the protocol
+     */
+    getSupportedChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundDetails = yield this.mayachainQuery.getInboundDetails();
+            return [MAYAChain, ...Object.values(inboundDetails).map((inboundAddress) => inboundAddress.chain)];
+        });
+    }
+    /**
+     * Estimate swap by validating the swap parameters.
+     *
+     * @param {QuoteSwapParams} quoteSwapParams Swap parameters.
+     * @returns {QuoteSwap} Quote swap result. If swap cannot be done, it returns an empty QuoteSwap with reasons.
+     */
+    estimateSwap(params) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const estimatedSwap = yield this.mayachainAmm.estimateSwap(Object.assign(Object.assign({}, params), { affiliateBps: (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.affiliateBps, affiliateAddress: (_b = this.configuration) === null || _b === void 0 ? void 0 : _b.affiliateAddress }));
+            return {
+                protocol: this.name,
+                toAddress: estimatedSwap.toAddress,
+                memo: estimatedSwap.memo,
+                expectedAmount: estimatedSwap.expectedAmount,
+                dustThreshold: estimatedSwap.dustThreshold,
+                fees: estimatedSwap.fees,
+                totalSwapSeconds: estimatedSwap.inboundConfirmationSeconds || 0 + estimatedSwap.outboundDelaySeconds,
+                slipBasisPoints: estimatedSwap.slipBasisPoints,
+                canSwap: estimatedSwap.canSwap,
+                errors: estimatedSwap.errors,
+                warning: estimatedSwap.warning,
+            };
+        });
+    }
+    /**
+     * Perform a swap operation between assets.
+     * @param {QuoteSwapParams} quoteSwapParams Swap parameters
+     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     */
+    doSwap(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mayachainAmm.doSwap(params);
+        });
+    }
+    /**
+     * Get historical swaps
+     * @param {Address[]} addresses Addresses of which return their swap history
+     * @returns the swap history
+     */
+    getSwapHistory({ chainAddresses }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const swapHistory = yield this.mayachainQuery.getSwapHistory({
+                addresses: Array.from(new Set(chainAddresses.map((chainAddresses) => chainAddresses.address))),
+            });
+            return {
+                count: swapHistory.count,
+                swaps: swapHistory.swaps.map((swap) => {
+                    return Object.assign({ protocol: this.name }, swap);
+                }),
+            };
+        });
+    }
+}
+
+class ThorchainProtocol {
+    constructor(configuration) {
+        this.name = 'Thorchain';
+        this.thorchainQuery = new ThorchainQuery();
+        this.thorchainAmm = new ThorchainAMM(this.thorchainQuery, configuration === null || configuration === void 0 ? void 0 : configuration.wallet);
+        this.configuration = configuration;
+    }
+    /**
+     * Check if an asset is supported in the protocol
+     * @param {Asset} asset Asset to check if it is supported
+     * @returns {boolean} True if the asset is supported, otherwise false
+     */
+    isAssetSupported(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (eqAsset(asset, AssetRuneNative))
+                return true;
+            const pools = yield this.thorchainQuery.thorchainCache.getPools();
+            return (Object.values(pools).findIndex((pool) => pool.isAvailable() && assetToString(asset) === pool.assetString) !== -1);
+        });
+    }
+    /**
+     * Retrieve the supported chains by the protocol
+     * @returns {Chain[]} the supported chains by the protocol
+     */
+    getSupportedChains() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundDetails = yield this.thorchainQuery.thorchainCache.getInboundDetails();
+            return [THORChain, ...Object.values(inboundDetails).map((inboundAddress) => inboundAddress.chain)];
+        });
+    }
+    /**
+     * Estimate swap by validating the swap parameters.
+     *
+     * @param {QuoteSwapParams} quoteSwapParams Swap parameters.
+     * @returns {QuoteSwap} Quote swap result. If swap cannot be done, it returns an empty QuoteSwap with reasons.
+     */
+    estimateSwap(params) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const estimatedSwap = yield this.thorchainAmm.estimateSwap(Object.assign(Object.assign({}, params), { affiliateBps: (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.affiliateBps, affiliateAddress: (_b = this.configuration) === null || _b === void 0 ? void 0 : _b.affiliateAddress }));
+            return {
+                protocol: this.name,
+                toAddress: estimatedSwap.toAddress,
+                memo: estimatedSwap.memo,
+                expectedAmount: estimatedSwap.txEstimate.netOutput,
+                dustThreshold: estimatedSwap.dustThreshold,
+                fees: estimatedSwap.txEstimate.totalFees,
+                totalSwapSeconds: estimatedSwap.txEstimate.inboundConfirmationSeconds || 0 + estimatedSwap.txEstimate.outboundDelaySeconds,
+                slipBasisPoints: estimatedSwap.txEstimate.slipBasisPoints,
+                canSwap: estimatedSwap.txEstimate.canSwap,
+                errors: estimatedSwap.txEstimate.errors,
+                warning: estimatedSwap.txEstimate.warning,
+            };
+        });
+    }
+    /**
+     * Perform a swap operation between assets.
+     * @param {QuoteSwapParams} quoteSwapParams Swap parameters
+     * @returns {TxSubmitted} Transaction hash and URL of the swap
+     */
+    doSwap(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.thorchainAmm.doSwap(params);
+        });
+    }
+    /**x
+     * Get historical swaps
+     * @param {Address[]} addresses Addresses of which return their swap history
+     * @returns the swap history
+     */
+    getSwapHistory({ chainAddresses }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const swapHistory = yield this.thorchainQuery.getSwapHistory({
+                addresses: Array.from(new Set(chainAddresses.map((chainAddresses) => chainAddresses.address))),
+            });
+            return {
+                count: swapHistory.count,
+                swaps: swapHistory.swaps.map((swap) => {
+                    return Object.assign({ protocol: this.name }, swap);
+                }),
+            };
+        });
+    }
+}
+
+const getProtocolConfig = (name, configuration) => {
+    var _a, _b;
+    return {
+        wallet: configuration.wallet,
+        affiliateAddress: (_a = configuration.affiliate) === null || _a === void 0 ? void 0 : _a.affiliates[name],
+        affiliateBps: ((_b = configuration.affiliate) === null || _b === void 0 ? void 0 : _b.affiliates[name]) ? configuration.affiliate.basisPoints : undefined,
+    };
+};
+class ProtocolFactory {
+    static getProtocol(name, configuration) {
+        const protocolConfig = getProtocolConfig(name, configuration);
+        switch (name) {
+            case 'Thorchain':
+                return new ThorchainProtocol(protocolConfig);
+            case 'Mayachain':
+                return new MayachainProtocol(protocolConfig);
+            case 'Chainflip':
+                return new ChainflipProtocol(protocolConfig);
+        }
+    }
+}
+
 // Class definition for an Aggregator
 class Aggregator {
-    constructor(wallet) {
-        this.protocols = [new ThorchainProtocol(wallet), new MayachainProtocol(wallet), new ChainflipProtocol(wallet)];
+    constructor(config) {
+        const fConfig = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
+        this.verifyConfig(fConfig);
+        this.protocols = fConfig.protocols.map((protocol) => ProtocolFactory.getProtocol(protocol, fConfig));
+        this.config = Object.assign(Object.assign({}, fConfig), { protocols: this.protocols.map((protocol) => protocol.name) });
+    }
+    /**
+     * Get the current Aggregator configuration
+     * @returns {Omit<Config, 'wallet'>} the current Aggregator configuration
+     */
+    getConfiguration() {
+        return { protocols: this.config.protocols, affiliate: this.config.affiliate };
+    }
+    /**
+     * Update the Aggregator configuration
+     * @param {Configuration} config
+     */
+    setConfiguration(config) {
+        const fConfig = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
+        this.verifyConfig(fConfig);
+        this.protocols = fConfig.protocols.map((protocol) => ProtocolFactory.getProtocol(protocol, fConfig));
+        this.config = Object.assign(Object.assign({}, fConfig), { protocols: this.protocols.map((protocol) => protocol.name) });
     }
     /**
      * Estimate swap
@@ -25826,6 +25878,12 @@ class Aggregator {
             };
         });
     }
+    verifyConfig(config) {
+        if (config.affiliate && (config.affiliate.basisPoints < 0 || config.affiliate.basisPoints > 10000))
+            throw Error('Invalid affiliate basis point due to it is out of bound. It must be between [0 - 10000]');
+        if (config.protocols.length === 0)
+            throw Error('No protocols enabled');
+    }
 }
 
 // ../shared/src/strings.ts