@cityofzion/bs-multichain 1.0.14 → 1.1.0

package/dist/BSAggregator.d.ts

@@ -1,14 +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>[]);
+import { TBSAccount, IBlockchainService, TUntilIndexRecord } from '@cityofzion/blockchain-service';
+export declare class BSAggregator<N extends string> {
+    readonly blockchainServicesByName: Record<N, IBlockchainService<N>>;
+    readonly blockchainServices: IBlockchainService<N>[];
+    constructor(blockchainServices: IBlockchainService<N>[]);
     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>[]>>;
+    getBlockchainNameByAddress(address: string): N[];
+    getBlockchainNameByKey(wif: string): N[];
+    getBlockchainNameByEncrypted(keyOrJson: string): N[];
+    generateAccountsFromMnemonic(mnemonic: string, untilIndexByBlockchainService?: TUntilIndexRecord<N>): Promise<Map<N, TBSAccount<N>[]>>;
 }

package/dist/BSAggregator.js

@@ -8,60 +8,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.blockchainServices = blockchainServices;
         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));
+        return this.blockchainServices.some(bs => bs.validateAddress(address));
     }
     validateTextAllBlockchains(text) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => [bs.validateAddress(text), (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
+        return this.blockchainServices.some(bs => [bs.validateAddress(text), (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
     }
     validateKeyAllBlockchains(wif) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateKey(wif));
+        return this.blockchainServices.some(bs => bs.validateKey(wif));
     }
     validateEncryptedAllBlockchains(keyOrJson) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson));
+        return this.blockchainServices.some(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson));
     }
     getBlockchainNameByAddress(address) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateAddress(address)).map(bs => bs.name);
+        return this.blockchainServices.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);
+        return this.blockchainServices.filter(bs => bs.validateKey(wif)).map(bs => bs.name);
     }
     getBlockchainNameByEncrypted(keyOrJson) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f")
-            .filter(bs => (0, blockchain_service_1.hasEncryption)(bs) && bs.validateEncrypted(keyOrJson))
-            .map(bs => bs.name);
+        return this.blockchainServices.filter(bs => (0, blockchain_service_1.hasEncryption)(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 (0, blockchain_service_1.generateAccountForBlockchainService)(this.blockchainServices, (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

@@ -1,21 +1,21 @@
-import { Account, BalanceResponse, IBridgeOrchestrator, TBridgeOrchestratorEvents, TBridgeToken } from '@cityofzion/blockchain-service';
+import { TBSAccount, TBalanceResponse, 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, TNeo3NeoXBridgeOrchestratorWaitParams } from './types';
-export declare class Neo3NeoXBridgeOrchestrator<BSName extends string> implements IBridgeOrchestrator<BSName> {
+export declare class Neo3NeoXBridgeOrchestrator<N extends string> implements IBridgeOrchestrator<N> {
     #private;
-    eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<BSName>>;
-    fromService: BSNeo3<BSName> | BSNeoX<BSName>;
-    toService: BSNeo3<BSName> | BSNeoX<BSName>;
-    constructor(params: TNeo3NeoXBridgeOrchestratorInitParams<BSName>);
+    eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<N>>;
+    fromService: BSNeo3<N> | BSNeoX<N>;
+    toService: BSNeo3<N> | BSNeoX<N>;
+    constructor(params: TNeo3NeoXBridgeOrchestratorInitParams<N>);
     init(): Promise<void>;
     switchTokens(): Promise<void>;
-    setTokenToUse(token: TBridgeToken<BSName> | null): Promise<void>;
-    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+    setTokenToUse(token: TBridgeToken<N> | null): Promise<void>;
+    setAccountToUse(account: TBSAccount<N> | null): Promise<void>;
     setAddressToReceive(address: string | null): Promise<void>;
-    setBalances(balances: BalanceResponse[] | null): Promise<void>;
+    setBalances(balances: TBalanceResponse[] | null): Promise<void>;
     setAmountToUse(amount: string | null): Promise<void>;
     bridge(): Promise<string>;
-    static wait<BSName extends string = string>({ tokenToUse, tokenToReceive, transactionHash, neo3Service, neoXService, }: TNeo3NeoXBridgeOrchestratorWaitParams<BSName>): Promise<void>;
+    static wait<N extends string = string>({ tokenToUse, tokenToReceive, transactionHash, neo3Service, neoXService, }: TNeo3NeoXBridgeOrchestratorWaitParams<N>): Promise<void>;
 }

package/dist/features/bridge/Neo3NeoXBridgeOrchestrator.js

@@ -53,7 +53,7 @@ class Neo3NeoXBridgeOrchestrator {
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             __classPrivateFieldSet(this, _Neo3NeoXBridgeOrchestrator_instances, {
-                value: this.fromService.neo3NeoXBridgeService.tokens,
+                value: [this.fromService.neo3NeoXBridgeService.gasToken, this.fromService.neo3NeoXBridgeService.neoToken],
             }, "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);
@@ -91,9 +91,10 @@ class Neo3NeoXBridgeOrchestrator {
                         return;
                     if (!__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_availableTokensToUse_get).value.some(currentToken => this.fromService.tokenService.predicate(token, currentToken)))
                         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');
+                    const isGasToken = this.fromService.tokenService.predicateByHash(token, this.fromService.neo3NeoXBridgeService.gasToken);
+                    tokenToReceive = isGasToken
+                        ? this.toService.neo3NeoXBridgeService.gasToken
+                        : this.toService.neo3NeoXBridgeService.neoToken;
                 }
                 __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);
@@ -146,8 +147,8 @@ class Neo3NeoXBridgeOrchestrator {
         });
     }
     setBalances(balances) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             __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 => this.fromService.tokenService.predicateByHash(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value, item.token))
@@ -276,8 +277,8 @@ class Neo3NeoXBridgeOrchestrator {
             });
         });
     }
