sigma_rb 0.1.3

data/tests/sigma/address_test.rb

@@ -0,0 +1,45 @@
+
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::Address::Test < Test::Unit::TestCase
+  def test_testnet_addresses
+    p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+    p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
+    assert_equal(p2pk_addr_str, p2pk_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:testnet]))
+    assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:p2pk], p2pk_addr.type_prefix)
+
+    p2sh_addr_str = "rbcrmKEYduUvADj9Ts3dSVSG27h54pgrq5fPuwB"
+    p2sh_addr = Sigma::Address.with_testnet_address(p2sh_addr_str)
+    assert_equal(p2sh_addr_str, p2sh_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:testnet]))
+    assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:pay2sh], p2sh_addr.type_prefix)
+  end
+
+  def test_mainnet_addresses
+    p2pk_addr_str = "9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA"
+    p2pk_addr = Sigma::Address.with_mainnet_address(p2pk_addr_str)
+    assert_equal(p2pk_addr_str, p2pk_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:mainnet]))
+    assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:p2pk], p2pk_addr.type_prefix)
+
+    p2sh_addr_str = "8UApt8czfFVuTgQmMwtsRBZ4nfWquNiSwCWUjMg"
+    p2sh_addr = Sigma::Address.with_mainnet_address(p2sh_addr_str)
+    assert_equal(p2sh_addr_str, p2sh_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:mainnet]))
+    assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:pay2sh], p2sh_addr.type_prefix)
+  end
+
+  def test_base58_address
+    addr_str = "9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA"
+    address = Sigma::Address.with_base58_address(addr_str)
+    assert_equal(addr_str, address.to_base58(Sigma::NETWORK_PREFIX_ENUM[:mainnet]))
+  end
+
+  def test_invalid_address
+    assert_raises do
+      Sigma::Address.with_mainnet_address("sss")
+    end
+  end
+end

data/tests/sigma/block_header_test.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::BlockHeader::Test < Test::Unit::TestCase
+  def test_block_header
+    header_json = TestSeeds.block_header_json 
+    block_header = Sigma::BlockHeader.with_json(header_json)
+    assert_nothing_raised do
+      Sigma::PreHeader.with_block_header(block_header)
+    end
+    assert_raises do
+      Sigma::BlockHeader.from_json("")
+    end
+    headers = Sigma::BlockHeaders.create
+    assert_equal(nil, headers.get(0))
+    assert_equal(0, headers.len)
+    assert_nothing_raised do
+      headers.add(block_header)
+    end
+    assert_equal(1, headers.len)
+    assert_equal(block_header, headers.get(0))
+    assert_equal(nil, headers.get(1))
+    assert_nothing_raised do
+      headers.add(block_header)
+    end
+    assert_equal(2, headers.len)
+    assert_equal(block_header, headers.get(1))
+    assert_equal(nil, headers.get(2))
+  end
+end

