Java Protos.Key方法代码示例

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
@Test
public void serializationUnencrypted() throws UnreadableWalletException {
    Utils.setMockClock();
    Date now = Utils.now();
    final ECKey key1 = new ECKey();
    Utils.rollMockClock(5000);
    final ECKey key2 = new ECKey();
    chain.importKeys(ImmutableList.of(key1, key2));
    List<Protos.Key> keys = chain.serializeToProtobuf();
    assertEquals(2, keys.size());
    assertArrayEquals(key1.getPubKey(), keys.get(0).getPublicKey().toByteArray());
    assertArrayEquals(key2.getPubKey(), keys.get(1).getPublicKey().toByteArray());
    assertArrayEquals(key1.getPrivKeyBytes(), keys.get(0).getSecretBytes().toByteArray());
    assertArrayEquals(key2.getPrivKeyBytes(), keys.get(1).getSecretBytes().toByteArray());
    long normTime = (long) (Math.floor(now.getTime() / 1000) * 1000);
    assertEquals(normTime, keys.get(0).getCreationTimestamp());
    assertEquals(normTime + 5000 * 1000, keys.get(1).getCreationTimestamp());

    chain = BasicKeyChain.fromProtobufUnencrypted(keys);
    assertEquals(2, chain.getKeys().size());
    assertEquals(key1, chain.getKeys().get(0));
    assertEquals(key2, chain.getKeys().get(1));
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
@Test
public void serializationEncrypted() throws UnreadableWalletException {
    ECKey key1 = new ECKey();
    chain.importKeys(key1);
    chain = chain.toEncrypted("foo bar");
    key1 = chain.getKeys().get(0);
    List<Protos.Key> keys = chain.serializeToProtobuf();
    assertEquals(1, keys.size());
    assertArrayEquals(key1.getPubKey(), keys.get(0).getPublicKey().toByteArray());
    assertFalse(keys.get(0).hasSecretBytes());
    assertTrue(keys.get(0).hasEncryptedData());
    chain = BasicKeyChain.fromProtobufEncrypted(keys, checkNotNull(chain.getKeyCrypter()));
    assertEquals(key1.getEncryptedPrivateKey(), chain.getKeys().get(0).getEncryptedPrivateKey());
    assertTrue(chain.checkPassword("foo bar"));
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
@Test
public void watching() throws UnreadableWalletException {
    ECKey key1 = new ECKey();
    ECKey pub = ECKey.fromPublicOnly(key1.getPubKeyPoint());
    chain.importKeys(pub);
    assertEquals(1, chain.numKeys());
    List<Protos.Key> keys = chain.serializeToProtobuf();
    assertEquals(1, keys.size());
    assertTrue(keys.get(0).hasPublicKey());
    assertFalse(keys.get(0).hasSecretBytes());
    chain = BasicKeyChain.fromProtobufUnencrypted(keys);
    assertEquals(1, chain.numKeys());
    assertFalse(chain.findKeyFromPubKey(pub.getPubKey()).hasPrivKey());
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
@Test
public void serializeUnencrypted() throws UnreadableWalletException {
    chain.maybeLookAhead();
    DeterministicKey key1 = chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    DeterministicKey key2 = chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    DeterministicKey key3 = chain.getKey(KeyChain.KeyPurpose.CHANGE);
    List<Protos.Key> keys = chain.serializeToProtobuf();
    // 1 mnemonic/seed, 1 master key, 1 account key, 2 internal keys, 3 derived, 20 lookahead and 5 lookahead threshold.
    int numItems =
            1  // mnemonic/seed
          + 1  // master key
          + 1  // account key
          + 2  // ext/int parent keys
          + (chain.getLookaheadSize() + chain.getLookaheadThreshold()) * 2   // lookahead zone on each chain
    ;
    assertEquals(numItems, keys.size());

    // Get another key that will be lost during round-tripping, to ensure we can derive it again.
    DeterministicKey key4 = chain.getKey(KeyChain.KeyPurpose.CHANGE);

    final String EXPECTED_SERIALIZATION = checkSerialization(keys, "deterministic-wallet-serialization.txt");

    // Round trip the data back and forth to check it is preserved.
    int oldLookaheadSize = chain.getLookaheadSize();
    chain = DeterministicKeyChain.fromProtobuf(keys, null).get(0);
    assertEquals(EXPECTED_SERIALIZATION, protoToString(chain.serializeToProtobuf()));
    assertEquals(key1, chain.findKeyFromPubHash(key1.getPubKeyHash()));
    assertEquals(key2, chain.findKeyFromPubHash(key2.getPubKeyHash()));
    assertEquals(key3, chain.findKeyFromPubHash(key3.getPubKeyHash()));
    assertEquals(key4, chain.getKey(KeyChain.KeyPurpose.CHANGE));
    key1.sign(Sha256Hash.ZERO_HASH);
    key2.sign(Sha256Hash.ZERO_HASH);
    key3.sign(Sha256Hash.ZERO_HASH);
    key4.sign(Sha256Hash.ZERO_HASH);
    assertEquals(oldLookaheadSize, chain.getLookaheadSize());
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
@Test
public void encryption() throws UnreadableWalletException {
    DeterministicKey key1 = chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    DeterministicKeyChain encChain = chain.toEncrypted("open secret");
    DeterministicKey encKey1 = encChain.findKeyFromPubKey(key1.getPubKey());
    checkEncryptedKeyChain(encChain, key1);

    // Round-trip to ensure de/serialization works and that we can store two chains and they both deserialize.
    List<Protos.Key> serialized = encChain.serializeToProtobuf();
    List<Protos.Key> doubled = Lists.newArrayListWithExpectedSize(serialized.size() * 2);
    doubled.addAll(serialized);
    doubled.addAll(serialized);
    final List<DeterministicKeyChain> chains = DeterministicKeyChain.fromProtobuf(doubled, encChain.getKeyCrypter());
    assertEquals(2, chains.size());
    encChain = chains.get(0);
    checkEncryptedKeyChain(encChain, chain.findKeyFromPubKey(key1.getPubKey()));
    encChain = chains.get(1);
    checkEncryptedKeyChain(encChain, chain.findKeyFromPubKey(key1.getPubKey()));

    DeterministicKey encKey2 = encChain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    // Decrypt and check the keys match.
    DeterministicKeyChain decChain = encChain.toDecrypted("open secret");
    DeterministicKey decKey1 = decChain.findKeyFromPubHash(encKey1.getPubKeyHash());
    DeterministicKey decKey2 = decChain.findKeyFromPubHash(encKey2.getPubKeyHash());
    assertEquals(decKey1.getPubKeyPoint(), encKey1.getPubKeyPoint());
    assertEquals(decKey2.getPubKeyPoint(), encKey2.getPubKeyPoint());
    assertFalse(decKey1.isEncrypted());
    assertFalse(decKey2.isEncrypted());
    assertNotEquals(encKey1.getParent(), decKey1.getParent());   // parts of a different hierarchy
    // Check we can once again derive keys from the decrypted chain.
    decChain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS).sign(Sha256Hash.ZERO_HASH);
    decChain.getKey(KeyChain.KeyPurpose.CHANGE).sign(Sha256Hash.ZERO_HASH);
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
@Test
public void watchingChain() throws UnreadableWalletException {
    Utils.setMockClock();
    DeterministicKey key1 = chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    DeterministicKey key2 = chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    DeterministicKey key3 = chain.getKey(KeyChain.KeyPurpose.CHANGE);
    DeterministicKey key4 = chain.getKey(KeyChain.KeyPurpose.CHANGE);

    DeterministicKey watchingKey = chain.getWatchingKey();
    final String pub58 = watchingKey.serializePubB58();
    assertEquals("xpub69KR9epSNBM59KLuasxMU5CyKytMJjBP5HEZ5p8YoGUCpM6cM9hqxB9DDPCpUUtqmw5duTckvPfwpoWGQUFPmRLpxs5jYiTf2u6xRMcdhDf", pub58);
    watchingKey = DeterministicKey.deserializeB58(null, pub58);
    watchingKey.setCreationTimeSeconds(100000);
    chain = DeterministicKeyChain.watch(watchingKey);
    assertEquals(DeterministicHierarchy.BIP32_STANDARDISATION_TIME_SECS, chain.getEarliestKeyCreationTime());
    chain.setLookaheadSize(10);
    chain.maybeLookAhead();

    assertEquals(key1.getPubKeyPoint(), chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS).getPubKeyPoint());
    assertEquals(key2.getPubKeyPoint(), chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS).getPubKeyPoint());
    final DeterministicKey key = chain.getKey(KeyChain.KeyPurpose.CHANGE);
    assertEquals(key3.getPubKeyPoint(), key.getPubKeyPoint());
    try {
        // Can't sign with a key from a watching chain.
        key.sign(Sha256Hash.ZERO_HASH);
        fail();
    } catch (ECKey.MissingPrivateKeyException e) {
        // Ignored.
    }
    // Test we can serialize and deserialize a watching chain OK.
    List<Protos.Key> serialization = chain.serializeToProtobuf();
    checkSerialization(serialization, "watching-wallet-serialization.txt");
    chain = DeterministicKeyChain.fromProtobuf(serialization, null).get(0);
    final DeterministicKey rekey4 = chain.getKey(KeyChain.KeyPurpose.CHANGE);
    assertEquals(key4.getPubKeyPoint(), rekey4.getPubKeyPoint());
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
private String protoToString(List<Protos.Key> keys) {
    StringBuilder sb = new StringBuilder();
    for (Protos.Key key : keys) {
        sb.append(key.toString());
        sb.append("\n");
    }
    return sb.toString().trim();
}
 

import org.bitcoinj.wallet.Protos; //导入方法依赖的package包/类
private String checkSerialization(List<Protos.Key> keys, String filename) {
    try {
        String sb = protoToString(keys);
        String expected = Utils.getResourceAsString(getClass().getResource(filename));
        assertEquals(expected, sb);
        return expected;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}