-    static wait({ tokenToUse, tokenToReceive, transactionHash, neo3Service, neoXService, }) {
-        return __awaiter(this, void 0, void 0, function* () {
+    static wait(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ tokenToUse, tokenToReceive, transactionHash, neo3Service, neoXService, }) {
             const isNeo3Service = tokenToUse.blockchain === neo3Service.name;
             const fromService = isNeo3Service ? neo3Service : neoXService;
             const toService = isNeo3Service ? neoXService : neo3Service;

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

@@ -1,15 +1,15 @@
 import { TBridgeToken } from '@cityofzion/blockchain-service';
 import { BSNeo3 } from '@cityofzion/bs-neo3';
 import { BSNeoX } from '@cityofzion/bs-neox';
-export type TNeo3NeoXBridgeOrchestratorInitParams<BSName extends string> = {
-    neo3Service: BSNeo3<BSName>;
-    neoXService: BSNeoX<BSName>;
-    initialFromServiceName?: BSName;
+export type TNeo3NeoXBridgeOrchestratorInitParams<N extends string> = {
+    neo3Service: BSNeo3<N>;
+    neoXService: BSNeoX<N>;
+    initialFromServiceName?: N;
 };
-export type TNeo3NeoXBridgeOrchestratorWaitParams<BSName extends string = string> = {
-    neo3Service: BSNeo3<BSName>;
-    neoXService: BSNeoX<BSName>;
+export type TNeo3NeoXBridgeOrchestratorWaitParams<N extends string = string> = {
+    neo3Service: BSNeo3<N>;
+    neoXService: BSNeoX<N>;
     transactionHash: string;
-    tokenToUse: TBridgeToken<BSName>;
-    tokenToReceive: TBridgeToken<BSName>;
+    tokenToUse: TBridgeToken<N>;
+    tokenToReceive: TBridgeToken<N>;
 };

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

@@ -1,9 +1,8 @@
 import { TSimpleSwapApiCreateExchangeParams, TSimpleSwapApiCurrency, TSimpleSwapOrchestratorInitParams } from './types';
-export declare class SimpleSwapApi<BSName extends string = string> {
+export declare class SimpleSwapApi<N extends string> {
     #private;
-    constructor();
-    getCurrencies(options: TSimpleSwapOrchestratorInitParams<BSName>): Promise<TSimpleSwapApiCurrency<BSName>[]>;
-    getPairs(ticker: string, network: string): Promise<TSimpleSwapApiCurrency<BSName>[]>;
+    getCurrencies(options: TSimpleSwapOrchestratorInitParams<N>): Promise<TSimpleSwapApiCurrency<N>[]>;
+    getPairs(ticker: string, network: string): Promise<TSimpleSwapApiCurrency<N>[]>;
     getRange(currencyFrom: TSimpleSwapApiCurrency, currencyTo: TSimpleSwapApiCurrency): Promise<{
         min: string;
         max: string | null;

package/dist/features/swap/SimpleSwapApi.js

@@ -8,21 +8,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _SimpleSwapApi_instances, _SimpleSwapApi_tickersBySimpleSwapBlockchain, _SimpleSwapApi_axios, _SimpleSwapApi_allCurrenciesMap, _SimpleSwapApi_createAddressTemplateUrl, _SimpleSwapApi_createTxTemplateUrl, _SimpleSwapApi_getTokenFromCurrency;
+var _SimpleSwapApi_instances, _SimpleSwapApi_tickersBySimpleSwapBlockchain, _SimpleSwapApi_apiInstance, _SimpleSwapApi_allCurrenciesMap, _SimpleSwapApi_api_get, _SimpleSwapApi_createAddressTemplateUrl, _SimpleSwapApi_createTxTemplateUrl, _SimpleSwapApi_getTokenFromCurrency;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleSwapApi = void 0;
 const axios_1 = __importDefault(require("axios"));
@@ -36,25 +36,17 @@ class SimpleSwapApi {
                 gasn3: 'gas',
             },
         });
-        _SimpleSwapApi_axios.set(this, void 0);
+        _SimpleSwapApi_apiInstance.set(this, void 0);
         _SimpleSwapApi_allCurrenciesMap.set(this, new Map());
-        __classPrivateFieldSet(this, _SimpleSwapApi_axios, axios_1.default.create({
-            baseURL: `${blockchain_service_1.BSCommonConstants.DORA_URL}/api/v2/swap`,
-            headers: {
-                'Cache-Control': 'no-cache',
-                Pragma: 'no-cache',
-                Expires: '0',
-            },
-        }), "f");
     }
     getCurrencies(options) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
                 if (__classPrivateFieldGet(this, _SimpleSwapApi_allCurrenciesMap, "f").size) {
                     return Array.from(__classPrivateFieldGet(this, _SimpleSwapApi_allCurrenciesMap, "f").values());
                 }
-                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get('/currencies');
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_instances, "a", _SimpleSwapApi_api_get).get('/currencies');
                 const tokens = [];
                 response.data.result.forEach(currency => {
                     const token = __classPrivateFieldGet(this, _SimpleSwapApi_instances, "m", _SimpleSwapApi_getTokenFromCurrency).call(this, currency, options);
@@ -76,10 +68,10 @@ class SimpleSwapApi {
         });
     }
     getPairs(ticker, network) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             try {
-                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get(`/pairs/${ticker}/${network}`);
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_instances, "a", _SimpleSwapApi_api_get).get(`/pairs/${ticker}/${network}`);
                 const pairs = (_a = response.data.result[`${ticker}:${network}`]) !== null && _a !== void 0 ? _a : [];
                 const tokens = [];
                 pairs.forEach(pair => {
@@ -98,10 +90,10 @@ class SimpleSwapApi {
         });
     }
     getRange(currencyFrom, currencyTo) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
-                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get('/ranges', {
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_instances, "a", _SimpleSwapApi_api_get).get('/ranges', {
                     params: {
                         tickerFrom: currencyFrom.ticker,
                         tickerTo: currencyTo.ticker,
@@ -120,10 +112,10 @@ class SimpleSwapApi {
         });
     }
     getEstimate(currencyFrom, currencyTo, amount) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
-                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get('/estimates', {
+                const response = yield __classPrivateFieldGet(this, _SimpleSwapApi_instances, "a", _SimpleSwapApi_api_get).get('/estimates', {
                     params: {
                         tickerFrom: currencyFrom.ticker,
                         tickerTo: currencyTo.ticker,
@@ -142,11 +134,11 @@ class SimpleSwapApi {
             }
         });
     }
-    createExchange({ currencyFrom, currencyTo, amount, refundAddress, address, extraIdToReceive, }) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
+    createExchange(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ currencyFrom, currencyTo, amount, refundAddress, address, extraIdToReceive, }) {
+            var _b, _c;
             try {
-                const { data: { result }, } = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").post('/exchanges', {
+                const { data: { result }, } = yield __classPrivateFieldGet(this, _SimpleSwapApi_instances, "a", _SimpleSwapApi_api_get).post('/exchanges', {
                     tickerFrom: currencyFrom.ticker,
                     networkFrom: currencyFrom.network,
                     tickerTo: currencyTo.ticker,
@@ -154,7 +146,7 @@ class SimpleSwapApi {
                     amount,
                     userRefundAddress: refundAddress,
                     addressTo: address,
-                    extraIdTo: (_a = extraIdToReceive === null || extraIdToReceive === void 0 ? void 0 : extraIdToReceive.trim()) !== null && _a !== void 0 ? _a : null,
+                    extraIdTo: (_b = extraIdToReceive === null || extraIdToReceive === void 0 ? void 0 : extraIdToReceive.trim()) !== null && _b !== void 0 ? _b : null,
                 });
                 return {
                     id: result.id,
@@ -163,7 +155,7 @@ class SimpleSwapApi {
                 };
             }
             catch (error) {
-                if (axios_1.default.isAxiosError(error) && ((_b = error.response) === null || _b === void 0 ? void 0 : _b.data.message)) {
+                if (axios_1.default.isAxiosError(error) && ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data.message)) {
                     throw new Error(error.response.data.message);
                 }
                 throw error;
@@ -171,10 +163,10 @@ class SimpleSwapApi {
         });
     }
     getExchange(id) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
-                const { data: { result }, } = yield __classPrivateFieldGet(this, _SimpleSwapApi_axios, "f").get(`/exchanges/${id}`);
+                const { data: { result }, } = yield __classPrivateFieldGet(this, _SimpleSwapApi_instances, "a", _SimpleSwapApi_api_get).get(`/exchanges/${id}`);
                 return {
                     status: result.status,
                     txFrom: result.txFrom,
@@ -192,7 +184,19 @@ class SimpleSwapApi {
     }
 }
 exports.SimpleSwapApi = SimpleSwapApi;
-_SimpleSwapApi_tickersBySimpleSwapBlockchain = new WeakMap(), _SimpleSwapApi_axios = new WeakMap(), _SimpleSwapApi_allCurrenciesMap = new WeakMap(), _SimpleSwapApi_instances = new WeakSet(), _SimpleSwapApi_createAddressTemplateUrl = function _SimpleSwapApi_createAddressTemplateUrl(blockchainService, explorer) {
+_SimpleSwapApi_tickersBySimpleSwapBlockchain = new WeakMap(), _SimpleSwapApi_apiInstance = new WeakMap(), _SimpleSwapApi_allCurrenciesMap = new WeakMap(), _SimpleSwapApi_instances = new WeakSet(), _SimpleSwapApi_api_get = function _SimpleSwapApi_api_get() {
+    if (!__classPrivateFieldGet(this, _SimpleSwapApi_apiInstance, "f")) {
+        __classPrivateFieldSet(this, _SimpleSwapApi_apiInstance, axios_1.default.create({
+            baseURL: `${blockchain_service_1.BSCommonConstants.DORA_URL}/api/v2/swap`,
+            headers: {
+                'Cache-Control': 'no-cache',
+                Pragma: 'no-cache',
+                Expires: '0',
+            },
+        }), "f");
+    }
+    return __classPrivateFieldGet(this, _SimpleSwapApi_apiInstance, "f");
+}, _SimpleSwapApi_createAddressTemplateUrl = function _SimpleSwapApi_createAddressTemplateUrl(blockchainService, explorer) {
     var _a;
     explorer = !explorer ? undefined : explorer.replace('{}', '{address}');
     if (blockchainService && (0, blockchain_service_1.hasExplorerService)(blockchainService))
@@ -223,7 +227,7 @@ _SimpleSwapApi_tickersBySimpleSwapBlockchain = new WeakMap(), _SimpleSwapApi_axi
         blockchain = chainsByServiceNameEntry[0];
         blockchainService = options.blockchainServicesByName[blockchain];
         const normalizedHash = hash && blockchainService ? blockchainService.tokenService.normalizeHash(hash) : '';
-        const token = blockchainService.tokens.find(item => {
+        const token = blockchainService === null || blockchainService === void 0 ? void 0 : blockchainService.tokens.find(item => {
             if (normalizedHash && blockchainService && blockchainService.tokenService.predicateByHash(item, normalizedHash))
                 return true;
             const currentLowerCaseSymbol = item.symbol.toLowerCase();

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

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

package/dist/features/swap/SimpleSwapOrchestrator.js

@@ -75,8 +75,8 @@ class SimpleSwapOrchestrator {
         });
     }
     setTokenToUse(token) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { loading: false, value: null }, "a", _SimpleSwapOrchestrator_amountToReceive_set);
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { loading: false, value: null }, "a", _SimpleSwapOrchestrator_amountToUseMinMax_set);
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { loading: true }, "a", _SimpleSwapOrchestrator_tokenToUse_set);
@@ -124,8 +124,8 @@ class SimpleSwapOrchestrator {
         });
     }
     setTokenToReceive(token) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { value: null, valid: null }, "a", _SimpleSwapOrchestrator_extraIdToReceive_set);
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { loading: false, value: null }, "a", _SimpleSwapOrchestrator_amountToReceive_set);
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { loading: false, value: null }, "a", _SimpleSwapOrchestrator_amountToUseMinMax_set);
@@ -153,8 +153,8 @@ class SimpleSwapOrchestrator {
         });
     }
     setExtraIdToReceive(extraIdToReceive) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!((_a = __classPrivateFieldGet(this, _SimpleSwapOrchestrator_instances, "a", _SimpleSwapOrchestrator_tokenToReceive_get).value) === null || _a === void 0 ? void 0 : _a.hasExtraId))
                 return;
             __classPrivateFieldSet(this, _SimpleSwapOrchestrator_instances, { value: extraIdToReceive, valid: null }, "a", _SimpleSwapOrchestrator_extraIdToReceive_set);
@@ -162,8 +162,8 @@ class SimpleSwapOrchestrator {
         });
     }
     swap() {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!__classPrivateFieldGet(this, _SimpleSwapOrchestrator_instances, "a", _SimpleSwapOrchestrator_tokenToUse_get).value ||
                 !__classPrivateFieldGet(this, _SimpleSwapOrchestrator_instances, "a", _SimpleSwapOrchestrator_tokenToReceive_get).value ||
                 !__classPrivateFieldGet(this, _SimpleSwapOrchestrator_instances, "a", _SimpleSwapOrchestrator_accountToUse_get).value ||

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

@@ -1,9 +1,9 @@
-import { BlockchainService, TSwapToken } from '@cityofzion/blockchain-service';
-export type TSimpleSwapOrchestratorInitParams<BSName extends string = string> = {
-    blockchainServicesByName: Record<BSName, BlockchainService<BSName>>;
-    chainsByServiceName: Partial<Record<BSName, string[]>>;
+import { IBlockchainService, TSwapToken } from '@cityofzion/blockchain-service';
+export type TSimpleSwapOrchestratorInitParams<N extends string = string> = {
+    blockchainServicesByName: Record<N, IBlockchainService<N>>;
+    chainsByServiceName: Partial<Record<N, string[]>>;
 };
-export type TSimpleSwapApiCurrency<BSName extends string = string> = TSwapToken<BSName> & {
+export type TSimpleSwapApiCurrency<N extends string = string> = TSwapToken<N> & {
     network: string;
     ticker: string;
     hasExtraId: boolean;

package/dist/features/wallet-connect/WalletKitHelper.d.ts

@@ -0,0 +1,17 @@
+import { ErrorResponse } from '@walletconnect/jsonrpc-utils';
+import type { PendingRequestTypes, SessionTypes } from '@walletconnect/types';
+import { SdkErrorKey } from '@walletconnect/utils';
+import { TWalletKitHelperFilterSessionsParams, TWalletKitHelperGetProposalDetailsParams, TWalletKitHelperGetSessionDetailsParams, TWalletKitHelperProcessRequestParams, TWalletKitHelperProposalDetails, TWalletKitHelperSessionDetails } from './types';
+export declare class WalletKitHelper {
+    static getProposalDetails<N extends string>({ address, proposal, services, }: TWalletKitHelperGetProposalDetailsParams<N>): TWalletKitHelperProposalDetails<N>;
+    static getSessionDetails<N extends string>({ session, services, }: TWalletKitHelperGetSessionDetailsParams<N>): TWalletKitHelperSessionDetails<N>;
+    static getError(key: SdkErrorKey): {
+        message: string;
+        code: number;
+    };
+    static formatRequestResult(request: PendingRequestTypes.Struct, response: any): import("@walletconnect/jsonrpc-utils").JsonRpcResult<any>;
+    static formatRequestError(request: PendingRequestTypes.Struct, reason: ErrorResponse): import("@walletconnect/jsonrpc-utils").JsonRpcError;
+    static processRequest<N extends string>({ sessionDetails, account, request, }: TWalletKitHelperProcessRequestParams<N>): Promise<any>;
+    static filterSessions(sessions: SessionTypes.Struct[], filters: TWalletKitHelperFilterSessionsParams): SessionTypes.Struct[];
+    static isValidURI(uri: string): boolean;
+}

package/dist/features/wallet-connect/WalletKitHelper.js

@@ -0,0 +1,106 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletKitHelper = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const jsonrpc_utils_1 = require("@walletconnect/jsonrpc-utils");
+const utils_1 = require("@walletconnect/utils");
+class WalletKitHelper {
+    static getProposalDetails({ address, proposal, services, }) {
+        const mergedNamespacesObject = (0, utils_1.mergeRequiredAndOptionalNamespaces)(proposal.requiredNamespaces, proposal.optionalNamespaces);
+        const allChains = new Set((0, utils_1.getChainsFromRequiredNamespaces)(mergedNamespacesObject));
+        const service = services.find((service) => (0, blockchain_service_1.hasWalletConnect)(service) && allChains.has(service.walletConnectService.chain));
+        if (!service)
+            throw new blockchain_service_1.BSError('Requested chain(s) not supported by any service', 'NO_SERVICE');
+        const namespaceObject = mergedNamespacesObject[service.walletConnectService.namespace];
+        if (!namespaceObject)
+            throw new blockchain_service_1.BSError('Requested namespace not supported by any service', 'NO_SERVICE');
+        const approvedNamespaces = (0, utils_1.buildApprovedNamespaces)({
+            proposal: proposal,
+            supportedNamespaces: {
+                [service.walletConnectService.namespace]: {
+                    chains: [service.walletConnectService.chain],
+                    methods: service.walletConnectService.supportedMethods,
+                    events: service.walletConnectService.supportedEvents,
+                    accounts: [`${service.walletConnectService.chain}:${address}`],
+                },
+            },
+        });
+        const methods = namespaceObject.methods;
+        return { approvedNamespaces, methods, service, blockchain: service.name };
+    }
+    static getSessionDetails({ session, services, }) {
+        const sessionAccounts = (0, utils_1.getAccountsFromNamespaces)(session.namespaces);
+        const [sessionAddress] = (0, utils_1.getAddressesFromAccounts)(sessionAccounts);
+        if (!sessionAddress)
+            throw new blockchain_service_1.BSError('No accounts found in session', 'NO_ACCOUNTS');
+        const chains = (0, utils_1.getChainsFromNamespaces)(session.namespaces);
+        const service = services.find((service) => (0, blockchain_service_1.hasWalletConnect)(service) && chains.includes(service.walletConnectService.chain));
+        if (!service)
+            throw new blockchain_service_1.BSError('Requested chain not supported by any service', 'NO_SERVICE');
+        const methods = (0, utils_1.getNamespacesMethodsForChainId)(session.namespaces, service.walletConnectService.chain);
+        return { service, address: sessionAddress, methods, blockchain: service.name };
+    }
+    static getError(key) {
+        return (0, utils_1.getSdkError)(key);
+    }
+    static formatRequestResult(request, response) {
+        return (0, jsonrpc_utils_1.formatJsonRpcResult)(request.id, response);
+    }
+    static formatRequestError(request, reason) {
+        return (0, jsonrpc_utils_1.formatJsonRpcError)(request.id, reason !== null && reason !== void 0 ? reason : (0, utils_1.getSdkError)('USER_REJECTED'));
+    }
+    static processRequest(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sessionDetails, account, request, }) {
+            if (account.address !== sessionDetails.address) {
+                throw new blockchain_service_1.BSError('Account address does not match session address', 'INVALID_ACCOUNT');
+            }
+            const method = request.params.request.method;
+            if (!sessionDetails.methods.includes(method)) {
+                throw new blockchain_service_1.BSError('Method not supported by session', 'UNSUPPORTED_METHOD');
+            }
+            const serviceMethod = sessionDetails.service.walletConnectService[method];
+            if (!serviceMethod || typeof serviceMethod !== 'function')
+                throw new blockchain_service_1.BSError('Method not supported', 'UNSUPPORTED_METHOD');
+            const response = yield serviceMethod.apply(sessionDetails.service.walletConnectService, [
+                { account, params: request.params.request.params },
+            ]);
+            return response;
+        });
+    }
+    static filterSessions(sessions, filters) {
+        let filteredSessions = sessions;
+        if (filters === null || filters === void 0 ? void 0 : filters.addresses) {
+            filteredSessions = filteredSessions.filter(session => {
+                let matched = false;
+                if (filters.addresses) {
+                    const sessionAccounts = (0, utils_1.getAccountsFromNamespaces)(session.namespaces);
+                    const [address] = (0, utils_1.getAddressesFromAccounts)(sessionAccounts);
+                    if (address && filters.addresses.includes(address)) {
+                        matched = true;
+                    }
+                }
+                if (filters.chains && !matched) {
+                    const chains = (0, utils_1.getChainsFromNamespaces)(session.namespaces);
+                    if (chains.some(namespace => { var _a; return (_a = filters.chains) === null || _a === void 0 ? void 0 : _a.includes(namespace); })) {
+                        matched = true;
+                    }
+                }
+                return matched;
+            });
+        }
+        return filteredSessions;
+    }
+    static isValidURI(uri) {
+        return /^wc:.+@\d.*$/g.test(uri);
+    }
+}
+exports.WalletKitHelper = WalletKitHelper;

package/dist/features/wallet-connect/index.d.ts

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

package/dist/features/wallet-connect/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("./WalletKitHelper"), exports);
+__exportStar(require("./types"), exports);

