@cityofzion/blockchain-service 1.21.2 → 1.21.3

package/dist/interfaces.d.ts

@@ -1,113 +1,125 @@
 import Transport from '@ledgerhq/hw-transport';
 import TypedEmitter from 'typed-emitter';
 import { BSError } from './error';
-export type UntilIndexRecord<BSName extends string = string> = Partial<Record<BSName, Record<string, number>>>;
-export type Account<BSName extends string = string> = {
+export type TUntilIndexRecord<N extends string = string> = Partial<Record<N, Record<string, number>>>;
+export type TBSAccount<N extends string = string> = {
     key: string;
     type: 'wif' | 'privateKey' | 'publicKey';
     address: string;
     bip44Path?: string;
     isHardware?: boolean;
-    blockchain: BSName;
+    blockchain: N;
 };
-export type Token = {
+export type TBSToken = {
     symbol: string;
     name: string;
     hash: string;
     decimals: number;
 };
-export type NetworkId<T extends string = string> = T | (string & {});
-export type Network<T extends string = string> = {
-    id: NetworkId<T>;
+export type TBSNetworkId<T extends string = string> = T | (string & {});
+export type TBSNetworkType = 'mainnet' | 'testnet' | 'custom';
+export type TBSNetwork<T extends string = string> = {
+    id: TBSNetworkId<T>;
     name: string;
     url: string;
+    type: TBSNetworkType;
 };
-export type IntentTransferParam = {
+export type TIntentTransferParam = {
     receiverAddress: string;
     tokenHash: string;
     amount: string;
     tokenDecimals?: number;
 };
-export type TransferParam<BSName extends string = string> = {
-    senderAccount: Account<BSName>;
-    intents: IntentTransferParam[];
-    tipIntent?: IntentTransferParam;
+export type TTransferParam<N extends string = string> = {
+    senderAccount: TBSAccount<N>;
+    intents: TIntentTransferParam[];
+    tipIntent?: TIntentTransferParam;
     priorityFee?: string;
 };
-export interface BlockchainService<BSName extends string = string, BSAvailableNetworks extends string = string> {
-    readonly name: BSName;
+export type TPingNetworkResponse = {
+    latency: number;
+    url: string;
+    height: number;
+};
+export interface IBlockchainService<N extends string = string, A extends string = string> {
+    readonly name: N;
     readonly bip44DerivationPath: string;
-    readonly feeToken: Token;
-    exchangeDataService: ExchangeDataService;
-    blockchainDataService: BlockchainDataService;
+    readonly feeToken: TBSToken;
+    readonly isMultiTransferSupported: boolean;
+    readonly isCustomNetworkSupported: boolean;
+    tokens: TBSToken[];
+    readonly nativeTokens: TBSToken[];
+    network: TBSNetwork<A>;
+    availableNetworkURLs: string[];
+    readonly defaultNetwork: TBSNetwork<A>;
+    readonly availableNetworks: TBSNetwork<A>[];
+    exchangeDataService: IExchangeDataService;
+    blockchainDataService: IBlockchainDataService;
     tokenService: ITokenService;
-    tokens: Token[];
-    nativeTokens: Token[];
-    network: Network<BSAvailableNetworks>;
-    testNetwork: (network: Network<BSAvailableNetworks>) => Promise<void>;
-    setNetwork: (partialNetwork: Network<BSAvailableNetworks>) => void;
-    generateAccountFromMnemonic(mnemonic: string, index: number): Account<BSName>;
-    generateAccountFromKey(key: string): Account<BSName>;
+    pingNetwork: (network: TBSNetwork<A>) => Promise<TPingNetworkResponse>;
+    setNetwork: (network: TBSNetwork<A>) => void;
+    generateAccountFromMnemonic(mnemonic: string, index: number): TBSAccount<N>;
+    generateAccountFromKey(key: string): TBSAccount<N>;
     validateAddress(address: string): boolean;
     validateKey(key: string): boolean;
-    transfer(param: TransferParam<BSName>): Promise<string[]>;
+    transfer(param: TTransferParam<N>): Promise<string[]>;
 }
-export interface BSWithEncryption<BSName extends string = string> {
-    decrypt(keyOrJson: string, password: string): Promise<Account<BSName>>;
+export interface IBSWithEncryption<N extends string = string> {
+    decrypt(keyOrJson: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
     validateEncrypted(keyOrJson: string): boolean;
 }
-export interface BSCalculableFee<BSName extends string = string> {
-    calculateTransferFee(param: TransferParam<BSName>): Promise<string>;
+export interface IBSWithFee<N extends string = string> {
+    calculateTransferFee(param: TTransferParam<N>): Promise<string>;
 }
-export interface BSClaimable<BSName extends string = string> {
-    readonly claimToken: Token;
-    readonly burnToken: Token;
-    blockchainDataService: BlockchainDataService & BDSClaimable;
-    claim(account: Account<BSName>): Promise<string>;
+export interface IBSWithClaim<N extends string = string> {
+    readonly claimToken: TBSToken;
+    readonly burnToken: TBSToken;
+    claimDataService: IClaimDataService;
+    claim(account: TBSAccount<N>): Promise<string>;
 }
-export interface BSWithNameService {
+export interface IBSWithNameService {
     resolveNameServiceDomain(domainName: string): Promise<string>;
     validateNameServiceDomainFormat(domainName: string): boolean;
 }
-export interface BSWithExplorerService {
-    explorerService: ExplorerService;
+export interface IBSWithExplorer {
+    explorerService: IExplorerService;
 }
-export interface BSWithNft {
-    nftDataService: NftDataService;
+export interface IBSWithNft {
+    nftDataService: INftDataService;
 }
-export interface BSWithLedger<BSName extends string = string> {
-    ledgerService: LedgerService<BSName>;
-    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
+export interface IBSWithLedger<N extends string = string> {
+    ledgerService: ILedgerService<N>;
+    generateAccountFromPublicKey(publicKey: string): TBSAccount<N>;
 }
-export type TransactionNotificationTypedResponse = {
+export type TTransactionNotificationTypedResponse = {
     type: string;
     value?: string;
 };
-export type TransactionNotificationStateResponse = {
+export type TTransactionNotificationStateResponse = {
     type: string;
-    value?: string | TransactionNotificationTypedResponse[];
+    value?: string | TTransactionNotificationTypedResponse[];
 };
-export type TransactionNotifications = {
+export type TTransactionNotifications = {
     eventName: string;
-    state?: TransactionNotificationStateResponse | TransactionNotificationStateResponse[];
+    state?: TTransactionNotificationStateResponse | TTransactionNotificationStateResponse[];
 };
-export type TransactionTransferAsset = {
+export type TTransactionTransferAsset = {
     amount: string;
     to: string;
     from: string;
     type: 'token';
     contractHash: string;
-    token?: Token;
+    token?: TBSToken;
 };
-export type TransactionTransferNft = {
+export type TTransactionTransferNft = {
     tokenHash: string;
     to: string;
     from: string;
     type: 'nft';
     collectionHash: string;
 };
-type TransactionDefaultResponse = {
+type TTransactionDefaultResponse = {
     type: 'default';
 };
 export type TransactionBridgeNeo3NeoXResponse = {
@@ -118,39 +130,39 @@ export type TransactionBridgeNeo3NeoXResponse = {
         receiverAddress: string;
     };
 };
-export type TransactionResponse = {
+export type TTransactionResponse = {
     hash: string;
     block: number;
     time: number;
-    transfers: (TransactionTransferAsset | TransactionTransferNft)[];
+    transfers: (TTransactionTransferAsset | TTransactionTransferNft)[];
     fee?: string;
-    notifications: TransactionNotifications[];
-} & (TransactionDefaultResponse | TransactionBridgeNeo3NeoXResponse);
-export type ContractParameter = {
+    notifications: TTransactionNotifications[];
+} & (TTransactionDefaultResponse | TransactionBridgeNeo3NeoXResponse);
+export type TContractParameter = {
     name: string;
     type: string;
 };
-export type TransactionsByAddressResponse = {
-    transactions: TransactionResponse[];
+export type TTransactionsByAddressResponse = {
+    transactions: TTransactionResponse[];
     nextPageParams?: any;
 };
-export type TransactionsByAddressParams = {
+export type TTransactionsByAddressParams = {
     address: string;
     nextPageParams?: any;
 };
-export type FullTransactionsByAddressParams = {
+export type TFullTransactionsByAddressParams = {
     address: string;
     dateFrom: string;
     dateTo: string;
     pageSize?: number;
     nextCursor?: string;
 };
-export type ExportTransactionsByAddressParams = {
+export type TExportTransactionsByAddressParams = {
     address: string;
     dateFrom: string;
     dateTo: string;
 };
-export type FullTransactionNftEvent = {
+export type TFullTransactionNftEvent = {
     eventType: 'nft';
     amount?: string;
     methodName: string;
@@ -167,7 +179,7 @@ export type FullTransactionNftEvent = {
     name?: string;
     collectionName?: string;
 };
-export type FullTransactionAssetEvent = {
+export type TFullTransactionAssetEvent = {
     eventType: 'token';
     amount?: string;
     methodName: string;
@@ -177,13 +189,13 @@ export type FullTransactionAssetEvent = {
     toUrl?: string;
     from?: string;
     fromUrl?: string;
-    token?: Token;
+    token?: TBSToken;
     tokenType: 'generic' | (string & NonNullable<unknown>);
 };
-type FullTransactionsItemDefault = {
+type TFullTransactionsItemDefault = {
     type: 'default';
 };
-export type FullTransactionsItemBridgeNeo3NeoX = {
+export type TFullTransactionsItemBridgeNeo3NeoX = {
     type: 'bridgeNeo3NeoX';
     data: {
         amount: string;
@@ -191,7 +203,7 @@ export type FullTransactionsItemBridgeNeo3NeoX = {
         receiverAddress: string;
     };
 };
-export type FullTransactionsItem = {
+export type TFullTransactionsItem = {
     txId: string;
     txIdUrl?: string;
     block: number;
@@ -200,68 +212,62 @@ export type FullTransactionsItem = {
     notificationCount: number;
     networkFeeAmount?: string;
     systemFeeAmount?: string;
-    events: (FullTransactionAssetEvent | FullTransactionNftEvent)[];
-} & (FullTransactionsItemDefault | FullTransactionsItemBridgeNeo3NeoX);
-export type FullTransactionsByAddressResponse = {
+    events: (TFullTransactionAssetEvent | TFullTransactionNftEvent)[];
+} & (TFullTransactionsItemDefault | TFullTransactionsItemBridgeNeo3NeoX);
+export type TFullTransactionsByAddressResponse = {
     nextCursor?: string;
-    data: FullTransactionsItem[];
+    data: TFullTransactionsItem[];
 };
-export type ContractMethod = {
+export type TContractMethod = {
     name: string;
-    parameters: ContractParameter[];
+    parameters: TContractParameter[];
 };
 export type ContractResponse = {
     hash: string;
     name: string;
-    methods: ContractMethod[];
+    methods: TContractMethod[];
 };
-export type BalanceResponse = {
+export type TBalanceResponse = {
     amount: string;
-    token: Token;
-};
-export type RpcResponse = {
-    latency: number;
-    url: string;
-    height: number;
-};
-export interface BlockchainDataService {
-    maxTimeToConfirmTransactionInMs: number;
-    getTransaction(txid: string): Promise<TransactionResponse>;
-    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
-    getFullTransactionsByAddress(params: FullTransactionsByAddressParams): Promise<FullTransactionsByAddressResponse>;
-    exportFullTransactionsByAddress(params: ExportTransactionsByAddressParams): Promise<string>;
+    token: TBSToken;
+};
+export interface IBlockchainDataService {
+    readonly maxTimeToConfirmTransactionInMs: number;
+    getTransaction(txid: string): Promise<TTransactionResponse>;
+    getTransactionsByAddress(params: TTransactionsByAddressParams): Promise<TTransactionsByAddressResponse>;
+    getFullTransactionsByAddress(params: TFullTransactionsByAddressParams): Promise<TFullTransactionsByAddressResponse>;
+    exportFullTransactionsByAddress(params: TExportTransactionsByAddressParams): Promise<string>;
     getContract(contractHash: string): Promise<ContractResponse>;
-    getTokenInfo(tokenHash: string): Promise<Token>;
-    getBalance(address: string): Promise<BalanceResponse[]>;
+    getTokenInfo(tokenHash: string): Promise<TBSToken>;
+    getBalance(address: string): Promise<TBalanceResponse[]>;
     getBlockHeight(): Promise<number>;
-    getRpcList(): Promise<RpcResponse[]>;
 }
-export interface BDSClaimable {
+export interface IClaimDataService {
     getUnclaimed(address: string): Promise<string>;
 }
-export type TokenPricesResponse = {
+export type TTokenPricesResponse = {
     usdPrice: number;
-    token: Token;
+    token: TBSToken;
 };
-export type TokenPricesHistoryResponse = {
+export type TTokenPricesHistoryResponse = {
     usdPrice: number;
     timestamp: number;
-    token: Token;
+    token: TBSToken;
 };
-export type GetTokenPriceHistoryParams = {
-    token: Token;
+export type TGetTokenPriceHistoryParams = {
+    token: TBSToken;
     type: 'hour' | 'day';
     limit: number;
 };
-export type GetTokenPricesParams = {
-    tokens: Token[];
+export type TGetTokenPricesParams = {
+    tokens: TBSToken[];
 };
-export interface ExchangeDataService {
-    getTokenPrices(params: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
-    getTokenPriceHistory(params: GetTokenPriceHistoryParams): Promise<TokenPricesHistoryResponse[]>;
+export interface IExchangeDataService {
+    getTokenPrices(params: TGetTokenPricesParams): Promise<TTokenPricesResponse[]>;
+    getTokenPriceHistory(params: TGetTokenPriceHistoryParams): Promise<TTokenPricesHistoryResponse[]>;
     getCurrencyRatio(currency: string): Promise<number>;
 }
-export interface NftResponse {
+export type TNftResponse = {
     hash: string;
     collection: {
         name?: string;
@@ -276,58 +282,58 @@ export interface NftResponse {
     image?: string;
     name?: string;
     isSVG?: boolean;
-}
-export interface NftsResponse {
-    items: NftResponse[];
+};
+export type TNftsResponse = {
+    items: TNftResponse[];
     nextCursor?: string;
     total?: number;
-}
-export type GetNftsByAddressParams = {
+};
+export type TGetNftsByAddressParams = {
     address: string;
     page?: number;
     cursor?: string;
     size?: number;
 };
-export type GetNftParam = {
+export type TGetNftParam = {
     tokenHash: string;
     collectionHash: string;
 };
-export type HasTokenParam = {
+export type THasTokenParam = {
     address: string;
     collectionHash: string;
 };
-export interface NftDataService {
-    getNftsByAddress(params: GetNftsByAddressParams): Promise<NftsResponse>;
-    getNft(params: GetNftParam): Promise<NftResponse>;
-    hasToken(params: HasTokenParam): Promise<boolean>;
+export interface INftDataService {
+    getNftsByAddress(params: TGetNftsByAddressParams): Promise<TNftsResponse>;
+    getNft(params: TGetNftParam): Promise<TNftResponse>;
+    hasToken(params: THasTokenParam): Promise<boolean>;
 }
-export type BuildNftUrlParams = {
+export type TBuildNftUrlParams = {
     collectionHash: string;
     tokenHash: string;
 };
-export interface ExplorerService {
+export interface IExplorerService {
     buildTransactionUrl(hash: string): string;
     buildContractUrl(contractHash: string): string;
-    buildNftUrl(params: BuildNftUrlParams): string;
+    buildNftUrl(params: TBuildNftUrlParams): string;
     getAddressTemplateUrl(): string | undefined;
     getTxTemplateUrl(): string | undefined;
     getNftTemplateUrl(): string | undefined;
     getContractTemplateUrl(): string | undefined;
 }
-export type LedgerServiceEmitter = TypedEmitter<{
+export type TLedgerServiceEmitter = TypedEmitter<{
     getSignatureStart(): void | Promise<void>;
     getSignatureEnd(): void | Promise<void>;
 }>;
-export type GetLedgerTransport<BSName extends string = string> = (account: Account<BSName>) => Promise<Transport>;
-export interface LedgerService<BSName extends string = string> {
-    emitter: LedgerServiceEmitter;
-    getLedgerTransport?: GetLedgerTransport<BSName>;
-    getAccounts(transport: Transport, getUntilIndex?: UntilIndexRecord<BSName>): Promise<Account<BSName>[]>;
-    getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
+export type TGetLedgerTransport<N extends string = string> = (account: TBSAccount<N>) => Promise<Transport>;
+export interface ILedgerService<N extends string = string> {
+    emitter: TLedgerServiceEmitter;
+    getLedgerTransport?: TGetLedgerTransport<N>;
+    getAccounts(transport: Transport, getUntilIndex?: TUntilIndexRecord<N>): Promise<TBSAccount<N>[]>;
+    getAccount(transport: Transport, index: number): Promise<TBSAccount<N>>;
 }
-export type TSwapToken<BSName extends string = string> = {
+export type TSwapToken<N extends string = string> = {
     id: string;
-    blockchain?: BSName;
+    blockchain?: N;
     imageUrl?: string;
     symbol: string;
     name: string;
@@ -349,17 +355,17 @@ export type TSwapMinMaxAmount = {
     min: string;
     max: string | null;
 };
-export type TSwapOrchestratorEvents<BSName extends string = string> = {
-    accountToUse: (account: TSwapValidateValue<Account<BSName>>) => void | Promise<void>;
+export type TSwapOrchestratorEvents<N extends string = string> = {
+    accountToUse: (account: TSwapValidateValue<TBSAccount<N>>) => void | Promise<void>;
     amountToUse: (amount: TSwapLoadableValue<string>) => void | Promise<void>;
     amountToUseMinMax: (minMax: TSwapLoadableValue<TSwapMinMaxAmount>) => void | Promise<void>;
-    tokenToUse: (token: TSwapLoadableValue<TSwapToken<BSName>>) => void | Promise<void>;
-    availableTokensToUse: (tokens: TSwapLoadableValue<TSwapToken<BSName>[]>) => void | Promise<void>;
+    tokenToUse: (token: TSwapLoadableValue<TSwapToken<N>>) => void | Promise<void>;
+    availableTokensToUse: (tokens: TSwapLoadableValue<TSwapToken<N>[]>) => void | Promise<void>;
     addressToReceive: (account: TSwapValidateValue<string>) => void | Promise<void>;
     extraIdToReceive: (extraIdToReceive: TSwapValidateValue<string>) => void;
     amountToReceive: (amount: TSwapLoadableValue<string>) => void | Promise<void>;
-    tokenToReceive: (token: TSwapLoadableValue<TSwapToken<BSName>>) => void | Promise<void>;
-    availableTokensToReceive: (tokens: TSwapLoadableValue<TSwapToken<BSName>[]>) => void | Promise<void>;
+    tokenToReceive: (token: TSwapLoadableValue<TSwapToken<N>>) => void | Promise<void>;
+    availableTokensToReceive: (tokens: TSwapLoadableValue<TSwapToken<N>[]>) => void | Promise<void>;
     error: (error: string) => void | Promise<void>;
 };
 export type TSwapResult = {
@@ -376,20 +382,20 @@ export type TSwapServiceStatusResponse = {
 export interface ISwapService {
     getStatus(id: string): Promise<TSwapServiceStatusResponse>;
 }
-export interface ISwapOrchestrator<BSName extends string = string> {
-    eventEmitter: TypedEmitter<TSwapOrchestratorEvents<BSName>>;
-    setTokenToUse(token: TSwapToken<BSName> | null): Promise<void>;
-    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+export interface ISwapOrchestrator<N extends string = string> {
+    eventEmitter: TypedEmitter<TSwapOrchestratorEvents<N>>;
+    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(extraId: string | null): Promise<void>;
     swap(): Promise<TSwapResult>;
     calculateFee(): Promise<string>;
 }
-export type TBridgeToken<BSName extends string = string> = Token & {
+export type TBridgeToken<N extends string = string> = TBSToken & {
+    blockchain: N;
     multichainId: string;
-    blockchain: BSName;
 };
 export type TBridgeValue<T> = {
     value: T | null;
@@ -399,64 +405,65 @@ export type TBridgeValue<T> = {
 export type TBridgeValidateValue<T> = TBridgeValue<T> & {
     valid: boolean | null;
 };
-export type TBridgeOrchestratorEvents<BSName extends string = string> = {
-    accountToUse: (account: TBridgeValue<Account<BSName>>) => void | Promise<void>;
+export type TBridgeOrchestratorEvents<N extends string = string> = {
+    accountToUse: (account: TBridgeValue<TBSAccount<N>>) => void | Promise<void>;
     amountToUse: (amount: TBridgeValidateValue<string>) => void | Promise<void>;
     amountToUseMin: (max: TBridgeValue<string>) => void | Promise<void>;
     amountToUseMax: (max: TBridgeValue<string>) => void | Promise<void>;
-    tokenToUse: (token: TBridgeValue<TBridgeToken<BSName>>) => void | Promise<void>;
-    availableTokensToUse: (tokens: TBridgeValue<TBridgeToken<BSName>[]>) => void | Promise<void>;
+    tokenToUse: (token: TBridgeValue<TBridgeToken<N>>) => void | Promise<void>;
+    availableTokensToUse: (tokens: TBridgeValue<TBridgeToken<N>[]>) => void | Promise<void>;
     addressToReceive: (account: TBridgeValidateValue<string>) => void | Promise<void>;
     amountToReceive: (amount: TBridgeValue<string>) => void | Promise<void>;
-    tokenToReceive: (token: TBridgeValue<TBridgeToken<BSName>>) => void | Promise<void>;
-    tokenToUseBalance: (balance: TBridgeValue<BalanceResponse | undefined>) => void | Promise<void>;
+    tokenToReceive: (token: TBridgeValue<TBridgeToken<N>>) => void | Promise<void>;
+    tokenToUseBalance: (balance: TBridgeValue<TBalanceResponse | undefined>) => void | Promise<void>;
     bridgeFee: (fee: TBridgeValue<string>) => void | Promise<void>;
 };
-export interface IBridgeOrchestrator<BSName extends string = string> {
-    eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<BSName>>;
-    setTokenToUse(token: TBridgeToken<BSName> | null): Promise<void>;
-    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+export interface IBridgeOrchestrator<N extends string = string> {
+    eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<N>>;
+    setTokenToUse(token: TBridgeToken<N> | null): Promise<void>;
+    setAccountToUse(account: TBSAccount<N> | null): Promise<void>;
     setAmountToUse(amount: string | null): Promise<void>;
     setAddressToReceive(address: string | null): Promise<void>;
-    setBalances(balances: BalanceResponse[] | null): Promise<void>;
+    setBalances(balances: TBalanceResponse[] | null): Promise<void>;
     switchTokens(): Promise<void>;
     bridge(): Promise<string>;
 }
-export interface IBSWithNeo3NeoXBridge<BSName extends string = string> {
-    neo3NeoXBridgeService: INeo3NeoXBridgeService<BSName>;
+export interface IBSWithNeo3NeoXBridge<N extends string = string> {
+    neo3NeoXBridgeService: INeo3NeoXBridgeService<N>;
 }
 export type TNeo3NeoXBridgeServiceConstants = {
     bridgeFee: string;
     bridgeMaxAmount: string;
     bridgeMinAmount: string;
 };
-export type TNeo3NeoXBridgeServiceBridgeParam<BSName extends string = string> = {
-    account: Account<BSName>;
+export type TNeo3NeoXBridgeServiceBridgeParam<N extends string = string> = {
+    account: TBSAccount<N>;
     receiverAddress: string;
     amount: string;
-    token: TBridgeToken<BSName>;
+    token: TBridgeToken<N>;
     bridgeFee: string;
 };
-export type TNeo3NeoXBridgeServiceGetApprovalParam<BSName extends string = string> = {
-    account: Account<BSName>;
+export type TNeo3NeoXBridgeServiceGetApprovalParam<N extends string = string> = {
+    account: TBSAccount<N>;
     amount: string;
-    token: TBridgeToken<BSName>;
+    token: TBridgeToken<N>;
 };
-export type TNeo3NeoXBridgeServiceGetNonceParams<BSName extends string = string> = {
-    token: TBridgeToken<BSName>;
+export type TNeo3NeoXBridgeServiceGetNonceParams<N extends string = string> = {
+    token: TBridgeToken<N>;
     transactionHash: string;
 };
-export type TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<BSName extends string = string> = {
-    token: TBridgeToken<BSName>;
+export type TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<N extends string = string> = {
+    token: TBridgeToken<N>;
     nonce: string;
 };
-export interface INeo3NeoXBridgeService<BSName extends string = string> {
-    tokens: TBridgeToken<BSName>[];
+export interface INeo3NeoXBridgeService<N extends string = string> {
+    readonly gasToken: TBridgeToken<N>;
+    readonly neoToken: TBridgeToken<N>;
     getApprovalFee(params: TNeo3NeoXBridgeServiceGetApprovalParam): Promise<string>;
     getBridgeConstants(token: TBridgeToken): Promise<TNeo3NeoXBridgeServiceConstants>;
-    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
-    getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams<BSName>): Promise<string>;
-    getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<BSName>): Promise<string>;
+    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<N>): Promise<string>;
+    getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams<N>): Promise<string>;
+    getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<N>): Promise<string>;
 }
 export type TTokenServicePredicateParams = {
     hash: string;
@@ -472,7 +479,7 @@ export interface ITokenService {
     predicate(compareFrom: TTokenServicePredicateParams, compareTo: TTokenServicePredicateParams): boolean;
     predicateByHash(compareFrom: TTokenServicePredicateByHashParams, compareTo: TTokenServicePredicateByHashParams): boolean;
     predicateBySymbol(compareFrom: TTokenServicePredicateBySymbolParams, compareTo: TTokenServicePredicateBySymbolParams): boolean;
-    normalizeToken<T extends Token | Token[]>(token: T): T;
+    normalizeToken<T extends TBSToken | TBSToken[]>(token: T): T;
     normalizeHash(hash: string): string;
 }
 export {};

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

@@ -1,8 +1,7 @@
-import { ExchangeDataService, GetTokenPriceHistoryParams, GetTokenPricesParams, TokenPricesHistoryResponse, TokenPricesResponse } from '../../interfaces';
-export declare class CryptoCompareEDS implements ExchangeDataService {
+import { TGetTokenPriceHistoryParams, TGetTokenPricesParams, IExchangeDataService, TTokenPricesHistoryResponse, TTokenPricesResponse } from '../../interfaces';
+export declare class CryptoCompareEDS implements IExchangeDataService {
     #private;
-    constructor();
-    getTokenPrices(params: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
-    getTokenPriceHistory(params: GetTokenPriceHistoryParams): Promise<TokenPricesHistoryResponse[]>;
+    getTokenPrices(params: TGetTokenPricesParams): Promise<TTokenPricesResponse[]>;
+    getTokenPriceHistory(params: TGetTokenPriceHistoryParams): Promise<TTokenPricesHistoryResponse[]>;
     getCurrencyRatio(currency: string): Promise<number>;
 }