@cityofzion/bs-multichain 0.0.1 → 1.0.2

package/dist/BSAggregator.d.ts

@@ -0,0 +1,14 @@
+import { Account, BlockchainService, UntilIndexRecord } from '@cityofzion/blockchain-service';
+export declare class BSAggregator<BSName extends string> {
+    #private;
+    readonly blockchainServicesByName: Record<BSName, BlockchainService<BSName>>;
+    constructor(blockchainServices: BlockchainService<BSName>[]);
+    validateAddressAllBlockchains(address: string): boolean;
+    validateTextAllBlockchains(text: string): boolean;
+    validateKeyAllBlockchains(wif: string): boolean;
+    validateEncryptedAllBlockchains(keyOrJson: string): boolean;
+    getBlockchainNameByAddress(address: string): BSName[];
+    getBlockchainNameByKey(wif: string): BSName[];
+    getBlockchainNameByEncrypted(keyOrJson: string): BSName[];
+    generateAccountsFromMnemonic(mnemonic: string, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Map<BSName, Account<BSName>[]>>;
+}

package/dist/BSAggregator.js

@@ -0,0 +1,65 @@
+"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 _BSAggregator_blockchainServices;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSAggregator = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+class BSAggregator {
+    constructor(blockchainServices) {
+        _BSAggregator_blockchainServices.set(this, void 0);
+        __classPrivateFieldSet(this, _BSAggregator_blockchainServices, blockchainServices, "f");
+        this.blockchainServicesByName = blockchainServices.reduce((acc, service) => {
+            acc[service.name] = service;
+            return acc;
+        }, {});
+    }
+    validateAddressAllBlockchains(address) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateAddress(address));
+    }
+    validateTextAllBlockchains(text) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => [bs.validateAddress(text), bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
+    }
+    validateKeyAllBlockchains(wif) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateKey(wif));
+    }
+    validateEncryptedAllBlockchains(keyOrJson) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateEncrypted(keyOrJson));
+    }
+    getBlockchainNameByAddress(address) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateAddress(address)).map(bs => bs.name);
+    }
+    getBlockchainNameByKey(wif) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateKey(wif)).map(bs => bs.name);
+    }
+    getBlockchainNameByEncrypted(keyOrJson) {
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateEncrypted(keyOrJson)).map(bs => bs.name);
+    }
+    generateAccountsFromMnemonic(mnemonic, untilIndexByBlockchainService) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, blockchain_service_1.generateAccountForBlockchainService)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), (service, index) => __awaiter(this, void 0, void 0, function* () {
+                return service.generateAccountFromMnemonic(mnemonic, index);
+            }), untilIndexByBlockchainService);
+        });
+    }
+}
+exports.BSAggregator = BSAggregator;
+_BSAggregator_blockchainServices = new WeakMap();

package/dist/features/bridge/Neo3NeoXBridgeOrchestrator.d.ts

@@ -0,0 +1,21 @@
+import { Account, BalanceResponse, IBridgeOrchestrator, TBridgeOrchestratorEvents, TBridgeToken } from '@cityofzion/blockchain-service';
+import { BSNeo3 } from '@cityofzion/bs-neo3';
+import { BSNeoX } from '@cityofzion/bs-neox';
+import TypedEmitter from 'typed-emitter';
+import { TNeo3NeoXBridgeOrchestratorInitParams } from './types';
+export declare class Neo3NeoXBridgeOrchestrator<BSName extends string> implements IBridgeOrchestrator<BSName> {
+    #private;
+    eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<BSName>>;
+    fromService: BSNeo3<BSName> | BSNeoX<BSName>;
+    toService: BSNeo3<BSName> | BSNeoX<BSName>;
+    constructor(params: TNeo3NeoXBridgeOrchestratorInitParams<BSName>);
+    init(): Promise<void>;
+    switchTokens(): Promise<void>;
+    setTokenToUse(token: TBridgeToken | null): Promise<void>;
+    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+    setAddressToReceive(address: string | null): Promise<void>;
+    setBalances(balances: BalanceResponse[] | null): Promise<void>;
+    setAmountToUse(amount: string | null): Promise<void>;
+    bridge(): Promise<string>;
+    wait(): Promise<boolean>;
+}

