btcruby 0.0.0 → 1.0.0

data/spec/open_assets/asset_transaction_builder_spec.rb

@@ -0,0 +1,273 @@
+require_relative '../spec_helper'
+
+describe BTC::AssetTransactionBuilder do
+
+  class SignerByKey
+    include TransactionBuilder::Signer
+    def initialize(&block)
+      @block = block
+    end
+    def signing_key_for_output(output: nil, address: nil)
+      @block.call(output, address)
+    end
+  end
+
+  describe "Issuing an asset with two transactions" do
+
+    before do
+      builder = BTC::AssetTransactionBuilder.new
+
+      @all_wallet_utxos = self.mock_wallet_utxos
+      builder.bitcoin_provider = TransactionBuilder::Provider.new do |txb|
+        @all_wallet_utxos
+      end
+      builder.signer = SignerByKey.new do |output, address|
+        mock_all_keys.find{|k| k.address == address }
+      end
+
+      # We want to issue 1M units to one address and 50K units for another.
+      # OpenAssets does not allow issuing different assets in one Asset Transaction because Asset ID is determined by the first input.
+      builder.issue_asset(source_script: issuer1_key.address.script, amount: 1000_000, address: holder1_asset_address)
+      builder.issue_asset(source_script: issuer1_key.address.script, amount: 50_000, address: holder2_asset_address)
+
+      # Just some payment to add.
+      builder.send_bitcoin(amount: 100, address: wallet1_key.address)
+
+      # Send btc change to this address.
+      builder.bitcoin_change_address = wallet2_key.address
+
+      # Send leftover assets to this address.
+      builder.asset_change_address = holder2_asset_address
+
+      # Build transactions.
+      @builder = builder
+      @result = builder.build
+    end
+
+    it "should have two transactions: asset definition and issuance" do
+      @result.transactions.size.must_equal(2)
+    end
+
+    it "should have last transaction wrapped in AssetTransaction" do
+      @result.asset_transaction.transaction.must_equal(@result.transactions.last)
+    end
+
+    it "should have two transactions linked up" do
+      @result.transactions.last.inputs.first.previous_hash.must_equal @result.transactions.first.transaction_hash
+    end
+
+    it "should have first transaction uncolored" do
+      @result.transactions.first.open_assets_transaction?.must_equal false
+    end
+
+    it "should have second transaction with colored outputs" do
+      @result.transactions.last.open_assets_transaction?.must_equal true
+      @result.asset_transaction.inputs.each do |ain|
+        ain.colored?.must_equal false
+        ain.verified?.must_equal true
+      end
+      @result.asset_transaction.outputs.each_with_index do |aout, i|
+        aout.colored?.must_equal(i < 2) # only first 2 outputs are colored because they issue asset
+        aout.verified?.must_equal true
+      end
+    end
+
+    it "should have an asset cost of two issuances" do
+      @result.assets_cost.must_equal 546*2
+    end
+  end
+
+  describe "Issuing an asset with an existing source output" do
+  end
+
+  describe "Transferring a few assets" do
+    before do
+
+      builder = BTC::AssetTransactionBuilder.new
+
+      @all_wallet_utxos = self.mock_wallet_utxos
+      builder.bitcoin_provider = TransactionBuilder::Provider.new do |txb|
+        @all_wallet_utxos
+      end
+      builder.signer = SignerByKey.new do |output, address|
+        mock_all_keys.find{|k| k.address == address }
+      end
+
+      # We want to be able to swap assets: when one user provides Apples and the other provides Oranges.
+      # 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)
+
+      builder.transfer_asset(
+        asset_id: @asset1,
+        amount: 10_000,
+        address: holder2_asset_address,
+        unspent_outputs: [
+          AssetTransactionOutput.new(
+            transaction_output: mock_utxo(value: 1000),
+            asset_id: @asset1,
+            value: 11_000,
+            transfer: true,
+            verified: true,
+          )
+        ],
+        change_address: holder1_asset_address
+      )
+
+      builder.transfer_asset(
+        asset_id: @asset2,
+        amount: 50_000,
+        address: holder1_asset_address,
+        unspent_outputs: [
+          AssetTransactionOutput.new(
+            transaction_output: mock_utxo(value: 1000),
+            asset_id: @asset2,
+            value: 150_000,
+            transfer: true,
+            verified: true,
+          )
+        ],
+        change_address: holder2_asset_address
+      )
+
+      # Send btc change to this address.
+      builder.bitcoin_change_address = wallet2_key.address
+
+      # Send leftover assets to this address.
+      builder.asset_change_address = AssetAddress.new(bitcoin_address: holder2_key.address)
+
+      # Build transactions.
+      @builder = builder
+      @result = builder.build
+    end
+
+    it "should have two change outputs: for each transfer" do
+      @result.asset_transaction.outputs.size.must_equal(1 + 2 + 2 + 1)
+      marker, transfer1, change1, transfer2, change2, btcchange = @result.asset_transaction.outputs
+
+      transfer1.transfer?.must_equal true
+      transfer1.value.must_equal 10_000
+      change1.transfer?.must_equal true
+      change1.value.must_equal 1_000
+      transfer1.asset_id.to_s.must_equal change1.asset_id.to_s
+      transfer1.asset_id.to_s.must_equal @asset1.to_s
+      transfer1.transaction_output.script.standard_address.to_s.must_equal holder2_key.address.to_s
+      change1.transaction_output.script.standard_address.to_s.must_equal holder1_key.address.to_s
+
+      transfer2.transfer?.must_equal true
+      transfer2.value.must_equal 50_000
+      change2.transfer?.must_equal true
+      change2.value.must_equal 100_000
+      transfer2.asset_id.to_s.must_equal change2.asset_id.to_s
+      transfer2.asset_id.to_s.must_equal @asset2.to_s
+      transfer2.transaction_output.script.standard_address.to_s.must_equal holder1_key.address.to_s
+      change2.transaction_output.script.standard_address.to_s.must_equal holder2_key.address.to_s
+
+      btcchange.colored?.must_equal false
+      btcchange.verified?.must_equal true
+      btcchange.asset_id.must_equal nil
+    end
+  end
+
+  # Mocked wallet
+
+  def wallet1_key
+    @wallet1_key ||= Key.new(private_key: "Wallet1".sha256)
+  end
+
+  def wallet2_key
+    @wallet2_key ||= Key.new(private_key: "Wallet2".sha256)
+  end
+
+  def issuer1_key
+    @issuer1_key ||= Key.new(private_key: "Issuer1".sha256)
+  end
+
+  def issuer2_key
+    @issuer2_key ||= Key.new(private_key: "Issuer2".sha256)
+  end
+
+  def holder1_key
+    @holder1_key ||= Key.new(private_key: "Holder1".sha256)
+  end
+
+  def holder2_key
+    @holder2_key ||= Key.new(private_key: "Holder2".sha256)
+  end
+
+  def holder1_asset_address
+    AssetAddress.new(bitcoin_address: holder1_key.address)
+  end
+
+  def holder2_asset_address
+    AssetAddress.new(bitcoin_address: holder2_key.address)
+  end
+
+  def mock_wallet_keys
+    @mock_wallet_keys ||= [wallet1_key, wallet2_key]
+  end
+
+  def mock_all_keys
+    @mock_all_keys ||= [wallet1_key, wallet2_key,
+                        issuer1_key, issuer2_key,
+                        holder1_key, holder2_key]
+  end
+
+  def mock_wallet_addresses
+    mock_wallet_keys.map{|k| k.address }
+  end
+
+  def mock_wallet_utxos
+    scripts = mock_wallet_addresses.map{|a| a.script }
+    (1..32).map do |i|
+      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,
+                         script: script,
+               transaction_hash: Key.random.private_key.sha256,
+                          index: index)
+  end
+
+  def mock_asset_utxos
+
+  end
+
+end
+
+# Temporary test
+describe "Issuing an asset" do
+
+  it "should issue a new asset from a given tx output" do
+    issuer = BTC::Key.new(private_key: "Treasury Key".sha256)
+    holder = BTC::Key.new(private_key: "Chancellor Key".sha256)
+
+    issuing_script = issuer.address.script
+    holding_script = holder.address.script
+
+    source_output = 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.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
+    marker.quantities = [ 1000_000_000 ]
+    marker.metadata = "Chancellor bailing out banks"
+    transfer.outputs << marker.output
+  end
+
+end
+
+