data/tests/sigma/box_selection_test.rb

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::BoxSelection::Test < Test::Unit::TestCase
+  def test_box_selection
+    # create ergo boxes
+    box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_value_int = 67500000000
+    ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
+    creation_height = 284761
+    index = 1
+
+    box_id = Sigma::BoxId.with_string(box_id_str)
+    box_value = Sigma::BoxValue.from_i64(box_value_int)
+    ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
+    contract = Sigma::Contract.from_ergo_tree(ergo_tree)
+    tx_id = Sigma::TxId.with_string(tx_id_str)
+    tokens = Sigma::Tokens.create
+    ergo_box = Sigma::ErgoBox.create(box_value: box_value, creation_height: creation_height, 
+      contract: contract, tx_id: tx_id, index: index, tokens: tokens)
+    ergo_boxes = Sigma::ErgoBoxes.create
+    ergo_boxes.add(ergo_box)
+
+    # create change boxes
+    amount = 12345678
+    box_value = Sigma::BoxValue.from_i64(amount)
+    tokens = Sigma::Tokens.create
+    str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
+    token_id = Sigma::TokenId.from_base16_encoded_string(str)
+    amount = 12345678
+    token_amount = Sigma::TokenAmount.with_i64(amount)
+    token = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
+    tokens.add(token)
+    ergo_box_assets_data = Sigma::ErgoBoxAssetsData.create(box_value: box_value, tokens: tokens)
+    change_boxes = Sigma::ErgoBoxAssetsDataList.create
+    change_boxes.add(ergo_box_assets_data)
+
+    selection = Sigma::BoxSelection.create(ergo_boxes: ergo_boxes, change_ergo_boxes: change_boxes)
+    retrieved_boxes = selection.get_boxes
+    assert_equal(ergo_boxes.len, retrieved_boxes.len)
+    assert_equal(ergo_boxes.get(0), retrieved_boxes.get(0))
+    assert_equal(ergo_boxes.get(1), retrieved_boxes.get(1))
+
+    retrieved_change_boxes = selection.get_change_boxes
+    assert_equal(change_boxes.len, retrieved_change_boxes.len)
+    assert_equal(change_boxes.get(0), retrieved_change_boxes.get(0))
+    assert_equal(change_boxes.get(1), retrieved_change_boxes.get(1))
+  end
+
+  def test_simple_box_selector
+    box_attrs = {
+      boxId: "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
+      value: 67500000000,
+      ergoTree: "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
+      assets: [],                                                                                                                                        
+      creationHeight: 284761,
+      additionalRegisters: {},
+      transactionId: "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
+      index: 1
+    }
+
+    json = box_attrs.to_json
+    boxes = Sigma::ErgoBoxes.from_json([json])
+    sbs = Sigma::SimpleBoxSelector.create
+    value = Sigma::BoxValue.from_i64(10000000)
+    tokens = Sigma::Tokens.create
+    selection = sbs.select(inputs: boxes, target_balance: value, target_tokens: tokens)
+    expected_box_id = boxes.get(0).get_box_id
+    selected_box_id = selection.get_boxes.get(0).get_box_id
+    assert_equal(expected_box_id, selected_box_id)
+  end
+end

data/tests/sigma/constant_test.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::Constant::Test < Test::Unit::TestCase
+  def test_i32
+    c = Sigma::Constant.with_i32(9999)
+    encoded = c.to_base16_string
+    decoded = Sigma::Constant.with_base_16(encoded)
+    assert_equal(c, decoded)
+  end
+
+  def test_i64
+    c = Sigma::Constant.with_i64(9223372036854775807)
+    encoded = c.to_base16_string
+    decoded = Sigma::Constant.with_base_16(encoded)
+    assert_equal(c, decoded)
+  end
+
+  def test_byte_array
+    bytes = [1,1,2,255]
+    c = Sigma::Constant.with_bytes(bytes)
+    encoded = c.to_base16_string
+    decoded = Sigma::Constant.with_base_16(encoded)
+    assert_equal(c, decoded)
+  end
+
+  def test_ec_point_bytes
+    str = "02d6b2141c21e4f337e9b065a031a6269fb5a49253094fc6243d38662eb765db00"
+    assert_nothing_raised do
+      Sigma::Constant.with_ecpoint_bytes(TestUtils.base16_string_to_bytes(str))
+    end
+  end
+
+  def test_ergo_box
+   json = {
+       "boxId": "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
+       "value": 67500000000,
+       "ergoTree": "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
+       "assets": [],
+       "creationHeight": 284761,
+       "additionalRegisters": {},
+       "transactionId": "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
+       "index": 1
+   }.to_json
+   ergo_box = Sigma::ErgoBox.with_json(json)
+   c = Sigma::Constant.with_ergo_box(ergo_box)
+   encoded = c.to_base16_string
+   decoded = Sigma::Constant.with_base_16(encoded)
+   assert_equal(c, decoded)
+  end
+end
+

data/tests/sigma/context_extension_test.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::ContextExtension::Test < Test::Unit::TestCase
+  def test_context_extension
+    # create
+    ce = Sigma::ContextExtension.create
+    # get_keys
+    assert_equal([], ce.get_keys)
+  end
+end

data/tests/sigma/contract_test.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::Contract::Test < Test::Unit::TestCase
+  def test_from_ergo_tree
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    contract = Sigma::Contract.from_ergo_tree(tree)
+    assert_equal(tree, contract.get_ergo_tree)
+  end
+
+  def test_pay_to_address
+    p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+    p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
+    assert_nothing_raised do
+      contract = Sigma::Contract.pay_to_address(p2pk_addr)
+    end
+
+    p2pk_addr_str = "9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA"
+    p2pk_addr = Sigma::Address.with_mainnet_address(p2pk_addr_str)
+    assert_nothing_raised do
+      contract = Sigma::Contract.pay_to_address(p2pk_addr)
+    end
+  end
+
+  # TODO
+#  def test_compile_from_string
+#script = <<-SCRIPT.chomp
+#SCRIPT
+#puts script
+#    assert_nothing_raised do
+#      contract = Sigma::Contract.compile_from_string(script)
+#    end
+#  end
+end

