diff --git a/build.sbt b/build.sbt
index 7c2bdc3d2a..2de010cce3 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1 +1 @@
-import AssemblyKeys._
\ No newline at end of file
+import AssemblyKeys._

test in assembly := {} 
\ No newline at end of file
diff --git a/src/main/scala/org/bitcoins/core/crypto/ECDigitalSignature.scala b/src/main/scala/org/bitcoins/core/crypto/ECDigitalSignature.scala
index 0d139bcca9..6ff0d0d823 100644
--- a/src/main/scala/org/bitcoins/core/crypto/ECDigitalSignature.scala
+++ b/src/main/scala/org/bitcoins/core/crypto/ECDigitalSignature.scala
@@ -1,16 +1,18 @@
 package org.bitcoins.core.crypto
 
-import org.bitcoins.core.util.{BitcoinSLogger, BitcoinSUtil}
+import org.bitcoins.core.util.{BitcoinSLogger, BitcoinSUtil, Factory}
 /**
  * Created by chris on 2/26/16.
  */
 sealed trait ECDigitalSignature extends BitcoinSLogger {
 
   def hex : String = BitcoinSUtil.encodeHex(bytes)
-  def bytes : Seq[Byte]
-  def isEmpty = bytes.isEmpty
-  override def toString = hex
 
+  def bytes : Seq[Byte]
+
+  def isEmpty = bytes.isEmpty
+
+  override def toString = "ECDigitalSignature(" + hex + ")"
 
   /**
    * Checks if this signature is encoded to DER correctly
@@ -49,6 +51,33 @@ case object EmptyDigitalSignature extends ECDigitalSignature {
   def bytes = Seq()
   override def r = java.math.BigInteger.valueOf(0)
   override def s = r
-
 }
-sealed case class ECDigitalSignatureImpl(bytes : Seq[Byte]) extends ECDigitalSignature
+
+
+object ECDigitalSignature extends Factory[ECDigitalSignature] {
+  private case class ECDigitalSignatureImpl(bytes : Seq[Byte]) extends ECDigitalSignature
+
+  override def fromBytes(bytes : Seq[Byte]) : ECDigitalSignature = {
+    //this represents the empty signature
+    if (bytes.size == 1 && bytes.head == 0x0) EmptyDigitalSignature
+    else if (bytes.size == 0) EmptyDigitalSignature
+    else ECDigitalSignatureImpl(bytes)
+  }
+
+  def apply(r : BigInt, s : BigInt) = fromRS(r,s)
+  /**
+    * Takes in the r and s component of a digital signature and gives back a ECDigitalSignature object
+    * The ECDigitalSignature object complies with strict der encoding as per BIP62
+    * note: That the hash type for the signature CANNOT be added to the digital signature
+    * @param r the r component of the digital signature
+    * @param s the s component of the digital signature
+    * @return
+    */
+  def fromRS(r : BigInt, s : BigInt) : ECDigitalSignature = {
+    val rsSize = r.toByteArray.size + s.toByteArray.size
+    val totalSize = 4 + rsSize
+    val bytes : Seq[Byte] = Seq(0x30.toByte, totalSize.toByte, 0x2.toByte, r.toByteArray.size.toByte) ++
+      r.toByteArray.toSeq ++ Seq(0x2.toByte, s.toByteArray.size.toByte) ++ s.toByteArray.toSeq
+    fromBytes(bytes)
+  }
+}
diff --git a/src/main/scala/org/bitcoins/core/protocol/Address.scala b/src/main/scala/org/bitcoins/core/protocol/Address.scala
index 5cbbafe1da..115c1d6622 100644
--- a/src/main/scala/org/bitcoins/core/protocol/Address.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/Address.scala
@@ -149,6 +149,5 @@ object Address extends Factory[Address] {
 
   override def fromHex(hex : String) : Address = throw new RuntimeException("We cannot create a bitcoin address from hex - bitcoin addresses are base 58 encoded")
 
-  def apply(bytes : Seq[Byte]) : Address = fromBytes(bytes)
-  def apply(str : String) : Address = factory(str)
+  override def apply(str : String) : Address = factory(str)
 }
\ No newline at end of file
diff --git a/src/main/scala/org/bitcoins/core/protocol/blockchain/Block.scala b/src/main/scala/org/bitcoins/core/protocol/blockchain/Block.scala
index 670860233c..59b10200b9 100644
--- a/src/main/scala/org/bitcoins/core/protocol/blockchain/Block.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/blockchain/Block.scala
@@ -67,5 +67,4 @@ object Block extends Factory[Block] {
 
   def fromBytes(bytes : Seq[Byte]) : Block = RawBlockSerializer.read(bytes)
 
-  def apply(bytes : Seq[Byte]) : Block = fromBytes(bytes)
 }
\ No newline at end of file
diff --git a/src/main/scala/org/bitcoins/core/protocol/blockchain/BlockHeader.scala b/src/main/scala/org/bitcoins/core/protocol/blockchain/BlockHeader.scala
index 162ba3936f..63b9a1191e 100644
--- a/src/main/scala/org/bitcoins/core/protocol/blockchain/BlockHeader.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/blockchain/BlockHeader.scala
@@ -99,6 +99,5 @@ object BlockHeader extends Factory[BlockHeader] {
 
   def fromBytes(bytes : Seq[Byte]) : BlockHeader = RawBlockHeaderSerializer.read(bytes)
 
-  def apply(bytes : Seq[Byte]) : BlockHeader = fromBytes(bytes)
 
 }
\ No newline at end of file
diff --git a/src/main/scala/org/bitcoins/core/protocol/script/ScriptPubKey.scala b/src/main/scala/org/bitcoins/core/protocol/script/ScriptPubKey.scala
index b8b28fa2e0..4124f21c5d 100644
--- a/src/main/scala/org/bitcoins/core/protocol/script/ScriptPubKey.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/script/ScriptPubKey.scala
@@ -1,6 +1,6 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.{ECFactory, ECPublicKey}
+import org.bitcoins.core.crypto.{ECPublicKey}
 import org.bitcoins.core.serializers.script.{RawScriptPubKeyParser, ScriptParser}
 import org.bitcoins.core.protocol._
 import org.bitcoins.core.script.bitwise.{OP_EQUAL, OP_EQUALVERIFY}
@@ -88,7 +88,7 @@ trait MultiSignatureScriptPubKey extends ScriptPubKey {
    * @return
    */
   def publicKeys : Seq[ECPublicKey] = {
-    asm.filter(_.isInstanceOf[ScriptConstant]).slice(1, maxSigs.toInt + 1).map(key => ECFactory.publicKey(key.hex))
+    asm.filter(_.isInstanceOf[ScriptConstant]).slice(1, maxSigs.toInt + 1).map(key => ECPublicKey(key.hex))
   }
 }
 
@@ -105,7 +105,7 @@ trait P2SHScriptPubKey extends ScriptPubKey
  * Format: <pubkey> OP_CHECKSIG
  */
 trait P2PKScriptPubKey extends ScriptPubKey {
-  def publicKey = ECFactory.publicKey(BitcoinScriptUtil.filterPushOps(asm).head.bytes)
+  def publicKey = ECPublicKey(BitcoinScriptUtil.filterPushOps(asm).head.bytes)
 }
 
 trait NonStandardScriptPubKey extends ScriptPubKey
@@ -169,8 +169,4 @@ object ScriptPubKey extends Factory[ScriptPubKey] {
 
   def fromBytes(bytes : Seq[Byte]) : ScriptPubKey = RawScriptPubKeyParser.read(bytes)
 
-  def apply(bytes: Seq[Byte]) : ScriptPubKey = fromBytes(bytes)
-
-  def apply(hex : String) : ScriptPubKey = fromHex(hex)
-
 }
