import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
@Test
public void testCreateAccountFromScratch() throws Exception {
	
	// create new private/public key pair
	ECKeyPair keyPair = Keys.createEcKeyPair();
	
	BigInteger publicKey = keyPair.getPublicKey();
	String publicKeyHex = Numeric.toHexStringWithPrefix(publicKey);
	
	BigInteger privateKey = keyPair.getPrivateKey();
	String privateKeyHex = Numeric.toHexStringWithPrefix(privateKey);
	
	// create credentials + address from private/public key pair
	Credentials credentials = Credentials.create(new ECKeyPair(privateKey, publicKey));
	String address = credentials.getAddress();
	
	// print resulting data of new account
	System.out.println("private key: '" + privateKeyHex + "'");
	System.out.println("public key: '" + publicKeyHex + "'");
	System.out.println("address: '" + address + "'\n");
	
	// test (1) check if it's possible to transfer funds to new address
	BigInteger amountWei = Convert.toWei("0.131313", Convert.Unit.ETHER).toBigInteger();
	transferWei(getCoinbase(), address, amountWei);

	BigInteger balanceWei = getBalanceWei(address);
	BigInteger nonce = getNonce(address);
	
	assertEquals("Unexpected nonce for 'to' address", BigInteger.ZERO, nonce);
	assertEquals("Unexpected balance for 'to' address", amountWei, balanceWei);

	// test (2) funds can be transferred out of the newly created account
	BigInteger txFees = Web3jConstants.GAS_LIMIT_ETHER_TX.multiply(Web3jConstants.GAS_PRICE);
	RawTransaction txRaw = RawTransaction
			.createEtherTransaction(
					nonce, 
					Web3jConstants.GAS_PRICE, 
					Web3jConstants.GAS_LIMIT_ETHER_TX, 
					getCoinbase(), 
					amountWei.subtract(txFees));

	// sign raw transaction using the sender's credentials
	byte[] txSignedBytes = TransactionEncoder.signMessage(txRaw, credentials);
	String txSigned = Numeric.toHexString(txSignedBytes);

	// send the signed transaction to the ethereum client
	EthSendTransaction ethSendTx = web3j
			.ethSendRawTransaction(txSigned)
			.sendAsync()
			.get();

	Error error = ethSendTx.getError();
	String txHash = ethSendTx.getTransactionHash();
	assertNull(error);		
	assertFalse(txHash.isEmpty());
	
	waitForReceipt(txHash);

	assertEquals("Unexpected nonce for 'to' address", BigInteger.ONE, getNonce(address));
	assertTrue("Balance for 'from' address too large: " + getBalanceWei(address), getBalanceWei(address).compareTo(txFees) < 0);
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public static String generateWalletFile(
        String password, ECKeyPair ecKeyPair, File destinationDirectory, boolean useFullScrypt)
        throws CipherException, IOException {

    WalletFile walletFile;
    if (useFullScrypt) {
        walletFile = Wallet.createStandard(password, ecKeyPair);
    } else {
        walletFile = Wallet.createLight(password, ecKeyPair);
    }

    String fileName = getWalletFileName(walletFile);
    File destination = new File(destinationDirectory, fileName);

    ObjectMapper objectMapper = ObjectMapperFactory.getObjectMapper();
    objectMapper.writeValue(destination, walletFile);

    return fileName;
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public static Wallet generateWallet(Context context, ECKeyPair ecKeyPair,
                                    final String password)
        throws WalletNotGeneratedException
{
    try {
        final String address = Numeric.prependHexPrefix(Keys.getAddress(ecKeyPair));
        final File destDirectory = Environment.getExternalStorageDirectory().getAbsoluteFile();
        Log.d(TAG, Environment.getExternalStorageState());
        final String fileName = WalletUtils.generateWalletFile(password, ecKeyPair, destDirectory, false);
        final String destFilePath = destDirectory + "/" + fileName;

        return new Wallet(ecKeyPair, destFilePath, address);
    } catch (CipherException | IOException e)
    {
        e.printStackTrace();
        throw new WalletNotGeneratedException();
    }
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public static KeyPair decodeKeyPair(ECKeyPair ecKeyPair) {
    byte[] bytes = Numeric.toBytesPadded(ecKeyPair.getPublicKey(), 64);
    BigInteger x = Numeric.toBigInt(Arrays.copyOfRange(bytes, 0, 32));
    BigInteger y = Numeric.toBigInt(Arrays.copyOfRange(bytes, 32, 64));
    ECPoint q = curve.createPoint(x, y);
    BCECPublicKey publicKey = new BCECPublicKey(ALGORITHM, new ECPublicKeyParameters(q, dp), BouncyCastleProvider.CONFIGURATION);
    BCECPrivateKey privateKey = new BCECPrivateKey(ALGORITHM, new ECPrivateKeyParameters(ecKeyPair.getPrivateKey(), dp), publicKey, p, BouncyCastleProvider.CONFIGURATION);
    return new KeyPair(publicKey, privateKey);
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
@Override
public Single<Wallet> importPrivateKey(String privateKey, String newPassword) {
    return Single.fromCallable(() -> {
        BigInteger key = new BigInteger(privateKey, PRIVATE_KEY_RADIX);
        ECKeyPair keypair = ECKeyPair.create(key);
        WalletFile walletFile = create(newPassword, keypair, N, P);
        return new ObjectMapper().writeValueAsString(walletFile);
    }).compose(upstream -> importKeystore(upstream.blockingGet(), newPassword, newPassword));
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
private void configureSsl(NettyServerBuilder builder) throws NoSuchAlgorithmException, CertificateEncodingException, NoSuchProviderException, InvalidKeyException, SignatureException, SSLException {
    NativeLibraryLoader.loadFirstAvailable(ClassLoader.getSystemClassLoader(),
        "netty_tcnative_osx_x86_64",
        "netty_tcnative_linux_x86_64",
        "netty_tcnative_windows_x86_64"
    );
    ECKeyPair ecKeyPair = ethereumConfig.getMainCredentials().getEcKeyPair();
    KeyPair keyPair = CryptoUtil.decodeKeyPair(ecKeyPair);
    SslContextBuilder contextBuilder = SslContextBuilder.forServer(
        keyPair.getPrivate(),
        CryptoUtil.genCert(keyPair)
    );

    builder.sslContext(GrpcSslContexts.configure(contextBuilder).build());
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
@Test
public void test() throws IOException, InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchProviderException, SignatureException {
    long channelId = 1;
    ECKeyPair keyPair = Keys.createEcKeyPair();
    Address sender = new Address(Keys.getAddress(keyPair));
    int blockNumber = 1;
    File file = File.createTempFile("state_channels", ".data");
    BlockId blockId = new BlockId(channelId, blockNumber);
    FileBlockWriter store = new FileBlockWriter(blockId, file);
    Assert.assertEquals(0, store.length());

    byte[] data = {1, 2, 3};
    ChannelTransaction transaction = new ChannelTransaction(channelId, blockNumber, data);
    transaction.sign(keyPair);
    store.append(transaction);

    byte[] data1 = {1, 2, 3};
    transaction = new ChannelTransaction(channelId, blockNumber, data1);
    transaction.sign(keyPair);
    store.append(transaction);
    store.close();

    Iterator<ChannelTransaction> iterator = new FileBlockReader(blockId, file).readAll();

    Assert.assertTrue(iterator.hasNext());
    ChannelTransaction transaction1 = iterator.next();
    Assert.assertEquals(channelId, transaction1.getChannelId());
    Assert.assertEquals(blockNumber, transaction1.getBlockNumber());
    Assert.assertArrayEquals(data, transaction1.getData());
    Assert.assertEquals(sender, transaction1.getSignerAddress());

    Assert.assertTrue(iterator.hasNext());
    transaction1 = iterator.next();
    Assert.assertEquals(channelId, transaction1.getChannelId());
    Assert.assertEquals(blockNumber, transaction1.getBlockNumber());
    Assert.assertArrayEquals(data1, transaction1.getData());
    Assert.assertEquals(sender, transaction1.getSignerAddress());
    
    Assert.assertFalse(iterator.hasNext());
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public static String generateNewWalletFile(
        String password, File destinationDirectory, boolean useFullScrypt)
        throws CipherException, IOException, InvalidAlgorithmParameterException,
        NoSuchAlgorithmException, NoSuchProviderException {

    ECKeyPair ecKeyPair = Keys.createEcKeyPair();
    return generateWalletFile(password, ecKeyPair, destinationDirectory, useFullScrypt);
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public MyWallet(String privateKey) throws Exception {
  if (!WalletUtils.isValidPrivateKey(privateKey)) {
    throw new Exception("Private Key error");
  }
  credentials = Credentials.create(ECKeyPair.create(hexStringToByteArray(privateKey)));
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public static byte[] sign(ECKeyPair keyPair, byte[] hash) {
    Sign.SignatureData signatureData = Sign.signMessage(hash, keyPair);
    return signatureEncode(signatureData);
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public static void main(String[] args) throws InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchProviderException {
    ECKeyPair ecKeyPair = Keys.createEcKeyPair();
    KeyPair keyPair1 = decodeKeyPair(ecKeyPair);
    System.out.println(toString(keyPair1));
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public void sign(ECKeyPair keyPair) {
    byte[] hash = hash();
    signature = CryptoUtil.sign(keyPair, hash);
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
public ECKeyPair getEcKeyPair() {
    return ecKeyPair;
}
 

import org.web3j.crypto.ECKeyPair; //导入依赖的package包/类
private Wallet(ECKeyPair ecKeyPair, final String walletFile, final String address) {
    this.walletFile = walletFile;
    this.address = address;
    this.ecKeyPair = ecKeyPair;
}