Java DeterministicKey类代码示例

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
private void testVector(int testCase) throws AddressFormatException {
    log.info("=======  Test vector {}", testCase);
    HDWTestVector tv = tvs[testCase];
    DeterministicKey masterPrivateKey = HDKeyDerivation.createMasterPrivateKey(Hex.decode(tv.seed));
    Assert.assertEquals(testEncode(tv.priv), testEncode(masterPrivateKey.serializePrivB58()));
    Assert.assertEquals(testEncode(tv.pub), testEncode(masterPrivateKey.serializePubB58()));
    DeterministicHierarchy dh = new DeterministicHierarchy(masterPrivateKey);
    for (int i = 0; i < tv.derived.size(); i++) {
        HDWTestVector.DerivedTestCase tc = tv.derived.get(i);
        log.info("{}", tc.name);
        Assert.assertEquals(tc.name, String.format("Test%d %s", testCase + 1, tc.getPathDescription()));
        int depth = tc.path.length - 1;
        DeterministicKey ehkey = dh.deriveChild(Arrays.asList(tc.path).subList(0, depth), false, true, tc.path[depth]);
        Assert.assertEquals(testEncode(tc.priv), testEncode(ehkey.serializePrivB58()));
        Assert.assertEquals(testEncode(tc.pub), testEncode(ehkey.serializePubB58()));
    }
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
public static DeterministicKey createMasterPubKeyFromPubB58(String xpubstr)
    throws AddressFormatException
{
    byte[] data = Base58.decodeChecked(xpubstr);
    ByteBuffer ser = ByteBuffer.wrap(data);
    if (ser.getInt() != 0x0488B21E)
        throw new AddressFormatException("bad xpub version");
    ser.get();		// depth
    ser.getInt();	// parent fingerprint
    ser.getInt();	// child number
    byte[] chainCode = new byte[32];
    ser.get(chainCode);
    byte[] pubBytes = new byte[33];
    ser.get(pubBytes);
    return HDKeyDerivation.createMasterPubKeyFromBytes(pubBytes, chainCode);
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
protected Void doInBackground(DeterministicKey... args)
{
    DeterministicKey accountKey = args[0];

    WalletApplication wallapp =
        (WalletApplication) getApplicationContext();
    NetworkParameters params = MainNetParams.get();
    String filePrefix = "btcreceive";

    HDReceiver hdrecvr = new HDReceiver(getApplicationContext(),
                             params,
                             getApplicationContext().getFilesDir(),
                             filePrefix,
                             accountKey);
    hdrecvr.persist();
    return null;
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
public HDAccount(NetworkParameters params,
                 DeterministicKey accountKey,
                 JSONObject acctNode) throws JSONException {

    mParams = params;
    mAccountKey = accountKey;

    mAccountName = acctNode.getString("name");

    mReceiveChain = new HDChain(mParams, mAccountKey,
                                acctNode.getJSONObject("receive"));
    mChangeChain = new HDChain(mParams, mAccountKey,
                               acctNode.getJSONObject("change"));

    mLogger.info("deserialized account " + mAccountName);
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
public HDReceiver(Context ctxt,
                  NetworkParameters params,
                  File dir,
                  String prefix,
                  DeterministicKey accountRootKey) {

    mParams = params;
    mDirectory = dir;
    mFilePrefix = prefix;

    // WORKAROUND - there is a bug that watch-only addresses
    // don't seem to properly scan historically; they use
    // quick catchup.  Create a real key (that we ignore) as a
    // workaround.
    //
    mWorkaroundKey = new ECKey();
    mWorkaroundKey.setCreationTimeSeconds(HDAddress.EPOCH);

    mAccountKey = accountRootKey;
    mAccount = new HDAccount(params, mAccountKey, "Account 0");
    mLogger.info("created HDReceiver");
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
public HDChain(NetworkParameters params,
               DeterministicKey accountKey,
               JSONObject chainNode)
    throws RuntimeException, JSONException {

    mParams = params;

    mChainName = chainNode.getString("name");
    mIsReceive = chainNode.getBoolean("isReceive");

    int chainnum = mIsReceive ? 0 : 1;

    mChainKey = HDKeyDerivation.deriveChildKey(accountKey, chainnum);

    mLogger.info("deserialized HDChain " + mChainName + ": " +
                 mChainKey.getPath());
    
    mAddrs = new ArrayList<HDAddress>();
    JSONArray addrobjs = chainNode.getJSONArray("addrs");
    for (int ii = 0; ii < addrobjs.length(); ++ii) {
        JSONObject addrNode = addrobjs.getJSONObject(ii);
        mAddrs.add(new HDAddress(mParams, mChainKey, addrNode));
    }
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
public HDAddress(NetworkParameters params,
                 DeterministicKey chainKey,
                 JSONObject addrNode)
    throws RuntimeException, JSONException {

    mParams = params;

    mAddrNum = addrNode.getInt("addrNum");
    mPath = addrNode.getString("path");

    // Derive ECKey.
    byte[] prvBytes = null;
    try {
        mPubBytes = Base58.decode(addrNode.getString("pubBytes"));
    } catch (AddressFormatException ex) {
        throw new RuntimeException("failed to decode pubBytes");
    }
    
    mECKey = new ECKey(prvBytes, mPubBytes);

    // Set creation time to BTCReceive epoch.
    mECKey.setCreationTimeSeconds(EPOCH);

    // Derive public key, public hash and address.
    mPubKey = mECKey.getPubKey();
    mPubKeyHash = mECKey.getPubKeyHash();
    mAddress = mECKey.toAddress(mParams);

    // Initialize transaction count and balance.  If we don't have
    // a persisted available amount, presume it is all available.
    mNumTrans = addrNode.getInt("numTrans");
    mBalance = addrNode.getLong("balance");
    mAvailable = addrNode.has("available") ?
        addrNode.getLong("available") : mBalance;

    mLogger.info("read address " + mPath + ": " + mAddress.toString());
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
private DeterministicKey getKey(int... index) throws PinModeLockedException, NoKeyLoadedException {
    ensurePin(PinMode.USER);
    ensureKey();
    List<ChildNumber> path = new ArrayList<ChildNumber>();
    for(int i : index) {
        if((i & 0x80000000) != 0) {
            path.add(new ChildNumber(i & 0x7fffffff, true));
        } else {
            path.add(new ChildNumber(i, false));
        }
    }

    return master.get(path, true, true);
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
@Override
public byte[] getPublicKey(boolean compress, int... index) throws PinModeLockedException, UnusableIndexException, IOException, NoKeyLoadedException {
    DeterministicKey key = getKey(index);
    X9ECParameters params = SECNamedCurves.getByName("secp256k1");
    ECPoint point = params.getCurve().decodePoint(key.toECKey().getPubKey());
    point = new ECPoint.Fp(point.getCurve(), point.getX(), point.getY(), compress);
    return point.getEncoded();
}
 

import com.google.bitcoin.crypto.DeterministicKey; //导入依赖的package包/类
@Override
public byte[] sign(byte[] hash, int... index) throws PinModeLockedException, UnusableIndexException, IOException, NoKeyLoadedException {
    DeterministicKey key = getKey(index);
    ECKey.ECDSASignature signature = key.toECKey().sign(new Sha256Hash(hash));
    return signature.encodeToDER();
}