@cityofzion/bs-multichain 3.1.3 → 3.1.4

package/dist/BSAggregator.d.ts

@@ -1,14 +1,16 @@
 import { type TBSAccount, type IBlockchainService, type 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>[]);
+import type { TBSService, TBSServiceByName, TBSServiceName } from './types';
+export declare class BSAggregator<S extends TBSService[] = TBSService[], T = [TBSService] extends [S[number]] ? Partial<TBSServiceByName<S>> : TBSServiceByName<S>> {
+    readonly blockchainServicesByName: T;
+    readonly blockchainServices: S;
+    readonly blockchainServicesByNameRecord: Record<TBSServiceName, IBlockchainService<TBSServiceName, string>>;
+    constructor(blockchainServices: S);
     validateAddressAllBlockchains(address: string): boolean;
     validateTextAllBlockchains(text: string): boolean;
     validateKeyAllBlockchains(wif: string): boolean;
     validateEncryptedAllBlockchains(keyOrJson: string): boolean;
-    getBlockchainNameByAddress(address: string): N[];
-    getBlockchainNameByKey(wif: string): N[];
-    getBlockchainNameByEncrypted(keyOrJson: string): N[];
-    generateAccountsFromMnemonic(mnemonic: string, untilIndexByBlockchainService?: TUntilIndexRecord<N>): Promise<Map<N, TBSAccount<N>[]>>;
+    getBlockchainNameByAddress(address: string): TBSServiceName[];
+    getBlockchainNameByKey(wif: string): TBSServiceName[];
+    getBlockchainNameByEncrypted(keyOrJson: string): TBSServiceName[];
+    generateAccountsFromMnemonic(mnemonic: string, untilIndexByBlockchainService?: TUntilIndexRecord<TBSServiceName>): Promise<Map<TBSServiceName, TBSAccount<TBSServiceName>[]>>;
 }

package/dist/BSAggregator.js

@@ -9,6 +9,7 @@ class BSAggregator {
             acc[service.name] = service;
             return acc;
         }, {});
