@cityofzion/bs-ethereum 3.0.5 → 3.1.0

package/dist/BSEthereum.d.ts

@@ -1,19 +1,19 @@
-import { TBSAccount, TIntentTransferParam, TBSToken, TTransferParam, TGetLedgerTransport, ITokenService, TBSNetwork, IBlockchainDataService, IExchangeDataService, INftDataService, IExplorerService, TPingNetworkResponse, IWalletConnectService, type IFullTransactionsDataService } from '@cityofzion/blockchain-service';
+import { type TBSAccount, type TTransferIntent, type TBSToken, type TTransferParams, type TGetLedgerTransport, type ITokenService, type TBSNetwork, type IBlockchainDataService, type IExchangeDataService, type INftDataService, type IExplorerService, type TPingNetworkResponse, type IWalletConnectService, type IFullTransactionsDataService, type TTransactionDefault } from '@cityofzion/blockchain-service';
 import { ethers } from 'ethers';
 import { EthersLedgerServiceEthereum } from './services/ledger/EthersLedgerServiceEthereum';
-import { IBSEthereum, TBSEthereumNetworkId, TSupportedEVM } from './types';
+import type { IBSEthereum, TBSEthereumNetworkId, TSupportedEVM } from './types';
 import { TypedDataSigner } from '@ethersproject/abstract-signer';
 export declare class BSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> implements IBSEthereum<N, A> {
     #private;
     readonly name: N;
-    readonly bip44DerivationPath: string;
+    readonly bipDerivationPath: string;
     readonly isMultiTransferSupported = false;
     readonly isCustomNetworkSupported = false;
     tokens: TBSToken[];
     nativeTokens: TBSToken[];
     feeToken: TBSToken;
     network: TBSNetwork<A>;
-    rpcNetworkUrls: string[];
+    networkUrls: string[];
     readonly defaultNetwork: TBSNetwork<A>;
     readonly availableNetworks: TBSNetwork<A>[];
     blockchainDataService: IBlockchainDataService<N>;
@@ -25,13 +25,13 @@ export declare class BSEthereum<N extends string = string, A extends string = TB
     walletConnectService: IWalletConnectService<N>;
     fullTransactionsDataService: IFullTransactionsDataService<N>;
     constructor(name: N, evm?: TSupportedEVM, network?: TBSNetwork<A>, getLedgerTransport?: TGetLedgerTransport<N>);
-    protected _buildTransferParams(intent: TIntentTransferParam): Promise<{
+    protected _buildTransferParams(intent: TTransferIntent): Promise<{
         transactionParams: ethers.utils.Deferrable<ethers.providers.TransactionRequest>;
         gasPrice: ethers.BigNumber;
     }>;
     generateSigner(account: TBSAccount<N>): Promise<ethers.Signer & TypedDataSigner>;
     setNetwork(network: TBSNetwork<A>): void;
-    pingNode(url: string): Promise<TPingNetworkResponse>;
+    pingNetwork(url: string): Promise<TPingNetworkResponse>;
     validateAddress(address: string): boolean;
     validateEncrypted(json: string): boolean;
     validateKey(key: string): boolean;
@@ -41,7 +41,7 @@ export declare class BSEthereum<N extends string = string, A extends string = TB
     generateAccountFromPublicKey(publicKey: string): Promise<TBSAccount<N>>;
     decrypt(json: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
-    transfer(param: TTransferParam<N>): Promise<string[]>;
-    calculateTransferFee(param: TTransferParam<N>): Promise<string>;
+    transfer({ senderAccount, intents }: TTransferParams<N>): Promise<TTransactionDefault<N>[]>;
+    calculateTransferFee(params: TTransferParams<N>): Promise<string>;
     resolveNameServiceDomain(domainName: string): Promise<string>;
 }

package/dist/BSEthereum.js

@@ -66,7 +66,7 @@ class BSEthereum {
         this.isCustomNetworkSupported = false;
         this.name = name;
         this.ledgerService = new EthersLedgerServiceEthereum_1.EthersLedgerServiceEthereum(this, getLedgerTransport);
-        this.bip44DerivationPath = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH;
+        this.bipDerivationPath = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_BIP_DERIVATION_PATH;
         if (!evm)
             return;
         this.availableNetworks = BSEthereumConstants_1.BSEthereumConstants.NETWORKS_BY_EVM[evm];
@@ -105,22 +105,23 @@ class BSEthereum {
         if (account.isHardware) {
             if (!this.ledgerService.getLedgerTransport)
                 throw new Error('You must provide getLedgerTransport function to use Ledger');
-            if (typeof account.bip44Path !== 'string')
-                throw new Error('Your account must have bip44 path to use Ledger');
+            if (!account.bipPath) {
+                throw new Error('Account must have BIP path to use Ledger');
+            }
             const ledgerTransport = await this.ledgerService.getLedgerTransport(account);
-            return this.ledgerService.getSigner(ledgerTransport, account.bip44Path, provider);
+            return this.ledgerService.getSigner(ledgerTransport, account.bipPath, provider);
         }
         return new ethers_1.ethers.Wallet(account.key, provider);
     }
     setNetwork(network) {
-        const rpcNetworkUrls = BSEthereumConstants_1.BSEthereumConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
-        const isValidNetwork = blockchain_service_1.BSUtilsHelper.validateNetwork(network, this.availableNetworks, rpcNetworkUrls);
+        const networkUrls = BSEthereumConstants_1.BSEthereumConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
+        const isValidNetwork = blockchain_service_1.BSUtilsHelper.validateNetwork(network, this.availableNetworks, networkUrls);
         if (!isValidNetwork) {
             throw new Error(`Network with id ${network.id} is not available for ${this.name}`);
         }
         __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_setTokens).call(this, network);
         this.network = network;
-        this.rpcNetworkUrls = rpcNetworkUrls;
+        this.networkUrls = networkUrls;
         this.nftDataService = new GhostMarketNDSEthereum_1.GhostMarketNDSEthereum(this);
         this.explorerService = new BlockscoutESEthereum_1.BlockscoutESEthereum(this);
         this.exchangeDataService = new MoralisEDSEthereum_1.MoralisEDSEthereum(this);
@@ -130,7 +131,7 @@ class BSEthereum {
         this.fullTransactionsDataService = new MoralisFullTransactionsDataServiceEthereum_1.MoralisFullTransactionsDataServiceEthereum(this);
     }
     // This method is done manually because we need to ensure that the request is aborted after timeout
-    async pingNode(url) {
+    async pingNetwork(url) {
         const abortController = new AbortController();
         const timeout = setTimeout(() => {
             abortController.abort();
@@ -166,13 +167,13 @@ class BSEthereum {
         return domainName.endsWith('.eth');
     }
     async generateAccountFromMnemonic(mnemonic, index) {
-        const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
-        const hd = ethers_1.ethers.utils.HDNode.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic).derivePath(bip44Path);
+        const bipPath = blockchain_service_1.BSKeychainHelper.getBipPath(this.bipDerivationPath, index);
+        const hd = ethers_1.ethers.utils.HDNode.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic).derivePath(bipPath);
         return {
             address: hd.address,
             key: hd.privateKey,
             type: 'privateKey',
-            bip44Path,
+            bipPath,
             blockchain: this.name,
         };
     }
@@ -207,12 +208,14 @@ class BSEthereum {
         const wallet = new ethers_1.ethers.Wallet(key);
         return wallet.encrypt(password);
     }
-    async transfer(param) {
-        const signer = await this.generateSigner(param.senderAccount);
-        const sentTransactionHashes = [];
+    async transfer({ senderAccount, intents }) {
+        const signer = await this.generateSigner(senderAccount);
+        const { address } = senderAccount;
+        const addressUrl = this.explorerService.buildAddressUrl(address);
+        const nativeTokenHash = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this.network).hash;
+        const transactions = [];
         let error;
-        for (const intent of param.intents) {
-            let transactionHash = '';
+        for (const intent of intents) {
             try {
                 const { transactionParams, gasPrice } = await this._buildTransferParams(intent);
                 let gasLimit;
@@ -222,29 +225,56 @@ class BSEthereum {
                 catch {
                     gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
                 }
+                const fee = ethers_1.ethers.utils.formatEther(gasPrice.mul(gasLimit));
                 const transaction = await signer.sendTransaction({
                     ...transactionParams,
                     gasLimit,
                     maxPriorityFeePerGas: gasPrice,
                     maxFeePerGas: gasPrice,
                 });
-                transactionHash = transaction.hash;
+                const txId = transaction.hash;
+                if (txId) {
+                    const { receiverAddress, token } = intent;
+                    const tokenHash = token.hash;
+                    const isNativeToken = this.tokenService.predicateByHash(nativeTokenHash, tokenHash);
+                    transactions.push({
+                        txId,
+                        txIdUrl: this.explorerService.buildTransactionUrl(txId),
+                        date: new Date().toJSON(),
+                        networkFeeAmount: fee,
+                        type: 'default',
+                        view: 'default',
+                        events: [
+                            {
+                                eventType: 'token',
+                                amount: intent.amount,
+                                methodName: 'transfer',
+                                from: address,
+                                fromUrl: addressUrl,
+                                to: receiverAddress,
+                                toUrl: this.explorerService.buildAddressUrl(receiverAddress),
+                                tokenType: isNativeToken ? 'native' : 'erc-20',
+                                tokenUrl: this.explorerService.buildContractUrl(tokenHash),
+                                token,
+                            },
+                        ],
+                    });
+                }
             }
-            catch (err) {
+            catch (currentError) {
                 if (!error)
-                    error = err;
+                    error = currentError;
             }
-            sentTransactionHashes.push(transactionHash);
         }
-        if (error && sentTransactionHashes.every(hash => !hash)) {
+        if (!!error && transactions.length === 0) {
             throw error;
         }
-        return sentTransactionHashes;
+        return transactions;
     }
-    async calculateTransferFee(param) {
-        const signer = await this.generateSigner(param.senderAccount);
+    async calculateTransferFee(params) {
+        const signer = await this.generateSigner(params.senderAccount);
         let fee = ethers_1.ethers.utils.parseEther('0');
-        for (const intent of param.intents) {
+        for (const intent of params.intents) {
             const { gasPrice, transactionParams } = await this._buildTransferParams(intent);
             const estimated = await signer.estimateGas(transactionParams);
             const intentFee = gasPrice.mul(estimated);

package/dist/constants/BSEthereumConstants.d.ts

@@ -1,9 +1,9 @@
-import { TBSNetwork } from '@cityofzion/blockchain-service';
-import { TBSEthereumNetworkId, TSupportedEVM } from '../types';
+import type { TBSNetwork } from '@cityofzion/blockchain-service';
+import type { TBSEthereumNetworkId, TSupportedEVM } from '../types';
 export declare class BSEthereumConstants {
     static readonly DEFAULT_DECIMALS = 18;
     static readonly DEFAULT_GAS_LIMIT = 21000;
-    static readonly DEFAULT_BIP44_DERIVATION_PATH = "m/44'/60'/0'/0/?";
+    static readonly DEFAULT_BIP_DERIVATION_PATH = "m/44'/60'/0'/0/?";
     static readonly NATIVE_SYMBOL_BY_NETWORK_ID: Record<TBSEthereumNetworkId, string>;
     static readonly NATIVE_WRAPPED_HASH_BY_NETWORK_ID: Partial<Record<TBSEthereumNetworkId, string>>;
     static readonly RPC_LIST_BY_NETWORK_ID: Record<TBSEthereumNetworkId, string[]>;

package/dist/constants/BSEthereumConstants.js

@@ -8,7 +8,7 @@ exports.BSEthereumConstants = BSEthereumConstants;
 _a = BSEthereumConstants;
 BSEthereumConstants.DEFAULT_DECIMALS = 18;
 BSEthereumConstants.DEFAULT_GAS_LIMIT = 0x5208;
-BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/60'/0'/0/?";
+BSEthereumConstants.DEFAULT_BIP_DERIVATION_PATH = "m/44'/60'/0'/0/?";
 BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID = {
     '1': 'ETH',
     '10': 'ETH',
@@ -40,8 +40,8 @@ BSEthereumConstants.NATIVE_WRAPPED_HASH_BY_NETWORK_ID = {
 };
 BSEthereumConstants.RPC_LIST_BY_NETWORK_ID = {
     '1': [
-        'https://eth.llamarpc.com',
         'https://ethereum-rpc.publicnode.com',
+        'https://eth.llamarpc.com',
         'https://rpc.mevblocker.io',
         'https://rpc.flashbots.net',
         'https://endpoints.omniatech.io/v1/eth/mainnet/public',

package/dist/helpers/BSEthereumHelper.d.ts

@@ -1,5 +1,5 @@
-import { TBSNetwork, TBSNetworkId } from '@cityofzion/blockchain-service';
-import { IBSEthereum, TBSEthereumNetworkId } from '../types';
+import type { TBSNetwork, TBSNetworkId } from '@cityofzion/blockchain-service';
+import type { IBSEthereum, TBSEthereumNetworkId } from '../types';
 export declare class BSEthereumHelper {
     static getNativeAsset(network: TBSNetwork<TBSEthereumNetworkId>): {
         symbol: string;

package/dist/services/blockchain-data/MoralisBDSEthereum.d.ts

@@ -1,6 +1,6 @@
-import { TBalanceResponse, TBSToken, TBSNetwork, TBSNetworkId, type TContractResponse, type TTransaction, type TGetTransactionsByAddressResponse, type TGetTransactionsByAddressParams } from '@cityofzion/blockchain-service';
+import { type TBalanceResponse, type TBSToken, type TBSNetwork, type TBSNetworkId, type TContractResponse, type TGetTransactionsByAddressResponse, type TGetTransactionsByAddressParams, type TTransactionDefault } from '@cityofzion/blockchain-service';
 import axios from 'axios';
-import { IBSEthereum, TBSEthereumNetworkId } from '../../types';
+import type { IBSEthereum, TBSEthereumNetworkId } from '../../types';
 import { RpcBDSEthereum } from './RpcBDSEthereum';
 export declare class MoralisBDSEthereum<N extends string, A extends TBSNetworkId> extends RpcBDSEthereum<N, A> {
     #private;
@@ -11,7 +11,7 @@ export declare class MoralisBDSEthereum<N extends string, A extends TBSNetworkId
     constructor(service: IBSEthereum<N, A>);
     getBalance(address: string): Promise<TBalanceResponse[]>;
     getTokenInfo(hash: string): Promise<TBSToken>;
-    getTransaction(hash: string): Promise<TTransaction<N>>;
-    getTransactionsByAddress(params: TGetTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N>>;
+    getTransaction(hash: string): Promise<TTransactionDefault<N>>;
+    getTransactionsByAddress(params: TGetTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N, TTransactionDefault<N>>>;
     getContract(hash: string): Promise<TContractResponse>;
 }

package/dist/services/blockchain-data/MoralisBDSEthereum.js

@@ -80,7 +80,7 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
         if (this._tokenCache.has(hash)) {
             return this._tokenCache.get(hash);
         }
-        const response = await __classPrivateFieldGet(this, _MoralisBDSEthereum_instances, "a", _MoralisBDSEthereum_api_get).get(`/erc20/metadata`, {
+        const response = await __classPrivateFieldGet(this, _MoralisBDSEthereum_instances, "a", _MoralisBDSEthereum_api_get).get('/erc20/metadata', {
             params: {
                 addresses: [hash],
             },
@@ -101,29 +101,23 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
         }
         const { data } = await __classPrivateFieldGet(this, _MoralisBDSEthereum_instances, "a", _MoralisBDSEthereum_api_get).get(`/transaction/${hash}/verbose`);
         const events = [];
-        const txTemplateUrl = this._service.explorerService.getTxTemplateUrl();
-        const addressTemplateUrl = this._service.explorerService.getAddressTemplateUrl();
-        const contractTemplateUrl = this._service.explorerService.getContractTemplateUrl();
-        const nftTemplateUrl = this._service.explorerService.getNftTemplateUrl();
         if (data.value && Number(data.value) > 0) {
             const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._service.network);
-            const fromUrl = addressTemplateUrl?.replace('{address}', data.from_address);
-            const toUrl = addressTemplateUrl?.replace('{address}', data.to_address);
-            const contractHashUrl = contractTemplateUrl?.replace('{hash}', nativeToken.hash);
+            const fromUrl = this._service.explorerService.buildAddressUrl(data.from_address);
+            const toUrl = this._service.explorerService.buildAddressUrl(data.to_address);
             events.push({
                 eventType: 'token',
                 amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(data.value, nativeToken.decimals), {
                     decimals: nativeToken.decimals,
                 }),
-                from: data.from_address,
-                to: data.to_address,
-                token: nativeToken,
-                contractHash: nativeToken.hash,
-                tokenType: 'native',
                 methodName: 'transfer',
-                contractHashUrl,
+                from: data.from_address,
                 fromUrl,
+                to: data.to_address,
                 toUrl,
+                tokenType: 'native',
+                tokenUrl: this._service.explorerService.buildContractUrl(nativeToken.hash),
+                token: nativeToken,
             });
         }
         if (data.logs) {
@@ -134,70 +128,58 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                     return;
                 const contractHash = log.address;
                 const amount = log.decoded_event.params.find((param) => param.name === 'value')?.value;
-                const from = log.decoded_event.params.find((param) => param.name === 'from')?.value;
-                const to = log.decoded_event.params.find((param) => param.name === 'to')?.value;
+                const from = log.decoded_event.params.find((param) => param.name === 'from')?.value || data.from_address;
+                const to = log.decoded_event.params.find((param) => param.name === 'to')?.value || data.to_address;
                 if (!from || !to)
                     return;
-                const fromUrl = addressTemplateUrl?.replace('{address}', data.from_address);
-                const toUrl = addressTemplateUrl?.replace('{address}', data.to_address);
-                const contractHashUrl = contractTemplateUrl?.replace('{hash}', contractHash);
+                const fromUrl = this._service.explorerService.buildAddressUrl(from);
+                const toUrl = this._service.explorerService.buildAddressUrl(to);
                 if (amount) {
                     const token = await this.getTokenInfo(contractHash);
                     events.push({
-                        contractHash,
+                        eventType: 'token',
                         amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(amount, token.decimals), {
                             decimals: token.decimals,
                         }),
+                        methodName: 'transfer',
                         from,
                         fromUrl,
                         to,
                         toUrl,
-                        eventType: 'token',
-                        methodName: 'transfer',
                         tokenType: 'erc-20',
-                        contractHashUrl,
+                        tokenUrl: this._service.explorerService.buildContractUrl(contractHash),
+                        token,
                     });
                 }
                 const tokenHash = log.decoded_event.params.find((param) => param.name === 'tokenId')?.value;
                 if (!tokenHash)
                     return;
                 const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
-                const nftUrl = contractHash
-                    ? nftTemplateUrl?.replace('{collectionHash}', contractHash).replace('{tokenHash}', tokenHash)
-                    : undefined;
                 events.push({
-                    collectionHash: contractHash,
-                    tokenHash,
+                    eventType: 'nft',
+                    amount: '1',
+                    methodName: 'transfer',
                     from,
                     fromUrl,
                     to,
                     toUrl,
-                    eventType: 'nft',
-                    methodName: 'transfer',
                     tokenType: 'erc-721',
-                    amount: '1',
-                    nftImageUrl: nft?.image,
-                    nftUrl,
-                    name: nft?.name,
-                    collectionName: nft?.collection?.name,
-                    collectionHashUrl: contractHashUrl,
+                    nft,
                 });
             });
             await Promise.allSettled(promises);
         }
-        const txIdUrl = txTemplateUrl?.replace('{txId}', hash);
         return {
             txId: hash,
+            txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
             block: Number(data.block_number),
-            date: new Date(data.block_timestamp).toISOString(),
-            invocationCount: 0,
-            notificationCount: 0,
+            date: new Date(data.block_timestamp).toJSON(),
             networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromNumber(data.transaction_fee), {
                 decimals: this._service.feeToken.decimals,
             }),
-            txIdUrl,
-            events,
             type: 'default',
+            view: 'default',
+            events,
         };
     }
     async getTransactionsByAddress(params) {
@@ -212,113 +194,93 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
         });
         const transactions = [];
         const nativeAsset = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._service.network);
-        const txTemplateUrl = this._service.explorerService.getTxTemplateUrl();
-        const addressTemplateUrl = this._service.explorerService.getAddressTemplateUrl();
-        const contractTemplateUrl = this._service.explorerService.getContractTemplateUrl();
-        const nftTemplateUrl = this._service.explorerService.getNftTemplateUrl();
-        const promises = data.result.map(async (item) => {
+        const promises = data.result.map(async (item, index) => {
             const events = [];
-            const nativeContractHashUrl = contractTemplateUrl?.replace('{hash}', nativeAsset.hash);
             item.native_transfers.forEach(transfer => {
-                const fromUrl = addressTemplateUrl?.replace('{address}', transfer.from_address);
-                const toUrl = addressTemplateUrl?.replace('{address}', transfer.to_address);
+                const fromUrl = this._service.explorerService.buildAddressUrl(transfer.from_address);
+                const toUrl = this._service.explorerService.buildAddressUrl(transfer.to_address);
                 events.push({
+                    eventType: 'token',
                     amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(transfer.value, nativeAsset.decimals), {
                         decimals: nativeAsset.decimals,
                     }),
+                    methodName: 'transfer',
                     from: transfer.from_address,
                     fromUrl,
                     to: transfer.to_address,
                     toUrl,
-                    eventType: 'token',
-                    token: nativeAsset,
-                    contractHash: nativeAsset.hash,
-                    methodName: 'transfer',
                     tokenType: 'native',
-                    contractHashUrl: nativeContractHashUrl,
+                    tokenUrl: this._service.explorerService.buildContractUrl(nativeAsset.hash),
+                    token: nativeAsset,
                 });
             });
             item.erc20_transfers.forEach(transfer => {
                 if (transfer.possible_spam)
                     return;
-                const fromUrl = addressTemplateUrl?.replace('{address}', transfer.from_address);
-                const toUrl = addressTemplateUrl?.replace('{address}', transfer.to_address);
-                const contractHashUrl = contractTemplateUrl?.replace('{hash}', transfer.address);
+                const fromUrl = this._service.explorerService.buildAddressUrl(transfer.from_address);
+                const toUrl = this._service.explorerService.buildAddressUrl(transfer.to_address);
+                const tokenHash = transfer.address;
+                const tokenDecimals = transfer.token_decimals;
                 events.push({
-                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(transfer.value, transfer.token_decimals), {
-                        decimals: transfer.token_decimals,
+                    eventType: 'token',
+                    amount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(transfer.value, tokenDecimals), {
+                        decimals: tokenDecimals,
                     }),
+                    methodName: 'transfer',
                     from: transfer.from_address,
                     fromUrl,
                     to: transfer.to_address,
                     toUrl,
-                    eventType: 'token',
+                    tokenType: 'erc-20',
+                    tokenUrl: this._service.explorerService.buildContractUrl(tokenHash),
                     token: this._service.tokenService.normalizeToken({
-                        decimals: Number(transfer.token_decimals),
-                        hash: transfer.address,
+                        decimals: Number(tokenDecimals),
+                        hash: tokenHash,
                         name: transfer.token_name,
                         symbol: transfer.token_symbol,
                     }),
-                    contractHash: transfer.address,
-                    methodName: 'transfer',
-                    tokenType: 'erc-20',
-                    contractHashUrl,
                 });
             });
             const nftPromises = item.nft_transfers.map(async (transfer) => {
-                const fromUrl = addressTemplateUrl?.replace('{address}', transfer.from_address);
-                const toUrl = addressTemplateUrl?.replace('{address}', transfer.to_address);
-                const collectionHashUrl = contractTemplateUrl?.replace('{contractHash}', transfer.token_address);
-                const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: transfer.token_address, tokenHash: transfer.token_id }));
-                const nftUrl = nftTemplateUrl
-                    ?.replace('{collectionHash}', transfer.token_address)
-                    .replace('{tokenHash}', transfer.token_id);
+                const fromUrl = this._service.explorerService.buildAddressUrl(transfer.from_address);
+                const toUrl = this._service.explorerService.buildAddressUrl(transfer.to_address);
+                const tokenHash = transfer.token_id;
+                const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: transfer.token_address, tokenHash }));
                 events.push({
-                    collectionHash: transfer.token_address,
-                    collectionHashUrl,
-                    tokenHash: transfer.token_id,
+                    eventType: 'nft',
+                    amount: '1',
+                    methodName: 'transfer',
                     from: transfer.from_address,
                     fromUrl,
                     to: transfer.to_address,
                     toUrl,
-                    eventType: 'nft',
-                    methodName: 'transfer',
                     tokenType: 'erc-721',
-                    amount: '1',
-                    nftImageUrl: nft?.image,
-                    nftUrl,
-                    name: nft?.name,
-                    collectionName: nft?.collection?.name,
+                    nft,
                 });
             });
             await Promise.allSettled(nftPromises);
-            const txIdUrl = txTemplateUrl?.replace('{txId}', item.hash);
-            transactions.push({
-                block: Number(item.block_number),
+            transactions.splice(index, 0, {
                 txId: item.hash,
-                txIdUrl,
-                notificationCount: 0,
-                invocationCount: 0,
+                txIdUrl: this._service.explorerService.buildTransactionUrl(item.hash),
+                block: Number(item.block_number),
+                date: new Date(item.block_timestamp).toJSON(),
                 networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromNumber(item.transaction_fee), {
                     decimals: this._service.feeToken.decimals,
                 }),
-                date: new Date(item.block_timestamp).toISOString(),
-                events,
                 type: 'default',
+                view: 'default',
+                events,
             });
         });
         await Promise.allSettled(promises);
-        return {
-            nextPageParams: data.cursor,
-            transactions,
-        };
+        return { nextPageParams: data.cursor, transactions };
     }
     async getContract(hash) {
         if (!_a.isSupported(this._service.network)) {
             return super.getContract(hash);
         }
         try {
-            const { data } = await __classPrivateFieldGet(this, _MoralisBDSEthereum_instances, "a", _MoralisBDSEthereum_api_get).get(`erc20/metadata`, {
+            const { data } = await __classPrivateFieldGet(this, _MoralisBDSEthereum_instances, "a", _MoralisBDSEthereum_api_get).get('erc20/metadata', {
                 params: {
                     addresses: [hash],
                 },

package/dist/services/blockchain-data/RpcBDSEthereum.d.ts

@@ -1,13 +1,13 @@
-import { TBalanceResponse, IBlockchainDataService, TBSNetworkId, TBSToken, type TContractResponse, type TGetTransactionsByAddressParams, type TGetTransactionsByAddressResponse, type TTransaction } from '@cityofzion/blockchain-service';
-import { IBSEthereum } from '../../types';
+import { type TBalanceResponse, type IBlockchainDataService, type TBSNetworkId, type TBSToken, type TContractResponse, type TGetTransactionsByAddressParams, type TGetTransactionsByAddressResponse, type TTransactionDefault } from '@cityofzion/blockchain-service';
+import type { IBSEthereum } from '../../types';
 export declare class RpcBDSEthereum<N extends string, A extends TBSNetworkId, S extends IBSEthereum<N, A> = IBSEthereum<N, A>> implements IBlockchainDataService<N> {
     #private;
     readonly maxTimeToConfirmTransactionInMs: number;
     readonly _tokenCache: Map<string, TBSToken>;
     readonly _service: S;
     constructor(service: S);
-    getTransaction(hash: string): Promise<TTransaction<N>>;
-    getTransactionsByAddress(_params: TGetTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N>>;
+    getTransaction(hash: string): Promise<TTransactionDefault<N>>;
+    getTransactionsByAddress(_params: TGetTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N, TTransactionDefault<N>>>;
     getContract(_hash: string): Promise<TContractResponse>;
     getTokenInfo(hash: string): Promise<TBSToken>;
     getBalance(address: string): Promise<TBalanceResponse[]>;

package/dist/services/blockchain-data/RpcBDSEthereum.js

@@ -35,24 +35,19 @@ class RpcBDSEthereum {
         const effectiveGasPrice = receipt.effectiveGasPrice ?? transaction.gasPrice;
         const fee = effectiveGasPrice.mul(receipt.gasUsed);
         const token = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(this._service.network);
-        const txTemplateUrl = this._service.explorerService.getTxTemplateUrl();
-        const addressTemplateUrl = this._service.explorerService.getAddressTemplateUrl();
-        const contractTemplateUrl = this._service.explorerService.getContractTemplateUrl();
-        const fromUrl = addressTemplateUrl?.replace('{address}', transaction.from);
-        const toUrl = addressTemplateUrl?.replace('{address}', transaction.to);
-        const contractHashUrl = contractTemplateUrl?.replace('{hash}', token.hash);
-        const txIdUrl = txTemplateUrl?.replace('{txId}', hash);
+        const fromUrl = this._service.explorerService.buildAddressUrl(transaction.from);
+        const toUrl = this._service.explorerService.buildAddressUrl(transaction.to);
         const timestamp = transaction.timestamp ?? 0;
         return {
             txId: hash,
-            txIdUrl,
+            txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
             block: receipt.blockNumber,
-            date: new Date(timestamp).toISOString(),
-            invocationCount: 0,
-            notificationCount: 0,
+            date: new Date(timestamp).toJSON(),
             networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromDecimals(fee.toString(), this._service.feeToken.decimals), {
                 decimals: this._service.feeToken.decimals,
             }),
+            type: 'default',
+            view: 'default',
             events: [
                 {
                     eventType: 'token',
@@ -64,13 +59,11 @@ class RpcBDSEthereum {
                     fromUrl,
                     to: transaction.to,
                     toUrl,
-                    contractHash: token.hash,
-                    contractHashUrl,
-                    token: token ?? undefined,
                     tokenType: 'native',
+                    tokenUrl: this._service.explorerService.buildContractUrl(token.hash),
+                    token,
                 },
             ],
-            type: 'default',
         };
     }
     async getTransactionsByAddress(_params) {

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

@@ -1,5 +1,5 @@
-import { CryptoCompareEDS, TGetTokenPriceHistoryParams, TGetTokenPricesParams, TBSNetworkId, TTokenPricesHistoryResponse, TTokenPricesResponse } from '@cityofzion/blockchain-service';
-import { IBSEthereum } from '../../types';
+import { CryptoCompareEDS, type TGetTokenPriceHistoryParams, type TGetTokenPricesParams, type TBSNetworkId, type TTokenPricesHistoryResponse, type TTokenPricesResponse } from '@cityofzion/blockchain-service';
+import type { IBSEthereum } from '../../types';
 export declare class MoralisEDSEthereum<N extends string, A extends TBSNetworkId> extends CryptoCompareEDS {
     #private;
     static readonly NUMBERS_OF_BLOCK_BY_HOUR: number;

package/dist/services/explorer/BlockscoutESEthereum.d.ts

@@ -1,16 +1,16 @@
-import { TBuildNftUrlParams, IExplorerService, TBSNetworkId } from '@cityofzion/blockchain-service';
-import { IBSEthereum, TBSEthereumNetworkId } from '../../types';
+import type { TBuildNftUrlParams, IExplorerService, TBSNetworkId } from '@cityofzion/blockchain-service';
+import type { IBSEthereum, TBSEthereumNetworkId } from '../../types';
 export declare class BlockscoutESEthereum<N extends string, A extends TBSNetworkId> implements IExplorerService {
     #private;
     static readonly DEFAULT_BASE_URL_BY_NETWORK_ID: Partial<Record<TBSEthereumNetworkId, string>>;
     readonly _service: IBSEthereum<N, A>;
     constructor(service: IBSEthereum<N, A>, baseUrl?: string);
-    buildTransactionUrl(hash: string): string | undefined;
+    buildTransactionUrl(transactionId: string): string | undefined;
     buildContractUrl(contractHash: string): string | undefined;
-    buildNftUrl(params: TBuildNftUrlParams): string | undefined;
+    buildNftUrl({ tokenHash, collectionHash }: TBuildNftUrlParams): string | undefined;
     buildAddressUrl(address: string): string | undefined;
     getAddressTemplateUrl(): string | undefined;
-    getTxTemplateUrl(): string | undefined;
+    getTransactionTemplateUrl(): string | undefined;
     getNftTemplateUrl(): string | undefined;
     getContractTemplateUrl(): string | undefined;
 }

package/dist/services/explorer/BlockscoutESEthereum.js

@@ -10,41 +10,44 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _BlockscoutESEthereum_baseUrl;
+var _BlockscoutESEthereum_instances, _BlockscoutESEthereum_baseUrl, _BlockscoutESEthereum_validateValueLength;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockscoutESEthereum = void 0;
 class BlockscoutESEthereum {
     constructor(service, baseUrl) {
+        _BlockscoutESEthereum_instances.add(this);
         _BlockscoutESEthereum_baseUrl.set(this, void 0);
         this._service = service;
         __classPrivateFieldSet(this, _BlockscoutESEthereum_baseUrl, baseUrl ?? BlockscoutESEthereum.DEFAULT_BASE_URL_BY_NETWORK_ID[this._service.network.id], "f");
     }
-    buildTransactionUrl(hash) {
-        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f"))
+    buildTransactionUrl(transactionId) {
+        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_instances, "m", _BlockscoutESEthereum_validateValueLength).call(this, transactionId))
             return undefined;
-        return `${__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f")}/tx/${this._service.tokenService.normalizeHash(hash)}`;
+        return this.getTransactionTemplateUrl()?.replace('{txId}', this._service.tokenService.normalizeHash(transactionId));
     }
     buildContractUrl(contractHash) {
-        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f"))
+        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_instances, "m", _BlockscoutESEthereum_validateValueLength).call(this, contractHash))
             return undefined;
-        return `${__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f")}/address/${this._service.tokenService.normalizeHash(contractHash)}`;
+        return this.getContractTemplateUrl()?.replace('{hash}', this._service.tokenService.normalizeHash(contractHash));
     }
-    buildNftUrl(params) {
-        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f") || !params.collectionHash)
+    buildNftUrl({ tokenHash, collectionHash }) {
+        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_instances, "m", _BlockscoutESEthereum_validateValueLength).call(this, tokenHash, 1) || !__classPrivateFieldGet(this, _BlockscoutESEthereum_instances, "m", _BlockscoutESEthereum_validateValueLength).call(this, collectionHash))
             return undefined;
-        return `${__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f")}/token/${this._service.tokenService.normalizeHash(params.collectionHash)}/instance/${params.tokenHash}`;
+        return this.getNftTemplateUrl()
+            ?.replace('{tokenHash}', tokenHash)
+            ?.replace('{collectionHash}', this._service.tokenService.normalizeHash(collectionHash));
     }
     buildAddressUrl(address) {
-        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f"))
+        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_instances, "m", _BlockscoutESEthereum_validateValueLength).call(this, address))
             return undefined;
-        return `${__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f")}/address/${address}`;
+        return this.getAddressTemplateUrl()?.replace('{address}', address);
     }
     getAddressTemplateUrl() {
         if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f"))
             return undefined;
         return `${__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f")}/address/{address}`;
     }
-    getTxTemplateUrl() {
+    getTransactionTemplateUrl() {
         if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f"))
             return undefined;
         return `${__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f")}/tx/{txId}`;
@@ -61,7 +64,9 @@ class BlockscoutESEthereum {
     }
 }
 exports.BlockscoutESEthereum = BlockscoutESEthereum;
-_BlockscoutESEthereum_baseUrl = new WeakMap();
+_BlockscoutESEthereum_baseUrl = new WeakMap(), _BlockscoutESEthereum_instances = new WeakSet(), _BlockscoutESEthereum_validateValueLength = function _BlockscoutESEthereum_validateValueLength(value, minimumLength) {
+    return !!value?.length && value.length >= (minimumLength || 4);
+};
 BlockscoutESEthereum.DEFAULT_BASE_URL_BY_NETWORK_ID = {
     '1': 'https://eth.blockscout.com',
     '10': 'https://optimism.blockscout.com',

package/dist/services/full-transactions-data/MoralisFullTransactionsDataServiceEthereum.d.ts

@@ -1,4 +1,4 @@
-import { type IFullTransactionsDataService, type TBSNetworkId, type TExportFullTransactionsByAddressParams, type TGetFullTransactionsByAddressParams, type TGetTransactionsByAddressResponse } from '@cityofzion/blockchain-service';
+import { type IFullTransactionsDataService, type TBSNetworkId, type TExportFullTransactionsByAddressParams, type TGetFullTransactionsByAddressParams, type TGetTransactionsByAddressResponse, type TTransactionDefault } from '@cityofzion/blockchain-service';
 import type { IBSEthereum, TBSEthereumNetworkId } from '../../types';
 export declare class MoralisFullTransactionsDataServiceEthereum<N extends string, A extends TBSNetworkId> implements IFullTransactionsDataService<N> {
     #private;
@@ -7,6 +7,6 @@ export declare class MoralisFullTransactionsDataServiceEthereum<N extends string
     static readonly ERC1155_STANDARDS: string[];
     static readonly ERC20_STANDARDS: string[];
     constructor(service: IBSEthereum<N, A>);
-    getFullTransactionsByAddress({ nextPageParams, ...params }: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N>>;
+    getFullTransactionsByAddress({ nextPageParams, ...params }: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N, TTransactionDefault<N>>>;
     exportFullTransactionsByAddress(params: TExportFullTransactionsByAddressParams): Promise<string>;
 }

package/dist/services/full-transactions-data/MoralisFullTransactionsDataServiceEthereum.js

@@ -38,27 +38,19 @@ class MoralisFullTransactionsDataServiceEthereum {
         });
         const items = response.data ?? [];
         const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(__classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").network);
-        const addressTemplateUrl = __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.getAddressTemplateUrl();
-        const txTemplateUrl = __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.getTxTemplateUrl();
-        const nftTemplateUrl = __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.getNftTemplateUrl();
-        const contractTemplateUrl = __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.getContractTemplateUrl();
-        const itemPromises = items.map(async ({ networkFeeAmount, systemFeeAmount, ...item }, index) => {
+        const itemPromises = items.map(async ({ networkFeeAmount, ...item }, index) => {
             const txId = item.transactionID;
             const newItem = {
                 txId,
-                txIdUrl: txId ? txTemplateUrl?.replace('{txId}', txId) : undefined,
+                txIdUrl: __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.buildTransactionUrl(txId),
                 block: item.block,
                 date: item.date,
-                invocationCount: item.invocationCount,
-                notificationCount: item.notificationCount,
                 networkFeeAmount: networkFeeAmount
                     ? blockchain_service_1.BSBigNumberHelper.format(networkFeeAmount, { decimals: nativeToken.decimals })
                     : undefined,
-                systemFeeAmount: systemFeeAmount
-                    ? blockchain_service_1.BSBigNumberHelper.format(systemFeeAmount, { decimals: nativeToken.decimals })
-                    : undefined,
-                events: [],
                 type: 'default',
+                view: 'default',
+                events: [],
             };
             const eventPromises = item.events.map(async (event, eventIndex) => {
                 const { methodName, tokenID: tokenHash, contractHash } = event;
@@ -69,30 +61,20 @@ class MoralisFullTransactionsDataServiceEthereum {
                 const isErc721 = MoralisFullTransactionsDataServiceEthereum.ERC721_STANDARDS.includes(standard);
                 const isErc20 = MoralisFullTransactionsDataServiceEthereum.ERC20_STANDARDS.includes(standard);
                 const isNft = (isErc1155 || isErc721) && !!tokenHash;
-                const fromUrl = from ? addressTemplateUrl?.replace('{address}', from) : undefined;
-                const toUrl = to ? addressTemplateUrl?.replace('{address}', to) : undefined;
-                const contractHashUrl = contractHash ? contractTemplateUrl?.replace('{hash}', contractHash) : undefined;
+                const fromUrl = from ? __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.buildAddressUrl(from) : undefined;
+                const toUrl = to ? __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.buildAddressUrl(to) : undefined;
                 if (isNft) {
                     const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
-                    const nftUrl = contractHash
-                        ? nftTemplateUrl?.replace('{collectionHash}', contractHash).replace('{tokenHash}', tokenHash)
-                        : undefined;
                     newItem.events.splice(eventIndex, 0, {
                         eventType: 'nft',
-                        amount: undefined,
+                        amount: '1',
                         methodName,
                         from,
                         fromUrl,
                         to,
                         toUrl,
-                        collectionHash: contractHash,
-                        collectionHashUrl: contractHashUrl,
-                        tokenHash,
                         tokenType: isErc1155 ? 'erc-1155' : 'erc-721',
-                        nftImageUrl: nft?.image,
-                        nftUrl,
-                        name: nft?.name,
-                        collectionName: nft?.collection?.name,
+                        nft,
                     });
                     return;
                 }
@@ -107,10 +89,9 @@ class MoralisFullTransactionsDataServiceEthereum {
                     fromUrl,
                     to,
                     toUrl,
-                    contractHash,
-                    contractHashUrl,
-                    token: token ?? undefined,
                     tokenType: isErc20 ? 'erc-20' : 'generic',
+                    tokenUrl: __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.buildContractUrl(contractHash),
+                    token,
                 });
             });
             await Promise.allSettled(eventPromises);

package/dist/services/ledger/EthersLedgerServiceEthereum.d.ts

@@ -1,4 +1,4 @@
-import { TBSAccount, TLedgerServiceEmitter, TGetLedgerTransport, TUntilIndexRecord, ILedgerService } from '@cityofzion/blockchain-service';
+import { type TBSAccount, type TLedgerServiceEmitter, type TGetLedgerTransport, type TUntilIndexRecord, type ILedgerService } from '@cityofzion/blockchain-service';
 import Transport from '@ledgerhq/hw-transport';
 import { ethers, Signer } from 'ethers';
 import { TypedDataSigner } from '@ethersproject/abstract-signer';
@@ -6,7 +6,7 @@ import { BSEthereum } from '../../BSEthereum';
 export declare class EthersLedgerSigner extends Signer implements TypedDataSigner {
     #private;
     static shouldRetry: (error: any) => boolean;
-    constructor(transport: Transport, bip44Path: string, provider?: ethers.providers.Provider, emitter?: TLedgerServiceEmitter);
+    constructor(transport: Transport, bipPath: string, provider?: ethers.providers.Provider, emitter?: TLedgerServiceEmitter);
     connect(provider: ethers.providers.Provider): EthersLedgerSigner;
     getAddress(): Promise<string>;
     signMessage(message: string | ethers.utils.Bytes): Promise<string>;

package/dist/services/ledger/EthersLedgerServiceEthereum.js

@@ -46,7 +46,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _EthersLedgerSigner_transport, _EthersLedgerSigner_emitter, _EthersLedgerSigner_bip44Path, _EthersLedgerSigner_ledgerApp, _EthersLedgerServiceEthereum_blockchainService;
+var _EthersLedgerSigner_transport, _EthersLedgerSigner_emitter, _EthersLedgerSigner_bipPath, _EthersLedgerSigner_ledgerApp, _EthersLedgerServiceEthereum_blockchainService;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EthersLedgerServiceEthereum = exports.EthersLedgerSigner = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
@@ -55,23 +55,23 @@ const ethers_1 = require("ethers");
 const properties_1 = require("@ethersproject/properties");
 const events_1 = __importDefault(require("events"));
 class EthersLedgerSigner extends ethers_1.Signer {
-    constructor(transport, bip44Path, provider, emitter) {
+    constructor(transport, bipPath, provider, emitter) {
         super();
         _EthersLedgerSigner_transport.set(this, void 0);
         _EthersLedgerSigner_emitter.set(this, void 0);
-        _EthersLedgerSigner_bip44Path.set(this, void 0);
+        _EthersLedgerSigner_bipPath.set(this, void 0);
         _EthersLedgerSigner_ledgerApp.set(this, void 0);
-        __classPrivateFieldSet(this, _EthersLedgerSigner_bip44Path, bip44Path, "f");
+        __classPrivateFieldSet(this, _EthersLedgerSigner_bipPath, bipPath, "f");
         __classPrivateFieldSet(this, _EthersLedgerSigner_transport, transport, "f");
         __classPrivateFieldSet(this, _EthersLedgerSigner_emitter, emitter, "f");
         __classPrivateFieldSet(this, _EthersLedgerSigner_ledgerApp, new hw_app_eth_1.default(transport), "f");
         (0, properties_1.defineReadOnly)(this, 'provider', provider);
     }
     connect(provider) {
-        return new EthersLedgerSigner(__classPrivateFieldGet(this, _EthersLedgerSigner_transport, "f"), __classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), provider, __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f"));
+        return new EthersLedgerSigner(__classPrivateFieldGet(this, _EthersLedgerSigner_transport, "f"), __classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f"), provider, __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f"));
     }
     async getAddress() {
-        const { address } = await blockchain_service_1.BSUtilsHelper.retry(() => __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").getAddress(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f")), {
+        const { address } = await blockchain_service_1.BSUtilsHelper.retry(() => __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").getAddress(__classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f")), {
             shouldRetry: EthersLedgerSigner.shouldRetry,
         });
         return address;
@@ -82,7 +82,7 @@ class EthersLedgerSigner extends ethers_1.Signer {
                 message = ethers_1.ethers.utils.toUtf8Bytes(message);
             }
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureStart');
-            const obj = await blockchain_service_1.BSUtilsHelper.retry(() => __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signPersonalMessage(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), ethers_1.ethers.utils.hexlify(message).substring(2)), { shouldRetry: EthersLedgerSigner.shouldRetry });
+            const obj = await __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signPersonalMessage(__classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f"), ethers_1.ethers.utils.hexlify(message).substring(2));
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureEnd');
             // Normalize the signature for Ethers
             obj.r = '0x' + obj.r;
@@ -102,7 +102,7 @@ class EthersLedgerSigner extends ethers_1.Signer {
                 .substring(2);
             const resolution = await hw_app_eth_1.ledgerService.resolveTransaction(serializedUnsignedTransaction, {}, {});
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureStart');
-            const signature = await blockchain_service_1.BSUtilsHelper.retry(() => __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signTransaction(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), serializedUnsignedTransaction, resolution), { shouldRetry: EthersLedgerSigner.shouldRetry });
+            const signature = await __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signTransaction(__classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f"), serializedUnsignedTransaction, resolution);
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureEnd');
             return ethers_1.ethers.utils.serializeTransaction(tx, {
                 v: ethers_1.ethers.BigNumber.from('0x' + signature.v).toNumber(),
@@ -129,14 +129,12 @@ class EthersLedgerSigner extends ethers_1.Signer {
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureStart');
             let obj;
             try {
-                obj = await blockchain_service_1.BSUtilsHelper.retry(() => __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signEIP712Message(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), payload), {
-                    shouldRetry: EthersLedgerSigner.shouldRetry,
-                });
+                obj = await __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signEIP712Message(__classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f"), payload);
             }
             catch {
                 const domainSeparatorHex = ethers_1.ethers.utils._TypedDataEncoder.hashDomain(payload.domain);
                 const hashStructMessageHex = ethers_1.ethers.utils._TypedDataEncoder.hashStruct(payload.primaryType, types, payload.message);
-                obj = await blockchain_service_1.BSUtilsHelper.retry(() => __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signEIP712HashedMessage(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), domainSeparatorHex, hashStructMessageHex), { shouldRetry: EthersLedgerSigner.shouldRetry });
+                obj = await __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signEIP712HashedMessage(__classPrivateFieldGet(this, _EthersLedgerSigner_bipPath, "f"), domainSeparatorHex, hashStructMessageHex);
             }
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureEnd');
             // Normalize the signature for Ethers
@@ -151,7 +149,7 @@ class EthersLedgerSigner extends ethers_1.Signer {
     }
 }
 exports.EthersLedgerSigner = EthersLedgerSigner;
-_EthersLedgerSigner_transport = new WeakMap(), _EthersLedgerSigner_emitter = new WeakMap(), _EthersLedgerSigner_bip44Path = new WeakMap(), _EthersLedgerSigner_ledgerApp = new WeakMap();
+_EthersLedgerSigner_transport = new WeakMap(), _EthersLedgerSigner_emitter = new WeakMap(), _EthersLedgerSigner_bipPath = new WeakMap(), _EthersLedgerSigner_ledgerApp = new WeakMap();
 EthersLedgerSigner.shouldRetry = (error) => {
     return error?.id === 'TransportLocked';
 };
@@ -171,8 +169,8 @@ class EthersLedgerServiceEthereum {
     }
     async getAccount(transport, index) {
         const ledgerApp = new hw_app_eth_1.default(transport);
-        const bip44Path = __classPrivateFieldGet(this, _EthersLedgerServiceEthereum_blockchainService, "f").bip44DerivationPath.replace('?', index.toString());
-        const { publicKey, address } = await blockchain_service_1.BSUtilsHelper.retry(() => ledgerApp.getAddress(bip44Path), {
+        const bipPath = blockchain_service_1.BSKeychainHelper.getBipPath(__classPrivateFieldGet(this, _EthersLedgerServiceEthereum_blockchainService, "f").bipDerivationPath, index);
+        const { publicKey, address } = await blockchain_service_1.BSUtilsHelper.retry(() => ledgerApp.getAddress(bipPath), {
             shouldRetry: EthersLedgerSigner.shouldRetry,
         });
         const publicKeyWithPrefix = '0x' + publicKey;
@@ -180,7 +178,7 @@ class EthersLedgerServiceEthereum {
             address,
             key: publicKeyWithPrefix,
             type: 'publicKey',
-            bip44Path,
+            bipPath,
             blockchain: __classPrivateFieldGet(this, _EthersLedgerServiceEthereum_blockchainService, "f").name,
             isHardware: true,
         };

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

@@ -1,8 +1,8 @@
-import { TBSNetworkId, GhostMarketNDS, THasTokenParam } from '@cityofzion/blockchain-service';
-import { IBSEthereum, TBSEthereumNetworkId } from '../../types';
+import { GhostMarketNDS, type TBSNetworkId, type THasTokenParams } from '@cityofzion/blockchain-service';
+import type { IBSEthereum, TBSEthereumNetworkId } from '../../types';
 export declare class GhostMarketNDSEthereum<N extends string, A extends TBSNetworkId> extends GhostMarketNDS<N, A, IBSEthereum<N, A>> {
     static readonly CHAIN_BY_NETWORK_ID: Partial<Record<TBSEthereumNetworkId, string>>;
     constructor(service: IBSEthereum<N, A>);
-    hasToken({ collectionHash, address }: THasTokenParam): Promise<boolean>;
+    hasToken({ address, collectionHash }: THasTokenParams): Promise<boolean>;
     getChain(): string;
 }

package/dist/services/nft-data/GhostMarketNDSEthereum.js

@@ -8,7 +8,7 @@ class GhostMarketNDSEthereum extends blockchain_service_1.GhostMarketNDS {
     constructor(service) {
         super(service);
     }
-    async hasToken({ collectionHash, address }) {
+    async hasToken({ address, collectionHash }) {
         try {
             if (!collectionHash)
                 return false;

package/dist/services/wallet-connect/WalletConnectServiceEthereum.d.ts

@@ -1,5 +1,5 @@
-import { IWalletConnectService, TBSNetworkId, TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
-import { IBSEthereum } from '../../types';
+import type { IWalletConnectService, TBSNetworkId, TWalletConnectServiceRequestMethodParams } from '@cityofzion/blockchain-service';
+import type { IBSEthereum } from '../../types';
 import { ethers } from 'ethers';
 export declare class WalletConnectServiceEthereum<N extends string, A extends TBSNetworkId> implements IWalletConnectService<N> {
     #private;

package/dist/services/wallet-connect/WalletConnectServiceEthereum.js

@@ -50,11 +50,9 @@ class WalletConnectServiceEthereum {
         if (typeof param !== 'object') {
             throw new Error('Invalid params');
         }
-        if (!param.chainId) {
-            const chainId = parseInt(this._service.network.id);
-            if (!isNaN(chainId))
-                param.chainId = chainId;
-        }
+        const chainId = parseInt(param.chainId ?? this._service.network.id);
+        if (!isNaN(chainId))
+            param.chainId = chainId;
         if (param.gas) {
             param.gasLimit = param.gas;
             delete param.gas;

package/dist/types.d.ts

@@ -1,9 +1,9 @@
-import { IBlockchainService, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNft, IBSWithWalletConnect, TBSAccount, TBSNetworkId, type IBSWithFullTransactions } from '@cityofzion/blockchain-service';
+import type { IBlockchainService, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNft, IBSWithWalletConnect, TBSAccount, TBSNetworkId, IBSWithFullTransactions } from '@cityofzion/blockchain-service';
 import { TypedDataSigner } from '@ethersproject/abstract-signer';
 import { ethers } from 'ethers';
 export type TBSEthereumNetworkId = TBSNetworkId<'1' | '10' | '25' | '56' | '137' | '250' | '1101' | '8453' | '80002' | '42161' | '42220' | '43114' | '59144' | '11155111'>;
 export type TSupportedEVM = 'ethereum' | 'polygon' | 'base' | 'arbitrum';
-export interface IBSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> extends IBlockchainService<N, A>, IBSWithNft, IBSWithNameService, IBSWithFee<N>, IBSWithLedger<N>, IBSWithExplorer, IBSWithEncryption<N>, IBSWithWalletConnect<N>, IBSWithFullTransactions<N> {
+export interface IBSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> extends IBlockchainService<N, A>, IBSWithNameService, IBSWithNft, IBSWithFee<N>, IBSWithLedger<N>, IBSWithExplorer, IBSWithEncryption<N>, IBSWithWalletConnect<N>, IBSWithFullTransactions<N> {
     generateSigner(account: TBSAccount<N>): Promise<ethers.Signer & TypedDataSigner>;
 }
 export type TMoralisBDSEthereumNativeBalanceApiResponse = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-ethereum",
-  "version": "3.0.5",
+  "version": "3.1.0",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -17,16 +17,16 @@
     "@ethersproject/json-wallets": "5.8.0",
     "@ethersproject/properties": "5.8.0",
     "@ledgerhq/hw-app-eth": "~7.3.0",
-    "axios": "~1.13.2",
+    "axios": "~1.13.5",
     "ethers": "5.8.0",
-    "@cityofzion/blockchain-service": "3.0.5"
+    "@cityofzion/blockchain-service": "3.1.0"
   },
   "devDependencies": {
     "@ledgerhq/hw-transport": "~6.32.0",
     "@ledgerhq/hw-transport-node-hid": "~6.30.0",
     "date-fns": "~4.1.0",
     "dotenv": "~17.3.1",
-    "eslint": "~9.36.0",
+    "eslint": "~9.37.0",
     "typescript": "~5.9.2",
     "vitest": "~4.0.18"
   },