Transaction.java

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Transaction {

   public class Input {
      public byte[] prevTxHash;   // hash of the Transaction whose output is being used
      public int outputIndex;     // used output's index in the previous transaction 
      public byte[] signature;    // the signature produced to check validity

      public Input(byte[] prevHash, int index) {
         if (prevHash == null)
            prevTxHash = null;
         else
            prevTxHash = Arrays.copyOf(prevHash, prevHash.length);
         outputIndex = index;
      }
      public void addSignature(byte[] sig) {
         if (sig == null)
            signature = null;
         else
            signature = Arrays.copyOf(sig, sig.length);
      }
      public boolean equals(Object other) {
         if (other == null) {
            return false;
         }
         if (getClass() != other.getClass()) {
            return false;
         }

         Input in = (Input) other;

         if (prevTxHash.length != in.prevTxHash.length)
            return false;
         for (int i = 0; i < prevTxHash.length; i++) {
            if (prevTxHash[i] != in.prevTxHash[i])
               return false;
         }
         if (outputIndex != in.outputIndex)
            return false;
         if (signature.length != in.signature.length)
            return false;
         for (int i = 0; i < signature.length; i++) {
            if (signature[i] != in.signature[i])
               return false;
         }
         return true;
      }

      public int hashCode() {
         int hash = 1;
         hash = hash * 17 + Arrays.hashCode(prevTxHash);
         hash = hash * 31 + outputIndex;
         hash = hash * 31 + Arrays.hashCode(signature);
         return hash;
      }
   }

   public class Output {
      public double value;        // value in bitcoins of the output
      public RSAKey address;      // the address or public key of the recipient

      public Output(double v, RSAKey addr) {
         value = v;
         address = addr;
      }
      public boolean equals(Object other) {
         if (other == null) {
            return false;
         }
         if (getClass() != other.getClass()) {
            return false;
         }

         Output op = (Output) other;

         if (value != op.value)
            return false;
         if (!address.getExponent().equals(op.address.getExponent()))
            return false;
         if (!address.getModulus().equals(op.address.getModulus()))
            return false;
         return true;
      }

      public int hashCode() {
         int hash = 1;
         hash = hash * 17 + (int)value*10000;
         hash = hash * 31 + address.getExponent().hashCode();
         hash = hash * 31 + address.getModulus().hashCode();
         return hash;
      }
   }

   private byte[] hash;    // hash of the transaction, its unique id
   private ArrayList<Input> inputs;   // inputs
   private ArrayList<Output> outputs; // outputs
   private boolean coinbase;

   public Transaction() {
      inputs = new ArrayList<Input>();
      outputs = new ArrayList<Output>();
      coinbase = false;
   }

   public Transaction(Transaction tx) {
      hash = tx.hash.clone();
      inputs = new ArrayList<Input>(tx.inputs);
      outputs = new ArrayList<Output>(tx.outputs);
      coinbase = false;
   }

   // create a coinbase transaction of value coin
   // also calls finalize on it
   public Transaction(double coin, RSAKey address) {
      coinbase = true;
      inputs = new ArrayList<Input>();
      outputs = new ArrayList<Output>();
      addOutput(coin, address);
      finalize();
   }
   
   public boolean isCoinbase() {
      return coinbase;
   }
   
   public void addInput(byte[] prevTxHash, int outputIndex) {
      Input in = new Input(prevTxHash, outputIndex);
      inputs.add(in);
   }

   public void addOutput(double value, RSAKey address) {
      Output op = new Output(value, address);
      outputs.add(op);
   }

   public void removeInput(int index) {
      inputs.remove(index);
   }

   public void removeInput(UTXO ut) {
      for (int i = 0; i < inputs.size(); i++) {
         Input in = inputs.get(i);
         UTXO u = new UTXO(in.prevTxHash, in.outputIndex);
         if (u.equals(ut)) {
            inputs.remove(i);
            return;
         }
      }
   }

   public byte[] getRawDataToSign(int index) {
      // ith input and all outputs
      ArrayList<Byte> sigData = new ArrayList<Byte>();
      if (index > inputs.size()) 
         return null;
      Input in = inputs.get(index);
      byte[] prevTxHash = in.prevTxHash;
      ByteBuffer b = ByteBuffer.allocate(Integer.SIZE/8);
      b.putInt(in.outputIndex);
      byte[] outputIndex = b.array();
      if (prevTxHash != null)
         for (int i = 0; i < prevTxHash.length; i++)
            sigData.add(prevTxHash[i]);
      for (int i = 0; i < outputIndex.length; i++)
         sigData.add(outputIndex[i]);
      for (Output op : outputs) {
         ByteBuffer bo = ByteBuffer.allocate(Double.SIZE/8);
         bo.putDouble(op.value);
         byte[] value = bo.array();
         byte[] addressExponent = op.address.getExponent().toByteArray();
         byte[] addressModulus = op.address.getModulus().toByteArray();
         for (int i = 0; i < value.length; i++)
            sigData.add(value[i]);
         for (int i = 0; i < addressExponent.length; i++)
            sigData.add(addressExponent[i]);
         for (int i = 0; i < addressModulus.length; i++)
            sigData.add(addressModulus[i]);
      }
      byte[] sigD = new byte[sigData.size()];
      int i = 0;
      for(Byte sb : sigData)
         sigD[i++] = sb;
      return sigD;
   }

   public void addSignature(byte[] signature, int index) {
      inputs.get(index).addSignature(signature);
   }

   public byte[] getRawTx() {
      ArrayList<Byte> rawTx = new ArrayList<Byte>();
      for (Input in : inputs) {
         byte[] prevTxHash = in.prevTxHash;
         ByteBuffer b = ByteBuffer.allocate(Integer.SIZE/8);
         b.putInt(in.outputIndex);
         byte[] outputIndex = b.array();
         byte[] signature = in.signature;
         if (prevTxHash != null)
            for (int i = 0; i < prevTxHash.length; i++)
               rawTx.add(prevTxHash[i]);
         for (int i = 0; i < outputIndex.length; i++)
            rawTx.add(outputIndex[i]);
         if (signature != null)
            for (int i = 0; i < signature.length; i++)
               rawTx.add(signature[i]);
      }
      for (Output op : outputs) {
         ByteBuffer b = ByteBuffer.allocate(Double.SIZE/8);
         b.putDouble(op.value);
         byte[] value = b.array();
         byte[] addressExponent = op.address.getExponent().toByteArray();
         byte[] addressModulus = op.address.getModulus().toByteArray();
         for (int i = 0; i < value.length; i++)
            rawTx.add(value[i]);
         for (int i = 0; i < addressExponent.length; i++)
            rawTx.add(addressExponent[i]);
         for (int i = 0; i < addressModulus.length; i++)
            rawTx.add(addressModulus[i]);
      }
      byte[] tx = new byte[rawTx.size()];
      int i = 0;
      for(Byte b : rawTx)
         tx[i++] = b;
      return tx;
   }

   public void finalize() {
      try {
         MessageDigest md = MessageDigest.getInstance("SHA-256");
         md.update(getRawTx());
         hash = md.digest();
      } catch(NoSuchAlgorithmException x) {
         x.printStackTrace(System.err);
      }
   }

   public void setHash(byte[] h) {
      hash = h;
   }

   public byte[] getHash() {
      return hash;
   }

   public ArrayList<Input> getInputs() {
      return inputs;
   }

   public ArrayList<Output> getOutputs() {
      return outputs;
   }

   public Input getInput(int index) {
      if (index < inputs.size()) {
         return inputs.get(index);
      }
      return null;
   }

   public Output getOutput(int index) {
      if (index < outputs.size()) {
         return outputs.get(index);
      }
      return null;
   }

   public int numInputs() {
      return inputs.size();
   }

   public int numOutputs() {
      return outputs.size();
   }

   public boolean equals(Object other) {
      if (other == null) {
         return false;
      }
      if (getClass() != other.getClass()) {
         return false;
      }

      Transaction tx = (Transaction) other;
      // inputs and outputs should be same
      if (tx.numInputs() != numInputs())
         return false;

      for (int i = 0; i < numInputs(); i++) {
         if (!getInput(i).equals(tx.getInput(i)))
            return false;
      }
      
      if (tx.numOutputs() != numOutputs())
         return false;

      for (int i = 0; i < numOutputs(); i++) {
         if (!getOutput(i).equals(tx.getOutput(i)))
            return false;
      }
      return true;
   }

   public int hashCode() {
      int hash = 1;
      for (int i = 0; i < numInputs(); i++) {
         hash = hash * 31 + getInput(i).hashCode();
      }
      for (int i = 0; i < numOutputs(); i++) {
         hash = hash * 31 + getOutput(i).hashCode();
      }
      return hash;
   }
}