@cityofzion/bs-neo3 1.2.1 → 1.3.0

package/dist/services/swap/handlers/FlamingoSwapDetailsHandler.d.ts

@@ -0,0 +1,24 @@
+import { Network, SwapRoute, Token } from '@cityofzion/blockchain-service';
+import { BSNeo3NetworkId } from '../../../helpers/BSNeo3Helper';
+type CalculateSwapDetailsArgs = {
+    amountToUse: string | null;
+    amountToReceive: string | null;
+    tokenToUse: Token;
+    tokenToReceive: Token;
+    slippage: number;
+    network: Network<BSNeo3NetworkId>;
+    route: SwapRoute[];
+};
+export declare class FlamingoSwapDetailsHandler {
+    #private;
+    static calculateSwapDetails({ amountToReceive, amountToUse, network, route, slippage, tokenToReceive, tokenToUse, }: CalculateSwapDetailsArgs): {
+        amountToReceiveToDisplay: string;
+        amountToUseToDisplay: string;
+        liquidityProviderFee: string;
+        priceImpact: string | null;
+        priceInverse: string | null;
+        minimumReceived: string | null;
+        maximumSelling: string | null;
+    };
+}
+export {};

package/dist/services/swap/handlers/FlamingoSwapDetailsHandler.js

@@ -0,0 +1,178 @@
+"use strict";
+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 _a, _FlamingoSwapDetailsHandler_calculateUsingAmountToReceive, _FlamingoSwapDetailsHandler_calculateUsingAmountToUse, _FlamingoSwapDetailsHandler_formatSwapDetails, _FlamingoSwapDetailsHandler_createTradeData, _FlamingoSwapDetailsHandler_calculateAmountToUse, _FlamingoSwapDetailsHandler_calculateAmountToReceive;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapDetailsHandler = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const FlamingoSwapConstants_1 = require("../../../constants/FlamingoSwapConstants");
+const FlamingoSwapHelper_1 = require("../../../helpers/FlamingoSwapHelper");
+class FlamingoSwapDetailsHandler {
+    static calculateSwapDetails({ amountToReceive, amountToUse, network, route, slippage, tokenToReceive, tokenToUse, }) {
+        const overrodeTokenToUse = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToUse);
+        const overrodeTokenToReceive = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToReceive);
+        const overrodeRoute = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideRoute(network, route);
+        const slippageFormatted = new bignumber_js_1.default(slippage * 10).shiftedBy(-3);
+        if (amountToReceive) {
+            return __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_calculateUsingAmountToReceive).call(this, {
+                network,
+                amountToReceive,
+                overrodeRoute,
+                overrodeTokenToUse,
+                overrodeTokenToReceive,
+                slippageFormatted,
+            });
+        }
+        else if (amountToUse) {
+            return __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_calculateUsingAmountToUse).call(this, {
+                network,
+                amountToUse,
+                overrodeRoute,
+                overrodeTokenToUse,
+                overrodeTokenToReceive,
+                slippageFormatted,
+            });
+        }
+        else {
+            throw new Error('AmountToReceive or amountToUse are required, but both aren`t provided');
+        }
+    }
+}
+exports.FlamingoSwapDetailsHandler = FlamingoSwapDetailsHandler;
+_a = FlamingoSwapDetailsHandler, _FlamingoSwapDetailsHandler_calculateUsingAmountToReceive = function _FlamingoSwapDetailsHandler_calculateUsingAmountToReceive({ network, amountToReceive, overrodeRoute, overrodeTokenToUse, overrodeTokenToReceive, slippageFormatted, }) {
+    const amountToReceiveBn = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideAmountInput(network, amountToReceive, overrodeTokenToReceive);
+    const amountToUse = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_calculateAmountToUse).call(this, {
+        amountToReceive,
+        route: overrodeRoute,
+    });
+    const amountToUseBn = new bignumber_js_1.default(amountToUse);
+    const maximumSelling = amountToUseBn
+        .times(FlamingoSwapConstants_1.FlamingoSwapConstants.BN_1.plus(slippageFormatted))
+        .dp(0)
+        .shiftedBy(-overrodeTokenToUse.decimals)
+        .toFixed();
+    const amountToUseToDisplay = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideAmountToDisplay(network, amountToUse, overrodeTokenToUse);
+    const { fee, price, priceImpact } = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_createTradeData).call(this, {
+        amountToReceive: amountToReceiveBn,
+        amountToUse: amountToUseBn,
+        route: overrodeRoute,
+    });
+    return __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_formatSwapDetails).call(this, {
+        amountToReceiveToDisplay: amountToReceive,
+        amountToUseToDisplay,
+        fee,
+        price,
+        priceImpact,
+        overrodeTokenToUse,
+        overrodeTokenToReceive,
+        slippageFormatted,
+        minimumReceived: null,
+        maximumSelling,
+    });
+}, _FlamingoSwapDetailsHandler_calculateUsingAmountToUse = function _FlamingoSwapDetailsHandler_calculateUsingAmountToUse({ network, amountToUse, overrodeRoute, overrodeTokenToUse, overrodeTokenToReceive, slippageFormatted, }) {
+    const amountToUseBn = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideAmountInput(network, amountToUse, overrodeTokenToUse);
+    const amountToReceive = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_calculateAmountToReceive).call(this, {
+        amountToUse,
+        route: overrodeRoute,
+    });
+    const amountToReceiveBn = new bignumber_js_1.default(amountToReceive);
+    const minimumReceived = amountToReceiveBn
+        .times(FlamingoSwapConstants_1.FlamingoSwapConstants.BN_1.minus(slippageFormatted))
+        .dp(0)
+        .shiftedBy(-overrodeTokenToReceive.decimals)
+        .toFixed();
+    const amountToReceiveToDisplay = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideAmountToDisplay(network, amountToReceiveBn.toString(), overrodeTokenToReceive);
+    const { fee, price, priceImpact } = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_createTradeData).call(this, {
+        amountToReceive: amountToReceiveBn,
+        amountToUse: amountToUseBn,
+        route: overrodeRoute,
+    });
+    return __classPrivateFieldGet(this, _a, "m", _FlamingoSwapDetailsHandler_formatSwapDetails).call(this, {
+        amountToReceiveToDisplay,
+        amountToUseToDisplay: amountToUse,
+        fee,
+        price,
+        priceImpact,
+        overrodeTokenToUse,
+        overrodeTokenToReceive,
+        slippageFormatted,
+        minimumReceived,
+        maximumSelling: null,
+    });
+}, _FlamingoSwapDetailsHandler_formatSwapDetails = function _FlamingoSwapDetailsHandler_formatSwapDetails({ amountToReceiveToDisplay, amountToUseToDisplay, fee, price, priceImpact, overrodeTokenToUse, overrodeTokenToReceive, minimumReceived, maximumSelling, }) {
+    const priceInverse = FlamingoSwapConstants_1.FlamingoSwapConstants.BN_1.div(price);
+    const diffDecimals = overrodeTokenToUse.decimals - overrodeTokenToReceive.decimals;
+    return {
+        amountToReceiveToDisplay,
+        amountToUseToDisplay,
+        liquidityProviderFee: fee.shiftedBy(-8).plus(FlamingoSwapConstants_1.FlamingoSwapConstants.BN_0).toFixed(4),
+        priceImpact: isFinite(Number(priceImpact)) ? priceImpact.shiftedBy(2).toFixed(4) : null,
+        priceInverse: isFinite(Number(priceInverse)) ? priceInverse.multipliedBy(Math.pow(10, diffDecimals)).toFixed() : null,
+        minimumReceived,
+        maximumSelling,
+    };
+}, _FlamingoSwapDetailsHandler_createTradeData = function _FlamingoSwapDetailsHandler_createTradeData({ amountToReceive, amountToUse, route }) {
+    const fee = amountToUse.minus(route.reduce(acc => acc.times(FlamingoSwapConstants_1.FlamingoSwapConstants.BN_1.minus(FlamingoSwapConstants_1.FlamingoSwapConstants.FEE_RATE)), amountToUse));
+    const price = amountToUse.div(amountToReceive);
+    const midPrice = route.reduce((acc, item) => acc.times(item.reserveTokenToUse).div(item.reserveTokenToReceive), FlamingoSwapConstants_1.FlamingoSwapConstants.BN_1);
+    const priceImpact = price.minus(midPrice).div(price).minus(fee.div(amountToUse));
+    return {
+        fee,
+        price,
+        priceImpact,
+        midPrice,
+    };
+}, _FlamingoSwapDetailsHandler_calculateAmountToUse = function _FlamingoSwapDetailsHandler_calculateAmountToUse({ amountToReceive, route }) {
+    let amountToUse = '';
+    let tempAmountToReceive = amountToReceive;
+    route
+        .reverse()
+        .map(({ tokenToUse: tradeTokenToUse, tokenToReceive: tradeTokenToReceive, reserveTokenToUse, reserveTokenToReceive, }, index) => {
+        if (amountToUse) {
+            tempAmountToReceive = amountToUse;
+        }
+        const reserveTokenToUseBn = new bignumber_js_1.default(reserveTokenToUse);
+        const reserveTokenToReceiveBn = new bignumber_js_1.default(reserveTokenToReceive);
+        const tempAmountToReceiveBn = new bignumber_js_1.default(tempAmountToReceive).shiftedBy(tradeTokenToReceive.decimals);
+        amountToUse = reserveTokenToUseBn
+            .times(tempAmountToReceiveBn)
+            .times(1000)
+            .idiv(reserveTokenToReceiveBn.minus(tempAmountToReceiveBn).times(997))
+            .plus(1)
+            .toFixed();
+        if (route.length > 1) {
+            amountToUse = new bignumber_js_1.default(amountToUse).shiftedBy(-tradeTokenToUse.decimals).toFixed();
+            if (index === route.length - 1) {
+                amountToUse = new bignumber_js_1.default(amountToUse).shiftedBy(tradeTokenToUse.decimals).toFixed();
+            }
+        }
+    });
+    return amountToUse;
+}, _FlamingoSwapDetailsHandler_calculateAmountToReceive = function _FlamingoSwapDetailsHandler_calculateAmountToReceive({ amountToUse, route }) {
+    let amountToReceive = '';
+    let tempAmountToUse = amountToUse;
+    route.map(({ tokenToUse: tradeTokenToUse, tokenToReceive: tradeTokenToReceive, reserveTokenToUse, reserveTokenToReceive }, index) => {
+        if (amountToReceive) {
+            tempAmountToUse = amountToReceive;
+        }
+        const reserveTokenToUseBn = new bignumber_js_1.default(reserveTokenToUse);
+        const tempAmountToUseWithFee = new bignumber_js_1.default(tempAmountToUse).times(997).shiftedBy(tradeTokenToUse.decimals);
+        amountToReceive = tempAmountToUseWithFee
+            .times(reserveTokenToReceive)
+            .idiv(reserveTokenToUseBn.times(1000).plus(tempAmountToUseWithFee))
+            .toFixed();
+        if (route.length > 1) {
+            amountToReceive = new bignumber_js_1.default(amountToReceive).shiftedBy(-tradeTokenToReceive.decimals).toFixed();
+            if (index === route.length - 1) {
+                amountToReceive = new bignumber_js_1.default(amountToReceive).shiftedBy(tradeTokenToReceive.decimals).toFixed();
+            }
+        }
+    });
+    return amountToReceive;
+};

