@cityofzion/bs-neo3 0.13.1 → 0.14.0

package/dist/constants.d.ts

@@ -1,8 +1,20 @@
 import { NetworkType, Token } from '@cityofzion/blockchain-service';
 export declare const TOKENS: Record<NetworkType, Token[]>;
+export declare const BLOCKCHAIN_WSS_URL = "wss://rpc10.n3.nspcc.ru:10331/ws";
 export declare const NEO_NS_HASH = "0x50ac1c37690cc2cfc594472833cf57505d5f46de";
+export declare const GAS_PER_NEO = 0.001;
 export declare const GHOSTMARKET_URL_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>>;
 export declare const GHOSTMARKET_CHAIN_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>>;
 export declare const DERIVATION_PATH = "m/44'/888'/0'/0/?";
 export declare const RPC_LIST_BY_NETWORK_TYPE: Record<NetworkType, string[]>;
 export declare const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string>;
+export type SwapScriptHashes = {
+    flamingoSwapRouter: string;
+    flamingoPairWhiteList: string;
+    flamingoFactory: string;
+    neo: string;
+    gas: string;
+    bneo: string;
+    flpBneoGas: string;
+};
+export declare const SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE: Partial<Record<NetworkType, SwapScriptHashes>>;

package/dist/constants.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_URL_BY_NETWORK_TYPE = exports.RPC_LIST_BY_NETWORK_TYPE = exports.DERIVATION_PATH = exports.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE = exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = exports.NEO_NS_HASH = exports.TOKENS = void 0;
+exports.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE = exports.DEFAULT_URL_BY_NETWORK_TYPE = exports.RPC_LIST_BY_NETWORK_TYPE = exports.DERIVATION_PATH = exports.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE = exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = exports.GAS_PER_NEO = exports.NEO_NS_HASH = exports.BLOCKCHAIN_WSS_URL = exports.TOKENS = void 0;
 const common_json_1 = __importDefault(require("./assets/tokens/common.json"));
 const mainnet_json_1 = __importDefault(require("./assets/tokens/mainnet.json"));
 exports.TOKENS = {
@@ -11,7 +11,9 @@ exports.TOKENS = {
     testnet: common_json_1.default,
     custom: common_json_1.default,
 };
+exports.BLOCKCHAIN_WSS_URL = 'wss://rpc10.n3.nspcc.ru:10331/ws';
 exports.NEO_NS_HASH = '0x50ac1c37690cc2cfc594472833cf57505d5f46de';
+exports.GAS_PER_NEO = 0.001;
 exports.GHOSTMARKET_URL_BY_NETWORK_TYPE = {
     mainnet: 'https://api.ghostmarket.io/api/v2',
     testnet: 'https://api-testnet.ghostmarket.io/api/v2',
@@ -50,3 +52,23 @@ exports.DEFAULT_URL_BY_NETWORK_TYPE = {
     testnet: exports.RPC_LIST_BY_NETWORK_TYPE.testnet[0],
     custom: exports.RPC_LIST_BY_NETWORK_TYPE.custom[0],
 };
+exports.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE = {
+    mainnet: {
+        flamingoSwapRouter: '0xf970f4ccecd765b63732b821775dc38c25d74f23',
+        flamingoPairWhiteList: '0xfb75a5314069b56e136713d38477f647a13991b4',
+        flamingoFactory: '0xca2d20610d7982ebe0bed124ee7e9b2d580a6efc',
+        gas: '0xd2a4cff31913016155e38e474a2c06d08be276cf',
+        neo: '0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5',
+        bneo: '0x48c40d4666f93408be1bef038b6722404d9a4c2a',
+        flpBneoGas: '0x3244fcadcccff190c329f7b3083e4da2af60fbce',
+    },
+    testnet: {
+        flamingoSwapRouter: '0x6f0910fa26290f4a423930c8f833395790c71705',
+        flamingoPairWhiteList: '0xfb75a5314069b56e136713d38477f647a13991b4',
+        flamingoFactory: '0xca2d20610d7982ebe0bed124ee7e9b2d580a6efc',
+        gas: '0xd2a4cff31913016155e38e474a2c06d08be276cf',
+        neo: '0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5',
+        bneo: '0x85deac50febfd93988d3f391dea54e8289e43e9e',
+        flpBneoGas: '0x3244fcadcccff190c329f7b3083e4da2af60fbce',
+    },
+};

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

@@ -0,0 +1,55 @@
+import { Account, Network, SwapControllerService, SwapControllerServiceEvents, SwapControllerServiceSwapToReceiveArgs, SwapControllerServiceSwapToUseArgs, Token } from '@cityofzion/blockchain-service';
+import TypedEmitter from 'typed-emitter';
+import WebSocket from 'isomorphic-ws';
+export declare class FlamingoSwapControllerService implements SwapControllerService {
+    #private;
+    eventEmitter: TypedEmitter<SwapControllerServiceEvents>;
+    ws: WebSocket;
+    constructor(network: Network);
+    buildSwapArgs(): SwapControllerServiceSwapToReceiveArgs | SwapControllerServiceSwapToUseArgs;
+    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;
+    private recalculateSwapArguments;
+    private clearFields;
+    private get lastAmountChange();
+    private set lastAmountChange(value);
+    private get accountToUse();
+    private set accountToUse(value);
+    private get amountToUse();
+    private set amountToUse(value);
+    private get minimumReceived();
+    private set minimumReceived(value);
+    private get maximumSelling();
+    private set maximumSelling(value);
+    private get amountToReceive();
+    private set amountToReceive(value);
+    private get deadline();
+    private set deadline(value);
+    private get liquidityProviderFee();
+    private set liquidityProviderFee(value);
+    private get priceImpact();
+    private set priceImpact(value);
+    private get priceInverse();
+    private set priceInverse(value);
+    private get routes();
+    private set routes(value);
+    private get reservesToUse();
+    private set reservesToUse(value);
+    private get reservesToReceive();
+    private set reservesToReceive(value);
+    private get slippage();
+    private set slippage(value);
+    private get tokenToReceive();
+    private set tokenToReceive(value);
+    private get tokenToUse();
+    private set tokenToUse(value);
+}

package/dist/flamingo-swap/FlamingoSwapControllerService.js

@@ -0,0 +1,332 @@
+"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 _FlamingoSwapControllerService_network, _FlamingoSwapControllerService_accountToUse, _FlamingoSwapControllerService_tokenToReceive, _FlamingoSwapControllerService_tokenToUse, _FlamingoSwapControllerService_amountToReceive, _FlamingoSwapControllerService_amountToUse, _FlamingoSwapControllerService_minimumReceived, _FlamingoSwapControllerService_maximumSelling, _FlamingoSwapControllerService_reservesToReceive, _FlamingoSwapControllerService_reservesToUse, _FlamingoSwapControllerService_slippage, _FlamingoSwapControllerService_deadline, _FlamingoSwapControllerService_priceInverse, _FlamingoSwapControllerService_priceImpact, _FlamingoSwapControllerService_liquidityProviderFee, _FlamingoSwapControllerService_routes, _FlamingoSwapControllerService_lastAmountChange;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapControllerService = void 0;
+const events_1 = __importDefault(require("events"));
+const FlamingoSwapNeonDappKitInvocationBuilder_1 = require("./FlamingoSwapNeonDappKitInvocationBuilder");
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+const neon_core_1 = require("@cityofzion/neon-core");
+const FlamingoSwapError_1 = require("./FlamingoSwapError");
+const FlamingoSwapHelper_1 = require("./FlamingoSwapHelper");
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const constants_1 = require("../constants");
+class FlamingoSwapControllerService {
+    constructor(network) {
+        _FlamingoSwapControllerService_network.set(this, void 0);
+        _FlamingoSwapControllerService_accountToUse.set(this, null);
+        _FlamingoSwapControllerService_tokenToReceive.set(this, null);
+        _FlamingoSwapControllerService_tokenToUse.set(this, null);
+        _FlamingoSwapControllerService_amountToReceive.set(this, null);
+        _FlamingoSwapControllerService_amountToUse.set(this, null);
+        _FlamingoSwapControllerService_minimumReceived.set(this, null);
+        _FlamingoSwapControllerService_maximumSelling.set(this, null);
+        _FlamingoSwapControllerService_reservesToReceive.set(this, null);
+        _FlamingoSwapControllerService_reservesToUse.set(this, null);
+        _FlamingoSwapControllerService_slippage.set(this, 0.5);
+        _FlamingoSwapControllerService_deadline.set(this, '10');
+        _FlamingoSwapControllerService_priceInverse.set(this, null);
+        _FlamingoSwapControllerService_priceImpact.set(this, null);
+        _FlamingoSwapControllerService_liquidityProviderFee.set(this, null);
+        _FlamingoSwapControllerService_routes.set(this, null);
+        _FlamingoSwapControllerService_lastAmountChange.set(this, null);
+        if (network.type === 'custom')
+            throw new FlamingoSwapError_1.CustomNetworkNotSupportedError();
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_network, network, "f");
+        this.eventEmitter = new events_1.default();
+    }
+    buildSwapArgs() {
+        if (!this.accountToUse)
+            throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('accountToUse');
+        if (!this.amountToReceive)
+            throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('amountToReceive');
+        if (!this.amountToUse)
+            throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('amountToUse');
+        if (!this.tokenToReceive)
+            throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('tokenToReceive');
+        if (!this.tokenToUse)
+            throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('tokenToUse');
+        const baseSwapArgs = {
+            address: this.accountToUse.address,
+            amountToReceive: this.amountToReceive,
+            amountToUse: this.amountToUse,
+            tokenToReceive: this.tokenToReceive,
+            tokenToUse: this.tokenToUse,
+            deadline: this.deadline,
+            network: __classPrivateFieldGet(this, _FlamingoSwapControllerService_network, "f"),
+        };
+        if (this.lastAmountChange === 'amountToReceive') {
+            if (!this.maximumSelling)
+                throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('maximumSelling');
+            return Object.assign(Object.assign({}, baseSwapArgs), { maximumSelling: this.maximumSelling, type: 'swapTokenToReceive' });
+        }
+        if (!this.minimumReceived)
+            throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('minimumReceived');
+        return Object.assign(Object.assign({}, baseSwapArgs), { minimumReceived: this.minimumReceived, type: 'swapTokenToUse' });
+    }
+    setAccountToUse(account) {
+        this.accountToUse = account;
+    }
+    setAmountToUse(val) {
+        this.amountToUse = val;
+        this.lastAmountChange = 'amountToUse';
+        this.recalculateSwapArguments();
+    }
+    setAmountToReceive(val) {
+        this.amountToReceive = val;
+        this.lastAmountChange = 'amountToReceive';
+        this.recalculateSwapArguments();
+    }
+    setDeadline(deadline) {
+        this.deadline = deadline;
+    }
+    setSlippage(slippage) {
+        this.slippage = slippage;
+        this.recalculateSwapArguments();
+    }
+    setTokenToUse(val) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.tokenToUse = val;
+            yield this.setReserves();
+        });
+    }
+    setTokenToReceive(val) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.tokenToReceive = val;
+            yield this.setReserves();
+        });
+    }
+    swap(isLedger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isLedger)
+                throw new Error('Method not implemented.');
+            if (!this.accountToUse)
+                throw new FlamingoSwapError_1.FlamingoSwapMissingParametersError('accountToUse');
+            const swapArguments = this.buildSwapArgs();
+            const neonInvokerAccount = new neon_core_1.wallet.Account(this.accountToUse);
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                rpcAddress: __classPrivateFieldGet(this, _FlamingoSwapControllerService_network, "f").url,
+                account: neonInvokerAccount,
+            });
+            yield invoker.invokeFunction(FlamingoSwapNeonDappKitInvocationBuilder_1.FlamingoSwapNeonDappKitInvocationBuilder.swapInvocation(swapArguments));
+        });
+    }
+    setReserves() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenToReceive || !this.tokenToUse)
+                return;
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+                rpcAddress: __classPrivateFieldGet(this, _FlamingoSwapControllerService_network, "f").url,
+            });
+            const invocation = FlamingoSwapNeonDappKitInvocationBuilder_1.FlamingoSwapNeonDappKitInvocationBuilder.getReservesInvocation({
+                network: __classPrivateFieldGet(this, _FlamingoSwapControllerService_network, "f"),
+                tokenToReceiveScriptHash: this.tokenToReceive.hash,
+                tokenToUseScriptHash: this.tokenToUse.hash,
+            });
+            const { stack } = yield invoker.testInvoke(invocation);
+            if (!neon_dappkit_1.TypeChecker.isStackTypeArray(stack[0]) ||
+                !neon_dappkit_1.TypeChecker.isStackTypeInteger(stack[0].value[0]) ||
+                !neon_dappkit_1.TypeChecker.isStackTypeInteger(stack[0].value[1]))
+                throw new FlamingoSwapError_1.FlamingoInvalidReservesResponseError();
+            this.reservesToReceive = stack[0].value[0].value;
+            this.reservesToUse = stack[0].value[1].value;
+            this.recalculateSwapArguments();
+        });
+    }
+    startListeningBlockGeneration() {
+        this.ws = new isomorphic_ws_1.default(constants_1.BLOCKCHAIN_WSS_URL);
+        this.ws.onopen = () => {
+            const block_added = {
+                jsonrpc: '2.0',
+                method: 'subscribe',
+                params: ['block_added'],
+                id: 1,
+            };
+            this.ws.send(JSON.stringify(block_added));
+        };
+        this.ws.onmessage = () => __awaiter(this, void 0, void 0, function* () {
+            this.setReserves();
+        });
+    }
+    stopListeningBlockGeneration() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    recalculateSwapArguments() {
+        if (!this.tokenToReceive || !this.tokenToUse || !this.reservesToReceive || !this.reservesToUse)
+            return;
+        if ((this.lastAmountChange === 'amountToReceive' && this.amountToReceive) ||
+            (this.lastAmountChange === 'amountToUse' && this.amountToUse)) {
+            const amountToReceive = this.lastAmountChange === 'amountToReceive' ? this.amountToReceive : null;
+            const amountToUse = this.lastAmountChange === 'amountToUse' ? this.amountToUse : null;
+            const { amountToUseToDisplay, amountToReceiveToDisplay, maximumSelling, minimumReceived, liquidityProviderFee, priceImpact, priceInverse, } = FlamingoSwapHelper_1.FlamingoSwapHelper.getSwapFields({
+                network: __classPrivateFieldGet(this, _FlamingoSwapControllerService_network, "f"),
+                amountToReceive,
+                amountToUse,
+                tokenToUse: this.tokenToUse,
+                tokenToReceive: this.tokenToReceive,
+                reservesToUse: this.reservesToUse,
+                reservesToReceive: this.reservesToReceive,
+                slippage: this.slippage,
+            });
+            this.amountToUse = amountToUseToDisplay;
+            this.amountToReceive = amountToReceiveToDisplay;
+            this.maximumSelling = maximumSelling;
+            this.minimumReceived = minimumReceived;
+            this.liquidityProviderFee = liquidityProviderFee;
+            this.priceImpact = priceImpact;
+            this.priceInverse = priceInverse;
+            this.routes = []; // TODO: It will be implemented in Swap Multi Invoke issue
+            return;
+        }
+        this.clearFields();
+    }
+    clearFields() {
+        this.amountToUse = null;
+        this.amountToReceive = null;
+        this.minimumReceived = null;
+        this.maximumSelling = null;
+        this.liquidityProviderFee = null;
+        this.priceImpact = null;
+        this.priceInverse = null;
+    }
+    // Getters and setters
+    get lastAmountChange() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_lastAmountChange, "f");
+    }
+    set lastAmountChange(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_lastAmountChange, val, "f");
+        this.eventEmitter.emit('lastAmountChanged', val);
+    }
+    get accountToUse() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_accountToUse, "f");
+    }
+    set accountToUse(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_accountToUse, val, "f");
+        this.eventEmitter.emit('accountToUse', val);
+    }
+    get amountToUse() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_amountToUse, "f");
+    }
+    set amountToUse(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_amountToUse, val, "f");
+        this.eventEmitter.emit('amountToUse', val);
+    }
+    get minimumReceived() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_minimumReceived, "f");
+    }
+    set minimumReceived(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_minimumReceived, val, "f");
+        this.eventEmitter.emit('minimumReceived', val);
+    }
+    get maximumSelling() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_maximumSelling, "f");
+    }
+    set maximumSelling(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_maximumSelling, val, "f");
+        this.eventEmitter.emit('maximumSelling', val);
+    }
+    get amountToReceive() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_amountToReceive, "f");
+    }
+    set amountToReceive(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_amountToReceive, val, "f");
+        this.eventEmitter.emit('amountToReceive', val);
+    }
+    get deadline() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_deadline, "f");
+    }
+    set deadline(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_deadline, val, "f");
+        this.eventEmitter.emit('deadline', val);
+    }
+    get liquidityProviderFee() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_liquidityProviderFee, "f");
+    }
+    set liquidityProviderFee(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_liquidityProviderFee, val, "f");
+        this.eventEmitter.emit('liquidityProviderFee', val);
+    }
+    get priceImpact() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_priceImpact, "f");
+    }
+    set priceImpact(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_priceImpact, val, "f");
+        this.eventEmitter.emit('priceImpact', val);
+    }
+    get priceInverse() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_priceInverse, "f");
+    }
+    set priceInverse(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_priceInverse, val, "f");
+        this.eventEmitter.emit('priceInverse', val);
+    }
+    get routes() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_routes, "f");
+    }
+    set routes(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_routes, val, "f");
+        this.eventEmitter.emit('routes', val);
+    }
+    get reservesToUse() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_reservesToUse, "f");
+    }
+    set reservesToUse(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_reservesToUse, val, "f");
+        this.eventEmitter.emit('reservesToUse', val);
+    }
+    get reservesToReceive() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_reservesToReceive, "f");
+    }
+    set reservesToReceive(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_reservesToReceive, val, "f");
+        this.eventEmitter.emit('reservesToReceive', val);
+    }
+    get slippage() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_slippage, "f");
+    }
+    set slippage(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_slippage, val, "f");
+        this.eventEmitter.emit('slippage', val);
+    }
+    get tokenToReceive() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_tokenToReceive, "f");
+    }
+    set tokenToReceive(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_tokenToReceive, val, "f");
+        this.eventEmitter.emit('tokenToReceive', val);
+    }
+    get tokenToUse() {
+        return __classPrivateFieldGet(this, _FlamingoSwapControllerService_tokenToUse, "f");
+    }
+    set tokenToUse(val) {
+        __classPrivateFieldSet(this, _FlamingoSwapControllerService_tokenToUse, val, "f");
+        this.eventEmitter.emit('tokenToUse', val);
+    }
+}
+exports.FlamingoSwapControllerService = FlamingoSwapControllerService;
+_FlamingoSwapControllerService_network = new WeakMap(), _FlamingoSwapControllerService_accountToUse = new WeakMap(), _FlamingoSwapControllerService_tokenToReceive = new WeakMap(), _FlamingoSwapControllerService_tokenToUse = new WeakMap(), _FlamingoSwapControllerService_amountToReceive = new WeakMap(), _FlamingoSwapControllerService_amountToUse = new WeakMap(), _FlamingoSwapControllerService_minimumReceived = new WeakMap(), _FlamingoSwapControllerService_maximumSelling = new WeakMap(), _FlamingoSwapControllerService_reservesToReceive = new WeakMap(), _FlamingoSwapControllerService_reservesToUse = new WeakMap(), _FlamingoSwapControllerService_slippage = new WeakMap(), _FlamingoSwapControllerService_deadline = new WeakMap(), _FlamingoSwapControllerService_priceInverse = new WeakMap(), _FlamingoSwapControllerService_priceImpact = new WeakMap(), _FlamingoSwapControllerService_liquidityProviderFee = new WeakMap(), _FlamingoSwapControllerService_routes = new WeakMap(), _FlamingoSwapControllerService_lastAmountChange = new WeakMap();

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