package/dist/features/bridge/Neo3NeoXBridgeOrchestrator.js

@@ -0,0 +1,360 @@
+"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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Neo3NeoXBridgeOrchestrator_instances, _Neo3NeoXBridgeOrchestrator_balances, _Neo3NeoXBridgeOrchestrator_feeTokenBalance, _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout, _Neo3NeoXBridgeOrchestrator_transactionHash, _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse, _Neo3NeoXBridgeOrchestrator_internalTokenToUse, _Neo3NeoXBridgeOrchestrator_internalAccountToUse, _Neo3NeoXBridgeOrchestrator_internalAmountToUse, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax, _Neo3NeoXBridgeOrchestrator_internalTokenToReceive, _Neo3NeoXBridgeOrchestrator_internalAddressToReceive, _Neo3NeoXBridgeOrchestrator_internalAmountToReceive, _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance, _Neo3NeoXBridgeOrchestrator_internalBridgeFee, _Neo3NeoXBridgeOrchestrator_availableTokensToUse_get, _Neo3NeoXBridgeOrchestrator_availableTokensToUse_set, _Neo3NeoXBridgeOrchestrator_tokenToUse_get, _Neo3NeoXBridgeOrchestrator_tokenToUse_set, _Neo3NeoXBridgeOrchestrator_accountToUse_get, _Neo3NeoXBridgeOrchestrator_accountToUse_set, _Neo3NeoXBridgeOrchestrator_amountToUse_get, _Neo3NeoXBridgeOrchestrator_amountToUse_set, _Neo3NeoXBridgeOrchestrator_amountToUseMin_get, _Neo3NeoXBridgeOrchestrator_amountToUseMin_set, _Neo3NeoXBridgeOrchestrator_amountToUseMax_get, _Neo3NeoXBridgeOrchestrator_amountToUseMax_set, _Neo3NeoXBridgeOrchestrator_tokenToReceive_get, _Neo3NeoXBridgeOrchestrator_tokenToReceive_set, _Neo3NeoXBridgeOrchestrator_addressToReceive_get, _Neo3NeoXBridgeOrchestrator_addressToReceive_set, _Neo3NeoXBridgeOrchestrator_amountToReceive_get, _Neo3NeoXBridgeOrchestrator_amountToReceive_set, _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_get, _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_set, _Neo3NeoXBridgeOrchestrator_bridgeFee_get, _Neo3NeoXBridgeOrchestrator_bridgeFee_set, _Neo3NeoXBridgeOrchestrator_treatError;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo3NeoXBridgeOrchestrator = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const events_1 = __importDefault(require("events"));
+class Neo3NeoXBridgeOrchestrator {
+    constructor(params) {
+        _Neo3NeoXBridgeOrchestrator_instances.add(this);
+        _Neo3NeoXBridgeOrchestrator_balances.set(this, null);
+        _Neo3NeoXBridgeOrchestrator_feeTokenBalance.set(this, null);
+        _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout.set(this, undefined);
+        _Neo3NeoXBridgeOrchestrator_transactionHash.set(this, null);
+        _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalTokenToUse.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalAccountToUse.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalAmountToUse.set(this, { value: null, valid: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalTokenToReceive.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalAddressToReceive.set(this, { value: null, valid: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalAmountToReceive.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance.set(this, { value: null, loading: false, error: null });
+        _Neo3NeoXBridgeOrchestrator_internalBridgeFee.set(this, { value: null, loading: false, error: null });
+        this.eventEmitter = new events_1.default();
+        this.fromService = params.neo3Service;
+        this.toService = params.neoXService;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, {
+                value: this.fromService.neo3NeoXBridgeService.tokens,
+            }, "a", _Neo3NeoXBridgeOrchestrator_availableTokensToUse_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, valid: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, valid: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToReceive_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_tokenToReceive_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_transactionHash, null, "f");
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_balances, null, "f");
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_feeTokenBalance, null, "f");
+        });
+    }
+    switchTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fromService = this.fromService;
+            const toService = this.toService;
+            this.fromService = toService;
+            this.toService = fromService;
+            const tokenToReceive = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToReceive_get).value;
+            yield this.init();
+            yield this.setTokenToUse(tokenToReceive);
+        });
+    }
+    setTokenToUse(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let tokenToReceive;
+            try {
+                if (!__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_availableTokensToUse_get).value)
+                    throw new blockchain_service_1.BSError('No available tokens to use', 'NO_AVAILABLE_TOKENS');
+                if (token) {
+                    if (__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value && blockchain_service_1.BSTokenHelper.predicate(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value)(token))
+                        return;
+                    if (!__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_availableTokensToUse_get).value.some(blockchain_service_1.BSTokenHelper.predicate(token)))
+                        throw new blockchain_service_1.BSError('You are trying to use a token that is not available', 'TOKEN_NOT_AVAILABLE');
+                    tokenToReceive = this.toService.neo3NeoXBridgeService.tokens.find(item => token.multichainId === item.multichainId);
+                    if (!tokenToReceive)
+                        throw new blockchain_service_1.BSError('Pair token not found', 'PAIR_TOKEN_NOT_FOUND');
+                }
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: tokenToReceive !== null && tokenToReceive !== void 0 ? tokenToReceive : null, error: null }, "a", _Neo3NeoXBridgeOrchestrator_tokenToReceive_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: token, error: null }, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_set);
+            }
+            catch (error) {
+                const treatedError = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "m", _Neo3NeoXBridgeOrchestrator_treatError).call(this, error);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { error: treatedError }, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_set);
+                throw treatedError;
+            }
+            yield Promise.allSettled([this.setBalances(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_balances, "f")), this.setAmountToUse(null)]);
+        });
+    }
+    setAccountToUse(account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (account) {
+                    if (__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value && blockchain_service_1.BSAccountHelper.predicate(account)(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value))
+                        return;
+                    if (this.fromService.name !== account.blockchain)
+                        throw new blockchain_service_1.BSError('You are trying to use an account that is not compatible with the selected token', 'ACCOUNT_NOT_COMPATIBLE_WITH_TOKEN');
+                }
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: account, error: null }, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_set);
+                yield Promise.allSettled([this.setBalances(null), this.setAmountToUse(null)]);
+            }
+            catch (error) {
+                const treatedError = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "m", _Neo3NeoXBridgeOrchestrator_treatError).call(this, error);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { error: treatedError }, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_set);
+                throw treatedError;
+            }
+        });
+    }
+    setAddressToReceive(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, {
+                value: address,
+                loading: !!address,
+                valid: null,
+                error: null,
+            }, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_set);
+            if (__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout, "f") !== null)
+                clearTimeout(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout, "f"));
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout, setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                if (__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_get).value) {
+                    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, {
+                        valid: this.toService.validateAddress(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_get).value),
+                        loading: false,
+                    }, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_set);
+                }
+            }), 1500), "f");
+        });
+    }
+    setBalances(balances) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_balances, balances, "f");
+            const tokenToUseBalance = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value && balances
+                ? balances === null || balances === void 0 ? void 0 : balances.find(item => blockchain_service_1.BSTokenHelper.predicateByHash(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value)(item.token))
+                : null;
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, {
+                value: tokenToUseBalance,
+            }, "a", _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_set);
+            const feeTokenBalance = balances
+                ? balances === null || balances === void 0 ? void 0 : balances.find(item => blockchain_service_1.BSTokenHelper.predicateByHash(this.fromService.feeToken)(item.token))
+                : null;
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_feeTokenBalance, feeTokenBalance, "f");
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: true, error: null }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: true, error: null }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: true, error: null }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+            try {
+                if (tokenToUseBalance === null || !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value)
+                    throw new blockchain_service_1.BSError('Token to use is not set', 'TOKEN_NOT_SET');
+                const constants = yield this.fromService.neo3NeoXBridgeService.getBridgeConstants(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: constants.bridgeMinAmount }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: constants.bridgeFee }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+                const bridgeMaxAmountBn = blockchain_service_1.BSBigNumberHelper.fromNumber(constants.bridgeMaxAmount);
+                const tokenBalanceAmountBn = blockchain_service_1.BSBigNumberHelper.fromNumber((_a = tokenToUseBalance === null || tokenToUseBalance === void 0 ? void 0 : tokenToUseBalance.amount) !== null && _a !== void 0 ? _a : 0);
+                const max = Math.max(0, Math.min(bridgeMaxAmountBn.toNumber(), tokenBalanceAmountBn.minus(constants.bridgeFee).toNumber()));
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: blockchain_service_1.BSBigNumberHelper.format(max, { decimals: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value.decimals }) }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_set);
+            }
+            catch (error) {
+                const treatedError = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "m", _Neo3NeoXBridgeOrchestrator_treatError).call(this, error);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, error: treatedError }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, error: treatedError }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: null, error: treatedError }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+                throw treatedError;
+            }
+            finally {
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: false }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+            }
+        });
+    }
+    setAmountToUse(amount) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedAmount = amount && __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value
+                ? blockchain_service_1.BSBigNumberHelper.format(amount, { decimals: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value.decimals })
+                : amount;
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: formattedAmount }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { value: formattedAmount }, "a", _Neo3NeoXBridgeOrchestrator_amountToReceive_set);
+            if (formattedAmount === null) {
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { valid: null, loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+                return;
+            }
+            try {
+                if (__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value === null ||
+                    __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_get).value === null ||
+                    __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_get).value === null ||
+                    __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_get).value === null ||
+                    __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value === null ||
+                    __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_feeTokenBalance, "f") === null) {
+                    throw new blockchain_service_1.BSError('Required parameters are not set', 'REQUIRED_PARAMETERS_NOT_SET');
+                }
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: true }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: true }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+                const amountToUseBn = blockchain_service_1.BSBigNumberHelper.fromNumber(formattedAmount);
+                if (amountToUseBn.isLessThan(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMin_get).value) ||
+                    amountToUseBn.isGreaterThan(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_get).value)) {
+                    throw new blockchain_service_1.BSError('Amount is out of range', 'AMOUNT_OUT_OF_RANGE');
+                }
+                const approvalFee = yield this.fromService.neo3NeoXBridgeService
+                    .getApprovalFee({
+                    account: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value,
+                    token: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value,
+                    amount: formattedAmount,
+                })
+                    .then(fee => fee)
+                    .catch(() => '0');
+                const newBridgeFee = blockchain_service_1.BSBigNumberHelper.fromNumber(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_get).value).plus(approvalFee);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, {
+                    value: blockchain_service_1.BSBigNumberHelper.format(newBridgeFee, { decimals: this.fromService.feeToken.decimals }),
+                }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+                const isFeeToken = blockchain_service_1.BSTokenHelper.predicateByHash(this.fromService.feeToken)(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value);
+                if (newBridgeFee.plus(isFeeToken ? amountToUseBn : 0).isGreaterThan((_b = (_a = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_feeTokenBalance, "f")) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : 0)) {
+                    throw new blockchain_service_1.BSError('You do not have enough fee token balance to cover the bridge fee', 'INSUFFICIENT_FEE_TOKEN_BALANCE');
+                }
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { valid: true }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+            }
+            catch (error) {
+                const treatedError = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "m", _Neo3NeoXBridgeOrchestrator_treatError).call(this, error);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { valid: false, error: treatedError }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+                throw treatedError;
+            }
+            finally {
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: false }, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_set);
+                __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, { loading: false }, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_set);
+            }
+        });
+    }
+    bridge() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToReceive_get).value ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_get).valid ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_get).value ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToReceive_get).value ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_get).value ||
+                !__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_get).value) {
+                throw new blockchain_service_1.BSError('Required parameters are not set for bridging', 'BRIDGE_NOT_READY');
+            }
+            const transaction = yield this.fromService.neo3NeoXBridgeService.bridge({
+                account: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value,
+                token: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value,
+                amount: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUse_get).value,
+                receiverAddress: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_addressToReceive_get).value,
+                bridgeFee: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_bridgeFee_get).value,
+            });
+            __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_transactionHash, transaction, "f");
+            return transaction;
+        });
+    }
+    wait() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_transactionHash, "f") === null || __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value === null) {
+                throw new blockchain_service_1.BSError('You need to bridge before', 'BRIDGE_NOT_EXECUTED');
+            }
+            try {
+                const transactionHash = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_transactionHash, "f");
+                const token = __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value;
+                const nonce = yield blockchain_service_1.BSUtilsHelper.retry(() => this.fromService.neo3NeoXBridgeService.getNonce({
+                    token,
+                    transactionHash,
+                }), {
+                    retries: 10,
+                    delay: 30000,
+                });
+                if (!nonce) {
+                    return false;
+                }
+                yield blockchain_service_1.BSUtilsHelper.retry(() => this.toService.neo3NeoXBridgeService.getTransactionHashByNonce({ nonce, token }), {
+                    retries: 10,
+                    delay: 30000,
+                });
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+}
+exports.Neo3NeoXBridgeOrchestrator = Neo3NeoXBridgeOrchestrator;
+_Neo3NeoXBridgeOrchestrator_balances = new WeakMap(), _Neo3NeoXBridgeOrchestrator_feeTokenBalance = new WeakMap(), _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout = new WeakMap(), _Neo3NeoXBridgeOrchestrator_transactionHash = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalTokenToUse = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAccountToUse = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAmountToUse = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalTokenToReceive = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAddressToReceive = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalAmountToReceive = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance = new WeakMap(), _Neo3NeoXBridgeOrchestrator_internalBridgeFee = new WeakMap(), _Neo3NeoXBridgeOrchestrator_instances = new WeakSet(), _Neo3NeoXBridgeOrchestrator_availableTokensToUse_get = function _Neo3NeoXBridgeOrchestrator_availableTokensToUse_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse, "f");
+}, _Neo3NeoXBridgeOrchestrator_availableTokensToUse_set = function _Neo3NeoXBridgeOrchestrator_availableTokensToUse_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse, "f")), value), "f");
+    this.eventEmitter.emit('availableTokensToUse', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse, "f"));
+}, _Neo3NeoXBridgeOrchestrator_tokenToUse_get = function _Neo3NeoXBridgeOrchestrator_tokenToUse_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUse, "f");
+}, _Neo3NeoXBridgeOrchestrator_tokenToUse_set = function _Neo3NeoXBridgeOrchestrator_tokenToUse_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUse, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUse, "f")), value), "f");
+    this.eventEmitter.emit('tokenToUse', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUse, "f"));
+}, _Neo3NeoXBridgeOrchestrator_accountToUse_get = function _Neo3NeoXBridgeOrchestrator_accountToUse_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAccountToUse, "f");
+}, _Neo3NeoXBridgeOrchestrator_accountToUse_set = function _Neo3NeoXBridgeOrchestrator_accountToUse_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAccountToUse, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAccountToUse, "f")), value), "f");
+    this.eventEmitter.emit('accountToUse', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAccountToUse, "f"));
+}, _Neo3NeoXBridgeOrchestrator_amountToUse_get = function _Neo3NeoXBridgeOrchestrator_amountToUse_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUse, "f");
+}, _Neo3NeoXBridgeOrchestrator_amountToUse_set = function _Neo3NeoXBridgeOrchestrator_amountToUse_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUse, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUse, "f")), value), "f");
+    this.eventEmitter.emit('amountToUse', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUse, "f"));
+}, _Neo3NeoXBridgeOrchestrator_amountToUseMin_get = function _Neo3NeoXBridgeOrchestrator_amountToUseMin_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin, "f");
+}, _Neo3NeoXBridgeOrchestrator_amountToUseMin_set = function _Neo3NeoXBridgeOrchestrator_amountToUseMin_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin, "f")), value), "f");
+    this.eventEmitter.emit('amountToUseMin', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMin, "f"));
+}, _Neo3NeoXBridgeOrchestrator_amountToUseMax_get = function _Neo3NeoXBridgeOrchestrator_amountToUseMax_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax, "f");
+}, _Neo3NeoXBridgeOrchestrator_amountToUseMax_set = function _Neo3NeoXBridgeOrchestrator_amountToUseMax_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax, "f")), value), "f");
+    this.eventEmitter.emit('amountToUseMax', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToUseMax, "f"));
+}, _Neo3NeoXBridgeOrchestrator_tokenToReceive_get = function _Neo3NeoXBridgeOrchestrator_tokenToReceive_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToReceive, "f");
+}, _Neo3NeoXBridgeOrchestrator_tokenToReceive_set = function _Neo3NeoXBridgeOrchestrator_tokenToReceive_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToReceive, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToReceive, "f")), value), "f");
+    this.eventEmitter.emit('tokenToReceive', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToReceive, "f"));
+}, _Neo3NeoXBridgeOrchestrator_addressToReceive_get = function _Neo3NeoXBridgeOrchestrator_addressToReceive_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAddressToReceive, "f");
+}, _Neo3NeoXBridgeOrchestrator_addressToReceive_set = function _Neo3NeoXBridgeOrchestrator_addressToReceive_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAddressToReceive, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAddressToReceive, "f")), value), "f");
+    this.eventEmitter.emit('addressToReceive', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAddressToReceive, "f"));
+}, _Neo3NeoXBridgeOrchestrator_amountToReceive_get = function _Neo3NeoXBridgeOrchestrator_amountToReceive_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToReceive, "f");
+}, _Neo3NeoXBridgeOrchestrator_amountToReceive_set = function _Neo3NeoXBridgeOrchestrator_amountToReceive_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToReceive, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToReceive, "f")), value), "f");
+    this.eventEmitter.emit('amountToReceive', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalAmountToReceive, "f"));
+}, _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_get = function _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance, "f");
+}, _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_set = function _Neo3NeoXBridgeOrchestrator_tokenToUseBalance_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance, "f")), value), "f");
+    this.eventEmitter.emit('tokenToUseBalance', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalTokenToUseBalance, "f"));
+}, _Neo3NeoXBridgeOrchestrator_bridgeFee_get = function _Neo3NeoXBridgeOrchestrator_bridgeFee_get() {
+    return __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalBridgeFee, "f");
+}, _Neo3NeoXBridgeOrchestrator_bridgeFee_set = function _Neo3NeoXBridgeOrchestrator_bridgeFee_set(value) {
+    __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_internalBridgeFee, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalBridgeFee, "f")), value), "f");
+    this.eventEmitter.emit('bridgeFee', __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_internalBridgeFee, "f"));
+}, _Neo3NeoXBridgeOrchestrator_treatError = function _Neo3NeoXBridgeOrchestrator_treatError(error) {
+    if (error instanceof blockchain_service_1.BSError)
+        return error;
+    return new blockchain_service_1.BSError('An unexpected error occurred', 'UNEXPECTED_ERROR', { cause: error });
+};