package/dist/services/swap/handlers/FlamingoSwapRouteHandler.d.ts

@@ -0,0 +1,13 @@
+import { Network, PoolGraph, SwapRoute, Token } from '@cityofzion/blockchain-service';
+import { BSNeo3NetworkId } from '../../../helpers/BSNeo3Helper';
+type CalculateBestRouteForSwapArgs = {
+    tokenToUse: Token;
+    tokenToReceive: Token;
+    network: Network<BSNeo3NetworkId>;
+};
+export declare class FlamingoSwapRouteHandler {
+    #private;
+    static calculateBestRouteForSwap({ tokenToUse, tokenToReceive, network, }: CalculateBestRouteForSwapArgs): Promise<SwapRoute[]>;
+    static createPoolGraph(network: Network<BSNeo3NetworkId>): PoolGraph;
+}
+export {};

package/dist/services/swap/handlers/FlamingoSwapRouteHandler.js

@@ -0,0 +1,181 @@
+"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 __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 _a, _FlamingoSwapRouteHandler_invokeReserves, _FlamingoSwapRouteHandler_createSwapRoute, _FlamingoSwapRouteHandler_getShortestRoutePath;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapRouteHandler = void 0;
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+const neon_dappkit_types_1 = require("@cityofzion/neon-dappkit-types");
+const NeonDappKitInvocationBuilderNeo3_1 = require("../../../builder/invocation/NeonDappKitInvocationBuilderNeo3");
+const FlamingoSwapHelper_1 = require("../../../helpers/FlamingoSwapHelper");
+class FlamingoSwapRouteHandler {
+    static calculateBestRouteForSwap({ tokenToUse, tokenToReceive, network, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routePath = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapRouteHandler_getShortestRoutePath).call(this, {
+                network,
+                startToken: tokenToUse,
+                targetToken: tokenToReceive,
+            });
+            if (routePath.length === 0)
+                return [];
+            const { stack: reservesStack } = yield __classPrivateFieldGet(this, _a, "m", _FlamingoSwapRouteHandler_invokeReserves).call(this, { network, routePath });
+            return __classPrivateFieldGet(this, _a, "m", _FlamingoSwapRouteHandler_createSwapRoute).call(this, { network, routePath, reservesStack });
+        });
+    }
+    static createPoolGraph(network) {
+        const pools = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapPools(network);
+        const tokens = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapTokens(network);
+        const { NEO, bNEO } = tokens;
+        const poolGraph = {};
+        // Initialize poolGraph with empty arrays
+        Object.values(tokens).forEach(token => {
+            poolGraph[token.symbol] = [];
+        });
+        // Add edges to poolGraph
+        Object.values(pools).forEach(pool => {
+            const tokenA = pool.tokens[0].symbol;
+            const tokenB = pool.tokens[1].symbol;
+            poolGraph[tokenA].push(tokenB);
+            poolGraph[tokenB].push(tokenA);
+        });
+        // Remove duplicates from poolGraph
+        Object.keys(poolGraph).forEach(tokenSymbol => {
+            poolGraph[tokenSymbol] = [...new Set(poolGraph[tokenSymbol])];
+        });
+        // Include NEO to the poolGraph
+        poolGraph[NEO.symbol] = Object.keys(tokens).filter(tokenSymbol => tokenSymbol === bNEO.symbol);
+        // Include relationship between NEO and bNEO
+        poolGraph[bNEO.symbol].push(NEO.symbol);
+        return poolGraph;
+    }
+}
+exports.FlamingoSwapRouteHandler = FlamingoSwapRouteHandler;
+_a = FlamingoSwapRouteHandler, _FlamingoSwapRouteHandler_invokeReserves = function _FlamingoSwapRouteHandler_invokeReserves({ network, routePath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const invoker = yield neon_dappkit_1.NeonInvoker.init({
+            rpcAddress: network.url,
+        });
+        const scriptHashes = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapScriptHashes(network);
+        const routerScriptHash = scriptHashes.flamingoSwapRouter;
+        // Remove NEO token from the routePath because it's not supported by the router
+        const routePathWithoutNeo = routePath.filter(route => !FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, route.tokenToUse) &&
+            !FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, route.tokenToReceive));
+        const getReservesContractInvocations = routePathWithoutNeo.map(route => NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.getReservesContractInvocation({
+            routerScriptHash,
+            tokenToUseHash: route.tokenToUse.hash,
+            tokenToReceiveHash: route.tokenToReceive.hash,
+        }));
+        const getReservesContractInvocationMulti = {
+            invocations: [...getReservesContractInvocations],
+        };
+        return yield invoker.testInvoke(getReservesContractInvocationMulti);
+    });
+}, _FlamingoSwapRouteHandler_createSwapRoute = function _FlamingoSwapRouteHandler_createSwapRoute({ network, routePath, reservesStack }) {
+    const isNeoTokenToUse = FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, routePath[0].tokenToUse);
+    const isNeoTokenToReceive = FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, routePath[routePath.length - 1].tokenToReceive);
+    const swapRoute = [];
+    for (let index = 0; index < reservesStack.length; index++) {
+        const item = reservesStack[index];
+        if (!neon_dappkit_types_1.TypeChecker.isStackTypeArray(item) ||
+            !neon_dappkit_types_1.TypeChecker.isStackTypeInteger(item.value[0]) ||
+            !neon_dappkit_types_1.TypeChecker.isStackTypeInteger(item.value[1])) {
+            throw new Error('Invalid reserves response');
+        }
+        // Include NEO token in the swapRoute with 0 reserves because it wasn't supported by the router during the reserves invocation
+        if (isNeoTokenToUse && index === 0) {
+            swapRoute.push({
+                tokenToUse: routePath[index].tokenToUse,
+                reserveTokenToUse: '0',
+                tokenToReceive: routePath[index].tokenToReceive,
+                reserveTokenToReceive: '0',
+            });
+            index++;
+        }
+        swapRoute.push({
+            tokenToUse: routePath[index].tokenToUse,
+            reserveTokenToUse: item.value[1].value,
+            tokenToReceive: routePath[index].tokenToReceive,
+            reserveTokenToReceive: item.value[0].value,
+        });
+    }
+    // Include NEO token in the swapRoute with 0 reserves because it wasn't supported by the router during the reserves invocation
+    if (isNeoTokenToReceive) {
+        swapRoute.push({
+            tokenToUse: routePath[routePath.length - 1].tokenToUse,
+            reserveTokenToUse: '0',
+            tokenToReceive: routePath[routePath.length - 1].tokenToReceive,
+            reserveTokenToReceive: '0',
+        });
+    }
+    return swapRoute;
+}, _FlamingoSwapRouteHandler_getShortestRoutePath = function _FlamingoSwapRouteHandler_getShortestRoutePath({ network, startToken, targetToken }) {
+    // Initialize an empty object to track predecessors of each token
+    const predecessor = {};
+    // Create a graph representation of the token network
+    const poolGraph = this.createPoolGraph(network);
+    // Initialize the queue with the start token's symbol
+    const queue = [startToken.symbol];
+    // Track visited tokens, starting with the start token marked as visited
+    const tokensVisited = {
+        [startToken.symbol]: true,
+    };
+    // Initialize an empty array to store the path of tokens
+    let path = [];
+    while (queue.length) {
+        // Remove and get the first token symbol from the queue
+        const currentTokenSymbol = queue.shift();
+        if (!currentTokenSymbol)
+            break;
+        const currentToken = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, currentTokenSymbol);
+        if (!currentToken)
+            continue;
+        // Get the neighbors of the current token from the graph
+        const neighbours = poolGraph[currentToken.symbol];
+        for (const neighbourSymbol of neighbours || []) {
+            if (tokensVisited[neighbourSymbol])
+                continue; // Skip if the neighbor has already been visited
+            // Mark the neighbor token as visited
+            tokensVisited[neighbourSymbol] = true;
+            // Record the current token as the predecessor of the neighbor token
+            predecessor[neighbourSymbol] = currentToken;
+            // Add the neighbor token symbol to the queue
+            queue.push(neighbourSymbol);
+            if (neighbourSymbol === targetToken.symbol) {
+                // Initialize the path with the target token
+                path = [targetToken];
+                // Start reconstructing the path from the target token back to the start token
+                let prevToken = currentToken;
+                while (prevToken && prevToken.symbol !== startToken.symbol) {
+                    path.push(prevToken); // Add the predecessor token to the path
+                    prevToken = predecessor[prevToken.symbol]; // Move to the predecessor token
+                }
+                // If the start token is reached, add it to the path and reverse the path to start-to-end order
+                if (prevToken) {
+                    path.push(prevToken);
+                    path.reverse();
+                }
+                break;
+            }
+        }
+        if (path.length)
+            break;
+    }
+    const routePath = [];
+    // Convert the token path into route paths
+    for (let i = 0; i < path.length - 1; i++) {
+        routePath.push({ tokenToUse: path[i], tokenToReceive: path[i + 1] });
+    }
+    return routePath;
+};

