btcruby 1.1.4 → 1.1.5

data/spec/open_assets/asset_transaction_builder_spec.rb

@@ -3,7 +3,7 @@ require_relative '../spec_helper'
 describe BTC::AssetTransactionBuilder do
 
   class SignerByKey
-    include TransactionBuilder::Signer
+    include BTC::TransactionBuilder::Signer
     def initialize(&block)
       @block = block
     end
@@ -18,7 +18,7 @@ describe BTC::AssetTransactionBuilder do
       builder = BTC::AssetTransactionBuilder.new
 
       @all_wallet_utxos = self.mock_wallet_utxos
-      builder.bitcoin_provider = TransactionBuilder::Provider.new do |txb|
+      builder.bitcoin_provider = BTC::TransactionBuilder::Provider.new do |txb|
         @all_wallet_utxos
       end
       builder.signer = SignerByKey.new do |output, address|
@@ -86,7 +86,7 @@ describe BTC::AssetTransactionBuilder do
       builder = BTC::AssetTransactionBuilder.new
 
       @all_wallet_utxos = self.mock_wallet_utxos
-      builder.bitcoin_provider = TransactionBuilder::Provider.new do |txb|
+      builder.bitcoin_provider = BTC::TransactionBuilder::Provider.new do |txb|
         @all_wallet_utxos
       end
       builder.signer = SignerByKey.new do |output, address|
@@ -97,15 +97,15 @@ describe BTC::AssetTransactionBuilder do
       # Each transfer may have its own unspents and its own change address.
       # If those are not specified, a per-builder setting is chosen.
 