\ No newline at end of file
diff --git a/src/main/scala/org/bitcoins/core/protocol/script/ScriptSignature.scala b/src/main/scala/org/bitcoins/core/protocol/script/ScriptSignature.scala
index 75367dc8ba..467f86985d 100644
--- a/src/main/scala/org/bitcoins/core/protocol/script/ScriptSignature.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/script/ScriptSignature.scala
@@ -1,6 +1,6 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.{ECDigitalSignature, ECFactory, ECPublicKey, EmptyDigitalSignature}
+import org.bitcoins.core.crypto.{ECDigitalSignature, ECPublicKey, EmptyDigitalSignature}
 import org.bitcoins.core.protocol.NetworkElement
 import org.bitcoins.core.serializers.script.{RawScriptPubKeyParser, RawScriptSignatureParser, ScriptParser}
 import org.bitcoins.core.script.constant._
@@ -75,7 +75,7 @@ trait P2PKHScriptSignature extends ScriptSignature {
     * Gives us the public key inside of a p2pkh script signature
     * @return
     */
-  def publicKey : ECPublicKey = ECFactory.publicKey(asm.last.bytes)
+  def publicKey : ECPublicKey = ECPublicKey(asm.last.bytes)
 
   /**
     * Returns the hash type for the p2pkh script signature
@@ -84,7 +84,7 @@ trait P2PKHScriptSignature extends ScriptSignature {
   def hashType : HashType = HashTypeFactory.fromByte(signature.bytes.last)
 
   override def signatures : Seq[ECDigitalSignature] = {
-    Seq(ECFactory.digitalSignature(asm(1).hex))
+    Seq(ECDigitalSignature(asm(1).hex))
   }
 
 }
@@ -118,7 +118,7 @@ trait P2SHScriptSignature extends ScriptSignature {
   def publicKeys : Seq[ECPublicKey] = {
     val pubKeys : Seq[ScriptToken] = redeemScript.asm.filter(_.isInstanceOf[ScriptConstant])
       .filterNot(_.isInstanceOf[ScriptNumberOperation])
-    pubKeys.map(k => ECFactory.publicKey(k.hex))
+    pubKeys.map(k => ECPublicKey(k.hex))
   }
 
 
@@ -129,7 +129,7 @@ trait P2SHScriptSignature extends ScriptSignature {
   def signatures : Seq[ECDigitalSignature] = {
     val nonRedeemScript = splitAtRedeemScript(asm)._1
     val sigs = nonRedeemScript.filter(_.isInstanceOf[ScriptConstant]).filterNot(_.isInstanceOf[ScriptNumberOperation])
-    sigs.map(s => ECFactory.digitalSignature(s.hex))
+    sigs.map(s => ECDigitalSignature(s.hex))
   }
 
 
@@ -161,7 +161,7 @@ trait MultiSignatureScriptSignature extends ScriptSignature {
     */
   def signatures : Seq[ECDigitalSignature] = {
     asm.tail.filter(_.isInstanceOf[ScriptConstant])
-      .map(sig => ECFactory.digitalSignature(sig.hex))
+      .map(sig => ECDigitalSignature(sig.hex))
   }
 }
 
@@ -189,7 +189,7 @@ trait P2PKScriptSignature extends ScriptSignature {
     * @return
     */
   def signatures : Seq[ECDigitalSignature] = {
-    Seq(ECFactory.digitalSignature(BitcoinScriptUtil.filterPushOps(asm).head.hex))
+    Seq(ECDigitalSignature(BitcoinScriptUtil.filterPushOps(asm).head.hex))
   }
 }
 
@@ -346,9 +346,8 @@ object ScriptSignature extends Factory[ScriptSignature] with BitcoinSLogger {
     }
   }
 
-  def apply(bytes: Seq[Byte]) : ScriptSignature = fromBytes(bytes)
-  def apply(hex : String) : ScriptSignature = fromHex(hex)
   def apply(signature : ECDigitalSignature, pubKey : ECPublicKey) : ScriptSignature = factory(signature,pubKey)
+
   def apply(tokens : Seq[ScriptToken], scriptPubKey : ScriptPubKey) : ScriptSignature = fromScriptPubKey(tokens, scriptPubKey)
 }
 
