sigma_rb 0.1.3

data/tests/sigma/ergo_tree_test.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::ErgoTree::Test < Test::Unit::TestCase
+
+  def test_encoding
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    assert_equal(base_16, tree.to_base16_encoded_string)
+    assert_nothing_raised do
+      tree.to_bytes
+    end
+    assert_nothing_raised do
+      tree.to_template_bytes
+    end
+  end
+
+  def test_constant_length
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    assert_equal(2, tree.constants_length)
+  end
+
+  def test_get_constant
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    assert_not_nil(tree.get_constant(0))
+    assert_not_nil(tree.get_constant(1))
+    assert_equal(nil, tree.get_constant(2))
+  end
+
+  def test_with_constant
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    assert_equal(2, tree.constants_length)
+    constant = Sigma::Constant.with_i32(99)
+    tree.replace_constant(index: 0, constant: constant)
+    assert_equal(99, tree.get_constant(0).to_i32) 
+    assert_equal(2, tree.constants_length) 
+  end
+
+  def test_with_constant_out_of_bounds
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    assert_equal(2, tree.constants_length)
+    constant = Sigma::Constant.with_i32(99)
+    assert_raise do
+      tree.replace_constant(index: 3, constant: constant)
+    end
+  end
+
+  def test_with_constant_type_mismatch
+    base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
+    tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
+    assert_equal(2, tree.constants_length)
+    constant = Sigma::Constant.with_i64(342423)
+    assert_raise do
+      tree.replace_constant(index: 0, constant: constant)
+    end
+  end
+end
+

data/tests/sigma/input_test.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::Input::Test < Test::Unit::TestCase
+  # TODO
+  def test_input
+    # get_box_id
+    # get_spending_proof
+  end
+
+  def test_inputs
+    # create
+    # len
+    # get
+    # add
+  end
+
+  def test_prover_result
+    # to_bytes
+    # get_context_extension
+    # to_json
+  end
+
+  def test_unsigned_input
+    # get_box_id
+    # get_context_extension
+  end
+
+  def test_unsigned_inputs
+    # create
+    # len
+    # get
+    # add
+  end
+end
+

data/tests/sigma/merkle_proof_test.rb

@@ -0,0 +1,34 @@
+
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+include Sigma
+
+class Sigma::MerkleProof::Test < Test::Unit::TestCase
+  def test_block_proof
+    json = {
+      leafData: "563b34b96e65788d767a10b0c2ce4a9ef5dcb9f7f7919781624870d56506dc5b",
+      levels: [
+          ["274d105b42c2da3e03519865470ccef5072d389b153535ca7192fef4abf3b3ed", 0],
+          ["c1887cee0c42318ac04dfa93b8ef6b40c2b53a83b0e111f91a16b0842166e76e", 0],
+          ["58be076cd9ef596a739ec551cbb6b467b95044c05a80a66a7f256d4ebafd787f", 0]]
+    }.to_json
+    merkle_proof = MerkleProof.with_json(json)
+    root = "250063ac1cec3bf56f727f644f49b70515616afa6009857a29b1fe298441e69a"
+    assert(merkle_proof.valid(root))
+  end
+
+  def test_miner_proof
+    json = {
+      leafData: "642c15c62553edd8fd9af9a6f754f3c7a6c03faacd0c9b9d5b7d11052c6c6fe8",
+      levels: [["39b79af823a92aa72ced2c6d9e7f7f4687de5b5af7fab0ad205d3e54bda3f3ae",1]]
+    }.to_json
+    merkle_proof = MerkleProof.with_json(json)
+    root = "74c851610658a40f5ae74aa3a4babd5751bd827a6ccc1fe069468ef487cb90a8"
+    assert(merkle_proof.valid(root))
+  end
+end

