target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Ignore @Test public void testCODECOPY_2() { program = getProgram("605E60076000396000605f556014600054601e60205463abcddcba6040545b51602001" + "600a5254516040016014525451606001601e5254516080016028525460a05254601660" + "4860003960166000f26000603f556103e75660005460005360200235602054"); String m_expected_1 = "6000605F556014600054601E60205463ABCDDCBA6040545B51602001600A5254516040016" + "014525451606001601E5254516080016028525460A0525460166048600039" + "60166000F26000603F556103E756600054600053602002356020540000"; vm.step(program); vm.step(program); vm.step(program); vm.step(program); long gas = program.getResult().getGasUsed(); assertEquals(m_expected_1, ByteUtil.toHexString(program.getMemory()).toUpperCase()); assertEquals(10, gas); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Ignore @Test public void testCODECOPY_3() { program = getProgram("605E60076000396000605f556014600054601e60205463abcddcba6040545b51602001" + "600a5254516040016014525451606001601e5254516080016028525460a0525460166048600" + "03960166000f26000603f556103e75660005460005360200235"); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertEquals(10, program.getResult().getGasUsed()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Ignore @Test public void testCODECOPY_4() { program = getProgram("605E60076000396000605f556014600054601e60205463abcddcba6040545b51602001600a5254" + "516040016014525451606001601e5254516080016028525460a052546016604860003960166000f260006" + "03f556103e756600054600053602002351234"); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertEquals(10, program.getResult().getGasUsed()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void getBlockByNumberBlockWithUncles() { World world = new World(); Web3Impl web3 = createWeb3(world); Block genesis = world.getBlockChain().getBestBlock(); Block block1 = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()) .difficulty(20) .parent(genesis) .build(); block1.setBitcoinMergedMiningHeader(new byte[]{0x01}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(block1)); Block block1b = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()) .difficulty(10) .parent(genesis) .build(); block1b.setBitcoinMergedMiningHeader(new byte[]{0x02}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(block1b)); Block block1c = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()) .difficulty(10) .parent(genesis) .build(); block1c.setBitcoinMergedMiningHeader(new byte[]{0x03}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(block1c)); ArrayList<BlockHeader> uncles = new ArrayList<>(); uncles.add(block1b.getHeader()); uncles.add(block1c.getHeader()); Block block2 = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()) .difficulty(10) .parent(block1) .uncles(uncles) .build(); block2.setBitcoinMergedMiningHeader(new byte[]{0x04}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(block2)); String block1HashString = "0x" + block1.getHash(); String block1bHashString = "0x" + block1b.getHash(); String block1cHashString = "0x" + block1c.getHash(); String block2HashString = "0x" + block2.getHash(); BlockResultDTO result = web3.eth_getBlockByNumber("0x02", false); Assert.assertEquals(block2HashString, result.getHash()); Assert.assertEquals(block1HashString, result.getParentHash()); Assert.assertTrue(result.getUncles().contains(block1bHashString)); Assert.assertTrue(result.getUncles().contains(block1cHashString)); Assert.assertEquals(TypeConverter.toQuantityJsonHex(30), result.getCumulativeDifficulty()); }
|
@Override public BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects) { BlockResultDTO s = null; try { s = web3InformationRetriever.getBlock(bnOrId) .map(b -> getBlockResult(b, fullTransactionObjects)) .orElse(null); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getBlockByNumber({}, {}): {}", bnOrId, fullTransactionObjects, s); } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects) { BlockResultDTO s = null; try { s = web3InformationRetriever.getBlock(bnOrId) .map(b -> getBlockResult(b, fullTransactionObjects)) .orElse(null); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getBlockByNumber({}, {}): {}", bnOrId, fullTransactionObjects, s); } } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects) { BlockResultDTO s = null; try { s = web3InformationRetriever.getBlock(bnOrId) .map(b -> getBlockResult(b, fullTransactionObjects)) .orElse(null); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getBlockByNumber({}, {}): {}", bnOrId, fullTransactionObjects, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects) { BlockResultDTO s = null; try { s = web3InformationRetriever.getBlock(bnOrId) .map(b -> getBlockResult(b, fullTransactionObjects)) .orElse(null); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getBlockByNumber({}, {}): {}", bnOrId, fullTransactionObjects, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects) { BlockResultDTO s = null; try { s = web3InformationRetriever.getBlock(bnOrId) .map(b -> getBlockResult(b, fullTransactionObjects)) .orElse(null); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getBlockByNumber({}, {}): {}", bnOrId, fullTransactionObjects, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void testCODECOPY_5() { program = getProgram("611234600054615566602054607060006020396000605f556014600054601e6020546" + "3abcddcba6040545b51602001600a5254516040016014525451606001601e5254516080016028525460a05" + "2546016604860003960166000f26000603f556103e756600054600053602002351234"); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertFalse(program.isStopped()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = StackTooSmallException.class) public void testCODECOPY_6() { program = getProgram("605E6007396000605f556014600054601e60205463abcddcba604054" + "5b51602001600a5254516040016014525451606001601e5254516080016028525460a" + "052546016604860003960166000f26000603f556103e756600054600053602002351234"); try { vm.step(program); vm.step(program); vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testEXTCODECOPY_1() { program = getProgram("60036007600073471FD3AD3E9EEADEEC4608B92D16CE6B500704CC3C123456"); String m_expected_1 = "6000600000000000000000000000000000000000000000000000000000000000"; vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertEquals(m_expected_1, ByteUtil.toHexString(program.getMemory()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testEXTCODECOPY_2() { program = getProgram("603E6007600073471FD3AD3E9EEADEEC4608B92D16CE6B500704CC3C6000605f556014"+ "600054601e60205463abcddcba6040545b51602001600a5254516040016014525451606001601e52545160"+ "80016028525460a052546016604860003960166000f26000603f556103e75660005460005360200235602054"); String m_expected_1 = "6000605F556014600054601E60205463ABCDDCBA6040545B5160200" + "1600A5254516040016014525451606001601E5254516080016028525460A0525460160000"; vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertEquals(m_expected_1, ByteUtil.toHexString(program.getMemory()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testEXTCODECOPY_3() { program = getProgram("605E6007600073471FD3AD3E9EEADEEC4608B92D16CE6B500704CC3C60" + "00605f556014600054601e60205463abcddcba6040545b51602001600a525451604001601452545160" + "6001601e5254516080016028525460a052546016604860003960166000f26000603f556103e75660005460005360200235"); String m_expected_1 = "6000605F556014600054601E60205463ABCDDCBA6040545B51602001600A5254516040016014" + "525451606001601E5254516080016028525460A052546016604860003" + "960166000F26000603F556103E756600054600053602002350000000000"; vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertEquals(m_expected_1, ByteUtil.toHexString(program.getMemory()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testEXTCODECOPY_4() { program = getProgram("611234600054615566602054603E6000602073471FD3AD3E9EEADEEC4608B9" + "2D16CE6B500704CC3C6000605f556014600054601e60205463abcddcba6040545b51602001600a5" + "254516040016014525451606001601e5254516080016028525460a0525460166" + "04860003960166000f26000603f556103e756600054600053602002351234"); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); vm.step(program); assertFalse(program.isStopped()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = StackTooSmallException.class) public void testEXTCODECOPY_5() { program = getProgram("605E600773471FD3AD3E9EEADEEC4608B92D16CE6B500704CC3C"); try { vm.step(program); vm.step(program); vm.step(program); vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testCODESIZE_1() { program = getProgram("385E60076000396000605f556014600054601e60205463abcddcba6040545b51602" + "001600a5254516040016014525451606001601e5254516080016028525460a05254601660486" + "0003960166000f26000603f556103e75660005460005360200235"); String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000062"; vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Ignore @Test public void testEXTCODESIZE_1() { program = getProgram("73471FD3AD3E9EEADEEC4608B92D16CE6B500704CC395E60076000396000605f55" + "6014600054601e60205463abcddcba6040545b51602001600a5254516040016014525451606001" + "601e5254516080016028525460a052546016604860003960166000f26000603f556103e75660005460005360200235"); String s_expected_1 = "000000000000000000000000471FD3AD3E9EEADEEC4608B92D16CE6B500704CC"; vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testMOD_1() { program = getProgram("6003600406"); String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000001"; vm.step(program); vm.step(program); vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void getUncleByBlockHashAndIndexBlockWithUncles() { World world = new World(); Web3Impl web3 = createWeb3(world); Block genesis = world.getBlockChain().getBestBlock(); Block blockA = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockA.setBitcoinMergedMiningHeader(new byte[]{0x01}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockA)); Block blockB = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockB.setBitcoinMergedMiningHeader(new byte[]{0x02}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockB)); Block blockC = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockC.setBitcoinMergedMiningHeader(new byte[]{0x03}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockC)); Block blockD = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(100).parent(blockA).build(); blockD.setBitcoinMergedMiningHeader(new byte[]{0x04}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockD)); List<BlockHeader> blockEUncles = Arrays.asList(blockB.getHeader(), blockC.getHeader()); Block blockE = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockA).uncles(blockEUncles).build(); blockE.setBitcoinMergedMiningHeader(new byte[]{0x05}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockE)); List<BlockHeader> blockFUncles = Arrays.asList(blockE.getHeader()); Block blockF = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockD).uncles(blockFUncles).build(); blockF.setBitcoinMergedMiningHeader(new byte[]{0x06}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockF)); String blockFhash = "0x" + blockF.getHash(); String blockEhash = "0x" + blockE.getHash(); String blockBhash = "0x" + blockB.getHash(); String blockChash = "0x" + blockC.getHash(); BlockResultDTO result = web3.eth_getUncleByBlockHashAndIndex(blockFhash, "0x00"); Assert.assertEquals(blockEhash, result.getHash()); Assert.assertEquals(2, result.getUncles().size()); Assert.assertTrue(result.getUncles().contains(blockBhash)); Assert.assertTrue(result.getUncles().contains(blockChash)); Assert.assertEquals(TypeConverter.toQuantityJsonHex(30), result.getCumulativeDifficulty()); }
|
@Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void testMOD_2() { program = getProgram("61012C6101F406"); String s_expected_1 = "00000000000000000000000000000000000000000000000000000000000000C8"; vm.step(program); vm.step(program); vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testMOD_3() { program = getProgram("6004600206"); String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000002"; vm.step(program); vm.step(program); vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = StackTooSmallException.class) public void testMOD_4() { program = getProgram("600406"); try { vm.step(program); vm.step(program); vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testSMOD_1() { program = getProgram("6003600407"); String s_expected_1 = "0000000000000000000000000000000000000000000000000000000000000001"; vm.step(program); vm.step(program); vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testSMOD_2() { program = getProgram("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE2" + "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + "07"); String s_expected_1 = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC"; vm.step(program); vm.step(program); vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void testSMOD_3() { program = getProgram("7F000000000000000000000000000000000000000000000000000000000000001E" + "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" + "07"); String s_expected_1 = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC"; vm.step(program); vm.step(program); vm.step(program); DataWord item1 = program.stackPop(); assertEquals(s_expected_1, ByteUtil.toHexString(item1.getData()).toUpperCase()); }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = StackTooSmallException.class) public void testSMOD_4() { program = getProgram("7F000000000000000000000000000000000000000000000000000000000000001E" + "07"); try { vm.step(program); vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = Program.IllegalOperationException.class) public void testScriptVersion0() { program = getProgram("FC"); try { vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = Program.IllegalOperationException.class) public void testScriptVersion1() { program = getProgram("FC000000" + "FC"); try { vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test(expected = Program.IllegalOperationException.class) public void testScriptVersion2() { program = getProgram( "FC010100" + "FC" ); try { vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void getUncleByBlockHashAndIndexBlockWithUnclesCorrespondingToAnUnknownBlock() { World world = new World(); Account acc1 = new AccountBuilder(world).name("acc1").balance(Coin.valueOf(10000)).build(); Web3Impl web3 = createWeb3(world); Block genesis = world.getBlockChain().getBestBlock(); Block blockA = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockA.setBitcoinMergedMiningHeader(new byte[]{0x01}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockA)); Block blockB = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockB.setBitcoinMergedMiningHeader(new byte[]{0x02}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockB)); Block blockC = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockC.setBitcoinMergedMiningHeader(new byte[]{0x03}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockC)); Block blockD = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(100).parent(blockA).build(); blockD.setBitcoinMergedMiningHeader(new byte[]{0x04}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockD)); Transaction tx = new TransactionBuilder() .sender(acc1) .gasLimit(BigInteger.valueOf(100000)) .gasPrice(BigInteger.ONE) .build(); List<Transaction> txs = new ArrayList<>(); txs.add(tx); List<BlockHeader> blockEUncles = Arrays.asList(blockB.getHeader(), blockC.getHeader()); Block blockE = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockA).uncles(blockEUncles) .transactions(txs).buildWithoutExecution(); blockE.setBitcoinMergedMiningHeader(new byte[]{0x05}); Assert.assertEquals(1, blockE.getTransactionsList().size()); Assert.assertFalse(Arrays.equals(blockC.getTxTrieRoot(), blockE.getTxTrieRoot())); List<BlockHeader> blockFUncles = Arrays.asList(blockE.getHeader()); Block blockF = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockD).uncles(blockFUncles).build(); blockF.setBitcoinMergedMiningHeader(new byte[]{0x06}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockF)); String blockFhash = "0x" + blockF.getHash(); String blockEhash = "0x" + blockE.getHash(); BlockResultDTO result = web3.eth_getUncleByBlockHashAndIndex(blockFhash, "0x00"); Assert.assertEquals(blockEhash, result.getHash()); Assert.assertEquals(0, result.getUncles().size()); Assert.assertEquals(0, result.getTransactions().size()); Assert.assertEquals("0x" + ByteUtil.toHexString(blockE.getTxTrieRoot()), result.getTransactionsRoot()); }
|
@Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx) { BlockResultDTO s = null; try { Block block = blockchain.getBlockByHash(stringHexToByteArray(blockHash)); if (block == null) { return null; } s = getUncleResultDTO(uncleIdx, block); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockHashAndIndex({}, {}): {}", blockHash, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void testScriptVersion3() { program = getProgram( "FC01010A" + "0102030405060708090A" + "00" ); try { vm.step(program); } finally { assertTrue(program.isStopped()); } }
|
public void step(Program aprogram) { steps(aprogram,1); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
VM { public void step(Program aprogram) { steps(aprogram,1); } VM(VmConfig vmConfig, PrecompiledContracts precompiledContracts); void step(Program aprogram); int getVmCounter(); void resetVmCounter(); static long limitedAddToMaxLong(long left, long right); void steps(Program aprogram, long steps); void initDebugData(); void play(Program program); static void setVmHook(VMHook vmHook); }
|
@Test public void subscribeToNewHeads() { Channel channel = mock(Channel.class); EthSubscribeNewHeadsParams params = mock(EthSubscribeNewHeadsParams.class); SubscriptionId subscriptionId = emitter.visit(params, channel); assertThat(subscriptionId, notNullValue()); verify(newHeads).subscribe(subscriptionId, channel); }
|
@Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void subscribeToLogs() { Channel channel = mock(Channel.class); EthSubscribeLogsParams params = mock(EthSubscribeLogsParams.class); SubscriptionId subscriptionId = emitter.visit(params, channel); assertThat(subscriptionId, notNullValue()); verify(logs).subscribe(subscriptionId, channel, params); }
|
@Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { @Override public SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel) { SubscriptionId subscriptionId = new SubscriptionId(); blockHeader.subscribe(subscriptionId, channel); return subscriptionId; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void unsubscribeUnsuccessfully() { SubscriptionId subscriptionId = mock(SubscriptionId.class); boolean unsubscribed = emitter.unsubscribe(subscriptionId); assertThat(unsubscribed, is(false)); verify(newHeads).unsubscribe(subscriptionId); verify(logs).unsubscribe(subscriptionId); }
|
public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void unsubscribeSuccessfullyFromNewHeads() { SubscriptionId subscriptionId = mock(SubscriptionId.class); when(newHeads.unsubscribe(subscriptionId)).thenReturn(true); boolean unsubscribed = emitter.unsubscribe(subscriptionId); assertThat(unsubscribed, is(true)); verify(newHeads).unsubscribe(subscriptionId); verify(logs).unsubscribe(subscriptionId); }
|
public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void unsubscribeSuccessfullyFromLogs() { SubscriptionId subscriptionId = mock(SubscriptionId.class); when(logs.unsubscribe(subscriptionId)).thenReturn(true); boolean unsubscribed = emitter.unsubscribe(subscriptionId); assertThat(unsubscribed, is(true)); verify(newHeads).unsubscribe(subscriptionId); verify(logs).unsubscribe(subscriptionId); }
|
public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void unsubscribeChannel() { Channel channel = mock(Channel.class); emitter.unsubscribe(channel); verify(newHeads).unsubscribe(channel); verify(logs).unsubscribe(channel); }
|
public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
EthSubscriptionNotificationEmitter implements EthSubscribeParamsVisitor { public boolean unsubscribe(SubscriptionId subscriptionId) { boolean unsubscribedBlockHeader = blockHeader.unsubscribe(subscriptionId); boolean unsubscribedLogs = logs.unsubscribe(subscriptionId); return unsubscribedBlockHeader || unsubscribedLogs; } EthSubscriptionNotificationEmitter(
BlockHeaderNotificationEmitter blockHeader,
LogsNotificationEmitter logs); @Override SubscriptionId visit(EthSubscribeNewHeadsParams params, Channel channel); @Override SubscriptionId visit(EthSubscribeLogsParams params, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void txpool_content_basic() throws IOException { JsonNode node = txPoolModule.content(); checkFieldIsObject(node,"pending"); checkFieldIsObject(node,"queued"); }
|
@Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_inspect_basic() throws IOException { JsonNode node = txPoolModule.inspect(); checkFieldIsObject(node,"pending"); checkFieldIsObject(node,"queued"); }
|
@Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_status_basic() throws IOException { JsonNode node = txPoolModule.status(); checkFieldIsNumber(node,"pending"); checkFieldIsNumber(node,"queued"); }
|
@Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void getUncleByBlockNumberAndIndexBlockWithUncles() { World world = new World(); Web3Impl web3 = createWeb3(world); Block genesis = world.getBlockChain().getBestBlock(); Block blockA = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockA.setBitcoinMergedMiningHeader(new byte[]{0x01}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockA)); Block blockB = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockB.setBitcoinMergedMiningHeader(new byte[]{0x02}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockB)); Block blockC = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockC.setBitcoinMergedMiningHeader(new byte[]{0x03}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockC)); Block blockD = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(100).parent(blockA).build(); blockD.setBitcoinMergedMiningHeader(new byte[]{0x04}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockD)); List<BlockHeader> blockEUncles = Arrays.asList(blockB.getHeader(), blockC.getHeader()); Block blockE = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockA).uncles(blockEUncles).build(); blockE.setBitcoinMergedMiningHeader(new byte[]{0x05}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockE)); List<BlockHeader> blockFUncles = Arrays.asList(blockE.getHeader()); Block blockF = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockD).uncles(blockFUncles).build(); blockF.setBitcoinMergedMiningHeader(new byte[]{0x06}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockF)); String blockEhash = "0x" + blockE.getHash(); String blockBhash = "0x" + blockB.getHash(); String blockChash = "0x" + blockC.getHash(); BlockResultDTO result = web3.eth_getUncleByBlockNumberAndIndex("0x03", "0x00"); Assert.assertEquals(blockEhash, result.getHash()); Assert.assertEquals(2, result.getUncles().size()); Assert.assertTrue(result.getUncles().contains(blockBhash)); Assert.assertTrue(result.getUncles().contains(blockChash)); Assert.assertEquals(TypeConverter.toQuantityJsonHex(30), result.getCumulativeDifficulty()); }
|
@Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void txpool_content_oneTx() throws Exception { Transaction tx = createSampleTransaction(); when(transactionPool.getPendingTransactions()).thenReturn(Collections.singletonList(tx)); JsonNode node = txPoolModule.content(); checkFieldIsEmpty(node, "queued"); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode senderNode = checkFieldIsObject(pendingNode, tx.getSender().toString()); JsonNode nonceNode = checkFieldIsArray(senderNode, tx.getNonceAsInteger().toString()); nonceNode.elements().forEachRemaining(item -> assertFullTransaction(tx, item)); }
|
@Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_inspect_oneTx() throws Exception { Transaction tx = createSampleTransaction(); when(transactionPool.getPendingTransactions()).thenReturn(Collections.singletonList(tx)); JsonNode node = txPoolModule.inspect(); checkFieldIsEmpty(node, "queued"); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode senderNode = checkFieldIsObject(pendingNode, tx.getSender().toString()); JsonNode nonceNode = checkFieldIsArray(senderNode, tx.getNonceAsInteger().toString()); nonceNode.elements().forEachRemaining(item -> assertSummaryTransaction(tx, item)); }
|
@Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_content_sameNonce() throws Exception { Transaction tx1 = createSampleTransaction(); Transaction tx2 = createSampleTransaction(); Transaction tx3 = createSampleTransaction(); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3); when(transactionPool.getPendingTransactions()).thenReturn(transactions); JsonNode node = txPoolModule.content(); checkFieldIsEmpty(node, "queued"); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode senderNode = checkFieldIsObject(pendingNode, tx1.getSender().toString()); JsonNode nonceNode = checkFieldIsArray(senderNode, tx1.getNonceAsInteger().toString()); int i = 0; for (Iterator<JsonNode> iter = nonceNode.elements(); iter.hasNext();){ JsonNode item = iter.next(); assertFullTransaction(transactions.get(i), item); i++; } }
|
@Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_inspect_sameNonce() throws Exception { Transaction tx1 = createSampleTransaction(); Transaction tx2 = createSampleTransaction(); Transaction tx3 = createSampleTransaction(); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3); when(transactionPool.getPendingTransactions()).thenReturn(transactions); JsonNode node = txPoolModule.inspect(); checkFieldIsEmpty(node, "queued"); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode senderNode = checkFieldIsObject(pendingNode, tx1.getSender().toString()); JsonNode nonceNode = checkFieldIsArray(senderNode, tx1.getNonceAsInteger().toString()); int i = 0; for (Iterator<JsonNode> iter = nonceNode.elements(); iter.hasNext();){ JsonNode item = iter.next(); assertSummaryTransaction(transactions.get(i), item); i++; } }
|
@Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_content_sameSender() throws Exception { Transaction tx1 = createSampleTransaction(0, 1, 1, 0); Transaction tx2 = createSampleTransaction(0, 2, 1, 1); Transaction tx3 = createSampleTransaction(0, 3, 1, 2); Transaction tx4 = createSampleTransaction(1, 3, 1, 0); Transaction tx5 = createSampleTransaction(1, 3, 1, 1); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3, tx4, tx5); List<Transaction> txs = Arrays.asList(tx4, tx5); when(transactionPool.getPendingTransactions()).thenReturn(transactions); when(transactionPool.getQueuedTransactions()).thenReturn(txs); JsonNode node = txPoolModule.content(); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode queuedNode = checkFieldIsObject(node, "queued"); checkGroupedTransactions(transactions, pendingNode, this::assertFullTransaction); checkGroupedTransactions(txs, queuedNode, this::assertFullTransaction); }
|
@Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_inspect_sameSender() throws Exception { Transaction tx1 = createSampleTransaction(0, 1, 1, 0); Transaction tx2 = createSampleTransaction(0, 2, 1, 1); Transaction tx3 = createSampleTransaction(0, 3, 1, 2); Transaction tx4 = createSampleTransaction(1, 3, 1, 0); Transaction tx5 = createSampleTransaction(1, 3, 1, 1); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3, tx4, tx5); List<Transaction> txs = Arrays.asList(tx4, tx5); when(transactionPool.getPendingTransactions()).thenReturn(transactions); when(transactionPool.getQueuedTransactions()).thenReturn(txs); JsonNode node = txPoolModule.inspect(); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode queuedNode = checkFieldIsObject(node, "queued"); checkGroupedTransactions(transactions, pendingNode, this::assertSummaryTransaction); checkGroupedTransactions(txs, queuedNode, this::assertSummaryTransaction); }
|
@Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_content_manyTxs() throws Exception { Transaction tx1 = createSampleTransaction(0, 1, 1, 0); Transaction tx2 = createSampleTransaction(0, 2, 1, 0); Transaction tx3 = createSampleTransaction(0, 3, 1, 0); Transaction tx4 = createSampleTransaction(1, 3, 1, 0); Transaction tx5 = createSampleTransaction(1, 3, 1, 1); Transaction tx6 = createSampleTransaction(1, 3, 1, 2); Transaction tx7 = createSampleTransaction(2, 3, 1, 0); Transaction tx8 = createSampleTransaction(2, 3, 1, 1); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3, tx4, tx5); List<Transaction> txs = Arrays.asList(tx7, tx8, tx6); when(transactionPool.getPendingTransactions()).thenReturn(transactions); when(transactionPool.getQueuedTransactions()).thenReturn(txs); JsonNode node = txPoolModule.content(); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode queuedNode = checkFieldIsObject(node, "queued"); checkGroupedTransactions(transactions, pendingNode, this::assertFullTransaction); checkGroupedTransactions(txs, queuedNode, this::assertFullTransaction); }
|
@Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode content() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::fullSerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::fullSerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_inspect_manyTxs() throws Exception { Transaction tx1 = createSampleTransaction(0, 1, 1, 0); Transaction tx2 = createSampleTransaction(0, 2, 1, 0); Transaction tx3 = createSampleTransaction(0, 3, 1, 0); Transaction tx4 = createSampleTransaction(1, 3, 1, 0); Transaction tx5 = createSampleTransaction(1, 3, 1, 1); Transaction tx6 = createSampleTransaction(1, 3, 1, 2); Transaction tx7 = createSampleTransaction(2, 3, 1, 0); Transaction tx8 = createSampleTransaction(2, 3, 1, 1); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3, tx4, tx5); List<Transaction> txs = Arrays.asList(tx7, tx8, tx6); when(transactionPool.getPendingTransactions()).thenReturn(transactions); when(transactionPool.getQueuedTransactions()).thenReturn(txs); JsonNode node = txPoolModule.inspect(); JsonNode pendingNode = checkFieldIsObject(node, "pending"); JsonNode queuedNode = checkFieldIsObject(node, "queued"); checkGroupedTransactions(transactions, pendingNode, this::assertSummaryTransaction); checkGroupedTransactions(txs, queuedNode, this::assertSummaryTransaction); }
|
@Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode inspect() { Map<String, JsonNode> contentProps = new HashMap<>(); Map<RskAddress, Map<BigInteger, List<Transaction>>> pendingGrouped = groupTransactions(transactionPool.getPendingTransactions()); Map<RskAddress, Map<BigInteger, List<Transaction>>> queuedGrouped = groupTransactions(transactionPool.getQueuedTransactions()); contentProps.put(PENDING, serializeTransactions(pendingGrouped, this::summarySerializer)); contentProps.put(QUEUED, serializeTransactions(queuedGrouped, this::summarySerializer)); JsonNode node = jsonNodeFactory.objectNode().setAll(contentProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_status_oneTx() throws Exception { Transaction tx = createSampleTransaction(); when(transactionPool.getPendingTransactions()).thenReturn(Collections.singletonList(tx)); JsonNode node = txPoolModule.status(); JsonNode queuedNode = checkFieldIsNumber(node, "queued"); JsonNode pendingNode = checkFieldIsNumber(node, "pending"); Assert.assertEquals(0, queuedNode.asInt()); Assert.assertEquals(1, pendingNode.asInt()); }
|
@Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void txpool_status_manyPending() throws Exception { Transaction tx1 = createSampleTransaction(); Transaction tx2 = createSampleTransaction(); Transaction tx3 = createSampleTransaction(); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3); when(transactionPool.getPendingTransactions()).thenReturn(transactions); JsonNode node = txPoolModule.status(); JsonNode queuedNode = checkFieldIsNumber(node, "queued"); JsonNode pendingNode = checkFieldIsNumber(node, "pending"); Assert.assertEquals(0, queuedNode.asInt()); Assert.assertEquals(transactions.size(), pendingNode.asInt()); }
|
@Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void getUncleByBlockNumberAndIndexBlockWithUnclesCorrespondingToAnUnknownBlock() { World world = new World(); Account acc1 = new AccountBuilder(world).name("acc1").balance(Coin.valueOf(10000)).build(); Web3Impl web3 = createWeb3(world); Block genesis = world.getBlockChain().getBestBlock(); Block blockA = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockA.setBitcoinMergedMiningHeader(new byte[]{0x01}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockA)); Block blockB = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockB.setBitcoinMergedMiningHeader(new byte[]{0x02}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockB)); Block blockC = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(genesis).build(); blockC.setBitcoinMergedMiningHeader(new byte[]{0x03}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_NOT_BEST, world.getBlockChain().tryToConnect(blockC)); Block blockD = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(100).parent(blockA).build(); blockD.setBitcoinMergedMiningHeader(new byte[]{0x04}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockD)); Transaction tx = new TransactionBuilder() .sender(acc1) .gasLimit(BigInteger.valueOf(100000)) .gasPrice(BigInteger.ONE) .build(); List<Transaction> txs = new ArrayList<>(); txs.add(tx); List<BlockHeader> blockEUncles = Arrays.asList(blockB.getHeader(), blockC.getHeader()); Block blockE = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockA).uncles(blockEUncles) .transactions(txs).buildWithoutExecution(); blockE.setBitcoinMergedMiningHeader(new byte[]{0x05}); Assert.assertEquals(1, blockE.getTransactionsList().size()); Assert.assertFalse(Arrays.equals(blockC.getTxTrieRoot(), blockE.getTxTrieRoot())); List<BlockHeader> blockFUncles = Arrays.asList(blockE.getHeader()); Block blockF = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()) .trieStore(world.getTrieStore()).difficulty(10).parent(blockD).uncles(blockFUncles).build(); blockF.setBitcoinMergedMiningHeader(new byte[]{0x06}); org.junit.Assert.assertEquals(ImportResult.IMPORTED_BEST, world.getBlockChain().tryToConnect(blockF)); String blockEhash = "0x" + blockE.getHash(); BlockResultDTO result = web3.eth_getUncleByBlockNumberAndIndex("0x" + blockF.getNumber(), "0x00"); Assert.assertEquals(blockEhash, result.getHash()); Assert.assertEquals(0, result.getUncles().size()); Assert.assertEquals(0, result.getTransactions().size()); Assert.assertEquals("0x" + ByteUtil.toHexString(blockE.getTxTrieRoot()), result.getTransactionsRoot()); }
|
@Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx) { BlockResultDTO s = null; try { Optional<Block> block = web3InformationRetriever.getBlock(blockId); if (!block.isPresent()) { return null; } s = getUncleResultDTO(uncleIdx, block.get()); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_getUncleByBlockNumberAndIndex({}, {}): {}", blockId, uncleIdx, s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void getToAddressWhenValueIsNull() throws Exception { Web3.CallArguments args = new Web3.CallArguments(); CallArgumentsToByteArray byteArrayArgs = new CallArgumentsToByteArray(args); Assert.assertNull(byteArrayArgs.getToAddress()); }
|
public byte[] getToAddress() { byte[] toAddress = null; if (args.to != null) { toAddress = stringHexToByteArray(args.to); } return toAddress; }
|
CallArgumentsToByteArray { public byte[] getToAddress() { byte[] toAddress = null; if (args.to != null) { toAddress = stringHexToByteArray(args.to); } return toAddress; } }
|
CallArgumentsToByteArray { public byte[] getToAddress() { byte[] toAddress = null; if (args.to != null) { toAddress = stringHexToByteArray(args.to); } return toAddress; } CallArgumentsToByteArray(Web3.CallArguments args); }
|
CallArgumentsToByteArray { public byte[] getToAddress() { byte[] toAddress = null; if (args.to != null) { toAddress = stringHexToByteArray(args.to); } return toAddress; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }
|
CallArgumentsToByteArray { public byte[] getToAddress() { byte[] toAddress = null; if (args.to != null) { toAddress = stringHexToByteArray(args.to); } return toAddress; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }
|
@Test public void txpool_status_manyTxs() throws Exception { Transaction tx1 = createSampleTransaction(); Transaction tx2 = createSampleTransaction(); Transaction tx3 = createSampleTransaction(); Transaction tx4 = createSampleTransaction(); List<Transaction> transactions = Arrays.asList(tx1, tx2, tx3); List<Transaction> txs = Arrays.asList(tx1, tx4); when(transactionPool.getPendingTransactions()).thenReturn(transactions); when(transactionPool.getQueuedTransactions()).thenReturn(txs); JsonNode node = txPoolModule.status(); JsonNode queuedNode = checkFieldIsNumber(node, "queued"); JsonNode pendingNode = checkFieldIsNumber(node, "pending"); Assert.assertEquals(txs.size(), queuedNode.asInt()); Assert.assertEquals(transactions.size(), pendingNode.asInt()); }
|
@Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); }
|
TxPoolModuleImpl implements TxPoolModule { @Override public JsonNode status() { Map<String, JsonNode> txProps = new HashMap<>(); txProps.put(PENDING, jsonNodeFactory.numberNode(transactionPool.getPendingTransactions().size())); txProps.put(QUEUED, jsonNodeFactory.numberNode(transactionPool.getQueuedTransactions().size())); JsonNode node = jsonNodeFactory.objectNode().setAll(txProps); return node; } TxPoolModuleImpl(TransactionPool transactionPool); @Override JsonNode content(); @Override JsonNode inspect(); @Override JsonNode status(); static final String PENDING; static final String QUEUED; }
|
@Test public void debug_wireProtocolQueueSize_basic() throws IOException { String result = debugModule.wireProtocolQueueSize(); try { TypeConverter.JSonHexToLong(result); } catch (NumberFormatException e) { Assert.fail("This method is not returning a 0x Long"); } }
|
@Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_wireProtocolQueueSize_value() throws IOException { when(messageHandler.getMessageQueueSize()).thenReturn(5L); String result = debugModule.wireProtocolQueueSize(); try { long value = TypeConverter.JSonHexToLong(result); Assert.assertEquals(5L, value); } catch (NumberFormatException e) { Assert.fail("This method is not returning a 0x Long"); } }
|
@Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public String wireProtocolQueueSize() { long n = messageHandler.getMessageQueueSize(); return TypeConverter.toQuantityJsonHex(n); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_traceTransaction_retrieveUnknownTransactionAsNull() throws Exception { byte[] hash = stringHexToByteArray("0x00"); when(receiptStore.getAll(hash)).thenReturn(Collections.emptyList()); when(receiptStore.getInMainChain(hash, blockStore)).thenReturn(null); JsonNode result = debugModule.traceTransaction("0x00", null); Assert.assertNull(result); }
|
@Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_traceTransaction_retrieveSimpleContractCreationTrace() throws Exception { DslParser parser = DslParser.fromResource("dsl/contracts01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); DebugModuleImpl debugModule = new DebugModuleImpl(world.getBlockStore(), receiptStore, messageHandler, world.getBlockExecutor()); JsonNode result = debugModule.traceTransaction(transaction.getHash().toJsonString(), null); Assert.assertNotNull(result); Assert.assertTrue(result.isObject()); ObjectNode oResult = (ObjectNode) result; Assert.assertTrue(oResult.get("error").textValue().isEmpty()); Assert.assertTrue(oResult.get("result").isTextual()); JsonNode structLogs = oResult.get("structLogs"); Assert.assertTrue(structLogs.isArray()); Assert.assertTrue(structLogs.size() > 0); }
|
@Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_traceTransaction_retrieveEmptyContractCreationTrace() throws Exception { DslParser parser = DslParser.fromResource("dsl/contracts09.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); DebugModuleImpl debugModule = new DebugModuleImpl(world.getBlockStore(), receiptStore, messageHandler, world.getBlockExecutor()); JsonNode result = debugModule.traceTransaction(transaction.getHash().toJsonString(), null); Assert.assertNotNull(result); Assert.assertTrue(result.isObject()); ObjectNode oResult = (ObjectNode) result; Assert.assertTrue(oResult.get("error").isNull()); Assert.assertTrue(oResult.get("result").isNull()); JsonNode structLogs = oResult.get("structLogs"); Assert.assertNull(structLogs); }
|
@Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_traceTransaction_retrieveSimpleContractInvocationTrace() throws Exception { DslParser parser = DslParser.fromResource("dsl/contracts02.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx02"); DebugModuleImpl debugModule = new DebugModuleImpl(world.getBlockStore(), receiptStore, messageHandler, world.getBlockExecutor()); JsonNode result = debugModule.traceTransaction(transaction.getHash().toJsonString(), null); Assert.assertNotNull(result); Assert.assertTrue(result.isObject()); ObjectNode oResult = (ObjectNode) result; Assert.assertTrue(oResult.get("error").textValue().isEmpty()); Assert.assertTrue(oResult.get("result").textValue().isEmpty()); JsonNode structLogs = oResult.get("structLogs"); Assert.assertTrue(structLogs.isArray()); Assert.assertTrue(structLogs.size() > 0); }
|
@Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_traceTransaction_retrieveSimpleAccountTransfer() throws Exception { DslParser parser = DslParser.fromResource("dsl/transfers01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); DebugModuleImpl debugModule = new DebugModuleImpl(world.getBlockStore(), receiptStore, messageHandler, world.getBlockExecutor()); JsonNode result = debugModule.traceTransaction(transaction.getHash().toJsonString(), null); Assert.assertNotNull(result); Assert.assertTrue(result.isObject()); ObjectNode oResult = (ObjectNode) result; Assert.assertTrue(oResult.get("error").isNull()); Assert.assertTrue(oResult.get("result").isNull()); JsonNode structLogs = oResult.get("structLogs"); Assert.assertNull(structLogs); }
|
@Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void debug_traceTransaction_retrieveSimpleAccountTransferWithTraceOptions() throws Exception { DslParser parser = DslParser.fromResource("dsl/transfers01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); DebugModuleImpl debugModule = new DebugModuleImpl(world.getBlockStore(), receiptStore, messageHandler, world.getBlockExecutor()); JsonNode resultWithNoOptions = debugModule.traceTransaction(transaction.getHash().toJsonString(), null); JsonNode resultWithEmptyOptions = debugModule.traceTransaction(transaction.getHash().toJsonString(), Collections.emptyMap()); Assert.assertEquals(resultWithNoOptions, resultWithEmptyOptions); JsonNode resultWithNonEmptyOptions = debugModule.traceTransaction(transaction.getHash().toJsonString(), Collections.singletonMap("disableStorage", "true")); Assert.assertEquals(resultWithNoOptions, resultWithNonEmptyOptions); }
|
@Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
DebugModuleImpl implements DebugModule { @Override public JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions) throws Exception { logger.trace("debug_traceTransaction({}, {})", transactionHash, traceOptions); if (traceOptions != null && !traceOptions.isEmpty()) { logger.warn("Received {} trace options. For now trace options are being ignored", traceOptions); } byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = receiptStore.getInMainChain(hash, blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = blockStore.getBlockByHash(txInfo.getBlockHash()); Block parent = blockStore.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); blockExecutor.traceBlock(programTraceProcessor, 0, block, parent.getHeader(), false, false); return programTraceProcessor.getProgramTraceAsJsonNode(tx.getHash()); } DebugModuleImpl(
BlockStore blockStore,
ReceiptStore receiptStore,
MessageHandler messageHandler,
BlockExecutor blockExecutor); @Override String wireProtocolQueueSize(); @Override JsonNode traceTransaction(String transactionHash, Map<String, String> traceOptions); }
|
@Test public void callSmokeTest() { Web3.CallArguments args = new Web3.CallArguments(); BlockResult blockResult = mock(BlockResult.class); Block block = mock(Block.class); ExecutionBlockRetriever retriever = mock(ExecutionBlockRetriever.class); when(retriever.getExecutionBlock_workaround("latest")) .thenReturn(blockResult); when(blockResult.getBlock()).thenReturn(block); byte[] hreturn = TypeConverter.stringToByteArray("hello"); ProgramResult executorResult = mock(ProgramResult.class); when(executorResult.getHReturn()) .thenReturn(hreturn); ReversibleTransactionExecutor executor = mock(ReversibleTransactionExecutor.class); when(executor.executeTransaction(eq(blockResult.getBlock()), any(), any(), any(), any(), any(), any(), any())) .thenReturn(executorResult); EthModule eth = new EthModule( null, anyByte(), null, null, executor, retriever, null, null, null, new BridgeSupportFactory( null, null, null)); String result = eth.call(args, "latest"); assertThat(result, is(TypeConverter.toJsonHex(hreturn))); }
|
public String call(Web3.CallArguments args, String bnOrId) { String s = null; try { BlockResult blockResult = executionBlockRetriever.getExecutionBlock_workaround(bnOrId); ProgramResult res; if (blockResult.getFinalState() != null) { res = callConstant_workaround(args, blockResult); } else { res = callConstant(args, blockResult.getBlock()); } if (res.isRevert()) { throw RskJsonRpcRequestException.transactionRevertedExecutionError(); } return s = toJsonHex(res.getHReturn()); } finally { LOGGER.debug("eth_call(): {}", s); } }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String call(Web3.CallArguments args, String bnOrId) { String s = null; try { BlockResult blockResult = executionBlockRetriever.getExecutionBlock_workaround(bnOrId); ProgramResult res; if (blockResult.getFinalState() != null) { res = callConstant_workaround(args, blockResult); } else { res = callConstant(args, blockResult.getBlock()); } if (res.isRevert()) { throw RskJsonRpcRequestException.transactionRevertedExecutionError(); } return s = toJsonHex(res.getHReturn()); } finally { LOGGER.debug("eth_call(): {}", s); } } }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String call(Web3.CallArguments args, String bnOrId) { String s = null; try { BlockResult blockResult = executionBlockRetriever.getExecutionBlock_workaround(bnOrId); ProgramResult res; if (blockResult.getFinalState() != null) { res = callConstant_workaround(args, blockResult); } else { res = callConstant(args, blockResult.getBlock()); } if (res.isRevert()) { throw RskJsonRpcRequestException.transactionRevertedExecutionError(); } return s = toJsonHex(res.getHReturn()); } finally { LOGGER.debug("eth_call(): {}", s); } } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String call(Web3.CallArguments args, String bnOrId) { String s = null; try { BlockResult blockResult = executionBlockRetriever.getExecutionBlock_workaround(bnOrId); ProgramResult res; if (blockResult.getFinalState() != null) { res = callConstant_workaround(args, blockResult); } else { res = callConstant(args, blockResult.getBlock()); } if (res.isRevert()) { throw RskJsonRpcRequestException.transactionRevertedExecutionError(); } return s = toJsonHex(res.getHReturn()); } finally { LOGGER.debug("eth_call(): {}", s); } } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); @Override String[] accounts(); Map<String, Object> bridgeState(); String call(Web3.CallArguments args, String bnOrId); String estimateGas(Web3.CallArguments args); @Override String sendTransaction(Web3.CallArguments args); @Override String sendRawTransaction(String rawData); @Override String sign(String addr, String data); String chainId(); String getCode(String address, String blockId); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String call(Web3.CallArguments args, String bnOrId) { String s = null; try { BlockResult blockResult = executionBlockRetriever.getExecutionBlock_workaround(bnOrId); ProgramResult res; if (blockResult.getFinalState() != null) { res = callConstant_workaround(args, blockResult); } else { res = callConstant(args, blockResult.getBlock()); } if (res.isRevert()) { throw RskJsonRpcRequestException.transactionRevertedExecutionError(); } return s = toJsonHex(res.getHReturn()); } finally { LOGGER.debug("eth_call(): {}", s); } } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); @Override String[] accounts(); Map<String, Object> bridgeState(); String call(Web3.CallArguments args, String bnOrId); String estimateGas(Web3.CallArguments args); @Override String sendTransaction(Web3.CallArguments args); @Override String sendRawTransaction(String rawData); @Override String sign(String addr, String data); String chainId(); String getCode(String address, String blockId); }
|
@Test public void callFromAddressInWallet() throws Exception { World world = new World(); Account acc1 = new AccountBuilder(world).name("notDefault").balance(Coin.valueOf(10000000)).build(); Block genesis = world.getBlockByName("g00"); Transaction tx = new TransactionBuilder() .sender(acc1) .gasLimit(BigInteger.valueOf(100000)) .gasPrice(BigInteger.ONE) .data("60606040525b33600060006101000a81548173ffffffffffffffffffffffffffffffffffffffff02191690836c010000000000000000000000009081020402179055505b610181806100516000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063ead710c41461003c57610037565b610002565b34610002576100956004808035906020019082018035906020019191908080601f016020809104026020016040519081016040528093929190818152602001838380828437820191505050505050909091905050610103565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f1680156100f55780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6020604051908101604052806000815260200150600060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561017357610002565b81905061017b565b5b91905056") .build(); List<Transaction> txs = new ArrayList<>(); txs.add(tx); Block block1 = new BlockBuilder(world.getBlockChain(), world.getBridgeSupportFactory(), world.getBlockStore()).trieStore(world.getTrieStore()).parent(genesis).transactions(txs).build(); world.getBlockChain().tryToConnect(block1); Web3Impl web3 = createWeb3Mocked(world); web3.personal_newAccountWithSeed("default"); web3.personal_newAccountWithSeed("notDefault"); Web3.CallArguments argsForCall = new Web3.CallArguments(); argsForCall.from = TypeConverter.toJsonHex(acc1.getAddress().getBytes()); argsForCall.to = TypeConverter.toJsonHex(tx.getContractAddress().getBytes()); argsForCall.data = "0xead710c40000000000000000000000000000000000000000000000000000000064617665"; String result = web3.eth_call(argsForCall, "latest"); org.junit.Assert.assertEquals("0x0000000000000000000000000000000000000000000000000000000064617665", result); }
|
@Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void getCode() { byte[] expectedCode = new byte[] {1, 2, 3}; TransactionPool mockTransactionPool = mock(TransactionPool.class); PendingState mockPendingState = mock(PendingState.class); doReturn(expectedCode).when(mockPendingState).getCode(any(RskAddress.class)); doReturn(mockPendingState).when(mockTransactionPool).getPendingState(); EthModule eth = new EthModule( null, (byte) 0, null, mockTransactionPool, null, null, null, null, null, new BridgeSupportFactory( null, null, null ) ); String addr = eth.getCode(TestUtils.randomAddress().toHexString(), "pending"); Assert.assertThat(Hex.decode(addr.substring("0x".length())), is(expectedCode)); }
|
public String getCode(String address, String blockId) { if (blockId == null) { throw new NullPointerException(); } String s = null; try { RskAddress addr = new RskAddress(address); AccountInformationProvider accountInformationProvider = getAccountInformationProvider(blockId); if(accountInformationProvider != null) { byte[] code = accountInformationProvider.getCode(addr); if (code == null) { code = new byte[0]; } s = TypeConverter.toJsonHex(code); } return s; } finally { if (LOGGER.isDebugEnabled()) { LOGGER.debug("eth_getCode({}, {}): {}", address, blockId, s); } } }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String getCode(String address, String blockId) { if (blockId == null) { throw new NullPointerException(); } String s = null; try { RskAddress addr = new RskAddress(address); AccountInformationProvider accountInformationProvider = getAccountInformationProvider(blockId); if(accountInformationProvider != null) { byte[] code = accountInformationProvider.getCode(addr); if (code == null) { code = new byte[0]; } s = TypeConverter.toJsonHex(code); } return s; } finally { if (LOGGER.isDebugEnabled()) { LOGGER.debug("eth_getCode({}, {}): {}", address, blockId, s); } } } }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String getCode(String address, String blockId) { if (blockId == null) { throw new NullPointerException(); } String s = null; try { RskAddress addr = new RskAddress(address); AccountInformationProvider accountInformationProvider = getAccountInformationProvider(blockId); if(accountInformationProvider != null) { byte[] code = accountInformationProvider.getCode(addr); if (code == null) { code = new byte[0]; } s = TypeConverter.toJsonHex(code); } return s; } finally { if (LOGGER.isDebugEnabled()) { LOGGER.debug("eth_getCode({}, {}): {}", address, blockId, s); } } } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String getCode(String address, String blockId) { if (blockId == null) { throw new NullPointerException(); } String s = null; try { RskAddress addr = new RskAddress(address); AccountInformationProvider accountInformationProvider = getAccountInformationProvider(blockId); if(accountInformationProvider != null) { byte[] code = accountInformationProvider.getCode(addr); if (code == null) { code = new byte[0]; } s = TypeConverter.toJsonHex(code); } return s; } finally { if (LOGGER.isDebugEnabled()) { LOGGER.debug("eth_getCode({}, {}): {}", address, blockId, s); } } } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); @Override String[] accounts(); Map<String, Object> bridgeState(); String call(Web3.CallArguments args, String bnOrId); String estimateGas(Web3.CallArguments args); @Override String sendTransaction(Web3.CallArguments args); @Override String sendRawTransaction(String rawData); @Override String sign(String addr, String data); String chainId(); String getCode(String address, String blockId); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String getCode(String address, String blockId) { if (blockId == null) { throw new NullPointerException(); } String s = null; try { RskAddress addr = new RskAddress(address); AccountInformationProvider accountInformationProvider = getAccountInformationProvider(blockId); if(accountInformationProvider != null) { byte[] code = accountInformationProvider.getCode(addr); if (code == null) { code = new byte[0]; } s = TypeConverter.toJsonHex(code); } return s; } finally { if (LOGGER.isDebugEnabled()) { LOGGER.debug("eth_getCode({}, {}): {}", address, blockId, s); } } } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); @Override String[] accounts(); Map<String, Object> bridgeState(); String call(Web3.CallArguments args, String bnOrId); String estimateGas(Web3.CallArguments args); @Override String sendTransaction(Web3.CallArguments args); @Override String sendRawTransaction(String rawData); @Override String sign(String addr, String data); String chainId(); String getCode(String address, String blockId); }
|
@Test public void chainId() { EthModule eth = new EthModule( mock(BridgeConstants.class), (byte) 33, mock(Blockchain.class), mock(TransactionPool.class), mock(ReversibleTransactionExecutor.class), mock(ExecutionBlockRetriever.class), mock(RepositoryLocator.class), mock(EthModuleWallet.class), mock(EthModuleTransaction.class), mock(BridgeSupportFactory.class) ); assertThat(eth.chainId(), is("0x21")); }
|
public String chainId() { return TypeConverter.toJsonHex(new byte[] { chainId }); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String chainId() { return TypeConverter.toJsonHex(new byte[] { chainId }); } }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String chainId() { return TypeConverter.toJsonHex(new byte[] { chainId }); } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String chainId() { return TypeConverter.toJsonHex(new byte[] { chainId }); } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); @Override String[] accounts(); Map<String, Object> bridgeState(); String call(Web3.CallArguments args, String bnOrId); String estimateGas(Web3.CallArguments args); @Override String sendTransaction(Web3.CallArguments args); @Override String sendRawTransaction(String rawData); @Override String sign(String addr, String data); String chainId(); String getCode(String address, String blockId); }
|
EthModule implements EthModuleWallet, EthModuleTransaction { public String chainId() { return TypeConverter.toJsonHex(new byte[] { chainId }); } EthModule(
BridgeConstants bridgeConstants,
byte chainId,
Blockchain blockchain,
TransactionPool transactionPool,
ReversibleTransactionExecutor reversibleTransactionExecutor,
ExecutionBlockRetriever executionBlockRetriever,
RepositoryLocator repositoryLocator,
EthModuleWallet ethModuleWallet,
EthModuleTransaction ethModuleTransaction,
BridgeSupportFactory bridgeSupportFactory); @Override String[] accounts(); Map<String, Object> bridgeState(); String call(Web3.CallArguments args, String bnOrId); String estimateGas(Web3.CallArguments args); @Override String sendTransaction(Web3.CallArguments args); @Override String sendRawTransaction(String rawData); @Override String sign(String addr, String data); String chainId(); String getCode(String address, String blockId); }
|
@Test public void deserializeUnsubscribe() throws IOException { String message = "{\"jsonrpc\":\"2.0\",\"id\":100,\"method\":\"eth_unsubscribe\",\"params\":[\"0x0204\"]}"; RskJsonRpcRequest request = serializer.deserializeRequest( new ByteArrayInputStream(message.getBytes(StandardCharsets.UTF_8)) ); assertThat(request, instanceOf(EthUnsubscribeRequest.class)); EthUnsubscribeRequest unsubscribeRequest = (EthUnsubscribeRequest) request; assertThat(unsubscribeRequest.getParams().getSubscriptionId(), is(new SubscriptionId("0x0204"))); }
|
@JsonInclude(JsonInclude.Include.NON_NULL) public EthUnsubscribeParams getParams() { return params; }
|
EthUnsubscribeRequest extends RskJsonRpcRequest { @JsonInclude(JsonInclude.Include.NON_NULL) public EthUnsubscribeParams getParams() { return params; } }
|
EthUnsubscribeRequest extends RskJsonRpcRequest { @JsonInclude(JsonInclude.Include.NON_NULL) public EthUnsubscribeParams getParams() { return params; } @JsonCreator EthUnsubscribeRequest(
@JsonProperty("jsonrpc") JsonRpcVersion version,
@JsonProperty("method") RskJsonRpcMethod method,
@JsonProperty("id") int id,
@JsonProperty("params") EthUnsubscribeParams params); }
|
EthUnsubscribeRequest extends RskJsonRpcRequest { @JsonInclude(JsonInclude.Include.NON_NULL) public EthUnsubscribeParams getParams() { return params; } @JsonCreator EthUnsubscribeRequest(
@JsonProperty("jsonrpc") JsonRpcVersion version,
@JsonProperty("method") RskJsonRpcMethod method,
@JsonProperty("id") int id,
@JsonProperty("params") EthUnsubscribeParams params); @JsonInclude(JsonInclude.Include.NON_NULL) EthUnsubscribeParams getParams(); @Override JsonRpcResultOrError accept(RskJsonRpcRequestVisitor visitor, ChannelHandlerContext ctx); }
|
EthUnsubscribeRequest extends RskJsonRpcRequest { @JsonInclude(JsonInclude.Include.NON_NULL) public EthUnsubscribeParams getParams() { return params; } @JsonCreator EthUnsubscribeRequest(
@JsonProperty("jsonrpc") JsonRpcVersion version,
@JsonProperty("method") RskJsonRpcMethod method,
@JsonProperty("id") int id,
@JsonProperty("params") EthUnsubscribeParams params); @JsonInclude(JsonInclude.Include.NON_NULL) EthUnsubscribeParams getParams(); @Override JsonRpcResultOrError accept(RskJsonRpcRequestVisitor visitor, ChannelHandlerContext ctx); }
|
@Test public void getLogIndex() { assertThat(logsNotification.getLogIndex(), is(QUANTITY_JSON_HEX)); }
|
public String getLogIndex() { if (lazyLogIndex == null) { lazyLogIndex = toQuantityJsonHex(logInfoIndex); } return lazyLogIndex; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getLogIndex() { if (lazyLogIndex == null) { lazyLogIndex = toQuantityJsonHex(logInfoIndex); } return lazyLogIndex; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getLogIndex() { if (lazyLogIndex == null) { lazyLogIndex = toQuantityJsonHex(logInfoIndex); } return lazyLogIndex; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getLogIndex() { if (lazyLogIndex == null) { lazyLogIndex = toQuantityJsonHex(logInfoIndex); } return lazyLogIndex; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getLogIndex() { if (lazyLogIndex == null) { lazyLogIndex = toQuantityJsonHex(logInfoIndex); } return lazyLogIndex; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void getBlockNumber() { doReturn(42L).when(block).getNumber(); assertThat(logsNotification.getBlockNumber(), is(QUANTITY_JSON_HEX)); }
|
public String getBlockNumber() { if (lazyBlockNumber == null) { lazyBlockNumber = toQuantityJsonHex(block.getNumber()); } return lazyBlockNumber; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockNumber() { if (lazyBlockNumber == null) { lazyBlockNumber = toQuantityJsonHex(block.getNumber()); } return lazyBlockNumber; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockNumber() { if (lazyBlockNumber == null) { lazyBlockNumber = toQuantityJsonHex(block.getNumber()); } return lazyBlockNumber; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockNumber() { if (lazyBlockNumber == null) { lazyBlockNumber = toQuantityJsonHex(block.getNumber()); } return lazyBlockNumber; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockNumber() { if (lazyBlockNumber == null) { lazyBlockNumber = toQuantityJsonHex(block.getNumber()); } return lazyBlockNumber; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void getBlockHash() { Keccak256 blockHash = TestUtils.randomHash(); doReturn(blockHash).when(block).getHash(); doCallRealMethod().when(block).getHashJsonString(); assertThat(logsNotification.getBlockHash(), is(toUnformattedJsonHex(blockHash.getBytes()))); }
|
public String getBlockHash() { if (lazyBlockHash == null) { lazyBlockHash = block.getHashJsonString(); } return lazyBlockHash; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockHash() { if (lazyBlockHash == null) { lazyBlockHash = block.getHashJsonString(); } return lazyBlockHash; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockHash() { if (lazyBlockHash == null) { lazyBlockHash = block.getHashJsonString(); } return lazyBlockHash; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockHash() { if (lazyBlockHash == null) { lazyBlockHash = block.getHashJsonString(); } return lazyBlockHash; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getBlockHash() { if (lazyBlockHash == null) { lazyBlockHash = block.getHashJsonString(); } return lazyBlockHash; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void getTransactionHash() { Keccak256 transactionHash = TestUtils.randomHash(); doReturn(transactionHash).when(transaction).getHash(); assertThat(logsNotification.getTransactionHash(), is(toUnformattedJsonHex(transactionHash.getBytes()))); }
|
public String getTransactionHash() { if (lazyTransactionHash == null) { lazyTransactionHash = transaction.getHash().toJsonString(); } return lazyTransactionHash; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionHash() { if (lazyTransactionHash == null) { lazyTransactionHash = transaction.getHash().toJsonString(); } return lazyTransactionHash; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionHash() { if (lazyTransactionHash == null) { lazyTransactionHash = transaction.getHash().toJsonString(); } return lazyTransactionHash; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionHash() { if (lazyTransactionHash == null) { lazyTransactionHash = transaction.getHash().toJsonString(); } return lazyTransactionHash; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionHash() { if (lazyTransactionHash == null) { lazyTransactionHash = transaction.getHash().toJsonString(); } return lazyTransactionHash; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void getTransactionIndex() { assertThat(logsNotification.getTransactionIndex(), is(QUANTITY_JSON_HEX)); }
|
public String getTransactionIndex() { if (lazyTransactionIndex == null) { lazyTransactionIndex = toQuantityJsonHex(transactionIndex); } return lazyTransactionIndex; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionIndex() { if (lazyTransactionIndex == null) { lazyTransactionIndex = toQuantityJsonHex(transactionIndex); } return lazyTransactionIndex; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionIndex() { if (lazyTransactionIndex == null) { lazyTransactionIndex = toQuantityJsonHex(transactionIndex); } return lazyTransactionIndex; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionIndex() { if (lazyTransactionIndex == null) { lazyTransactionIndex = toQuantityJsonHex(transactionIndex); } return lazyTransactionIndex; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getTransactionIndex() { if (lazyTransactionIndex == null) { lazyTransactionIndex = toQuantityJsonHex(transactionIndex); } return lazyTransactionIndex; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void getAddress() { byte[] logSender = TestUtils.randomAddress().getBytes(); doReturn(logSender).when(logInfo).getAddress(); assertThat(logsNotification.getAddress(), is(toJsonHex(logSender))); }
|
public String getAddress() { if (lazyAddress == null) { lazyAddress = toJsonHex(logInfo.getAddress()); } return lazyAddress; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getAddress() { if (lazyAddress == null) { lazyAddress = toJsonHex(logInfo.getAddress()); } return lazyAddress; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getAddress() { if (lazyAddress == null) { lazyAddress = toJsonHex(logInfo.getAddress()); } return lazyAddress; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getAddress() { if (lazyAddress == null) { lazyAddress = toJsonHex(logInfo.getAddress()); } return lazyAddress; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getAddress() { if (lazyAddress == null) { lazyAddress = toJsonHex(logInfo.getAddress()); } return lazyAddress; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void getData() { byte[] logData = TestUtils.randomBytes(random.nextInt(1024)); doReturn(logData).when(logInfo).getData(); assertThat(logsNotification.getData(), is(toJsonHex(logData))); }
|
public String getData() { if (lazyData == null) { lazyData = toJsonHex(logInfo.getData()); } return lazyData; }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getData() { if (lazyData == null) { lazyData = toJsonHex(logInfo.getData()); } return lazyData; } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getData() { if (lazyData == null) { lazyData = toJsonHex(logInfo.getData()); } return lazyData; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getData() { if (lazyData == null) { lazyData = toJsonHex(logInfo.getData()); } return lazyData; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public String getData() { if (lazyData == null) { lazyData = toJsonHex(logInfo.getData()); } return lazyData; } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void net_listening() { World world = new World(); SimpleEthereum eth = new SimpleEthereum(world.getBlockChain()); SimplePeerServer peerServer = new SimplePeerServer(); Web3Impl web3 = createWeb3(eth, peerServer); assertTrue("Node is not listening", !web3.net_listening()); peerServer.isListening = true; assertTrue("Node is listening", web3.net_listening()); }
|
@Override public boolean net_listening() { Boolean s = null; try { return s = peerServer.isListening(); } finally { if (logger.isDebugEnabled()) { logger.debug("net_listening(): {}", s); } } }
|
Web3Impl implements Web3 { @Override public boolean net_listening() { Boolean s = null; try { return s = peerServer.isListening(); } finally { if (logger.isDebugEnabled()) { logger.debug("net_listening(): {}", s); } } } }
|
Web3Impl implements Web3 { @Override public boolean net_listening() { Boolean s = null; try { return s = peerServer.isListening(); } finally { if (logger.isDebugEnabled()) { logger.debug("net_listening(): {}", s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public boolean net_listening() { Boolean s = null; try { return s = peerServer.isListening(); } finally { if (logger.isDebugEnabled()) { logger.debug("net_listening(): {}", s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public boolean net_listening() { Boolean s = null; try { return s = peerServer.isListening(); } finally { if (logger.isDebugEnabled()) { logger.debug("net_listening(): {}", s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void getTopics() { List<DataWord> logTopics = IntStream.range(0, random.nextInt(1024)).mapToObj(i -> TestUtils.randomDataWord()).collect(Collectors.toList()); doReturn(logTopics).when(logInfo).getTopics(); for (int i = 0; i < logTopics.size(); i++) { assertThat(logsNotification.getTopics().get(i), is(toJsonHex(logTopics.get(i).getData()))); } }
|
public List<String> getTopics() { if (lazyTopics == null) { lazyTopics = logInfo.getTopics().stream() .map(t -> toJsonHex(t.getData())) .collect(Collectors.toList()); } return Collections.unmodifiableList(lazyTopics); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public List<String> getTopics() { if (lazyTopics == null) { lazyTopics = logInfo.getTopics().stream() .map(t -> toJsonHex(t.getData())) .collect(Collectors.toList()); } return Collections.unmodifiableList(lazyTopics); } }
|
LogsNotification implements EthSubscriptionNotificationDTO { public List<String> getTopics() { if (lazyTopics == null) { lazyTopics = logInfo.getTopics().stream() .map(t -> toJsonHex(t.getData())) .collect(Collectors.toList()); } return Collections.unmodifiableList(lazyTopics); } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public List<String> getTopics() { if (lazyTopics == null) { lazyTopics = logInfo.getTopics().stream() .map(t -> toJsonHex(t.getData())) .collect(Collectors.toList()); } return Collections.unmodifiableList(lazyTopics); } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
LogsNotification implements EthSubscriptionNotificationDTO { public List<String> getTopics() { if (lazyTopics == null) { lazyTopics = logInfo.getTopics().stream() .map(t -> toJsonHex(t.getData())) .collect(Collectors.toList()); } return Collections.unmodifiableList(lazyTopics); } LogsNotification(LogInfo logInfo, Block b, int txIndex, Transaction tx, int logIdx, boolean r); String getLogIndex(); String getBlockNumber(); String getBlockHash(); String getTransactionHash(); String getTransactionIndex(); String getAddress(); String getData(); List<String> getTopics(); @JsonInclude(JsonInclude.Include.NON_EMPTY) boolean getRemoved(); @JsonIgnore LogInfo getLogInfo(); }
|
@Test public void onBestBlockEventTriggersMessageToChannel() throws JsonProcessingException { SubscriptionId subscriptionId = mock(SubscriptionId.class); Channel channel = mock(Channel.class); EthSubscribeLogsParams params = mock(EthSubscribeLogsParams.class); emitter.subscribe(subscriptionId, channel, params); when(serializer.serializeMessage(any())) .thenReturn("serialized"); listener.onBestBlock(testBlock(logInfo()), null); verify(channel).write(new TextWebSocketFrame("serialized")); verify(channel).flush(); }
|
public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void onBestBlockEventTriggersOneMessageToChannelPerLogInfoAndSubscription() throws JsonProcessingException { SubscriptionId subscriptionId1 = mock(SubscriptionId.class); SubscriptionId subscriptionId2 = mock(SubscriptionId.class); Channel channel1 = mock(Channel.class); Channel channel2 = mock(Channel.class); EthSubscribeLogsParams params = mock(EthSubscribeLogsParams.class); emitter.subscribe(subscriptionId1, channel1, params); emitter.subscribe(subscriptionId2, channel2, params); when(serializer.serializeMessage(any())) .thenReturn("serializedLog1") .thenReturn("serializedLog2") .thenReturn("serializedLog1") .thenReturn("serializedLog2"); listener.onBestBlock(testBlock(logInfo(), logInfo()), null); verify(channel1).write(new TextWebSocketFrame("serializedLog1")); verify(channel1).write(new TextWebSocketFrame("serializedLog2")); verify(channel1).flush(); verify(channel2).write(new TextWebSocketFrame("serializedLog1")); verify(channel2).write(new TextWebSocketFrame("serializedLog2")); verify(channel2).flush(); }
|
public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void filterEmittedLog() throws JsonProcessingException { SubscriptionId subscriptionId = mock(SubscriptionId.class); Channel channel = mock(Channel.class); EthSubscribeLogsParams params = mock(EthSubscribeLogsParams.class); RskAddress logSender = TestUtils.randomAddress(); when(params.getAddresses()).thenReturn(new RskAddress[] { logSender }); emitter.subscribe(subscriptionId, channel, params); byte[] log1Data = {0x1}; byte[] log2Data = {0x2}; Block block1 = testBlock(logInfo(logSender, log1Data)); Block block2 = testBlock(logInfo(log2Data)); listener.onBestBlock(block1, null); verifyLogsData(log1Data); BlockFork blockFork = mock(BlockFork.class); when(blockFork.getNewBlocks()).thenReturn(Collections.singletonList(block2)); when(comparator.calculateFork(block1, block2)).thenReturn(blockFork); clearInvocations(channel); listener.onBestBlock(block2, null); verify(channel, never()).write(any(ByteBufHolder.class)); }
|
public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void emitsNewAndRemovedLogs() throws JsonProcessingException { SubscriptionId subscriptionId = mock(SubscriptionId.class); Channel channel = mock(Channel.class); EthSubscribeLogsParams params = mock(EthSubscribeLogsParams.class); emitter.subscribe(subscriptionId, channel, params); byte[] log1Data = {0x1}; byte[] log2Data = {0x2}; Block block1 = testBlock(logInfo(log1Data)); Block block2 = testBlock(logInfo(log2Data)); listener.onBestBlock(block1, null); verifyLogsData(log1Data); verifyLogsRemovedStatus(false); BlockFork blockFork = mock(BlockFork.class); when(blockFork.getOldBlocks()).thenReturn(Collections.singletonList(block1)); when(blockFork.getNewBlocks()).thenReturn(Collections.singletonList(block2)); when(comparator.calculateFork(block1, block2)) .thenReturn(blockFork); listener.onBestBlock(block2, null); verifyLogsData(log1Data, log1Data, log2Data); verifyLogsRemovedStatus(false, true, false); }
|
public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
LogsNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params) { subscriptions.put(subscriptionId, new Subscription(channel, params)); } LogsNotificationEmitter(
Ethereum ethereum,
JsonRpcSerializer jsonRpcSerializer,
ReceiptStore receiptStore,
BlockchainBranchComparator branchComparator); void subscribe(SubscriptionId subscriptionId, Channel channel, EthSubscribeLogsParams params); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void ethereumOnBlockEventTriggersMessageToChannel() throws JsonProcessingException { SubscriptionId subscriptionId = mock(SubscriptionId.class); Channel channel = mock(Channel.class); emitter.subscribe(subscriptionId, channel); when(serializer.serializeMessage(any())) .thenReturn("serialized"); listener.onBlock(TEST_BLOCK, null); verify(channel).writeAndFlush(new TextWebSocketFrame("serialized")); }
|
public void subscribe(SubscriptionId subscriptionId, Channel channel) { subscriptions.put(subscriptionId, channel); }
|
BlockHeaderNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel) { subscriptions.put(subscriptionId, channel); } }
|
BlockHeaderNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel) { subscriptions.put(subscriptionId, channel); } BlockHeaderNotificationEmitter(Ethereum ethereum, JsonRpcSerializer jsonRpcSerializer); }
|
BlockHeaderNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel) { subscriptions.put(subscriptionId, channel); } BlockHeaderNotificationEmitter(Ethereum ethereum, JsonRpcSerializer jsonRpcSerializer); void subscribe(SubscriptionId subscriptionId, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
BlockHeaderNotificationEmitter { public void subscribe(SubscriptionId subscriptionId, Channel channel) { subscriptions.put(subscriptionId, channel); } BlockHeaderNotificationEmitter(Ethereum ethereum, JsonRpcSerializer jsonRpcSerializer); void subscribe(SubscriptionId subscriptionId, Channel channel); boolean unsubscribe(SubscriptionId subscriptionId); void unsubscribe(Channel channel); }
|
@Test public void getTopAddress() { TraceAddress address = new TraceAddress(); Assert.assertArrayEquals(new int[0], address.toAddress()); }
|
@JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); @JsonValue int[] toAddress(); }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); @JsonValue int[] toAddress(); }
|
@Test public void getChildAddress() { TraceAddress parent = new TraceAddress(); TraceAddress address = new TraceAddress(parent, 1); Assert.assertArrayEquals(new int[] { 1 }, address.toAddress()); }
|
@JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); @JsonValue int[] toAddress(); }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); @JsonValue int[] toAddress(); }
|
@Test public void getGrandChildAddress() { TraceAddress grandparent = new TraceAddress(); TraceAddress parent = new TraceAddress(grandparent, 1); TraceAddress address = new TraceAddress(parent, 2); Assert.assertArrayEquals(new int[] { 1, 2 }, address.toAddress()); }
|
@JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); @JsonValue int[] toAddress(); }
|
TraceAddress { @JsonValue public int[] toAddress() { if (this.parent == null) { return EMPTY_ADDRESS; } int[] parentAddress = this.parent.toAddress(); int[] address = Arrays.copyOf(parentAddress, parentAddress.length + 1); address[address.length - 1] = this.index; return address; } TraceAddress(); TraceAddress(TraceAddress parent, int index); @JsonValue int[] toAddress(); }
|
@Test public void getActionFromInvokeData() { DataWord address = DataWord.valueOf(1); DataWord origin = DataWord.valueOf(2); DataWord caller = DataWord.valueOf(3); long gas = 1000000; DataWord callValue = DataWord.valueOf(100000); byte[] data = new byte[]{0x01, 0x02, 0x03, 0x04}; ProgramInvoke invoke = new ProgramInvokeImpl( address, origin, caller, null, null, gas, callValue, data, null, null, null, null, null, null, null, null, 0, null, false, false); TraceAction action = TraceTransformer.toAction(TraceType.CALL, invoke, CallType.CALL, null, null, null); Assert.assertNotNull(action); Assert.assertEquals("call", action.getCallType()); Assert.assertEquals("0x0000000000000000000000000000000000000001", action.getTo()); Assert.assertEquals("0x0000000000000000000000000000000000000003", action.getFrom()); Assert.assertEquals("0x01020304", action.getInput()); Assert.assertEquals("0xf4240", action.getGas()); Assert.assertEquals("0x186a0", action.getValue()); }
|
public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); static List<TransactionTrace> toTraces(SummarizedProgramTrace trace, TransactionInfo txInfo, long blockNumber); static TransactionTrace toTrace(TraceType traceType, InvokeData invoke, ProgramResult programResult, TransactionInfo txInfo, long blockNumber, TraceAddress traceAddress, CallType callType, CreationData creationData, String creationMethod, String err, int nsubtraces, DataWord codeAddress); static TraceResult toResult(ProgramResult programResult, byte[] createdCode, RskAddress createdAddress); static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); static List<TransactionTrace> toTraces(SummarizedProgramTrace trace, TransactionInfo txInfo, long blockNumber); static TransactionTrace toTrace(TraceType traceType, InvokeData invoke, ProgramResult programResult, TransactionInfo txInfo, long blockNumber, TraceAddress traceAddress, CallType callType, CreationData creationData, String creationMethod, String err, int nsubtraces, DataWord codeAddress); static TraceResult toResult(ProgramResult programResult, byte[] createdCode, RskAddress createdAddress); static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress); }
|
@Test public void eth_coinbase() { String originalCoinbase = "1dcc4de8dec75d7aab85b513f0a142fd40d49347"; MinerServer minerServerMock = mock(MinerServer.class); when(minerServerMock.getCoinbaseAddress()).thenReturn(new RskAddress(originalCoinbase)); Ethereum ethMock = Web3Mocks.getMockEthereum(); Blockchain blockchain = Web3Mocks.getMockBlockchain(); TransactionPool transactionPool = Web3Mocks.getMockTransactionPool(); BlockStore blockStore = Web3Mocks.getMockBlockStore(); RskSystemProperties mockProperties = Web3Mocks.getMockProperties(); PersonalModule personalModule = new PersonalModuleWalletDisabled(); Web3 web3 = new Web3Impl( ethMock, blockchain, blockStore, null, mockProperties, null, minerServerMock, personalModule, null, null, null, null, null, null, null, Web3Mocks.getMockChannelManager(), null, null, null, null, null, null, null, mock(Web3InformationRetriever.class)); Assert.assertEquals("0x" + originalCoinbase, web3.eth_coinbase()); verify(minerServerMock, times(1)).getCoinbaseAddress(); }
|
@Override public String eth_coinbase() { String s = null; try { s = minerServer.getCoinbaseAddress().toJsonString(); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_coinbase(): {}", s); } } }
|
Web3Impl implements Web3 { @Override public String eth_coinbase() { String s = null; try { s = minerServer.getCoinbaseAddress().toJsonString(); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_coinbase(): {}", s); } } } }
|
Web3Impl implements Web3 { @Override public String eth_coinbase() { String s = null; try { s = minerServer.getCoinbaseAddress().toJsonString(); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_coinbase(): {}", s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public String eth_coinbase() { String s = null; try { s = minerServer.getCoinbaseAddress().toJsonString(); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_coinbase(): {}", s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public String eth_coinbase() { String s = null; try { s = minerServer.getCoinbaseAddress().toJsonString(); return s; } finally { if (logger.isDebugEnabled()) { logger.debug("eth_coinbase(): {}", s); } } } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void getActionFromInvokeDataWithCreationData() { DataWord address = DataWord.valueOf(1); DataWord origin = DataWord.valueOf(2); DataWord caller = DataWord.valueOf(3); long gas = 1000000; DataWord callValue = DataWord.valueOf(100000); byte[] data = new byte[]{0x01, 0x02, 0x03, 0x04}; ProgramInvoke invoke = new ProgramInvokeImpl( address, origin, caller, null, null, gas, callValue, null, null, null, null, null, null, null, null, null, 0, null, false, false); TraceAction action = TraceTransformer.toAction(TraceType.CREATE, invoke, CallType.NONE, data, null, null); Assert.assertNotNull(action); Assert.assertNull(action.getCallType()); Assert.assertNull(action.getTo()); Assert.assertEquals("0x0000000000000000000000000000000000000003", action.getFrom()); Assert.assertEquals("0x01020304", action.getInit()); Assert.assertNull(action.getCreationMethod()); Assert.assertEquals("0xf4240", action.getGas()); Assert.assertEquals("0x186a0", action.getValue()); }
|
public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); static List<TransactionTrace> toTraces(SummarizedProgramTrace trace, TransactionInfo txInfo, long blockNumber); static TransactionTrace toTrace(TraceType traceType, InvokeData invoke, ProgramResult programResult, TransactionInfo txInfo, long blockNumber, TraceAddress traceAddress, CallType callType, CreationData creationData, String creationMethod, String err, int nsubtraces, DataWord codeAddress); static TraceResult toResult(ProgramResult programResult, byte[] createdCode, RskAddress createdAddress); static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); static List<TransactionTrace> toTraces(SummarizedProgramTrace trace, TransactionInfo txInfo, long blockNumber); static TransactionTrace toTrace(TraceType traceType, InvokeData invoke, ProgramResult programResult, TransactionInfo txInfo, long blockNumber, TraceAddress traceAddress, CallType callType, CreationData creationData, String creationMethod, String err, int nsubtraces, DataWord codeAddress); static TraceResult toResult(ProgramResult programResult, byte[] createdCode, RskAddress createdAddress); static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress); }
|
@Test public void getActionFromInvokeDataWithCreationDataUsingCreationMethod() { DataWord address = DataWord.valueOf(1); DataWord origin = DataWord.valueOf(2); DataWord caller = DataWord.valueOf(3); long gas = 1000000; DataWord callValue = DataWord.valueOf(100000); byte[] data = new byte[]{0x01, 0x02, 0x03, 0x04}; ProgramInvoke invoke = new ProgramInvokeImpl( address, origin, caller, null, null, gas, callValue, null, null, null, null, null, null, null, null, null, 0, null, false, false); TraceAction action = TraceTransformer.toAction(TraceType.CREATE, invoke, CallType.NONE, data, "create2", null); Assert.assertNotNull(action); Assert.assertNull(action.getCallType()); Assert.assertNull(action.getTo()); Assert.assertEquals("0x0000000000000000000000000000000000000003", action.getFrom()); Assert.assertEquals("0x01020304", action.getInit()); Assert.assertEquals("create2", action.getCreationMethod()); Assert.assertEquals("0xf4240", action.getGas()); Assert.assertEquals("0x186a0", action.getValue()); }
|
public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); static List<TransactionTrace> toTraces(SummarizedProgramTrace trace, TransactionInfo txInfo, long blockNumber); static TransactionTrace toTrace(TraceType traceType, InvokeData invoke, ProgramResult programResult, TransactionInfo txInfo, long blockNumber, TraceAddress traceAddress, CallType callType, CreationData creationData, String creationMethod, String err, int nsubtraces, DataWord codeAddress); static TraceResult toResult(ProgramResult programResult, byte[] createdCode, RskAddress createdAddress); static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress); }
|
TraceTransformer { public static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress) { String from; if (callType == CallType.DELEGATECALL) { from = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } else { from = new RskAddress(invoke.getCallerAddress().getLast20Bytes()).toJsonString(); } String to = null; String gas = null; DataWord callValue = invoke.getCallValue(); String input = null; String value = null; String address = null; String refundAddress = null; String balance = null; String init = null; if (traceType == TraceType.CREATE) { init = TypeConverter.toUnformattedJsonHex(creationInput); value = TypeConverter.toQuantityJsonHex(callValue.getData()); gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.CALL) { input = TypeConverter.toUnformattedJsonHex(invoke.getDataCopy(DataWord.ZERO, invoke.getDataSize()));; value = TypeConverter.toQuantityJsonHex(callValue.getData()); if (callType == CallType.DELEGATECALL) { if (codeAddress != null) { to = new RskAddress(codeAddress.getLast20Bytes()).toJsonString(); } } else { to = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } gas = TypeConverter.toQuantityJsonHex(invoke.getGas()); } if (traceType == TraceType.SUICIDE) { address = from; from = null; balance = TypeConverter.toQuantityJsonHex(callValue.getData()); refundAddress = new RskAddress(invoke.getOwnerAddress().getLast20Bytes()).toJsonString(); } return new TraceAction( callType, from, to, gas, input, init, creationMethod, value, address, refundAddress, balance ); } private TraceTransformer(); static List<TransactionTrace> toTraces(SummarizedProgramTrace trace, TransactionInfo txInfo, long blockNumber); static TransactionTrace toTrace(TraceType traceType, InvokeData invoke, ProgramResult programResult, TransactionInfo txInfo, long blockNumber, TraceAddress traceAddress, CallType callType, CreationData creationData, String creationMethod, String err, int nsubtraces, DataWord codeAddress); static TraceResult toResult(ProgramResult programResult, byte[] createdCode, RskAddress createdAddress); static TraceAction toAction(TraceType traceType, InvokeData invoke, CallType callType, byte[] creationInput, String creationMethod, DataWord codeAddress); }
|
@Test public void retrieveUnknownTransactionAsNull() throws Exception { ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction("0x00"); Assert.assertNull(result); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void retrieveUnknownBlockAsNull() throws Exception { ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceBlock("0x0001020300010203000102030001020300010203000102030001020300010203"); Assert.assertNull(result); }
|
@Override public JsonNode traceBlock(String blockArgument) throws Exception { logger.trace("trace_block({})", blockArgument); Block block = this.getByJsonArgument(blockArgument); if (block == null) { logger.trace("No block for {}", blockArgument); return null; } Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); List<TransactionTrace> blockTraces = new ArrayList<>(); if (block.getNumber() != 0) { ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); for (Transaction tx : block.getTransactionsList()) { TransactionInfo txInfo = receiptStore.getInMainChain(tx.getHash().getBytes(), this.blockStore); txInfo.setTransaction(tx); SummarizedProgramTrace programTrace = (SummarizedProgramTrace) programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); blockTraces.addAll(traces); } } ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(blockTraces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceBlock(String blockArgument) throws Exception { logger.trace("trace_block({})", blockArgument); Block block = this.getByJsonArgument(blockArgument); if (block == null) { logger.trace("No block for {}", blockArgument); return null; } Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); List<TransactionTrace> blockTraces = new ArrayList<>(); if (block.getNumber() != 0) { ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); for (Transaction tx : block.getTransactionsList()) { TransactionInfo txInfo = receiptStore.getInMainChain(tx.getHash().getBytes(), this.blockStore); txInfo.setTransaction(tx); SummarizedProgramTrace programTrace = (SummarizedProgramTrace) programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); blockTraces.addAll(traces); } } ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(blockTraces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceBlock(String blockArgument) throws Exception { logger.trace("trace_block({})", blockArgument); Block block = this.getByJsonArgument(blockArgument); if (block == null) { logger.trace("No block for {}", blockArgument); return null; } Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); List<TransactionTrace> blockTraces = new ArrayList<>(); if (block.getNumber() != 0) { ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); for (Transaction tx : block.getTransactionsList()) { TransactionInfo txInfo = receiptStore.getInMainChain(tx.getHash().getBytes(), this.blockStore); txInfo.setTransaction(tx); SummarizedProgramTrace programTrace = (SummarizedProgramTrace) programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); blockTraces.addAll(traces); } } ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(blockTraces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceBlock(String blockArgument) throws Exception { logger.trace("trace_block({})", blockArgument); Block block = this.getByJsonArgument(blockArgument); if (block == null) { logger.trace("No block for {}", blockArgument); return null; } Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); List<TransactionTrace> blockTraces = new ArrayList<>(); if (block.getNumber() != 0) { ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); for (Transaction tx : block.getTransactionsList()) { TransactionInfo txInfo = receiptStore.getInMainChain(tx.getHash().getBytes(), this.blockStore); txInfo.setTransaction(tx); SummarizedProgramTrace programTrace = (SummarizedProgramTrace) programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); blockTraces.addAll(traces); } } ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(blockTraces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceBlock(String blockArgument) throws Exception { logger.trace("trace_block({})", blockArgument); Block block = this.getByJsonArgument(blockArgument); if (block == null) { logger.trace("No block for {}", blockArgument); return null; } Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); List<TransactionTrace> blockTraces = new ArrayList<>(); if (block.getNumber() != 0) { ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); for (Transaction tx : block.getTransactionsList()) { TransactionInfo txInfo = receiptStore.getInMainChain(tx.getHash().getBytes(), this.blockStore); txInfo.setTransaction(tx); SummarizedProgramTrace programTrace = (SummarizedProgramTrace) programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); blockTraces.addAll(traces); } } ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(blockTraces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void retrieveSimpleContractCreationTrace() throws Exception { DslParser parser = DslParser.fromResource("dsl/contracts01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(1, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(0); Assert.assertNotNull(oresult.get("type")); Assert.assertEquals("\"create\"", oresult.get("type").toString()); Assert.assertNotNull(oresult.get("action")); Assert.assertNull(oresult.get("action").get("creationMethod")); Assert.assertNotNull(oresult.get("action").get("init")); Assert.assertNull(oresult.get("action").get("input")); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void retrieveEmptyContractCreationTrace() throws Exception { DslParser parser = DslParser.fromResource("dsl/contracts09.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(1, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(0); Assert.assertNotNull(oresult.get("type")); Assert.assertEquals("\"create\"", oresult.get("type").toString()); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void retrieveSimpleContractInvocationTrace() throws Exception { DslParser parser = DslParser.fromResource("dsl/contracts02.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx02"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(1, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(0); Assert.assertNotNull(oresult.get("type")); Assert.assertEquals("\"call\"", oresult.get("type").toString()); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void retrieveSimpleAccountTransfer() throws Exception { DslParser parser = DslParser.fromResource("dsl/transfers01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(1, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(0); Assert.assertNotNull(oresult.get("type")); Assert.assertEquals("\"call\"", oresult.get("type").toString()); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void executeContractWithCall() throws Exception { DslParser parser = DslParser.fromResource("dsl/call01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Account callAccount = world.getAccountByName("call"); Account calledAccount = world.getAccountByName("called"); Assert.assertNotNull(callAccount); Assert.assertNotNull(calledAccount); Transaction transaction = world.getTransactionByName("tx01"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(2, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(1); Assert.assertNotNull(oresult.get("action")); Assert.assertNotNull(oresult.get("action").get("callType")); Assert.assertEquals("\"call\"", oresult.get("action").get("callType").toString()); Assert.assertEquals("\"" + calledAccount.getAddress().toJsonString() + "\"", oresult.get("action").get("to").toString()); Assert.assertEquals("\"" + callAccount.getAddress().toJsonString() + "\"", oresult.get("action").get("from").toString()); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void executeContractWithDelegateCall() throws Exception { DslParser parser = DslParser.fromResource("dsl/delegatecall01.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Account delegateCallAccount = world.getAccountByName("delegatecall"); Account delegatedAccount = world.getAccountByName("delegated"); Assert.assertNotNull(delegateCallAccount); Assert.assertNotNull(delegatedAccount); Transaction transaction = world.getTransactionByName("tx01"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(2, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(1); Assert.assertNotNull(oresult.get("action")); Assert.assertNotNull(oresult.get("action").get("callType")); Assert.assertEquals("\"delegatecall\"", oresult.get("action").get("callType").toString()); Assert.assertEquals("\"" + delegatedAccount.getAddress().toJsonString() + "\"", oresult.get("action").get("to").toString()); Assert.assertEquals("\"" + delegateCallAccount.getAddress().toJsonString() + "\"", oresult.get("action").get("from").toString()); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void eth_sign() { Web3Impl web3 = createWeb3(); String addr1 = web3.personal_newAccountWithSeed("sampleSeed1"); byte[] hash = Keccak256Helper.keccak256("this is the data to hash".getBytes()); String signature = web3.eth_sign(addr1, "0x" + ByteUtil.toHexString(hash)); Assert.assertThat( signature, is("0xc8be87722c6452172a02a62fdea70c8b25cfc9613d28647bf2aeb3c7d1faa1a91b861fccc05bb61e25ff4300502812750706ca8df189a0b8163540b9bccabc9f1b") ); }
|
@Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); }
|
Web3Impl implements Web3 { @Override public String personal_newAccountWithSeed(String seed) { return personalModule.newAccountWithSeed(seed); } protected Web3Impl(
Ethereum eth,
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
RskSystemProperties config,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule,
RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever web3InformationRetriever); @Override void start(); @Override void stop(); @Override String web3_clientVersion(); @Override String web3_sha3(String data); @Override String net_version(); @Override String net_peerCount(); @Override boolean net_listening(); @Override String rsk_protocolVersion(); @Override String eth_protocolVersion(); @Override Object eth_syncing(); @Override String eth_coinbase(); @Override boolean eth_mining(); @Override BigInteger eth_hashrate(); @Override BigInteger eth_netHashrate(); @Override String[] net_peerList(); @Override String eth_gasPrice(); @Override String eth_blockNumber(); @Override String eth_getBalance(String address, String block); @Override String eth_getBalance(String address); @Override String eth_getStorageAt(String address, String storageIdx, String blockId); @Override String eth_getTransactionCount(String address, String blockId); Block getBlockByJSonHash(String blockHash); @Override String eth_getBlockTransactionCountByHash(String blockHash); static Block getBlockByNumberOrStr(String bnOrId, Blockchain blockchain); @Override String eth_getBlockTransactionCountByNumber(String bnOrId); @Override String eth_getUncleCountByBlockHash(String blockHash); @Override String eth_getUncleCountByBlockNumber(String bnOrId); BlockInformationResult getBlockInformationResult(BlockInformation blockInformation); BlockResultDTO getBlockResult(Block b, boolean fullTx); BlockInformationResult[] eth_getBlocksByNumber(String number); @Override BlockResultDTO eth_getBlockByHash(String blockHash, Boolean fullTransactionObjects); @Override BlockResultDTO eth_getBlockByNumber(String bnOrId, Boolean fullTransactionObjects); @Override TransactionResultDTO eth_getTransactionByHash(String transactionHash); @Override TransactionResultDTO eth_getTransactionByBlockHashAndIndex(String blockHash, String index); @Override TransactionResultDTO eth_getTransactionByBlockNumberAndIndex(String bnOrId, String index); @Override TransactionReceiptDTO eth_getTransactionReceipt(String transactionHash); @Override BlockResultDTO eth_getUncleByBlockHashAndIndex(String blockHash, String uncleIdx); @Override BlockResultDTO eth_getUncleByBlockNumberAndIndex(String blockId, String uncleIdx); @Override String[] eth_getCompilers(); @Override Map<String, CompilationResultDTO> eth_compileLLL(String contract); @Override Map<String, CompilationResultDTO> eth_compileSerpent(String contract); @Override Map<String, CompilationResultDTO> eth_compileSolidity(String contract); @Override String eth_newFilter(FilterRequest fr); @Override String eth_newBlockFilter(); @Override String eth_newPendingTransactionFilter(); @Override boolean eth_uninstallFilter(String id); @Override Object[] eth_getFilterChanges(String id); @Override Object[] eth_getFilterLogs(String id); @Override Object[] eth_getLogs(FilterRequest fr); @Override Map<String, String> rpc_modules(); @Override void db_putString(); @Override void db_getString(); @Override boolean eth_submitWork(String nonce, String header, String mince); @Override boolean eth_submitHashrate(String hashrate, String id); @Override void db_putHex(); @Override void db_getHex(); @Override String personal_newAccountWithSeed(String seed); @Override String personal_newAccount(String passphrase); @Override String personal_importRawKey(String key, String passphrase); @Override String personal_dumpRawKey(String address); @Override String[] personal_listAccounts(); @Override String personal_sendTransaction(CallArguments args, String passphrase); @Override boolean personal_unlockAccount(String address, String passphrase, String duration); @Override boolean personal_lockAccount(String address); @Override EthModule getEthModule(); @Override EvmModule getEvmModule(); @Override TxPoolModule getTxPoolModule(); @Override MnrModule getMnrModule(); @Override DebugModule getDebugModule(); @Override TraceModule getTraceModule(); @Override RskModule getRskModule(); @Override void sco_banAddress(String address); @Override void sco_unbanAddress(String address); @Override PeerScoringInformation[] sco_peerList(); @Override String[] sco_bannedAddresses(); public Ethereum eth; }
|
@Test public void executeContractWithCreate2() throws Exception { DslParser parser = DslParser.fromResource("dsl/create201.txt"); ReceiptStore receiptStore = new ReceiptStoreImpl(new HashMapDB()); World world = new World(receiptStore); WorldDslProcessor processor = new WorldDslProcessor(world); processor.processCommands(parser); Transaction transaction = world.getTransactionByName("tx01"); TraceModuleImpl traceModule = new TraceModuleImpl(world.getBlockChain(), world.getBlockStore(), receiptStore, world.getBlockExecutor()); JsonNode result = traceModule.traceTransaction(transaction.getHash().toJsonString()); Assert.assertNotNull(result); Assert.assertTrue(result.isArray()); ArrayNode aresult = (ArrayNode)result; Assert.assertEquals(2, aresult.size()); Assert.assertTrue(result.get(0).isObject()); ObjectNode oresult = (ObjectNode)result.get(1); Assert.assertNotNull(oresult.get("action")); Assert.assertNotNull(oresult.get("action").get("creationMethod")); Assert.assertEquals("\"create2\"", oresult.get("action").get("creationMethod").toString()); }
|
@Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
TraceModuleImpl implements TraceModule { @Override public JsonNode traceTransaction(String transactionHash) throws Exception { logger.trace("trace_transaction({})", transactionHash); byte[] hash = stringHexToByteArray(transactionHash); TransactionInfo txInfo = this.receiptStore.getInMainChain(hash, this.blockStore); if (txInfo == null) { logger.trace("No transaction info for {}", transactionHash); return null; } Block block = this.blockchain.getBlockByHash(txInfo.getBlockHash()); Block parent = this.blockchain.getBlockByHash(block.getParentHash().getBytes()); Transaction tx = block.getTransactionsList().get(txInfo.getIndex()); txInfo.setTransaction(tx); ProgramTraceProcessor programTraceProcessor = new ProgramTraceProcessor(); this.blockExecutor.traceBlock(programTraceProcessor, VmConfig.LIGHT_TRACE, block, parent.getHeader(), false, false); SummarizedProgramTrace programTrace = (SummarizedProgramTrace)programTraceProcessor.getProgramTrace(tx.getHash()); if (programTrace == null) { return null; } List<TransactionTrace> traces = TraceTransformer.toTraces(programTrace, txInfo, block.getNumber()); ObjectMapper mapper = Serializers.createMapper(true); return mapper.valueToTree(traces); } TraceModuleImpl(
Blockchain blockchain,
BlockStore blockStore,
ReceiptStore receiptStore,
BlockExecutor blockExecutor); @Override JsonNode traceTransaction(String transactionHash); @Override JsonNode traceBlock(String blockArgument); }
|
@Test public void visitUnsubscribe() { EthUnsubscribeRequest unsubscribe = new EthUnsubscribeRequest( JsonRpcVersion.V2_0, RskJsonRpcMethod.ETH_UNSUBSCRIBE, 35, new EthUnsubscribeParams(SAMPLE_SUBSCRIPTION_ID) ); when(emitter.unsubscribe(SAMPLE_SUBSCRIPTION_ID)) .thenReturn(true); assertThat( handler.visit(unsubscribe, null), is(new JsonRpcBooleanResult(true)) ); }
|
@Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); @Override void channelInactive(ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthSubscribeRequest request, ChannelHandlerContext ctx); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); @Override void channelInactive(ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthSubscribeRequest request, ChannelHandlerContext ctx); }
|
@Test public void visitSubscribe() { Channel channel = mock(Channel.class); ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); when(ctx.channel()) .thenReturn(channel); when(emitter.visit(any(EthSubscribeNewHeadsParams.class), eq(channel))) .thenReturn(SAMPLE_SUBSCRIPTION_ID); assertThat( handler.visit(SAMPLE_SUBSCRIBE_REQUEST, ctx), is(SAMPLE_SUBSCRIPTION_ID) ); }
|
@Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); @Override void channelInactive(ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthSubscribeRequest request, ChannelHandlerContext ctx); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); @Override void channelInactive(ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthSubscribeRequest request, ChannelHandlerContext ctx); }
|
@Test public void handlerDeserializesAndHandlesRequest() throws Exception { Channel channel = mock(Channel.class); ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); when(ctx.channel()) .thenReturn(channel); when(serializer.deserializeRequest(any())) .thenReturn(SAMPLE_SUBSCRIBE_REQUEST); when(emitter.visit(any(EthSubscribeNewHeadsParams.class), eq(channel))) .thenReturn(SAMPLE_SUBSCRIPTION_ID); when(serializer.serializeMessage(any())) .thenReturn("serialized"); DefaultByteBufHolder msg = new DefaultByteBufHolder(Unpooled.copiedBuffer("raw".getBytes())); handler.channelRead(ctx, msg); verify(ctx, times(1)).writeAndFlush(new TextWebSocketFrame("serialized")); verify(ctx, never()).fireChannelRead(any()); }
|
@Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); @Override void channelInactive(ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthSubscribeRequest request, ChannelHandlerContext ctx); }
|
RskJsonRpcHandler extends SimpleChannelInboundHandler<ByteBufHolder> implements RskJsonRpcRequestVisitor { @Override public JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx) { boolean unsubscribed = emitter.unsubscribe(request.getParams().getSubscriptionId()); return new JsonRpcBooleanResult(unsubscribed); } RskJsonRpcHandler(EthSubscriptionNotificationEmitter emitter, JsonRpcSerializer serializer); @Override void channelInactive(ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthUnsubscribeRequest request, ChannelHandlerContext ctx); @Override JsonRpcResultOrError visit(EthSubscribeRequest request, ChannelHandlerContext ctx); }
|
@Test public void web3_ext_dumpState() { Ethereum rsk = mock(Ethereum.class); Blockchain blockchain = mock(Blockchain.class); MiningMainchainView mainchainView = mock(MiningMainchainView.class); NetworkStateExporter networkStateExporter = mock(NetworkStateExporter.class); Mockito.when(networkStateExporter.exportStatus(Mockito.anyString())).thenReturn(true); Block block = mock(Block.class); Mockito.when(block.getHash()).thenReturn(PegTestUtils.createHash3()); Mockito.when(block.getNumber()).thenReturn(1L); BlockStore blockStore = mock(BlockStore.class); Mockito.when(blockStore.getBestBlock()).thenReturn(block); Mockito.when(networkStateExporter.exportStatus(Mockito.anyString())).thenReturn(true); Mockito.when(blockchain.getBestBlock()).thenReturn(block); Wallet wallet = WalletFactory.createWallet(); TestSystemProperties config = new TestSystemProperties(); PersonalModule pm = new PersonalModuleWalletEnabled(config, rsk, wallet, null); EthModule em = new EthModule( config.getNetworkConstants().getBridgeConstants(), config.getNetworkConstants().getChainId(), blockchain, null, null, new ExecutionBlockRetriever(mainchainView, blockchain, null, null), null, new EthModuleWalletEnabled(wallet), null, new BridgeSupportFactory( null, config.getNetworkConstants().getBridgeConstants(), config.getActivationConfig()) ); TxPoolModule tpm = new TxPoolModuleImpl(Web3Mocks.getMockTransactionPool()); DebugModule dm = new DebugModuleImpl(null, null, Web3Mocks.getMockMessageHandler(), null); Web3RskImpl web3 = new Web3RskImpl( rsk, blockchain, config, Web3Mocks.getMockMinerClient(), Web3Mocks.getMockMinerServer(), pm, em, null, tpm, null, dm, null, null, Web3Mocks.getMockChannelManager(), null, networkStateExporter, blockStore, null, null, null, null, null, null, null, null); web3.ext_dumpState(); }
|
public void ext_dumpState() { Block bestBlcock = blockStore.getBestBlock(); logger.info("Dumping state for block hash {}, block number {}", bestBlcock.getHash(), bestBlcock.getNumber()); networkStateExporter.exportStatus(System.getProperty("user.dir") + "/" + "rskdump.json"); }
|
Web3RskImpl extends Web3Impl { public void ext_dumpState() { Block bestBlcock = blockStore.getBestBlock(); logger.info("Dumping state for block hash {}, block number {}", bestBlcock.getHash(), bestBlcock.getNumber()); networkStateExporter.exportStatus(System.getProperty("user.dir") + "/" + "rskdump.json"); } }
|
Web3RskImpl extends Web3Impl { public void ext_dumpState() { Block bestBlcock = blockStore.getBestBlock(); logger.info("Dumping state for block hash {}, block number {}", bestBlcock.getHash(), bestBlcock.getNumber()); networkStateExporter.exportStatus(System.getProperty("user.dir") + "/" + "rskdump.json"); } Web3RskImpl(
Ethereum eth,
Blockchain blockchain,
RskSystemProperties properties,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule, RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
NetworkStateExporter networkStateExporter,
BlockStore blockStore,
ReceiptStore receiptStore,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever retriever); }
|
Web3RskImpl extends Web3Impl { public void ext_dumpState() { Block bestBlcock = blockStore.getBestBlock(); logger.info("Dumping state for block hash {}, block number {}", bestBlcock.getHash(), bestBlcock.getNumber()); networkStateExporter.exportStatus(System.getProperty("user.dir") + "/" + "rskdump.json"); } Web3RskImpl(
Ethereum eth,
Blockchain blockchain,
RskSystemProperties properties,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule, RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
NetworkStateExporter networkStateExporter,
BlockStore blockStore,
ReceiptStore receiptStore,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever retriever); void ext_dumpState(); void ext_dumpBlockchain(long numberOfBlocks, boolean includeUncles); }
|
Web3RskImpl extends Web3Impl { public void ext_dumpState() { Block bestBlcock = blockStore.getBestBlock(); logger.info("Dumping state for block hash {}, block number {}", bestBlcock.getHash(), bestBlcock.getNumber()); networkStateExporter.exportStatus(System.getProperty("user.dir") + "/" + "rskdump.json"); } Web3RskImpl(
Ethereum eth,
Blockchain blockchain,
RskSystemProperties properties,
MinerClient minerClient,
MinerServer minerServer,
PersonalModule personalModule,
EthModule ethModule,
EvmModule evmModule,
TxPoolModule txPoolModule,
MnrModule mnrModule,
DebugModule debugModule,
TraceModule traceModule, RskModule rskModule,
ChannelManager channelManager,
PeerScoringManager peerScoringManager,
NetworkStateExporter networkStateExporter,
BlockStore blockStore,
ReceiptStore receiptStore,
PeerServer peerServer,
BlockProcessor nodeBlockProcessor,
HashRateCalculator hashRateCalculator,
ConfigCapabilities configCapabilities,
BuildInfo buildInfo,
BlocksBloomStore blocksBloomStore,
Web3InformationRetriever retriever); void ext_dumpState(); void ext_dumpBlockchain(long numberOfBlocks, boolean includeUncles); }
|
@Test public void getBlock_pending() { RskJsonRpcRequestException e = TestUtils .assertThrows(RskJsonRpcRequestException.class, () -> target.getBlock("pending")); assertEquals(UNIMPLEMENTED_ERROR_CODE, (int) e.getCode()); }
|
public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } Web3InformationRetriever(TransactionPool transactionPool, Blockchain blockchain, RepositoryLocator locator); }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } Web3InformationRetriever(TransactionPool transactionPool, Blockchain blockchain, RepositoryLocator locator); Optional<Block> getBlock(String identifier); AccountInformationProvider getInformationProvider(String identifier); List<Transaction> getTransactions(String identifier); }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } Web3InformationRetriever(TransactionPool transactionPool, Blockchain blockchain, RepositoryLocator locator); Optional<Block> getBlock(String identifier); AccountInformationProvider getInformationProvider(String identifier); List<Transaction> getTransactions(String identifier); }
|
@Test public void getBlock_invalidIdentifier() { RskJsonRpcRequestException e = TestUtils .assertThrows(RskJsonRpcRequestException.class, () -> target.getBlock("pending2")); assertEquals(INVALID_PARAM_ERROR_CODE, (int) e.getCode()); }
|
public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } Web3InformationRetriever(TransactionPool transactionPool, Blockchain blockchain, RepositoryLocator locator); }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } Web3InformationRetriever(TransactionPool transactionPool, Blockchain blockchain, RepositoryLocator locator); Optional<Block> getBlock(String identifier); AccountInformationProvider getInformationProvider(String identifier); List<Transaction> getTransactions(String identifier); }
|
Web3InformationRetriever { public Optional<Block> getBlock(String identifier) { if (PENDING.equals(identifier)) { throw unimplemented("This method doesn't support 'pending' as a parameter"); } Block block; if (LATEST.equals(identifier)) { block = blockchain.getBestBlock(); } else if (EARLIEST.equals(identifier)) { block = blockchain.getBlockByNumber(0); } else { block = this.blockchain.getBlockByNumber(getBlockNumber(identifier)); } return Optional.ofNullable(block); } Web3InformationRetriever(TransactionPool transactionPool, Blockchain blockchain, RepositoryLocator locator); Optional<Block> getBlock(String identifier); AccountInformationProvider getInformationProvider(String identifier); List<Transaction> getTransactions(String identifier); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.