Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.bitcoinj.wallet;
import com.google.common.collect.ImmutableList;
import org.bitcoinj.crypto.*;
import org.bitcoinj.script.Script;
import java.util.ArrayList;
import java.util.List;
import static com.google.common.base.Preconditions.checkArgument;
public class AuthenticationKeyChain extends DeterministicKeyChain {
enum KeyChainType {
BLOCKCHAIN_USER,
MASTERNODE_HOLDINGS,
MASTERNODE_OWNER,
MASTERNODE_OPERATOR,
MASTERNODE_VOTING,
}
KeyChainType type;
int currentIndex;
int issuedKeys;
public AuthenticationKeyChain(DeterministicSeed seed, ImmutableList path) {
super(seed, null, Script.ScriptType.P2PKH, path);
}
public AuthenticationKeyChain(DeterministicSeed seed, KeyCrypter keyCrypter, ImmutableList path) {
super(seed, keyCrypter, Script.ScriptType.P2PKH, path);
}
@Override
public DeterministicKey getKey(KeyPurpose purpose) {
return getKeys(purpose, 1).get(0);
}
@Override
public List getKeys(KeyPurpose purpose, int numberOfKeys) {
checkArgument(numberOfKeys > 0);
lock.lock();
try {
DeterministicKey parentKey;
int index;
switch (purpose) {
case AUTHENTICATION:
issuedKeys += numberOfKeys;
index = issuedKeys;
parentKey = getKeyByPath(getAccountPath());
break;
default:
throw new UnsupportedOperationException();
}
// Optimization: potentially do a very quick key generation for just the number of keys we need if we
// didn't already create them, ignoring the configured lookahead size. This ensures we'll be able to
// retrieve the keys in the following loop, but if we're totally fresh and didn't get a chance to
// calculate the lookahead keys yet, this will not block waiting to calculate 100+ EC point multiplies.
// On slow/crappy Android phones looking ahead 100 keys can take ~5 seconds but the OS will kill us
// if we block for just one second on the UI thread. Because UI threads may need an address in order
// to render the screen, we need getKeys to be fast even if the wallet is totally brand new and lookahead
// didn't happen yet.
//
// It's safe to do this because when a network thread tries to calculate a Bloom filter, we'll go ahead
// and calculate the full lookahead zone there, so network requests will always use the right amount.
//List lookahead = maybeLookAhead(parentKey, index, 0, 0);
//basicKeyChain.importKeys(lookahead);
List keys = new ArrayList(numberOfKeys);
for (int i = 0; i < numberOfKeys; i++) {
//ImmutableList path = HDUtils.append(parentKey.getPath(), new ChildNumber(index - numberOfKeys + i, false));
//DeterministicKey k = hierarchy.get(path, false, false);
DeterministicKey k = HDKeyDerivation.deriveChildKey(parentKey, new ChildNumber(index - numberOfKeys + i));
// Just a last minute sanity check before we hand the key out to the app for usage. This isn't inspired
// by any real problem reports from bitcoinj users, but I've heard of cases via the grapevine of
// places that lost money due to bitflips causing addresses to not match keys. Of course in an
// environment with flaky RAM there's no real way to always win: bitflips could be introduced at any
// other layer. But as we're potentially retrieving from long term storage here, check anyway.
//checkForBitFlip(k);
keys.add(k);
}
return keys;
} finally {
lock.unlock();
}
}
public DeterministicKey getKey(int index) {
return getKeyByPath(new ImmutableList.Builder().addAll(getAccountPath()).addAll(ImmutableList.of(new ChildNumber(index, false))).build(), true); }
public int getCurrentIndex() {
return currentIndex;
}
public DeterministicKey freshAuthenticationKey() {
return getKey(KeyPurpose.AUTHENTICATION);
}
public DeterministicKey currentAuthenticationKey() {
return getKey(currentIndex);
}
}