data/spec/open_assets/asset_transaction_spec.rb

@@ -0,0 +1,70 @@
+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
+    inputs.each do
+      tx.add_input(TransactionInput.new(previous_hash: "".sha256, previous_index: 0))
+    end
+    issues.each do |tuple|
+      tx.add_output(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)
+    transfers.each do |tuple|
+      tx.add_output(TransactionOutput.new(value: 1, script: script))
+    end
+
+    atx = AssetTransaction.new(transaction: tx)
+    atx.inputs.each_with_index do |ain, i|
+      amount, name = inputs[i]
+      if amount
+        ain.asset_id = asset_id(name)
+        ain.value = amount
+        ain.verified = true
+      else
+        ain.asset_id = nil
+        ain.value = nil
+        ain.verified = true
+      end
+    end
+    
+    atx
+  end
+  
+  def asset_id(name)
+    name ? AssetID.new(hash: name.hash160) : nil
+  end
+    
+  before do
+    @atx = build_asset_transaction(
+      inputs:    [ [100, "A"], [30, "B"], [14, "B"] ],
+      issues:    [ ],
+      transfers: [ [40, "A"], [60, "A"], [44, "B"] ]
+    )
+    data = @atx.data
+    @atx2 = AssetTransaction.new(data: data)
+  end
+  
+  it "should restore all outputs" do 
+    @atx.inputs.each_with_index do |ain1, i|
+      ain2 = @atx2.inputs[i]
+      ain1.verified?.must_equal ain2.verified?
+      ain1.verified?.must_equal true
+      ain1.asset_id.must_equal ain2.asset_id
+      ain1.value.must_equal ain2.value
+    end
+    @atx.outputs.each_with_index do |aout1, i|
+      aout2 = @atx2.outputs[i]
+      aout1.verified?.must_equal aout2.verified?
+      aout1.verified?.must_equal aout1.marker?
+      aout1.asset_id.must_equal aout2.asset_id
+      aout1.asset_id.must_equal nil
+      aout1.value.must_equal aout2.value
+    end
+  end
+  
+  
+end

