@cityofzion/blockchain-service 3.1.3 → 3.1.4

package/dist/functions.d.ts

@@ -1,24 +1,25 @@
-import type { TBSAccount, IBlockchainService, IBSWithClaim, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNeo3NeoXBridge, IBSWithNft, TUntilIndexRecord, IBSWithWalletConnect, IBSWithFullTransactions } from './interfaces';
-export declare function hasNameService<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithNameService;
-export declare function isClaimable<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithClaim<N>;
-export declare function isCalculableFee<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithFee<N>;
-export declare function hasNft<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithNft;
-export declare function hasExplorerService<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithExplorer;
-export declare function hasLedger<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithLedger<N>;
-export declare function hasNeo3NeoXBridge<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithNeo3NeoXBridge<N>;
-export declare function hasEncryption<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithEncryption<N>;
-export declare function hasWalletConnect<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithWalletConnect<N>;
-export declare function hasFullTransactions<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithFullTransactions<N>;
+import type { TBSAccount, IBlockchainService, IBSWithClaim, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNeo3NeoXBridge, IBSWithNft, TUntilIndexRecord, IBSWithWalletConnect, IBSWithFullTransactions, TBSNetworkId, IBSWithFaucet, TBSBridgeName } from './interfaces';
+export declare function hasNameService<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithNameService;
+export declare function isClaimable<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithClaim<N>;
+export declare function isCalculableFee<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithFee<N>;
+export declare function hasNft<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithNft;
+export declare function hasExplorerService<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithExplorer;
+export declare function hasLedger<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithLedger<N>;
+export declare function hasNeo3NeoXBridge<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is N extends TBSBridgeName ? IBlockchainService<N, A> & IBSWithNeo3NeoXBridge<N> : never;
+export declare function hasEncryption<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithEncryption<N>;
+export declare function hasWalletConnect<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithWalletConnect<N>;
+export declare function hasFullTransactions<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithFullTransactions;
+export declare function hasFaucet<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>): service is IBlockchainService<N, A> & IBSWithFaucet;
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */
-export declare function waitForTransaction<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>, txId: string): Promise<boolean>;
-export declare function waitForAccountTransaction<N extends string = string, A extends string = string>(params: {
+export declare function waitForTransaction<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>, txId: string): Promise<boolean>;
+export declare function waitForAccountTransaction<N extends string, A extends TBSNetworkId>(params: {
     service: IBlockchainService<N, A>;
     txId: string;
     address: string;
     maxAttempts?: number;
 }): Promise<boolean>;
-export declare function fetchAccounts<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>, initialIndex: number, getAccountCallback: (service: IBlockchainService<N, A>, index: number) => Promise<TBSAccount<N>>): Promise<TBSAccount<N>[]>;
-export declare function generateAccount<N extends string = string, A extends string = string>(service: IBlockchainService<N, A>, initialIndex: number, untilIndex: number, getAccountCallback: (service: IBlockchainService<N, A>, index: number) => Promise<TBSAccount<N>>): Promise<TBSAccount<N>[]>;
-export declare function generateAccountForBlockchainService<N extends string = string, A extends string = string>(services: IBlockchainService<N, A>[], getAccountCallback: (service: IBlockchainService<N, A>, index: number) => Promise<TBSAccount<N>>, untilIndexByBlockchainService?: TUntilIndexRecord<N>): Promise<Map<N, TBSAccount<N>[]>>;
+export declare function fetchAccounts<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>, initialIndex: number, getAccountCallback: (service: IBlockchainService<N, A>, index: number) => Promise<TBSAccount<N>>): Promise<TBSAccount<N>[]>;
+export declare function generateAccount<N extends string, A extends TBSNetworkId>(service: IBlockchainService<N, A>, initialIndex: number, untilIndex: number, getAccountCallback: (service: IBlockchainService<N, A>, index: number) => Promise<TBSAccount<N>>): Promise<TBSAccount<N>[]>;
+export declare function generateAccountForBlockchainService<N extends string, A extends TBSNetworkId>(services: IBlockchainService<N, A>[], getAccountCallback: (service: IBlockchainService<N, A>, index: number) => Promise<TBSAccount<N>>, untilIndexByBlockchainService?: TUntilIndexRecord<N>): Promise<Map<N, TBSAccount<N>[]>>;