-      @asset1 = AssetID.new(script: Script.new << OP_1)
-      @asset2 = AssetID.new(script: Script.new << OP_2)
+      @asset1 = BTC::AssetID.new(script: BTC::Script.new << BTC::OP_1)
+      @asset2 = BTC::AssetID.new(script: BTC::Script.new << BTC::OP_2)
 
       builder.transfer_asset(
         asset_id: @asset1,
         amount: 10_000,
         address: holder2_asset_address,
         unspent_outputs: [
-          AssetTransactionOutput.new(
+          BTC::AssetTransactionOutput.new(
             transaction_output: mock_utxo(value: 1000),
             asset_id: @asset1,
             value: 11_000,
@@ -121,7 +121,7 @@ describe BTC::AssetTransactionBuilder do
         amount: 50_000,
         address: holder1_asset_address,
         unspent_outputs: [
-          AssetTransactionOutput.new(
+          BTC::AssetTransactionOutput.new(
             transaction_output: mock_utxo(value: 1000),
             asset_id: @asset2,
             value: 150_000,
@@ -136,7 +136,7 @@ describe BTC::AssetTransactionBuilder do
       builder.bitcoin_change_address = wallet2_key.address
 
       # Send leftover assets to this address.
-      builder.asset_change_address = AssetAddress.new(bitcoin_address: holder2_key.address)
+      builder.asset_change_address = BTC::AssetAddress.new(bitcoin_address: holder2_key.address)
 
       # Build transactions.
       @builder = builder
@@ -174,35 +174,35 @@ describe BTC::AssetTransactionBuilder do
   # Mocked wallet
 
   def wallet1_key
-    @wallet1_key ||= Key.new(private_key: "Wallet1".sha256)
+    @wallet1_key ||= BTC::Key.new(private_key: "Wallet1".sha256)
   end
 
   def wallet2_key
-    @wallet2_key ||= Key.new(private_key: "Wallet2".sha256)
+    @wallet2_key ||= BTC::Key.new(private_key: "Wallet2".sha256)
   end
 
   def issuer1_key
-    @issuer1_key ||= Key.new(private_key: "Issuer1".sha256)
+    @issuer1_key ||= BTC::Key.new(private_key: "Issuer1".sha256)
   end
 
   def issuer2_key
-    @issuer2_key ||= Key.new(private_key: "Issuer2".sha256)
+    @issuer2_key ||= BTC::Key.new(private_key: "Issuer2".sha256)
   end
 
   def holder1_key
-    @holder1_key ||= Key.new(private_key: "Holder1".sha256)
+    @holder1_key ||= BTC::Key.new(private_key: "Holder1".sha256)
   end
 
   def holder2_key
-    @holder2_key ||= Key.new(private_key: "Holder2".sha256)
+    @holder2_key ||= BTC::Key.new(private_key: "Holder2".sha256)
   end
 
   def holder1_asset_address
-    AssetAddress.new(bitcoin_address: holder1_key.address)
+    BTC::AssetAddress.new(bitcoin_address: holder1_key.address)
   end
 
   def holder2_asset_address
-    AssetAddress.new(bitcoin_address: holder2_key.address)
+    BTC::AssetAddress.new(bitcoin_address: holder2_key.address)
   end
 
   def mock_wallet_keys
@@ -222,17 +222,17 @@ describe BTC::AssetTransactionBuilder do
   def mock_wallet_utxos
     scripts = mock_wallet_addresses.map{|a| a.script }
     (1..32).map do |i|
-      TransactionOutput.new(value:  100_000,
+      BTC::TransactionOutput.new(value:  100_000,
                            script: scripts[i % scripts.size],
                  transaction_hash: ((16+i).to_s(16)*32).from_hex,
                             index: i)
     end
   end
 
-  def mock_utxo(value: 100_000, index: 0, script: Script.new << OP_1)
-    TransactionOutput.new(value: value,
+  def mock_utxo(value: 100_000, index: 0, script: BTC::Script.new << BTC::OP_1)
+    BTC::TransactionOutput.new(value: value,
                          script: script,
-               transaction_hash: Key.random.private_key.sha256,
+               transaction_hash: BTC::Key.random.private_key.sha256,
                           index: index)
   end
 
@@ -252,17 +252,17 @@ describe "Issuing an asset" do
     issuing_script = issuer.address.script
     holding_script = holder.address.script
 
-    source_output = TransactionOutput.new(value: 100, script: issuing_script)
+    source_output = BTC::TransactionOutput.new(value: 100, script: issuing_script)
 
     # These are set automatically if source_output is a part of some BTC::Transaction
     # We need these to complete the input for the transfer transaction.
-    source_output.transaction_hash = BTC::Data.hash256("some tx")
+    source_output.transaction_hash = BTC.hash256("some tx")
     source_output.index = 0
 
-    transfer = Transaction.new
-    transfer.add_input(TransactionInput.new(transaction_output: source_output))
-    transfer.add_output(TransactionOutput.new(value: source_output.value, script: holding_script))
-    marker = AssetMarker.new
+    transfer = BTC::Transaction.new
+    transfer.add_input(BTC::TransactionInput.new(transaction_output: source_output))
+    transfer.add_output(BTC::TransactionOutput.new(value: source_output.value, script: holding_script))
+    marker = BTC::AssetMarker.new
     marker.quantities = [ 1000_000_000 ]
     marker.metadata = "Chancellor bailing out banks"
     transfer.outputs << marker.output

data/spec/open_assets/asset_transaction_spec.rb

@@ -3,21 +3,21 @@ require_relative '../spec_helper'
 describe "Serialization" do
 
   def build_asset_transaction(inputs: [], issues: [], transfers: [])
-    tx = Transaction.new
-    script = PublicKeyAddress.new(hash: "some address".hash160).script
+    tx = BTC::Transaction.new
+    script = BTC::PublicKeyAddress.new(hash: "some address".hash160).script
     inputs.each do
-      tx.add_input(TransactionInput.new(previous_hash: "".sha256, previous_index: 0))
+      tx.add_input(BTC::TransactionInput.new(previous_hash: "".sha256, previous_index: 0))
     end
     issues.each do |tuple|
-      tx.add_output(TransactionOutput.new(value: 1, script: script))
+      tx.add_output(BTC::TransactionOutput.new(value: 1, script: script))
     end
     qtys = issues.map{|tuple| tuple.first} + transfers.map{|tuple| tuple.first}
-    tx.add_output(AssetMarker.new(quantities: qtys).output)
+    tx.add_output(BTC::AssetMarker.new(quantities: qtys).output)
     transfers.each do |tuple|
-      tx.add_output(TransactionOutput.new(value: 1, script: script))
+      tx.add_output(BTC::TransactionOutput.new(value: 1, script: script))
     end
 
-    atx = AssetTransaction.new(transaction: tx)
+    atx = BTC::AssetTransaction.new(transaction: tx)
     atx.inputs.each_with_index do |ain, i|
       amount, name = inputs[i]
       if amount
@@ -35,7 +35,7 @@ describe "Serialization" do
   end
   
   def asset_id(name)
-    name ? AssetID.new(hash: name.hash160) : nil
+    name ? BTC::AssetID.new(hash: name.hash160) : nil
   end
     
   before do
@@ -45,7 +45,7 @@ describe "Serialization" do
       transfers: [ [40, "A"], [60, "A"], [44, "B"] ]
     )
     data = @atx.data
-    @atx2 = AssetTransaction.new(data: data)
+    @atx2 = BTC::AssetTransaction.new(data: data)
   end
   
   it "should restore all outputs" do 

data/spec/open_assets/issuance_id_spec.rb

@@ -2,14 +2,14 @@ require_relative '../spec_helper'
 
 describe BTC::IssuanceID do
   it "should encode script to a correct address" do
-    key = Key.new(private_key: "18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725".from_hex, public_key_compressed: false)
-    issuance_id = IssuanceID.new(outpoint: Outpoint.new(transaction_hash: BTC.hash256("tx1"), index:1), amount:100, network: Network.mainnet)
+    key = BTC::Key.new(private_key: "18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725".from_hex, public_key_compressed: false)
+    issuance_id = BTC::IssuanceID.new(outpoint: BTC::Outpoint.new(transaction_hash: BTC.hash256("tx1"), index:1), amount:100, network: BTC::Network.mainnet)
     issuance_id.hash.to_hex.must_equal "29d2765469a299d1219a1cbf7561534eae4595f7"
     issuance_id.to_s.must_equal "SR78rsv5RCMMay22D3ZUZmMgPkRGpqphnQ"
     issuance_id.is_a?(BTC::IssuanceID).must_equal true
   end
   it "should decode an asset address" do
-    issuance_id = Address.parse("SR78rsv5RCMMay22D3ZUZmMgPkRGpqphnQ")
+    issuance_id = BTC::Address.parse("SR78rsv5RCMMay22D3ZUZmMgPkRGpqphnQ")
     issuance_id.is_a?(BTC::IssuanceID).must_equal true
     issuance_id.hash.to_hex.must_equal "29d2765469a299d1219a1cbf7561534eae4595f7"
   end

data/spec/script_interpreter_spec.rb

@@ -9,11 +9,11 @@ describe BTC::ScriptInterpreter do
 
     def verify_script(sig_script, output_script, flags, expected_result, record)
       tx = build_spending_transaction(sig_script, build_crediting_transaction(output_script));
-      checker = TransactionSignatureChecker.new(transaction: tx, input_index: 0)
+      checker = BTC::TransactionSignatureChecker.new(transaction: tx, input_index: 0)
       plugins = []
-      plugins << P2SHPlugin.new if (flags & ScriptFlags::SCRIPT_VERIFY_P2SH) != 0
-      plugins << CLTVPlugin.new if (flags & ScriptFlags::SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY) != 0
-      interpreter = ScriptInterpreter.new(
+      plugins << BTC::P2SHPlugin.new if (flags & BTC::ScriptFlags::SCRIPT_VERIFY_P2SH) != 0
+      plugins << BTC::CLTVPlugin.new if (flags & BTC::ScriptFlags::SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY) != 0
+      interpreter = BTC::ScriptInterpreter.new(
         flags: flags,
         plugins: plugins,
         signature_checker: checker,

data/spec/script_spec.rb

@@ -1,42 +1,42 @@
 require_relative 'spec_helper'
 describe BTC::Script do
-
+  
   it "should instantiate with empty data" do
-    empty_script = Script.new
+    empty_script = BTC::Script.new
     empty_script.data.must_equal "".b
     empty_script.to_s.must_equal ''
   end
 
   it "should support standard P2PKH script" do
-    script = (Script.new << OP_DUP << OP_HASH160 << "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex << OP_EQUALVERIFY << OP_CHECKSIG)
+    script = (BTC::Script.new << BTC::OP_DUP << BTC::OP_HASH160 << "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex << BTC::OP_EQUALVERIFY << BTC::OP_CHECKSIG)
     script.standard?.must_equal true
     script.public_key_hash_script?.must_equal true
     script.script_hash_script?.must_equal false
     script.multisig_script?.must_equal false
     script.standard_multisig_script?.must_equal false
-    script.standard_address.class.must_equal PublicKeyAddress
+    script.standard_address.class.must_equal BTC::PublicKeyAddress
     script.standard_address.data.must_equal "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex
     script.to_s.must_equal "OP_DUP OP_HASH160 5a73e920b7836c74f9e740a5bb885e8580557038 OP_EQUALVERIFY OP_CHECKSIG"
   end
 
   it "should support standard P2SH script" do
-    script = (Script.new << OP_HASH160 << "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex << OP_EQUAL)
+    script = (BTC::Script.new << BTC::OP_HASH160 << "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex << BTC::OP_EQUAL)
     script.standard?.must_equal true
     script.public_key_hash_script?.must_equal false
     script.script_hash_script?.must_equal true
     script.multisig_script?.must_equal false
     script.standard_multisig_script?.must_equal false
-    script.standard_address.class.must_equal ScriptHashAddress
+    script.standard_address.class.must_equal BTC::ScriptHashAddress
     script.standard_address.data.must_equal "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex
     script.to_s.must_equal "OP_HASH160 5a73e920b7836c74f9e740a5bb885e8580557038 OP_EQUAL"
   end
 
   it "should support standard multisig script" do
-    script = (Script.new << OP_1 <<
+    script = (BTC::Script.new << BTC::OP_1 <<
               "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex <<
               "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19".from_hex <<
-              OP_2 <<
-              OP_CHECKMULTISIG)
+              BTC::OP_2 <<
+              BTC::OP_CHECKMULTISIG)
     script.standard?.must_equal true
     script.public_key_hash_script?.must_equal false
     script.script_hash_script?.must_equal false
@@ -51,7 +51,7 @@ describe BTC::Script do
     script.to_s.must_equal "OP_1 c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a "+
                            "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19 OP_2 OP_CHECKMULTISIG"
 
-    script2 = Script.multisig(public_keys:[
+    script2 = BTC::Script.multisig(public_keys:[
                              "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex,
                              "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19".from_hex
                            ], signatures_required: 1)
@@ -63,36 +63,36 @@ describe BTC::Script do
   end
 
   it "should support subscripts" do
-    s = Script.new << OP_DUP << OP_HASH160 << OP_CODESEPARATOR << "some data" << OP_EQUALVERIFY << OP_CHECKSIG
+    s = BTC::Script.new << BTC::OP_DUP << BTC::OP_HASH160 << BTC::OP_CODESEPARATOR << "some data" << BTC::OP_EQUALVERIFY << BTC::OP_CHECKSIG
     s.subscript(0..-1).must_equal s
     s[0..-1].must_equal s
-    s.subscript(3..-1).must_equal(Script.new << "some data" << OP_EQUALVERIFY << OP_CHECKSIG)
-    s[3..-1].must_equal(Script.new << "some data" << OP_EQUALVERIFY << OP_CHECKSIG)
+    s.subscript(3..-1).must_equal(BTC::Script.new << "some data" << BTC::OP_EQUALVERIFY << BTC::OP_CHECKSIG)
+    s[3..-1].must_equal(BTC::Script.new << "some data" << BTC::OP_EQUALVERIFY << BTC::OP_CHECKSIG)
   end
 
 
   it "removing subscript does not modify the receiver" do
-    s = Script.new << OP_DUP << OP_HASH160 << OP_CODESEPARATOR << "some data" << OP_EQUALVERIFY << OP_CHECKSIG
+    s = BTC::Script.new << BTC::OP_DUP << BTC::OP_HASH160 << BTC::OP_CODESEPARATOR << "some data" << BTC::OP_EQUALVERIFY << BTC::OP_CHECKSIG
     s1 = s.dup
-    s2 = s1.find_and_delete(Script.new << OP_HASH160)
+    s2 = s1.find_and_delete(BTC::Script.new << BTC::OP_HASH160)
     s.must_equal s1
-    s2.must_equal(Script.new << OP_DUP << OP_CODESEPARATOR << "some data" << OP_EQUALVERIFY << OP_CHECKSIG)
+    s2.must_equal(BTC::Script.new << BTC::OP_DUP << BTC::OP_CODESEPARATOR << "some data" << BTC::OP_EQUALVERIFY << BTC::OP_CHECKSIG)
   end
 
   it "should find subsequence" do
-    s = Script.new << OP_1 << OP_3 << OP_1 << OP_2 << OP_1 << OP_2 << OP_1 << OP_3
-    s2 = s.find_and_delete(Script.new << OP_1 << OP_2 << OP_1)
-    s2.must_equal(Script.new << OP_1 << OP_3 << OP_2 << OP_1 << OP_3)
+    s = BTC::Script.new << BTC::OP_1 << BTC::OP_3 << BTC::OP_1 << BTC::OP_2 << BTC::OP_1 << BTC::OP_2 << BTC::OP_1 << BTC::OP_3
+    s2 = s.find_and_delete(BTC::Script.new << BTC::OP_1 << BTC::OP_2 << BTC::OP_1)
+    s2.must_equal(BTC::Script.new << BTC::OP_1 << BTC::OP_3 << BTC::OP_2 << BTC::OP_1 << BTC::OP_3)
   end
 
   it "should not find-and-delete non-matching encoding for the same pushdata" do
-    s = Script.new.append_pushdata("foo").append_pushdata("foo", opcode:OP_PUSHDATA1)
-    s2 = s.find_and_delete(Script.new << "foo")
-    s2.must_equal(Script.new.append_pushdata("foo", opcode:OP_PUSHDATA1))
+    s = BTC::Script.new.append_pushdata("foo").append_pushdata("foo", opcode:BTC::OP_PUSHDATA1)
+    s2 = s.find_and_delete(BTC::Script.new << "foo")
+    s2.must_equal(BTC::Script.new.append_pushdata("foo", opcode:BTC::OP_PUSHDATA1))
   end
 
   it "should parse interpreted data and pushdata correctly" do
-    script = Script.new << OP_0 << OP_1NEGATE << OP_NOP << OP_RESERVED << OP_1 << OP_16 << "1" << "2" << "chancellor"
+    script = BTC::Script.new << BTC::OP_0 << BTC::OP_1NEGATE << BTC::OP_NOP << BTC::OP_RESERVED << BTC::OP_1 << BTC::OP_16 << "1" << "2" << "chancellor"
     script.chunks.map{|c| c.interpreted_data }.must_equal ["", "\x81".b, nil, nil, "\x01".b, "\x10".b, "1", "2", "chancellor"]
     script.chunks.map{|c| c.pushdata }.must_equal ["", nil, nil, nil, nil, nil, "1", "2", "chancellor"]
   end

data/spec/spec_helper.rb

@@ -5,22 +5,22 @@ require_relative '../lib/btcruby'
 require_relative '../lib/btcruby/extensions'
 
 # So every test can access classes directly without prefixing them with BTC::
-include BTC
+#include BTC
 
 # Script helper used by transaction_spec and script_interpreter_spec
 FLAGS_MAP = {
-    "" =>                           ScriptFlags::SCRIPT_VERIFY_NONE,
-    "NONE" =>                       ScriptFlags::SCRIPT_VERIFY_NONE,
-    "P2SH" =>                       ScriptFlags::SCRIPT_VERIFY_P2SH,
-    "STRICTENC" =>                  ScriptFlags::SCRIPT_VERIFY_STRICTENC,
-    "DERSIG" =>                     ScriptFlags::SCRIPT_VERIFY_DERSIG,
-    "LOW_S" =>                      ScriptFlags::SCRIPT_VERIFY_LOW_S,
-    "NULLDUMMY" =>                  ScriptFlags::SCRIPT_VERIFY_NULLDUMMY,
-    "SIGPUSHONLY" =>                ScriptFlags::SCRIPT_VERIFY_SIGPUSHONLY,
-    "MINIMALDATA" =>                ScriptFlags::SCRIPT_VERIFY_MINIMALDATA,
-    "DISCOURAGE_UPGRADABLE_NOPS" => ScriptFlags::SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
-    "CLEANSTACK" =>                 ScriptFlags::SCRIPT_VERIFY_CLEANSTACK,
-    "CHECKLOCKTIMEVERIFY" =>        ScriptFlags::SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
+    "" =>                           BTC::ScriptFlags::SCRIPT_VERIFY_NONE,
+    "NONE" =>                       BTC::ScriptFlags::SCRIPT_VERIFY_NONE,
+    "P2SH" =>                       BTC::ScriptFlags::SCRIPT_VERIFY_P2SH,
+    "STRICTENC" =>                  BTC::ScriptFlags::SCRIPT_VERIFY_STRICTENC,
+    "DERSIG" =>                     BTC::ScriptFlags::SCRIPT_VERIFY_DERSIG,
+    "LOW_S" =>                      BTC::ScriptFlags::SCRIPT_VERIFY_LOW_S,
+    "NULLDUMMY" =>                  BTC::ScriptFlags::SCRIPT_VERIFY_NULLDUMMY,
+    "SIGPUSHONLY" =>                BTC::ScriptFlags::SCRIPT_VERIFY_SIGPUSHONLY,
+    "MINIMALDATA" =>                BTC::ScriptFlags::SCRIPT_VERIFY_MINIMALDATA,
+    "DISCOURAGE_UPGRADABLE_NOPS" => BTC::ScriptFlags::SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
+    "CLEANSTACK" =>                 BTC::ScriptFlags::SCRIPT_VERIFY_CLEANSTACK,
+    "CHECKLOCKTIMEVERIFY" =>        BTC::ScriptFlags::SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
 }
 
 def parse_script(json_script, expected_result = true)
@@ -33,7 +33,7 @@ def parse_script(json_script, expected_result = true)
     oldsize = json_script.size
     json_script.gsub!(/0x([0-9a-fA-F]+)\s+0x/, "0x\\1")
   end
-  json_script.split(" ").inject(Script.new) do |parsed_script, x|
+  json_script.split(" ").inject(BTC::Script.new) do |parsed_script, x|
     if x.size == 0
       # Empty string, ignore.
       parsed_script
@@ -41,25 +41,27 @@ def parse_script(json_script, expected_result = true)
       # Number
       n = x.to_i
       if (n == -1) || (n >= 1 and n <= 16)
-        parsed_script << Opcode.opcode_for_small_integer(n)
+        parsed_script << BTC::Opcode.opcode_for_small_integer(n)
       else
-        parsed_script << ScriptNumber.new(integer: n).data
+        parsed_script << BTC::ScriptNumber.new(integer: n).data
       end
     elsif x[0,2] == "0x"
       # Raw hex data, inserted NOT pushed onto stack:
       data = BTC.from_hex(x[2..-1])
-      Script.new(data: parsed_script.data + data)
+      BTC::Script.new(data: parsed_script.data + data)
     elsif x =~ /^'.*'$/
       # Single-quoted string, pushed as data.
       parsed_script << x[1..-2]
     else
       # opcode, e.g. OP_ADD or ADD:
-      opcode = Opcode.opcode_for_name("OP_" + x)
-      opcode = Opcode.opcode_for_name(x) if opcode == OP_INVALIDOPCODE
+      opcode = BTC::Opcode.opcode_for_name("OP_" + x)
+      opcode = BTC::Opcode.opcode_for_name(x) if opcode == BTC::OP_INVALIDOPCODE
       parsed_script << opcode
     end
   end
 rescue => e
+   # puts e.backtrace.join("\n")
+   # raise "!!!!"
   if expected_result
     # puts "json_script = #{orig_string.inspect}"
     # puts "json_script = #{json_script.inspect}"
@@ -76,14 +78,14 @@ def parse_flags(string)
 end
 
 def build_crediting_transaction(scriptPubKey)
-  txCredit = Transaction.new;
-  txCredit.version = 1;
-  txCredit.lock_time = 0;
-  txCredit.add_input(TransactionInput.new(
+  txCredit = BTC::Transaction.new
+  txCredit.version = 1
+  txCredit.lock_time = 0
+  txCredit.add_input(BTC::TransactionInput.new(
     previous_hash: nil,
-    coinbase_data: (Script.new << ScriptNumber.new(integer:0) << ScriptNumber.new(integer:0)).data
+    coinbase_data: (BTC::Script.new << BTC::ScriptNumber.new(integer:0) << BTC::ScriptNumber.new(integer:0)).data
   ))
-  txCredit.add_output(TransactionOutput.new(
+  txCredit.add_output(BTC::TransactionOutput.new(
     script: scriptPubKey,
     value: 0
   ))
@@ -91,16 +93,16 @@ def build_crediting_transaction(scriptPubKey)
 end
 
 def build_spending_transaction(scriptSig, txCredit)
-  txSpend = Transaction.new
-  txSpend.version = 1;
-  txSpend.lock_time = 0;
-  txSpend.add_input(TransactionInput.new(
+  txSpend = BTC::Transaction.new
+  txSpend.version = 1
+  txSpend.lock_time = 0
+  txSpend.add_input(BTC::TransactionInput.new(
     previous_hash: txCredit.transaction_hash,
     previous_index: 0,
     signature_script: scriptSig
   ))
-  txSpend.add_output(TransactionOutput.new(
-    script: Script.new,
+  txSpend.add_output(BTC::TransactionOutput.new(
+    script: BTC::Script.new,
     value: 0
   ))
   txSpend