Java Code Examples for net.bither.bitherj.crypto.mnemonic.MnemonicException#MnemonicLengthException

protected void decryptHDSeed(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    if (hdSeedId < 0 || password == null) {
        return;
    }
    String encryptedHDSeed = getEncryptedHDSeed();
    if (Utils.isEmpty(encryptedHDSeed)) {
        initHDSeedFromMnemonicSeed(password);
    } else {
        hdSeed = new EncryptedData(encryptedHDSeed).decrypt(password);
    }
}
 

public Tx newTx(String[] toAddresses, Long[] amounts) throws TxBuilderException,
        MnemonicException.MnemonicLengthException {
    List<Out> outs = AbstractDb.hdAccountAddressProvider.getUnspendOutByHDAccount(hdSeedId);
    Tx tx = TxBuilder.getInstance().buildTxFromAllAddress(outs, getNewChangeAddress(), Arrays
            .asList(amounts), Arrays.asList(toAddresses));
    return tx;
}
 

public List<byte[]> signHashes(Collection<byte[]> hashes, Collection<PathTypeIndex> paths,
                               CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    assert hashes.size() == paths.size();
    ArrayList<byte[]> sigs = new ArrayList<byte[]>();
    DeterministicKey master = masterKey(password);
    DeterministicKey account = getAccount(master);
    DeterministicKey external = getChainRootKey(account, PathType.EXTERNAL_ROOT_PATH);
    DeterministicKey internal = getChainRootKey(account, PathType.INTERNAL_ROOT_PATH);
    master.wipe();
    account.wipe();
    Iterator<byte[]> hashIterator = hashes.iterator();
    Iterator<PathTypeIndex> pathIterator = paths.iterator();
    while (hashIterator.hasNext() && pathIterator.hasNext()) {
        byte[] hash = hashIterator.next();
        PathTypeIndex path = pathIterator.next();
        DeterministicKey key;
        if (path.pathType == PathType.EXTERNAL_ROOT_PATH) {
            key = external.deriveSoftened(path.index);
        } else {
            key = internal.deriveSoftened(path.index);
        }
        TransactionSignature sig = new TransactionSignature(key.sign(hash),
                TransactionSignature.SigHash.ALL, false);
        sigs.add(ScriptBuilder.createInputScript(sig, key).getProgram());
        key.wipe();
    }
    external.wipe();
    internal.wipe();
    return sigs;
}
 

public byte[] getExternalChainRootPubExtended(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    DeterministicKey ex = externalChainRoot(password);
    byte[] pub = ex.getPubKeyExtended();
    ex.wipe();
    return pub;
}
 

public String accountPubExtendedString(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    byte[] extended = accountPubExtended(password);
    String result = "";
    if (isFromXRandom) {
        result += QRCodeUtil.XRANDOM_FLAG;
    }
    result += Utils.bytesToHexString(extended).toUpperCase();
    return result;
}
 

private DeterministicKey externalChainRoot(CharSequence password) throws MnemonicException.MnemonicLengthException {
    DeterministicKey master = masterKey(password);
    DeterministicKey accountKey = getAccount(master);
    DeterministicKey externalKey = getChainRootKey(accountKey, PathType.EXTERNAL_ROOT_PATH);
    master.wipe();
    accountKey.wipe();
    return externalKey;
}
 

private void initHDSeedFromMnemonicSeed(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    decryptMnemonicSeed(password);
    hdSeed = seedFromMnemonic(mnemonicSeed);
    wipeMnemonicSeed();
    AbstractDb.addressProvider.updateEncrypttMnmonicSeed(getHdSeedId(), new EncryptedData(hdSeed,
            password, isFromXRandom).toEncryptedString());
}
 

public byte[] getExternalChainRootPubExtended(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    DeterministicKey ex = externalChainRoot(password);
    byte[] pub = ex.getPubKeyExtended();
    ex.wipe();
    return pub;
}
 

protected void decryptHDSeed(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    if (hdSeedId < 0 || password == null) {
        return;
    }
    String encryptedHDSeed = getEncryptedHDSeed();
    if (!Utils.isEmpty(encryptedHDSeed)) {
        hdSeed = new EncryptedData(encryptedHDSeed).decrypt(password);
    }
}
 