@@ -0,0 +1,12 @@
+export declare class FlamingoSwapError extends Error {
+    constructor(message: string);
+}
+export declare class FlamingoSwapMissingParametersError extends FlamingoSwapError {
+    constructor(parameter: string);
+}
+export declare class CustomNetworkNotSupportedError extends FlamingoSwapError {
+    constructor();
+}
+export declare class FlamingoInvalidReservesResponseError extends FlamingoSwapError {
+    constructor();
+}

package/dist/flamingo-swap/FlamingoSwapError.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoInvalidReservesResponseError = exports.CustomNetworkNotSupportedError = exports.FlamingoSwapMissingParametersError = exports.FlamingoSwapError = void 0;
+class FlamingoSwapError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FlamingoSwapError';
+    }
+}
+exports.FlamingoSwapError = FlamingoSwapError;
+class FlamingoSwapMissingParametersError extends FlamingoSwapError {
+    constructor(parameter) {
+        super(`Missing parameter: ${parameter} for swap invocation`);
+    }
+}
+exports.FlamingoSwapMissingParametersError = FlamingoSwapMissingParametersError;
+class CustomNetworkNotSupportedError extends FlamingoSwapError {
+    constructor() {
+        super('Custom network is not supported');
+    }
+}
+exports.CustomNetworkNotSupportedError = CustomNetworkNotSupportedError;
+class FlamingoInvalidReservesResponseError extends FlamingoSwapError {
+    constructor() {
+        super('Invalid reserves response');
+    }
+}
+exports.FlamingoInvalidReservesResponseError = FlamingoInvalidReservesResponseError;

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

