protected TransactionSummary transform(
Transaction tx, int time, int height, int blockChainHeight) {
long value = 0;
Address destAddress = null;
for (TransactionOutput output : tx.outputs) {
if (isMine(output.script)) {
value += output.value;
} else {
destAddress = output.script.getAddress(_network);
}
}
if (tx.isCoinbase()) {
// For coinbase transactions there is nothing to subtract
} else {
for (TransactionInput input : tx.inputs) {
// find parent output
TransactionOutputEx funding = _backing.getParentTransactionOutput(input.outPoint);
if (funding == null) {
_logger.logError("Unable to find parent output for: " + input.outPoint);
continue;
}
if (isMine(funding)) {
value -= funding.value;
}
}
}
int confirmations;
if (height == -1) {
confirmations = 0;
} else {
confirmations = Math.max(0, blockChainHeight - height + 1);
}
// only track a destinationAddress if it is an outgoing transaction (i.e. send money to someone)
// to prevent the user that he tries to return money to an address he got bitcoin from.
if (value >= 0) {
destAddress = null;
}
boolean isQueuedOutgoing = _backing.isOutgoingTransaction(tx.getHash());
return new TransactionSummary(
tx.getHash(),
value,
time,
height,
confirmations,
isQueuedOutgoing,
com.google.common.base.Optional.fromNullable(destAddress));
}
private static void sendTransactionsToListener(
StoredBlock block,
NewBlockType blockType,
BlockChainListener listener,
int relativityOffset,
List<Transaction> transactions,
boolean clone,
Set<Sha256Hash> falsePositives)
throws VerificationException {
for (Transaction tx : transactions) {
try {
if (listener.isTransactionRelevant(tx)) {
falsePositives.remove(tx.getHash());
if (clone) tx = new Transaction(tx.params, tx.bitcoinSerialize());
listener.receiveFromBlock(tx, block, blockType, relativityOffset++);
}
} catch (ScriptException e) {
// We don't want scripts we don't understand to break the block chain so just note that this
// tx was
// not scanned here and continue.
log.warn("Failed to parse a script: " + e.toString());
} catch (ProtocolException e) {
// Failed to duplicate tx, should never happen.
throw new RuntimeException(e);
}
}
}
@Override
public synchronized boolean deleteTransaction(Sha256Hash transactionId) {
TransactionEx tex = _backing.getTransaction(transactionId);
if (tex == null) return false;
Transaction tx = TransactionEx.toTransaction(tex);
_backing.beginTransaction();
try {
// See if any of the outputs are stored locally and remove them
for (int i = 0; i < tx.outputs.length; i++) {
TransactionOutput output = tx.outputs[i];
OutPoint outPoint = new OutPoint(tx.getHash(), i);
TransactionOutputEx utxo = _backing.getUnspentOutput(outPoint);
if (utxo != null) {
_backing.deleteUnspentOutput(outPoint);
}
}
// remove it from the backing
_backing.deleteTransaction(transactionId);
_backing.setTransactionSuccessful();
} finally {
_backing.endTransaction();
}
updateLocalBalance(); // will still need a new sync besides re-calculating
return true;
}
public synchronized void queueTransaction(Transaction transaction) {
// Store transaction in outgoing buffer, so we can broadcast it
// later
byte[] rawTransaction = transaction.toBytes();
_backing.putOutgoingTransaction(transaction.getHash(), rawTransaction);
markTransactionAsSpent(transaction);
}
@Override
public synchronized boolean cancelQueuedTransaction(Sha256Hash transaction) {
Map<Sha256Hash, byte[]> outgoingTransactions = _backing.getOutgoingTransactions();
if (!outgoingTransactions.containsKey(transaction)) {
return false;
}
Transaction tx;
try {
tx = Transaction.fromBytes(outgoingTransactions.get(transaction));
} catch (TransactionParsingException e) {
return false;
}
_backing.beginTransaction();
try {
// See if any of the outputs are stored locally and remove them
for (int i = 0; i < tx.outputs.length; i++) {
TransactionOutput output = tx.outputs[i];
OutPoint outPoint = new OutPoint(tx.getHash(), i);
TransactionOutputEx utxo = _backing.getUnspentOutput(outPoint);
if (utxo != null) {
_backing.deleteUnspentOutput(outPoint);
}
}
// Remove a queued transaction from our outgoing buffer
_backing.removeOutgoingTransaction(transaction);
// remove it from the backing
_backing.deleteTransaction(transaction);
_backing.setTransactionSuccessful();
} finally {
_backing.endTransaction();
}
// calc the new balance to remove the outgoing amount
// the total balance will still be wrong, as we already deleted some UTXOs to build the queued
// transaction
// these will get restored after the next sync
updateLocalBalance();
// markTransactionAsSpent(transaction);
return true;
}
private void markTransactionAsSpent(Transaction transaction) {
_backing.beginTransaction();
try {
// Remove inputs from unspent, marking them as spent
for (TransactionInput input : transaction.inputs) {
TransactionOutputEx parentOutput = _backing.getUnspentOutput(input.outPoint);
if (parentOutput != null) {
_backing.deleteUnspentOutput(input.outPoint);
_backing.putParentTransactionOutput(parentOutput);
}
}
// See if any of the outputs are for ourselves and store them as
// unspent
for (int i = 0; i < transaction.outputs.length; i++) {
TransactionOutput output = transaction.outputs[i];
if (isMine(output.script)) {
_backing.putUnspentOutput(
new TransactionOutputEx(
new OutPoint(transaction.getHash(), i),
-1,
output.value,
output.script.getScriptBytes(),
false));
}
}
// Store transaction locally, so we have it in our history and don't
// need to fetch it in a minute
_backing.putTransaction(TransactionEx.fromUnconfirmedTransaction(transaction));
_backing.setTransactionSuccessful();
} finally {
_backing.endTransaction();
}
// Tell account that we have a new transaction
onNewTransaction(TransactionEx.fromUnconfirmedTransaction(transaction), transaction);
// Calculate local balance cache. It has changed because we have done
// some spending
updateLocalBalance();
persistContextIfNecessary();
}
protected Balance calculateLocalBalance() {
Collection<TransactionOutputEx> unspentOutputs =
new HashSet<TransactionOutputEx>(_backing.getAllUnspentOutputs());
long confirmed = 0;
long pendingChange = 0;
long pendingSending = 0;
long pendingReceiving = 0;
//
// Determine the value we are receiving and create a set of outpoints for fast lookup
//
Set<OutPoint> unspentOutPoints = new HashSet<OutPoint>();
for (TransactionOutputEx output : unspentOutputs) {
if (output.height == -1) {
if (isFromMe(output.outPoint.hash)) {
pendingChange += output.value;
} else {
pendingReceiving += output.value;
}
} else {
confirmed += output.value;
}
unspentOutPoints.add(output.outPoint);
}
//
// Determine the value we are sending
//
// Get the current set of unconfirmed transactions
List<Transaction> unconfirmed = new ArrayList<Transaction>();
for (TransactionEx tex : _backing.getUnconfirmedTransactions()) {
try {
Transaction t = Transaction.fromByteReader(new ByteReader(tex.binary));
unconfirmed.add(t);
} catch (TransactionParsingException e) {
// never happens, we have parsed it before
}
}
for (Transaction t : unconfirmed) {
// For each input figure out if WE are sending it by fetching the
// parent transaction and looking at the address
boolean weSend = false;
for (TransactionInput input : t.inputs) {
// Find the parent transaction
if (input.outPoint.hash.equals(Sha256Hash.ZERO_HASH)) {
continue;
}
TransactionOutputEx parent = _backing.getParentTransactionOutput(input.outPoint);
if (parent == null) {
_logger.logError("Unable to find parent transaction output: " + input.outPoint);
continue;
}
TransactionOutput parentOutput = transform(parent);
Address fundingAddress = parentOutput.script.getAddress(_network);
if (isMine(fundingAddress)) {
// One of our addresses are sending coins
pendingSending += parentOutput.value;
weSend = true;
}
}
// Now look at the outputs and if it contains change for us, then subtract that from the
// sending amount
// if it is already spent in another transaction
for (int i = 0; i < t.outputs.length; i++) {
TransactionOutput output = t.outputs[i];
Address destination = output.script.getAddress(_network);
if (weSend && isMine(destination)) {
// The funds are sent from us to us
OutPoint outPoint = new OutPoint(t.getHash(), i);
if (!unspentOutPoints.contains(outPoint)) {
// This output has been spent, subtract it from the amount sent
pendingSending -= output.value;
}
}
}
}
int blockHeight = getBlockChainHeight();
return new Balance(
confirmed,
pendingReceiving,
pendingSending,
pendingChange,
System.currentTimeMillis(),
blockHeight,
true,
_allowZeroConfSpending);
}
private void readTransaction(Protos.Transaction txProto, NetworkParameters params)
throws UnreadableWalletException {
Transaction tx = new Transaction(params);
if (txProto.hasUpdatedAt()) {
tx.setUpdateTime(new Date(txProto.getUpdatedAt()));
}
for (Protos.TransactionOutput outputProto : txProto.getTransactionOutputList()) {
Coin value = Coin.valueOf(outputProto.getValue());
byte[] scriptBytes = outputProto.getScriptBytes().toByteArray();
TransactionOutput output = new TransactionOutput(params, tx, value, scriptBytes);
tx.addOutput(output);
}
for (Protos.TransactionInput inputProto : txProto.getTransactionInputList()) {
byte[] scriptBytes = inputProto.getScriptBytes().toByteArray();
TransactionOutPoint outpoint =
new TransactionOutPoint(
params,
inputProto.getTransactionOutPointIndex() & 0xFFFFFFFFL,
byteStringToHash(inputProto.getTransactionOutPointHash()));
Coin value = inputProto.hasValue() ? Coin.valueOf(inputProto.getValue()) : null;
TransactionInput input = new TransactionInput(params, tx, scriptBytes, outpoint, value);
if (inputProto.hasSequence()) {
input.setSequenceNumber(inputProto.getSequence());
}
tx.addInput(input);
}
for (int i = 0; i < txProto.getBlockHashCount(); i++) {
ByteString blockHash = txProto.getBlockHash(i);
int relativityOffset = 0;
if (txProto.getBlockRelativityOffsetsCount() > 0)
relativityOffset = txProto.getBlockRelativityOffsets(i);
tx.addBlockAppearance(byteStringToHash(blockHash), relativityOffset);
}
if (txProto.hasLockTime()) {
tx.setLockTime(0xffffffffL & txProto.getLockTime());
}
if (txProto.hasPurpose()) {
switch (txProto.getPurpose()) {
case UNKNOWN:
tx.setPurpose(Transaction.Purpose.UNKNOWN);
break;
case USER_PAYMENT:
tx.setPurpose(Transaction.Purpose.USER_PAYMENT);
break;
case KEY_ROTATION:
tx.setPurpose(Transaction.Purpose.KEY_ROTATION);
break;
case ASSURANCE_CONTRACT_CLAIM:
tx.setPurpose(Transaction.Purpose.ASSURANCE_CONTRACT_CLAIM);
break;
case ASSURANCE_CONTRACT_PLEDGE:
tx.setPurpose(Transaction.Purpose.ASSURANCE_CONTRACT_PLEDGE);
break;
case ASSURANCE_CONTRACT_STUB:
tx.setPurpose(Transaction.Purpose.ASSURANCE_CONTRACT_STUB);
break;
default:
throw new RuntimeException("New purpose serialization not implemented");
}
} else {
// Old wallet: assume a user payment as that's the only reason a new tx would have been
// created back then.
tx.setPurpose(Transaction.Purpose.USER_PAYMENT);
}
if (txProto.hasExchangeRate()) {
Protos.ExchangeRate exchangeRateProto = txProto.getExchangeRate();
tx.setExchangeRate(
new ExchangeRate(
Coin.valueOf(exchangeRateProto.getCoinValue()),
Fiat.valueOf(
exchangeRateProto.getFiatCurrencyCode(), exchangeRateProto.getFiatValue())));
}
if (txProto.hasMemo()) tx.setMemo(txProto.getMemo());
// Peercoin: Include time
tx.setTime(txProto.getTime());
// Transaction should now be complete.
Sha256Hash protoHash = byteStringToHash(txProto.getHash());
if (!tx.getHash().equals(protoHash))
throw new UnreadableWalletException(
String.format(
"Transaction did not deserialize completely: %s vs %s", tx.getHash(), protoHash));
if (txMap.containsKey(txProto.getHash()))
throw new UnreadableWalletException(
"Wallet contained duplicate transaction " + byteStringToHash(txProto.getHash()));
txMap.put(txProto.getHash(), tx);
}
private static Protos.Transaction makeTxProto(WalletTransaction wtx) {
Transaction tx = wtx.getTransaction();
Protos.Transaction.Builder txBuilder = Protos.Transaction.newBuilder();
txBuilder
.setPool(getProtoPool(wtx))
.setHash(hashToByteString(tx.getHash()))
.setVersion((int) tx.getVersion())
.setTime(tx.getTime());
if (tx.getUpdateTime() != null) {
txBuilder.setUpdatedAt(tx.getUpdateTime().getTime());
}
if (tx.getLockTime() > 0) {
txBuilder.setLockTime((int) tx.getLockTime());
}
// Handle inputs.
for (TransactionInput input : tx.getInputs()) {
Protos.TransactionInput.Builder inputBuilder =
Protos.TransactionInput.newBuilder()
.setScriptBytes(ByteString.copyFrom(input.getScriptBytes()))
.setTransactionOutPointHash(hashToByteString(input.getOutpoint().getHash()))
.setTransactionOutPointIndex((int) input.getOutpoint().getIndex());
if (input.hasSequence()) inputBuilder.setSequence((int) input.getSequenceNumber());
if (input.getValue() != null) inputBuilder.setValue(input.getValue().value);
txBuilder.addTransactionInput(inputBuilder);
}
// Handle outputs.
for (TransactionOutput output : tx.getOutputs()) {
Protos.TransactionOutput.Builder outputBuilder =
Protos.TransactionOutput.newBuilder()
.setScriptBytes(ByteString.copyFrom(output.getScriptBytes()))
.setValue(output.getValue().value);
final TransactionInput spentBy = output.getSpentBy();
if (spentBy != null) {
Sha256Hash spendingHash = spentBy.getParentTransaction().getHash();
int spentByTransactionIndex = spentBy.getParentTransaction().getInputs().indexOf(spentBy);
outputBuilder
.setSpentByTransactionHash(hashToByteString(spendingHash))
.setSpentByTransactionIndex(spentByTransactionIndex);
}
txBuilder.addTransactionOutput(outputBuilder);
}
// Handle which blocks tx was seen in.
final Map<Sha256Hash, Integer> appearsInHashes = tx.getAppearsInHashes();
if (appearsInHashes != null) {
for (Map.Entry<Sha256Hash, Integer> entry : appearsInHashes.entrySet()) {
txBuilder.addBlockHash(hashToByteString(entry.getKey()));
txBuilder.addBlockRelativityOffsets(entry.getValue());
}
}
if (tx.hasConfidence()) {
TransactionConfidence confidence = tx.getConfidence();
Protos.TransactionConfidence.Builder confidenceBuilder =
Protos.TransactionConfidence.newBuilder();
writeConfidence(txBuilder, confidence, confidenceBuilder);
}
Protos.Transaction.Purpose purpose;
switch (tx.getPurpose()) {
case UNKNOWN:
purpose = Protos.Transaction.Purpose.UNKNOWN;
break;
case USER_PAYMENT:
purpose = Protos.Transaction.Purpose.USER_PAYMENT;
break;
case KEY_ROTATION:
purpose = Protos.Transaction.Purpose.KEY_ROTATION;
break;
case ASSURANCE_CONTRACT_CLAIM:
purpose = Protos.Transaction.Purpose.ASSURANCE_CONTRACT_CLAIM;
break;
case ASSURANCE_CONTRACT_PLEDGE:
purpose = Protos.Transaction.Purpose.ASSURANCE_CONTRACT_PLEDGE;
break;
case ASSURANCE_CONTRACT_STUB:
purpose = Protos.Transaction.Purpose.ASSURANCE_CONTRACT_STUB;
break;
default:
throw new RuntimeException("New tx purpose serialization not implemented.");
}
txBuilder.setPurpose(purpose);
ExchangeRate exchangeRate = tx.getExchangeRate();
if (exchangeRate != null) {
Protos.ExchangeRate.Builder exchangeRateBuilder =
Protos.ExchangeRate.newBuilder()
.setCoinValue(exchangeRate.coin.value)
.setFiatValue(exchangeRate.fiat.value)
.setFiatCurrencyCode(exchangeRate.fiat.currencyCode);
txBuilder.setExchangeRate(exchangeRateBuilder);
}
if (tx.getMemo() != null) txBuilder.setMemo(tx.getMemo());
return txBuilder.build();
}