package/dist/features/wallet-connect/types.d.ts

@@ -0,0 +1,32 @@
+import { IBlockchainService, IBSWithWalletConnect, TBSAccount } from '@cityofzion/blockchain-service';
+import { PendingRequestTypes, ProposalTypes, SessionTypes } from '@walletconnect/types';
+export type TWalletKitHelperGetProposalDetailsParams<N extends string = string> = {
+    proposal: ProposalTypes.Struct;
+    address: string;
+    services: IBlockchainService<N>[];
+};
+export type TWalletKitHelperProposalDetails<N extends string = string> = {
+    methods: string[];
+    approvedNamespaces: SessionTypes.Namespaces;
+    service: IBlockchainService<N> & IBSWithWalletConnect;
+    blockchain: N;
+};
+export type TWalletKitHelperGetSessionDetailsParams<N extends string = string> = {
+    session: SessionTypes.Struct;
+    services: IBlockchainService<N>[];
+};
+export type TWalletKitHelperSessionDetails<N extends string = string> = {
+    address: string;
+    methods: string[];
+    service: IBlockchainService<N> & IBSWithWalletConnect;
+    blockchain: N;
+};
+export type TWalletKitHelperProcessRequestParams<N extends string = string> = {
+    request: PendingRequestTypes.Struct;
+    sessionDetails: TWalletKitHelperSessionDetails<N>;
+    account: TBSAccount<N>;
+};
+export type TWalletKitHelperFilterSessionsParams = {
+    addresses?: string[];
+    chains?: string[];
+};

