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(); }