package/dist/features/bridge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './Neo3NeoXBridgeOrchestrator';

package/dist/features/bridge/index.js

@@ -0,0 +1,18 @@
+"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("./types"), exports);
+__exportStar(require("./Neo3NeoXBridgeOrchestrator"), exports);

package/dist/features/bridge/types.d.ts

@@ -0,0 +1,6 @@
+import { BSNeo3 } from '@cityofzion/bs-neo3';
+import { BSNeoX } from '@cityofzion/bs-neox';
+export type TNeo3NeoXBridgeOrchestratorInitParams<BSName extends string> = {
+    neo3Service: BSNeo3<BSName>;
+    neoXService: BSNeoX<BSName>;
+};

package/dist/features/bridge/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,23 @@
+import { TSimpleSwapApiCreateExchangeParams, TSimpleSwapApiCurrency, TSimpleSwapOrchestratorInitParams } from './types';
+export declare class SimpleSwapApi<BSName extends string = string> {
+    #private;
+    constructor();
+    getCurrencies(options: TSimpleSwapOrchestratorInitParams<BSName>): Promise<TSimpleSwapApiCurrency<BSName>[]>;
+    getPairs(ticker: string, network: string): Promise<TSimpleSwapApiCurrency<BSName>[]>;
+    getRange(currencyFrom: TSimpleSwapApiCurrency, currencyTo: TSimpleSwapApiCurrency): Promise<{
+        min: string;
+        max: string | null;
+    }>;
+    getEstimate(currencyFrom: TSimpleSwapApiCurrency, currencyTo: TSimpleSwapApiCurrency, amount: string): Promise<string>;
+    createExchange({ currencyFrom, currencyTo, amount, refundAddress, address, extraIdToReceive, }: TSimpleSwapApiCreateExchangeParams): Promise<{
+        id: string;
+        depositAddress: string;
+        log: string;
+    }>;
+    getExchange(id: string): Promise<{
+        status: string;
+        txFrom: string | undefined;
+        txTo: string | undefined;
+        log: string;
+    }>;
+}