@@ -0,0 +1,34 @@
+import BigNumber from 'bignumber.js';
+import { Network, Token } from '@cityofzion/blockchain-service';
+type TGetSwapArgs = {
+    amountToUse: string | null;
+    amountToReceive: string | null;
+    tokenToUse: Token;
+    tokenToReceive: Token;
+    reservesToUse: string;
+    reservesToReceive: string;
+    slippage: number;
+    network: Network;
+};
+export declare class FlamingoSwapHelper {
+    static readonly BN_0: BigNumber;
+    static readonly BN_1: BigNumber;
+    static readonly BN_997: BigNumber;
+    static readonly BN_1000: BigNumber;
+    static readonly FEE_RATE: BigNumber;
+    static getSwapFields(params: TGetSwapArgs): {
+        amountToReceiveToDisplay: string;
+        amountToUseToDisplay: string;
+        liquidityProviderFee: string;
+        priceImpact: string | null;
+        priceInverse: string | null;
+        minimumReceived: string | null;
+        maximumSelling: string | null;
+    };
+    static overrideToken(network: Network, token: Token): Token;
+    private static createTradeData;
+    private static overrideAmountInput;
+    private static overrideAmountToDisplay;
+    private static normalizeHash;
+}
+export {};

package/dist/flamingo-swap/FlamingoSwapHelper.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapHelper = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const constants_1 = require("../constants");
+class FlamingoSwapHelper {
+    static getSwapFields(params) {
+        const reservesToUseBn = new bignumber_js_1.default(params.reservesToUse);
+        const reservesToReceiveBn = new bignumber_js_1.default(params.reservesToReceive);
+        if (reservesToUseBn.lt(this.BN_0) || reservesToReceiveBn.lt(this.BN_0)) {
+            throw new Error('Reserve should be positive number');
+        }
+        let amountToUseBn;
+        let amountToReceiveBn;
+        let amountToUseToDisplay;
+        let amountToReceiveToDisplay;
+        let maximumSelling = null;
+        let minimumReceived = null;
+        const slippageFormatted = new bignumber_js_1.default(params.slippage * 10).shiftedBy(-3);
+        if (params.amountToReceive) {
+            amountToReceiveBn = this.overrideAmountInput(params.network, params.amountToReceive, params.tokenToReceive);
+            amountToUseBn = reservesToUseBn
+                .times(amountToReceiveBn)
+                .times(this.BN_1000)
+                .idiv(reservesToReceiveBn.minus(amountToReceiveBn).times(this.BN_997))
+                .plus(this.BN_1);
+            maximumSelling = amountToUseBn
+                .times(this.BN_1.plus(slippageFormatted))
+                .dp(0)
+                .shiftedBy(-params.tokenToUse.decimals)
+                .toFixed();
+            amountToUseToDisplay = this.overrideAmountToDisplay(params.network, amountToUseBn.toFixed(), params.tokenToUse);
+            amountToReceiveToDisplay = params.amountToReceive;
+        }
+        else if (params.amountToUse) {
+            amountToUseBn = this.overrideAmountInput(params.network, params.amountToUse, params.tokenToUse);
+            const amountToUseWithFee = amountToUseBn.times(this.BN_997);
+            amountToReceiveBn = amountToUseWithFee
+                .times(params.reservesToReceive)
+                .idiv(reservesToUseBn.times(this.BN_1000).plus(amountToUseWithFee));
+            minimumReceived = amountToReceiveBn
+                .times(this.BN_1.minus(slippageFormatted))
+                .dp(0)
+                .shiftedBy(-params.tokenToReceive.decimals)
+                .toFixed();
+            amountToReceiveToDisplay = this.overrideAmountToDisplay(params.network, amountToReceiveBn.toString(), params.tokenToReceive);
+            amountToUseToDisplay = params.amountToUse;
+        }
+        else {
+            throw new Error('AmountToReceive or amountToUse are required, but both aren`t provided');
+        }
+        const route = [
+            {
+                assetToUseSymbol: this.overrideToken(params.network, params.tokenToUse).symbol,
+                reservesToReceive: params.reservesToReceive,
+                assetToReceiveSymbol: this.overrideToken(params.network, params.tokenToReceive).symbol,
+                reservesToUse: params.reservesToUse,
+            },
+        ];
+        const { fee, price, priceImpact } = this.createTradeData({
+            amountToReceive: amountToReceiveBn,
+            amountToUse: amountToUseBn,
+            route,
+        });
+        const priceInverse = this.BN_1.div(price);
+        const diffDecimals = params.tokenToUse.decimals - params.tokenToReceive.decimals;
+        return {
+            amountToReceiveToDisplay,
+            amountToUseToDisplay,
+            liquidityProviderFee: fee.shiftedBy(-8).plus(this.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,
+        };
+    }
+    static overrideToken(network, token) {
+        const neoScriptHash = constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type].neo;
+        const isNeoToken = this.normalizeHash(token.hash) === this.normalizeHash(neoScriptHash);
+        if (!isNeoToken) {
+            return token;
+        }
+        const bneoToken = constants_1.TOKENS[network.type].find(token => token.hash === constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type].bneo);
+        if (!bneoToken)
+            throw new Error('Bneo token not found');
+        return bneoToken;
+    }
+    static createTradeData({ amountToUse, amountToReceive, route }) {
+        const fee = amountToUse.minus(route.reduce((acc) => acc.times(this.BN_1.minus(this.FEE_RATE)), amountToUse));
+        const price = amountToUse.div(amountToReceive);
+        const midPrice = route.reduce((acc, item) => acc.times(item.reservesToUse).div(item.reservesToReceive), this.BN_1);
+        const priceImpact = price.minus(midPrice).div(price).minus(fee.div(amountToUse));
+        return {
+            fee,
+            price,
+            priceImpact,
+            midPrice,
+        };
+    }
+    static overrideAmountInput(network, amount, token) {
+        const tokenOverrode = this.overrideToken(network, token);
+        return new bignumber_js_1.default(amount).shiftedBy(tokenOverrode.decimals);
+    }
+    static overrideAmountToDisplay(network, amount, token) {
+        const tokenOverrode = this.overrideToken(network, token);
+        return new bignumber_js_1.default(amount).shiftedBy(-tokenOverrode.decimals).toFixed();
+    }
+    static normalizeHash(hash) {
+        return hash.startsWith('0x') ? hash.slice(2) : hash;
+    }
+}
+exports.FlamingoSwapHelper = FlamingoSwapHelper;
+FlamingoSwapHelper.BN_0 = new bignumber_js_1.default(0);
+FlamingoSwapHelper.BN_1 = new bignumber_js_1.default(1);
+FlamingoSwapHelper.BN_997 = new bignumber_js_1.default(997);
+FlamingoSwapHelper.BN_1000 = new bignumber_js_1.default(1000);
+FlamingoSwapHelper.FEE_RATE = new bignumber_js_1.default(0.003);

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