data/tests/sigma/nipopow_test.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+include Sigma
+
+class Sigma::NipopowProof::Test < Test::Unit::TestCase
+  def test_from_json
+    json = {
+      "header": {
+      "version": 1,
+      "id": "fa31f25f95c6ae9752392daa38f45c59e57593a4def26427cbda25747938d0a3",
+      "parentId": "99e19212a3dd1f3951464cbeb42e6bc447b646fe20e362653009be31b8ac756d",
+      "adProofsRoot": "7bd5d1c0df436e1e175df31a0272013ca93f2305a1bddea99d6b607ecf24fcac",
+      "stateRoot": "000000000000000000000000000000000000000000000000000000000000000000",
+      "transactionsRoot": "024562cb92738cbe9f5345b6d78b0272f4823692d2a16a11d80459c6d61f7860",
+      "timestamp": 0,                                                                                                                                      
+      "nBits": 16842752,
+      "height": 8,
+      "extensionHash": "696a076089090b128c4856a17e2e23ed2788d074fe09e9975e2ee799f79e9743",
+      "powSolutions": {
+        "pk": "038b0f29a60fa8d7e1aeafbe512288a6c6bc696547bbf8247db23c95e83014513c",
+        "w": "03a0f176159c0895ee4cc64149ff3fa8a0ccf8cf15b884fb0bfaabc0bae2355b10",
+        "n": "8000000000000000",
+        "d": "21099867708510879837487107380901512552573946537697225889752133246839759121455"
+        },
+        "votes": "000000"
+        },
+        "interlinks": [
+        "e57483be3653936848f646ebd44e8ea7311d3d8fbc07b4c900a1b7edcc0b9a74",
+        "b2525defb4a3ab2f0ffdad6f37ff5a9e330eae2f00ec0c19f1aef234369bd408",
+        "99e19212a3dd1f3951464cbeb42e6bc447b646fe20e362653009be31b8ac756d"
+        ],
+        "interlinksProof": {
+        "indices": [
+            {
+            "index": 0,
+            "digest": "e489b3601239d37b066aa53b6640758c9774334dde616d43fb8288e1fdb4f083"
+            },
+            {
+            "index": 1,
+            "digest": "76387dd1010dbfc7e318fb7989fe3013099ca0ed4fc6176471815ab116e3542a"
+            },
+            {
+            "index": 2,
+            "digest": "c61ce82b2b3bfe369daaa51e5df8070364d68e0cb9a3dfa6ebf79e3bfb89d9fa"
+            }
+            ],
+            "proofs": [
+                {
+                "digest": "",
+                "side": 1
+                }
+            ]
+         }
+    }.to_json
+
+    header_json = {
+      "version": 1,
+      "id": "fa31f25f95c6ae9752392daa38f45c59e57593a4def26427cbda25747938d0a3",
+      "parentId": "99e19212a3dd1f3951464cbeb42e6bc447b646fe20e362653009be31b8ac756d",
+      "adProofsRoot": "7bd5d1c0df436e1e175df31a0272013ca93f2305a1bddea99d6b607ecf24fcac",
+      "stateRoot": "000000000000000000000000000000000000000000000000000000000000000000",
+      "transactionsRoot": "024562cb92738cbe9f5345b6d78b0272f4823692d2a16a11d80459c6d61f7860",
+      "timestamp": 0,
+      "nBits": 16842752,
+      "height": 8,
+      "extensionHash": "696a076089090b128c4856a17e2e23ed2788d074fe09e9975e2ee799f79e9743",
+      "powSolutions": {
+          "pk": "038b0f29a60fa8d7e1aeafbe512288a6c6bc696547bbf8247db23c95e83014513c",
+          "w": "03a0f176159c0895ee4cc64149ff3fa8a0ccf8cf15b884fb0bfaabc0bae2355b10",
+          "n": "8000000000000000",
+          "d": "21099867708510879837487107380901512552573946537697225889752133246839759121455"
+      },
+      "votes": "000000"
+   }.to_json
+
+    popow = PoPowHeader.with_json(json)
+    assert_equal(3, popow.get_interlinks.len)
+    assert_equal(BlockHeader.with_json(header_json), popow.get_header)
+    #assert(popow.check_interlinks_proof)
+  end
+
+  def test_nipopow_proof
+    # TODO
+    # with_json
+    # is_better_than
+    # to_json
+  end
+
+  def test_nipopow_verifier
+    # TODO
+    # create
+    # best_chain
+    # process
+  end
+end

data/tests/sigma/secret_key_test.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'json'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::SecretKey::Test < Test::Unit::TestCase
+  def test_secret_key 
+    sk = Sigma::SecretKey.create
+    assert_nothing_raised do
+      address = sk.get_address
+    end
+    bytes = sk.to_bytes
+    sk_2 = Sigma::SecretKey.from_bytes(bytes)
+    assert_equal(bytes, sk_2.to_bytes)
+  end
+
+  def test_secret_keys
+    sk = Sigma::SecretKey.create
+    sks = Sigma::SecretKeys.create
+    assert_equal(0, sks.len)
+    assert_equal(nil, sks.get(0))
+    sks.add(sk)
+    assert_equal(1, sks.len)
+    assert_equal(sk.to_bytes, sks.get(0).to_bytes)
+    assert_equal(nil, sks.get(1))
+  end
+
+end

data/tests/sigma/token_test.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+
+require_relative '../../lib/sigma.rb'
+require_relative '../test_utils.rb'
+
+class Sigma::Token::Test < Test::Unit::TestCase
+  def test_token_id_from_box_id
+    str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
+    box_id = Sigma::BoxId.with_string(str)
+    token_id = Sigma::TokenId.with_box_id(box_id)
+    assert_nothing_raised do
+      token_id.to_base16_encoded_string
+    end
+
+    token_id_two = Sigma::TokenId.with_box_id(box_id)
+    assert_equal(token_id, token_id_two)
+  end
+
+  def test_token_id_from_string
+    str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
+    token_id = Sigma::TokenId.from_base16_encoded_string(str)
+    assert_equal(str, token_id.to_base16_encoded_string)
+
+    token_id_two = Sigma::TokenId.from_base16_encoded_string(str)
+    assert_equal(token_id, token_id_two)
+  end
+
+  def test_token_amount_from_int
+    amount = 12345678
+    token_amount = Sigma::TokenAmount.with_i64(amount)
+    assert_equal(amount, token_amount.to_i)
+
+    token_amount_two = Sigma::TokenAmount.with_i64(amount)
+    assert_equal(token_amount, token_amount_two)
+  end
+
+  def test_token
+    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)
+    new_token_id = token.get_id
+    new_token_amount = token.get_amount
+    assert_equal(str, new_token_id.to_base16_encoded_string)
+    assert_equal(token_id, new_token_id)
+    assert_equal(token_amount, new_token_amount)
+
+    token_two = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
+    assert_equal(token, token_two)
+  end
+
+  def test_token_json
+    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)
+    assert_nothing_raised do
+      token.to_json_eip12
+    end
+  end
+
+  def test_tokens
+    tokens = Sigma::Tokens.create
+    assert_equal(0, tokens.len)
+    assert_equal(nil, tokens.get(3))
+    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)
+
+    255.times do |i|
+      tokens.add(token)
+    end
+    assert_equal(255, tokens.len)
+    assert_equal(tokens.get(254), token)
+
+    # 256 raises error
+    assert_raise do
+      tokens.add(token)
+    end
+  end
+end