package/dist/features/wallet-connect/types.js

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

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './features/swap';
 export * from './features/bridge';
+export * from './features/wallet-connect';
 export * from './BSAggregator';

package/dist/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./features/swap"), exports);
 __exportStar(require("./features/bridge"), exports);
+__exportStar(require("./features/wallet-connect"), exports);
 __exportStar(require("./BSAggregator"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-multichain",
-  "version": "1.0.14",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -10,32 +10,32 @@
     "/dist"
   ],
   "dependencies": {
-    "axios": "~1.8.2",
-    "lodash": "~4.17.21",
-    "@cityofzion/blockchain-service": "1.21.2"
+    "axios": "~1.12.2",
+    "@walletconnect/utils": "~2.21.9",
+    "@walletconnect/jsonrpc-utils": "~1.0.8",
+    "@cityofzion/blockchain-service": "1.22.0"
   },
   "devDependencies": {
-    "@types/jest": "29.5.3",
-    "dotenv": "16.3.1",
-    "eslint": "^8.48.0",
-    "jest": "29.6.2",
-    "ts-jest": "29.1.1",
+    "@types/node": "~24.5.2",
+    "@types/jest": "~30.0.0",
+    "@walletconnect/types": "~2.21.9",
+    "dotenv": "~17.2.2",
+    "eslint": "~9.36.0",
+    "jest": "~30.1.3",
+    "ts-jest": "~29.4.4",
     "ts-node": "~10.9.2",
-    "typescript": "4.9.5",
+    "typescript": "~5.9.2",
     "typed-emitter": "~2.1.0",
-    "@types/lodash": "~4.17.12",
-    "@types/node": "~22.8.6",
-    "@typescript-eslint/eslint-plugin": "~8.12.2",
-    "@typescript-eslint/parser": "~8.12.2",
-    "@cityofzion/bs-neo3": "1.16.3",
-    "@cityofzion/bs-neo-legacy": "1.13.4",
-    "@cityofzion/bs-neox": "1.3.5",
-    "@cityofzion/bs-ethereum": "2.13.4"
+    "@cityofzion/bs-ethereum": "2.14.0",
+    "@cityofzion/bs-neo3": "1.17.0",
+    "@cityofzion/bs-neo-legacy": "1.13.5",
+    "@cityofzion/bs-neox": "1.4.0"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
-    "test": "jest --config jest.config.ts",
+    "build": "rm -rf ./dist && tsc --project tsconfig.build.json",
+    "test": "jest -i --config jest.config.ts",
     "lint": "eslint .",
-    "format": "eslint --fix"
+    "format": "eslint --fix",
+    "package": "npm run build && npm pack"
   }
 }