private void send() {
    tx = null;
    HDAccount account = (HDAccount) address;
    SecureCharSequence password = new SecureCharSequence(etPassword.getText());
    try {
        tx = account.newTx(toAddress, btcAmount, AppSharedPreference.getInstance().isSegwitAddressType(), password);
    } catch (Exception e) {
        e.printStackTrace();
        btcAmount = 0;
        tx = null;
        String msg = getString(R.string.send_failed);
        if (e instanceof KeyCrypterException || e instanceof MnemonicException
                .MnemonicLengthException) {
            msg = getString(R.string.password_wrong);
        } else if (e instanceof TxBuilderException) {
            msg = e.getMessage();
        }
        final String m = msg;
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (dp.isShowing()) {
                    dp.dismiss();
                }
                DropdownMessage.showDropdownMessage(HDAccountSendActivity.this, m);
            }
        });
    } finally {
        password.wipe();
    }
    if (tx != null) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                showConfirm();
            }
        });
    }
}
 

protected DeterministicKey masterKey(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    long begin = System.currentTimeMillis();
    decryptHDSeed(password);
    DeterministicKey master = HDKeyDerivation.createMasterPrivateKey(hdSeed);
    wipeHDSeed();
    log.info("hdm keychain decrypt time: {}", System.currentTimeMillis() - begin);
    return master;
}
 

private void send(String...blockhash) {
    txs = null;
    HDAccount account = (HDAccount) address;
    SecureCharSequence password = new SecureCharSequence(etPassword.getText());
    try {
        txs = account.newForkTx(etAddress.getText().toString().trim(), btcAmount, password, splitCoin,blockhash);
    } catch (Exception e) {
        e.printStackTrace();
        btcAmount = 0;
        txs = null;
        String msg = getString(R.string.send_failed);
        if (e instanceof KeyCrypterException || e instanceof MnemonicException
                .MnemonicLengthException) {
            msg = getString(R.string.password_wrong);
        } else if (e instanceof TxBuilderException) {
            msg = e.getMessage();
        }
        final String m = msg;
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (dp.isShowing()) {
                    dp.dismiss();
                }
                DropdownMessage.showDropdownMessage(SplitBCCHDAccountSendActivity.this, m);
            }
        });
    } finally {
        password.wipe();
    }
    if (txs != null) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                showConfirm();

            }
        });
    }
}
 

public String xPubB58(CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    DeterministicKey master = masterKey(password);
    DeterministicKey purpose = master.deriveHardened(44);
    DeterministicKey coinType = purpose.deriveHardened(0);
    DeterministicKey account = coinType.deriveHardened(0);
    String xpub = account.serializePubB58();
    master.wipe();
    purpose.wipe();
    coinType.wipe();
    account.wipe();
    return xpub;
}
 

public HDAccount(byte[] mnemonicSeed, CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    this(mnemonicSeed, password, true);
}
 

public EnterpriseHDMSeed(byte[] mnemonicSeed, CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    this(mnemonicSeed, false, password);
}
 

public static final byte[] seedFromMnemonic(byte[] mnemonicSeed) throws MnemonicException
        .MnemonicLengthException {
    MnemonicCode mnemonic = MnemonicCode.instance();
    return mnemonic.toSeed(mnemonic.toMnemonic(mnemonicSeed), "");
}
 

public String getExternalChainRootPubExtendedAsHex(CharSequence password) throws
        MnemonicException.MnemonicLengthException {
    return Utils.bytesToHexString(getExternalChainRootPubExtended(password)).toUpperCase();
}
 

public HDAccountCold(SecureRandom random, CharSequence password) throws MnemonicException
        .MnemonicLengthException {
    this(randomByteFromSecureRandom(random, 16), password, random.getClass().getCanonicalName
            ().indexOf("XRandom") >= 0);
}
 

public String getExternalChainRootPubExtendedAsHex(CharSequence password) throws
        MnemonicException.MnemonicLengthException {
    return Utils.bytesToHexString(getExternalChainRootPubExtended(password)).toUpperCase();
}
 

public Tx newTx(String toAddress, Long amount, CharSequence password) throws
        TxBuilderException, MnemonicException.MnemonicLengthException {
    return newTx(new String[]{toAddress}, new Long[]{amount}, password);
}