supports optionality of request id when configured ‑ RPC Server given REQUEST_ID_IS_OPTIONAL=true are set supports optionality of request id when configured

"eth_blockNumber" return the latest block number on second try ‑ @ethGetBlockByNumber using MirrorNode "eth_blockNumber" return the latest block number on second try
"eth_blockNumber" should return the latest block number using cache ‑ @ethGetBlockByNumber using MirrorNode "eth_blockNumber" should return the latest block number using cache
"eth_blockNumber" should return the latest block number ‑ @ethGetBlockByNumber using MirrorNode "eth_blockNumber" should return the latest block number
"eth_blockNumber" should throw an error if no blocks are found after third try ‑ @ethGetBlockByNumber using MirrorNode "eth_blockNumber" should throw an error if no blocks are found after third try
"eth_blockNumber" should throw an error if no blocks are found ‑ @ethGetBlockByNumber using MirrorNode "eth_blockNumber" should throw an error if no blocks are found
Adds a revertReason field for receipts with errorMessage ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests Adds a revertReason field for receipts with errorMessage
BLOCK_HASH filter timeouts and throws the expected error ‑ @ethGetLogs using MirrorNode timeout BLOCK_HASH filter timeouts and throws the expected error
BLOCK_HASH filter ‑ @ethGetLogs using MirrorNode BLOCK_HASH filter
Can extract the account number out of an account pagination next link url ‑ MirrorNodeClient Can extract the account number out of an account pagination next link url
Can extract the evm address out of an account pagination next link url ‑ MirrorNodeClient Can extract the evm address out of an account pagination next link url
Can provide custom x-api-key header ‑ MirrorNodeClient given MIRROR_NODE_URL_HEADER_X_API_KEY=abc123iAManAPIkey are set Can provide custom x-api-key header
Constructs correctly with request ID ‑ Errors JsonRpcError Constructs correctly with request ID
Constructs correctly without request ID ‑ Errors JsonRpcError Constructs correctly without request ID
Creates a filter with type=log ‑ Filter API Test Suite eth_newFilter Creates a filter with type=log
Creates a filter with type=new_block ‑ Filter API Test Suite eth_newBlockFilter Creates a filter with type=new_block
Decodes correctly ‑ Formatters decodeErrorMessage Decodes correctly
Decodes correctly ‑ Formatters hexToASCII Decodes correctly
Given a blockNumber, return the account balance at that blocknumber, with transactions that credit the account balance ‑ @ethGetBalance using MirrorNode Calculate balance at block timestamp Given a blockNumber, return the account balance at that blocknumber, with transactions that credit the account balance
Given a blockNumber, return the account balance at that blocknumber, with transactions that debit and credit the account balance ‑ @ethGetBalance using MirrorNode Calculate balance at block timestamp Given a blockNumber, return the account balance at that blocknumber, with transactions that debit and credit the account balance
Given a blockNumber, return the account balance at that blocknumber, with transactions that debit the account balance ‑ @ethGetBalance using MirrorNode Calculate balance at block timestamp Given a blockNumber, return the account balance at that blocknumber, with transactions that debit the account balance
Given a blockNumber, return the account balance at that blocknumber, with transactions that debit, credit, and debit the account balance ‑ @ethGetBalance using MirrorNode Calculate balance at block timestamp Given a blockNumber, return the account balance at that blocknumber, with transactions that debit, credit, and debit the account balance
Handles null type ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests Handles null type
Initialize the privateKey for OPERATOR_KEY_FORMAT set to DER ‑ SdkClient HAPIService given OPERATOR_KEY_FORMAT=DER are set Initialize the privateKey for OPERATOR_KEY_FORMAT set to DER
Initialize the privateKey for OPERATOR_KEY_FORMAT set to HEX_ECDSA ‑ SdkClient HAPIService given OPERATOR_KEY_FORMAT=HEX_ECDSA are set Initialize the privateKey for OPERATOR_KEY_FORMAT set to HEX_ECDSA
Initialize the privateKey for OPERATOR_KEY_FORMAT set to HEX_ED25519 ‑ SdkClient HAPIService given OPERATOR_KEY_FORMAT=HEX_ED25519 are set Initialize the privateKey for OPERATOR_KEY_FORMAT set to HEX_ED25519
Initialize the privateKey for default which is DER when OPERATOR_KEY_FORMAT is undefined ‑ SdkClient HAPIService given OPERATOR_KEY_FORMAT=undefined are set Initialize the privateKey for default which is DER when OPERATOR_KEY_FORMAT is undefined
Initialize the privateKey for default which is DER ‑ SdkClient HAPIService Initialize the privateKey for default which is DER
It should throw an Error when an unexpected string is set ‑ SdkClient HAPIService given OPERATOR_KEY_FORMAT=BAD_FORMAT are set It should throw an Error when an unexpected string is set
Returns a valid filterId ‑ Filter API Test Suite eth_newBlockFilter Returns a valid filterId
Returns a valid filterId ‑ Filter API Test Suite eth_newFilter Returns a valid filterId
Returns decoded message when decoded errorMessage is provided ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when decoded errorMessage is provided
Returns decoded message when decoded message is provided as errorMessage and encoded custom error is provided as data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when decoded message is provided as errorMessage and encoded custom error is provided as data
Returns decoded message when decoded message is provided as errorMessage and encoded default error is provided as data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when decoded message is provided as errorMessage and encoded default error is provided as data
Returns decoded message when encoded custom error is provided as data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when encoded custom error is provided as data
Returns decoded message when encoded custom error is provided as errorMessage and data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when encoded custom error is provided as errorMessage and data
Returns decoded message when encoded custom error is provided as errorMessage ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when encoded custom error is provided as errorMessage
Returns decoded message when encoded default error is provided as data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when encoded default error is provided as data
Returns decoded message when encoded default error is provided as errorMessage and data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when encoded default error is provided as errorMessage and data
Returns decoded message when encoded default error is provided as errorMessage ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when encoded default error is provided as errorMessage
Returns decoded message when message is empty and encoded custom error is provided as data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when message is empty and encoded custom error is provided as data
Returns decoded message when message is empty and encoded default error is provided as data ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns decoded message when message is empty and encoded default error is provided as data
Returns default message when data is empty ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns default message when data is empty
Returns default message when errorMessage is empty ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns default message when errorMessage is empty
Returns default message when neither errorMessage nor data is provided ‑ Errors JsonRpcError predefined.CONTRACT_REVERT Returns default message when neither errorMessage nor data is provided
SDK returns a precheck error ‑ @ethCall Eth Call spec eth_call using consensus node SDK returns a precheck error
SDK returns a precheck error ‑ @ethCall Eth Call spec eth_call using mirror node SDK returns a precheck error
Should check if a transaction is an unprotected pre-EIP155 transaction ‑ Precheck chainId Should check if a transaction is an unprotected pre-EIP155 transaction
Should correctly rearrange parameters for chainId ‑ Utilities unit tests paramRearrangementMap Should correctly rearrange parameters for chainId
Should correctly rearrange parameters for default ‑ Utilities unit tests paramRearrangementMap Should correctly rearrange parameters for default
Should correctly rearrange parameters for estimateGas ‑ Utilities unit tests paramRearrangementMap Should correctly rearrange parameters for estimateGas
Should correctly rearrange parameters for getStorageAt ‑ Utilities unit tests paramRearrangementMap Should correctly rearrange parameters for getStorageAt
Should correctly rearrange parameters for newFilter ‑ Utilities unit tests paramRearrangementMap Should correctly rearrange parameters for newFilter
Should create sha256 hash out of a data object ‑ subscriptionController Should create sha256 hash out of a data object
Should execute calculateTxRecordChargeAmount() to get the charge amount of transaction record ‑ SdkClient HBAR Limiter Should execute calculateTxRecordChargeAmount() to get the charge amount of transaction record
Should execute captureTransactionMetrics() by retrieving transaction record from CONSENSUS NODE client ‑ Metric Service captureTransactionMetrics given GET_RECORD_DEFAULT_TO_CONSENSUS_NODE=true are set Should execute captureTransactionMetrics() by retrieving transaction record from CONSENSUS NODE client
Should execute captureTransactionMetrics() by retrieving transaction record from MIRROR NODE client ‑ Metric Service captureTransactionMetrics given GET_RECORD_DEFAULT_TO_CONSENSUS_NODE=false are set Should execute captureTransactionMetrics() by retrieving transaction record from MIRROR NODE client
Should execute estimateFileTransactionFee() to estimate total fee of file transactions ‑ Utils estimateFileTransactionsFee Should execute estimateFileTransactionFee() to estimate total fee of file transactions
Should execute getTransferAmountSumForAccount() to calculate transactionFee by only transfers that are paid by the specify accountId ‑ MirrorNodeClient getTransactionRecordMetrics Should execute getTransferAmountSumForAccount() to calculate transactionFee by only transfers that are paid by the specify accountId
Should execute getTransferAmountSumForAccount() to calculate transactionFee by only transfers that are paid by the specify accountId ‑ SdkClient HBAR Limiter Should execute getTransferAmountSumForAccount() to calculate transactionFee by only transfers that are paid by the specify accountId
Should execute validateJsonRpcRequest() to validate JSON RPC request that has no id field but return true because REQUEST_ID_IS_OPTIONAL=true ‑ validations unit test given REQUEST_ID_IS_OPTIONAL=true are set Should execute validateJsonRpcRequest() to validate JSON RPC request that has no id field but return true because REQUEST_ID_IS_OPTIONAL=true
Should execute validateJsonRpcRequest() to validate invalid JSON RPC requests and return false ‑ validations unit test Should execute validateJsonRpcRequest() to validate invalid JSON RPC requests and return false
Should execute validateJsonRpcRequest() to validate valid JSON RPC request and return true ‑ validations unit test Should execute validateJsonRpcRequest() to validate valid JSON RPC request and return true
Should execute verifySupportedMethod() to validate requests' methods and return false if methods are not supported ‑ validations unit test Should execute verifySupportedMethod() to validate requests' methods and return false if methods are not supported
Should execute verifySupportedMethod() to validate requests' methods and return true if methods are supported ‑ validations unit test Should execute verifySupportedMethod() to validate requests' methods and return true if methods are supported
Should format request ID message ‑ Formatters formatRequestIdMessage Should format request ID message
Should ignore all the unexpected params and return a new filter object with valid params (address, topics) ‑ Utilities unit tests constructValidLogSubscriptionFilter tests Should ignore all the unexpected params and return a new filter object with valid params (address, topics)
Should listen to EXECUTE_TRANSACTION event to kick off captureTransactionMetrics() ‑ Metric Service captureTransactionMetrics given GET_RECORD_DEFAULT_TO_CONSENSUS_NODE=true are set Should listen to EXECUTE_TRANSACTION event to kick off captureTransactionMetrics()
Should not include chainId field for legacy EIP155 transaction (tx.chainId=0x0) ‑ Formatters formatContractResult Should not include chainId field for legacy EIP155 transaction (tx.chainId=0x0)
Should only add valid params if presented in original filter object ‑ Utilities unit tests constructValidLogSubscriptionFilter tests Should only add valid params if presented in original filter object
Should recognize if a signed raw transaction is NOT the deterministic deployment transaction ‑ Precheck gas price Should recognize if a signed raw transaction is NOT the deterministic deployment transaction
Should return an empty string if undefined is passed in ‑ Formatters formatRequestIdMessage Should return an empty string if undefined is passed in
Should return empty log if address = ZeroAddress ‑ @ethGetLogs using MirrorNode Should return empty log if address = ZeroAddress
Should return evm address if contract has one ‑ @ethGetLogs using MirrorNode Should return evm address if contract has one
Should return formated request ID if already formatted request ID is passed in ‑ Formatters formatRequestIdMessage Should return formated request ID if already formatted request ID is passed in
Should return legacy EIP155 transaction when null type ‑ Formatters formatContractResult Should return legacy EIP155 transaction when null type
Should return null when contract result type is undefined ‑ Formatters formatContractResult Should return null when contract result type is undefined
Subscribing to the same event and filters should return different subscription id ‑ subscriptionController With WS_SAME_SUB_FOR_SAME_EVENT == `false` Subscribing to the same event and filters should return different subscription id
Subscribing to the same event and filters should return the same subscription id ‑ subscriptionController Subscribing to the same event and filters should return the same subscription id
Test call tracer with onlyTopCall false ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set callTracer Test call tracer with onlyTopCall false
Test call tracer with onlyTopCall true ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set callTracer Test call tracer with onlyTopCall true
Then 'memory' should be empty ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set opcodeLogger When opcode logger is called with enableMemory=false, disableStack=false, disableStorage=false Then 'memory' should be empty
Then 'stack' should be empty ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set opcodeLogger When opcode logger is called with disableStack=true Then 'stack' should be empty
Then 'stack,storage' should be empty ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set opcodeLogger When opcode logger is called with enableMemory=true, disableStack=true, disableStorage=true Then 'stack,storage' should be empty
Then 'storage' should be empty ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set opcodeLogger When opcode logger is called with disableStorage=true Then 'storage' should be empty
Then all should be returned ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set opcodeLogger When opcode logger is called with enableMemory=true Then all should be returned
Unsubscribing all subscriptions from same connection ‑ subscriptionController Unsubscribing all subscriptions from same connection
Unsubscribing single subscriptions from connection ‑ subscriptionController Unsubscribing single subscriptions from connection
Unsubscribing without a valid subscription or ws conn should return true ‑ subscriptionController Unsubscribing without a valid subscription or ws conn should return true
`getAccount` not found ‑ MirrorNodeClient `getAccount` not found
`getAccount` works ‑ MirrorNodeClient `getAccount` works
`getAccount` ‑ MirrorNodeClient `getAccount`
`getBlock by hash` works ‑ MirrorNodeClient `getBlock by hash` works
`getBlock by number` works ‑ MirrorNodeClient `getBlock by number` works
`getBlocks` by number ‑ MirrorNodeClient `getBlocks` by number
`getBlocks` by timestamp ‑ MirrorNodeClient `getBlocks` by timestamp
`getBlocks` should hit the cache ‑ MirrorNodeClient `getBlocks` should hit the cache
`getContractCurrentStateByAddressAndSlot` - incorrect address ‑ MirrorNodeClient `getContractCurrentStateByAddressAndSlot` - incorrect address
`getContractCurrentStateByAddressAndSlot` - incorrect slot ‑ MirrorNodeClient `getContractCurrentStateByAddressAndSlot` - incorrect slot
`getContractCurrentStateByAddressAndSlot` ‑ MirrorNodeClient `getContractCurrentStateByAddressAndSlot`
`getContractResultsLogsByAddress`  ‑ MirrorNodeClient `getContractResultsLogsByAddress` 
`getContractResultsLogsByAddress` - incorrect address ‑ MirrorNodeClient `getContractResultsLogsByAddress` - incorrect address
`getContractResultsLogsByAddress` with ZeroAddress  ‑ MirrorNodeClient `getContractResultsLogsByAddress` with ZeroAddress 
`getContractResultsLogs`  ‑ MirrorNodeClient `getContractResultsLogs` 
`getContractResultsWithRetry` by hash retries once because of block_hash equals 0x ‑ MirrorNodeClient `getContractResultsWithRetry` by hash retries once because of block_hash equals 0x
`getContractResultsWithRetry` by hash retries once because of missing block_number ‑ MirrorNodeClient `getContractResultsWithRetry` by hash retries once because of missing block_number
`getContractResultsWithRetry` by hash retries once because of missing transaction_index and block_number ‑ MirrorNodeClient `getContractResultsWithRetry` by hash retries once because of missing transaction_index and block_number
`getContractResultsWithRetry` by hash retries once because of missing transaction_index ‑ MirrorNodeClient `getContractResultsWithRetry` by hash retries once because of missing transaction_index
`getContractResultsWithRetry` by hash retries once because of missing transaction_index, block_number and block_hash equals 0x ‑ MirrorNodeClient `getContractResultsWithRetry` by hash retries once because of missing transaction_index, block_number and block_hash equals 0x
`getContractResultsWithRetry` by hash ‑ MirrorNodeClient `getContractResultsWithRetry` by hash
`getContractResults` by address ‑ MirrorNodeClient `getContractResults` by address
`getContractResults` by hash using cache ‑ MirrorNodeClient `getContractResults` by hash using cache
`getContractResults` by hash ‑ MirrorNodeClient `getContractResults` by hash
`getContractResults` by id ‑ MirrorNodeClient `getContractResults` by id
`getContractResults` by transactionId ‑ MirrorNodeClient `getContractResults` by transactionId
`getContractResults` detailed ‑ MirrorNodeClient `getContractResults` detailed
`getContract` not found ‑ MirrorNodeClient `getContract` not found
`getContract` ‑ MirrorNodeClient `getContract`
`getLatestContractResultsByAddress` by address no timestamp ‑ MirrorNodeClient `getLatestContractResultsByAddress` by address no timestamp
`getLatestContractResultsByAddress` by address with timestamp, limit 2 ‑ MirrorNodeClient `getLatestContractResultsByAddress` by address with timestamp, limit 2
`getNetworkExchangeRate` ‑ MirrorNodeClient `getNetworkExchangeRate`
`getQueryParams` contract result related ‑ MirrorNodeClient `getQueryParams` contract result related
`getQueryParams` general ‑ MirrorNodeClient `getQueryParams` general
`getQueryParams` logs related ‑ MirrorNodeClient `getQueryParams` logs related
`getTokenById` not found ‑ MirrorNodeClient `getTokenById` not found
`getTokenById` ‑ MirrorNodeClient `getTokenById`
`get` works ‑ MirrorNodeClient `get` works
`post` works ‑ MirrorNodeClient `post` works
`restUrl` is exposed and correct ‑ MirrorNodeClient `restUrl` is exposed and correct
account should be cached ‑ @ethGetTransactionByHash eth_getTransactionByHash tests account should be cached
address filter timeouts and throws the expected error ‑ @ethGetLogs using MirrorNode timeout address filter timeouts and throws the expected error
address filter ‑ @ethGetLogs using MirrorNode address filter
adds amount to amountSpent ‑ HbarSpendingPlanRepository with shared cache addToAmountSpent adds amount to amountSpent
adds amount to amountSpent ‑ HbarSpendingPlanRepository without shared cache addToAmountSpent adds amount to amountSpent
adds amount to spending history ‑ HbarSpendingPlanRepository with shared cache addAmountToSpendingHistory adds amount to spending history
adds amount to spending history ‑ HbarSpendingPlanRepository without shared cache addAmountToSpendingHistory adds amount to spending history
adds multiple amounts to spending history ‑ HbarSpendingPlanRepository with shared cache addAmountToSpendingHistory adds multiple amounts to spending history
adds multiple amounts to spending history ‑ HbarSpendingPlanRepository without shared cache addAmountToSpendingHistory adds multiple amounts to spending history
batch request be disabled by default ‑ RPC Server batchRequest Test Cases given BATCH_REQUESTS_ENABLED=undefined are set batch request be disabled by default
blockNumber is in the latest 15 minutes and the block.timstamp.to is later than the consensus transactions timestamps ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes and the block.timstamp.to is later than the consensus transactions timestamps
blockNumber is in the latest 15 minutes and there have been mixed credit and debit transactions and a next pagination with a timestamp less than the block.timestamp.to ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes and there have been mixed credit and debit transactions and a next pagination with a timestamp less than the block.timestamp.to
blockNumber is in the latest 15 minutes and there have been mixed credit and debit transactions with consensus.timestamps greater the block.timestamp.to ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes and there have been mixed credit and debit transactions with consensus.timestamps greater the block.timestamp.to
blockNumber is in the latest 15 minutes and there have been several credit transactions with consensus.timestamps greater the block.timestamp.to ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes and there have been several credit transactions with consensus.timestamps greater the block.timestamp.to
blockNumber is in the latest 15 minutes and there have been several debit transactions with consensus.timestamps greater the block.timestamp.to ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes and there have been several debit transactions with consensus.timestamps greater the block.timestamp.to
blockNumber is in the latest 15 minutes with credit and debit transactions and a next pagination with a timestamp greater than the block.timestamp.to ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes with credit and debit transactions and a next pagination with a timestamp greater than the block.timestamp.to
blockNumber is in the latest 15 minutes with debit transactions and a next pagination with a timestamp greater than the block.timestamp.to ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes with debit transactions and a next pagination with a timestamp greater than the block.timestamp.to
blockNumber is in the latest 15 minutes, mirror node balance for address not found 404 status ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is in the latest 15 minutes, mirror node balance for address not found 404 status
blockNumber is not in the latest 15 minutes ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is not in the latest 15 minutes
blockNumber is not in the latest 15 minutes, mirror node balance for address not found 404 status ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is not in the latest 15 minutes, mirror node balance for address not found 404 status
blockNumber is the same as the latest block ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter blockNumber is the same as the latest block
call to non-existing REST route returns 404 ‑ MirrorNodeClient call to non-existing REST route returns 404
calls mirror node tokens API when token is long zero type ‑ MirrorNodeClient resolveEntityType calls mirror node tokens API when token is long zero type
creates a plan successfully ‑ HbarSpendingPlanRepository with shared cache create creates a plan successfully
creates a plan successfully ‑ HbarSpendingPlanRepository without shared cache create creates a plan successfully
delete a valid object ‑ LocalLRUCache Test Suite verify simple cache delete a valid object
deletes all address plans by plan ID ‑ EvmAddressHbarSpendingPlanRepository with shared cache deleteAllByPlanId deletes all address plans by plan ID
deletes all address plans by plan ID ‑ EvmAddressHbarSpendingPlanRepository without shared cache deleteAllByPlanId deletes all address plans by plan ID
deletes all address plans by plan ID ‑ IPAddressHbarSpendingPlanRepository with shared cache deleteAllByPlanId deletes all address plans by plan ID
deletes all address plans by plan ID ‑ IPAddressHbarSpendingPlanRepository without shared cache deleteAllByPlanId deletes all address plans by plan ID
deletes an address plan successfully ‑ EvmAddressHbarSpendingPlanRepository with shared cache delete deletes an address plan successfully
deletes an address plan successfully ‑ EvmAddressHbarSpendingPlanRepository without shared cache delete deletes an address plan successfully
deletes an address plan successfully ‑ IPAddressHbarSpendingPlanRepository with shared cache delete deletes an address plan successfully
deletes an address plan successfully ‑ IPAddressHbarSpendingPlanRepository without shared cache delete deletes an address plan successfully
deletes unknown properties of Transaction Object param ‑ Validator Other error cases deletes unknown properties of Transaction Object param
does NOT throw an error if Transaction Object param contains unexpected param ‑ Validator Other error cases does NOT throw an error if Transaction Object param contains unexpected param
does not call mirror node tokens API when token is not long zero type ‑ MirrorNodeClient resolveEntityType does not call mirror node tokens API when token is not long zero type
does not return inactive plans for the subscription tier ‑ HbarSpendingPlanRepository with shared cache findAllActiveBysubscriptionTier does not return inactive plans for the subscription tier
does not return inactive plans for the subscription tier ‑ HbarSpendingPlanRepository without shared cache findAllActiveBysubscriptionTier does not return inactive plans for the subscription tier
does not throw an error for correct values ‑ Validator validates Filter Object type correctly does not throw an error for correct values
does not throw an error for input: "callTracer" ‑ Validator validates tracerType correctly does not throw an error for input: "callTracer"
does not throw an error for input: "opcodeLogger" ‑ Validator validates tracerType correctly does not throw an error for input: "opcodeLogger"
does not throw an error for input: {"disableStack":false} ‑ Validator validates opcodeLoggerConfig correctly does not throw an error for input: {"disableStack":false}
does not throw an error for input: {"disableStack":false} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"disableStack":false}
does not throw an error for input: {"disableStorage":true} ‑ Validator validates opcodeLoggerConfig correctly does not throw an error for input: {"disableStorage":true}
does not throw an error for input: {"disableStorage":true} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"disableStorage":true}
does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true,"unknownParam":true} ‑ Validator validates opcodeLoggerConfig correctly does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true,"unknownParam":true}
does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true,"unknownParam":true} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true,"unknownParam":true}
does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true} ‑ Validator validates opcodeLoggerConfig correctly does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true}
does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"enableMemory":true,"disableStack":false,"disableStorage":true}
does not throw an error for input: {"enableMemory":true} ‑ Validator validates opcodeLoggerConfig correctly does not throw an error for input: {"enableMemory":true}
does not throw an error for input: {"enableMemory":true} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"enableMemory":true}
does not throw an error for input: {"onlyTopCall":true,"unknownParam":true} ‑ Validator validates callTracerConfig correctly does not throw an error for input: {"onlyTopCall":true,"unknownParam":true}
does not throw an error for input: {"onlyTopCall":true,"unknownParam":true} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"onlyTopCall":true,"unknownParam":true}
does not throw an error for input: {"onlyTopCall":true} ‑ Validator validates callTracerConfig correctly does not throw an error for input: {"onlyTopCall":true}
does not throw an error for input: {"onlyTopCall":true} ‑ Validator validates tracerConfig correctly does not throw an error for input: {"onlyTopCall":true}
does not throw an error for input: {"tracer":"callTracer","tracerConfig":{"onlyTopCall":true},"unknownParam":true} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"callTracer","tracerConfig":{"onlyTopCall":true},"unknownParam":true}
does not throw an error for input: {"tracer":"callTracer","tracerConfig":{"onlyTopCall":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"callTracer","tracerConfig":{"onlyTopCall":true}}
does not throw an error for input: {"tracer":"callTracer","tracerConfig":{}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"callTracer","tracerConfig":{}}
does not throw an error for input: {"tracer":"callTracer"} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"callTracer"}
does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStack":false}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStack":false}}
does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStorage":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStorage":true}}
does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":true,"disableStack":false,"disableStorage":true,"unknownParam":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":true,"disableStack":false,"disableStorage":true,"unknownParam":true}}
does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":true,"disableStack":false,"disableStorage":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":true,"disableStack":false,"disableStorage":true}}
does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":true}}
does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger","tracerConfig":{}}
does not throw an error for input: {"tracer":"opcodeLogger"} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracer":"opcodeLogger"}
does not throw an error for input: {"tracerConfig":{"enableMemory":true,"disableStack":false,"disableStorage":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracerConfig":{"enableMemory":true,"disableStack":false,"disableStorage":true}}
does not throw an error for input: {"tracerConfig":{"onlyTopCall":true}} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {"tracerConfig":{"onlyTopCall":true}}
does not throw an error for input: {} ‑ Validator validates callTracerConfig correctly does not throw an error for input: {}
does not throw an error for input: {} ‑ Validator validates opcodeLoggerConfig correctly does not throw an error for input: {}
does not throw an error for input: {} ‑ Validator validates tracerConfig correctly does not throw an error for input: {}
does not throw an error for input: {} ‑ Validator validates tracerConfigWrapper correctly does not throw an error for input: {}
does not throw an error if 'address' is valid and topics is missing ‑ Validator validates ethSubscribeLogsParams Object type correctly does not throw an error if 'address' is valid and topics is missing
does not throw an error if 'address' is valid and topics is undefined ‑ Validator validates ethSubscribeLogsParams Object type correctly does not throw an error if 'address' is valid and topics is undefined
does not throw an error if 'address' is valid array and topics is missing ‑ Validator validates ethSubscribeLogsParams Object type correctly does not throw an error if 'address' is valid array and topics is missing
does not throw an error if 'address' is valid array and topics is valid array ‑ Validator validates ethSubscribeLogsParams Object type correctly does not throw an error if 'address' is valid array and topics is valid array
does not throw an error if 'topics' value is empty array ‑ Validator validates ethSubscribeLogsParams Object type correctly does not throw an error if 'topics' value is empty array
does not throw an error if 'topics' values are 0x prefixed and 32 bytes ‑ Validator validates ethSubscribeLogsParams Object type correctly does not throw an error if 'topics' values are 0x prefixed and 32 bytes
does not throw an error if address is long-zero address ‑ Validator validates Address type correctly does not throw an error if address is long-zero address
does not throw an error if address is valid ‑ Validator validates Address type correctly does not throw an error if address is valid
does not throw an error if address plan to delete does not exist ‑ EvmAddressHbarSpendingPlanRepository with shared cache delete does not throw an error if address plan to delete does not exist
does not throw an error if address plan to delete does not exist ‑ EvmAddressHbarSpendingPlanRepository without shared cache delete does not throw an error if address plan to delete does not exist
does not throw an error if address plan to delete does not exist ‑ IPAddressHbarSpendingPlanRepository with shared cache delete does not throw an error if address plan to delete does not exist
does not throw an error if address plan to delete does not exist ‑ IPAddressHbarSpendingPlanRepository without shared cache delete does not throw an error if address plan to delete does not exist
does not throw an error if block hash is valid ‑ Validator validates blockHash type correctly does not throw an error if block hash is valid
does not throw an error if no address plans are found for the plan ID ‑ EvmAddressHbarSpendingPlanRepository with shared cache deleteAllByPlanId does not throw an error if no address plans are found for the plan ID
does not throw an error if no address plans are found for the plan ID ‑ EvmAddressHbarSpendingPlanRepository without shared cache deleteAllByPlanId does not throw an error if no address plans are found for the plan ID
does not throw an error if no address plans are found for the plan ID ‑ IPAddressHbarSpendingPlanRepository with shared cache deleteAllByPlanId does not throw an error if no address plans are found for the plan ID
does not throw an error if no address plans are found for the plan ID ‑ IPAddressHbarSpendingPlanRepository without shared cache deleteAllByPlanId does not throw an error if no address plans are found for the plan ID
does not throw an error if no amountSpent keys exist ‑ HbarSpendingPlanRepository with shared cache resetAllAmountSpentEntries does not throw an error if no amountSpent keys exist
does not throw an error if no amountSpent keys exist ‑ HbarSpendingPlanRepository without shared cache resetAllAmountSpentEntries does not throw an error if no amountSpent keys exist
does not throw an error if param is array ‑ Validator validates Array type correctly does not throw an error if param is array
does not throw an error if topic hash is valid ‑ Validator validates topicHash type correctly does not throw an error if topic hash is valid
does not throw an error if topics param is null ‑ Validator validates topics type correctly does not throw an error if topics param is null
does not throw an error if topics param is valid ‑ Validator validates topics type correctly does not throw an error if topics param is valid
does not throw an error if transactionHash is valid ‑ Validator validates transactionHash type correctly does not throw an error if transactionHash is valid
does not throw error when block number is valid hex ‑ Validator validates blockNumber type correctly does not throw error when block number is valid hex
does not throw error when block number is valid tag ‑ Validator validates blockNumber type correctly does not throw error when block number is valid tag
earliest ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter earliest
error when retrieving logs ‑ @ethGetLogs using MirrorNode error when retrieving logs
eth_call should cache the response for 200ms ‑ @ethCall Eth Call spec eth_call using consensus node eth_call should cache the response for 200ms
eth_call throws internal error when consensus node times out and submitContractCallQueryWithRetry returns undefined ‑ @ethCall Eth Call spec eth_call using consensus node eth_call throws internal error when consensus node times out and submitContractCallQueryWithRetry returns undefined
eth_call to simulate deploying a smart contract with `to` field being empty/undefined ‑ @ethCall Eth Call spec eth_call using mirror node eth_call to simulate deploying a smart contract with `to` field being empty/undefined
eth_call to simulate deploying a smart contract with `to` field being null ‑ @ethCall Eth Call spec eth_call using mirror node eth_call to simulate deploying a smart contract with `to` field being null
eth_call with a bad "from" address ‑ @ethCall Eth Call spec eth_call using consensus node eth_call with a bad "from" address
eth_call with all fields and value ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields and value
eth_call with all fields but mirrorNode throws 400 due to non-existent `to` address (FAIL_INVALID) ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields but mirrorNode throws 400 due to non-existent `to` address (FAIL_INVALID)
eth_call with all fields but mirrorNode throws 400 due to non-existent `to` address (INVALID_TRANSACTION) ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields but mirrorNode throws 400 due to non-existent `to` address (INVALID_TRANSACTION)
eth_call with all fields but mirrorNode throws 400 ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields but mirrorNode throws 400
eth_call with all fields but mirrorNode throws 429 ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields but mirrorNode throws 429
eth_call with all fields ‑ @ethCall Eth Call spec eth_call using consensus node eth_call with all fields
eth_call with all fields ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields
eth_call with all fields, but mirror node throws CONTRACT_REVERTED ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields, but mirror node throws CONTRACT_REVERTED
eth_call with all fields, but mirror node throws NOT_SUPPORTED ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields, but mirror node throws NOT_SUPPORTED
eth_call with all fields, but mirror-node returns empty response ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with all fields, but mirror-node returns empty response
eth_call with gas capping ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with gas capping
eth_call with incorrect `to` field length ‑ @ethCall Eth Call spec eth_call precheck failures eth_call with incorrect `to` field length
eth_call with matched selector redirects to consensus ‑ @ethCall Eth Call spec eth_call using consensus node because of redirect by selector eth_call with matched selector redirects to consensus
eth_call with no "from" address ‑ @ethCall Eth Call spec eth_call using consensus node eth_call with no "from" address
eth_call with no data ‑ @ethCall Eth Call spec eth_call using consensus node eth_call with no data
eth_call with no data ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with no data
eth_call with no from address ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with no from address
eth_call with no gas ‑ @ethCall Eth Call spec eth_call using consensus node eth_call with no gas
eth_call with no gas ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with no gas
eth_call with non-matched selector redirects to consensus ‑ @ethCall Eth Call spec eth_call using consensus node because of redirect by selector eth_call with non-matched selector redirects to consensus
eth_call with wrong `to` field ‑ @ethCall Eth Call spec eth_call using consensus node eth_call with wrong `to` field
eth_call with wrong `to` field ‑ @ethCall Eth Call spec eth_call using mirror node eth_call with wrong `to` field
eth_feeHistory 5 blocks with custom newest with fixed fees ‑ @ethFeeHistory using MirrorNode eth_feeHistory using fixed fees eth_feeHistory 5 blocks with custom newest with fixed fees
eth_feeHistory 5 blocks with latest with fixed fees ‑ @ethFeeHistory using MirrorNode eth_feeHistory using fixed fees eth_feeHistory 5 blocks with latest with fixed fees
eth_feeHistory on mirror 404 ‑ @ethFeeHistory using MirrorNode eth_feeHistory -> Mirror node returns error eth_feeHistory on mirror 404
eth_feeHistory on mirror 500 ‑ @ethFeeHistory using MirrorNode eth_feeHistory -> Mirror node returns error eth_feeHistory on mirror 500
eth_feeHistory verify cached value ‑ @ethFeeHistory using MirrorNode eth_feeHistory verify cached value
eth_feeHistory with earliest param ‑ @ethFeeHistory using MirrorNode eth_feeHistory using fixed fees eth_feeHistory with earliest param
eth_feeHistory with earliest param ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory with earliest param
eth_feeHistory with finalized param ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory with finalized param
eth_feeHistory with fixed fees using cache ‑ @ethFeeHistory using MirrorNode eth_feeHistory using fixed fees eth_feeHistory with fixed fees using cache
eth_feeHistory with fixed fees ‑ @ethFeeHistory using MirrorNode eth_feeHistory using fixed fees eth_feeHistory with fixed fees
eth_feeHistory with latest param ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory with latest param
eth_feeHistory with max results ‑ @ethFeeHistory using MirrorNode eth_feeHistory with max results
eth_feeHistory with number param ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory with number param
eth_feeHistory with pending param ‑ @ethFeeHistory using MirrorNode eth_feeHistory using fixed fees eth_feeHistory with pending param
eth_feeHistory with pending param ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory with pending param
eth_feeHistory with safe param ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory with safe param
eth_feeHistory ‑ @ethFeeHistory using MirrorNode eth_feeHistory with ... param eth_feeHistory
eth_gasPrice with cached value ‑ @ethGasPrice Gas Price spec @ethGasPrice eth_gasPrice with cached value
eth_gasPrice with mirror node return network fees found ‑ @ethGasPrice Gas Price spec @ethGasPrice eth_gasPrice not found eth_gasPrice with mirror node return network fees found
eth_gasPrice with no EthereumTransaction gas returned ‑ @ethGasPrice Gas Price spec @ethGasPrice eth_gasPrice with no EthereumTransaction gas returned
eth_gasPrice with no network fees records found ‑ @ethGasPrice Gas Price spec @ethGasPrice eth_gasPrice not found eth_gasPrice with no network fees records found
eth_gasPrice ‑ @ethGasPrice Gas Price spec @ethGasPrice eth_gasPrice
eth_getBlockByHash should hit cache ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash should hit cache
eth_getBlockByHash should skip wrong nonce transactions when showDetails = false ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash should skip wrong nonce transactions when showDetails = false
eth_getBlockByHash should skip wrong nonce transactions when showDetails = true ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash should skip wrong nonce transactions when showDetails = true
eth_getBlockByHash should throw if unexpected error ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash should throw if unexpected error
eth_getBlockByHash with block match and contract revert ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with block match and contract revert
eth_getBlockByHash with greater number of transactions than the ETH_GET_TRANSACTION_COUNT_MAX_BLOCK_RANGE ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with greater number of transactions than the ETH_GET_TRANSACTION_COUNT_MAX_BLOCK_RANGE
eth_getBlockByHash with match and details paginated ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with match and details paginated
eth_getBlockByHash with match and details ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with match and details
eth_getBlockByHash with match and duplicated transactions ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with match and duplicated transactions
eth_getBlockByHash with match and valid logsBloom field ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with match and valid logsBloom field
eth_getBlockByHash with match paginated ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with match paginated
eth_getBlockByHash with match paginated ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByHash with match paginated
eth_getBlockByHash with match ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with match
eth_getBlockByHash with match ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByHash with match
eth_getBlockByHash with no match ‑ @ethGetBlockByHash using MirrorNode eth_getBlockByHash with no match
eth_getBlockByNumber should return cached result ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByNumber should return cached result
eth_getBlockByNumber should skip INVALID_ACCOUNT_ID transactions when showDetails = false ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber should skip INVALID_ACCOUNT_ID transactions when showDetails = false
eth_getBlockByNumber should skip INVALID_ACCOUNT_ID transactions when showDetails = true ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber should skip INVALID_ACCOUNT_ID transactions when showDetails = true
eth_getBlockByNumber should skip WRONG_NONCE transactions when showDetails = false ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber should skip WRONG_NONCE transactions when showDetails = false
eth_getBlockByNumber should skip WRONG_NONCE transactions when showDetails = true ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber should skip WRONG_NONCE transactions when showDetails = true
eth_getBlockByNumber with block match and contract revert ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with block match and contract revert
eth_getBlockByNumber with earliest tag ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with earliest tag
eth_getBlockByNumber with finalized tag ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with finalized tag
eth_getBlockByNumber with greater number of transactions than the ETH_GET_TRANSACTION_COUNT_MAX_BLOCK_RANGE ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with greater number of transactions than the ETH_GET_TRANSACTION_COUNT_MAX_BLOCK_RANGE
eth_getBlockByNumber with hex number tag ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with hex number tag
eth_getBlockByNumber with latest tag paginated ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with latest tag paginated
eth_getBlockByNumber with latest tag ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with latest tag
eth_getBlockByNumber with match and details and sythetic transactions ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with match and details and sythetic transactions
eth_getBlockByNumber with match and details paginated ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with match and details paginated
eth_getBlockByNumber with match and details ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with match and details
eth_getBlockByNumber with match and duplicated transactions ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByNumber with match and duplicated transactions
eth_getBlockByNumber with match and valid logsBloom field ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByNumber with match and valid logsBloom field
eth_getBlockByNumber with match paginated ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByNumber with match paginated
eth_getBlockByNumber with match ‑ @ethGetBlockByNumber using MirrorNode with match eth_getBlockByNumber with match
eth_getBlockByNumber with no match ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with no match
eth_getBlockByNumber with pending tag ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with pending tag
eth_getBlockByNumber with safe tag ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with tag eth_getBlockByNumber with safe tag
eth_getBlockByNumber with zero transactions ‑ @ethGetBlockByNumber using MirrorNode eth_getBlockByNumber with zero transactions
eth_getBlockTransactionCountByHash with match should hit cache ‑ @ethGetBlockTransactionCountByHash using MirrorNode eth_getBlockTransactionCountByHash with match should hit cache
eth_getBlockTransactionCountByHash with match ‑ @ethGetBlockTransactionCountByHash using MirrorNode eth_getBlockTransactionCountByHash with match
eth_getBlockTransactionCountByHash with no match ‑ @ethGetBlockTransactionCountByHash using MirrorNode eth_getBlockTransactionCountByHash with no match
eth_getBlockTransactionCountByNumber with earliest tag ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with earliest tag
eth_getBlockTransactionCountByNumber with finalized tag ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with finalized tag
eth_getBlockTransactionCountByNumber with hex number ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with hex number
eth_getBlockTransactionCountByNumber with latest tag ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with latest tag
eth_getBlockTransactionCountByNumber with match should hit cache ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with match should hit cache
eth_getBlockTransactionCountByNumber with match ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with match
eth_getBlockTransactionCountByNumber with no match ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with no match
eth_getBlockTransactionCountByNumber with pending tag ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with pending tag
eth_getBlockTransactionCountByNumber with safe tag ‑ @ethGetBlockTransactionCountByNumber using MirrorNode eth_getBlockTransactionCountByNumber with safe tag
eth_getStorageAt should return EthImpl.zeroHex32Byte when slot wrong ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt should return EthImpl.zeroHex32Byte when slot wrong
eth_getStorageAt should return Zero Hash when address is not found ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt should return Zero Hash when address is not found
eth_getStorageAt should return old state when passing older block number ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt should return old state when passing older block number
eth_getStorageAt should throw a predefined RESOURCE_NOT_FOUND when block not found ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt should throw a predefined RESOURCE_NOT_FOUND when block not found
eth_getStorageAt with match null block ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match null block
eth_getStorageAt with match with block and slot less than 32 bytes and leading zeroes ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with block and slot less than 32 bytes and leading zeroes
eth_getStorageAt with match with block and slot less than 32 bytes and without leading zeroes ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with block and slot less than 32 bytes and without leading zeroes
eth_getStorageAt with match with block hash ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with block hash
eth_getStorageAt with match with block ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with block
eth_getStorageAt with match with finalized block ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with finalized block
eth_getStorageAt with match with latest block ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with latest block
eth_getStorageAt with match with safe block ‑ @ethGetStorageAt eth_getStorageAt spec eth_getStorageAt eth_getStorageAt with match with safe block
eth_getTransactionByBlockHashAndIndex returns 155 transaction for type 0 ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex returns 155 transaction for type 0
eth_getTransactionByBlockHashAndIndex returns 1559 transaction for type 2 ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex returns 1559 transaction for type 2
eth_getTransactionByBlockHashAndIndex returns 2930 transaction for type 1 ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex returns 2930 transaction for type 1
eth_getTransactionByBlockHashAndIndex should throw for internal error ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex should throw for internal error
eth_getTransactionByBlockHashAndIndex with match ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex with match
eth_getTransactionByBlockHashAndIndex with no contract result match ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex with no contract result match
eth_getTransactionByBlockHashAndIndex with no contract results ‑ @ethGetTransactionByBlockHashAndIndex using MirrorNode eth_getTransactionByBlockHashAndIndex with no contract results
eth_getTransactionByBlockNumberAndIndex should throw for internal error ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex should throw for internal error
eth_getTransactionByBlockNumberAndIndex with earliest tag ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with earliest tag
eth_getTransactionByBlockNumberAndIndex with finalized tag ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with finalized tag
eth_getTransactionByBlockNumberAndIndex with hex number ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with hex number
eth_getTransactionByBlockNumberAndIndex with latest tag ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with latest tag
eth_getTransactionByBlockNumberAndIndex with match pending tag ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with match pending tag
eth_getTransactionByBlockNumberAndIndex with match ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with match
eth_getTransactionByBlockNumberAndIndex with no contract result match ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with no contract result match
eth_getTransactionByBlockNumberAndIndex with no contract results ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with no contract results
eth_getTransactionByBlockNumberAndIndex with null amount ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with null amount
eth_getTransactionByBlockNumberAndIndex with safe tag ‑ @ethGetTransactionByBlockNumberAndIndex using MirrorNode eth_getTransactionByBlockNumberAndIndex with safe tag
executes the query ‑ SdkClient increaseCostAndRetryExecution executes the query
finalized ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter finalized
generateId should create a random hex ID, with 34 length ‑ subscriptionController generateId should create a random hex ID, with 34 length
generatedId should be unique ‑ subscriptionController generatedId should be unique
get on empty cache return null ‑ LocalLRUCache Test Suite verify simple cache get on empty cache return null
get on valid false boolean cache returns non null ‑ LocalLRUCache Test Suite verify simple cache get on valid false boolean cache returns non null
get on valid int cache returns non null ‑ LocalLRUCache Test Suite verify simple cache get on valid int cache returns non null
get on valid object cache returns non null ‑ LocalLRUCache Test Suite verify simple cache get on valid object cache returns non null
get on valid string cache returns non null ‑ LocalLRUCache Test Suite verify simple cache get on valid string cache returns non null
get on valid true boolean cache returns non null ‑ LocalLRUCache Test Suite verify simple cache get on valid true boolean cache returns non null
getAccount (400) validation error ‑ MirrorNodeClient getAccount (400) validation error
getAccount (500) Unexpected error ‑ MirrorNodeClient getAccount (500) Unexpected error
handles empty bloom ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests handles empty bloom
handles empty gas_used ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests handles empty gas_used
handles missing transaction index ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests handles missing transaction index
handles transactions with null amount ‑ @ethGetTransactionByHash eth_getTransactionByHash tests handles transactions with null amount
handles transactions with null gas_used ‑ @ethGetTransactionByHash eth_getTransactionByHash tests handles transactions with null gas_used
handles transactions with undefined block_number ‑ @ethGetTransactionByHash eth_getTransactionByHash tests handles transactions with undefined block_number
handles transactions with undefined transaction_index and block_number ‑ @ethGetTransactionByHash eth_getTransactionByHash tests handles transactions with undefined transaction_index and block_number
handles transactions with undefined transaction_index ‑ @ethGetTransactionByHash eth_getTransactionByHash tests handles transactions with undefined transaction_index
handles transactions with v as null ‑ @ethGetTransactionByHash eth_getTransactionByHash tests handles transactions with v as null
if the method returns an immediate result it is called only once ‑ MirrorNodeClient repeatedRequest if the method returns an immediate result it is called only once
increases the cost when INSUFFICIENT_TX_FEE is thrown on every repeat ‑ SdkClient increaseCostAndRetryExecution increases the cost when INSUFFICIENT_TX_FEE is thrown on every repeat
increases the cost when INSUFFICIENT_TX_FEE is thrown ‑ SdkClient increaseCostAndRetryExecution increases the cost when INSUFFICIENT_TX_FEE is thrown
is repeated at most 4 times ‑ SdkClient increaseCostAndRetryExecution is repeated at most 4 times

it should have a `request` method  ‑ MirrorNodeClient it should have a `request` method 
it should set without TTL if -1 is passed for TTL ‑ LocalLRUCache Test Suite verify cache management given CACHE_TTL=100 are set it should set without TTL if -1 is passed for TTL
it should set without TTL if -1 is passed for TTL ‑ RedisCache Test Suite Get and Set Test Suite it should set without TTL if -1 is passed for TTL
latest ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter latest
method is not repeated more times than the limit ‑ MirrorNodeClient repeatedRequest method is not repeated more times than the limit
method is repeated the specified number of times if no result is found ‑ MirrorNodeClient repeatedRequest method is repeated the specified number of times if no result is found
method is repeated until a result is found ‑ MirrorNodeClient repeatedRequest method is repeated until a result is found
multiple addresses filter ‑ @ethGetLogs using MirrorNode multiple addresses filter
no filters but undefined transaction_index ‑ @ethGetLogs using MirrorNode no filters but undefined transaction_index
no filters ‑ @ethGetLogs using MirrorNode no filters
no receipts ‑ ReceiptsRootUtils getRootHash no receipts
notifySubscribers should notify multiple subscribers with data ‑ subscriptionController notifySubscribers should notify multiple subscribers with data
notifySubscribers should notify subscribers with data ‑ subscriptionController notifySubscribers should notify subscribers with data
notifySubscribers should use cache to not send the data again ‑ subscriptionController notifySubscribers should use cache to not send the data again
notifySubscribers using a Tag that has no subscribers should not send anything to connection ‑ subscriptionController notifySubscribers using a Tag that has no subscribers should not send anything to connection
one transaction in block with three emitted events ‑ ReceiptsRootUtils getRootHash one transaction in block with three emitted events
one transaction in block without emitted events ‑ ReceiptsRootUtils getRootHash one transaction in block without emitted events
overwrites an existing address plan ‑ EvmAddressHbarSpendingPlanRepository with shared cache save overwrites an existing address plan
overwrites an existing address plan ‑ EvmAddressHbarSpendingPlanRepository without shared cache save overwrites an existing address plan
overwrites an existing address plan ‑ IPAddressHbarSpendingPlanRepository with shared cache save overwrites an existing address plan
overwrites an existing address plan ‑ IPAddressHbarSpendingPlanRepository without shared cache save overwrites an existing address plan
pending ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter pending
populateSyntheticTransactions with 1 transaction dupes in transactionHashes ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=false populateSyntheticTransactions with 1 transaction dupes in transactionHashes
populateSyntheticTransactions with 1 transaction dupes in txObjects ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=true populateSyntheticTransactions with 1 transaction dupes in txObjects
populateSyntheticTransactions with all dupes in transactionHashes ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=false populateSyntheticTransactions with all dupes in transactionHashes
populateSyntheticTransactions with all dupes in txObjects ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=true populateSyntheticTransactions with all dupes in txObjects
populateSyntheticTransactions with no dupes in empty transactionHashes ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=false populateSyntheticTransactions with no dupes in empty transactionHashes
populateSyntheticTransactions with no dupes in empty txObjects ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=true populateSyntheticTransactions with no dupes in empty txObjects
populateSyntheticTransactions with no dupes in non empty transactionHashes ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=false populateSyntheticTransactions with no dupes in non empty transactionHashes
populateSyntheticTransactions with no dupes in non empty txObjects ‑ eth_getBlockBy populateSyntheticTransactions w showDetails=true populateSyntheticTransactions with no dupes in non empty txObjects
purge stale entries from the cache ‑ LocalLRUCache Test Suite verify simple cache purge stale entries from the cache
resets all amountSpent entries ‑ HbarSpendingPlanRepository with shared cache resetAllAmountSpentEntries resets all amountSpent entries
resets all amountSpent entries ‑ HbarSpendingPlanRepository without shared cache resetAllAmountSpentEntries resets all amountSpent entries
retrieves all address plans by plan ID ‑ EvmAddressHbarSpendingPlanRepository with shared cache findAllByPlanId retrieves all address plans by plan ID
retrieves all address plans by plan ID ‑ EvmAddressHbarSpendingPlanRepository without shared cache findAllByPlanId retrieves all address plans by plan ID
retrieves all address plans by plan ID ‑ IPAddressHbarSpendingPlanRepository with shared cache findAllByPlanId retrieves all address plans by plan ID
retrieves all address plans by plan ID ‑ IPAddressHbarSpendingPlanRepository without shared cache findAllByPlanId retrieves all address plans by plan ID
retrieves amountSpent for a plan ‑ HbarSpendingPlanRepository with shared cache getAmountSpent retrieves amountSpent for a plan
retrieves amountSpent for a plan ‑ HbarSpendingPlanRepository without shared cache getAmountSpent retrieves amountSpent for a plan
retrieves an address plan by address ‑ EvmAddressHbarSpendingPlanRepository with shared cache findByAddress retrieves an address plan by address
retrieves an address plan by address ‑ EvmAddressHbarSpendingPlanRepository without shared cache findByAddress retrieves an address plan by address
retrieves an address plan by ip ‑ IPAddressHbarSpendingPlanRepository with shared cache findByAddress retrieves an address plan by ip
retrieves an address plan by ip ‑ IPAddressHbarSpendingPlanRepository without shared cache findByAddress retrieves an address plan by ip
retrieves spending history for a plan ‑ HbarSpendingPlanRepository with shared cache getSpendingHistory retrieves spending history for a plan
retrieves spending history for a plan ‑ HbarSpendingPlanRepository without shared cache getSpendingHistory retrieves spending history for a plan
returns 0 if amountSpent key does not exist ‑ HbarSpendingPlanRepository with shared cache getAmountSpent returns 0 if amountSpent key does not exist
returns 0 if amountSpent key does not exist ‑ HbarSpendingPlanRepository without shared cache getAmountSpent returns 0 if amountSpent key does not exist
returns 155 transaction for type 0 ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns 155 transaction for type 0
returns 1559 transaction for type 2 ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns 1559 transaction for type 2
returns 2930 transaction for type 1 ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns 2930 transaction for type 1
returns `account` when CONTRACTS and TOKENS endpoint returns 404 and ACCOUNTS endpoint returns a result ‑ MirrorNodeClient resolveEntityType returns `account` when CONTRACTS and TOKENS endpoint returns 404 and ACCOUNTS endpoint returns a result
returns `contract` when CONTRACTS endpoint returns a result ‑ MirrorNodeClient resolveEntityType returns `contract` when CONTRACTS endpoint returns a result
returns `null` for non-existent hash ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests returns `null` for non-existent hash
returns `null` for non-existing hash ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns `null` for non-existing hash
returns `token` when CONTRACTS and ACCOUNTS endpoints returns 404 and TOKEN endpoint returns a result ‑ MirrorNodeClient resolveEntityType returns `token` when CONTRACTS and ACCOUNTS endpoints returns 404 and TOKEN endpoint returns a result
returns a plan by ID ‑ HbarSpendingPlanRepository with shared cache findById returns a plan by ID
returns a plan by ID ‑ HbarSpendingPlanRepository with shared cache findByIdWithDetails returns a plan by ID
returns a plan by ID ‑ HbarSpendingPlanRepository without shared cache findById returns a plan by ID
returns a plan by ID ‑ HbarSpendingPlanRepository without shared cache findByIdWithDetails returns a plan by ID
returns all active plans for the subscription tier ‑ HbarSpendingPlanRepository with shared cache findAllActiveBysubscriptionTier returns all active plans for the subscription tier
returns all active plans for the subscription tier ‑ HbarSpendingPlanRepository without shared cache findAllActiveBysubscriptionTier returns all active plans for the subscription tier
returns an empty array if no active plans exist for the subscription tier ‑ HbarSpendingPlanRepository with shared cache findAllActiveBysubscriptionTier returns an empty array if no active plans exist for the subscription tier
returns an empty array if no active plans exist for the subscription tier ‑ HbarSpendingPlanRepository without shared cache findAllActiveBysubscriptionTier returns an empty array if no active plans exist for the subscription tier
returns an empty array if no address plans are found for the plan ID ‑ EvmAddressHbarSpendingPlanRepository with shared cache findAllByPlanId returns an empty array if no address plans are found for the plan ID
returns an empty array if no address plans are found for the plan ID ‑ EvmAddressHbarSpendingPlanRepository without shared cache findAllByPlanId returns an empty array if no address plans are found for the plan ID
returns an empty array if no address plans are found for the plan ID ‑ IPAddressHbarSpendingPlanRepository with shared cache findAllByPlanId returns an empty array if no address plans are found for the plan ID
returns an empty array if no address plans are found for the plan ID ‑ IPAddressHbarSpendingPlanRepository without shared cache findAllByPlanId returns an empty array if no address plans are found for the plan ID
returns an empty array if spending history is empty ‑ HbarSpendingPlanRepository with shared cache getSpendingHistory returns an empty array if spending history is empty
returns an empty array if spending history is empty ‑ HbarSpendingPlanRepository without shared cache getSpendingHistory returns an empty array if spending history is empty
returns correct transaction for existing hash w no sigs ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns correct transaction for existing hash w no sigs
returns correct transaction for existing hash ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns correct transaction for existing hash
returns false for an invalid config ‑ Validator validates tracerConfig type correctly returns false for an invalid config
returns false for non-object values ‑ Validator validates tracerConfig type correctly returns false for non-object values
returns false if address plan does not exist ‑ EvmAddressHbarSpendingPlanRepository with shared cache existsByAddress returns false if address plan does not exist
returns false if address plan does not exist ‑ EvmAddressHbarSpendingPlanRepository without shared cache existsByAddress returns false if address plan does not exist
returns false if address plan does not exist ‑ IPAddressHbarSpendingPlanRepository with shared cache existsByAddress returns false if address plan does not exist
returns false if address plan does not exist ‑ IPAddressHbarSpendingPlanRepository without shared cache existsByAddress returns false if address plan does not exist
returns false if transaction data is a valid 0x value and isnullable is false ‑ Validator validates isValidAndNonNullableParam returns false if transaction data is a valid 0x value and isnullable is false
returns false if transaction data is a valid 0x value and isnullable is true ‑ Validator validates isValidAndNonNullableParam returns false if transaction data is a valid 0x value and isnullable is true
returns false if transaction data is null and isnullable is false ‑ Validator validates isValidAndNonNullableParam returns false if transaction data is null and isnullable is false
returns false if transaction data is null and isnullable is true ‑ Validator validates isValidAndNonNullableParam returns false if transaction data is null and isnullable is true
returns false if transaction data is undefined and isnullable is false ‑ Validator validates isValidAndNonNullableParam returns false if transaction data is undefined and isnullable is false
returns false if transaction data is undefined and isnullable is true ‑ Validator validates isValidAndNonNullableParam returns false if transaction data is undefined and isnullable is true
returns null when 404 is returned ‑ MirrorNodeClient handleError returns null when 404 is returned
returns null when CONTRACTS and ACCOUNTS endpoints return 404 ‑ MirrorNodeClient resolveEntityType returns null when CONTRACTS and ACCOUNTS endpoints return 404
returns only active plans for the specified subscription tier ‑ HbarSpendingPlanRepository with shared cache findAllActiveBysubscriptionTier returns only active plans for the specified subscription tier
returns only active plans for the specified subscription tier ‑ HbarSpendingPlanRepository without shared cache findAllActiveBysubscriptionTier returns only active plans for the specified subscription tier
returns reverted transactions ‑ @ethGetTransactionByHash eth_getTransactionByHash tests returns reverted transactions
returns true for a valid call tracer config ‑ Validator validates tracerConfig type correctly returns true for a valid call tracer config
returns true for a valid opcode logger config ‑ Validator validates tracerConfig type correctly returns true for a valid opcode logger config
returns true for an empty object ‑ Validator validates tracerConfig type correctly returns true for an empty object
returns true if address plan exists ‑ EvmAddressHbarSpendingPlanRepository with shared cache existsByAddress returns true if address plan exists
returns true if address plan exists ‑ EvmAddressHbarSpendingPlanRepository without shared cache existsByAddress returns true if address plan exists
returns true if address plan exists ‑ IPAddressHbarSpendingPlanRepository with shared cache existsByAddress returns true if address plan exists
returns true if address plan exists ‑ IPAddressHbarSpendingPlanRepository without shared cache existsByAddress returns true if address plan exists
returns true when transaction data is null and is nullable is true ‑ Validator validates validateObject with transaction object returns true when transaction data is null and is nullable is true
safe ‑ @ethGetBalance using MirrorNode with blockNumberOrTag filter safe
saves an address plan successfully ‑ EvmAddressHbarSpendingPlanRepository with shared cache save saves an address plan successfully
saves an address plan successfully ‑ EvmAddressHbarSpendingPlanRepository without shared cache save saves an address plan successfully
saves an address plan successfully ‑ IPAddressHbarSpendingPlanRepository with shared cache save saves an address plan successfully
saves an address plan successfully ‑ IPAddressHbarSpendingPlanRepository without shared cache save saves an address plan successfully
should 0x0 ‑ Formatters weibarHexToTinyBarInt should 0x0
should accept London transactions ‑ Precheck transactionType should accept London transactions
should accept legacy transactions ‑ Precheck transactionType should accept legacy transactions
should accepts both input and data fields but copy value of input field to data field ‑ @ethCall Eth Call spec contractCallFormat should accepts both input and data fields but copy value of input field to data field
should accepts both input and data fields but copy value of input field to data field ‑ @ethEstimateGas Estimate Gas spec should accepts both input and data fields but copy value of input field to data field
should add a prefix if there is no one ‑ Formatters prepend0x should add a prefix if there is no one
should add the expense to the spending plan and update the remaining budget when both evmAddress and ipAddress are provided ‑ HBAR Rate Limit Service addExpense should add the expense to the spending plan and update the remaining budget when both evmAddress and ipAddress are provided
should add the expense to the spending plan and update the remaining budget when evmAddress is provided but ipAddress is not ‑ HBAR Rate Limit Service addExpense should add the expense to the spending plan and update the remaining budget when evmAddress is provided but ipAddress is not
should add the expense to the spending plan and update the remaining budget when ipAddress is provided but evmAddress is not ‑ HBAR Rate Limit Service addExpense should add the expense to the spending plan and update the remaining budget when ipAddress is provided but evmAddress is not
should allow topic to be null in nested topic arrays ‑ Validator validates topics type correctly should allow topic to be null in nested topic arrays
should apply no mapping if mapFn is not provided ‑ Formatters mapKeysAndValues should apply no mapping if mapFn is not provided
should apply no mapping if mapFn.key is not provided ‑ Formatters mapKeysAndValues should apply no mapping if mapFn.key is not provided
should apply no mapping if mapFn.value is not provided ‑ Formatters mapKeysAndValues should apply no mapping if mapFn.value is not provided
should be able to able to calculate transfer ‑ Precheck IntrinsicGasCost should be able to able to calculate transfer
should be able to accept null ‑ Formatters nullableNumberTo0x should be able to accept null
should be able to calculate contract call ‑ Precheck IntrinsicGasCost should be able to calculate contract call
should be able to calculate for odd length tx ‑ Precheck IntrinsicGasCost should be able to calculate for odd length tx
should be able to calculate normal contract create ‑ Precheck IntrinsicGasCost should be able to calculate normal contract create
should be able to calculate small contract create ‑ Precheck IntrinsicGasCost should be able to calculate small contract create
should be able to calucate tx without starting 0x ‑ Precheck IntrinsicGasCost should be able to calucate tx without starting 0x
should be able to clear from internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite should be able to clear from internal cache in case of Redis error
should be able to delete from internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite should be able to delete from internal cache in case of Redis error
should be able to delete from shared cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to delete from shared cache
should be able to fetch empty ethereum transactions for an account ‑ MirrorNodeClient getAccountLatestEthereumTransactionsByTimestamp should be able to fetch empty ethereum transactions for an account
should be able to fetch ethereum transactions for an account ‑ MirrorNodeClient getAccountLatestEthereumTransactionsByTimestamp should be able to fetch ethereum transactions for an account
should be able to fetch single ethereum transactions for an account ‑ MirrorNodeClient getAccountLatestEthereumTransactionsByTimestamp should be able to fetch single ethereum transactions for an account
should be able to fetch transaction by transaction id and nonce ‑ MirrorNodeClient getTransactionById should be able to fetch transaction by transaction id and nonce
should be able to fetch transaction by transaction id ‑ MirrorNodeClient getTransactionById should be able to fetch transaction by transaction id
should be able to generate emptyBloom if address is empty ‑ LogsBloomUtils buildLogsBloom should be able to generate emptyBloom if address is empty
should be able to generate emptyBloom if passed address is null ‑ LogsBloomUtils buildLogsBloom should be able to generate emptyBloom if passed address is null
should be able to generate emptyBloom if passed address is undefined ‑ LogsBloomUtils buildLogsBloom should be able to generate emptyBloom if passed address is undefined
should be able to generate emptyBloom if passed topics value is null ‑ LogsBloomUtils buildLogsBloom should be able to generate emptyBloom if passed topics value is null
should be able to generate emptyBloom if passed topics value is undefined ‑ LogsBloomUtils buildLogsBloom should be able to generate emptyBloom if passed topics value is undefined
should be able to generate emptyBloom if there are no logs ‑ LogsBloomUtils buildLogsBloom should be able to generate emptyBloom if there are no logs
should be able to generate logsBloom of transfer event ‑ LogsBloomUtils buildLogsBloom should be able to generate logsBloom of transfer event
should be able to get accurate logs with address filter ‑ Filter API Test Suite eth_getFilterLogs should be able to get accurate logs with address filter
should be able to get accurate logs with fromBlock filter ‑ Filter API Test Suite eth_getFilterLogs should be able to get accurate logs with fromBlock filter
should be able to get accurate logs with toBlock filter ‑ Filter API Test Suite eth_getFilterLogs should be able to get accurate logs with toBlock filter
should be able to get accurate logs with topics ‑ Filter API Test Suite eth_getFilterLogs should be able to get accurate logs with topics
should be able to get existing env var ‑ ConfigService tests should be able to get existing env var
should be able to get from internal cache when calling getAsync ‑ CacheService Test Suite Internal Cache Test Suite should be able to get from internal cache when calling getAsync
should be able to get from shared cache with fallback to internal cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to get from shared cache with fallback to internal cache
should be able to getAsync from internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite should be able to getAsync from internal cache in case of Redis error
should be able to initialize SDK instance ‑ HAPI Service should be able to initialize SDK instance
should be able to mask every value if it starts with known secret prefix ‑ LoggerService tests should be able to mask every value if it starts with known secret prefix
should be able to mask sensitive information ‑ LoggerService tests should be able to mask sensitive information
should be able to multiSet to internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite should be able to multiSet to internal cache in case of Redis error
should be able to multiSet ‑ LocalLRUCache Test Suite KEYS Test Suite should be able to multiSet
should be able to multiset to shared cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to multiset to shared cache
should be able to pipelineSet to internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite should be able to pipelineSet to internal cache in case of Redis error
should be able to reinitialise SDK instance upon error status code encounter ‑ HAPI Service given HAPI_CLIENT_ERROR_RESET=[50] are set should be able to reinitialise SDK instance upon error status code encounter
should be able to reinitialise SDK instance upon reaching time limit ‑ HAPI Service given HAPI_CLIENT_DURATION_RESET=100 are set should be able to reinitialise SDK instance upon reaching time limit
should be able to reinitialise SDK instance upon reaching transaction limit ‑ HAPI Service given HAPI_CLIENT_TRANSACTION_RESET=2 are set should be able to reinitialise SDK instance upon reaching transaction limit
should be able to reset all counter upon reinitialization of the SDK Client ‑ HAPI Service given HAPI_CLIENT_ERROR_RESET=[50], HAPI_CLIENT_TRANSACTION_RESET=50, HAPI_CLIENT_DURATION_RESET=36000 are set should be able to reset all counter upon reinitialization of the SDK Client
should be able to return more than two logs with limit of two per request ‑ @ethGetLogs using MirrorNode given MIRROR_NODE_LIMIT_PARAM=2 are set should be able to return more than two logs with limit of two per request
should be able to return plain information ‑ LoggerService tests should be able to return plain information
should be able to set and delete from internal cache ‑ CacheService Test Suite Internal Cache Test Suite should be able to set and delete from internal cache
should be able to set and delete from shared cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to set and delete from shared cache
should be able to set and get from internal cache ‑ CacheService Test Suite Internal Cache Test Suite should be able to set and get from internal cache
should be able to set and get from shared cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to set and get from shared cache
should be able to set cache with TTL greater than 1000 milliseconds ‑ RedisCache Test Suite Get and Set Test Suite should be able to set cache with TTL greater than 1000 milliseconds
should be able to set cache with TTL less than 1000 milliseconds ‑ RedisCache Test Suite Get and Set Test Suite should be able to set cache with TTL less than 1000 milliseconds
should be able to set to internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite should be able to set to internal cache in case of Redis error
should be able to set to shared cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to set to shared cache
should be able to set using multiSet and get them separately using internal cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to set using multiSet and get them separately using internal cache
should be able to set using multiSet and get them separately ‑ CacheService Test Suite Internal Cache Test Suite should be able to set using multiSet and get them separately
should be able to set using pipelineSet and get them separately using internal cache ‑ CacheService Test Suite Shared Cache Test Suite should be able to set using pipelineSet and get them separately using internal cache
should be able to use default value for missing env if default value is set ‑ ValidationService tests typeCasting should be able to use default value for missing env if default value is set
should be able to validate address and topics in generated logsBloom ‑ LogsBloomUtils buildLogsBloom should be able to validate address and topics in generated logsBloom
should be able to validate non-existing address and topic in generated logsBloom ‑ LogsBloomUtils buildLogsBloom should be able to validate non-existing address and topic in generated logsBloom
should call getFilterChanges ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=true are set should call getFilterChanges
should call newFilter ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=true are set should call newFilter
should call repeated request passing masked IP address ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should call repeated request passing masked IP address
should call uninstallFilter ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=true are set should call uninstallFilter
should connect Redis client if shared cache is enabled ‑ CacheService Test Suite Shared Cache Test Suite connectRedisClient should connect Redis client if shared cache is enabled
should connect to the Redis cache ‑ RedisCache Test Suite Connect Test Suite should connect to the Redis cache
should convert a Uint8Array with maximum byte value (0xff) to a hex string ‑ Formatters toHexString should convert a Uint8Array with maximum byte value (0xff) to a hex string
should convert a Uint8Array with multiple byte values to a hex string ‑ Formatters toHexString should convert a Uint8Array with multiple byte values to a hex string
should convert a Uint8Array with single byte values to a hex string ‑ Formatters toHexString should convert a Uint8Array with single byte values to a hex string
should convert a hex string to bytes ‑ Precheck hexToBytes should convert a hex string to bytes
should convert a number ‑ Formatters nanOrNumberTo0x should convert a number
should convert a valid hex to BigNumber ‑ Formatters toNullableBigNumber should convert a valid hex to BigNumber
should convert a valid number to hex ‑ Formatters nullableNumberTo0x should convert a valid number to hex
should convert an empty Uint8Array to an empty hex string ‑ Formatters toHexString should convert an empty Uint8Array to an empty hex string
should convert max int64 value in hex to tinybar number ‑ Formatters weibarHexToTinyBarInt should convert max int64 value in hex to tinybar number
should convert tinybars to weibars ‑ Formatters tinybarsToWeibars should convert tinybars to weibars
should convert to hex a BigInt type ‑ Formatters numberTo0x should convert to hex a BigInt type
should convert to hex a number type ‑ Formatters numberTo0x should convert to hex a number type
should convert weibar hex value to tinybar number ‑ Formatters weibarHexToTinyBarInt should convert weibar hex value to tinybar number
should copy input to data if input is provided but data is not ‑ @ethCall Eth Call spec contractCallFormat should copy input to data if input is provided but data is not
should correctly handle a valid network error with a status field ‑ SDKClientError should correctly handle a valid network error with a status field
should correctly handle an error without a status field ‑ SDKClientError should correctly handle an error without a status field
should correctly handle an invalid status code in the error object ‑ SDKClientError should correctly handle an invalid status code in the error object
should correctly identify connection dropped ‑ SDKClientError should correctly identify connection dropped
should correctly identify contract deletion ‑ SDKClientError should correctly identify contract deletion
should correctly identify contract revert execution ‑ SDKClientError should correctly identify contract revert execution
should correctly identify gRPC timeout ‑ SDKClientError should correctly identify gRPC timeout
should correctly identify insufficient transaction fee ‑ SDKClientError should correctly identify insufficient transaction fee
should correctly identify invalid account ID ‑ SDKClientError should correctly identify invalid account ID
should correctly identify invalid contract ID by message ‑ SDKClientError should correctly identify invalid contract ID by message
should correctly identify invalid contract ID by status code ‑ SDKClientError should correctly identify invalid contract ID by status code
should correctly identify timeout exceeded ‑ SDKClientError should correctly identify timeout exceeded
should correctly validate nested topic arrays ‑ Validator validates topics type correctly should correctly validate nested topic arrays
should create a MethodNotFound with correct message and code ‑ RpcErrors MethodNotFound should create a MethodNotFound with correct message and code
should create a ParseError with correct message and code ‑ RpcErrors ParseError should create a ParseError with correct message and code
should create a ServerError with correct message and code within valid range ‑ RpcErrors ServerError should create a ServerError with correct message and code within valid range
should create a basic spending plan and link it only to the given evmAddress, if also an ipAddress is available ‑ HBAR Rate Limit Service createBasicSpendingPlan should create a basic spending plan and link it only to the given evmAddress, if also an ipAddress is available
should create a basic spending plan for the given evmAddress ‑ HBAR Rate Limit Service createBasicSpendingPlan should create a basic spending plan for the given evmAddress
should create a basic spending plan if none exists for the evmAddress ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should create a basic spending plan if none exists for the evmAddress
should create a basic spending plan if none exists ‑ HBAR Rate Limit Service addExpense should create a basic spending plan if none exists
should create an HBARRateLimitExceeded error with correct message and code ‑ RpcErrors HBARRateLimitExceeded should create an HBARRateLimitExceeded error with correct message and code
should create an IPRateLimitExceeded error with correct message and code ‑ RpcErrors IPRateLimitExceeded should create an IPRateLimitExceeded error with correct message and code
should create an InternalError with default message when no error is provided ‑ RpcErrors InternalError should create an InternalError with default message when no error is provided
should create an InternalError with provided error message and code ‑ RpcErrors InternalError should create an InternalError with provided error message and code
should create an InvalidParams with correct message and code ‑ RpcErrors InvalidParams should create an InvalidParams with correct message and code
should create an InvalidRequest with correct message and code ‑ RpcErrors InvalidRequest should create an InvalidRequest with correct message and code
should create an Unauthorized error with correct message and code ‑ RpcErrors Unauthorized should create an Unauthorized error with correct message and code
should decode a valid error message ‑ Formatters strip0x decodeErrorMessage should decode a valid error message
should decode correctly regarding hardcoded mapping ‑ Formatters ASCIIToHex Function should decode correctly regarding hardcoded mapping
should decrease remaining calls on subsequent requests ‑ RateLimit should decrease remaining calls on subsequent requests
should decrement the limiter counters ‑ Utilities unit tests handleConnectionClose should decrement the limiter counters
should default chainId to 298 when no environment variables are set ‑ Net given HEDERA_NETWORK=undefined, CHAIN_ID=undefined are set should default chainId to 298 when no environment variables are set
should delete array cache ‑ RedisCache Test Suite Delete Test Suite should delete array cache
should delete boolean cache ‑ RedisCache Test Suite Delete Test Suite should delete boolean cache
should delete int cache ‑ RedisCache Test Suite Delete Test Suite should delete int cache
should delete object cache ‑ RedisCache Test Suite Delete Test Suite should delete object cache
should delete obsolete EXTENDED and PRIVILEGED plans from the database ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should delete obsolete EXTENDED and PRIVILEGED plans from the database
should delete obsolete EXTENDED and PRIVILEGED plans from the database ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should delete obsolete EXTENDED and PRIVILEGED plans from the database
should delete obsolete EXTENDED and PRIVILEGED plans from the database ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should delete obsolete EXTENDED and PRIVILEGED plans from the database
should delete obsolete EXTENDED and PRIVILEGED plans from the database ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should delete obsolete EXTENDED and PRIVILEGED plans from the database
should delete obsolete associations for EVM addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for EVM addresses
should delete obsolete associations for EVM addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for EVM addresses
should delete obsolete associations for EVM addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for EVM addresses
should delete obsolete associations for EVM addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for EVM addresses
should delete obsolete associations for IP addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for IP addresses
should delete obsolete associations for IP addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for IP addresses
should delete obsolete associations for IP addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for IP addresses
should delete obsolete associations for IP addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should delete obsolete associations for IP addresses
should disconnect Redis client if shared cache is enabled ‑ CacheService Test Suite Shared Cache Test Suite disconnectRedisClient should disconnect Redis client if shared cache is enabled
should disconnect from the Redis cache ‑ RedisCache Test Suite Disconnect Test Suite should disconnect from the Redis cache
should do nothing when already disconnected ‑ RedisCache Test Suite Disconnect Test Suite should do nothing when already disconnected
should emit tracking event (limiter and metrics) only for successful tx responses from FileAppend transaction ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should emit tracking event (limiter and metrics) only for successful tx responses from FileAppend transaction
should escape special characters in the pattern ‑ CacheService Test Suite Internal Cache Test Suite keys should escape special characters in the pattern
should escape special characters in the pattern ‑ CacheService Test Suite Shared Cache Test Suite keys should escape special characters in the pattern
should eth_estimateGas contract call returns workaround response from mirror-node ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas contract call returns workaround response from mirror-node
should eth_estimateGas contract call with value is converted to tinybars before it is sent to mirror node ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas contract call with value is converted to tinybars before it is sent to mirror node
should eth_estimateGas empty call returns transfer cost with overridden default gas ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas empty call returns transfer cost with overridden default gas
should eth_estimateGas empty call returns transfer cost ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas empty call returns transfer cost
should eth_estimateGas empty input transfer cost with overridden default gas ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas empty input transfer cost with overridden default gas
should eth_estimateGas empty input transfer cost ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas empty input transfer cost
should eth_estimateGas for contract create with input field and absent data field ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas for contract create with input field and absent data field
should eth_estimateGas for contract deploy returns default ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas for contract deploy returns default
should eth_estimateGas handles a 501 unimplemented response from the mirror node correctly by returning default gas ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas handles a 501 unimplemented response from the mirror node correctly by returning default gas
should eth_estimateGas to mirror node for contract call returns 501 ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas to mirror node for contract call returns 501
should eth_estimateGas to mirror node for transfer returns 501 ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas to mirror node for transfer returns 501
should eth_estimateGas to mirror node for transfer without value returns 501 ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas to mirror node for transfer without value returns 501
should eth_estimateGas transfer to existing account ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas transfer to existing account
should eth_estimateGas transfer to existing cached account ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas transfer to existing cached account
should eth_estimateGas transfer to non existing account ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas transfer to non existing account
should eth_estimateGas transfer with 0 value ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas transfer with 0 value
should eth_estimateGas transfer with invalid value ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas transfer with invalid value
should eth_estimateGas with contract revert and message does not equal executionReverted and ESTIMATE_GAS_THROWS is set to false ‑ @ethEstimateGas Estimate Gas spec given ESTIMATE_GAS_THROWS=false are set should eth_estimateGas with contract revert and message does not equal executionReverted and ESTIMATE_GAS_THROWS is set to false
should eth_estimateGas with contract revert and message does not equal executionReverted ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas with contract revert and message does not equal executionReverted
should eth_estimateGas with contract revert and message equals "execution reverted: Invalid number of recipients" ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas with contract revert and message equals "execution reverted: Invalid number of recipients"
should eth_estimateGas with contract revert for contract call and custom contract error ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas with contract revert for contract call and custom contract error
should eth_estimateGas with contract revert for contract call and generic revert error ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas with contract revert for contract call and generic revert error
should eth_estimateGas with transaction.data null does not fail ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas with transaction.data null does not fail
should eth_estimateGas zero input returns transfer cost with overridden default gas ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas zero input returns transfer cost with overridden default gas
should eth_estimateGas zero input returns transfer cost ‑ @ethEstimateGas Estimate Gas spec should eth_estimateGas zero input returns transfer cost
should exclude transaction with error_message INVALID_ACCOUNT_ID ‑ Utils isRevertedDueToHederaSpecificValidation should exclude transaction with error_message INVALID_ACCOUNT_ID
should exclude transaction with error_message WRONG_NONCE ‑ Utils isRevertedDueToHederaSpecificValidation should exclude transaction with error_message WRONG_NONCE
should exclude transaction with result INVALID_ACCOUNT_ID ‑ Utils isRevertedDueToHederaSpecificValidation should exclude transaction with result INVALID_ACCOUNT_ID
should exclude transaction with result WRONG_NONCE ‑ Utils isRevertedDueToHederaSpecificValidation should exclude transaction with result WRONG_NONCE
should execute "eth_accounts" ‑ @ethCommon @ethCommon should execute "eth_accounts"
should execute "eth_accounts" ‑ Open RPC Specification should execute "eth_accounts"
should execute "eth_accounts" ‑ RPC Server should execute "eth_accounts"
should execute "eth_blockNumber" ‑ Open RPC Specification should execute "eth_blockNumber"
should execute "eth_call" against consensus node with a ETH_CALL_DEFAULT_TO_CONSENSUS_NODE set to true ‑ @ethCall Eth Call spec eth_call precheck failures given ETH_CALL_DEFAULT_TO_CONSENSUS_NODE=true are set should execute "eth_call" against consensus node with a ETH_CALL_DEFAULT_TO_CONSENSUS_NODE set to true
should execute "eth_call" against mirror node with a false ETH_CALL_DEFAULT_TO_CONSENSUS_NODE ‑ @ethCall Eth Call spec eth_call precheck failures given ETH_CALL_DEFAULT_TO_CONSENSUS_NODE=false are set should execute "eth_call" against mirror node with a false ETH_CALL_DEFAULT_TO_CONSENSUS_NODE
should execute "eth_call" against mirror node with an undefined ETH_CALL_DEFAULT_TO_CONSENSUS_NODE ‑ @ethCall Eth Call spec eth_call precheck failures given ETH_CALL_DEFAULT_TO_CONSENSUS_NODE=undefined are set should execute "eth_call" against mirror node with an undefined ETH_CALL_DEFAULT_TO_CONSENSUS_NODE
should execute "eth_chainId" and "eth_accounts" in batch request with invalid request id ‑ RPC Server batchRequest Test Cases should execute "eth_chainId" and "eth_accounts" in batch request with invalid request id
should execute "eth_chainId" and "eth_accounts" in batch request ‑ RPC Server batchRequest Test Cases should execute "eth_chainId" and "eth_accounts" in batch request
should execute "eth_chainId" and method not found and params error in batch request ‑ RPC Server batchRequest Test Cases should execute "eth_chainId" and method not found and params error in batch request
should execute "eth_chainId" and method not found in batch request ‑ RPC Server batchRequest Test Cases should execute "eth_chainId" and method not found in batch request
should execute "eth_chainId" in batch request ‑ RPC Server batchRequest Test Cases should execute "eth_chainId" in batch request
should execute "eth_chainId" ‑ @ethCommon @ethCommon should execute "eth_chainId"
should execute "eth_chainId" ‑ Open RPC Specification should execute "eth_chainId"
should execute "eth_chainId" ‑ RPC Server should execute "eth_chainId"
should execute "eth_coinbase" ‑ Open RPC Specification should execute "eth_coinbase"
should execute "eth_coinbase" ‑ RPC Server should execute "eth_coinbase"
should execute "eth_estimateGas" ‑ Open RPC Specification should execute "eth_estimateGas"
should execute "eth_feeHistory" ‑ Open RPC Specification should execute "eth_feeHistory"
should execute "eth_gasPrice" ‑ Open RPC Specification should execute "eth_gasPrice"
should execute "eth_getBalance" ‑ Open RPC Specification should execute "eth_getBalance"
should execute "eth_getBlockByHash" with hydrated = false ‑ Open RPC Specification should execute "eth_getBlockByHash" with hydrated = false
should execute "eth_getBlockByHash" with hydrated = true ‑ Open RPC Specification should execute "eth_getBlockByHash" with hydrated = true
should execute "eth_getBlockByNumber" with hydrated = false ‑ Open RPC Specification should execute "eth_getBlockByNumber" with hydrated = false
should execute "eth_getBlockByNumber" with hydrated = true ‑ Open RPC Specification should execute "eth_getBlockByNumber" with hydrated = true
should execute "eth_getBlockTransactionCountByHash" ‑ Open RPC Specification should execute "eth_getBlockTransactionCountByHash"
should execute "eth_getBlockTransactionCountByNumber" with block number ‑ Open RPC Specification should execute "eth_getBlockTransactionCountByNumber" with block number
should execute "eth_getBlockTransactionCountByNumber" with block tag ‑ Open RPC Specification should execute "eth_getBlockTransactionCountByNumber" with block tag
should execute "eth_getCode" with block number ‑ Open RPC Specification should execute "eth_getCode" with block number
should execute "eth_getCode" with block tag ‑ Open RPC Specification should execute "eth_getCode" with block tag
should execute "eth_getLogs" with no filters ‑ Open RPC Specification should execute "eth_getLogs" with no filters
should execute "eth_getLogs" with topics filter ‑ Open RPC Specification should execute "eth_getLogs" with topics filter
should execute "eth_getProof" ‑ RPC Server should execute "eth_getProof"
should execute "eth_getTransactionByBlockHashAndIndex" ‑ Open RPC Specification should execute "eth_getTransactionByBlockHashAndIndex"
should execute "eth_getTransactionByBlockNumberAndIndex" ‑ Open RPC Specification should execute "eth_getTransactionByBlockNumberAndIndex"
should execute "eth_getTransactionByHash with missing transaction" ‑ RPC Server should execute "eth_getTransactionByHash with missing transaction"
should execute "eth_getTransactionByHash" ‑ Open RPC Specification should execute "eth_getTransactionByHash"
should execute "eth_getTransactionCount" ‑ Open RPC Specification should execute "eth_getTransactionCount"
should execute "eth_getTransactionReceipt" ‑ Open RPC Specification should execute "eth_getTransactionReceipt"
should execute "eth_getUncleByBlockHashAndIndex" ‑ @ethCommon @ethCommon should execute "eth_getUncleByBlockHashAndIndex"
should execute "eth_getUncleByBlockHashAndIndex" ‑ Open RPC Specification should execute "eth_getUncleByBlockHashAndIndex"
should execute "eth_getUncleByBlockHashAndIndex" ‑ RPC Server should execute "eth_getUncleByBlockHashAndIndex"
should execute "eth_getUncleByBlockNumberAndIndex" ‑ @ethCommon @ethCommon should execute "eth_getUncleByBlockNumberAndIndex"
should execute "eth_getUncleByBlockNumberAndIndex" ‑ Open RPC Specification should execute "eth_getUncleByBlockNumberAndIndex"
should execute "eth_getUncleByBlockNumberAndIndex" ‑ RPC Server should execute "eth_getUncleByBlockNumberAndIndex"
should execute "eth_getUncleCountByBlockHash" ‑ @ethCommon @ethCommon should execute "eth_getUncleCountByBlockHash"
should execute "eth_getUncleCountByBlockHash" ‑ Open RPC Specification should execute "eth_getUncleCountByBlockHash"
should execute "eth_getUncleCountByBlockHash" ‑ RPC Server should execute "eth_getUncleCountByBlockHash"
should execute "eth_getUncleCountByBlockNumber" ‑ @ethCommon @ethCommon should execute "eth_getUncleCountByBlockNumber"
should execute "eth_getUncleCountByBlockNumber" ‑ Open RPC Specification should execute "eth_getUncleCountByBlockNumber"
should execute "eth_getUncleCountByBlockNumber" ‑ RPC Server should execute "eth_getUncleCountByBlockNumber"
should execute "eth_getWork" ‑ @ethCommon @ethCommon should execute "eth_getWork"
should execute "eth_getWork" ‑ Open RPC Specification should execute "eth_getWork"
should execute "eth_getWork" ‑ RPC Server should execute "eth_getWork"
should execute "eth_hashrate" ‑ @ethCommon @ethCommon should execute "eth_hashrate"
should execute "eth_hashrate" ‑ Open RPC Specification should execute "eth_hashrate"
should execute "eth_hashrate" ‑ RPC Server should execute "eth_hashrate"
should execute "eth_maxPriorityFeePerGas" ‑ @ethCommon @ethCommon should execute "eth_maxPriorityFeePerGas"
should execute "eth_maxPriorityFeePerGas" ‑ RPC Server should execute "eth_maxPriorityFeePerGas"
should execute "eth_mining" ‑ @ethCommon @ethCommon should execute "eth_mining"
should execute "eth_mining" ‑ Open RPC Specification should execute "eth_mining"
should execute "eth_mining" ‑ RPC Server should execute "eth_mining"
should execute "eth_protocolVersion" ‑ Open RPC Specification should execute "eth_protocolVersion"
should execute "eth_protocolVersion" ‑ RPC Server should execute "eth_protocolVersion"
should execute "eth_sendRawTransaction" ‑ Open RPC Specification should execute "eth_sendRawTransaction"
should execute "eth_sendTransaction" ‑ Open RPC Specification should execute "eth_sendTransaction"
should execute "eth_sendTransaction" ‑ RPC Server should execute "eth_sendTransaction"
should execute "eth_sign" ‑ Open RPC Specification should execute "eth_sign"
should execute "eth_sign" ‑ RPC Server should execute "eth_sign"
should execute "eth_signTransaction" ‑ Open RPC Specification should execute "eth_signTransaction"
should execute "eth_signTransaction" ‑ RPC Server should execute "eth_signTransaction"
should execute "eth_signTypedData" ‑ RPC Server should execute "eth_signTypedData"
should execute "eth_submitHashrate" ‑ Open RPC Specification should execute "eth_submitHashrate"
should execute "eth_submitHashrate" ‑ RPC Server should execute "eth_submitHashrate"
should execute "eth_submitWork" ‑ @ethCommon @ethCommon should execute "eth_submitWork"
should execute "eth_submitWork" ‑ Open RPC Specification should execute "eth_submitWork"
should execute "eth_submitWork" ‑ RPC Server should execute "eth_submitWork"
should execute "eth_syncing" ‑ @ethCommon @ethCommon should execute "eth_syncing"
should execute "eth_syncing" ‑ Open RPC Specification should execute "eth_syncing"
should execute "eth_syncing" ‑ RPC Server should execute "eth_syncing"
should execute "net_listening" ‑ Net should execute "net_listening"
should execute "net_listening" ‑ Open RPC Specification should execute "net_listening"
should execute "net_listening" ‑ RPC Server should execute "net_listening"
should execute "net_peerCount" ‑ RPC Server should execute "net_peerCount"
should execute "net_version" ‑ Net should execute "net_version"
should execute "net_version" ‑ Open RPC Specification should execute "net_version"
should execute "web3_clientVersion" ‑ Open RPC Specification should execute "web3_clientVersion"
should execute "web3_clientVersion" ‑ RPC Server should execute "web3_clientVersion"
should execute "web3_sha" ‑ RPC Server should execute "web3_sha"
should execute EthereumTransaction and add expenses to limiter ‑ SdkClient HBAR Limiter should execute EthereumTransaction and add expenses to limiter
should execute EthereumTransaction, retrieve transactionStatus and expenses via MIRROR NODE ‑ SdkClient HBAR Limiter given GET_RECORD_DEFAULT_TO_CONSENSUS_NODE=false are set should execute EthereumTransaction, retrieve transactionStatus and expenses via MIRROR NODE
should execute FileCreateTransaction with callData.length <= fileAppendChunkSize and add expenses to limiter ‑ SdkClient HBAR Limiter should execute FileCreateTransaction with callData.length <= fileAppendChunkSize and add expenses to limiter
should execute FileCreateTransaction with callData.length > fileAppendChunkSize and add expenses to limiter ‑ SdkClient HBAR Limiter should execute FileCreateTransaction with callData.length > fileAppendChunkSize and add expenses to limiter
should execute FileDeleteTransaction and add expenses to limiter ‑ SdkClient HBAR Limiter should execute FileDeleteTransaction and add expenses to limiter
should execute FileInfoQuery (with paymentTransactionId) and add expenses to limiter ‑ SdkClient HBAR Limiter should execute FileInfoQuery (with paymentTransactionId) and add expenses to limiter
should execute FileInfoQuery (without paymentTransactionId) and add expenses to limiter ‑ SdkClient HBAR Limiter should execute FileInfoQuery (without paymentTransactionId) and add expenses to limiter
should execute HTTP OPTIONS cors preflight check ‑ RPC Server Validator eth_getLogs should execute HTTP OPTIONS cors preflight check
should execute addExpenseAndCaptureMetrics() to capture metrics in HBAR limiter and metric registry ‑ Metric Service addExpenseAndCaptureMetrics should execute addExpenseAndCaptureMetrics() to capture metrics in HBAR limiter and metric registry
should execute executeAllTransaction and add expenses to limiter ‑ SdkClient HBAR Limiter should execute executeAllTransaction and add expenses to limiter
should execute executeAllTransaction with 3 file appends and add expenses to limiter only for the successful ones (2) ‑ SdkClient HBAR Limiter should execute executeAllTransaction with 3 file appends and add expenses to limiter only for the successful ones (2)
should execute getTransactionRecordMetrics to get transaction record metrics ‑ MirrorNodeClient getTransactionRecordMetrics should execute getTransactionRecordMetrics to get transaction record metrics
should execute getTransactionRecordMetrics to get transaction record metrics ‑ SdkClient HBAR Limiter should execute getTransactionRecordMetrics to get transaction record metrics
should execute metrics collection ‑ RPC Server Validator eth_getLogs should execute metrics collection
should execute submitEthereumTransaction add expenses to limiter for large transaction data ‑ SdkClient HBAR Limiter should execute submitEthereumTransaction add expenses to limiter for large transaction data
should execute successful health liveness check ‑ RPC Server Validator eth_getLogs should execute successful health liveness check
should execute successful health readiness check ‑ RPC Server Validator eth_getLogs should execute successful health readiness check
should execute with CallTracer type and valid CallTracerConfig ‑ RPC Server Validator debug_traceTransaction should execute with CallTracer type and valid CallTracerConfig
should execute with OpcodeLogger type and valid OpcodeLoggerConfig ‑ RPC Server Validator debug_traceTransaction should execute with OpcodeLogger type and valid OpcodeLoggerConfig
should execute with empty TracerConfigWrapper.tracerConfig ‑ RPC Server Validator debug_traceTransaction should execute with empty TracerConfigWrapper.tracerConfig
should execute with unknown property in TracerConfig ‑ RPC Server Validator debug_traceTransaction should execute with unknown property in TracerConfig
should execute with unknown property in TracerConfigWrapper.tracerConfig ‑ RPC Server Validator debug_traceTransaction should execute with unknown property in TracerConfigWrapper.tracerConfig
should execute with valid hash and valid TracerType string ‑ RPC Server Validator debug_traceTransaction should execute with valid hash and valid TracerType string
should execute with valid hash ‑ RPC Server Validator debug_traceTransaction should execute with valid hash
should execute with valid hash, no TracerType and no TracerConfig ‑ RPC Server Validator debug_traceTransaction should execute with valid hash, no TracerType and no TracerConfig
should execute with valid hash, valid TracerType and empty TracerConfig ‑ RPC Server Validator debug_traceTransaction should execute with valid hash, valid TracerType and empty TracerConfig
should expire amountSpent key at the end of the day ‑ HbarSpendingPlanRepository with shared cache getAmountSpent should expire amountSpent key at the end of the day
should expire amountSpent key at the end of the day ‑ HbarSpendingPlanRepository without shared cache getAmountSpent should expire amountSpent key at the end of the day
should fail fast if mandatory env is invalid number format ‑ ValidationService tests startUp should fail fast if mandatory env is invalid number format
should fail fast if mandatory env is not passed ‑ ValidationService tests startUp should fail fast if mandatory env is not passed
should fail fast if npm_package_version is not set ‑ ValidationService tests package-version should fail fast if npm_package_version is not set
should fail for gasLimit: 1 ‑ Precheck gasLimit should fail for gasLimit: 1
should fail for gasLimit: 10 ‑ Precheck gasLimit should fail for gasLimit: 10
should fail for gasLimit: 100 ‑ Precheck gasLimit should fail for gasLimit: 100
should fail for gasLimit: 1000 ‑ Precheck gasLimit should fail for gasLimit: 1000
should fail for gasLimit: 10000 ‑ Precheck gasLimit should fail for gasLimit: 10000
should fail for gasLimit: 100000000 ‑ Precheck gasLimit should fail for gasLimit: 100000000
should fail for gasLimit: 20000000 ‑ Precheck gasLimit should fail for gasLimit: 20000000
should fail for gasLimit: 999999999999 ‑ Precheck gasLimit should fail for gasLimit: 999999999999
should fail for low nonce ‑ Precheck nonce should fail for low nonce
should fail for missing account ‑ Precheck account should fail for missing account
should fail if passed 0x ‑ Precheck hexToBytes should fail if passed 0x
should fail if passed empty string ‑ Precheck hexToBytes should fail if passed empty string
should fail to fetch blocks for empty network ‑ MirrorNodeClient getEarliestBlock should fail to fetch blocks for empty network
should fail to fetch contract for non existing contract ‑ MirrorNodeClient getContractId should fail to fetch contract for non existing contract
should fail to fetch transaction by non existing account ‑ MirrorNodeClient getAccountLatestEthereumTransactionsByTimestamp should fail to fetch transaction by non existing account
should fail to fetch transaction by wrong transaction id ‑ MirrorNodeClient getTransactionById should fail to fetch transaction by wrong transaction id
should fail when block range is too large for address(es) `["0x000000000000000000000000000000000000055f","0x000000000000000000000000000000000000055e"]` ‑ @ethGetLogs using MirrorNode should fail when block range is too large for address(es) `["0x000000000000000000000000000000000000055f","0x000000000000000000000000000000000000055e"]`
should fail when block range is too large for address(es) `[]` ‑ @ethGetLogs using MirrorNode should fail when block range is too large for address(es) `[]`
should fail when block range is too large for address(es) `null` ‑ @ethGetLogs using MirrorNode should fail when block range is too large for address(es) `null`
should fail with empty TracerConfig containing invalid properties ‑ RPC Server Validator debug_traceTransaction should fail with empty TracerConfig containing invalid properties
should fail with invalid JSON-RPC method name ‑ RPC Server Validator debug_traceTransaction should fail with invalid JSON-RPC method name
should fail with invalid JSON-RPC version ‑ RPC Server Validator debug_traceTransaction should fail with invalid JSON-RPC version
should fail with invalid hash ‑ RPC Server Validator debug_traceTransaction should fail with invalid hash
should fail with missing transaction hash ‑ RPC Server Validator debug_traceTransaction should fail with missing transaction hash
should fail with valid hash and invalid TracerType string ‑ RPC Server Validator debug_traceTransaction should fail with valid hash and invalid TracerType string
should fail with valid hash and invalid type for TracerConfig.disableStack ‑ RPC Server Validator debug_traceTransaction should fail with valid hash and invalid type for TracerConfig.disableStack
should fail with valid hash and invalid type for TracerConfig.disableStorage ‑ RPC Server Validator debug_traceTransaction should fail with valid hash and invalid type for TracerConfig.disableStorage

should fail with valid hash and invalid type for TracerConfig.enableMemory ‑ RPC Server Validator debug_traceTransaction should fail with valid hash and invalid type for TracerConfig.enableMemory
should fail with valid hash and invalid type for TracerConfigWrapper.tracer ‑ RPC Server Validator debug_traceTransaction should fail with valid hash and invalid type for TracerConfigWrapper.tracer
should fail with valid hash and invalid type for TracerConfigWrapper.tracerConfig ‑ RPC Server Validator debug_traceTransaction should fail with valid hash and invalid type for TracerConfigWrapper.tracerConfig
should fail with valid hash, valid tracer type and invalid tracer configuration ‑ RPC Server Validator debug_traceTransaction should fail with valid hash, valid tracer type and invalid tracer configuration
should fetch block for existing valid network ‑ MirrorNodeClient getEarliestBlock should fetch block for existing valid network
should fetch block for valid network from cache on additional calls ‑ MirrorNodeClient getEarliestBlock should fetch block for valid network from cache on additional calls
should fetch contract for existing contract from cache on additional calls ‑ MirrorNodeClient getContractId should fetch contract for existing contract from cache on additional calls
should fetch id for existing contract ‑ MirrorNodeClient getContractId should fetch id for existing contract
should filter logs by `"0x000000000000000000000000000000000000055f"` with a large block range ‑ @ethGetLogs using MirrorNode should filter logs by `"0x000000000000000000000000000000000000055f"` with a large block range
should filter logs by `["0x000000000000000000000000000000000000055f"]` with a large block range ‑ @ethGetLogs using MirrorNode should filter logs by `["0x000000000000000000000000000000000000055f"]` with a large block range
should format exactly 32 bytes hash to 32 bytes ‑ Formatters toHash32 should format exactly 32 bytes hash to 32 bytes
should format more than 32 bytes hash to 32 bytes ‑ Formatters toHash32 should format more than 32 bytes hash to 32 bytes
should format transaction value to tiny bar integer ‑ @ethCall Eth Call spec contractCallFormat should format transaction value to tiny bar integer
should get null on empty cache ‑ RedisCache Test Suite Get and Set Test Suite should get null on empty cache
should get the state of a failed transaction when the contract reverts ‑ MirrorNodeClient getTransactionById should get the state of a failed transaction when the contract reverts
should get the state of a null transaction when the contract reverts ‑ MirrorNodeClient getTransactionById should get the state of a null transaction when the contract reverts
should get the state of an empty transaction when the contract reverts ‑ MirrorNodeClient getTransactionById should get the state of an empty transaction when the contract reverts
should get valid array cache ‑ RedisCache Test Suite Get and Set Test Suite should get valid array cache
should get valid boolean cache ‑ RedisCache Test Suite Get and Set Test Suite should get valid boolean cache
should get valid int cache ‑ RedisCache Test Suite Get and Set Test Suite should get valid int cache
should get valid object cache ‑ RedisCache Test Suite Get and Set Test Suite should get valid object cache
should handle 0x value ‑ Formatters weibarHexToTinyBarInt should handle 0x value
should handle cases where status is undefined ‑ SDKClientError should handle cases where status is undefined
should handle empty HEDERA_NETWORK and set chainId to default ‑ Net given HEDERA_NETWORK=, CHAIN_ID=undefined are set should handle empty HEDERA_NETWORK and set chainId to default
should handle empty object ‑ Formatters mapKeysAndValues should handle empty object
should handle error when getSpendingPlanByEvmAddress throws an EvmAddressHbarSpendingPlanNotFoundError ‑ HBAR Rate Limit Service getSpendingPlanByEvmAddress should handle error when getSpendingPlanByEvmAddress throws an EvmAddressHbarSpendingPlanNotFoundError
should handle error when getSpendingPlanByEvmAddress throws an HbarSpendingPlanNotActiveError ‑ HBAR Rate Limit Service getSpendingPlanByEvmAddress should handle error when getSpendingPlanByEvmAddress throws an HbarSpendingPlanNotActiveError
should handle error when getSpendingPlanByEvmAddress throws an HbarSpendingPlanNotFoundError ‑ HBAR Rate Limit Service getSpendingPlanByEvmAddress should handle error when getSpendingPlanByEvmAddress throws an HbarSpendingPlanNotFoundError
should handle errors when adding expense fails ‑ HBAR Rate Limit Service addExpense should handle errors when adding expense fails
should handle input that only contains "0x" ‑ Formatters strip0x should handle input that only contains "0x"
should handle keys that are numbers ‑ Formatters mapKeysAndValues should handle keys that are numbers
should handle keys with special characters ‑ Formatters mapKeysAndValues should handle keys with special characters
should handle nested topic arrays ‑ Validator validates topics type correctly should handle nested topic arrays
should handle null id and return a valid response ‑ jsonResp should handle null id and return a valid response
should handle string id and return a valid response ‑ jsonResp should handle string id and return a valid response
should handle values that are not strings ‑ Formatters mapKeysAndValues should handle values that are not strings
should hit batch request limit ‑ RPC Server batchRequest Test Cases should hit batch request limit
should increment a non-existing key ‑ RedisCache Test Suite Increment Test Suite should increment a non-existing key
should increment an existing key ‑ RedisCache Test Suite Increment Test Suite should increment an existing key
should increment the total closed connections counter ‑ Utilities unit tests handleConnectionClose should increment the total closed connections counter
should increment value in internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite incrBy should increment value in internal cache in case of Redis error
should increment value in internal cache ‑ CacheService Test Suite Internal Cache Test Suite incrBy should increment value in internal cache
should increment value in shared cache ‑ CacheService Test Suite Shared Cache Test Suite incrBy should increment value in shared cache
should increment with a negative value ‑ RedisCache Test Suite Increment Test Suite should increment with a negative value
should initialize correctly with valid parameters ‑ RelayImpl should initialize correctly with valid parameters
should initialize metrics correctly ‑ HBAR Rate Limit Service should initialize metrics correctly
should keep the same instance of hbar limiter and not reset the budget ‑ HAPI Service given HAPI_CLIENT_ERROR_RESET=[50], HAPI_CLIENT_TRANSACTION_RESET=50, HAPI_CLIENT_DURATION_RESET=36000 are set should keep the same instance of hbar limiter and not reset the budget
should listen to EXECUTE_QUERY event and kick off addExpenseAndCaptureMetrics() ‑ Metric Service addExpenseAndCaptureMetrics should listen to EXECUTE_QUERY event and kick off addExpenseAndCaptureMetrics()
should log a warning and increment counter when rate limited ‑ RateLimit should log a warning and increment counter when rate limited
should log a warning ‑ RelayImpl populatePreconfiguredSpendingPlans when a configuration file with invalid JSON is provided should log a warning
should log the response being sent to the client ‑ Utilities unit tests sendToClient should log the response being sent to the client
should log warning when .env is missing ‑ ConfigService tests should log warning when .env is missing
should map keys and values correctly ‑ Formatters mapKeysAndValues should map keys and values correctly
should not add prefix if the string is already prefixed ‑ Formatters prepend0x should not add prefix if the string is already prefixed
should not be able to reinitialise and decrement counters, if it is disabled ‑ HAPI Service given HAPI_CLIENT_TRANSACTION_RESET=0, HAPI_CLIENT_DURATION_RESET=0, HAPI_CLIENT_ERROR_RESET=[] are set should not be able to reinitialise and decrement counters, if it is disabled
should not delete pre-configured spending plans after default cache TTL expires ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should not delete pre-configured spending plans after default cache TTL expires
should not delete pre-configured spending plans after default cache TTL expires ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should not delete pre-configured spending plans after default cache TTL expires
should not delete pre-configured spending plans after default cache TTL expires ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should not delete pre-configured spending plans after default cache TTL expires
should not delete pre-configured spending plans after default cache TTL expires ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should not delete pre-configured spending plans after default cache TTL expires
should not duplicate already existing spending plans and their associations ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should not duplicate already existing spending plans and their associations
should not duplicate already existing spending plans and their associations ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should not duplicate already existing spending plans and their associations
should not duplicate already existing spending plans and their associations ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should not duplicate already existing spending plans and their associations
should not duplicate already existing spending plans and their associations ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should not duplicate already existing spending plans and their associations
should not evict reserved keys from the cache on reaching the max cache size limit ‑ LocalLRUCache Test Suite verify cache management should not evict reserved keys from the cache on reaching the max cache size limit
should not exclude evm reverted transaction ‑ Utils isRevertedDueToHederaSpecificValidation should not exclude evm reverted transaction
should not exclude transaction with status SUCCESS ‑ Utils isRevertedDueToHederaSpecificValidation should not exclude transaction with status SUCCESS
should not execute batch request when disabled ‑ RPC Server batchRequest Test Cases given BATCH_REQUESTS_ENABLED=false are set should not execute batch request when disabled
should not fail for matched account ‑ Precheck account should not fail for matched account
should not fail for next nonce ‑ Precheck nonce should not fail for next nonce
should not identify gRPC timeout when the status code is different ‑ SDKClientError should not identify gRPC timeout when the status code is different
should not modify a string that contains "0x" not at the start ‑ Formatters strip0x should not modify a string that contains "0x" not at the start
should not modify transaction if input and data fields are not provided ‑ @ethCall Eth Call spec contractCallFormat should not modify transaction if input and data fields are not provided
should not modify transaction if only data field is present ‑ @ethCall Eth Call spec contractCallFormat should not modify transaction if only data field is present
should not pass for 1 hbar ‑ Precheck balance should not pass for 1 hbar
should not pass for gas price not enough ‑ Precheck gas price should not pass for gas price not enough
should not pass for no account found ‑ Precheck balance should not pass for no account found
should not pass for non-matching chainId ‑ Precheck chainId should not pass for non-matching chainId
should not rate limit when RATE_LIMIT_DISABLED is true ‑ RateLimit given RATE_LIMIT_DISABLED=true are set should not rate limit when RATE_LIMIT_DISABLED is true
should not send second transaction on error different from timeout ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should not send second transaction on error different from timeout
should not send second transaction upon succession ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should not send second transaction upon succession
should not throw an error if the configuration file is not found ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should not throw an error if the configuration file is not found
should not throw an error if the configuration file is not found ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should not throw an error if the configuration file is not found
should not throw an error if the configuration file is not found ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should not throw an error if the configuration file is not found
should not throw an error if the configuration file is not found ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should not throw an error if the configuration file is not found
should not throw an error ‑ RelayImpl populatePreconfiguredSpendingPlans when no configuration file is provided should not throw an error
should not throw error if Redis client is already connected ‑ CacheService Test Suite Shared Cache Test Suite connectRedisClient should not throw error if Redis client is already connected
should not throw error if Redis client is already disconnected ‑ CacheService Test Suite Shared Cache Test Suite disconnectRedisClient should not throw error if Redis client is already disconnected
should not throw error if shared cache is not enabled ‑ CacheService Test Suite Internal Cache Test Suite connectRedisClient should not throw error if shared cache is not enabled
should not throw error if shared cache is not enabled ‑ CacheService Test Suite Internal Cache Test Suite disconnectRedisClient should not throw error if shared cache is not enabled
should parse gas to integer ‑ @ethCall Eth Call spec contractCallFormat should parse gas to integer
should parse gasPrice to integer ‑ @ethCall Eth Call spec contractCallFormat should parse gasPrice to integer
should pass for 10 hbar ‑ Precheck balance should pass for 10 hbar
should pass for 100 hbar ‑ Precheck balance should pass for 100 hbar
should pass for 10000 hbar ‑ Precheck balance should pass for 10000 hbar
should pass for 100000 hbar ‑ Precheck balance should pass for 100000 hbar
should pass for 50_000_000_000 hbar ‑ Precheck balance should pass for 50_000_000_000 hbar
should pass for gas price equal to required gas price ‑ Precheck gas price should pass for gas price equal to required gas price
should pass for gas price gt to required gas price ‑ Precheck gas price should pass for gas price gt to required gas price
should pass for gas price if the transaction is the deterministic deployment transaction ‑ Precheck gas price should pass for gas price if the transaction is the deterministic deployment transaction
should pass for gas price not enough but within buffer ‑ Precheck gas price should pass for gas price not enough but within buffer
should pass for gasLimit: 100000 ‑ Precheck gasLimit should pass for gasLimit: 100000
should pass for gasLimit: 1000000 ‑ Precheck gasLimit should pass for gasLimit: 1000000
should pass for gasLimit: 10000000 ‑ Precheck gasLimit should pass for gasLimit: 10000000
should pass for gasLimit: 500000 ‑ Precheck gasLimit should pass for gasLimit: 500000
should pass for gasLimit: 5000000 ‑ Precheck gasLimit should pass for gasLimit: 5000000
should pass for gasLimit: 60000 ‑ Precheck gasLimit should pass for gasLimit: 60000
should pass for matching chainId ‑ Precheck chainId should pass for matching chainId
should pass if value is less than 1 tinybar and data is not empty ‑ Precheck value should pass if value is less than 1 tinybar and data is not empty
should pass if value is more than 1 tinybar ‑ Precheck value should pass if value is more than 1 tinybar
should pass the validate param check with blockParam=0x0 and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=0x0 and return the bytecode
should pass the validate param check with blockParam=0x369ABF and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=0x369ABF and return the bytecode
should pass the validate param check with blockParam=earliest and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=earliest and return the bytecode
should pass the validate param check with blockParam=finalized and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=finalized and return the bytecode
should pass the validate param check with blockParam=latest and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=latest and return the bytecode
should pass the validate param check with blockParam=null and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=null and return the bytecode
should pass the validate param check with blockParam=pending and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=pending and return the bytecode
should pass the validate param check with blockParam=safe and return the bytecode ‑ @ethGetCode using MirrorNode eth_getCode should pass the validate param check with blockParam=safe and return the bytecode
should pass when chainId=0x0 ‑ Precheck chainId should pass when chainId=0x0
should poll an array of log data ‑ Polling Poller should poll an array of log data
should poll mirror node upon Connection dropped error for valid transaction and return correct Connection dropped error if no transaction is found ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should poll mirror node upon Connection dropped error for valid transaction and return correct Connection dropped error if no transaction is found
should poll mirror node upon Connection dropped error for valid transaction and return correct transaction hash ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should poll mirror node upon Connection dropped error for valid transaction and return correct transaction hash
should poll mirror node upon timeout exceeded error for valid transaction and return correct timeout exceeded error if no transaction is found ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should poll mirror node upon timeout exceeded error for valid transaction and return correct timeout exceeded error if no transaction is found
should poll mirror node upon timeout exceeded error for valid transaction and return correct transaction hash ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should poll mirror node upon timeout exceeded error for valid transaction and return correct transaction hash
should poll single line of log data ‑ Polling Poller should poll single line of log data
should populate gas price if not provided ‑ @ethCall Eth Call spec contractCallFormat should populate gas price if not provided
should populate preconfigured spending plans successfully ‑ RelayImpl populatePreconfiguredSpendingPlans when a configuration file is provided should populate preconfigured spending plans successfully
should populate the database with pre-configured spending plans ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should populate the database with pre-configured spending plans
should populate the database with pre-configured spending plans ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should populate the database with pre-configured spending plans
should populate the database with pre-configured spending plans ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should populate the database with pre-configured spending plans
should populate the database with pre-configured spending plans ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should populate the database with pre-configured spending plans
should populate the from field if the from field is not provided and value is provided ‑ @ethCall Eth Call spec contractCallFormat should populate the from field if the from field is not provided and value is provided
should prioritize CHAIN_ID over HEDERA_NETWORK ‑ Net given HEDERA_NETWORK=mainnet, CHAIN_ID=0x2 are set should prioritize CHAIN_ID over HEDERA_NETWORK
should prioritize environment variable RATE_LIMIT_DISABLED ‑ RateLimit given RATE_LIMIT_DISABLED=true are set should prioritize environment variable RATE_LIMIT_DISABLED
should push to a non-existing list ‑ RedisCache Test Suite RPUSH Test Suite should push to a non-existing list
should push to an existing list ‑ RedisCache Test Suite RPUSH Test Suite should push to an existing list
should push value to internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite rPush should push value to internal cache in case of Redis error
should push value to internal cache ‑ CacheService Test Suite Internal Cache Test Suite rPush should push value to internal cache
should push value to shared cache ‑ CacheService Test Suite Shared Cache Test Suite rPush should push value to shared cache
should rate limit before creating file ‑ SdkClient HBAR Limiter should rate limit before creating file
should rate limit before executing executeAllTransaction ‑ SdkClient HBAR Limiter should rate limit before executing executeAllTransaction
should rate limit when remaining calls are exhausted ‑ RateLimit should rate limit when remaining calls are exhausted
should recognize if a signed raw transaction is the deterministic deployment transaction ‑ Precheck gas price should recognize if a signed raw transaction is the deterministic deployment transaction
should reject Cancun transactions ‑ Precheck transactionType should reject Cancun transactions
should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file
should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file
should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file
should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should remove associations of addresses which were previously linked to BASIC spending plans, but now appear in the configuration file
should reset rate limit after duration ‑ RateLimit should reset rate limit after duration
should reset the amountSpent field of all spending plans ‑ HBAR Rate Limit Service resetLimiter should reset the amountSpent field of all spending plans
should reset the inactivity TTL timer for the client connection ‑ Utilities unit tests sendToClient should reset the inactivity TTL timer for the client connection
should reset the limiter when the reset date is reached ‑ HBAR Rate Limit Service isTotalBudgetExceeded should reset the limiter when the reset date is reached
should reset the remaining budget and update the gauge ‑ HBAR Rate Limit Service resetLimiter should reset the remaining budget and update the gauge
should resolve parameters for ETH_GETLOGS method ‑ Utilities unit tests resolveParams should resolve parameters for ETH_GETLOGS method
should resolve parameters for ETH_NEWFILTER method ‑ Utilities unit tests resolveParams should resolve parameters for ETH_NEWFILTER method
should retrieve a range from a non-existing list ‑ RedisCache Test Suite LRANGE Test Suite should retrieve a range from a non-existing list
should retrieve a range from an existing list ‑ RedisCache Test Suite LRANGE Test Suite should retrieve a range from an existing list
should retrieve all keys with * pattern ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve all keys with * pattern
should retrieve all keys with * pattern ‑ RedisCache Test Suite KEYS Test Suite should retrieve all keys with * pattern
should retrieve all keys ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve all keys
should retrieve all keys ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve all keys
should retrieve keys from internal cache in case of Redis error ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve keys from internal cache in case of Redis error
should retrieve keys from internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve keys from internal cache in case of Redis error
should retrieve keys matching a glob-style pattern with * ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with *
should retrieve keys matching a glob-style pattern with * ‑ RedisCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with *
should retrieve keys matching a glob-style pattern with ? ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with ?
should retrieve keys matching a glob-style pattern with ? ‑ RedisCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with ?
should retrieve keys matching a glob-style pattern with [] ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with []
should retrieve keys matching a glob-style pattern with [] ‑ RedisCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with []
should retrieve keys matching a glob-style pattern with [^] ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with [^]
should retrieve keys matching a glob-style pattern with [^] ‑ RedisCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with [^]
should retrieve keys matching a glob-style pattern with [a-b] ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with [a-b]
should retrieve keys matching a glob-style pattern with [a-b] ‑ RedisCache Test Suite KEYS Test Suite should retrieve keys matching a glob-style pattern with [a-b]
should retrieve keys matching a pattern with escaped special characters ‑ LocalLRUCache Test Suite KEYS Test Suite should retrieve keys matching a pattern with escaped special characters
should retrieve keys matching a pattern with escaped special characters ‑ RedisCache Test Suite KEYS Test Suite should retrieve keys matching a pattern with escaped special characters
should retrieve keys matching pattern with ? ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve keys matching pattern with ?
should retrieve keys matching pattern with ? ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve keys matching pattern with ?
should retrieve keys matching pattern with [] ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve keys matching pattern with []
should retrieve keys matching pattern with [] ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve keys matching pattern with []
should retrieve keys matching pattern with [^] ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve keys matching pattern with [^]
should retrieve keys matching pattern with [^] ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve keys matching pattern with [^]
should retrieve keys matching pattern with [a-b] ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve keys matching pattern with [a-b]
should retrieve keys matching pattern with [a-b] ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve keys matching pattern with [a-b]
should retrieve keys matching pattern ‑ CacheService Test Suite Internal Cache Test Suite keys should retrieve keys matching pattern
should retrieve keys matching pattern ‑ CacheService Test Suite Shared Cache Test Suite keys should retrieve keys matching pattern
should retrieve range from internal cache in case of Redis error ‑ CacheService Test Suite Shared Cache Test Suite lRange should retrieve range from internal cache in case of Redis error
should retrieve range from internal cache ‑ CacheService Test Suite Internal Cache Test Suite lRange should retrieve range from internal cache
should retrieve range from shared cache ‑ CacheService Test Suite Shared Cache Test Suite lRange should retrieve range from shared cache
should retrieve range with negative index from internal cache ‑ CacheService Test Suite Internal Cache Test Suite lRange should retrieve range with negative index from internal cache
should retrieve range with negative index from shared cache ‑ CacheService Test Suite Shared Cache Test Suite lRange should retrieve range with negative index from shared cache
should return "" for empty string ‑ Formatters ASCIIToHex Function should return "" for empty string
should return "relay/" ‑ Web3 given npm_package_version=undefined are set should return "relay/"
should return "relay/1.0.0" ‑ Web3 given npm_package_version=1.0.0 are set should return "relay/1.0.0"
should return 0 for 0 input ‑ Formatters tinybarsToWeibars should return 0 for 0 input
should return 0 gas ‑ Utils addPercentageBufferToGasPrice zero input, 0 gas should return 0 gas
should return 0 if shared cache is enabled and client is disconnected ‑ CacheService Test Suite Shared Cache Test Suite getNumberOfRedisConnections should return 0 if shared cache is enabled and client is disconnected
should return 0 if shared cache is not enabled ‑ CacheService Test Suite Internal Cache Test Suite getNumberOfRedisConnections should return 0 if shared cache is not enabled
should return 0 ‑ Utilities unit tests getBatchRequestsMaxSize given WS_BATCH_REQUESTS_MAX_SIZE=0 are set should return 0
should return 0x0 for Nan input ‑ Formatters nanOrNumberTo0x should return 0x0 for Nan input
should return 0x0 nonce for block 0 consideration ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x0 nonce for block 0 consideration
should return 0x0 nonce for block 1 consideration ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x0 nonce for block 1 consideration
should return 0x0 nonce for earliest block with valid block ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x0 nonce for earliest block with valid block
should return 0x0 nonce for historical numerical block with no ethereum transactions found ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x0 nonce for historical numerical block with no ethereum transactions found
should return 0x0 nonce for no block consideration with not found acoount ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x0 nonce for no block consideration with not found acoount
should return 0x1 for pre-hip-729 contracts with nonce=null ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x1 for pre-hip-729 contracts with nonce=null
should return 0x1 nonce for historical numerical block with a single ethereum transactions found ‑ @ethGetTransactionCount eth_getTransactionCount spec should return 0x1 nonce for historical numerical block with a single ethereum transactions found
should return 1 if shared cache is enabled and client is reconnected ‑ CacheService Test Suite Shared Cache Test Suite getNumberOfRedisConnections should return 1 if shared cache is enabled and client is reconnected
should return 1 if shared cache is enabled ‑ CacheService Test Suite Shared Cache Test Suite getNumberOfRedisConnections should return 1 if shared cache is enabled
should return 1.19T gas ‑ Utils addPercentageBufferToGasPrice negative buffer -12.58%, 1.36T gas should return 1.19T gas
should return 1.39T gas ‑ Utils addPercentageBufferToGasPrice buffer 10%, 1.26T gas should return 1.39T gas
should return 1.5T gas ‑ Utils addPercentageBufferToGasPrice buffer 7%, 1.4T gas should return 1.5T gas
should return 100B gas ‑ Utils addPercentageBufferToGasPrice buffer 0%, 100B gas should return 100B gas
should return 20 ‑ Utilities unit tests getBatchRequestsMaxSize given WS_BATCH_REQUESTS_MAX_SIZE=undefined are set should return 20
should return 50 ‑ Utilities unit tests getBatchRequestsMaxSize given WS_BATCH_REQUESTS_MAX_SIZE=50 are set should return 50
should return 630B gas ‑ Utils addPercentageBufferToGasPrice buffer 12.25%, 560B gas should return 630B gas
should return 940B gas ‑ Utils addPercentageBufferToGasPrice negative buffer -6%, 1T gas should return 940B gas
should return NaN if inputs are invalid number ‑ Formatters trimPrecedingZeros should return NaN if inputs are invalid number
should return a computed hash if unable to retrieve EthereumHash from record due to contract revert ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should return a computed hash if unable to retrieve EthereumHash from record due to contract revert
should return a predefined GAS_LIMIT_TOO_HIGH instead of NUMERIC_FAULT as precheck exception ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should return a predefined GAS_LIMIT_TOO_HIGH instead of NUMERIC_FAULT as precheck exception
should return a valid JSON-RPC response with error ‑ jsonResp should return a valid JSON-RPC response with error
should return a valid JSON-RPC response with result ‑ jsonResp should return a valid JSON-RPC response with result
should return a valid match ‑ Formatters formatContractResult should return a valid match
should return a valid signature s value ‑ Formatters formatContractResult should return a valid signature s value
should return an empty set if there are no block hashes (e.g. 2 requests within 2 seconds) ‑ Filter API Test Suite eth_getFilterChanges should return an empty set if there are no block hashes (e.g. 2 requests within 2 seconds)
should return an empty set if there are no logs ‑ Filter API Test Suite eth_getFilterChanges should return an empty set if there are no logs
should return an empty string for a valid hex message with no content ‑ Formatters strip0x decodeErrorMessage should return an empty string for a valid hex message with no content
should return an empty string if input is an empty string ‑ Formatters strip0x should return an empty string if input is an empty string
should return an empty string if the message is an empty string ‑ Formatters strip0x decodeErrorMessage should return an empty string if the message is an empty string
should return an empty string if the message is undefined ‑ Formatters strip0x decodeErrorMessage should return an empty string if the message is undefined
should return an empty string when input is an empty string or undefined ‑ Formatters getFunctionSelector should return an empty string when input is an empty string or undefined
should return balance for latest block from cache ‑ @ethGetBalance using MirrorNode should return balance for latest block from cache
should return balance from consensus node ‑ @ethGetBalance using MirrorNode should return balance from consensus node
should return balance from mirror node with block hash passed as param the same as latest ‑ @ethGetBalance using MirrorNode should return balance from mirror node with block hash passed as param the same as latest
should return balance from mirror node with block hash passed as param, one behind latest ‑ @ethGetBalance using MirrorNode should return balance from mirror node with block hash passed as param, one behind latest
should return balance from mirror node with block number passed as param the same as latest ‑ @ethGetBalance using MirrorNode should return balance from mirror node with block number passed as param the same as latest
should return balance from mirror node with block number passed as param, one behind latest ‑ @ethGetBalance using MirrorNode should return balance from mirror node with block number passed as param, one behind latest
should return balance from mirror node ‑ @ethGetBalance using MirrorNode should return balance from mirror node
should return cached getTinyBarGasFee value ‑ SdkClient increaseCostAndRetryExecution should return cached getTinyBarGasFee value
should return cached value for mirror nodes that is not latest so will need to query mirror node ‑ @ethGetBalance using MirrorNode should return cached value for mirror nodes that is not latest so will need to query mirror node
should return cached value for mirror nodes ‑ @ethGetBalance using MirrorNode should return cached value for mirror nodes
should return correct formated transaction id ‑ Formatters formatTransactionId should return correct formated transaction id
should return correct formated transaction id ‑ Formatters formatTransactionIdWithoutQueryParams should return correct formated transaction id
should return default batch request max size when environment variable is not set ‑ utils.ts getBatchRequestsMaxSize given BATCH_REQUESTS_MAX_SIZE=undefined are set should return default batch request max size when environment variable is not set
should return empty result with invalid parameters in formatOpcodeResult ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set Invalid scenarios should return empty result with invalid parameters in formatOpcodeResult
should return empty string for custom error message without parameters ‑ Formatters strip0x decodeErrorMessage should return empty string for custom error message without parameters
should return empty string when we dont pass params ‑ Formatters decodeErrorMessage should return empty string when we dont pass params
should return expected hex formatted value ‑ Formatters ASCIIToHex Function should return expected hex formatted value
should return false for an address with a 0x value ‑ Formatters valid ethereum address should return false for an address with a 0x value
should return false for an address with a null value ‑ Formatters valid ethereum address should return false for an address with a null value
should return false for an address with an empty string ‑ Formatters valid ethereum address should return false for an address with an empty string
should return false for an address with an undefined value ‑ Formatters valid ethereum address should return false for an address with an undefined value
should return false for contract for non existing contract ‑ MirrorNodeClient isValidContract should return false for contract for non existing contract
should return false for empty string ‑ Formatters isHex Function should return false for empty string
should return false for invalid address ‑ Formatters valid ethereum address should return false for invalid address
should return false for string with invalid characters ‑ Formatters isHex Function should return false for string with invalid characters
should return false for string with only 0x prefix ‑ Formatters isHex Function should return false for string with only 0x prefix
should return false for string with spaces ‑ Formatters isHex Function should return false for string with spaces
should return false for string without 0x prefix ‑ Formatters isHex Function should return false for string without 0x prefix
should return false if amountSpent + estimatedTxFee is at the limit ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return false if amountSpent + estimatedTxFee is at the limit
should return false if amountSpent + estimatedTxFee is at the limit ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return false if amountSpent + estimatedTxFee is at the limit
should return false if amountSpent + estimatedTxFee is below the limit ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return false if amountSpent + estimatedTxFee is below the limit
should return false if amountSpent + estimatedTxFee is below the limit ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return false if amountSpent + estimatedTxFee is below the limit
should return false if amountSpent is just below the limit ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return false if amountSpent is just below the limit
should return false if amountSpent is just below the limit ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return false if amountSpent is just below the limit
should return false if evmAddress and ipAddress is empty string ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return false if evmAddress and ipAddress is empty string
should return false if filter does not exist, therefore is not deleted ‑ Filter API Test Suite eth_uninstallFilter should return false if filter does not exist, therefore is not deleted
should return false if ipAddress is null or empty ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return false if ipAddress is null or empty
should return false if shared cache is enabled and client is disconnected ‑ CacheService Test Suite Shared Cache Test Suite isRedisClientConnected should return false if shared cache is enabled and client is disconnected
should return false if shared cache is not enabled ‑ CacheService Test Suite Internal Cache Test Suite isRedisClientConnected should return false if shared cache is not enabled
should return false if the rate limiter is disabled by setting HBAR_RATE_LIMIT_TINYBAR to zero ‑ HBAR Rate Limit Service shouldLimit disable the rate limiter should return false if the rate limiter is disabled by setting HBAR_RATE_LIMIT_TINYBAR to zero
should return false when BATCH_REQUESTS_ENABLED is not set to true ‑ utils.ts getBatchRequestsEnabled given BATCH_REQUESTS_ENABLED=false are set should return false when BATCH_REQUESTS_ENABLED is not set to true
should return false when REQUEST_ID_IS_OPTIONAL is not set to true ‑ utils.ts getRequestIdIsOptional given REQUEST_ID_IS_OPTIONAL=false are set should return false when REQUEST_ID_IS_OPTIONAL is not set to true
should return false when disconnected ‑ RedisCache Test Suite Is Connected Test Suite should return false when disconnected
should return false when the object does not have the specified property ‑ utils.ts hasOwnProperty should return false when the object does not have the specified property
should return false when the remaining budget is greater than zero ‑ HBAR Rate Limit Service isTotalBudgetExceeded should return false when the remaining budget is greater than zero
should return false ‑ Utilities unit tests getMultipleAddressesEnabled given WS_MULTIPLE_ADDRESSES_ENABLED=false are set should return false
should return false ‑ Utilities unit tests getMultipleAddressesEnabled given WS_MULTIPLE_ADDRESSES_ENABLED=undefined are set should return false
should return false ‑ Utilities unit tests getWsBatchRequestsEnabled given WS_BATCH_REQUESTS_ENABLED=false are set should return false
should return gas price with buffer ‑ @ethGasPrice Gas Price spec @ethGasPrice @ethGasPrice different value for GAS_PRICE_PERCENTAGE_BUFFER env eth_gasPrice with GAS_PRICE_PERCENTAGE_BUFFER set to 10% should return gas price with buffer
should return gas price with buffer ‑ @ethGasPrice Gas Price spec @ethGasPrice @ethGasPrice different value for GAS_PRICE_PERCENTAGE_BUFFER env eth_gasPrice with GAS_PRICE_PERCENTAGE_BUFFER set to floating % that results in floating number for buffered gas price should return gas price with buffer
should return gas price without buffer ‑ @ethGasPrice Gas Price spec @ethGasPrice @ethGasPrice different value for GAS_PRICE_PERCENTAGE_BUFFER env should return gas price without buffer
should return hash from ContractResult mirror node api ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should return hash from ContractResult mirror node api
should return latest nonce for finalized block ‑ @ethGetTransactionCount eth_getTransactionCount spec should return latest nonce for finalized block
should return latest nonce for latest block ‑ @ethGetTransactionCount eth_getTransactionCount spec should return latest nonce for latest block
should return latest nonce for no block consideration but valid account ‑ @ethGetTransactionCount eth_getTransactionCount spec should return latest nonce for no block consideration but valid account
should return latest nonce for pending block ‑ @ethGetTransactionCount eth_getTransactionCount spec should return latest nonce for pending block
should return no blocks if the second request is for the same block ‑ Filter API Test Suite eth_getFilterChanges should return no blocks if the second request is for the same block
should return non cached value for not found contract ‑ @ethGetCode using MirrorNode eth_getCode should return non cached value for not found contract
should return nonce for request on historical numerical block ‑ @ethGetTransactionCount eth_getTransactionCount spec should return nonce for request on historical numerical block
should return nonce when block hash is passed ‑ @ethGetTransactionCount eth_getTransactionCount spec should return nonce when block hash is passed
should return null address with invalid parameters in resolveAddress ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set Invalid scenarios resolveAddress should return null address with invalid parameters in resolveAddress
should return null for empty hex ‑ Formatters toNullIfEmptyHex should return null for empty hex
should return null for null input ‑ Formatters toNullableBigNumber should return null for null input
should return null for nullable input ‑ Formatters nanOrNumberTo0x should return null for nullable input
should return null if neither evmAddress nor ipAddress is provided ‑ HBAR Rate Limit Service getSpendingPlan should return null if neither evmAddress nor ipAddress is provided
should return null if no spending plan is found for evmAddress ‑ HBAR Rate Limit Service getSpendingPlan should return null if no spending plan is found for evmAddress
should return null if no spending plan is found for ipAddress ‑ HBAR Rate Limit Service getSpendingPlan should return null if no spending plan is found for ipAddress
should return null if null is passed ‑ Formatters formatContractResult should return null if null is passed
should return null if null is passed ‑ Formatters tinybarsToWeibars should return null if null is passed
should return null on empty ‑ Formatters formatTransactionId should return null on empty
should return null on empty ‑ Formatters formatTransactionIdWithoutQueryParams should return null on empty
should return null ‑ Formatters formatTransactionId should return null
should return null ‑ Formatters formatTransactionIdWithoutQueryParams should return null
should return nullable fields ‑ Formatters formatContractResult should return nullable fields
should return original parameters for an unknown method ‑ Utilities unit tests resolveParams should return original parameters for an unknown method
should return passed address on notFound entity from the mirror node ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set Invalid scenarios resolveAddress should return passed address on notFound entity from the mirror node
should return redirect bytecode for HTS token ‑ @ethGetCode using MirrorNode eth_getCode should return redirect bytecode for HTS token
should return spending plan for evmAddress if evmAddress is provided ‑ HBAR Rate Limit Service getSpendingPlan should return spending plan for evmAddress if evmAddress is provided
should return spending plan for ipAddress if ipAddress is provided ‑ HBAR Rate Limit Service getSpendingPlan should return spending plan for ipAddress if ipAddress is provided
should return the batch request max size from environment variable ‑ utils.ts getBatchRequestsMaxSize given BATCH_REQUESTS_MAX_SIZE=150 are set should return the batch request max size from environment variable
should return the bytecode from SDK if Mirror Node returns 404 ‑ @ethGetCode using MirrorNode eth_getCode should return the bytecode from SDK if Mirror Node returns 404
should return the bytecode from SDK if Mirror Node returns empty runtime_bytecode ‑ @ethGetCode using MirrorNode eth_getCode should return the bytecode from SDK if Mirror Node returns empty runtime_bytecode
should return the correct eth implementation ‑ RelayImpl should return the correct eth implementation
should return the correct net implementation ‑ RelayImpl should return the correct net implementation
should return the correct status code ‑ SDKClientError should return the correct status code
should return the correct subscription implementation when enabled ‑ RelayImpl given SUBSCRIPTIONS_ENABLED=true are set should return the correct subscription implementation when enabled
should return the correct web3 implementation ‑ RelayImpl should return the correct web3 implementation
should return the current timestamp plus the limit duration ‑ HBAR Rate Limit Service getResetTimestamp should return the current timestamp plus the limit duration
should return the default limit duration when environment variable is not set ‑ utils.ts getLimitDuration given LIMIT_DURATION=undefined are set should return the default limit duration when environment variable is not set
should return the default rate limit from environment variable ‑ utils.ts getDefaultRateLimit given DEFAULT_RATE_LIMIT=250 are set should return the default rate limit from environment variable
should return the default rate limit when environment variable is not set ‑ utils.ts getDefaultRateLimit given DEFAULT_RATE_LIMIT=undefined are set should return the default rate limit when environment variable is not set
should return the first 8 characters of a valid hex string starting with "0x" ‑ Formatters getFunctionSelector should return the first 8 characters of a valid hex string starting with "0x"
should return the first 8 characters of a valid hex string without "0x" ‑ Formatters getFunctionSelector should return the first 8 characters of a valid hex string without "0x"
should return the hashes of latest blocks ‑ Filter API Test Suite eth_getFilterChanges should return the hashes of latest blocks
should return the limit duration from environment variable ‑ utils.ts getLimitDuration given LIMIT_DURATION=500 are set should return the limit duration from environment variable
should return the message as is if it does not start with 0x ‑ Formatters strip0x decodeErrorMessage should return the message as is if it does not start with 0x
should return the message of custom error with string parameter ‑ Formatters strip0x decodeErrorMessage should return the message of custom error with string parameter
should return the number of connections ‑ RedisCache Test Suite Number of Connections Test Suite should return the number of connections
should return the original params if method requires no special handling ‑ Utilities unit tests resolveParams should return the original params if method requires no special handling
should return the runtime_bytecode from the mirror node ‑ @ethGetCode using MirrorNode eth_getCode should return the runtime_bytecode from the mirror node
should return the same string if it does not start with "0x" ‑ Formatters strip0x should return the same string if it does not start with "0x"
should return the spending plan for the given evmAddress ‑ HBAR Rate Limit Service getSpendingPlanByEvmAddress should return the spending plan for the given evmAddress
should return the static bytecode for address(0x167) call ‑ @ethGetCode using MirrorNode eth_getCode should return the static bytecode for address(0x167) call
should return tomorrow at midnight ‑ HBAR Rate Limit Service getResetTimestamp given a limit duration that is 1 day should return tomorrow at midnight
should return true for a known gasPrice ‑ Formatters isHex Function should return true for a known gasPrice
should return true for mixed-case hexadecimal string ‑ Formatters isHex Function should return true for mixed-case hexadecimal string
should return true for valid address ‑ Formatters valid ethereum address should return true for valid address
should return true for valid long zero address ‑ Formatters valid ethereum address should return true for valid long zero address
should return true for valid lowercase hexadecimal string ‑ Formatters isHex Function should return true for valid lowercase hexadecimal string
should return true for valid uppercase hexadecimal string ‑ Formatters isHex Function should return true for valid uppercase hexadecimal string
should return true for valid zero address ‑ Formatters valid ethereum address should return true for valid zero address
should return true if amountSpent + estimatedTxFee is above the limit ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return true if amountSpent + estimatedTxFee is above the limit
should return true if amountSpent + estimatedTxFee is above the limit ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return true if amountSpent + estimatedTxFee is above the limit
should return true if amountSpent is exactly at the limit ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return true if amountSpent is exactly at the limit
should return true if amountSpent is exactly at the limit ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return true if amountSpent is exactly at the limit
should return true if amountSpent is just above the limit ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return true if amountSpent is just above the limit
should return true if amountSpent is just above the limit ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return true if amountSpent is just above the limit
should return true if filter is deleted ‑ Filter API Test Suite eth_uninstallFilter should return true if filter is deleted
should return true if shared cache is enabled and client is reconnected ‑ CacheService Test Suite Shared Cache Test Suite isRedisClientConnected should return true if shared cache is enabled and client is reconnected
should return true if shared cache is enabled ‑ CacheService Test Suite Shared Cache Test Suite isRedisClientConnected should return true if shared cache is enabled
should return true if the total budget is exceeded ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return true if the total budget is exceeded
should return true if the total budget is exceeded ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return true if the total budget is exceeded
should return true when BATCH_REQUESTS_ENABLED is set to true ‑ utils.ts getBatchRequestsEnabled given BATCH_REQUESTS_ENABLED=true are set should return true when BATCH_REQUESTS_ENABLED is set to true
should return true when REQUEST_ID_IS_OPTIONAL is set to true ‑ utils.ts getRequestIdIsOptional given REQUEST_ID_IS_OPTIONAL=true are set should return true when REQUEST_ID_IS_OPTIONAL is set to true
should return true when connected ‑ RedisCache Test Suite Is Connected Test Suite should return true when connected
should return true when remainingBudget < estimatedTxFee  ‑ HBAR Rate Limit Service shouldLimit based on evmAddress should return true when remainingBudget < estimatedTxFee 
should return true when remainingBudget < estimatedTxFee  ‑ HBAR Rate Limit Service shouldLimit based on ipAddress should return true when remainingBudget < estimatedTxFee 
should return true when the object has the specified property ‑ utils.ts hasOwnProperty should return true when the object has the specified property
should return true when the remaining budget is negative ‑ HBAR Rate Limit Service isTotalBudgetExceeded should return true when the remaining budget is negative
should return true when the remaining budget is zero ‑ HBAR Rate Limit Service isTotalBudgetExceeded should return true when the remaining budget is zero
should return true ‑ Utilities unit tests getMultipleAddressesEnabled given WS_MULTIPLE_ADDRESSES_ENABLED=true are set should return true
should return true ‑ Utilities unit tests getWsBatchRequestsEnabled given WS_BATCH_REQUESTS_ENABLED=true are set should return true
should return true ‑ Utilities unit tests getWsBatchRequestsEnabled given WS_BATCH_REQUESTS_ENABLED=undefined are set should return true
should return undefined for non-existing variable ‑ ConfigService tests should return undefined for non-existing variable
should return undefined if the rate limiter is disabled and addExpense is called ‑ HBAR Rate Limit Service shouldLimit disable the rate limiter should return undefined if the rate limiter is disabled and addExpense is called
should return undefined subscription implementation when not enabled ‑ RelayImpl given SUBSCRIPTIONS_ENABLED=false are set should return undefined subscription implementation when not enabled
should return valid for contract for existing contract ‑ MirrorNodeClient isValidContract should return valid for contract for existing contract
should return valid for contract from cache on additional calls ‑ MirrorNodeClient isValidContract should return valid for contract from cache on additional calls
should return valid hex ‑ Formatters ASCIIToHex Function should return valid hex
should return valid list of logs ‑ Filter API Test Suite eth_getFilterChanges should return valid list of logs
should return valid nonce for historical numerical block close to latest ‑ @ethGetTransactionCount eth_getTransactionCount spec should return valid nonce for historical numerical block close to latest
should return valid nonce for historical numerical block when contract result sender is not address ‑ @ethGetTransactionCount eth_getTransactionCount spec should return valid nonce for historical numerical block when contract result sender is not address
should return valid nonce for historical numerical block ‑ @ethGetTransactionCount eth_getTransactionCount spec should return valid nonce for historical numerical block
should return value for non-nullable input ‑ Formatters toNullIfEmptyHex should return value for non-nullable input
should save only new associations for EVM addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should save only new associations for EVM addresses
should save only new associations for EVM addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should save only new associations for EVM addresses
should save only new associations for EVM addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should save only new associations for EVM addresses
should save only new associations for EVM addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should save only new associations for EVM addresses
should save only new associations for IP addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should save only new associations for IP addresses
should save only new associations for IP addresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should save only new associations for IP addresses
should save only new associations for IP addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans positive scenarios should save only new associations for IP addresses
should save only new associations for IP addresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans positive scenarios should save only new associations for IP addresses
should send the response to the client connection ‑ Utilities unit tests sendToClient should send the response to the client connection
should set a new IP and method when first encountered ‑ RateLimit should set a new IP and method when first encountered
should set chainId from CHAIN_ID environment variable starting with 0x ‑ Net given CHAIN_ID=0x1a are set should set chainId from CHAIN_ID environment variable starting with 0x

should set chainId from CHAIN_ID environment variable ‑ Net given CHAIN_ID=123 are set should set chainId from CHAIN_ID environment variable
should set data as undefined if not provided ‑ RpcErrors JsonRpcError should set data as undefined if not provided
should set multiple key-value pairs in cache with TTL ‑ RedisCache Test Suite PipelineSet Test Suite should set multiple key-value pairs in cache with TTL
should set multiple key-value pairs in cache ‑ RedisCache Test Suite MultiSet Test Suite should set multiple key-value pairs in cache
should set multiple key-value pairs in cache ‑ RedisCache Test Suite PipelineSet Test Suite should set multiple key-value pairs in cache
should set server timeout from environment variable ‑ utils.ts setServerTimeout given SERVER_REQUEST_TIMEOUT_MS=30000 are set should set server timeout from environment variable
should set server timeout to default value when environment variable is not set ‑ utils.ts setServerTimeout given SERVER_REQUEST_TIMEOUT_MS=undefined are set should set server timeout to default value when environment variable is not set
should set status and validNetworkError if status is provided in error ‑ SDKClientError should set status and validNetworkError if status is provided in error
should set status to Unknown if status is not provided in error ‑ SDKClientError should set status to Unknown if status is not provided in error
should set the message, code, and data correctly ‑ RpcErrors JsonRpcError should set the message, code, and data correctly
should set the reset date properly ‑ HBAR Rate Limit Service should set the reset date properly
should set the reset date to the current timestamp plus the limit duration ‑ HBAR Rate Limit Service resetLimiter should set the reset date to the current timestamp plus the limit duration
should should perform estimateGas precheck ‑ @ethEstimateGas Estimate Gas spec should should perform estimateGas precheck
should skip adding value if it is missing and there is no default value set ‑ ValidationService tests typeCasting should skip adding value if it is missing and there is no default value set
should start polling ‑ Polling Poller should start polling
should stop polling ‑ Polling Poller should stop polling
should strip "0x" from the beginning of a string ‑ Formatters strip0x should strip "0x" from the beginning of a string
should successfully debug a transaction ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set should successfully debug a transaction
should terminate the websocket connection ‑ Utilities unit tests handleConnectionClose should terminate the websocket connection
should throw Error with unexpected exception if mirror node returns unexpected error ‑ MirrorNodeClient getAccountLatestEthereumTransactionsByTimestamp should throw Error with unexpected exception if mirror node returns unexpected error
should throw FILTER_NOT_FOUND for type=newBlock ‑ Filter API Test Suite eth_getFilterLogs should throw FILTER_NOT_FOUND for type=newBlock
should throw FILTER_NOT_FOUND for type=pendingTransaction ‑ Filter API Test Suite eth_getFilterLogs should throw FILTER_NOT_FOUND for type=pendingTransaction
should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=0x369ABF369ABF369ABF369ABF ‑ @ethGetCode using MirrorNode eth_getCode should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=0x369ABF369ABF369ABF369ABF
should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=0xhbar ‑ @ethGetCode using MirrorNode eth_getCode should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=0xhbar
should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=ethereum ‑ @ethGetCode using MirrorNode eth_getCode should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=ethereum
should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=hedera ‑ @ethGetCode using MirrorNode eth_getCode should throw INVALID_PARAMETER JsonRpcError with invalid blockParam=hedera
should throw UNSUPPORTED_METHOD for getFilterChanges ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=false are set should throw UNSUPPORTED_METHOD for getFilterChanges
should throw UNSUPPORTED_METHOD for getFilterChanges ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=undefined are set should throw UNSUPPORTED_METHOD for getFilterChanges
should throw UNSUPPORTED_METHOD for newFilter ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=false are set should throw UNSUPPORTED_METHOD for newFilter
should throw UNSUPPORTED_METHOD for newFilter ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=undefined are set should throw UNSUPPORTED_METHOD for newFilter
should throw UNSUPPORTED_METHOD for uninstallFilter ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=false are set should throw UNSUPPORTED_METHOD for uninstallFilter
should throw UNSUPPORTED_METHOD for uninstallFilter ‑ Filter API Test Suite all methods require a filter flag given FILTER_API_ENABLED=undefined are set should throw UNSUPPORTED_METHOD for uninstallFilter
should throw UNSUPPORTED_METHOD ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=false are set should throw UNSUPPORTED_METHOD
should throw UNSUPPORTED_METHOD ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=undefined are set should throw UNSUPPORTED_METHOD
should throw a MirrorNodeClientError if transaction record is not found when execute getTransactionRecordMetrics ‑ MirrorNodeClient getTransactionRecordMetrics should throw a MirrorNodeClientError if transaction record is not found when execute getTransactionRecordMetrics
should throw a TypeError for invalid error code type ‑ jsonResp should throw a TypeError for invalid error code type
should throw a TypeError for invalid error message type ‑ jsonResp should throw a TypeError for invalid error message type
should throw a TypeError for invalid id type ‑ jsonResp should throw a TypeError for invalid id type
should throw an SDKCLientError if transaction record is not found when execute getTransactionRecordMetrics ‑ SdkClient HBAR Limiter should throw an SDKCLientError if transaction record is not found when execute getTransactionRecordMetrics
should throw an error if configuration file is not a parsable JSON ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios given HBAR_SPENDING_PLANS_CONFIG=spendingPlansConfig.example.json are set should throw an error if configuration file is not a parsable JSON
should throw an error if configuration file is not a parsable JSON ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios given HBAR_SPENDING_PLANS_CONFIG=spendingPlansConfig.example.json are set should throw an error if configuration file is not a parsable JSON
should throw an error if configuration file is not a parsable JSON ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios given HBAR_SPENDING_PLANS_CONFIG=spendingPlansConfig.example.json are set should throw an error if configuration file is not a parsable JSON
should throw an error if configuration file is not a parsable JSON ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios given HBAR_SPENDING_PLANS_CONFIG=spendingPlansConfig.example.json are set should throw an error if configuration file is not a parsable JSON
should throw an error if no evmAddress is provided ‑ HBAR Rate Limit Service createBasicSpendingPlan should throw an error if no evmAddress is provided
should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses
should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses
should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses
should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with empty evmAddresses and ipAddresses
should throw an error if the configuration file has entry with invalid subscriptionTier ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with invalid subscriptionTier
should throw an error if the configuration file has entry with invalid subscriptionTier ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with invalid subscriptionTier
should throw an error if the configuration file has entry with invalid subscriptionTier ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with invalid subscriptionTier
should throw an error if the configuration file has entry with invalid subscriptionTier ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry with invalid subscriptionTier
should throw an error if the configuration file has entry without ID ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without ID
should throw an error if the configuration file has entry without ID ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without ID
should throw an error if the configuration file has entry without ID ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without ID
should throw an error if the configuration file has entry without ID ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without ID
should throw an error if the configuration file has entry without evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without evmAddresses and ipAddresses
should throw an error if the configuration file has entry without evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without evmAddresses and ipAddresses
should throw an error if the configuration file has entry without evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without evmAddresses and ipAddresses
should throw an error if the configuration file has entry without evmAddresses and ipAddresses ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without evmAddresses and ipAddresses
should throw an error if the configuration file has entry without name ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without name
should throw an error if the configuration file has entry without name ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without name
should throw an error if the configuration file has entry without name ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without name
should throw an error if the configuration file has entry without name ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without name
should throw an error if the configuration file has entry without subscriptionTier ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without subscriptionTier
should throw an error if the configuration file has entry without subscriptionTier ‑ HbarSpendingPlanConfigService using LRU cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without subscriptionTier
should throw an error if the configuration file has entry without subscriptionTier ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config file populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without subscriptionTier
should throw an error if the configuration file has entry without subscriptionTier ‑ HbarSpendingPlanConfigService using Redis cache and with a spending plan config variable populatePreconfiguredSpendingPlans negative scenarios should throw an error if the configuration file has entry without subscriptionTier
should throw an error when both error and result are provided ‑ jsonResp should throw an error when both error and result are provided
should throw an error when creating a ServerError with an invalid code ‑ RpcErrors ServerError should throw an error when creating a ServerError with an invalid code
should throw an error when neither result nor error is provided ‑ jsonResp should throw an error when neither result nor error is provided
should throw an error when the client is already connected ‑ RedisCache Test Suite Connect Test Suite should throw an error when the client is already connected
should throw an error when the client is closed ‑ RedisCache Test Suite Number of Connections Test Suite should throw an error when the client is closed
should throw an error when value is larger than the total supply of tinybars ‑ Formatters tinybarsToWeibars should throw an error when value is larger than the total supply of tinybars
should throw an error when value is smaller than 0 ‑ Formatters tinybarsToWeibars should throw an error when value is smaller than 0
should throw an exception if value is less than 1 tinybar ‑ Precheck value should throw an exception if value is less than 1 tinybar
should throw error for account historical numerical block tag with error on latest block ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw error for account historical numerical block tag with error on latest block
should throw error for account historical numerical block tag with missing block ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw error for account historical numerical block tag with missing block
should throw error for earliest block with invalid block ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw error for earliest block with invalid block
should throw error for earliest block with non 0 or 1 block ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw error for earliest block with non 0 or 1 block
should throw error for invalid filter type ‑ Filter API Test Suite eth_getFilterChanges should throw error for invalid filter type
should throw error for non-existing filters ‑ Filter API Test Suite eth_getFilterChanges should throw error for non-existing filters
should throw for -1 invalid block tag ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw for -1 invalid block tag
should throw for historical numerical block with a missing contracts results ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw for historical numerical block with a missing contracts results
should throw for invalid block tag ‑ @ethGetTransactionCount eth_getTransactionCount spec should throw for invalid block tag
should throw internal error if ContractResult from mirror node contains a null hash ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should throw internal error if ContractResult from mirror node contains a null hash
should throw internal error when transaction returned from mirror node is null ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should throw internal error when transaction returned from mirror node is null
should throw internal error when transactionID is invalid ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should throw internal error when transactionID is invalid
should throw invalid address error if mirror node returns 400 error status ‑ MirrorNodeClient getAccountLatestEthereumTransactionsByTimestamp should throw invalid address error if mirror node returns 400 error status
should throw precheck error for type=3 transactions ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should throw precheck error for type=3 transactions
should throw when env var is any non-parseable value and constant does not exist ‑ Formatters parseNumericEnvVar should throw when env var is any non-parseable value and constant does not exist
should throw when env var is any non-parseable value and constant is any non-parseable value ‑ Formatters parseNumericEnvVar should throw when env var is any non-parseable value and constant is any non-parseable value
should to cast boolean type ‑ ValidationService tests typeCasting should to cast boolean type
should to cast numeric type ‑ ValidationService tests typeCasting should to cast numeric type
should to cast string type ‑ ValidationService tests typeCasting should to cast string type
should trim all the unnecessary preceding 0s in a hex value ‑ Formatters trimPrecedingZeros should trim all the unnecessary preceding 0s in a hex value
should try to populate preconfigured spending plans ‑ RPC Server should try to populate preconfigured spending plans
should unsubscribe subscriptions ‑ Utilities unit tests handleConnectionClose should unsubscribe subscriptions
should update execution counter and list the correct data when eth_call is executed ‑ @ethCall Eth Call spec eth_call using consensus node should update execution counter and list the correct data when eth_call is executed
should update execution counter and list the correct data when eth_call is executed ‑ @ethCall Eth Call spec eth_call using mirror node should update execution counter and list the correct data when eth_call is executed
should update execution counter and list the correct data when eth_sendRawTransation is executed ‑ @ethSendRawTransaction eth_sendRawTransaction spec eth_sendRawTransaction should update execution counter and list the correct data when eth_sendRawTransation is executed
should update the connection duration histogram ‑ Utilities unit tests handleConnectionClose should update the connection duration histogram
should update the hbar limit counter when a method is called and the total budget is exceeded ‑ HBAR Rate Limit Service isTotalBudgetExceeded should update the hbar limit counter when a method is called and the total budget is exceeded
should use default value when env var is empty string ‑ Formatters parseNumericEnvVar should use default value when env var is empty string
should use default value when env var is non-numeric string ‑ Formatters parseNumericEnvVar should use default value when env var is non-numeric string
should use default value when env var is undefined ‑ Formatters parseNumericEnvVar should use default value when env var is undefined
should use specified value when env var is numeric string ‑ Formatters parseNumericEnvVar should use specified value when env var is numeric string
should verify that the server is running with the correct host and port ‑ RPC Server should verify that the server is running with the correct host and port
stops paginating when it reaches MAX_MIRROR_NODE_PAGINATION ‑ MirrorNodeClient getPaginatedResults stops paginating when it reaches MAX_MIRROR_NODE_PAGINATION
supports optionality of request id when configured ‑ RPC Server given REQUEST_ID_IS_OPTIONAL=true are set supports optionality of request id when configured
test case for non-existing transaction hash ‑ Debug API Test Suite debug_traceTransaction given DEBUG_API_ENABLED=true are set Invalid scenarios test case for non-existing transaction hash
the input is set with the encoded data for the data field ‑ @ethCall Eth Call spec eth_call precheck failures the input is set with the encoded data for the data field
three transactions in block with four emitted events ‑ ReceiptsRootUtils getRootHash three transactions in block with four emitted events
throws an error for input: "invalidType" ‑ Validator validates tracerType correctly throws an error for input: "invalidType"
throws an error for input: undefined ‑ Validator validates tracerType correctly throws an error for input: undefined
throws an error for input: {"disableStack":"invalid"} ‑ Validator validates opcodeLoggerConfig correctly throws an error for input: {"disableStack":"invalid"}
throws an error for input: {"disableStack":"invalid"} ‑ Validator validates tracerConfig correctly throws an error for input: {"disableStack":"invalid"}
throws an error for input: {"disableStorage":"invalid"} ‑ Validator validates opcodeLoggerConfig correctly throws an error for input: {"disableStorage":"invalid"}
throws an error for input: {"disableStorage":"invalid"} ‑ Validator validates tracerConfig correctly throws an error for input: {"disableStorage":"invalid"}
throws an error for input: {"enableMemory":"invalid"} ‑ Validator validates opcodeLoggerConfig correctly throws an error for input: {"enableMemory":"invalid"}
throws an error for input: {"enableMemory":"invalid"} ‑ Validator validates tracerConfig correctly throws an error for input: {"enableMemory":"invalid"}
throws an error for input: {"onlyTopCall":"invalid"} ‑ Validator validates callTracerConfig correctly throws an error for input: {"onlyTopCall":"invalid"}
throws an error for input: {"onlyTopCall":"invalid"} ‑ Validator validates tracerConfig correctly throws an error for input: {"onlyTopCall":"invalid"}
throws an error for input: {"tracer":"callTracer","tracerConfig":{"onlyTopCall":"invalid"}} ‑ Validator validates tracerConfigWrapper correctly throws an error for input: {"tracer":"callTracer","tracerConfig":{"onlyTopCall":"invalid"}}
throws an error for input: {"tracer":"invalid","tracerConfig":{}} ‑ Validator validates tracerConfigWrapper correctly throws an error for input: {"tracer":"invalid","tracerConfig":{}}
throws an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStack":"invalid"}} ‑ Validator validates tracerConfigWrapper correctly throws an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStack":"invalid"}}
throws an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStorage":"invalid"}} ‑ Validator validates tracerConfigWrapper correctly throws an error for input: {"tracer":"opcodeLogger","tracerConfig":{"disableStorage":"invalid"}}
throws an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":"invalid"}} ‑ Validator validates tracerConfigWrapper correctly throws an error for input: {"tracer":"opcodeLogger","tracerConfig":{"enableMemory":"invalid"}}
throws an error if 'address' is null ‑ Validator validates ethSubscribeLogsParams Object type correctly throws an error if 'address' is null
throws an error if 'topics' values are not 0x prefixed ‑ Validator validates ethSubscribeLogsParams Object type correctly throws an error if 'topics' values are not 0x prefixed
throws an error if 'topics' values are null ‑ Validator validates ethSubscribeLogsParams Object type correctly throws an error if 'topics' values are null
throws an error if Filter Object param contains unexpected param ‑ Validator Other error cases throws an error if Filter Object param contains unexpected param
throws an error if Transaction Object data param is null and isNullable is false ‑ Validator validates validateObject with transaction object throws an error if Transaction Object data param is null and isNullable is false
throws an error if address hash is smaller than 20bytes ‑ Validator validates Address type correctly throws an error if address hash is smaller than 20bytes
throws an error if address is NOT 0x prefixed ‑ Validator validates Address type correctly throws an error if address is NOT 0x prefixed
throws an error if address is larger than 20bytes ‑ Validator validates Address type correctly throws an error if address is larger than 20bytes
throws an error if address is other type ‑ Validator validates Address type correctly throws an error if address is other type
throws an error if address plan is not found ‑ EvmAddressHbarSpendingPlanRepository with shared cache findByAddress throws an error if address plan is not found
throws an error if address plan is not found ‑ EvmAddressHbarSpendingPlanRepository without shared cache findByAddress throws an error if address plan is not found
throws an error if address plan is not found ‑ IPAddressHbarSpendingPlanRepository with shared cache findByAddress throws an error if address plan is not found
throws an error if address plan is not found ‑ IPAddressHbarSpendingPlanRepository without shared cache findByAddress throws an error if address plan is not found
throws an error if block hash is NOT 0x prefixed ‑ Validator validates blockHash type correctly throws an error if block hash is NOT 0x prefixed
throws an error if block hash is larger than 32bytes ‑ Validator validates blockHash type correctly throws an error if block hash is larger than 32bytes
throws an error if block hash is other type ‑ Validator validates blockHash type correctly throws an error if block hash is other type
throws an error if block hash is smaller than 32bytes ‑ Validator validates blockHash type correctly throws an error if block hash is smaller than 32bytes
throws an error if both blockHash and fromBlock/toBlock are used ‑ Validator validates Filter Object type correctly throws an error if both blockHash and fromBlock/toBlock are used
throws an error if param is another type ‑ Validator validates boolean type correctly throws an error if param is another type
throws an error if param is other type of truthy or falsy value ‑ Validator validates boolean type correctly throws an error if param is other type of truthy or falsy value
throws an error if param is string ‑ Validator validates boolean type correctly throws an error if param is string
throws an error if plan is not active when adding to amountSpent ‑ HbarSpendingPlanRepository with shared cache addToAmountSpent throws an error if plan is not active when adding to amountSpent
throws an error if plan is not active when adding to amountSpent ‑ HbarSpendingPlanRepository without shared cache addToAmountSpent throws an error if plan is not active when adding to amountSpent
throws an error if plan is not found by ID ‑ HbarSpendingPlanRepository with shared cache findById throws an error if plan is not found by ID
throws an error if plan is not found by ID ‑ HbarSpendingPlanRepository with shared cache findByIdWithDetails throws an error if plan is not found by ID
throws an error if plan is not found by ID ‑ HbarSpendingPlanRepository without shared cache findById throws an error if plan is not found by ID
throws an error if plan is not found by ID ‑ HbarSpendingPlanRepository without shared cache findByIdWithDetails throws an error if plan is not found by ID
throws an error if plan not found by ID ‑ HbarSpendingPlanRepository with shared cache getSpendingHistory throws an error if plan not found by ID
throws an error if plan not found by ID ‑ HbarSpendingPlanRepository without shared cache getSpendingHistory throws an error if plan not found by ID
throws an error if the Filter Object properties are the wrong type ‑ Validator validates Filter Object type correctly throws an error if the Filter Object properties are the wrong type
throws an error if the Transaction Object properties are the wrong type ‑ Validator validates Transaction Object type correctly throws an error if the Transaction Object properties are the wrong type
throws an error if the param is not an Object ‑ Validator validates Filter Object type correctly throws an error if the param is not an Object
throws an error if the param is not an Object ‑ Validator validates Transaction Object type correctly throws an error if the param is not an Object
throws an error if the param is not an array ‑ Validator validates Array type correctly throws an error if the param is not an array
throws an error if topic hash is NOT 0x prefixed ‑ Validator validates topicHash type correctly throws an error if topic hash is NOT 0x prefixed
throws an error if topic hash is larger than 32bytes ‑ Validator validates topicHash type correctly throws an error if topic hash is larger than 32bytes
throws an error if topic hash is other type ‑ Validator validates topicHash type correctly throws an error if topic hash is other type
throws an error if topic hash is smaller than 32bytes ‑ Validator validates topicHash type correctly throws an error if topic hash is smaller than 32bytes
throws an error if topics contains hash larger than 32bytes ‑ Validator validates topics type correctly throws an error if topics contains hash larger than 32bytes
throws an error if topics contains hash smaller than 32bytes ‑ Validator validates topics type correctly throws an error if topics contains hash smaller than 32bytes
throws an error if topics contains hashes NOT 0x prefixed ‑ Validator validates topics type correctly throws an error if topics contains hashes NOT 0x prefixed
throws an error if topics is not array ‑ Validator validates topics type correctly throws an error if topics is not array
throws an error if transactionHash is NOT 0x prefixed ‑ Validator validates transactionHash type correctly throws an error if transactionHash is NOT 0x prefixed
throws an error if transactionHash is larger than 32bytes ‑ Validator validates transactionHash type correctly throws an error if transactionHash is larger than 32bytes
throws an error if transactionHash is other type ‑ Validator validates transactionHash type correctly throws an error if transactionHash is other type
throws an error if transactionHash is smaller than 32bytes ‑ Validator validates transactionHash type correctly throws an error if transactionHash is smaller than 32bytes
throws an error if validation type is missing ‑ Validator Other error cases throws an error if validation type is missing
throws an error if validation type is unknown ‑ Validator Other error cases throws an error if validation type is unknown
throws an error if validation type is wrong ‑ Validator Other error cases throws an error if validation type is wrong
throws an error when 400 is returned ‑ MirrorNodeClient handleError throws an error when 400 is returned
throws an error when 415 is returned ‑ MirrorNodeClient handleError throws an error when 415 is returned
throws an error when 429 is returned ‑ MirrorNodeClient handleError throws an error when 429 is returned
throws an error when 500 is returned ‑ MirrorNodeClient handleError throws an error when 500 is returned
throws an error when 501 is returned ‑ MirrorNodeClient handleError throws an error when 501 is returned
throws an error when 503 is returned ‑ MirrorNodeClient handleError throws an error when 503 is returned
throws error if block number contains invalid hex characters ‑ Validator validates blockNumber type correctly throws error if block number contains invalid hex characters
throws error if block number is NOT 0x prefixed hex ‑ Validator validates blockNumber type correctly throws error if block number is NOT 0x prefixed hex
throws error if block number is decimal ‑ Validator validates blockNumber type correctly throws error if block number is decimal
throws error if block number is greater than (2^53 – 1) ‑ Validator validates blockNumber type correctly throws error if block number is greater than (2^53 – 1)
throws error if block number is hex with leading zeros digits ‑ Validator validates blockNumber type correctly throws error if block number is hex with leading zeros digits
throws error if block number is not correct tag ‑ Validator validates blockNumber type correctly throws error if block number is not correct tag
throws error if block number is random type ‑ Validator validates blockNumber type correctly throws error if block number is random type
throws error if plan does not exist when checking if exists and active ‑ HbarSpendingPlanRepository with shared cache checkExistsAndActive throws error if plan does not exist when checking if exists and active
throws error if plan does not exist when checking if exists and active ‑ HbarSpendingPlanRepository without shared cache checkExistsAndActive throws error if plan does not exist when checking if exists and active
throws error if plan is not active when checking if exists and active ‑ HbarSpendingPlanRepository with shared cache checkExistsAndActive throws error if plan is not active when checking if exists and active
throws error if plan is not active when checking if exists and active ‑ HbarSpendingPlanRepository without shared cache checkExistsAndActive throws error if plan is not active when checking if exists and active
throws error if plan not found when adding to amountSpent ‑ HbarSpendingPlanRepository with shared cache addToAmountSpent throws error if plan not found when adding to amountSpent
throws error if plan not found when adding to amountSpent ‑ HbarSpendingPlanRepository without shared cache addToAmountSpent throws error if plan not found when adding to amountSpent
throws error if plan not found when adding to spending history ‑ HbarSpendingPlanRepository with shared cache addAmountToSpendingHistory throws error if plan not found when adding to spending history
throws error if plan not found when adding to spending history ‑ HbarSpendingPlanRepository without shared cache addAmountToSpendingHistory throws error if plan not found when adding to spending history
to field is not a contract or token ‑ @ethCall Eth Call spec eth_call precheck failures to field is not a contract or token
two transactions in block with three emitted events ‑ ReceiptsRootUtils getRootHash two transactions in block with three emitted events
valid receipt on cache match ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests valid receipt on cache match
valid receipt on match should hit cache ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests valid receipt on match should hit cache
valid receipt on match ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests valid receipt on match
valid receipt with evm address on match ‑ @ethGetTransactionReceipt eth_getTransactionReceipt tests valid receipt with evm address on match
validates Block param is non valid block hash ‑ RPC Server Validator eth_call validates Block param is non valid block hash
validates Block param is non valid block hex ‑ RPC Server Validator eth_call validates Block param is non valid block hex
validates Block param is non valid block number ‑ RPC Server Validator eth_call validates Block param is non valid block number
validates Block param is non valid tag ‑ RPC Server Validator eth_call validates Block param is non valid tag
validates Block param is valid block hex ‑ RPC Server Validator eth_estimateGas validates Block param is valid block hex
validates Block param is valid tag ‑ RPC Server Validator eth_estimateGas validates Block param is valid tag
validates Transaction `data` param is hex ‑ RPC Server Validator eth_call validates Transaction `data` param is hex
validates Transaction `data` param is hex ‑ RPC Server Validator eth_estimateGas validates Transaction `data` param is hex
validates Transaction `from` param is address ‑ RPC Server Validator eth_call validates Transaction `from` param is address
validates Transaction `from` param is address ‑ RPC Server Validator eth_estimateGas validates Transaction `from` param is address
validates Transaction `gasPrice` param is hex ‑ RPC Server Validator eth_call validates Transaction `gasPrice` param is hex
validates Transaction `gasPrice` param is hex ‑ RPC Server Validator eth_estimateGas validates Transaction `gasPrice` param is hex
validates Transaction `gas` param is hex ‑ RPC Server Validator eth_call validates Transaction `gas` param is hex
validates Transaction `gas` param is hex ‑ RPC Server Validator eth_estimateGas validates Transaction `gas` param is hex
validates Transaction `maxFeePerGas` param is hex ‑ RPC Server Validator eth_call validates Transaction `maxFeePerGas` param is hex
validates Transaction `maxFeePerGas` param is hex ‑ RPC Server Validator eth_estimateGas validates Transaction `maxFeePerGas` param is hex
validates Transaction `maxPriorityFeePerGas` param is hex ‑ RPC Server Validator eth_call validates Transaction `maxPriorityFeePerGas` param is hex
validates Transaction `maxPriorityFeePerGas` param is hex ‑ RPC Server Validator eth_estimateGas validates Transaction `maxPriorityFeePerGas` param is hex
validates Transaction `to` param is address ‑ RPC Server Validator eth_call validates Transaction `to` param is address
validates Transaction `to` param is address ‑ RPC Server Validator eth_estimateGas validates Transaction `to` param is address
validates Transaction `value` param is hex ‑ RPC Server Validator eth_call validates Transaction `value` param is hex
validates Transaction `value` param is hex ‑ RPC Server Validator eth_estimateGas validates Transaction `value` param is hex
validates address filter ‑ RPC Server Validator eth_getLogs validates address filter
validates blockHash filter ‑ RPC Server Validator eth_getLogs validates blockHash filter
validates enforcement of request id ‑ RPC Server validates enforcement of request id
validates fromBlock and toBlock ‑ Filter API Test Suite eth_newFilter validates fromBlock and toBlock
validates parameter 0 exists ‑ RPC Server Validator eth_call validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_estimateGas validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_feeHistory validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getBalance validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getBlockByHash validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getBlockByNumber validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getBlockTransactionCountByHash validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getBlockTransactionCountByNumber validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getCode validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getStorageAt validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getTransactionByBlockHashAndIndex validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getTransactionByBlockNumberAndIndex validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getTransactionByHash validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_getTransactionCount validates parameter 0 exists
validates parameter 0 exists ‑ RPC Server Validator eth_sendRawTransaction validates parameter 0 exists
validates parameter 0 is Filter Object ‑ RPC Server Validator eth_getLogs validates parameter 0 is Filter Object
validates parameter 0 is TransactionObject ‑ RPC Server Validator eth_call validates parameter 0 is TransactionObject
validates parameter 0 is TransactionObject ‑ RPC Server Validator eth_estimateGas validates parameter 0 is TransactionObject
validates parameter 0 is a block hash ‑ RPC Server Validator eth_getBlockByHash validates parameter 0 is a block hash
validates parameter 0 is address ‑ RPC Server Validator eth_getCode validates parameter 0 is address
validates parameter 0 is an address ‑ RPC Server Validator eth_getTransactionCount validates parameter 0 is an address
validates parameter 0 is block hash ‑ RPC Server Validator eth_getBlockTransactionCountByHash validates parameter 0 is block hash
validates parameter 0 is block hash ‑ RPC Server Validator eth_getTransactionByHash validates parameter 0 is block hash
validates parameter 0 is block number ‑ RPC Server Validator eth_getBlockTransactionCountByNumber validates parameter 0 is block number
validates parameter 0 is of type Address ‑ RPC Server Validator eth_getBalance validates parameter 0 is of type Address
validates parameter 0 is valid address ‑ RPC Server Validator eth_getStorageAt validates parameter 0 is valid address
validates parameter 0 is valid block hash ‑ RPC Server Validator eth_getTransactionByBlockHashAndIndex validates parameter 0 is valid block hash
validates parameter 0 is valid block number ‑ RPC Server Validator eth_getBlockByNumber validates parameter 0 is valid block number
validates parameter 0 is valid block number ‑ RPC Server Validator eth_getTransactionByBlockNumberAndIndex validates parameter 0 is valid block number
validates parameter 0 is valid block tag ‑ RPC Server Validator eth_getBlockByNumber validates parameter 0 is valid block tag
validates parameter 0 is valid block tag ‑ RPC Server Validator eth_getBlockTransactionCountByNumber validates parameter 0 is valid block tag
validates parameter 0 is valid block tag ‑ RPC Server Validator eth_getTransactionByBlockNumberAndIndex validates parameter 0 is valid block tag
validates parameter 0 is valid hex ‑ RPC Server Validator eth_sendRawTransaction validates parameter 0 is valid hex
validates parameter 1 exists ‑ RPC Server Validator eth_feeHistory validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getBalance validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getBlockByHash validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getBlockByNumber validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getCode validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getStorageAt validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getTransactionByBlockHashAndIndex validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getTransactionByBlockNumberAndIndex validates parameter 1 exists
validates parameter 1 exists ‑ RPC Server Validator eth_getTransactionCount validates parameter 1 exists
validates parameter 1 is a valid block number ‑ RPC Server Validator eth_getTransactionCount validates parameter 1 is a valid block number
validates parameter 1 is a valid block tag ‑ RPC Server Validator eth_getTransactionCount validates parameter 1 is a valid block tag
validates parameter 1 is boolean ‑ RPC Server Validator eth_getBlockByHash validates parameter 1 is boolean
validates parameter 1 is boolean ‑ RPC Server Validator eth_getBlockByNumber validates parameter 1 is boolean
validates parameter 1 is valid block number ‑ RPC Server Validator eth_getBalance validates parameter 1 is valid block number
validates parameter 1 is valid block number ‑ RPC Server Validator eth_getCode validates parameter 1 is valid block number
validates parameter 1 is valid block tag ‑ RPC Server Validator eth_getBalance validates parameter 1 is valid block tag
validates parameter 1 is valid block tag ‑ RPC Server Validator eth_getCode validates parameter 1 is valid block tag
validates parameter 1 is valid hex ‑ RPC Server Validator eth_getStorageAt validates parameter 1 is valid hex
validates parameter 1 is valid hex ‑ RPC Server Validator eth_getTransactionByBlockHashAndIndex validates parameter 1 is valid hex
validates parameter 1 is valid hex ‑ RPC Server Validator eth_getTransactionByBlockNumberAndIndex validates parameter 1 is valid hex
validates parameter 2 is array ‑ RPC Server Validator eth_feeHistory validates parameter 2 is array
validates parameter 2 is valid block number ‑ RPC Server Validator eth_getStorageAt validates parameter 2 is valid block number
validates parameter 2 is valid block tag ‑ RPC Server Validator eth_getStorageAt validates parameter 2 is valid block tag
validates parameter Filter Object does not contain both block hash and fromBlock/toBlock ‑ RPC Server Validator eth_getLogs validates parameter Filter Object does not contain both block hash and fromBlock/toBlock
validates the openrpc document ‑ Open RPC Specification validates the openrpc document
validates toBlock filter ‑ RPC Server Validator eth_getLogs validates toBlock filter
validates topics filter is array of array of topic hashes ‑ RPC Server Validator eth_getLogs validates topics filter is array of array of topic hashes
validates topics filter is array of topic hashes ‑ RPC Server Validator eth_getLogs validates topics filter is array of topic hashes
validates topics filter is array ‑ RPC Server Validator eth_getLogs validates topics filter is array
verify cache LRU nature ‑ LocalLRUCache Test Suite verify cache management verify cache LRU nature
verify cache size ‑ LocalLRUCache Test Suite verify cache management verify cache size
verify cache ttl nature ‑ LocalLRUCache Test Suite verify cache management verify cache ttl nature
when fromBlock > toBlock ‑ @ethGetLogs using MirrorNode when fromBlock > toBlock
when subscribing should return subId and poller should add(tag) ‑ subscriptionController when subscribing should return subId and poller should add(tag)
with block tag ‑ @ethGetLogs using MirrorNode with block tag
with non-existing fromBlock filter ‑ @ethGetLogs using MirrorNode with non-existing fromBlock filter
with non-existing toBlock filter ‑ @ethGetLogs using MirrorNode with non-existing toBlock filter
with null topics filter ‑ @ethGetLogs using MirrorNode with null topics filter
with only toBlock ‑ @ethGetLogs using MirrorNode with only toBlock
with topics and blocks filter ‑ @ethGetLogs using MirrorNode with topics and blocks filter
with topics filter ‑ @ethGetLogs using MirrorNode with topics filter
with valid fromBlock && toBlock filter ‑ @ethGetLogs using MirrorNode with valid fromBlock && toBlock filter
works when there are several pages ‑ MirrorNodeClient getPaginatedResults works when there are several pages
works when there is only 1 page ‑ MirrorNodeClient getPaginatedResults works when there is only 1 page