@@ -0,0 +1,18 @@
+import { ContractInvocationMulti } from '@cityofzion/neon-dappkit-types';
+import { Network, SwapControllerServiceSwapToUseArgs, SwapControllerServiceSwapToReceiveArgs } from '@cityofzion/blockchain-service';
+type GetReservesArgs = {
+    network: Network;
+    tokenToReceiveScriptHash: string;
+    tokenToUseScriptHash: string;
+};
+export declare class FlamingoSwapNeonDappKitInvocationBuilder {
+    static swapInvocation(data: SwapControllerServiceSwapToReceiveArgs | SwapControllerServiceSwapToUseArgs): ContractInvocationMulti;
+    static getReservesInvocation({ network, tokenToReceiveScriptHash, tokenToUseScriptHash, }: GetReservesArgs): ContractInvocationMulti;
+    private static swapTokenToReceiveForTokenToUseInvocation;
+    private static swapTokenToUseForTokenToReceiveInvocation;
+    private static transferContractInvocation;
+    private static allowedContractsSwap;
+    private static allowedContractsTransfer;
+    private static overrideScriptHash;
+}
+export {};

package/dist/flamingo-swap/FlamingoSwapNeonDappKitInvocationBuilder.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapNeonDappKitInvocationBuilder = void 0;
+const constants_1 = require("../constants");
+const neon_core_1 = require("@cityofzion/neon-core");
+const FlamingoSwapHelper_1 = require("./FlamingoSwapHelper");
+class FlamingoSwapNeonDappKitInvocationBuilder {
+    static swapInvocation(data) {
+        return data.type === 'swapTokenToReceive'
+            ? this.swapTokenToReceiveForTokenToUseInvocation(data)
+            : this.swapTokenToUseForTokenToReceiveInvocation(data);
+    }
+    static getReservesInvocation({ network, tokenToReceiveScriptHash, tokenToUseScriptHash, }) {
+        const flamingoSwapRouter = constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type].flamingoSwapRouter;
+        return {
+            invocations: [
+                {
+                    scriptHash: flamingoSwapRouter,
+                    operation: 'getReserves',
+                    args: [
+                        {
+                            type: 'Hash160',
+                            value: this.overrideScriptHash(network, tokenToReceiveScriptHash),
+                        },
+                        {
+                            type: 'Hash160',
+                            value: this.overrideScriptHash(network, tokenToUseScriptHash),
+                        },
+                    ],
+                },
+            ],
+            signers: [
+                {
+                    scopes: 1,
+                },
+            ],
+        };
+    }
+    static swapTokenToReceiveForTokenToUseInvocation({ address, amountToReceive, maximumSelling, tokenToReceive, tokenToUse, deadline, network, }) {
+        const invocations = [];
+        const allowedContracts = [];
+        const scriptHashes = constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type];
+        const tokenToReceiveOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToReceive);
+        const amountToReceiveFormatted = neon_core_1.u.BigInteger.fromDecimal(Number(amountToReceive), tokenToReceiveOverrode.decimals).toString();
+        const maximumSellingFormatted = neon_core_1.u.BigInteger.fromDecimal(Number(maximumSelling), tokenToUse.decimals).toString();
+        invocations.push({
+            scriptHash: scriptHashes.flamingoSwapRouter,
+            operation: 'swapTokenOutForTokenIn',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: address,
+                },
+                {
+                    type: 'Integer',
+                    value: amountToReceiveFormatted,
+                },
+                {
+                    type: 'Integer',
+                    value: maximumSellingFormatted,
+                },
+                {
+                    type: 'Array',
+                    value: [
+                        {
+                            type: 'Hash160',
+                            value: tokenToUse.hash,
+                        },
+                        {
+                            type: 'Hash160',
+                            value: tokenToReceiveOverrode.hash,
+                        },
+                    ],
+                },
+                {
+                    type: 'Integer',
+                    value: deadline,
+                },
+            ],
+        });
+        const isNeoSwapped = tokenToReceive.hash === scriptHashes.neo;
+        if (isNeoSwapped) {
+            const amountToUseInTransferFormatted = neon_core_1.u.BigInteger.fromNumber(Number(amountToReceiveFormatted) * constants_1.GAS_PER_NEO).toString();
+            const transferContractInvocation = this.transferContractInvocation({
+                address,
+                amountToUse: amountToUseInTransferFormatted,
+                tokenToUseScriptHash: scriptHashes.bneo,
+                contractScriptHash: scriptHashes.gas,
+            });
+            invocations.push(transferContractInvocation);
+            allowedContracts.push(...this.allowedContractsTransfer(scriptHashes));
+        }
+        allowedContracts.push(...this.allowedContractsSwap(scriptHashes, tokenToReceive.hash, tokenToUse.hash));
+        return {
+            invocations,
+            signers: [
+                {
+                    scopes: neon_core_1.tx.WitnessScope.CustomContracts,
+                    allowedContracts,
+                },
+            ],
+        };
+    }
+    static swapTokenToUseForTokenToReceiveInvocation({ address, amountToUse, deadline, tokenToReceive, tokenToUse, minimumReceived, network, }) {
+        const invocations = [];
+        const allowedContracts = [];
+        const scriptHashes = constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type];
+        const isNeoSwapped = tokenToUse.hash === scriptHashes.neo;
+        if (isNeoSwapped) {
+            const transferContractInvocation = this.transferContractInvocation({
+                address,
+                amountToUse,
+                tokenToUseScriptHash: scriptHashes.bneo,
+                contractScriptHash: scriptHashes.neo,
+            });
+            invocations.push(transferContractInvocation);
+            allowedContracts.push(...this.allowedContractsTransfer(scriptHashes));
+        }
+        const tokenToUseOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToUse);
+        const amountToUseFormatted = neon_core_1.u.BigInteger.fromDecimal(Number(amountToUse), tokenToUseOverrode.decimals).toString();
+        const minimumReceivedFormatted = neon_core_1.u.BigInteger.fromDecimal(Number(minimumReceived), tokenToReceive.decimals).toString();
+        invocations.push({
+            scriptHash: scriptHashes.flamingoSwapRouter,
+            operation: 'swapTokenInForTokenOut',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: address,
+                },
+                {
+                    type: 'Integer',
+                    value: amountToUseFormatted,
+                },
+                {
+                    type: 'Integer',
+                    value: minimumReceivedFormatted,
+                },
+                {
+                    type: 'Array',
+                    value: [
+                        {
+                            type: 'Hash160',
+                            value: tokenToUseOverrode.hash,
+                        },
+                        {
+                            type: 'Hash160',
+                            value: tokenToReceive.hash,
+                        },
+                    ],
+                },
+                {
+                    type: 'Integer',
+                    value: deadline,
+                },
+            ],
+        });
+        allowedContracts.push(...this.allowedContractsSwap(scriptHashes, tokenToReceive.hash, tokenToUse.hash));
+        return {
+            invocations,
+            signers: [
+                {
+                    scopes: neon_core_1.tx.WitnessScope.CustomContracts,
+                    allowedContracts,
+                },
+            ],
+        };
+    }
+    static transferContractInvocation({ address, amountToUse, contractScriptHash, tokenToUseScriptHash, }) {
+        return {
+            scriptHash: contractScriptHash,
+            operation: 'transfer',
+            args: [
+                {
+                    type: 'Hash160',
+                    value: address,
+                },
+                {
+                    type: 'Hash160',
+                    value: tokenToUseScriptHash,
+                },
+                {
+                    type: 'Integer',
+                    value: amountToUse,
+                },
+                {
+                    type: 'Any',
+                    value: null,
+                },
+            ],
+        };
+    }
+    static allowedContractsSwap(scriptHashes, tokenInScriptHash, tokenOutScriptHash) {
+        return [
+            scriptHashes.flamingoSwapRouter,
+            scriptHashes.flamingoFactory,
+            scriptHashes.flamingoPairWhiteList,
+            tokenInScriptHash,
+            tokenOutScriptHash,
+        ];
+    }
+    static allowedContractsTransfer(scriptHashes) {
+        return [scriptHashes.gas, scriptHashes.flpBneoGas, scriptHashes.bneo];
+    }
+    static overrideScriptHash(network, scriptHash) {
+        return scriptHash === constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type].neo
+            ? constants_1.SWAP_SCRIPT_HASHES_BY_NETWORK_TYPE[network.type].bneo
+            : scriptHash;
+    }
+}
+exports.FlamingoSwapNeonDappKitInvocationBuilder = FlamingoSwapNeonDappKitInvocationBuilder;

