@cityofzion/bs-ethereum 3.0.6 → 3.1.1

package/dist/BSEthereum.d.ts

@@ -1,4 +1,4 @@
-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 } 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 type { IBSEthereum, TBSEthereumNetworkId, TSupportedEVM } from './types';
@@ -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: TTransferParams<N>): Promise<string[]>;
-    calculateTransferFee(param: TTransferParams<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.bipDerivationPath = 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,8 +105,9 @@ class BSEthereum {
         if (account.isHardware) {
             if (!this.ledgerService.getLedgerTransport)
                 throw new Error('You must provide getLedgerTransport function to use Ledger');
-            if (typeof account.bipPath !== '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.bipPath, provider);
         }
@@ -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

@@ -3,7 +3,7 @@ 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/services/blockchain-data/MoralisBDSEthereum.d.ts

@@ -1,4 +1,4 @@
-import { type TBalanceResponse, type TBSToken, type TBSNetwork, type 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 type { IBSEthereum, TBSEthereumNetworkId } from '../../types';
 import { RpcBDSEthereum } from './RpcBDSEthereum';
@@ -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],
             },
@@ -110,15 +110,14 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                 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: this._service.explorerService.buildContractUrl(nativeToken.hash),
+                from: data.from_address,
                 fromUrl,
+                to: data.to_address,
                 toUrl,
+                tokenType: 'native',
+                tokenUrl: this._service.explorerService.buildContractUrl(nativeToken.hash),
+                token: nativeToken,
             });
         }
         if (data.logs) {
@@ -129,27 +128,27 @@ 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 = this._service.explorerService.buildAddressUrl(data.from_address);
-                const toUrl = this._service.explorerService.buildAddressUrl(data.to_address);
+                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: this._service.explorerService.buildContractUrl(contractHash),
+                        tokenUrl: this._service.explorerService.buildContractUrl(contractHash),
+                        token,
                     });
                 }
                 const tokenHash = log.decoded_event.params.find((param) => param.name === 'tokenId')?.value;
@@ -157,37 +156,30 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                     return;
                 const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
                 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: nft?.explorerUri,