data/tests/sigma/data_input_test.rb

@@ -0,0 +1,38 @@
+
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::DataInput::Test < Test::Unit::TestCase
+  def test_data_input
+    str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_id = Sigma::BoxId.with_string(str)
+    data_input = Sigma::DataInput.with_box_id(box_id) 
+    assert_equal(box_id, data_input.get_box_id)
+  end
+
+  def test_data_inputs
+    # create
+    data_inputs = assert_nothing_raised do
+      Sigma::DataInputs.create
+    end
+    # len
+    assert_equal(0, data_inputs.len)
+    # get
+    assert_equal(nil, data_inputs.get(0))
+    assert_equal(nil, data_inputs.get(1))
+    # add
+    str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_id = Sigma::BoxId.with_string(str)
+    data_input = Sigma::DataInput.with_box_id(box_id) 
+    data_inputs.add(data_input)
+    assert_equal(1, data_inputs.len)
+    # no eq method for DataInput
+    assert_equal(box_id, data_inputs.get(0).get_box_id)
+    assert_equal(nil, data_inputs.get(1))
+  end
+end

data/tests/sigma/ergo_box_candidate_builder_test.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::ErgoBoxCandidateBuilder::Test < Test::Unit::TestCase
+  def test_create
+    amount = 12345678
+    box_value = Sigma::BoxValue.from_i64(amount)
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    contract = Sigma::Contract.from_ergo_tree(tree)
+    ebcb = Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
+  end
+
+  def test_box_value
+    amount = 43000000
+    box_value = Sigma::BoxValue.from_i64(amount)
+    p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+    p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
+    contract = Sigma::Contract.pay_to_address(p2pk_addr)
+    ebcb = assert_nothing_raised do
+      Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
+    end
+
+    min_per_byte = 1000000
+    ebcb.set_min_box_value_per_byte(min_per_byte)
+    assert_equal(min_per_byte, ebcb.get_min_box_value_per_byte)
+    assert_nothing_raised do
+      ebcb.calc_box_size_bytes
+    end
+
+    new_amount = 123456789
+    new_box_value = Sigma::BoxValue.from_i64(new_amount)
+    ebcb.set_value(new_box_value)
+    assert_equal(new_box_value, ebcb.get_value)
+  end
+
+  def test_register_value
+    amount = 43000000
+    box_value = Sigma::BoxValue.from_i64(amount)
+    p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+    p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
+    contract = Sigma::Contract.pay_to_address(p2pk_addr)
+    ebcb = assert_nothing_raised do
+      Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
+    end
+    constant_val = 1
+    constant = Sigma::Constant.with_i32(constant_val)
+    ebcb.set_register_value(Sigma::REGISTER_ID_ENUM[:r4], constant)
+    assert_equal(constant, ebcb.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
+    box = ebcb.build
+    assert_equal(constant, box.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
+  end
+  
+  def test_delete_register
+    amount = 43000000
+    box_value = Sigma::BoxValue.from_i64(amount)
+    p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+    p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
+    contract = Sigma::Contract.pay_to_address(p2pk_addr)
+    ebcb = assert_nothing_raised do
+      Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
+    end
+    constant_val = 1
+    constant = Sigma::Constant.with_i32(constant_val)
+    ebcb.set_register_value(Sigma::REGISTER_ID_ENUM[:r4], constant)
+    assert_equal(constant, ebcb.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
+    ebcb = ebcb.delete_register_value(Sigma::REGISTER_ID_ENUM[:r4])
+    assert_equal(nil, ebcb.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
+    box = ebcb.build
+    assert_equal(nil, box.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
+  end
+end

data/tests/sigma/ergo_box_test.rb

@@ -0,0 +1,219 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::ErgoBox::Test < Test::Unit::TestCase
+  def test_box_id
+    str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_id = Sigma::BoxId.with_string(str)
+    new_str = box_id.to_s
+    assert_equal(str, new_str)
+    new_bytes = box_id.to_bytes
+    expected_bytes = [229, 104, 71, 237, 25, 179, 220, 107, 114, 130, 143, 207, 185, 146, 253, 247, 49, 8, 40, 207, 41, 18, 33, 38, 155, 127, 252, 114, 253, 102, 112, 110]
+    assert_equal(expected_bytes, new_bytes)
+  end
+
+  def test_box_value
+    amount = 12345678
+    box_value = Sigma::BoxValue.from_i64(amount)
+    assert_equal(box_value.to_i64, amount)
+  end
+
+  def test_box_value_units_per_ergo
+    units_per_ergo = Sigma::BoxValue.units_per_ergo
+    expected_units_per_ergo = 1000000000
+    assert_equal(expected_units_per_ergo, units_per_ergo)
+  end
+
+  def test_box_value_sum_of
+    amount_one = 12345678
+    amount_two = 12345679
+    sum = amount_one + amount_two
+    bv_one = Sigma::BoxValue.from_i64(amount_one)
+    bv_two = Sigma::BoxValue.from_i64(amount_two)
+    bv_three = Sigma::BoxValue.sum_of(bv_one, bv_two)
+    assert_equal(bv_three.to_i64, sum)
+  end
+
+  def test_box_value_safe_user_min
+    bv = Sigma::BoxValue.safe_user_min
+    expected_safe_user_min = 1000000
+    assert_equal(expected_safe_user_min, bv.to_i64)
+  end
+
+  def test_ergo_box_initializer
+    box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_value_int = 67500000000
+    ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
+    creation_height = 284761
+    index = 1
+
+    box_id = Sigma::BoxId.with_string(box_id_str)
+    box_value = Sigma::BoxValue.from_i64(box_value_int)
+    ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
+    contract = Sigma::Contract.from_ergo_tree(ergo_tree)
+    tx_id = Sigma::TxId.with_string(tx_id_str)
+    tokens = Sigma::Tokens.create
+    ergo_box = Sigma::ErgoBox.create(box_value: box_value, creation_height: creation_height, 
+      contract: contract, tx_id: tx_id, index: index, tokens: tokens)
+
+    assert_equal(creation_height, ergo_box.get_creation_height)
+    assert_equal(box_id, ergo_box.get_box_id)
+    assert_equal(box_value, ergo_box.get_box_value)
+    assert_equal(ergo_tree, ergo_box.get_ergo_tree)
+  end
+
+  def test_ergo_box_json
+    box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_value_int = 67500000000
+    ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
+    creation_height = 284761
+    index = 1
+
+    box_id = Sigma::BoxId.with_string(box_id_str)
+    box_value = Sigma::BoxValue.from_i64(box_value_int)
+    ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
+
+    payload = {
+      'boxId' => box_id_str,
+      'value' => box_value_int,
+      'ergoTree' => ergo_tree_encoded_str,
+      'assets' => [],
+      'creationHeight' => creation_height,
+      'additionalRegisters' => {},
+      'transactionId' => tx_id_str,
+      'index' => index
+    }
+    # EIP-12 Value can be a number or a string, in this case it is a string
+    payload_eip12 = payload.merge({'value' => box_value_int.to_s})
+
+    json_str = payload.to_json
+
+    ergo_box = Sigma::ErgoBox.with_json(json_str)
+
+    assert_equal(creation_height, ergo_box.get_creation_height)
+    assert_equal(box_id, ergo_box.get_box_id)
+    assert_equal(box_value, ergo_box.get_box_value)
+    assert_equal(ergo_tree, ergo_box.get_ergo_tree)
+    assert_equal(payload, JSON.parse(ergo_box.to_json))
+    assert_equal(payload_eip12, JSON.parse(ergo_box.to_json_eip12))
+  end
+
+  def test_ergo_boxes
+    box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_value_int = 67500000000
+    ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
+    creation_height = 284761
+    index = 1
+
+    box_id = Sigma::BoxId.with_string(box_id_str)
+    box_value = Sigma::BoxValue.from_i64(box_value_int)
+    ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
+    contract = Sigma::Contract.from_ergo_tree(ergo_tree)
+    tx_id = Sigma::TxId.with_string(tx_id_str)
+    tokens = Sigma::Tokens.create
+    ergo_box = Sigma::ErgoBox.create(box_value: box_value, creation_height: creation_height, 
+      contract: contract, tx_id: tx_id, index: index, tokens: tokens)
+
+    ergo_boxes = Sigma::ErgoBoxes.create
+    assert_equal(0, ergo_boxes.len)
+
+    ergo_boxes.add(ergo_box)
+    assert_equal(1, ergo_boxes.len)
+
+    retrieved_box = ergo_boxes.get(0)
+    assert_equal(ergo_box, retrieved_box)
+
+    nil_retrieved_box = ergo_boxes.get(1)
+    assert_equal(nil, nil_retrieved_box)
+
+    boxes_in_json = [ergo_box.to_json, retrieved_box.to_json]
+    ergo_boxes_from_json = Sigma::ErgoBoxes.from_json(boxes_in_json)
+    assert_equal(2, ergo_boxes_from_json.len)
+    assert_equal(ergo_box, ergo_boxes_from_json.get(0))
+  end
+
+  def test_ergo_box_candidates
+    # create
+    ebcs = assert_nothing_raised do
+      Sigma::ErgoBoxCandidates.create
+    end
+
+    # len
+    assert_equal(0, ebcs.len)
+
+    # get
+    assert_equal(nil, ebcs.get(0))
+    assert_equal(nil, ebcs.get(1))
+
+    # add
+    amount = 43000000
+    box_value = Sigma::BoxValue.from_i64(amount)
+    p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+    p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
+    contract = Sigma::Contract.pay_to_address(p2pk_addr)
+    ebcb = Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
+    cbox = ebcb.build
+    ebcs.add(cbox)
+    assert_equal(1, ebcs.len)
+    assert_equal(cbox, ebcs.get(0))
+    assert_equal(nil, ebcs.get(1))
+  end
+
+  def test_ergo_box_assets_data
+    # create
+    amount = 12345678
+    box_value = Sigma::BoxValue.from_i64(amount)
+    tokens = Sigma::Tokens.create
+    str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
+    token_id = Sigma::TokenId.from_base16_encoded_string(str)
+    amount = 12345678
+    token_amount = Sigma::TokenAmount.with_i64(amount)
+    token = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
+    tokens.add(token)
+    ergo_box_assets_data = Sigma::ErgoBoxAssetsData.create(box_value: box_value, tokens: tokens)
+    # get_box_value
+    assert_equal(box_value, ergo_box_assets_data.get_box_value)
+    # get_tokens
+    box_tokens = ergo_box_assets_data.get_box_tokens
+    assert_equal(tokens.len, box_tokens.len)
+    assert_equal(tokens.get(0), box_tokens.get(0))
+    assert_equal(tokens.get(1), box_tokens.get(1))
+  end
+
+  def test_ergo_box_assets_data_list
+    # create
+    ebs = assert_nothing_raised do
+      Sigma::ErgoBoxAssetsDataList.create
+    end
+
+    # len
+    assert_equal(0, ebs.len)
+
+    # get
+    assert_equal(nil, ebs.get(0))
+    assert_equal(nil, ebs.get(1))
+
+    # add
+    amount = 12345678
+    box_value = Sigma::BoxValue.from_i64(amount)
+    tokens = Sigma::Tokens.create
+    str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
+    token_id = Sigma::TokenId.from_base16_encoded_string(str)
+    amount = 12345678
+    token_amount = Sigma::TokenAmount.with_i64(amount)
+    token = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
+    tokens.add(token)
+    ergo_box_assets_data = Sigma::ErgoBoxAssetsData.create(box_value: box_value, tokens: tokens)
+    ebs.add(ergo_box_assets_data)
+    assert_equal(1, ebs.len)
+    assert_equal(ergo_box_assets_data, ebs.get(0))
+  end
+end

data/tests/sigma/ergo_state_context_test.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+include Sigma
+
+class ErgoStateContext::Test < Test::Unit::TestCase
+  def test_ergo_state_context
+    block_header = BlockHeader.with_json(TestSeeds.block_header_json)
+    pre_header = PreHeader.with_block_header(block_header)
+    block_headers = TestSeeds.block_headers_from_json
+    assert_nothing_raised do 
+      ctx = ErgoStateContext.create(pre_header: pre_header, headers: block_headers)
+    end 
+    # invalid # of headers
+    invalid_headers_json = Array.new(8) { TestSeeds.block_header_json } 
+    invalid_block_headers = BlockHeaders.from_json(invalid_headers_json)
+    assert_raises do
+      ctx = ErgoStateContext.create(pre_header: pre_header, headers: invalid_block_headers)
+    end
+  end
+end