package/dist/index.d.ts

@@ -1,8 +1,13 @@
-export * from './DoraBDSNeo3';
-export * from './RpcBDSNeo3';
 export * from './BSNeo3';
 export * from './constants';
+export * from './DoraBDSNeo3';
+export * from './DoraESNeo3';
 export * from './FlamingoEDSNeo3';
 export * from './GhostMarketNDSNeo3';
-export * from './RpcNDSNeo3';
 export * from './LedgerServiceNeo3';
+export * from './RpcBDSNeo3';
+export * from './RpcNDSNeo3';
+export * from './flamingo-swap/FlamingoSwapControllerService';
+export * from './flamingo-swap/FlamingoSwapError';
+export * from './flamingo-swap/FlamingoSwapHelper';
+export * from './flamingo-swap/FlamingoSwapNeonDappKitInvocationBuilder';

package/dist/index.js

@@ -14,11 +14,16 @@ 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("./DoraBDSNeo3"), exports);
-__exportStar(require("./RpcBDSNeo3"), exports);
 __exportStar(require("./BSNeo3"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./DoraBDSNeo3"), exports);
+__exportStar(require("./DoraESNeo3"), exports);
 __exportStar(require("./FlamingoEDSNeo3"), exports);
 __exportStar(require("./GhostMarketNDSNeo3"), exports);
-__exportStar(require("./RpcNDSNeo3"), exports);
 __exportStar(require("./LedgerServiceNeo3"), exports);
+__exportStar(require("./RpcBDSNeo3"), exports);
+__exportStar(require("./RpcNDSNeo3"), exports);
+__exportStar(require("./flamingo-swap/FlamingoSwapControllerService"), exports);
+__exportStar(require("./flamingo-swap/FlamingoSwapError"), exports);
+__exportStar(require("./flamingo-swap/FlamingoSwapHelper"), exports);
+__exportStar(require("./flamingo-swap/FlamingoSwapNeonDappKitInvocationBuilder"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -19,8 +19,11 @@
     "@cityofzion/neon-dappkit": "0.4.1",
     "@cityofzion/neon-dappkit-types": "~0.3.1",
     "@ledgerhq/hw-transport-node-hid": "~6.28.5",
-    "@cityofzion/bs-asteroid-sdk": "0.8.1",
-    "@cityofzion/blockchain-service": "0.12.0"
+    "bignumber.js": "~9.1.2",
+    "typed-emitter": "~2.1.0",
+    "isomorphic-ws": "~5.0.0",
+    "@cityofzion/blockchain-service": "0.13.0",
+    "@cityofzion/bs-asteroid-sdk": "0.9.0"
   },
   "devDependencies": {
     "@types/jest": "29.5.3",