diff --git a/core/src/core/block.rs b/core/src/core/block.rs
index 009d975cf..b7826ac13 100644
--- a/core/src/core/block.rs
+++ b/core/src/core/block.rs
@@ -35,7 +35,6 @@ pub struct BlockHeader {
pub td: u64, // total difficulty up to this block
pub utxo_merkle: Hash,
pub tx_merkle: Hash,
- pub total_fees: u64,
pub nonce: u64,
pub pow: Proof,
}
@@ -49,7 +48,6 @@ impl Default for BlockHeader {
td: 0,
utxo_merkle: ZERO_HASH,
tx_merkle: ZERO_HASH,
- total_fees: 0,
nonce: 0,
pow: Proof::zero(),
}
@@ -65,8 +63,7 @@ impl Writeable for BlockHeader {
[write_fixed_bytes, &self.previous],
[write_i64, self.timestamp.to_timespec().sec],
[write_fixed_bytes, &self.utxo_merkle],
- [write_fixed_bytes, &self.tx_merkle],
- [write_u64, self.total_fees]);
+ [write_fixed_bytes, &self.tx_merkle]);
// make sure to not introduce any variable length data before the nonce to
// avoid complicating PoW
try!(writer.write_u64(self.nonce));
@@ -117,14 +114,12 @@ impl Writeable for Block {
/// from a binary stream.
impl Readable<Block> for Block {
fn read(reader: &mut Reader) -> Result<Block, ser::Error> {
- let (height, previous, timestamp, utxo_merkle, tx_merkle, total_fees, nonce) =
- ser_multiread!(reader,
+ let (height, previous, timestamp, utxo_merkle, tx_merkle, nonce) = ser_multiread!(reader,
read_u64,
read_32_bytes,
read_i64,
read_32_bytes,
read_32_bytes,
- read_u64,
read_u64);
// cuckoo cycle of 42 nodes
@@ -156,7 +151,6 @@ impl Readable<Block> for Block {
td: td,
utxo_merkle: Hash::from_vec(utxo_merkle),
tx_merkle: Hash::from_vec(tx_merkle),
- total_fees: total_fees,
pow: Proof(pow),
nonce: nonce,
},
@@ -178,7 +172,7 @@ impl Committed for Block {
&self.outputs
}
fn overage(&self) -> i64 {
- (REWARD as i64) - (self.header.total_fees as i64)
+ (REWARD as i64) - (self.total_fees() as i64)
}
}
@@ -234,12 +228,10 @@ impl Block {
outputs.sort_by_key(|out| out.hash());
// calculate the overall Merkle tree and fees
- let fees = txs.iter().map(|tx| tx.fee).sum();
Ok(Block {
header: BlockHeader {
height: prev.height + 1,
- total_fees: fees,
timestamp: time::now(),
..Default::default()
},
@@ -254,6 +246,10 @@ impl Block {
self.header.hash()
}
+ pub fn total_fees(&self) -> u64 {
+ self.proofs.iter().map(|p| p.fee).sum()
+ }
+
/// Matches any output with a potential spending input, eliminating them
/// from the block. Provides a simple way to compact the block. The
/// elimination is stable with respect to inputs and outputs order.
@@ -311,11 +307,7 @@ impl Block {
Block {
// compact will fix the merkle tree
- header: BlockHeader {
- total_fees: self.header.total_fees + other.header.total_fees,
- pow: self.header.pow.clone(),
- ..self.header
- },
+ header: BlockHeader { pow: self.header.pow.clone(), ..self.header },
inputs: all_inputs,
outputs: all_outputs,
proofs: all_proofs,
@@ -339,11 +331,8 @@ impl Block {
}
// verify all signatures with the commitment as pk
- let msg = try!(Message::from_slice(&[0; 32]));
for proof in &self.proofs {
- let pubk = try!(proof.remainder.to_pubkey(secp));
- let sig = try!(Signature::from_der(secp, &proof.sig));
- try!(secp.verify(&msg, &sig, &pubk));
+ try!(proof.verify(secp));
}
Ok(())
}
@@ -367,6 +356,7 @@ impl Block {
let proof = TxProof {
remainder: remainder,
sig: sig.serialize_der(&secp),
+ fee: 0,
};
Ok((output, proof))
}
diff --git a/core/src/core/transaction.rs b/core/src/core/transaction.rs
index a221ebf2c..91852e165 100644
--- a/core/src/core/transaction.rs
+++ b/core/src/core/transaction.rs
@@ -14,6 +14,7 @@
//! Transactions
+use byteorder::{ByteOrder, BigEndian};
use secp::{self, Secp256k1, Message, Signature};
use secp::key::SecretKey;
use secp::pedersen::{RangeProof, Commitment};
@@ -24,34 +25,54 @@ use core::MerkleRow;
use core::hash::{Hash, Hashed};
use ser::{self, Reader, Writer, Readable, Writeable};
-/// A proof that a transaction did not create (or remove) funds. Includes both
-/// the transaction's Pedersen commitment and the signature that guarantees
-/// that the commitment amounts to zero.
+/// A proof that a transaction sums to zero. Includes both the transaction's
+/// Pedersen commitment and the signature, that guarantees that the commitments
+/// amount to zero. The signature signs the fee, which is retained for
+/// signature validation.
#[derive(Debug, Clone)]
pub struct TxProof {
- /// temporarily public
+ /// Remainder of the sum of all transaction commitments. If the transaction
+ /// is well formed, amounts components should sum to zero and the remainder
+ /// is hence a valid public key.
pub remainder: Commitment,
- /// temporarily public
+ /// The signature proving the remainder is a valid public key, which signs
+ /// the transaction fee.
pub sig: Vec<u8>,
+ /// Fee originally included in the transaction this proof is for.
+ pub fee: u64,
}
impl Writeable for TxProof {
fn write(&self, writer: &mut Writer) -> Result<(), ser::Error> {
try!(writer.write_fixed_bytes(&self.remainder));
- writer.write_bytes(&self.sig)
+ try!(writer.write_bytes(&self.sig));
+ writer.write_u64(self.fee)
}
}
impl Readable<TxProof> for TxProof {
fn read(reader: &mut Reader) -> Result<TxProof, ser::Error> {
- let (remainder, sig) = ser_multiread!(reader, read_33_bytes, read_vec);
+ let (remainder, sig, fee) = ser_multiread!(reader, read_33_bytes, read_vec, read_u64);
Ok(TxProof {
remainder: Commitment::from_vec(remainder),
sig: sig,
+ fee: fee,
})
}
}
+impl TxProof {
+ /// Verify the transaction proof validity. Entails handling the commitment
+ /// as a public key and checking the signature verifies with the fee as
+ /// message.
+ pub fn verify(&self, secp: &Secp256k1) -> Result<(), secp::Error> {
+ let msg = try!(Message::from_slice(&u64_to_32bytes(self.fee)));
+ let pubk = try!(self.remainder.to_pubkey(secp));
+ let sig = try!(Signature::from_der(secp, &self.sig));
+ secp.verify(&msg, &sig, &pubk)
+ }
+}
+
/// A transaction
#[derive(Debug)]
pub struct Transaction {
@@ -172,7 +193,7 @@ impl Transaction {
// and sign with the remainder so the signature can be checked to match with
// the k.G commitment leftover, that should also be the pubkey
- let msg = try!(Message::from_slice(&[0; 32]));
+ let msg = try!(Message::from_slice(&u64_to_32bytes(self.fee)));
let sig = try!(secp.sign(&msg, &remainder));
Ok(Transaction {
@@ -205,13 +226,14 @@ impl Transaction {
// pretend the sum is a public key (which it is, being of the form r.G) and
// verify the transaction sig with it
let pubk = try!(rsum.to_pubkey(secp));
- let msg = try!(Message::from_slice(&[0; 32]));
+ let msg = try!(Message::from_slice(&u64_to_32bytes(self.fee)));
let sig = try!(Signature::from_der(secp, &self.zerosig));
try!(secp.verify(&msg, &sig, &pubk));
Ok(TxProof {
remainder: rsum,
sig: self.zerosig.clone(),
+ fee: self.fee,
})
}
}
@@ -365,6 +387,12 @@ pub fn merkle_inputs_outputs(inputs: &Vec<Input>, outputs: &Vec<Output>) -> Hash
MerkleRow::new(all_hs).root()
}
+fn u64_to_32bytes(n: u64) -> [u8; 32] {
+ let mut bytes = [0; 32];
+ BigEndian::write_u64(&mut bytes[24..32], n);
+ bytes
+}
+
#[cfg(test)]
mod test {
use super::*;
diff --git a/core/src/genesis.rs b/core/src/genesis.rs
index 1fa92d7bb..58a76d68f 100644
--- a/core/src/genesis.rs
+++ b/core/src/genesis.rs
@@ -31,7 +31,7 @@ pub fn genesis() -> core::Block {
core::Block {
header: core::BlockHeader {
height: 0,
- previous: core::hash::ZERO_HASH,
+ previous: core::hash::Hash([0xff; 32]),
timestamp: time::Tm {
tm_year: 1997,
tm_mon: 7,
@@ -41,7 +41,6 @@ pub fn genesis() -> core::Block {
td: 0,
utxo_merkle: core::hash::Hash::from_vec(empty_h.to_vec()),
tx_merkle: core::hash::Hash::from_vec(empty_h.to_vec()),
- total_fees: 0,
nonce: 0,
pow: core::Proof::zero(), // TODO get actual PoW solution
},
diff --git a/core/src/pow/mod.rs b/core/src/pow/mod.rs
index 574249c5b..936a0eddf 100644
--- a/core/src/pow/mod.rs
+++ b/core/src/pow/mod.rs
@@ -47,7 +47,6 @@ struct PowHeader {
pub timestamp: time::Tm,
pub utxo_merkle: Hash,
pub tx_merkle: Hash,
- pub total_fees: u64,
pub n_in: u64,
pub n_out: u64,
pub n_proofs: u64,
@@ -64,7 +63,6 @@ impl Writeable for PowHeader {
try!(writer.write_i64(self.timestamp.to_timespec().sec));
try!(writer.write_fixed_bytes(&self.utxo_merkle));
try!(writer.write_fixed_bytes(&self.tx_merkle));
- try!(writer.write_u64(self.total_fees));
try!(writer.write_u64(self.n_in));
try!(writer.write_u64(self.n_out));
writer.write_u64(self.n_proofs)
@@ -81,7 +79,6 @@ impl PowHeader {
timestamp: h.timestamp,
utxo_merkle: h.utxo_merkle,
tx_merkle: h.tx_merkle,
- total_fees: h.total_fees,
n_in: b.inputs.len() as u64,
n_out: b.outputs.len() as u64,
n_proofs: b.proofs.len() as u64,