-                    name: nft?.name,
-                    collectionName: nft?.collection?.name,
-                    collectionHashUrl: nft?.collection?.url,
+                    nft,
                 });
             });
             await Promise.allSettled(promises);
         }
         return {
             txId: hash,
+            txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
             block: Number(data.block_number),
             date: new Date(data.block_timestamp).toJSON(),
-            invocationCount: 0,
-            notificationCount: 0,
             networkFeeAmount: blockchain_service_1.BSBigNumberHelper.format(blockchain_service_1.BSBigNumberHelper.fromNumber(data.transaction_fee), {
                 decimals: this._service.feeToken.decimals,
             }),
-            txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
-            events,
             type: 'default',
+            view: 'default',
+            events,
         };
     }
     async getTransactionsByAddress(params) {
@@ -208,19 +200,18 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                 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: this._service.explorerService.buildContractUrl(nativeAsset.hash),
+                    tokenUrl: this._service.explorerService.buildContractUrl(nativeAsset.hash),
+                    token: nativeAsset,
                 });
             });
             item.erc20_transfers.forEach(transfer => {
@@ -228,76 +219,68 @@ class MoralisBDSEthereum extends RpcBDSEthereum_1.RpcBDSEthereum {
                     return;
                 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: this._service.explorerService.buildContractUrl(transfer.address),
                 });
             });
             const nftPromises = item.nft_transfers.map(async (transfer) => {
                 const fromUrl = this._service.explorerService.buildAddressUrl(transfer.from_address);
                 const toUrl = this._service.explorerService.buildAddressUrl(transfer.to_address);
-                const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => this._service.nftDataService.getNft({ collectionHash: transfer.token_address, tokenHash: transfer.token_id }));
+                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: nft?.collection?.url,
-                    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: nft?.explorerUri,
-                    name: nft?.name,
-                    collectionName: nft?.collection?.name,
+                    nft,
                 });
             });
             await Promise.allSettled(nftPromises);
             transactions.splice(index, 0, {
-                block: Number(item.block_number),
                 txId: item.hash,
                 txIdUrl: this._service.explorerService.buildTransactionUrl(item.hash),
-                notificationCount: 0,
-                invocationCount: 0,
+                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).toJSON(),
-                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,4 +1,4 @@
-import { type TBalanceResponse, type IBlockchainDataService, type TBSNetworkId, type TBSToken, type TContractResponse, type TGetTransactionsByAddressParams, type TGetTransactionsByAddressResponse, type TTransaction } from '@cityofzion/blockchain-service';
+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;
@@ -6,8 +6,8 @@ export declare class RpcBDSEthereum<N extends string, A extends TBSNetworkId, S
     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

@@ -43,11 +43,11 @@ class RpcBDSEthereum {
             txIdUrl: this._service.explorerService.buildTransactionUrl(hash),
             block: receipt.blockNumber,
             date: new Date(timestamp).toJSON(),
-            invocationCount: 0,
-            notificationCount: 0,
             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',
@@ -59,13 +59,11 @@ class RpcBDSEthereum {
                     fromUrl,
                     to: transaction.to,
                     toUrl,
-                    contractHash: token.hash,
-                    contractHashUrl: this._service.explorerService.buildContractUrl(token.hash),
-                    token: token ?? undefined,
                     tokenType: 'native',
+                    tokenUrl: this._service.explorerService.buildContractUrl(token.hash),
+                    token,
                 },
             ],
-            type: 'default',
         };
     }
     async getTransactionsByAddress(_params) {

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

@@ -5,12 +5,12 @@ export declare class BlockscoutESEthereum<N extends string, A extends TBSNetwork
     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({ 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") || !hash?.length)
+    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") || !contractHash?.length)
+        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_instances, "m", _BlockscoutESEthereum_validateValueLength).call(this, contractHash, 1))
             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({ tokenHash, collectionHash }) {
-        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f") || !tokenHash?.length || !collectionHash?.length)
+        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(collectionHash)}/instance/${tokenHash}`;
+        return this.getNftTemplateUrl()
+            ?.replace('{tokenHash}', tokenHash)
+            ?.replace('{collectionHash}', this._service.tokenService.normalizeHash(collectionHash));
     }
     buildAddressUrl(address) {
-        if (!__classPrivateFieldGet(this, _BlockscoutESEthereum_baseUrl, "f") || !address?.length)
+        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,23 +38,19 @@ class MoralisFullTransactionsDataServiceEthereum {
         });
         const items = response.data ?? [];
         const nativeToken = BSEthereumHelper_1.BSEthereumHelper.getNativeAsset(__classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").network);
-        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 ? __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.buildTransactionUrl(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;
@@ -71,20 +67,14 @@ class MoralisFullTransactionsDataServiceEthereum {
                     const [nft] = await blockchain_service_1.BSUtilsHelper.tryCatch(() => __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").nftDataService.getNft({ collectionHash: contractHash, tokenHash }));
                     newItem.events.splice(eventIndex, 0, {
                         eventType: 'nft',
-                        amount: undefined,
+                        amount: '1',
                         methodName,
                         from,
                         fromUrl,
                         to,
                         toUrl,
-                        collectionHash: contractHash,
-                        collectionHashUrl: nft?.collection?.url,
-                        tokenHash,
                         tokenType: isErc1155 ? 'erc-1155' : 'erc-721',
-                        nftImageUrl: nft?.image,
-                        nftUrl: nft?.explorerUri,
-                        name: nft?.name,
-                        collectionName: nft?.collection?.name,
+                        nft,
                     });
                     return;
                 }
@@ -99,10 +89,9 @@ class MoralisFullTransactionsDataServiceEthereum {
                     fromUrl,
                     to,
                     toUrl,
-                    contractHash,
-                    contractHashUrl: __classPrivateFieldGet(this, _MoralisFullTransactionsDataServiceEthereum_service, "f").explorerService.buildContractUrl(contractHash),
-                    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

@@ -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 __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signPersonalMessage(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), ethers_1.ethers.utils.hexlify(message).substring(2));
+            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 __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signTransaction(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), serializedUnsignedTransaction, resolution);
+            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,12 +129,12 @@ class EthersLedgerSigner extends ethers_1.Signer {
             __classPrivateFieldGet(this, _EthersLedgerSigner_emitter, "f")?.emit('getSignatureStart');
             let obj;
             try {
-                obj = await __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signEIP712Message(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), payload);
+                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 __classPrivateFieldGet(this, _EthersLedgerSigner_ledgerApp, "f").signEIP712HashedMessage(__classPrivateFieldGet(this, _EthersLedgerSigner_bip44Path, "f"), domainSeparatorHex, hashStructMessageHex);
+                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
@@ -149,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';
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-ethereum",
-  "version": "3.0.6",
+  "version": "3.1.1",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -19,14 +19,14 @@
     "@ledgerhq/hw-app-eth": "~7.3.0",
     "axios": "~1.13.5",
     "ethers": "5.8.0",
-    "@cityofzion/blockchain-service": "3.0.6"
+    "@cityofzion/blockchain-service": "3.1.1"
   },
   "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"
   },