package/dist/functions.js

@@ -10,6 +10,7 @@ exports.hasNeo3NeoXBridge = hasNeo3NeoXBridge;
 exports.hasEncryption = hasEncryption;
 exports.hasWalletConnect = hasWalletConnect;
 exports.hasFullTransactions = hasFullTransactions;
+exports.hasFaucet = hasFaucet;
 exports.waitForTransaction = waitForTransaction;
 exports.waitForAccountTransaction = waitForAccountTransaction;
 exports.fetchAccounts = fetchAccounts;
@@ -20,11 +21,7 @@ function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
 function isClaimable(service) {
-    return ('claimToken' in service &&
-        'burnToken' in service &&
-        'claimDataService' in service &&
-        'calculateClaimFee' in service &&
-        'claim' in service);
+    return 'claimService' in service;
 }
 function isCalculableFee(service) {
     return 'calculateTransferFee' in service;
@@ -50,6 +47,9 @@ function hasWalletConnect(service) {
 function hasFullTransactions(service) {
     return 'fullTransactionsDataService' in service;
 }
+function hasFaucet(service) {
+    return 'faucet' in service;
+}
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */

package/dist/helpers/BSUtilsHelper.d.ts

@@ -1,9 +1,9 @@
-import type { TBSNetwork } from '../interfaces';
+import type { TBSNetwork, TBSNetworkId } from '../interfaces';
 import { TBSUtilsHelperRetryOptions } from '../types';
 export declare class BSUtilsHelper {
     static wait(ms: number): Promise<unknown>;
     static retry<T = any>(callback: () => Promise<T>, options?: TBSUtilsHelperRetryOptions): Promise<T>;
-    static validateNetwork(network: TBSNetwork, availableNetworks: TBSNetwork[], networkUrls: string[]): boolean;
+    static validateNetwork<A extends TBSNetworkId>(network: TBSNetwork<A>, availableNetworks: TBSNetwork<A>[], networkUrls: string[]): boolean;
     static tryCatch<T>(callback: () => T): T extends Promise<infer R> ? Promise<[R, undefined] | [undefined, any]> : [T, undefined] | [undefined, any];
     static isBase64(str: string): boolean;
 }

package/dist/interfaces.d.ts

@@ -1,6 +1,6 @@
 import Transport from '@ledgerhq/hw-transport';
 import TypedEmitter from 'typed-emitter';
-import { BSError } from './error';
+import type { BSError } from './error';
 export type TUntilIndexRecord<N extends string> = Partial<Record<N, Record<string, number>>>;
 export type TBSAccount<N extends string> = {
     key: string;
@@ -43,6 +43,7 @@ export interface IBlockchainService<N extends string, A extends string = string>
     readonly bipDerivationPath: string;
     readonly feeToken: TBSToken;
     readonly isMultiTransferSupported: boolean;
+    readonly amountToCreateAccount?: string;
     tokens: TBSToken[];
     readonly nativeTokens: TBSToken[];
     networkUrls: string[];
@@ -51,7 +52,7 @@ export interface IBlockchainService<N extends string, A extends string = string>
     readonly availableNetworks: TBSNetwork<A>[];
     readonly isCustomNetworkSupported: boolean;
     exchangeDataService: IExchangeDataService;
-    blockchainDataService: IBlockchainDataService<N>;
+    blockchainDataService: IBlockchainDataService;
     tokenService: ITokenService;
     setNetwork(network: TBSNetwork<A>): void;
     pingNetwork(url?: string): Promise<TPingNetworkResponse>;
@@ -59,7 +60,7 @@ export interface IBlockchainService<N extends string, A extends string = string>
     generateAccountFromKey(key: string): Promise<TBSAccount<N>>;
     validateAddress(address: string): boolean;
     validateKey(key: string): boolean;
-    transfer(params: TTransferParams<N>): Promise<TTransaction<N>[]>;
+    transfer(params: TTransferParams<N>): Promise<TTransaction[]>;
 }
 export interface IBSWithEncryption<N extends string> {
     decrypt(keyOrJson: string, password: string): Promise<TBSAccount<N>>;
@@ -70,11 +71,7 @@ export interface IBSWithFee<N extends string> {
     calculateTransferFee(params: TTransferParams<N>): Promise<string>;
 }
 export interface IBSWithClaim<N extends string> {
-    readonly claimToken: TBSToken;
-    readonly burnToken: TBSToken;
-    claimDataService: IClaimDataService;
-    calculateClaimFee(account: TBSAccount<N>): Promise<string>;
-    claim(account: TBSAccount<N>): Promise<TTransaction<N>>;
+    claimService: IClaimService<N>;
 }
 export interface IBSWithNameService {
     resolveNameServiceDomain(domainName: string): Promise<string>;
@@ -93,8 +90,11 @@ export interface IBSWithLedger<N extends string> {
 export interface IBSWithWalletConnect<N extends string> {
     walletConnectService: IWalletConnectService<N>;
 }
-export interface IBSWithFullTransactions<N extends string> {
-    fullTransactionsDataService: IFullTransactionsDataService<N>;
+export interface IBSWithFullTransactions {
+    fullTransactionsDataService: IFullTransactionsDataService;
+}
+export interface IBSWithFaucet {
+    faucet(address: string): Promise<TTransaction>;
 }
 export type TContractParameter = {
     name: string;
@@ -104,54 +104,34 @@ export type TGetTransactionsByAddressParams = {
     address: string;
     nextPageParams?: any;
 };
-type TTransactionEventTokenType = 'generic' | (string & NonNullable<unknown>);
-export type TTransactionNftEvent = {
-    eventType: 'nft';
+export type TTransactionBaseEvent = {
     methodName?: string;
-    amount?: string;
     from?: string;
     fromUrl?: string;
     to?: string;
     toUrl?: string;
-    tokenType: TTransactionEventTokenType;
+    amount?: string;
+};
+export type TTransactionDefaultNftEvent = TTransactionBaseEvent & {
+    eventType: 'nft';
     nft?: TNftResponse;
 };
-export type TTransactionTokenEvent = {
+export type TTransactionDefaultTokenEvent = TTransactionBaseEvent & {
     eventType: 'token';
-    methodName?: string;
-    amount?: string;
-    from?: string;
-    fromUrl?: string;
-    to?: string;
-    toUrl?: string;
-    tokenType: TTransactionEventTokenType;
     tokenUrl?: string;
     token?: TBSToken;
 };
-export type TTransactionDefaultType = {
-    type: 'default';
-};
-export type TTransactionVoteType = {
-    type: 'vote';
+export type TTransactionDefaultGenericEvent = TTransactionBaseEvent & {
+    eventType: 'generic';
+    data?: Record<string, string | number | boolean | undefined | null>;
 };
-export type TTransactionClaimType = {
-    type: 'claim';
-};
-export type TTransactionBridgeNeo3NeoXType<N extends string> = {
-    type: 'bridgeNeo3NeoX';
-    data: {
-        amount: string;
-        tokenToUse: TBridgeToken<N>;
-        receiverAddress: string;
-    };
-};
-export type TTransactionInputOutput = {
+export type TTransactionUtxoInputOutput = {
     address?: string;
     addressUrl?: string;
     amount: string;
     token: TBSToken;
 };
-type TTransactionBase<N extends string> = {
+type TTransactionBase = {
     txId: string;
     txIdUrl?: string;
     block?: number;
@@ -160,21 +140,23 @@ type TTransactionBase<N extends string> = {
     notificationCount?: number;
     networkFeeAmount?: string;
     systemFeeAmount?: string;
-} & (TTransactionDefaultType | TTransactionVoteType | TTransactionClaimType | TTransactionBridgeNeo3NeoXType<N>);
-export type TTransactionDefault<N extends string> = TTransactionBase<N> & {
+    data?: any;
+};
+export type TTransactionDefaultEvent = TTransactionDefaultNftEvent | TTransactionDefaultTokenEvent | TTransactionDefaultGenericEvent;
+export type TTransactionDefault = TTransactionBase & {
     view: 'default';
-    events: (TTransactionTokenEvent | TTransactionNftEvent)[];
+    events: TTransactionDefaultEvent[];
 };
-export type TTransactionUtxo<N extends string> = TTransactionBase<N> & {
+export type TTransactionUtxo = TTransactionBase & {
     view: 'utxo';
     hex: string;
     totalAmount: string;
     nfts: TNftResponse[];
-    inputs: TTransactionInputOutput[];
-    outputs: TTransactionInputOutput[];
+    inputs: TTransactionUtxoInputOutput[];
+    outputs: TTransactionUtxoInputOutput[];
 };
-export type TTransaction<N extends string> = TTransactionDefault<N> | TTransactionUtxo<N>;
-export type TGetTransactionsByAddressResponse<N extends string, T extends TTransaction<N> = TTransaction<N>> = {
+export type TTransaction = TTransactionDefault | TTransactionUtxo;
+export type TGetTransactionsByAddressResponse<T extends TTransaction = TTransaction> = {
     nextPageParams?: any;
     transactions: T[];
 };
@@ -191,10 +173,10 @@ export type TBalanceResponse = {
     amount: string;
     token: TBSToken;
 };
-export interface IBlockchainDataService<N extends string> {
+export interface IBlockchainDataService {
     readonly maxTimeToConfirmTransactionInMs: number;
-    getTransaction(transactionId: string): Promise<TTransaction<N>>;
-    getTransactionsByAddress(params: TGetTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N>>;
+    getTransaction(transactionId: string): Promise<TTransaction>;
+    getTransactionsByAddress(params: TGetTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse>;
     getContract(contractHash: string): Promise<TContractResponse>;
     getTokenInfo(tokenHash: string): Promise<TBSToken>;
     getBalance(address: string): Promise<TBalanceResponse[]>;
@@ -212,12 +194,19 @@ export type TExportFullTransactionsByAddressParams = {
     dateFrom: string;
     dateTo: string;
 };
-export interface IFullTransactionsDataService<N extends string> {
-    getFullTransactionsByAddress(params: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N>>;
+export interface IFullTransactionsDataService {
+    getFullTransactionsByAddress(params: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse>;
     exportFullTransactionsByAddress(params: TExportFullTransactionsByAddressParams): Promise<string>;
 }
-export interface IClaimDataService {
+export type TClaimServiceTransactionData = {
+    isClaim: boolean;
+};
+export interface IClaimService<N extends string> {
+    readonly claimToken: TBSToken;
     getUnclaimed(address: string): Promise<string>;
+    calculateFee(account: TBSAccount<N>): Promise<string>;
+    claim(account: TBSAccount<N>): Promise<TTransactionDefault>;
+    getTransactionData(transaction: TTransaction): TClaimServiceTransactionData | undefined;
 }
 export type TTokenPricesResponse = {
     usdPrice: number;
@@ -342,9 +331,9 @@ export type TSwapOrchestratorEvents<N extends string> = {
     availableTokensToReceive: (tokens: TSwapLoadableValue<TSwapToken<N>[]>) => void | Promise<void>;
     error: (error: string) => void | Promise<void>;
 };
-export type TSwapResponse<N extends string> = {
+export type TSwapResponse = {
     id: string;
-    transaction?: TTransaction<N>;
+    transaction?: TTransaction;
     log?: string;
 };
 export type TSwapServiceStatusResponse = {
@@ -364,10 +353,11 @@ export interface ISwapOrchestrator<N extends string> {
     setTokenToReceive(token: TSwapToken<N> | null): Promise<void>;
     setAddressToReceive(address: string | null): Promise<void>;
     setExtraIdToReceive(extraId: string | null): Promise<void>;
-    swap(): Promise<TSwapResponse<N>>;
+    swap(): Promise<TSwapResponse>;
     calculateFee(): Promise<string>;
 }
-export type TBridgeToken<N extends string> = TBSToken & {
+export type TBSBridgeName = 'neo3' | 'neox';
+export type TBridgeToken<N extends TBSBridgeName> = TBSToken & {
     blockchain: N;
     multichainId: string;
 };
@@ -379,7 +369,7 @@ export type TBridgeValue<T> = {
 export type TBridgeValidateValue<T> = TBridgeValue<T> & {
     valid: boolean | null;
 };
-export type TBridgeOrchestratorEvents<N extends string> = {
+export type TBridgeOrchestratorEvents<N extends TBSBridgeName> = {
     accountToUse: (account: TBridgeValue<TBSAccount<N>>) => void | Promise<void>;
     amountToUse: (amount: TBridgeValidateValue<string>) => void | Promise<void>;
     amountToUseMin: (max: TBridgeValue<string>) => void | Promise<void>;
@@ -392,7 +382,7 @@ export type TBridgeOrchestratorEvents<N extends string> = {
     tokenToUseBalance: (balance: TBridgeValue<TBalanceResponse | undefined>) => void | Promise<void>;
     bridgeFee: (fee: TBridgeValue<string>) => void | Promise<void>;
 };
-export interface IBridgeOrchestrator<N extends string> {
+export interface IBridgeOrchestrator<N extends TBSBridgeName> {
     eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<N>>;
     setTokenToUse(token: TBridgeToken<N> | null): Promise<void>;
     setAccountToUse(account: TBSAccount<N> | null): Promise<void>;
@@ -402,7 +392,7 @@ export interface IBridgeOrchestrator<N extends string> {
     switchTokens(): Promise<void>;
     bridge(): Promise<string>;
 }
-export interface IBSWithNeo3NeoXBridge<N extends string> {
+export interface IBSWithNeo3NeoXBridge<N extends TBSBridgeName> {
     neo3NeoXBridgeService: INeo3NeoXBridgeService<N>;
 }
 export type TNeo3NeoXBridgeServiceConstants = {
@@ -410,27 +400,34 @@ export type TNeo3NeoXBridgeServiceConstants = {
     bridgeMaxAmount: string;
     bridgeMinAmount: string;
 };
-export type TNeo3NeoXBridgeServiceBridgeParam<N extends string> = {
+export type TNeo3NeoXBridgeServiceBridgeParam<N extends TBSBridgeName> = {
     account: TBSAccount<N>;
     receiverAddress: string;
     amount: string;
     token: TBridgeToken<N>;
     bridgeFee: string;
 };
-export type TNeo3NeoXBridgeServiceGetApprovalParam<N extends string> = {
+export type TNeo3NeoXBridgeServiceGetApprovalParam<N extends TBSBridgeName> = {
     account: TBSAccount<N>;
     amount: string;
     token: TBridgeToken<N>;
 };
-export type TNeo3NeoXBridgeServiceGetNonceParams<N extends string> = {
+export type TNeo3NeoXBridgeServiceGetNonceParams<N extends TBSBridgeName> = {
     token: TBridgeToken<N>;
     transactionHash: string;
 };
-export type TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<N extends string> = {
+export type TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<N extends TBSBridgeName> = {
     token: TBridgeToken<N>;
     nonce: string;
 };
-export interface INeo3NeoXBridgeService<N extends string> {
+export type TNeo3NeoXBridgeTransactionData<N extends TBSBridgeName> = {
+    neo3NeoxBridge: {
+        tokenToUse: TBridgeToken<N>;
+        receiverAddress: string;
+        amount: string;
+    };
+};
+export interface INeo3NeoXBridgeService<N extends TBSBridgeName> {
     readonly gasToken: TBridgeToken<N>;
     readonly neoToken: TBridgeToken<N>;
     getApprovalFee(params: TNeo3NeoXBridgeServiceGetApprovalParam<N>): Promise<string>;
@@ -439,6 +436,7 @@ export interface INeo3NeoXBridgeService<N extends string> {
     getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams<N>): Promise<string>;
     getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<N>): Promise<string>;
     getTokenByMultichainId(multichainId: string): TBridgeToken<N> | undefined;
+    getTransactionData(transaction: TTransaction): TNeo3NeoXBridgeTransactionData<N> | undefined;
 }
 export type TTokenServicePredicateParams = {
     hash: string;
@@ -456,6 +454,8 @@ export interface ITokenService {
     predicateBySymbol(compareFrom: TTokenServicePredicateBySymbolParams, compareTo: TTokenServicePredicateBySymbolParams): boolean;
     normalizeToken<T extends TBSToken | TBSToken[]>(token: T): T;
     normalizeHash(hash: string): string;
+    validateTokenHash(hash?: string): hash is string;
+    isNativeToken(hash: string): boolean;
 }
 export type TWalletConnectServiceRequestMethodParams<N extends string> = {
     account: TBSAccount<N>;

package/dist/services/exchange-data/FlamingoForthewinEDS.d.ts

@@ -1,8 +1,8 @@
-import type { TGetTokenPricesParams, IBlockchainService, IExchangeDataService, TTokenPricesResponse } from '../../interfaces';
+import type { TGetTokenPricesParams, IBlockchainService, IExchangeDataService, TTokenPricesResponse, TBSNetworkId } from '../../interfaces';
 import { CryptoCompareEDS } from './CryptoCompareEDS';
-export declare class FlamingoForthewinEDS<N extends string> extends CryptoCompareEDS implements IExchangeDataService {
+export declare class FlamingoForthewinEDS<N extends string, A extends TBSNetworkId> extends CryptoCompareEDS implements IExchangeDataService {
     #private;
-    readonly _service: IBlockchainService<N>;
-    constructor(service: IBlockchainService<N>);
+    readonly _service: IBlockchainService<N, A>;
+    constructor(service: IBlockchainService<N, A>);
     getTokenPrices({ tokens }: TGetTokenPricesParams): Promise<TTokenPricesResponse[]>;
 }

package/dist/services/nft-data/GhostMarketNDS.d.ts

@@ -1,5 +1,5 @@
-import type { IBlockchainService, INftDataService, TGetNftParams, TGetNftsByAddressParams, THasTokenParams, TNftResponse, TNftsResponse } from '../../interfaces';
-export declare abstract class GhostMarketNDS<N extends string, A extends string, S extends IBlockchainService<N, A>> implements INftDataService {
+import type { IBlockchainService, INftDataService, TBSNetworkId, TGetNftParams, TGetNftsByAddressParams, THasTokenParams, TNftResponse, TNftsResponse } from '../../interfaces';
+export declare abstract class GhostMarketNDS<N extends string, A extends TBSNetworkId, S extends IBlockchainService<N, A>> implements INftDataService {
     #private;
     static readonly BASE_URL: string;
     _service: S;

package/dist/services/token/TokenService.d.ts

@@ -1,8 +1,12 @@
-import type { ITokenService, TBSToken, TTokenServicePredicateByHashParams, TTokenServicePredicateBySymbolParams, TTokenServicePredicateParams } from '../../interfaces';
-export declare abstract class TokenService implements ITokenService {
+import type { IBlockchainService, ITokenService, TBSNetworkId, TBSToken, TTokenServicePredicateByHashParams, TTokenServicePredicateBySymbolParams, TTokenServicePredicateParams } from '../../interfaces';
+export declare abstract class TokenService<N extends string, A extends TBSNetworkId> implements ITokenService {
+    protected _service: IBlockchainService<N, A>;
+    constructor(service: IBlockchainService<N, A>);
     predicate(compareFrom: TTokenServicePredicateParams, compareTo: TTokenServicePredicateParams): boolean;
     predicateByHash(compareFrom: TTokenServicePredicateByHashParams, compareTo: TTokenServicePredicateByHashParams): boolean;
     predicateBySymbol(compareFrom: TTokenServicePredicateBySymbolParams, compareTo: TTokenServicePredicateBySymbolParams): boolean;
     normalizeToken<T extends TBSToken | TBSToken[]>(token: T): T;
+    validateTokenHash(hash?: string): hash is string;
+    isNativeToken(hash: string): boolean;
     abstract normalizeHash(hash: string): string;
 }

package/dist/services/token/TokenService.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenService = void 0;
 class TokenService {
+    constructor(service) {
+        this._service = service;
+    }
     predicate(compareFrom, compareTo) {
         if (this.normalizeHash(compareFrom.hash) === this.normalizeHash(compareTo.hash))
             return true;
@@ -32,5 +35,14 @@ class TokenService {
             hash: this.normalizeHash(token.hash),
         };
     }
+    validateTokenHash(hash) {
+        hash = hash?.trim();
+        if (!hash)
+            return false;
+        return !this.isNativeToken(hash);
+    }
+    isNativeToken(hash) {
+        return this._service.nativeTokens.some(token => this.predicateByHash(hash, token));
+    }
 }
 exports.TokenService = TokenService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -30,7 +30,7 @@
     "vitest": "~4.0.18"
   },
   "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",