package/dist/services/swap/handlers/FlamingoSwapSocketHandler.d.ts

@@ -0,0 +1,9 @@
+type ListenBlockAddedParams = {
+    callback: () => Promise<void> | void;
+};
+export declare class FlamingoSwapSocketService {
+    #private;
+    onBlockAdded({ callback }: ListenBlockAddedParams): void;
+    closeConnection(): void;
+}
+export {};

package/dist/services/swap/handlers/FlamingoSwapSocketHandler.js

@@ -0,0 +1,57 @@
+"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 _FlamingoSwapSocketService_ws;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapSocketService = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const FlamingoSwapConstants_1 = require("../../../constants/FlamingoSwapConstants");
+class FlamingoSwapSocketService {
+    constructor() {
+        _FlamingoSwapSocketService_ws.set(this, void 0);
+    }
+    onBlockAdded({ callback }) {
+        __classPrivateFieldSet(this, _FlamingoSwapSocketService_ws, new isomorphic_ws_1.default(FlamingoSwapConstants_1.BLOCKCHAIN_WSS_URL), "f");
+        __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").onopen = () => {
+            const block_added = {
+                jsonrpc: '2.0',
+                method: 'subscribe',
+                params: ['block_added'],
+                id: 1,
+            };
+            __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").send(JSON.stringify(block_added));
+        };
+        __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").onmessage = () => __awaiter(this, void 0, void 0, function* () {
+            yield callback();
+        });
+    }
+    closeConnection() {
+        if (!__classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f"))
+            return;
+        __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").close();
+        __classPrivateFieldSet(this, _FlamingoSwapSocketService_ws, null, "f");
+    }
+}
+exports.FlamingoSwapSocketService = FlamingoSwapSocketService;
+_FlamingoSwapSocketService_ws = new WeakMap();