+        this.blockchainServicesByNameRecord = this.blockchainServicesByName;
     }
     validateAddressAllBlockchains(address) {
         return this.blockchainServices.some(bs => bs.validateAddress(address));

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

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

package/dist/features/bridge/Neo3NeoXBridgeOrchestrator.js

@@ -25,7 +25,11 @@ class Neo3NeoXBridgeOrchestrator {
         _Neo3NeoXBridgeOrchestrator_feeTokenBalance.set(this, null);
         _Neo3NeoXBridgeOrchestrator_addressToReceiveTimeout.set(this, undefined);
         _Neo3NeoXBridgeOrchestrator_amountToUseTimeout.set(this, undefined);
-        _Neo3NeoXBridgeOrchestrator_internalAvailableTokensToUse.set(this, { value: null, loading: false, error: 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 });
@@ -145,7 +149,8 @@ class Neo3NeoXBridgeOrchestrator {
         __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 {
-            const constants = await this.fromService.neo3NeoXBridgeService.getBridgeConstants(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value);
+            const neo3NeoXBridgeService = this.fromService.neo3NeoXBridgeService;
+            const constants = await 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);
@@ -203,7 +208,8 @@ class Neo3NeoXBridgeOrchestrator {
                 if (amountToUseBn.isGreaterThan(__classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_amountToUseMax_get).value)) {
                     throw new blockchain_service_1.BSError('Amount is above the maximum', 'AMOUNT_ABOVE_MAXIMUM');
                 }
-                const approvalFee = await this.fromService.neo3NeoXBridgeService
+                const neo3NeoXBridgeService = this.fromService.neo3NeoXBridgeService;
+                const approvalFee = await neo3NeoXBridgeService
                     .getApprovalFee({
                     account: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_accountToUse_get).value,
                     token: __classPrivateFieldGet(this, _Neo3NeoXBridgeOrchestrator_instances, "a", _Neo3NeoXBridgeOrchestrator_tokenToUse_get).value,
@@ -242,7 +248,8 @@ class Neo3NeoXBridgeOrchestrator {
             !__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');
         }
-        return await this.fromService.neo3NeoXBridgeService.bridge({
+        const neo3NeoXBridgeService = this.fromService.neo3NeoXBridgeService;
+        return await 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,
@@ -254,14 +261,16 @@ class Neo3NeoXBridgeOrchestrator {
         const isNeo3Service = tokenToUse.blockchain === neo3Service.name;
         const fromService = isNeo3Service ? neo3Service : neoXService;
         const toService = isNeo3Service ? neoXService : neo3Service;
-        const nonce = await blockchain_service_1.BSUtilsHelper.retry(() => fromService.neo3NeoXBridgeService.getNonce({
+        const fromNeo3NeoXBridgeService = fromService.neo3NeoXBridgeService;
+        const toNeo3NeoXBridgeService = toService.neo3NeoXBridgeService;
+        const nonce = await blockchain_service_1.BSUtilsHelper.retry(() => fromNeo3NeoXBridgeService.getNonce({
             token: tokenToUse,
             transactionHash,
         }), {
             retries: 10,
             delay: 30000,
         });
-        await blockchain_service_1.BSUtilsHelper.retry(() => toService.neo3NeoXBridgeService.getTransactionHashByNonce({ nonce, token: tokenToReceive }), {
+        await blockchain_service_1.BSUtilsHelper.retry(() => toNeo3NeoXBridgeService.getTransactionHashByNonce({ nonce, token: tokenToReceive }), {
             retries: 10,
             delay: 30000,
         });

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import type { ISwapService, TSwapServiceStatusResponse } from '@cityofzion/blockchain-service';
-export declare class SimpleSwapService<N extends string = string> implements ISwapService {
+export declare class SimpleSwapService implements ISwapService {
     #private;
     constructor();
     getStatus(id: string): Promise<TSwapServiceStatusResponse>;

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

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

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

@@ -1,19 +1,19 @@
-import { type IBlockchainService, type IBSWithWalletConnect } from '@cityofzion/blockchain-service';
+import { type IBlockchainService, type IBSWithWalletConnect, type TBSNetworkId } from '@cityofzion/blockchain-service';
 import { ErrorResponse } from '@walletconnect/jsonrpc-utils';
 import type { PendingRequestTypes, SessionTypes } from '@walletconnect/types';
 import { SdkErrorKey } from '@walletconnect/utils';
 import type { TWalletKitHelperFilterSessionsParams, TWalletKitHelperGetProposalDetailsParams, TWalletKitHelperGetSessionDetailsParams, TWalletKitHelperProcessRequestParams, TWalletKitHelperProposalDetails, TWalletKitHelperSessionDetails, TWalletKitHelperGetProposalServicesParams } from './types';
 export declare class WalletKitHelper {
-    static getProposalDetails<N extends string>({ address, proposal, service, }: TWalletKitHelperGetProposalDetailsParams<N>): TWalletKitHelperProposalDetails<N>;
-    static getProposalServices<N extends string>({ proposal, services }: TWalletKitHelperGetProposalServicesParams<N>): (IBlockchainService<N, string> & IBSWithWalletConnect<N>)[];
-    static getSessionDetails<N extends string>({ session, services, }: TWalletKitHelperGetSessionDetailsParams<N>): TWalletKitHelperSessionDetails<N>;
+    static getProposalDetails({ address, proposal, service, }: TWalletKitHelperGetProposalDetailsParams): TWalletKitHelperProposalDetails;
+    static getProposalServices({ proposal, services }: TWalletKitHelperGetProposalServicesParams): (IBlockchainService<"ethereum" | "polygon" | "base" | "arbitrum" | "neo3" | "neoLegacy" | "neox" | "solana" | "stellar" | "bitcoin", TBSNetworkId> & IBSWithWalletConnect<"ethereum" | "polygon" | "base" | "arbitrum" | "neo3" | "neoLegacy" | "neox" | "solana" | "stellar" | "bitcoin">)[];
+    static getSessionDetails({ session, services, }: TWalletKitHelperGetSessionDetailsParams): TWalletKitHelperSessionDetails;
     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 processRequest({ sessionDetails, account, request }: TWalletKitHelperProcessRequestParams): Promise<any>;
     static filterSessions(sessions: SessionTypes.Struct[], filters: TWalletKitHelperFilterSessionsParams): SessionTypes.Struct[];
     static isValidURI(uri: string): boolean;
 }

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

@@ -54,7 +54,7 @@ class WalletKitHelper {
     static formatRequestError(request, reason) {
         return (0, jsonrpc_utils_1.formatJsonRpcError)(request.id, reason ?? (0, utils_1.getSdkError)('USER_REJECTED'));
     }
-    static async processRequest({ sessionDetails, account, request, }) {
+    static async processRequest({ sessionDetails, account, request }) {
         if (account.address !== sessionDetails.address) {
             throw new blockchain_service_1.BSError('Account address does not match session address', 'INVALID_ACCOUNT');
         }

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

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./features/swap"), exports);
 __exportStar(require("./features/bridge"), exports);
 __exportStar(require("./features/wallet-connect"), exports);
 __exportStar(require("./BSAggregator"), exports);
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import type { IBSNeo3 } from '@cityofzion/bs-neo3';
+import type { IBSNeoLegacy } from '@cityofzion/bs-neo-legacy';
+import type { IBSEthereum } from '@cityofzion/bs-ethereum';
+import type { IBSNeoX } from '@cityofzion/bs-neox';
+import type { IBSSolana } from '@cityofzion/bs-solana';
+import type { IBSStellar } from '@cityofzion/bs-stellar';
+import type { IBSBitcoin } from '@cityofzion/bs-bitcoin';
+export type TBSService = IBSNeo3 | IBSNeoLegacy | IBSEthereum<'ethereum'> | IBSEthereum<'polygon'> | IBSEthereum<'base'> | IBSEthereum<'arbitrum'> | IBSNeoX | IBSSolana | IBSStellar | IBSBitcoin;
+export type TBSServiceByName<S extends Array<TBSService>> = {
+    [K in S[number]['name']]: Extract<S[number], {
+        name: K;
+    }>;
+};
+export type TBSServiceName = TBSService['name'];

package/dist/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-multichain",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -13,7 +13,7 @@
     "@walletconnect/utils": "~2.21.9",
     "@walletconnect/jsonrpc-utils": "~1.0.8",
     "axios": "~1.13.5",
-    "@cityofzion/blockchain-service": "3.1.3"
+    "@cityofzion/blockchain-service": "3.1.4"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
@@ -23,12 +23,16 @@
     "typed-emitter": "~2.1.0",
     "typescript": "~5.9.2",
     "vitest": "~4.0.18",
-    "@cityofzion/bs-ethereum": "3.1.3",
-    "@cityofzion/bs-neo3": "3.1.3",
-    "@cityofzion/bs-neox": "3.1.3"
+    "@cityofzion/bs-ethereum": "3.1.4",
+    "@cityofzion/bs-neo3": "3.1.4",
+    "@cityofzion/bs-neox": "3.1.4",
+    "@cityofzion/bs-bitcoin": "3.1.4",
+    "@cityofzion/bs-solana": "3.1.4",
+    "@cityofzion/bs-neo-legacy": "3.1.4",
+    "@cityofzion/bs-stellar": "3.1.4"
   },
   "scripts": {
-    "build": "rm -rf ./dist && npm run typecheck && tsc --project tsconfig.build.json",
+    "build": "rm -rf ./dist && rm -f *.tgz && npm run typecheck && tsc --project tsconfig.build.json",
     "format": "eslint --fix",
     "lint": "eslint .",
     "package": "npm run build && npm pack",