Java ECKey.fromPrivate方法代码示例

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test // find node message
public void test4() {

    byte[] id = sha3("+++".getBytes(Charset.forName("UTF-8")));
    ECKey key = ECKey.fromPrivate(BigInteger.TEN);

    Message findNode = FindNodeMessage.create(id, key);
    logger.info("{}", findNode);

    byte[] wire = findNode.getPacket();
    FindNodeMessage findNode2 = (FindNodeMessage) Message.decode(wire);
    logger.info("{}", findNode2);

    assertEquals(findNode.toString(), findNode2.toString());

    String key2 = findNode2.getKey().toString();
    assertEquals(key.toString(), key2.toString());
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
public Account getAccount(RskAddress address) {
    synchronized (accessLock) {
        if (!accounts.containsKey(address)) {
            return null;
        }

        if (unlocksTimeouts.containsKey(address)) {
            long ending = unlocksTimeouts.get(address);
            long time = System.currentTimeMillis();
            if (ending < time) {
                unlocksTimeouts.remove(address);
                accounts.remove(address);
                return null;
            }
        }
        return new Account(ECKey.fromPrivate(accounts.get(address)));
    }
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test  // Pong parse data
    public void test10(){
//        wire: 84db9bf6a1f7a3444f4d4946155da16c63a51abdd6822ac683d8243f260b99b265601b769acebfe3c76ddeb6e83e924f2bac2beca0c802ff0745d349bd58bc6662d62d38c2a3bb3e167a333d7d099496ebd35e096c5c1ee1587e9bd11f20e3d80002e6a079d49bdba3a7acfc9a2881d768d1aa246c2486ab166f0305a863bd47c5d21e0e8454f8483c
//        PongMessage: {mdc=84db9bf6a1f7a3444f4d4946155da16c63a51abdd6822ac683d8243f260b99b2, signature=65601b769acebfe3c76ddeb6e83e924f2bac2beca0c802ff0745d349bd58bc6662d62d38c2a3bb3e167a333d7d099496ebd35e096c5c1ee1587e9bd11f20e3d800, type=02, data=e6a079d49bdba3a7acfc9a2881d768d1aa246c2486ab166f0305a863bd47c5d21e0e8454f8483c}

        byte[] wire =
                Hex.decode("84db9bf6a1f7a3444f4d4946155da16c63a51abdd6822ac683d8243f260b99b265601b769acebfe3c76ddeb6e83e924f2bac2beca0c802ff0745d349bd58bc6662d62d38c2a3bb3e167a333d7d099496ebd35e096c5c1ee1587e9bd11f20e3d80002e6a079d49bdba3a7acfc9a2881d768d1aa246c2486ab166f0305a863bd47c5d21e0e8454f8483c");

        PongMessage msg1 = (PongMessage)Message.decode(wire);

        ECKey key = ECKey.fromPrivate(BigInteger.TEN);
        PongMessage msg2 = PongMessage.create(msg1.getToken(), key, 1448375807);

        PongMessage msg3 = (PongMessage) Message.decode(msg2.getPacket());
        assertEquals(Hex.toHexString(msg1.getToken()), Hex.toHexString(msg3.getToken()));
    }
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Before
public void before() throws IOException, ClassNotFoundException {
    World world = new World();
    blockChain = world.getBlockChain();
    repository = blockChain.getRepository();

    whitelistManipulationKey = ECKey.fromPrivate(Hex.decode("3890187a3071327cee08467ba1b44ed4c13adb2da0d5ffcc0563c371fa88259c"));

    genesis = (Genesis)blockChain.getBestBlock();
    keyHoldingRSKs = new ECKey();
    BigInteger balance = new BigInteger("10000000000000000000");
    repository.addBalance(keyHoldingRSKs.getAddress(), balance);
    genesis.setStateRoot(repository.getRoot());
    genesis.flushRLP();

    blockChain.getBlockStore().saveBlock(genesis, genesis.getCumulativeDifficulty(), true);

    Transaction whitelistAddressTx = buildWhitelistTx();
    Transaction receiveHeadersTx = buildReceiveHeadersTx();
    Transaction registerBtctransactionTx = buildRegisterBtcTransactionTx();

    blockBase = buildBlock(genesis, whitelistAddressTx, receiveHeadersTx, registerBtctransactionTx);
    Assert.assertEquals(ImportResult.IMPORTED_BEST, blockChain.tryToConnect(blockBase));
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Ignore //TODO #POC9
    @Test  // Ping parse data
    public void test9() {
//        wire: 4c62e1b75f4003ef77032006a142bbf31772936a1e5098566b28a04a5c71c73f1f2c9f539a85458c50a554de12da9d7e69fb2507f7c0788885508d385bbe7a9538fa675712aa1eaad29902bb46eee4531d00a10fd81179e4151929f60fec4dc50001ce87302e302e302e30808454f8483c
//        PingMessage: {mdc=4c62e1b75f4003ef77032006a142bbf31772936a1e5098566b28a04a5c71c73f, signature=1f2c9f539a85458c50a554de12da9d7e69fb2507f7c0788885508d385bbe7a9538fa675712aa1eaad29902bb46eee4531d00a10fd81179e4151929f60fec4dc500, type=01, data=ce87302e302e302e30808454f8483c}

        // FIXME: wire contains empty from data
        byte[] wire =
                Hex.decode("4c62e1b75f4003ef77032006a142bbf31772936a1e5098566b28a04a5c71c73f1f2c9f539a85458c50a554de12da9d7e69fb2507f7c0788885508d385bbe7a9538fa675712aa1eaad29902bb46eee4531d00a10fd81179e4151929f60fec4dc50001ce87302e302e302e30808454f8483c");

        PingMessage msg1 = (PingMessage)Message.decode(wire);

        ECKey key = ECKey.fromPrivate(BigInteger.TEN);
        Node node = Node.instanceOf(msg1.getToHost() + ":" + msg1.getToPort());
        PingMessage msg2 =  PingMessage.create(node, node, key);
        PingMessage msg3 = (PingMessage)Message.decode(msg2.getPacket());

        assertEquals(msg1.getToHost(), msg3.getToHost());
    }
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test(expected = Exception.class)// failure on MDC
public void test5() {

    byte[] id = sha3("+++".getBytes(Charset.forName("UTF-8")));
    ECKey key = ECKey.fromPrivate(BigInteger.TEN);

    Message findNode = FindNodeMessage.create(id, key);
    logger.info("{}", findNode);

    byte[] wire = findNode.getPacket();
    wire[64]++;

    FindNodeMessage findNode2 = (FindNodeMessage) Message.decode(wire);
    logger.info("{}", findNode2);

    assertEquals(findNode.toString(), findNode2.toString());
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
public void execute(){

        byte[] key = Hex.decode(this.key);
        byte[] cipher = Hex.decode(this.cipher);

        ECKey ecKey = ECKey.fromPrivate(key);

        byte[] resultPayload = new byte[0];
        if (decryption_type.equals("aes_ctr"))
            resultPayload = ecKey.decryptAES(cipher);

        if (decryption_type.equals("ecies_sec1_altered"))
            try {
                resultPayload = ECIESCoder.decrypt(new BigInteger(Hex.toHexString(key), 16), cipher);
            } catch (Throwable e) {e.printStackTrace();}

        if (!Hex.toHexString(resultPayload).equals(payload)){
            String error = String.format("payload should be: %s, but got that result: %s  ",
                    payload, Hex.toHexString(resultPayload));
            logger.info(error);

            System.exit(-1);
        }
    }
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test // ping test
public void test1() {

    Node node = Node.instanceOf("85.65.19.231:30303");
    ECKey key = ECKey.fromPrivate(BigInteger.TEN);

    Message ping = PingMessage.create(node, node, key);
    logger.info("{}", ping);

    byte[] wire = ping.getPacket();
    PingMessage ping2 = (PingMessage) Message.decode(wire);
    logger.info("{}", ping2);

    assertEquals(ping.toString(), ping2.toString());

    String key2 = ping2.getKey().toString();
    assertEquals(key.toString(), key2.toString());
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
public String sendContractToNetwork(final boolean userContract) throws IOException, InterruptedException {
    LOGGER.info("Compiling contract...");
    final ECKey senderKey = ECKey.fromPrivate(decode(privateKey));
    CompilationResult.ContractMetadata contractBinary = null;
    if (userContract) {
        contractBinary = solidityCompilerService.compileUserContract();
    } else {
        contractBinary = solidityCompilerService.compileRegistryContract();
    }
    LOGGER.info("Preparing transaction to send contract to the network.");
    Transaction contractTransaction =
            sendTransaction(null, senderKey, ETHER_TO_TRANSFER_IN_WEI, decode(contractBinary.bin));
    if (contractTransaction != null) {
        return toHexString(contractTransaction.getContractAddress());
    } else {
        return null;
    }
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
public void simulateTxs( ) {

        key = ECKey.fromPrivate(privateKeyBytes);

        new Thread() {
            @Override
            public void run()  {
                try {
                    Thread.sleep(60000);

                    while (blockProcessor.hasBetterBlockToSync()) {
                        Thread.sleep(60000);
                    }

                    SecureRandom random = new SecureRandom();

                    AccountState accountState = repository.getAccountState(key.getAddress());
                    BigInteger nonce = accountState.getNonce();

                    while (!stop) {
                        if ((random.nextInt() % 10) == 0) {
                            nonce = repository.getAccountState(key.getAddress()).getNonce();
                        }

                        TxBuilder.this.createNewTx(nonce);
                        
                        Thread.sleep(random.nextInt(51000));
                        nonce = nonce.add(BigInteger.ONE);
                    }

                } catch (InterruptedException e) {
                    logger.error("TxBuild Thread was interrupted", e);
                    Thread.currentThread().interrupt();
                    return;
                }
            }
        }.start();
    }
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test
    public void testCpp1() throws Exception {
        byte[] cipherText1 = Hex.decode("0469e324b8ab4a8e2bf0440548498226c9864d1210248ebf76c3396dd1748f0b04d347728b683993e4061998390c2cc8d6d09611da6df9769ebec888295f9be99e86ddad866f994a494361a5658d2b48d1140d73f71a382a4dc7ee2b0b5487091b0c25a3f0e6");
        ECKey priv = ECKey.fromPrivate(Hex.decode("d0b043b4c5d657670778242d82d68a29d25d7d711127d17b8e299f156dad361a"));
        ECKey pub = ECKey.fromPublicOnly(Hex.decode("04bd27a63c91fe3233c5777e6d3d7b39204d398c8f92655947eb5a373d46e1688f022a1632d264725cbc7dc43ee1cfebde42fa0a86d08b55d2acfbb5e9b3b48dc5"));
        byte[] plain1 = ECIESCoder.decryptSimple(priv.getPrivKey(), cipherText1);
        byte[] cipherText2 = ECIESCoder.encryptSimple(pub.getPubKeyPoint(), plain1);

//        System.out.println("Cipher1: " + Hex.toHexString(cipherText1));
//        System.out.println("Cipher2: " + Hex.toHexString(cipherText2));

        byte[] plain2 = ECIESCoder.decryptSimple(priv.getPrivKey(), cipherText2);

        Assert.assertArrayEquals(plain1, plain2);
    }
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test
public void replaceCodeTest2() throws IOException, InterruptedException {
    // We test code replacement during initialization: this is forbitten.

    BigInteger nonce = ConfigHelper.CONFIG.getBlockchainConfig().getCommonConstants().getInitialNonce();
    BlockChainImpl blockchain = org.ethereum.core.ImportLightTest.createBlockchain(GenesisLoader.loadGenesis(ConfigHelper.CONFIG, nonce,
            getClass().getResourceAsStream("/genesis/genesis-light.json"), false));

    ECKey sender = ECKey.fromPrivate(Hex.decode("3ec771c31cac8c0dba77a69e503765701d3c2bb62435888d4ffa38fed60c445c"));
    System.out.println("address: " + Hex.toHexString(sender.getAddress()));

    String asm =
            "HEADER !0x01 !0x01 !0x00 "+ // (4b) header script v1
            "0x01 0x00 CODEREPLACE "+ // (5b) we attempt to replace the code
            "0x01 0x15 0x00 CODECOPY " + // (7b) Extract real code into address 0, skip first 12 bytes, copy 1 bytes
            "0x01 0x00  RETURN " + // (5b) offset 0, size 0x01, now return the first code
            "STOP "; // (1b) REAL code to install

    EVMAssembler assembler = new EVMAssembler();
    byte[] code = assembler.assemble(asm);

    // Creates a contract
    Transaction tx1 = createTx(blockchain, sender, new byte[0], code);
    TransactionExecutor executor1 = executeTransaction(blockchain, tx1);
    // Now we can directly check the store and see the new code.
    Assert.assertTrue(executor1.getResult().getException() != null);
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Ignore
@Test  /* achieve public key of the sender nonce: 01 */
public void test3() throws Exception {

    // cat --> 79b08ad8787060333663d19704909ee7b1903e58
    // cow --> cd2a3d9f938e13cd947ec05abc7fe734df8dd826

    ECKey ecKey = ECKey.fromPrivate(HashUtil.sha3("cat".getBytes()));
    byte[] senderPrivKey = HashUtil.sha3("cow".getBytes());

    byte[] nonce = {0x01};
    byte[] gasPrice = Hex.decode("09184e72a000");
    byte[] gasLimit = Hex.decode("4255");
    BigInteger value = new BigInteger("1000000000000000000000000");

    Transaction tx = new Transaction(nonce, gasPrice, gasLimit,
            ecKey.getAddress(), value.toByteArray(), null);

    tx.sign(ECKey.fromPrivate(senderPrivKey));

    System.out.println("v\t\t\t: " + Hex.toHexString(new byte[]{tx.getSignature().v}));
    System.out.println("r\t\t\t: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(tx.getSignature().r)));
    System.out.println("s\t\t\t: " + Hex.toHexString(BigIntegers.asUnsignedByteArray(tx.getSignature().s)));

    System.out.println("RLP encoded tx\t\t: " + Hex.toHexString(tx.getEncoded()));

    // retrieve the signer/sender of the transaction
    ECKey key = ECKey.signatureToKey(tx.getHash(), tx.getSignature());

    System.out.println("Tx unsigned RLP\t\t: " + Hex.toHexString(tx.getEncodedRaw()));
    System.out.println("Tx signed   RLP\t\t: " + Hex.toHexString(tx.getEncoded()));

    System.out.println("Signature public key\t: " + Hex.toHexString(key.getPubKey()));
    System.out.println("Sender is\t\t: " + Hex.toHexString(key.getAddress()));

    assertEquals("cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
            Hex.toHexString(key.getAddress()));
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
@Test
public void mine1() throws Exception {

    blockchain.setMinerCoinbase(Hex.decode("ee0250c19ad59305b2bdb61f34b45b72fe37154f"));
    Block parent = blockchain.getBestBlock();

    List<Transaction> pendingTx = new ArrayList<>();

    ECKey senderKey = ECKey.fromPrivate(Hex.decode("3ec771c31cac8c0dba77a69e503765701d3c2bb62435888d4ffa38fed60c445c"));
    byte[] receiverAddr = Hex.decode("31e2e1ed11951c7091dfba62cd4b7145e947219c");
    Transaction tx = new Transaction(new byte[] {0}, new byte[] {1}, ByteUtil.longToBytesNoLeadZeroes(0xfffff),
            receiverAddr, new byte[] {77}, new byte[0]);
    tx.sign(senderKey);
    pendingTx.add(tx);

    Block b = blockchain.createNewBlock(parent, pendingTx, Collections.EMPTY_LIST);

    System.out.println("Mining...");
    Ethash.getForBlock(SystemProperties.getDefault(), b.getNumber()).mineLight(b).get();
    System.out.println("Validating...");
    boolean valid = Ethash.getForBlock(SystemProperties.getDefault(), b.getNumber()).validate(b.getHeader());
    Assert.assertTrue(valid);

    System.out.println("Connecting...");
    ImportResult importResult = blockchain.tryToConnect(b);

    Assert.assertTrue(importResult == ImportResult.IMPORTED_BEST);
    System.out.println(Hex.toHexString(blockchain.getRepository().getRoot()));
}
 

import org.ethereum.crypto.ECKey; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    ECKey k = ECKey.fromPrivate(Hex.decode("6ef8da380c27cea8fdf7448340ea99e8e2268fc2950d79ed47cbf6f85dc977ec"));
    System.out.println(Hex.toHexString(k.getPrivKeyBytes()));
    System.out.println(Hex.toHexString(k.getAddress()));
    System.out.println(Hex.toHexString(k.getNodeId()));
}