package/dist/services/swap/handlers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FlamingoSwapDetailsHandler';
+export * from './FlamingoSwapRouteHandler';
+export * from './FlamingoSwapSocketHandler';

package/dist/services/swap/handlers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FlamingoSwapDetailsHandler"), exports);
+__exportStar(require("./FlamingoSwapRouteHandler"), exports);
+__exportStar(require("./FlamingoSwapSocketHandler"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -17,14 +17,16 @@
     "query-string": "7.1.3",
     "@ledgerhq/hw-transport": "~6.30.5",
     "@cityofzion/neon-dappkit": "0.4.1",
-    "bignumber.js": "~9.1.2",
-    "isomorphic-ws": "~5.0.0",
-    "@cityofzion/bs-asteroid-sdk": "0.9.0",
-    "@cityofzion/blockchain-service": "1.2.0"
+    "bignumber.js": "^9.1.2",
+    "isomorphic-ws": "^5.0.0",
+    "lodash.clonedeep": "^4.5.0",
+    "@cityofzion/blockchain-service": "1.3.0",
+    "@cityofzion/bs-asteroid-sdk": "0.9.0"
   },
   "devDependencies": {
     "@cityofzion/neon-dappkit-types": "~0.3.1",
     "@ledgerhq/hw-transport-node-hid": "~6.28.5",
+    "@types/lodash.clonedeep": "^4.5.9",
     "@types/jest": "29.5.3",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
@@ -34,7 +36,7 @@
     "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
     "typescript": "4.9.5",
-    "typed-emitter": "~2.1.0"
+    "typed-emitter": "^2.1.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/flamingo-swap/FlamingoSwapControllerService.d.ts

@@ -1,20 +0,0 @@
-import { Account, Network, SwapControllerService, SwapControllerServiceEvents, SwapControllerServiceSwapToReceiveArgs, SwapControllerServiceSwapToUseArgs, Token } from '@cityofzion/blockchain-service';
-import TypedEmitter from 'typed-emitter';
-import { BSNeo3NetworkId } from '../BSNeo3Helper';
-export declare class FlamingoSwapControllerService implements SwapControllerService<BSNeo3NetworkId> {
-    #private;
-    eventEmitter: TypedEmitter<SwapControllerServiceEvents>;
-    constructor(network: Network<BSNeo3NetworkId>);
-    buildSwapArgs(): SwapControllerServiceSwapToReceiveArgs<BSNeo3NetworkId> | SwapControllerServiceSwapToUseArgs<BSNeo3NetworkId>;
-    setAccountToUse(account: Account | null): void;
-    setAmountToUse(val: string | null): void;
-    setAmountToReceive(val: string | null): void;
-    setDeadline(deadline: string): void;
-    setSlippage(slippage: number): void;
-    setTokenToUse(val: Token | null): Promise<void>;
-    setTokenToReceive(val: Token | null): Promise<void>;
-    swap(isLedger?: boolean): Promise<void>;
-    setReserves(): Promise<void>;
-    startListeningBlockGeneration(): void;
-    stopListeningBlockGeneration(): void;
-}