data/spec/proof_of_work_spec.rb

@@ -0,0 +1,53 @@
+require_relative 'spec_helper'
+describe BTC::ProofOfWork do
+
+  POW = BTC::ProofOfWork
+
+  it "should convert target to bits" do
+    POW.bits_from_target(0x00000000ffff0000000000000000000000000000000000000000000000000000).must_equal 0x1d00ffff
+    POW.bits_from_target(0x00000007fff80000000000000000000000000000000000000000000000000000).must_equal 0x1d07fff8
+    POW.bits_from_target(0x0).must_equal 0x03000000
+  end
+
+  it "should convert bits to target" do
+    POW.target_from_bits(0x1d00ffff).must_equal 0x00000000ffff0000000000000000000000000000000000000000000000000000
+    POW.target_from_bits(0x1d07fff8).must_equal 0x00000007fff80000000000000000000000000000000000000000000000000000
+    POW.target_from_bits(0x03000000).must_equal 0x0
+  end
+
+  it "should convert hash to target integer" do
+    POW.target_from_hash("").must_equal 0
+    POW.target_from_hash("\x00").must_equal 0
+    POW.target_from_hash("\x12").must_equal 0x12
+    POW.target_from_hash("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000".from_hex).must_equal 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
+  end
+
+  it "should convert target integer to 32-byte hash" do
+    POW.hash_from_target(0).must_equal "\x00"*32
+    POW.hash_from_target(0xbabe).must_equal "\xbe\xba".b.ljust(32, "\x00")
+    POW.hash_from_target(0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f).must_equal "6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000".from_hex
+  end
+
+  it "should convert target to difficulty (on mainnet)" do
+    POW.difficulty_from_target(0x00000000ffff0000000000000000000000000000000000000000000000000000).to_i.must_equal 1
+    POW.difficulty_from_target(0x000000007fff8000000000000000000000000000000000000000000000000000).to_i.must_equal 2
+    POW.difficulty_from_target(0x000000000ffff000000000000000000000000000000000000000000000000000).to_i.must_equal 16
+    POW.difficulty_from_target(0x0000000000ffff00000000000000000000000000000000000000000000000000).to_i.must_equal 256
+  end
+
+  it "should convert target to difficulty (on testnet)" do
+    POW.difficulty_from_target(0x00000007fff80000000000000000000000000000000000000000000000000000,
+                                                max_target: POW::MAX_TARGET_TESTNET).to_i.must_equal 1
+    POW.difficulty_from_target(0x00000003fff80000000000000000000000000000000000000000000000000000,
+                                                max_target: POW::MAX_TARGET_TESTNET).to_i.must_equal 2
+    POW.difficulty_from_target(0x000000007fff8000000000000000000000000000000000000000000000000000,
+                                                max_target: POW::MAX_TARGET_TESTNET).to_i.must_equal 16
+    POW.difficulty_from_target(0x0000000007fff800000000000000000000000000000000000000000000000000,
+                                                max_target: POW::MAX_TARGET_TESTNET).to_i.must_equal 256
+  end
+  
+  it "should convert difficulty to target or bits" do
+    POW.target_from_difficulty(1.0).must_equal 0x00000000ffff0000000000000000000000000000000000000000000000000000
+    POW.bits_from_difficulty(39603666252.41841).must_equal 0x181bc330
+  end
+end

data/spec/script_spec.rb

@@ -0,0 +1,66 @@
+require_relative 'spec_helper'
+describe BTC::Script do
+
+  it "should instantiate with empty data" do
+    empty_script = 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.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.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.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.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 <<
+              "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex <<
+              "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19".from_hex <<
+              OP_2 <<
+              OP_CHECKMULTISIG)
+    script.standard?.must_equal true
+    script.public_key_hash_script?.must_equal false
+    script.script_hash_script?.must_equal false
+    script.multisig_script?.must_equal true
+    script.standard_multisig_script?.must_equal true
+    script.standard_address.must_equal nil
+    script.multisig_public_keys.must_equal [
+      "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex,
+      "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19".from_hex
+    ]
+    script.multisig_signatures_required.must_equal 1
+    script.to_s.must_equal "OP_1 c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a "+
+                           "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19 OP_2 OP_CHECKMULTISIG"
+
+    script2 = Script.multisig(public_keys:[
+                             "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex,
+                             "bffbec99da8a6573bd4e359d85c8cb62e6f483d9afac4be2db963f0fe10bcb19".from_hex
+                           ], signatures_required: 1)
+
+    script2.standard_multisig_script?.must_equal true
+    script.must_equal script2
+
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require_relative '../lib/btcruby'
+require_relative '../lib/btcruby/extensions'
+
+# So every test can access classes directly without prefixing them with BTC::
+include BTC