@cityofzion/bs-multichain 0.0.1 → 1.0.2

package/dist/features/swap/SimpleSwapApi.js

@@ -0,0 +1,258 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SimpleSwapApi_instances, _SimpleSwapApi_tickersBySimpleSwapBlockchain, _SimpleSwapApi_axios, _SimpleSwapApi_allCurrenciesMap, _SimpleSwapApi_createAddressTemplateUrl, _SimpleSwapApi_createTxTemplateUrl, _SimpleSwapApi_getTokenFromCurrency;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleSwapApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+class SimpleSwapApi {
+    constructor() {
+        _SimpleSwapApi_instances.add(this);
+        _SimpleSwapApi_tickersBySimpleSwapBlockchain.set(this, {
+            neo3: {
+                neo3: 'neo',
+                gasn3: 'gas',
+            },
+        });
+        _SimpleSwapApi_axios.set(this, void 0);
+        _SimpleSwapApi_allCurrenciesMap.set(this, new Map());
+        __classPrivateFieldSet(this, _SimpleSwapApi_axios, axios_1.default.create({
+            baseURL: `${blockchain_service_1.BSCommonConstants.DORA_URL}/api/v2/swap`,
+            headers: {
+                'Cache-Control': 'no-cache',
+                Pragma: 'no-cache',
+                Expires: '0',
+            },
+        }), "f");
+    }
+    getCurrencies(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (__classPrivateFieldGet(this, _SimpleSwapApi_allCurrenciesMap, "f").size) {
+                    return Array.from(__classPrivateFieldGet(this, _SimpleSwapApi_allCurrenciesMap, "f").values());
+                }
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get('/currencies');
+                const tokens = [];
+                response.data.result.forEach(currency => {
+                    const token = __classPrivateFieldGet(this, _SimpleSwapApi_instances, "m", _SimpleSwapApi_getTokenFromCurrency).call(this, currency, options);
+                    if (!token)
+                        return;
+                    __classPrivateFieldGet(this, _SimpleSwapApi_allCurrenciesMap, "f").set(`${token.ticker}:${token.network}`, token);
+                    if (!token.blockchain)
+                        return;
+                    tokens.push(token);
+                });
+                return tokens;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data.message)) {
+                    throw new Error(error.response.data.message);
+                }
+                throw error;
+            }
+        });
+    }
+    getPairs(ticker, network) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get(`/pairs/${ticker}/${network}`);
+                const pairs = (_a = response.data.result[`${ticker}:${network}`]) !== null && _a !== void 0 ? _a : [];
+                const tokens = [];
+                pairs.forEach(pair => {
+                    const token = __classPrivateFieldGet(this, _SimpleSwapApi_allCurrenciesMap, "f").get(pair);
+                    if (token)
+                        tokens.push(token);
+                });
+                return tokens;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && ((_b = error.response) === null || _b === void 0 ? void 0 : _b.data.message)) {
+                    throw new Error(error.response.data.message);
+                }
+                throw error;
+            }
+        });
+    }
+    getRange(currencyFrom, currencyTo) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get('/ranges', {
+                    params: {
+                        tickerFrom: currencyFrom.ticker,
+                        tickerTo: currencyTo.ticker,
+                        networkFrom: currencyFrom.network,
+                        networkTo: currencyTo.network,
+                    },
+                });
+                return response.data.result;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data.message)) {
+                    throw new Error(error.response.data.message);
+                }
+                throw error;
+            }
+        });
+    }
+    getEstimate(currencyFrom, currencyTo, amount) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get('/estimates', {
+                    params: {
+                        tickerFrom: currencyFrom.ticker,
+                        tickerTo: currencyTo.ticker,
+                        networkFrom: currencyFrom.network,
+                        networkTo: currencyTo.network,
+                        amount,
+                    },
+                });
+                return response.data.result.estimatedAmount;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data.message)) {
+                    throw new Error(error.response.data.message);
+                }
+                throw error;
+            }
+        });
+    }
+    createExchange({ currencyFrom, currencyTo, amount, refundAddress, address, extraIdToReceive, }) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data: { result }, } = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").post('/exchanges', {
+                    tickerFrom: currencyFrom.ticker,
+                    networkFrom: currencyFrom.network,
+                    tickerTo: currencyTo.ticker,
+                    networkTo: currencyTo.network,
+                    amount,
+                    userRefundAddress: refundAddress,
+                    addressTo: address,
+                    extraIdTo: (_a = extraIdToReceive === null || extraIdToReceive === void 0 ? void 0 : extraIdToReceive.trim()) !== null && _a !== void 0 ? _a : null,
+                });
+                return {
+                    id: result.id,
+                    depositAddress: result.addressFrom,
+                    log: JSON.stringify(result),
+                };
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && ((_b = error.response) === null || _b === void 0 ? void 0 : _b.data.message)) {
+                    throw new Error(error.response.data.message);
+                }
+                throw error;
+            }
+        });
+    }
+    getExchange(id) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data: { result }, } = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get(`/exchanges/${id}`);
+                return {
+                    status: result.status,
+                    txFrom: result.txFrom,
+                    txTo: result.txTo,
+                    log: JSON.stringify(result),
+                };
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data.message)) {
+                    throw new Error(error.response.data.message);
+                }
+                throw error;
+            }
+        });
+    }
+}
+exports.SimpleSwapApi = SimpleSwapApi;
+_SimpleSwapApi_tickersBySimpleSwapBlockchain = new WeakMap(), _SimpleSwapApi_axios = new WeakMap(), _SimpleSwapApi_allCurrenciesMap = new WeakMap(), _SimpleSwapApi_instances = new WeakSet(), _SimpleSwapApi_createAddressTemplateUrl = function _SimpleSwapApi_createAddressTemplateUrl(blockchainService, explorer) {
+    var _a;
+    explorer = !explorer ? undefined : explorer.replace('{}', '{address}');
+    if (blockchainService && (0, blockchain_service_1.hasExplorerService)(blockchainService))
+        return (_a = blockchainService.explorerService.getAddressTemplateUrl()) !== null && _a !== void 0 ? _a : explorer;
+    return explorer;
+}, _SimpleSwapApi_createTxTemplateUrl = function _SimpleSwapApi_createTxTemplateUrl(blockchainService, explorer) {
+    var _a;
+    explorer = !explorer ? undefined : explorer.replace('{}', '{txId}');
+    if (blockchainService && (0, blockchain_service_1.hasExplorerService)(blockchainService))
+        return (_a = blockchainService.explorerService.getTxTemplateUrl()) !== null && _a !== void 0 ? _a : explorer;
+    return explorer;
+}, _SimpleSwapApi_getTokenFromCurrency = function _SimpleSwapApi_getTokenFromCurrency(currency, options) {
+    var _a;
+    const { network: simpleSwapBlockchain, ticker } = currency;
+    let { name } = currency;
+    let symbol = ticker;
+    if (!ticker || !simpleSwapBlockchain || !currency.image || !name || !currency.validationAddress)
+        return;
+    const chainsByServiceNameEntries = Object.entries(options.chainsByServiceName);
+    const chainsByServiceNameEntry = chainsByServiceNameEntries.find(([_serviceName, chains]) => chains.includes(simpleSwapBlockchain));
+    let blockchain;
+    let blockchainService;
+    let decimals;
+    let hash = (_a = currency.contractAddress) !== null && _a !== void 0 ? _a : undefined;
+    const normalizedHash = hash ? blockchain_service_1.BSTokenHelper.normalizeHash(hash) : '';
+    const lowerCaseSymbol = symbol.toLowerCase();
+    const tickers = __classPrivateFieldGet(this, _SimpleSwapApi_tickersBySimpleSwapBlockchain, "f")[simpleSwapBlockchain];
+    if (chainsByServiceNameEntry) {
+        blockchain = chainsByServiceNameEntry[0];
+        blockchainService = options.blockchainServicesByName[blockchain];
+        const token = blockchainService.tokens.find(item => {
+            if (normalizedHash && blockchain_service_1.BSTokenHelper.predicateByHash(item)(normalizedHash))
+                return true;
+            const currentLowerCaseSymbol = item.symbol.toLowerCase();
+            if (!normalizedHash)
+                return (lowerCaseSymbol === currentLowerCaseSymbol ||
+                    (!!tickers && currentLowerCaseSymbol === tickers[lowerCaseSymbol]));
+            return false;
+        });
+        if (token) {
+            hash = token.hash;
+            decimals = token.decimals;
+            name = token.name;
+            symbol = token.symbol;
+        }
+    }
+    return {
+        id: `${ticker}:${simpleSwapBlockchain}`,
+        ticker,
+        symbol: symbol,
+        network: simpleSwapBlockchain,
+        name,
+        imageUrl: currency.image,
+        hash,
+        decimals,
+        hasExtraId: currency.hasExtraId,
+        validationExtra: currency.validationExtra,
+        validationAddress: currency.validationAddress,
+        addressTemplateUrl: __classPrivateFieldGet(this, _SimpleSwapApi_instances, "m", _SimpleSwapApi_createAddressTemplateUrl).call(this, blockchainService, currency.addressExplorer),
+        txTemplateUrl: __classPrivateFieldGet(this, _SimpleSwapApi_instances, "m", _SimpleSwapApi_createTxTemplateUrl).call(this, blockchainService, currency.txExplorer),
+        blockchain,
+    };
+};

package/dist/features/swap/SimpleSwapOrchestrator.d.ts

@@ -0,0 +1,17 @@
+import { Account, ISwapOrchestrator, TSwapOrchestratorEvents, TSwapResult, TSwapToken } from '@cityofzion/blockchain-service';
+import TypedEmitter from 'typed-emitter';
+import { TSimpleSwapOrchestratorInitParams } from './types';
+export declare class SimpleSwapOrchestrator<BSName extends string = string> implements ISwapOrchestrator<BSName> {
+    #private;
+    eventEmitter: TypedEmitter<TSwapOrchestratorEvents<BSName>>;
+    constructor(params: TSimpleSwapOrchestratorInitParams<BSName>);
+    init(): Promise<void>;
+    setTokenToUse(token: TSwapToken<BSName> | null): Promise<void>;
+    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+    setAmountToUse(amount: string | null): Promise<void>;
+    setTokenToReceive(token: TSwapToken<BSName> | null): Promise<void>;
+    setAddressToReceive(address: string | null): Promise<void>;
+    setExtraIdToReceive(extraIdToReceive: string | null): Promise<void>;
+    swap(): Promise<TSwapResult>;
+    calculateFee(): Promise<string>;
+}