diff --git a/src/main/scala/org/bitcoins/core/protocol/transaction/Transaction.scala b/src/main/scala/org/bitcoins/core/protocol/transaction/Transaction.scala
index 4aaa73e8fd..ee09ca15f4 100644
--- a/src/main/scala/org/bitcoins/core/protocol/transaction/Transaction.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/transaction/Transaction.scala
@@ -126,8 +126,6 @@ object Transaction extends Factory[Transaction] {
 
   def fromBytes(bytes : Seq[Byte]) : Transaction = RawTransactionParser.read(bytes)
 
-  def apply(bytes : Seq[Byte]) : Transaction = fromBytes(bytes)
-  def apply(hex: String) : Transaction = fromHex(hex)
   def apply(bytes : Array[Byte]) : Transaction = factory(bytes)
   def apply(oldTx : Transaction, lockTime : Long)  : Transaction = factory(oldTx,lockTime)
   def apply(oldTx : Transaction, updatedInputs : UpdateTransactionInputs) : Transaction = factory(oldTx, updatedInputs)
diff --git a/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionInput.scala b/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionInput.scala
index dc43dae2e5..dedbfad27b 100644
--- a/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionInput.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionInput.scala
@@ -112,8 +112,6 @@ object TransactionInput extends Factory[TransactionInput] {
 
   def apply(outPoint : TransactionOutPoint, scriptSignature : ScriptSignature, sequenceNumber : Long) : TransactionInput = factory(outPoint,scriptSignature,sequenceNumber)
 
-  def apply(bytes : Seq[Byte]) : TransactionInput = fromBytes(bytes)
-
   /**
     * Creates a coinbase input - coinbase inputs always have an empty outpoint
     * @param scriptSignature this can contain anything, miners use this to signify support for various protocol BIPs
diff --git a/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutPoint.scala b/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutPoint.scala
index 6c49df648c..7041feac94 100644
--- a/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutPoint.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutPoint.scala
@@ -58,9 +58,8 @@ object TransactionOutPoint extends Factory[TransactionOutPoint] {
 
   def fromBytes(bytes : Seq[Byte]) : TransactionOutPoint = RawTransactionOutPointParser.read(bytes)
 
-  def apply(bytes : Seq[Byte]) : TransactionOutPoint = fromBytes(bytes)
-  def apply(hex : String) : TransactionOutPoint = fromHex(hex)
   def apply(output : TransactionOutput,parentTransaction : Transaction) : TransactionOutPoint = factory(output,parentTransaction)
+
   def apply(txId : DoubleSha256Digest, index: Int) : TransactionOutPoint = factory(txId,index)
 }
 
diff --git a/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutput.scala b/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutput.scala
index ccdebaeaba..d8fd1c4c7f 100644
--- a/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutput.scala
+++ b/src/main/scala/org/bitcoins/core/protocol/transaction/TransactionOutput.scala
@@ -43,7 +43,9 @@ object TransactionOutput extends Factory[TransactionOutput] {
   def fromBytes(bytes : Seq[Byte]) : TransactionOutput = RawTransactionOutputParser.read(bytes).head
 
   def apply(oldOutput : TransactionOutput, newCurrencyUnit: CurrencyUnit) : TransactionOutput = factory(oldOutput,newCurrencyUnit)
+
   def apply(oldOutput : TransactionOutput, newScriptPubKey : ScriptPubKey) : TransactionOutput = factory(oldOutput, newScriptPubKey)
+
   def apply(currencyUnit: CurrencyUnit, scriptPubKey: ScriptPubKey) : TransactionOutput = factory(currencyUnit, scriptPubKey)
-  def apply(bytes : Seq[Byte]) : TransactionOutput = fromBytes(bytes)
+
 }
\ No newline at end of file
diff --git a/src/main/scala/org/bitcoins/core/script/constant/Constants.scala b/src/main/scala/org/bitcoins/core/script/constant/Constants.scala
index 5e2060f959..0069ab1a6d 100644
--- a/src/main/scala/org/bitcoins/core/script/constant/Constants.scala
+++ b/src/main/scala/org/bitcoins/core/script/constant/Constants.scala
@@ -133,10 +133,6 @@ object ScriptNumber extends Factory[ScriptNumber] {
     if (num == 0) zero else apply(BitcoinSUtil.longToHex(num))
   }
 
-  def apply(hex : String) : ScriptNumber = fromHex(hex)
-
-  def apply(bytes : Seq[Byte]) : ScriptNumber = fromBytes(bytes)
-
   def apply(hex : String, requireMinimal : Boolean) : Try[ScriptNumber] = {
     if (requireMinimal && !BitcoinScriptUtil.isShortestEncoding(hex)) {
       Failure(new IllegalArgumentException("The given hex was not the shortest encoding for the script number: " + hex))
@@ -404,7 +400,4 @@ object ScriptConstant extends Factory[ScriptConstant] {
     */
   def fromBytes(bytes : Seq[Byte]) : ScriptConstant = ScriptConstantImpl(BitcoinSUtil.encodeHex(bytes))
 
-  def apply(hex : String) : ScriptConstant = fromHex(hex)
-
-  def apply(bytes : Seq[Byte]) : ScriptConstant = fromBytes(bytes)
 }
diff --git a/src/main/scala/org/bitcoins/core/script/crypto/CryptoInterpreter.scala b/src/main/scala/org/bitcoins/core/script/crypto/CryptoInterpreter.scala
index 20e6b54477..8929126c73 100644
--- a/src/main/scala/org/bitcoins/core/script/crypto/CryptoInterpreter.scala
+++ b/src/main/scala/org/bitcoins/core/script/crypto/CryptoInterpreter.scala
@@ -89,8 +89,8 @@ trait CryptoInterpreter extends ControlOperationsInterpreter with BitcoinSLogger
           logger.error("OP_CHECKSIG requires at lest two stack elements")
           ScriptProgram(program,ScriptErrorInvalidStackOperation)
         } else {
-          val pubKey = ECFactory.publicKey(executionInProgressScriptProgram.stack.head.bytes)
-          val signature = ECFactory.digitalSignature(executionInProgressScriptProgram.stack.tail.head.bytes)
+          val pubKey = ECPublicKey(executionInProgressScriptProgram.stack.head.bytes)
+          val signature = ECDigitalSignature(executionInProgressScriptProgram.stack.tail.head.bytes)
 
           if (ScriptFlagUtil.requiresStrictDerEncoding(executionInProgressScriptProgram.flags) &&
             !DERSignatureUtil.isStrictDEREncoding(signature)) {
@@ -229,7 +229,7 @@ trait CryptoInterpreter extends ControlOperationsInterpreter with BitcoinSLogger
               (program.stack.tail.slice(0, nPossibleSignatures.num.toInt),
                 program.stack.tail.slice(nPossibleSignatures.num.toInt, program.stack.tail.size))
 
-            val pubKeys = pubKeysScriptTokens.map(key => ECFactory.publicKey(key.bytes))
+            val pubKeys = pubKeysScriptTokens.map(key => ECPublicKey(key.bytes))
             logger.debug("Public keys on the stack: " + pubKeys)
             logger.debug("Stack without pubkeys: " + stackWithoutPubKeys)
             logger.debug("mRequiredSignatures: " + mRequiredSignatures)
@@ -237,7 +237,7 @@ trait CryptoInterpreter extends ControlOperationsInterpreter with BitcoinSLogger
             //+1 is for the fact that we have the # of sigs + the script token indicating the # of sigs
             val signaturesScriptTokens = program.stack.tail.slice(nPossibleSignatures.num.toInt + 1,
               nPossibleSignatures.num.toInt + mRequiredSignatures.num.toInt + 1)
-            val signatures = signaturesScriptTokens.map(token => ECFactory.digitalSignature(token.bytes))
+            val signatures = signaturesScriptTokens.map(token => ECDigitalSignature(token.bytes))
             logger.debug("Signatures on the stack: " + signatures)
 
             //this contains the extra Script OP that is required for OP_CHECKMULTISIG
diff --git a/src/main/scala/org/bitcoins/core/util/Factory.scala b/src/main/scala/org/bitcoins/core/util/Factory.scala
index 52350cd3c7..3a907bbfe0 100644
--- a/src/main/scala/org/bitcoins/core/util/Factory.scala
+++ b/src/main/scala/org/bitcoins/core/util/Factory.scala
@@ -20,4 +20,17 @@ trait Factory[T] {
    */
   def fromBytes(bytes : Seq[Byte]) : T
 
+  /**
+    * Creates a T out of a sequence of bytes
+    * @param bytes
+    * @return
+    */
+  def apply(bytes : Seq[Byte]) : T = fromBytes(bytes)
+
+  /**
+    * Creates a T from a hex string
+    * @param hex
+    * @return
+    */
+  def apply(hex : String) : T = fromHex(hex)
 }
diff --git a/src/test/scala/org/bitcoins/core/crypto/DERSignatureUtilTest.scala b/src/test/scala/org/bitcoins/core/crypto/DERSignatureUtilTest.scala
index da06df4cd3..bff38e20b0 100644
--- a/src/test/scala/org/bitcoins/core/crypto/DERSignatureUtilTest.scala
+++ b/src/test/scala/org/bitcoins/core/crypto/DERSignatureUtilTest.scala
@@ -8,9 +8,9 @@ import org.scalatest.{FlatSpec, MustMatchers}
  */
 class DERSignatureUtilTest extends FlatSpec with MustMatchers {
 
-  val p2shSignature = ECFactory.digitalSignature("304402205b7d2c2f177ae76cfbbf14d589c113b0b35db753d305d5562dd0b61cbf366cfb02202e56f93c4f08a27f986cd424ffc48a462c3202c4902104d4d0ff98ed28f4bf8001")
-  val p2pkhSignature = ECFactory.digitalSignature("3044022016ffdbb7c57634903c5e018fcfc48d59f4e37dc4bc3bbc9ba4e6ee39150bca030220119c2241a931819bc1a75d3596e4029d803d1cd6de123bf8a1a1a2c3665e1fac01")
-  val p2pkSignature = ECFactory.digitalSignature("304402200a5c6163f07b8d3b013c4d1d6dba25e780b39658d79ba37af7057a3b7f15ffa102201fd9b4eaa9943f734928b99a83592c2e7bf342ea2680f6a2bb705167966b742001")
+  val p2shSignature = ECDigitalSignature("304402205b7d2c2f177ae76cfbbf14d589c113b0b35db753d305d5562dd0b61cbf366cfb02202e56f93c4f08a27f986cd424ffc48a462c3202c4902104d4d0ff98ed28f4bf8001")
+  val p2pkhSignature = ECDigitalSignature("3044022016ffdbb7c57634903c5e018fcfc48d59f4e37dc4bc3bbc9ba4e6ee39150bca030220119c2241a931819bc1a75d3596e4029d803d1cd6de123bf8a1a1a2c3665e1fac01")
+  val p2pkSignature = ECDigitalSignature("304402200a5c6163f07b8d3b013c4d1d6dba25e780b39658d79ba37af7057a3b7f15ffa102201fd9b4eaa9943f734928b99a83592c2e7bf342ea2680f6a2bb705167966b742001")
   "DERSignatureUtil" must "say that a signature taken from a p2sh transaction is a valid DER encoded signature" in  {
     DERSignatureUtil.isDEREncoded(p2shSignature) must be (true)
   }
@@ -56,18 +56,18 @@ class DERSignatureUtilTest extends FlatSpec with MustMatchers {
   }
 
   it must "say that the empty signature is a valid strictly encoded DER signature" in {
-    DERSignatureUtil.isStrictDEREncoding(ECFactory.digitalSignature("")) must be (true)
+    DERSignatureUtil.isStrictDEREncoding(ECDigitalSignature("")) must be (true)
     DERSignatureUtil.isStrictDEREncoding(EmptyDigitalSignature) must be (true)
   }
 
 
   it must "say that an overly long signature is NOT strict der encoded" in {
-    val sig = ECFactory.digitalSignature("0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+    val sig = ECDigitalSignature("0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
     DERSignatureUtil.isStrictDEREncoding(sig) must be (false)
   }
 
   it must "determine if a signature is encoded with a low s value" in {
-    val highS = ECFactory.digitalSignature("304502203e4516da7253cf068effec6b95c41221c0cf3a8e6ccb8cbf1725b562e9afde2c022100ab1e3da73d67e32045a20e0b999e049978ea8d6ee5480d485fcf2ce0d03b2ef001".toLowerCase)
+    val highS = ECDigitalSignature("304502203e4516da7253cf068effec6b95c41221c0cf3a8e6ccb8cbf1725b562e9afde2c022100ab1e3da73d67e32045a20e0b999e049978ea8d6ee5480d485fcf2ce0d03b2ef001".toLowerCase)
     DERSignatureUtil.isLowDerSignature(highS) must be (false)
   }
 }
diff --git a/src/test/scala/org/bitcoins/core/crypto/ECDigitalSignatureTest.scala b/src/test/scala/org/bitcoins/core/crypto/ECDigitalSignatureTest.scala
index 0dd8f609dd..18a6867754 100644
--- a/src/test/scala/org/bitcoins/core/crypto/ECDigitalSignatureTest.scala
+++ b/src/test/scala/org/bitcoins/core/crypto/ECDigitalSignatureTest.scala
@@ -9,23 +9,23 @@ class ECDigitalSignatureTest extends FlatSpec with MustMatchers {
 
 
   "ECDigitalSignature" must "say that empty signature is a valid DER encoded signature" in {
-    val emptySiganture = ECFactory.digitalSignature(Seq())
+    val emptySiganture = ECDigitalSignature(Seq())
     emptySiganture.isDEREncoded must be (true)
 
   }
 
   it must "say that a signature taken from a p2sh transaction is a valid DER encoded signature" in  {
-    val signature = ECFactory.digitalSignature("304402205b7d2c2f177ae76cfbbf14d589c113b0b35db753d305d5562dd0b61cbf366cfb02202e56f93c4f08a27f986cd424ffc48a462c3202c4902104d4d0ff98ed28f4bf8001")
+    val signature = ECDigitalSignature("304402205b7d2c2f177ae76cfbbf14d589c113b0b35db753d305d5562dd0b61cbf366cfb02202e56f93c4f08a27f986cd424ffc48a462c3202c4902104d4d0ff98ed28f4bf8001")
     signature.isDEREncoded must be (true)
   }
 
   it must "say that signature taken from a p2pkh transaction is a valid DER encoded signature" in  {
-    val signature = ECFactory.digitalSignature("3044022016ffdbb7c57634903c5e018fcfc48d59f4e37dc4bc3bbc9ba4e6ee39150bca030220119c2241a931819bc1a75d3596e4029d803d1cd6de123bf8a1a1a2c3665e1fac01")
+    val signature = ECDigitalSignature("3044022016ffdbb7c57634903c5e018fcfc48d59f4e37dc4bc3bbc9ba4e6ee39150bca030220119c2241a931819bc1a75d3596e4029d803d1cd6de123bf8a1a1a2c3665e1fac01")
     signature.isDEREncoded must be (true)
   }
 
   it must "say that a signature taken from a p2pk transaction is a valid DER encoded signature" in {
-    val signature = ECFactory.digitalSignature("304402200a5c6163f07b8d3b013c4d1d6dba25e780b39658d79ba37af7057a3b7f15ffa102201fd9b4eaa9943f734928b99a83592c2e7bf342ea2680f6a2bb705167966b742001")
+    val signature = ECDigitalSignature("304402200a5c6163f07b8d3b013c4d1d6dba25e780b39658d79ba37af7057a3b7f15ffa102201fd9b4eaa9943f734928b99a83592c2e7bf342ea2680f6a2bb705167966b742001")
     signature.isDEREncoded must be (true)
   }
 
@@ -33,4 +33,23 @@ class ECDigitalSignatureTest extends FlatSpec with MustMatchers {
     EmptyDigitalSignature.r must be (0)
     EmptyDigitalSignature.s must be (0)
   }
+
+
+  it must "create a digital signature from it's r,s components" in {
+    //from the tx 44e504f5b7649d215be05ad9f09026dee95201244a3b218013c504a6a49a26ff
+    val rawDigitalSignature = "3044022040f91c48f4011bf2e2edb6621bfa8fb802241de939cb86f1872c99c580ef0fe402204fc27388bc525e1b655b5f5b35f9d601d28602432dd5672f29e0a47f5b8bbb26"
+    val digitalSignature = ECDigitalSignature(rawDigitalSignature)
+    val (r,s) = (digitalSignature.r, digitalSignature.s)
+    val digitalSignatureFromRS = ECDigitalSignature(r,s)
+    digitalSignatureFromRS must be (digitalSignature)
+  }
+
+
+  it must "create an empty digital signature when given 0 in hex or byte format" in {
+    val hex = ECDigitalSignature("00")
+    val byte = ECDigitalSignature(Seq(0.toByte))
+    val emptySignature = ECDigitalSignature("")
+    byte must be (emptySignature)
+    hex must be (emptySignature)
+  }
 }
diff --git a/src/test/scala/org/bitcoins/core/crypto/ECPrivateKeyTest.scala b/src/test/scala/org/bitcoins/core/crypto/ECPrivateKeyTest.scala
index beb83c02b5..09b45880de 100644
--- a/src/test/scala/org/bitcoins/core/crypto/ECPrivateKeyTest.scala
+++ b/src/test/scala/org/bitcoins/core/crypto/ECPrivateKeyTest.scala
@@ -1,7 +1,7 @@
 package org.bitcoins.core.crypto
 
-import org.bitcoins.core.util.{BitcoinSUtil, CryptoTestUtil}
-import org.scalatest.{MustMatchers, FlatSpec}
+import org.bitcoins.core.util.{BitcoinJTestUtil, BitcoinSUtil, CryptoTestUtil}
+import org.scalatest.{FlatSpec, MustMatchers}
 
 /**
  * Created by chris on 3/7/16.
@@ -20,7 +20,7 @@ class ECPrivateKeyTest extends FlatSpec with MustMatchers {
 
   it must "create a bitcoin-s private key from a bitcoinj private key, then convert to the same public key" in {
     val bitcoinjKey = new org.bitcoinj.core.ECKey()
-    val bitcoinsPrivKey = ECFactory.privateKey(bitcoinjKey.getSecretBytes)
+    val bitcoinsPrivKey = ECPrivateKey(bitcoinjKey.getSecretBytes)
     val bitcoinsPublicKey = bitcoinsPrivKey.publicKey
     val bitcoinjPublicKey = bitcoinjKey.getPubKey
 
@@ -28,7 +28,7 @@ class ECPrivateKeyTest extends FlatSpec with MustMatchers {
   }
 
   it must "create a bitcionj private key from a bitcoins private key and get the same public key" in {
-    val bitcoinsPrivKey = ECFactory.privateKey
+    val bitcoinsPrivKey = ECPrivateKey.freshPrivateKey
     val bitcoinjPrivKey = org.bitcoinj.core.ECKey.fromPrivate(bitcoinsPrivKey.bytes.toArray)
     val bitcoinjPublicKey = bitcoinjPrivKey.getPubKey
     val bitcoinsPublicKey = bitcoinsPrivKey.publicKey
@@ -36,4 +36,32 @@ class ECPrivateKeyTest extends FlatSpec with MustMatchers {
     bitcoinsPublicKey.bytes must be (bitcoinjPublicKey)
   }
 
+  it must "create a private key from the dumped base58 in bitcoin-cli" in {
+    val privateKeyBase58 = CryptoTestUtil.privateKeyBase58
+    val bitcoinjDumpedPrivateKey = new org.bitcoinj.core.DumpedPrivateKey(BitcoinJTestUtil.params,privateKeyBase58)
+    val bitcoinjPrivateKey = bitcoinjDumpedPrivateKey.getKey
+    val privateKey = ECPrivateKey.fromBase58ToPrivateKey(privateKeyBase58)
+
+    privateKey.hex must be (bitcoinjPrivateKey.getPrivateKeyAsHex)
+
+  }
+
+  it must "create a private key from a sequence of bytes that has the same byte representation of bitcoinj ECKeys" in {
+    val bytes = CryptoTestUtil.bitcoinjPrivateKey.getPrivKeyBytes.toList
+    val bitcoinJKey = org.bitcoinj.core.ECKey.fromPrivate(bytes.toArray)
+    val privateKey : ECPrivateKey = ECPrivateKey(bytes)
+    privateKey.hex must be (bitcoinJKey.getPrivateKeyAsHex)
+  }
+
+  it must "create a private key from bytes" in {
+    val privKeyBytes = Seq(0.toByte)
+    ECPrivateKey(privKeyBytes).bytes must be (privKeyBytes)
+  }
+
+  it must "create a private key from its hex representation" in {
+    val privateKeyHex = "180cb41c7c600be951b5d3d0a7334acc7506173875834f7a6c4c786a28fcbb19"
+    val key: ECPrivateKey = ECPrivateKey(privateKeyHex)
+    key.hex must be (privateKeyHex)
+  }
+
 }
diff --git a/src/test/scala/org/bitcoins/core/crypto/ECPublicKeyTest.scala b/src/test/scala/org/bitcoins/core/crypto/ECPublicKeyTest.scala
index f16c86ba06..3ac3b4d23e 100644
--- a/src/test/scala/org/bitcoins/core/crypto/ECPublicKeyTest.scala
+++ b/src/test/scala/org/bitcoins/core/crypto/ECPublicKeyTest.scala
@@ -14,7 +14,7 @@ class ECPublicKeyTest extends FlatSpec with MustMatchers {
   "ECPublicKey" must "verify that a arbitrary piece of data was signed by the private key corresponding to a public key" in {
 
     val privateKeyHex = "180cb41c7c600be951b5d3d0a7334acc7506173875834f7a6c4c786a28fcbb19"
-    val key: ECPrivateKey = ECFactory.privateKey(privateKeyHex)
+    val key: ECPrivateKey = ECPrivateKey(privateKeyHex)
 
     val signature: ECDigitalSignature = key.sign(Sha256Hash.ZERO_HASH.getBytes.toSeq)
 
@@ -26,10 +26,10 @@ class ECPublicKeyTest extends FlatSpec with MustMatchers {
 
   it must "fail to verify a piece of data if the wrong public key is given" in {
     val privateKeyHex = "180cb41c7c600be951b5d3d0a7334acc7506173875834f7a6c4c786a28fcbb19"
-    val key: ECPrivateKey = ECFactory.privateKey(privateKeyHex)
+    val key: ECPrivateKey = ECPrivateKey(privateKeyHex)
     val signature: ECDigitalSignature = key.sign(Sha256Hash.ZERO_HASH.getBytes.toSeq)
 
-    val wrongPublicKey = ECFactory.publicKey
+    val wrongPublicKey = ECPublicKey.freshPublicKey
     val isValid : Boolean = wrongPublicKey.verify(Sha256Hash.ZERO_HASH.getBytes.toSeq,signature)
     isValid must be (false)
   }
@@ -37,15 +37,15 @@ class ECPublicKeyTest extends FlatSpec with MustMatchers {
   it must "verify a piece of data signed with a bitcoinj private key" in {
     val bitcoinjPrivKey = new org.bitcoinj.core.ECKey
     val bitcoinjSignature = bitcoinjPrivKey.sign(Sha256Hash.ZERO_HASH)
-    val bitcoinsSignature = ECFactory.digitalSignature(bitcoinjSignature.encodeToDER())
-    val bitcoinsPublicKey = ECFactory.publicKey(bitcoinjPrivKey.getPubKey)
+    val bitcoinsSignature = ECDigitalSignature(bitcoinjSignature.encodeToDER())
+    val bitcoinsPublicKey = ECPublicKey(bitcoinjPrivKey.getPubKey)
     bitcoinsPublicKey.verify(Sha256Hash.ZERO_HASH.getBytes, bitcoinsSignature) must be (true)
 
   }
 
 
   it must "verify a piece of data was signed with a bitcoins private key inside of bitcoinj" in {
-    val bitcoinsPrivKey = ECFactory.privateKey
+    val bitcoinsPrivKey = ECPrivateKey.freshPrivateKey
     val bitcoinsSignature = bitcoinsPrivKey.sign(Sha256Hash.ZERO_HASH.getBytes)
     val bitcoinjPublicKey = org.bitcoinj.core.ECKey.fromPublicOnly(bitcoinsPrivKey.publicKey.bytes.toArray)
     bitcoinjPublicKey.verify(Sha256Hash.ZERO_HASH.getBytes, bitcoinsSignature.bytes.toArray) must be (true)
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptPubKeyTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptPubKeyTest.scala
index 22bc3d6e48..b425dd2c0f 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptPubKeyTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptPubKeyTest.scala
@@ -1,7 +1,7 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.ECFactory
-import org.scalatest.{MustMatchers, FlatSpec}
+import org.bitcoins.core.crypto.ECPublicKey
+import org.scalatest.{FlatSpec, MustMatchers}
 
 /**
  * Created by chris on 3/8/16.
@@ -36,9 +36,9 @@ class MultiSignatureScriptPubKeyTest extends FlatSpec with MustMatchers {
     }
 
     multiSigScriptPubKey.publicKeys must be (Seq(
-      ECFactory.publicKey("025878e270211662a27181cf4d6ad4d2cf0e69a98a3815c086f587c7e9388d8718"),
-      ECFactory.publicKey("03fc85980e3fac1f3d8a5c3223c3ef5bffc1bd42d2cc42add8c3899cc66e7f1906"),
-      ECFactory.publicKey("0215b5bd050869166a70a7341b4f216e268b7c6c7504576dcea2cce7d11cc9a35f")
+      ECPublicKey("025878e270211662a27181cf4d6ad4d2cf0e69a98a3815c086f587c7e9388d8718"),
+      ECPublicKey("03fc85980e3fac1f3d8a5c3223c3ef5bffc1bd42d2cc42add8c3899cc66e7f1906"),
+      ECPublicKey("0215b5bd050869166a70a7341b4f216e268b7c6c7504576dcea2cce7d11cc9a35f")
     ))
 
   }
@@ -53,8 +53,8 @@ class MultiSignatureScriptPubKeyTest extends FlatSpec with MustMatchers {
     }
 
     multiSigScriptPubKey.publicKeys must be (Seq(
-      ECFactory.publicKey("02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0"),
-      ECFactory.publicKey("02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0")
+      ECPublicKey("02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0"),
+      ECPublicKey("02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0")
     ))
 
   }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptSignatureTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptSignatureTest.scala
index 00ac9d7666..affbbbb7f8 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptSignatureTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/MultiSignatureScriptSignatureTest.scala
@@ -1,7 +1,7 @@
 package org.bitcoins.core.protocol.script
 
 
-import org.bitcoins.core.crypto.{ECFactory, EmptyDigitalSignature}
+import org.bitcoins.core.crypto.{ECDigitalSignature, EmptyDigitalSignature}
 import org.bitcoins.core.script.constant.{BytesToPushOntoStack, OP_0, ScriptConstant}
 import org.bitcoins.core.util.TransactionTestUtil
 import org.scalatest.{FlatSpec, MustMatchers}
@@ -21,7 +21,7 @@ class MultiSignatureScriptSignatureTest extends FlatSpec with MustMatchers {
     val multiSigScriptSignature = ScriptSignature.fromAsm(List(OP_0, BytesToPushOntoStack(71),
       ScriptConstant("30440220b119d67d389315308d1745f734a51ff3ec72e06081e84e236fdf9dc2f5d2a64802204b04e3bc38674c4422ea317231d642b56dc09d214a1ecbbf16ecca01ed996e2201"), OP_0))
    multiSigScriptSignature.signatures must be (Seq(
-     ECFactory.digitalSignature("30440220b119d67d389315308d1745f734a51ff3ec72e06081e84e236fdf9dc2f5d2a64802204b04e3bc38674c4422ea317231d642b56dc09d214a1ecbbf16ecca01ed996e2201"),
+     ECDigitalSignature("30440220b119d67d389315308d1745f734a51ff3ec72e06081e84e236fdf9dc2f5d2a64802204b04e3bc38674c4422ea317231d642b56dc09d214a1ecbbf16ecca01ed996e2201"),
      EmptyDigitalSignature))
   }
 }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/P2PKHScriptSignatureTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/P2PKHScriptSignatureTest.scala
index 8c6afe1676..538ee6deb9 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/P2PKHScriptSignatureTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/P2PKHScriptSignatureTest.scala
@@ -1,6 +1,6 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.{ECDigitalSignature}
 import org.bitcoins.core.script.crypto.SIGHASH_ALL
 import org.bitcoins.core.util.TestUtil
 import org.scalatest.{FlatSpec, MustMatchers}
@@ -23,7 +23,7 @@ class P2PKHScriptSignatureTest extends FlatSpec with MustMatchers {
       case s : P2PKHScriptSignature => s
       case _ => throw new RuntimeException("Must be p2pkh scriptSig")
     }
-    p2pkhScriptSig.signature must be (ECFactory.digitalSignature("3044022016ffdbb7c57634903c5e018fcfc48d59f4e37dc4bc3bbc9ba4e6ee39150bca030220119c2241a931819bc1a75d3596e4029d803d1cd6de123bf8a1a1a2c3665e1fac01"))
+    p2pkhScriptSig.signature must be (ECDigitalSignature("3044022016ffdbb7c57634903c5e018fcfc48d59f4e37dc4bc3bbc9ba4e6ee39150bca030220119c2241a931819bc1a75d3596e4029d803d1cd6de123bf8a1a1a2c3665e1fac01"))
   }
 
 }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptPubKeyTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptPubKeyTest.scala
index b29af14517..c059069207 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptPubKeyTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptPubKeyTest.scala
@@ -1,6 +1,6 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.{ECPublicKey}
 import org.bitcoins.core.util.TestUtil
 import org.scalatest.{FlatSpec, MustMatchers}
 
@@ -15,6 +15,6 @@ class P2PKScriptPubKeyTest extends FlatSpec with MustMatchers {
       case _ => throw new RuntimeException("should have been p2pk script pub key")
     }
 
-    p2pkScriptPubKey.publicKey must be (ECFactory.publicKey("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"))
+    p2pkScriptPubKey.publicKey must be (ECPublicKey("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"))
   }
 }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptSignatureTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptSignatureTest.scala
index 8a8b0b2a38..2e14d116ff 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptSignatureTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/P2PKScriptSignatureTest.scala
@@ -1,8 +1,8 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.{ECDigitalSignature}
 import org.bitcoins.core.util.TestUtil
-import org.scalatest.{MustMatchers, FlatSpec}
+import org.scalatest.{FlatSpec, MustMatchers}
 
 /**
  * Created by chris on 3/16/16.
@@ -14,6 +14,6 @@ class P2PKScriptSignatureTest extends FlatSpec with MustMatchers {
       case s : P2PKScriptSignature => s
       case _ => throw new RuntimeException("SHould have been a p2pk scriptSig")
     }
-    p2pkScriptSig.signature must be (ECFactory.digitalSignature("304402200a5c6163f07b8d3b013c4d1d6dba25e780b39658d79ba37af7057a3b7f15ffa102201fd9b4eaa9943f734928b99a83592c2e7bf342ea2680f6a2bb705167966b742001"))
+    p2pkScriptSig.signature must be (ECDigitalSignature("304402200a5c6163f07b8d3b013c4d1d6dba25e780b39658d79ba37af7057a3b7f15ffa102201fd9b4eaa9943f734928b99a83592c2e7bf342ea2680f6a2bb705167966b742001"))
   }
 }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/P2SHScriptSignatureTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/P2SHScriptSignatureTest.scala
index 050a9e1441..15ff45a8a7 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/P2SHScriptSignatureTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/P2SHScriptSignatureTest.scala
@@ -1,7 +1,7 @@
 package org.bitcoins.core.protocol.script
 
 
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.{ECPublicKey}
 import org.bitcoins.core.script.constant.{BytesToPushOntoStack, OP_0, ScriptConstant}
 import org.bitcoins.core.util.TestUtil
 import org.scalatest.{FlatSpec, MustMatchers}
@@ -18,8 +18,8 @@ class P2SHScriptSignatureTest extends FlatSpec with MustMatchers {
       case y => throw new RuntimeException("Must be p2sh script sig: " + y)
     }
     p2shScriptSig.publicKeys must be (Seq(
-      ECFactory.publicKey("0369d26ebd086523384a0f89f293d4c327a65fa73332d8efd1097cb35231295b83"),
-      ECFactory.publicKey("02480863e5c4a4e9763f5380c44fcfe6a3b7787397076cf9ea1049303a9d34f721")
+      ECPublicKey("0369d26ebd086523384a0f89f293d4c327a65fa73332d8efd1097cb35231295b83"),
+      ECPublicKey("02480863e5c4a4e9763f5380c44fcfe6a3b7787397076cf9ea1049303a9d34f721")
     ))
 
   }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/ScriptPubKeyTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/ScriptPubKeyTest.scala
index 31d318c613..53242b63dc 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/ScriptPubKeyTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/ScriptPubKeyTest.scala
@@ -1,6 +1,5 @@
 package org.bitcoins.core.protocol.script
 
-import org.bitcoins.core.crypto.ECFactory
 import org.bitcoins.core.script.bitwise.OP_EQUALVERIFY
 import org.bitcoins.core.script.constant.{BytesToPushOntoStack, ScriptConstant, ScriptToken}
 import org.bitcoins.core.script.crypto.{OP_CHECKSIG, OP_CODESEPARATOR, OP_HASH160}
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureFactoryTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureFactoryTest.scala
index aa135704b4..81a881e953 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureFactoryTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureFactoryTest.scala
@@ -33,9 +33,9 @@ class ScriptSignatureFactoryTest extends FlatSpec with MustMatchers {
   }
   it must "build a script signature from a digital signature and a public key" in {
     val digitalSignatureBytes = TestUtil.p2pkhInputScriptAsm(1).bytes
-    val digitalSignature : ECDigitalSignature = ECFactory.digitalSignature(digitalSignatureBytes)
+    val digitalSignature : ECDigitalSignature = ECDigitalSignature(digitalSignatureBytes)
     val publicKeyBytes = TestUtil.p2pkhInputScriptAsm(3).bytes
-    val publicKey : ECPublicKey = ECFactory.publicKey(publicKeyBytes)
+    val publicKey : ECPublicKey = ECPublicKey(publicKeyBytes)
     val actualScriptSig : ScriptSignature = ScriptSignature(digitalSignature,publicKey)
     actualScriptSig.asm must be (TestUtil.p2pkhInputScriptAsm)
   }
diff --git a/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureTest.scala b/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureTest.scala
index 8da3368f24..7bcc1be931 100644
--- a/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureTest.scala
+++ b/src/test/scala/org/bitcoins/core/protocol/script/ScriptSignatureTest.scala
@@ -1,11 +1,11 @@
 package org.bitcoins.core.protocol.script
 
 
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.{ECDigitalSignature}
 import org.bitcoins.core.serializers.script.RawScriptSignatureParser
 import org.bitcoins.core.script.constant._
-import org.bitcoins.core.script.crypto.{SIGHASH_SINGLE, SIGHASH_ALL}
-import org.bitcoins.core.util.{BitcoinScriptUtil, TransactionTestUtil, TestUtil}
+import org.bitcoins.core.script.crypto.{SIGHASH_ALL, SIGHASH_SINGLE}
+import org.bitcoins.core.util.{BitcoinScriptUtil, TestUtil, TransactionTestUtil}
 import org.scalatest.{FlatSpec, MustMatchers}
 
 /**
@@ -32,8 +32,8 @@ class ScriptSignatureTest extends FlatSpec with MustMatchers {
   it must "find the digital signatures for a p2sh script signature for a 2/3 p2sh address" in {
     val scriptSig = TestUtil.p2shInputScript2Of2
     scriptSig.signatures must be (Seq(
-      ECFactory.digitalSignature("304402207d764cb90c9fd84b74d33a47cf3a0ffead9ded98333776becd6acd32c4426dac02203905a0d064e7f53d07793e86136571b6e4f700c1cfb888174e84d78638335b8101"),
-      ECFactory.digitalSignature("3045022100906aaca39f022acd8b7a38fd2f92aca9e9f35cfeaee69a6f13e1d083ae18222602204c9ed96fc6c4de56fd85c679fc59c16ee1ccc80c42563b86174e1a506fc007c801")
+      ECDigitalSignature("304402207d764cb90c9fd84b74d33a47cf3a0ffead9ded98333776becd6acd32c4426dac02203905a0d064e7f53d07793e86136571b6e4f700c1cfb888174e84d78638335b8101"),
+      ECDigitalSignature("3045022100906aaca39f022acd8b7a38fd2f92aca9e9f35cfeaee69a6f13e1d083ae18222602204c9ed96fc6c4de56fd85c679fc59c16ee1ccc80c42563b86174e1a506fc007c801")
     ))
   }
 
@@ -41,11 +41,11 @@ class ScriptSignatureTest extends FlatSpec with MustMatchers {
     val scriptSig = TestUtil.p2shInputScriptLargeSignature
 
     scriptSig.signatures must be (Seq(
-      ECFactory.digitalSignature("3045022100a077d4fe9a81411ecb796c254d8b4e0bc73ff86a42288bc3b3ecfa1ef26c00dd02202389bf96cf38c14c3a6ccb8c688339f3fd880b724322862547a8ee3b547a9df901"),
-      ECFactory.digitalSignature("304402207c0692464998e7f3869f8501cdd25bbcd9d32b6fd34ae8aeae643b422a8dfd42022057eb16f8ca1f34e88babc9f8beb4c2521eb5c4dea41f8902a70d045f1c132a4401"),
-      ECFactory.digitalSignature("3044022024233923253c73569f4b34723a5495698bc124b099c5542a5997d13fba7d18a802203c317bddc070276c6f6c79cb3415413e608af30e4759e31b0d53eab3ca0acd4e01"),
-      ECFactory.digitalSignature("30450221009b9f0d8b945717d2fca3685093d547a3928d122b8894903ed51e2248303213bc022008b376422c9f2cd713b9d10b5b106d1c56c5893dcc01ae300253ed2234bdb63f01"),
-      ECFactory.digitalSignature("30440220257b57cb09386d82c4328461f8fe200c2f381d6b635e2a2f4ea40c8d945e9ec102201ec67d58d51a309af4d8896e9147a42944e9f9833a456f733ea5fa6954ed2fed01")
+      ECDigitalSignature("3045022100a077d4fe9a81411ecb796c254d8b4e0bc73ff86a42288bc3b3ecfa1ef26c00dd02202389bf96cf38c14c3a6ccb8c688339f3fd880b724322862547a8ee3b547a9df901"),
+      ECDigitalSignature("304402207c0692464998e7f3869f8501cdd25bbcd9d32b6fd34ae8aeae643b422a8dfd42022057eb16f8ca1f34e88babc9f8beb4c2521eb5c4dea41f8902a70d045f1c132a4401"),
+      ECDigitalSignature("3044022024233923253c73569f4b34723a5495698bc124b099c5542a5997d13fba7d18a802203c317bddc070276c6f6c79cb3415413e608af30e4759e31b0d53eab3ca0acd4e01"),
+      ECDigitalSignature("30450221009b9f0d8b945717d2fca3685093d547a3928d122b8894903ed51e2248303213bc022008b376422c9f2cd713b9d10b5b106d1c56c5893dcc01ae300253ed2234bdb63f01"),
+      ECDigitalSignature("30440220257b57cb09386d82c4328461f8fe200c2f381d6b635e2a2f4ea40c8d945e9ec102201ec67d58d51a309af4d8896e9147a42944e9f9833a456f733ea5fa6954ed2fed01")
     ))
   }
   it must "find the hash type for a p2sh script signature" in {
diff --git a/src/test/scala/org/bitcoins/core/script/interpreter/ScriptInterpreterTest.scala b/src/test/scala/org/bitcoins/core/script/interpreter/ScriptInterpreterTest.scala
index 9a7bb86258..662bd7a139 100644
--- a/src/test/scala/org/bitcoins/core/script/interpreter/ScriptInterpreterTest.scala
+++ b/src/test/scala/org/bitcoins/core/script/interpreter/ScriptInterpreterTest.scala
@@ -1,27 +1,13 @@
 package org.bitcoins.core.script.interpreter
 
-import java.io.File
 
-import com.sun.org.apache.bcel.internal.generic.NOP
-import org.bitcoins.core.protocol.script.{EmptyScriptSignature, ScriptPubKey, ScriptSignature}
+import org.bitcoins.core.protocol.script.ScriptPubKey
 import org.bitcoins.core.script.ScriptProgram
-import org.bitcoins.core.script.bitwise.{OP_EQUAL, OP_EQUALVERIFY}
-import org.bitcoins.core.script.constant._
-import org.bitcoins.core.script.control.OP_VERIFY
-import org.bitcoins.core.script.crypto.{OP_CHECKSIG, OP_HASH160, SIGHASH_ALL}
-import org.bitcoins.core.script.flag.{ScriptFlagFactory, ScriptVerifyP2SH}
+import org.bitcoins.core.script.flag.{ScriptFlagFactory}
 import org.bitcoins.core.script.interpreter.testprotocol.{CoreTestCase, CoreTestCaseProtocol}
-import org.bitcoins.core.script.reserved.OP_NOP
-import org.bitcoins.core.script.stack.OP_DUP
 import org.bitcoins.core.util._
 import org.scalatest.{FlatSpec, MustMatchers}
-import org.slf4j.LoggerFactory
 import CoreTestCaseProtocol._
-import org.bitcoins.core.crypto.{ECFactory, TransactionSignatureSerializer}
-import org.bitcoins.core.policy.Policy
-import org.bitcoins.core.protocol.transaction.Transaction
-import org.bitcoins.core.protocol.transaction.testprotocol.CoreTransactionTestCase
-import org.bitcoins.core.script.result.ScriptOk
 import spray.json._
 
 import scala.io.Source
diff --git a/src/test/scala/org/bitcoins/core/util/Base58Test.scala b/src/test/scala/org/bitcoins/core/util/Base58Test.scala
index 4520adb119..157ec86687 100644
--- a/src/test/scala/org/bitcoins/core/util/Base58Test.scala
+++ b/src/test/scala/org/bitcoins/core/util/Base58Test.scala
@@ -1,6 +1,5 @@
 package org.bitcoins.core.util
 
-import org.bitcoins.core.crypto.ECFactory
 import org.bitcoins.core.protocol.BitcoinAddress
 import org.bitcoins.core.util
 import org.scalatest.{FlatSpec, MustMatchers}
diff --git a/src/test/scala/org/bitcoins/core/util/BitcoinScriptUtilTest.scala b/src/test/scala/org/bitcoins/core/util/BitcoinScriptUtilTest.scala
index a982cba38b..39863d229d 100644
--- a/src/test/scala/org/bitcoins/core/util/BitcoinScriptUtilTest.scala
+++ b/src/test/scala/org/bitcoins/core/util/BitcoinScriptUtilTest.scala
@@ -1,6 +1,6 @@
 package org.bitcoins.core.util
 
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.ECPublicKey
 import org.bitcoins.core.script.bitwise.OP_EQUALVERIFY
 import org.bitcoins.core.script.constant._
 import org.bitcoins.core.script.crypto._
@@ -178,7 +178,7 @@ class BitcoinScriptUtilTest extends FlatSpec with MustMatchers {
 
   it must "check a public key's encoding" in {
     //pubkeys must be compressed or uncompressed or else that are not validly encoded
-    val key = ECFactory.publicKey("00")
+    val key = ECPublicKey("00")
     val program = TestUtil.testProgram
     BitcoinScriptUtil.checkPubKeyEncoding(key,program) must be (false)
   }
diff --git a/src/test/scala/org/bitcoins/core/util/CryptoTestUtil.scala b/src/test/scala/org/bitcoins/core/util/CryptoTestUtil.scala
index 3023f3b08e..fdadfb0728 100644
--- a/src/test/scala/org/bitcoins/core/util/CryptoTestUtil.scala
+++ b/src/test/scala/org/bitcoins/core/util/CryptoTestUtil.scala
@@ -2,7 +2,7 @@ package org.bitcoins.core.util
 
 import org.bitcoinj.core.DumpedPrivateKey
 import org.bitcoins.core.config.TestNet3
-import org.bitcoins.core.crypto.ECFactory
+import org.bitcoins.core.crypto.{ECPrivateKey}
 
 /**
  * Created by chris on 3/7/16.
@@ -13,7 +13,7 @@ trait CryptoTestUtil {
   def privateKeyHex = BitcoinSUtil.encodeHex(privateKeyBytes)
   def bitcoinjDumpedPrivateKey = new DumpedPrivateKey(BitcoinJTestUtil.params,privateKeyBase58)
   def bitcoinjPrivateKey = bitcoinjDumpedPrivateKey.getKey
-  def privateKey = ECFactory.fromBase58ToPrivateKey(privateKeyBase58)
+  def privateKey = ECPrivateKey.fromBase58ToPrivateKey(privateKeyBase58)
 
 }
 
diff --git a/src/test/scala/org/bitcoins/core/util/TransactionTestUtil.scala b/src/test/scala/org/bitcoins/core/util/TransactionTestUtil.scala
index b3d55faa06..fbdf22c8a1 100644
--- a/src/test/scala/org/bitcoins/core/util/TransactionTestUtil.scala
+++ b/src/test/scala/org/bitcoins/core/util/TransactionTestUtil.scala
@@ -1,13 +1,9 @@
 package org.bitcoins.core.util
 
-import org.bitcoinj.core.DumpedPrivateKey
-
-import org.bitcoins.core.config.TestNet3
-import org.bitcoins.core.crypto.{ECFactory, ECPublicKey}
+import org.bitcoins.core.crypto.{ECPrivateKey, ECPublicKey}
 import org.bitcoins.core.currency.CurrencyUnits
 import org.bitcoins.core.protocol.script._
 import org.bitcoins.core.protocol.transaction._
-import org.slf4j.LoggerFactory
 
 /**
  * Created by chris on 2/12/16.
@@ -106,9 +102,9 @@ trait TransactionTestUtil extends BitcoinSLogger {
   }
 
   def signedMultiSignatureTransaction : (Transaction, Int, ScriptPubKey, Seq[ECPublicKey]) = {
-    val key1 = ECFactory.fromBase58ToPrivateKey("cVLwRLTvz3BxDAWkvS3yzT9pUcTCup7kQnfT2smRjvmmm1wAP6QT")
-    val key2 = ECFactory.fromBase58ToPrivateKey("cTine92s8GLpVqvebi8rYce3FrUYq78ZGQffBYCS1HmDPJdSTxUo")
-    def key3 = ECFactory.fromBase58ToPrivateKey("cVHwXSPRZmL9adctwBwmn4oTZdZMbaCsR5XF6VznqMgcvt1FDDxg")
+    val key1 = ECPrivateKey.fromBase58ToPrivateKey("cVLwRLTvz3BxDAWkvS3yzT9pUcTCup7kQnfT2smRjvmmm1wAP6QT")
+    val key2 = ECPrivateKey.fromBase58ToPrivateKey("cTine92s8GLpVqvebi8rYce3FrUYq78ZGQffBYCS1HmDPJdSTxUo")
+    def key3 = ECPrivateKey.fromBase58ToPrivateKey("cVHwXSPRZmL9adctwBwmn4oTZdZMbaCsR5XF6VznqMgcvt1FDDxg")
     (signedMultiSignatureTx,0,multiSignatureScriptPubKey, Seq(key1.publicKey,key2.publicKey,key3.publicKey))
   }
 
@@ -122,21 +118,17 @@ trait TransactionTestUtil extends BitcoinSLogger {
     val spendingTx = TestUtil.p2sh2Of2Tx
     val inputIndex = 0
     val input = spendingTx.inputs(inputIndex)
-
     (spendingTx, input, inputIndex, creditingTx.outputs(input.previousOutput.vout))
-
   }
 
-
-
-
-
   //https://tbtc.blockr.io/api/v1/tx/raw/d77d905fc29f86bc3db39fdb68cfcab4e35f677d4f2ec33ed749912e0fa5f385
   def rawP2sh2Of3Transaction = "010000000197e355df4b040cdca3b5623864dfcd9b94cce06417a620e2826e81d6335186c300000000fc004730440220724714702c6c172dfb72dbc1536e3a7604b9fb5f9dcdf05d76c284010f97f75602200c0c749f2efc71234a752dddee42f38967a2c5eb725be3752c4d8c3a2e2403d60147304402200173f0628f05258829a71d62bfe3baaf48d9fa9f1b4c39355be74acc2db0cee6022067357b735da08fdc63546c81437b182e84ee505d7748cbcd32f8cb9098fb0df6014c69522102ab07ab88e8211f8d48820b78ca1276960e1d09ecdc5382afc59f17c660e01d7d210346d594bfc39dc5bc4a2afb62a8717bb049d1543289d78ceec533359e77d845092103c1d5b135b3b082dc20eab6ae7d39d80bb26b5fb33b8f1b4da72f995bca9fe05353aeffffffff02bbda02000000000017a91432f3a016b96be26f9cd088675012c26fca675cfc87a08601000000000017a9149fe9d38bb4054f1827285097f3ce7293030365ee8700000000"
+
   def p2sh2Of3Transaction = Transaction(rawP2sh2Of3Transaction)
 
   //https://tbtc.blockr.io/api/v1/tx/raw/c3865133d6816e82e220a61764e0cc949bcddf643862b5a3dc0c044bdf55e397
   def rawP2sh2Of3CreditingTransaction = "01000000016f817a337d3b7c09a7d3484eaad5467730cb48404492968047a0877232a081d000000000fdfd0000473044022053b21ad6a9c63c36792fa9ccabcecaca90015ef5cf93515010fb2f55597b4498022045889d57c7eb01113b50a403287baa1202f7e6cf65ff74c04d1b2bac18f6622201483045022100cdbe4cf74116ef080b0251dc79c65fc94cb601466dcca46852aaf648af7c701302206330a9f97c952cf033faca3dd623aa8150e4f325e228244c737950d38abd7bde014c69522103ed9accffc87e17042feb7dcffb8af8231739aa6ee87a4fc09b5523b5997a295f210310d24963b6777568731efe17a4d06cfeb207b55d869ab641636468ec5e551889210393d6f0fad0c89c190b5a6ce77241e4ff416bc562003c9308394021707f0fd9bd53aeffffffff022e8204000000000017a914aa75a01abb09b58eedd4a97612056c94a3ceafcf87a0860100000000001976a914c810ad20630f02790741f5458f666798b86470c688ac00000000"
+
   def p2sh2Of3CreditingTransaction = Transaction(rawP2sh2Of3CreditingTransaction)
   /**
    * Returns a p2sh transaction that has 2 of 3 signatures with the creiditing output