sigma_rb 0.1.3
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/LICENSE +21 -0
- data/README.md +9 -0
- data/ext/Rakefile +7 -0
- data/ext/csigma.c +5 -0
- data/lib/sigma/address.rb +73 -0
- data/lib/sigma/block_header.rb +197 -0
- data/lib/sigma/box_selection.rb +105 -0
- data/lib/sigma/byte_array.rb +96 -0
- data/lib/sigma/constant.rb +117 -0
- data/lib/sigma/context_extension.rb +47 -0
- data/lib/sigma/contract.rb +70 -0
- data/lib/sigma/data_input.rb +100 -0
- data/lib/sigma/enums.rb +35 -0
- data/lib/sigma/ergo_box.rb +556 -0
- data/lib/sigma/ergo_box_candidate_builder.rb +123 -0
- data/lib/sigma/ergo_state_context.rb +41 -0
- data/lib/sigma/ergo_tree.rb +111 -0
- data/lib/sigma/input.rb +249 -0
- data/lib/sigma/merkle_proof.rb +79 -0
- data/lib/sigma/nipopow.rb +155 -0
- data/lib/sigma/pre_header.rb +38 -0
- data/lib/sigma/reduced_transaction.rb +88 -0
- data/lib/sigma/secret_key.rb +119 -0
- data/lib/sigma/structs.rb +31 -0
- data/lib/sigma/token.rb +225 -0
- data/lib/sigma/transaction.rb +365 -0
- data/lib/sigma/tx_builder.rb +116 -0
- data/lib/sigma/util.rb +27 -0
- data/lib/sigma/wallet.rb +97 -0
- data/lib/sigma.rb +32 -0
- data/sigma.gemspec +20 -0
- data/tests/all.rb +44 -0
- data/tests/sigma/address_test.rb +45 -0
- data/tests/sigma/block_header_test.rb +35 -0
- data/tests/sigma/box_selection_test.rb +78 -0
- data/tests/sigma/constant_test.rb +57 -0
- data/tests/sigma/context_extension_test.rb +16 -0
- data/tests/sigma/contract_test.rb +39 -0
- data/tests/sigma/data_input_test.rb +38 -0
- data/tests/sigma/ergo_box_candidate_builder_test.rb +76 -0
- data/tests/sigma/ergo_box_test.rb +219 -0
- data/tests/sigma/ergo_state_context_test.rb +26 -0
- data/tests/sigma/ergo_tree_test.rb +66 -0
- data/tests/sigma/input_test.rb +41 -0
- data/tests/sigma/merkle_proof_test.rb +34 -0
- data/tests/sigma/nipopow_test.rb +100 -0
- data/tests/sigma/secret_key_test.rb +31 -0
- data/tests/sigma/token_test.rb +87 -0
- data/tests/sigma/transaction_test.rb +438 -0
- data/tests/sigma_test.rb +18 -0
- data/tests/test_seeds.rb +35 -0
- data/tests/test_utils.rb +11 -0
- metadata +174 -0
@@ -0,0 +1,45 @@
|
|
1
|
+
|
2
|
+
require 'rubygems'
|
3
|
+
require 'bundler/setup'
|
4
|
+
require 'test/unit'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
class Sigma::Address::Test < Test::Unit::TestCase
|
10
|
+
def test_testnet_addresses
|
11
|
+
p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
|
12
|
+
p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
|
13
|
+
assert_equal(p2pk_addr_str, p2pk_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:testnet]))
|
14
|
+
assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:p2pk], p2pk_addr.type_prefix)
|
15
|
+
|
16
|
+
p2sh_addr_str = "rbcrmKEYduUvADj9Ts3dSVSG27h54pgrq5fPuwB"
|
17
|
+
p2sh_addr = Sigma::Address.with_testnet_address(p2sh_addr_str)
|
18
|
+
assert_equal(p2sh_addr_str, p2sh_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:testnet]))
|
19
|
+
assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:pay2sh], p2sh_addr.type_prefix)
|
20
|
+
end
|
21
|
+
|
22
|
+
def test_mainnet_addresses
|
23
|
+
p2pk_addr_str = "9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA"
|
24
|
+
p2pk_addr = Sigma::Address.with_mainnet_address(p2pk_addr_str)
|
25
|
+
assert_equal(p2pk_addr_str, p2pk_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:mainnet]))
|
26
|
+
assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:p2pk], p2pk_addr.type_prefix)
|
27
|
+
|
28
|
+
p2sh_addr_str = "8UApt8czfFVuTgQmMwtsRBZ4nfWquNiSwCWUjMg"
|
29
|
+
p2sh_addr = Sigma::Address.with_mainnet_address(p2sh_addr_str)
|
30
|
+
assert_equal(p2sh_addr_str, p2sh_addr.to_base58(Sigma::NETWORK_PREFIX_ENUM[:mainnet]))
|
31
|
+
assert_equal(Sigma::ADDRESS_TYPE_PREFIX_ENUM[:pay2sh], p2sh_addr.type_prefix)
|
32
|
+
end
|
33
|
+
|
34
|
+
def test_base58_address
|
35
|
+
addr_str = "9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA"
|
36
|
+
address = Sigma::Address.with_base58_address(addr_str)
|
37
|
+
assert_equal(addr_str, address.to_base58(Sigma::NETWORK_PREFIX_ENUM[:mainnet]))
|
38
|
+
end
|
39
|
+
|
40
|
+
def test_invalid_address
|
41
|
+
assert_raises do
|
42
|
+
Sigma::Address.with_mainnet_address("sss")
|
43
|
+
end
|
44
|
+
end
|
45
|
+
end
|
@@ -0,0 +1,35 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
require 'json'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
class Sigma::BlockHeader::Test < Test::Unit::TestCase
|
10
|
+
def test_block_header
|
11
|
+
header_json = TestSeeds.block_header_json
|
12
|
+
block_header = Sigma::BlockHeader.with_json(header_json)
|
13
|
+
assert_nothing_raised do
|
14
|
+
Sigma::PreHeader.with_block_header(block_header)
|
15
|
+
end
|
16
|
+
assert_raises do
|
17
|
+
Sigma::BlockHeader.from_json("")
|
18
|
+
end
|
19
|
+
headers = Sigma::BlockHeaders.create
|
20
|
+
assert_equal(nil, headers.get(0))
|
21
|
+
assert_equal(0, headers.len)
|
22
|
+
assert_nothing_raised do
|
23
|
+
headers.add(block_header)
|
24
|
+
end
|
25
|
+
assert_equal(1, headers.len)
|
26
|
+
assert_equal(block_header, headers.get(0))
|
27
|
+
assert_equal(nil, headers.get(1))
|
28
|
+
assert_nothing_raised do
|
29
|
+
headers.add(block_header)
|
30
|
+
end
|
31
|
+
assert_equal(2, headers.len)
|
32
|
+
assert_equal(block_header, headers.get(1))
|
33
|
+
assert_equal(nil, headers.get(2))
|
34
|
+
end
|
35
|
+
end
|
@@ -0,0 +1,78 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
require 'json'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
class Sigma::BoxSelection::Test < Test::Unit::TestCase
|
10
|
+
def test_box_selection
|
11
|
+
# create ergo boxes
|
12
|
+
box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
13
|
+
box_value_int = 67500000000
|
14
|
+
ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
|
15
|
+
tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
|
16
|
+
creation_height = 284761
|
17
|
+
index = 1
|
18
|
+
|
19
|
+
box_id = Sigma::BoxId.with_string(box_id_str)
|
20
|
+
box_value = Sigma::BoxValue.from_i64(box_value_int)
|
21
|
+
ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
|
22
|
+
contract = Sigma::Contract.from_ergo_tree(ergo_tree)
|
23
|
+
tx_id = Sigma::TxId.with_string(tx_id_str)
|
24
|
+
tokens = Sigma::Tokens.create
|
25
|
+
ergo_box = Sigma::ErgoBox.create(box_value: box_value, creation_height: creation_height,
|
26
|
+
contract: contract, tx_id: tx_id, index: index, tokens: tokens)
|
27
|
+
ergo_boxes = Sigma::ErgoBoxes.create
|
28
|
+
ergo_boxes.add(ergo_box)
|
29
|
+
|
30
|
+
# create change boxes
|
31
|
+
amount = 12345678
|
32
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
33
|
+
tokens = Sigma::Tokens.create
|
34
|
+
str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
|
35
|
+
token_id = Sigma::TokenId.from_base16_encoded_string(str)
|
36
|
+
amount = 12345678
|
37
|
+
token_amount = Sigma::TokenAmount.with_i64(amount)
|
38
|
+
token = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
|
39
|
+
tokens.add(token)
|
40
|
+
ergo_box_assets_data = Sigma::ErgoBoxAssetsData.create(box_value: box_value, tokens: tokens)
|
41
|
+
change_boxes = Sigma::ErgoBoxAssetsDataList.create
|
42
|
+
change_boxes.add(ergo_box_assets_data)
|
43
|
+
|
44
|
+
selection = Sigma::BoxSelection.create(ergo_boxes: ergo_boxes, change_ergo_boxes: change_boxes)
|
45
|
+
retrieved_boxes = selection.get_boxes
|
46
|
+
assert_equal(ergo_boxes.len, retrieved_boxes.len)
|
47
|
+
assert_equal(ergo_boxes.get(0), retrieved_boxes.get(0))
|
48
|
+
assert_equal(ergo_boxes.get(1), retrieved_boxes.get(1))
|
49
|
+
|
50
|
+
retrieved_change_boxes = selection.get_change_boxes
|
51
|
+
assert_equal(change_boxes.len, retrieved_change_boxes.len)
|
52
|
+
assert_equal(change_boxes.get(0), retrieved_change_boxes.get(0))
|
53
|
+
assert_equal(change_boxes.get(1), retrieved_change_boxes.get(1))
|
54
|
+
end
|
55
|
+
|
56
|
+
def test_simple_box_selector
|
57
|
+
box_attrs = {
|
58
|
+
boxId: "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
|
59
|
+
value: 67500000000,
|
60
|
+
ergoTree: "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
|
61
|
+
assets: [],
|
62
|
+
creationHeight: 284761,
|
63
|
+
additionalRegisters: {},
|
64
|
+
transactionId: "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
|
65
|
+
index: 1
|
66
|
+
}
|
67
|
+
|
68
|
+
json = box_attrs.to_json
|
69
|
+
boxes = Sigma::ErgoBoxes.from_json([json])
|
70
|
+
sbs = Sigma::SimpleBoxSelector.create
|
71
|
+
value = Sigma::BoxValue.from_i64(10000000)
|
72
|
+
tokens = Sigma::Tokens.create
|
73
|
+
selection = sbs.select(inputs: boxes, target_balance: value, target_tokens: tokens)
|
74
|
+
expected_box_id = boxes.get(0).get_box_id
|
75
|
+
selected_box_id = selection.get_boxes.get(0).get_box_id
|
76
|
+
assert_equal(expected_box_id, selected_box_id)
|
77
|
+
end
|
78
|
+
end
|
@@ -0,0 +1,57 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
require 'json'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
class Sigma::Constant::Test < Test::Unit::TestCase
|
10
|
+
def test_i32
|
11
|
+
c = Sigma::Constant.with_i32(9999)
|
12
|
+
encoded = c.to_base16_string
|
13
|
+
decoded = Sigma::Constant.with_base_16(encoded)
|
14
|
+
assert_equal(c, decoded)
|
15
|
+
end
|
16
|
+
|
17
|
+
def test_i64
|
18
|
+
c = Sigma::Constant.with_i64(9223372036854775807)
|
19
|
+
encoded = c.to_base16_string
|
20
|
+
decoded = Sigma::Constant.with_base_16(encoded)
|
21
|
+
assert_equal(c, decoded)
|
22
|
+
end
|
23
|
+
|
24
|
+
def test_byte_array
|
25
|
+
bytes = [1,1,2,255]
|
26
|
+
c = Sigma::Constant.with_bytes(bytes)
|
27
|
+
encoded = c.to_base16_string
|
28
|
+
decoded = Sigma::Constant.with_base_16(encoded)
|
29
|
+
assert_equal(c, decoded)
|
30
|
+
end
|
31
|
+
|
32
|
+
def test_ec_point_bytes
|
33
|
+
str = "02d6b2141c21e4f337e9b065a031a6269fb5a49253094fc6243d38662eb765db00"
|
34
|
+
assert_nothing_raised do
|
35
|
+
Sigma::Constant.with_ecpoint_bytes(TestUtils.base16_string_to_bytes(str))
|
36
|
+
end
|
37
|
+
end
|
38
|
+
|
39
|
+
def test_ergo_box
|
40
|
+
json = {
|
41
|
+
"boxId": "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
|
42
|
+
"value": 67500000000,
|
43
|
+
"ergoTree": "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
|
44
|
+
"assets": [],
|
45
|
+
"creationHeight": 284761,
|
46
|
+
"additionalRegisters": {},
|
47
|
+
"transactionId": "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
|
48
|
+
"index": 1
|
49
|
+
}.to_json
|
50
|
+
ergo_box = Sigma::ErgoBox.with_json(json)
|
51
|
+
c = Sigma::Constant.with_ergo_box(ergo_box)
|
52
|
+
encoded = c.to_base16_string
|
53
|
+
decoded = Sigma::Constant.with_base_16(encoded)
|
54
|
+
assert_equal(c, decoded)
|
55
|
+
end
|
56
|
+
end
|
57
|
+
|
@@ -0,0 +1,16 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
require 'json'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
class Sigma::ContextExtension::Test < Test::Unit::TestCase
|
10
|
+
def test_context_extension
|
11
|
+
# create
|
12
|
+
ce = Sigma::ContextExtension.create
|
13
|
+
# get_keys
|
14
|
+
assert_equal([], ce.get_keys)
|
15
|
+
end
|
16
|
+
end
|
@@ -0,0 +1,39 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
|
5
|
+
require_relative '../../lib/sigma.rb'
|
6
|
+
require_relative '../test_utils.rb'
|
7
|
+
|
8
|
+
class Sigma::Contract::Test < Test::Unit::TestCase
|
9
|
+
def test_from_ergo_tree
|
10
|
+
base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
|
11
|
+
tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
|
12
|
+
contract = Sigma::Contract.from_ergo_tree(tree)
|
13
|
+
assert_equal(tree, contract.get_ergo_tree)
|
14
|
+
end
|
15
|
+
|
16
|
+
def test_pay_to_address
|
17
|
+
p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
|
18
|
+
p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
|
19
|
+
assert_nothing_raised do
|
20
|
+
contract = Sigma::Contract.pay_to_address(p2pk_addr)
|
21
|
+
end
|
22
|
+
|
23
|
+
p2pk_addr_str = "9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA"
|
24
|
+
p2pk_addr = Sigma::Address.with_mainnet_address(p2pk_addr_str)
|
25
|
+
assert_nothing_raised do
|
26
|
+
contract = Sigma::Contract.pay_to_address(p2pk_addr)
|
27
|
+
end
|
28
|
+
end
|
29
|
+
|
30
|
+
# TODO
|
31
|
+
# def test_compile_from_string
|
32
|
+
#script = <<-SCRIPT.chomp
|
33
|
+
#SCRIPT
|
34
|
+
#puts script
|
35
|
+
# assert_nothing_raised do
|
36
|
+
# contract = Sigma::Contract.compile_from_string(script)
|
37
|
+
# end
|
38
|
+
# end
|
39
|
+
end
|
@@ -0,0 +1,38 @@
|
|
1
|
+
|
2
|
+
require 'rubygems'
|
3
|
+
require 'bundler/setup'
|
4
|
+
require 'test/unit'
|
5
|
+
require 'json'
|
6
|
+
|
7
|
+
require_relative '../../lib/sigma.rb'
|
8
|
+
require_relative '../test_utils.rb'
|
9
|
+
|
10
|
+
class Sigma::DataInput::Test < Test::Unit::TestCase
|
11
|
+
def test_data_input
|
12
|
+
str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
13
|
+
box_id = Sigma::BoxId.with_string(str)
|
14
|
+
data_input = Sigma::DataInput.with_box_id(box_id)
|
15
|
+
assert_equal(box_id, data_input.get_box_id)
|
16
|
+
end
|
17
|
+
|
18
|
+
def test_data_inputs
|
19
|
+
# create
|
20
|
+
data_inputs = assert_nothing_raised do
|
21
|
+
Sigma::DataInputs.create
|
22
|
+
end
|
23
|
+
# len
|
24
|
+
assert_equal(0, data_inputs.len)
|
25
|
+
# get
|
26
|
+
assert_equal(nil, data_inputs.get(0))
|
27
|
+
assert_equal(nil, data_inputs.get(1))
|
28
|
+
# add
|
29
|
+
str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
30
|
+
box_id = Sigma::BoxId.with_string(str)
|
31
|
+
data_input = Sigma::DataInput.with_box_id(box_id)
|
32
|
+
data_inputs.add(data_input)
|
33
|
+
assert_equal(1, data_inputs.len)
|
34
|
+
# no eq method for DataInput
|
35
|
+
assert_equal(box_id, data_inputs.get(0).get_box_id)
|
36
|
+
assert_equal(nil, data_inputs.get(1))
|
37
|
+
end
|
38
|
+
end
|
@@ -0,0 +1,76 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
|
5
|
+
require_relative '../../lib/sigma.rb'
|
6
|
+
require_relative '../test_utils.rb'
|
7
|
+
|
8
|
+
class Sigma::ErgoBoxCandidateBuilder::Test < Test::Unit::TestCase
|
9
|
+
def test_create
|
10
|
+
amount = 12345678
|
11
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
12
|
+
base_16 = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
|
13
|
+
tree = Sigma::ErgoTree.from_base16_encoded_string(base_16)
|
14
|
+
contract = Sigma::Contract.from_ergo_tree(tree)
|
15
|
+
ebcb = Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
|
16
|
+
end
|
17
|
+
|
18
|
+
def test_box_value
|
19
|
+
amount = 43000000
|
20
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
21
|
+
p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
|
22
|
+
p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
|
23
|
+
contract = Sigma::Contract.pay_to_address(p2pk_addr)
|
24
|
+
ebcb = assert_nothing_raised do
|
25
|
+
Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
|
26
|
+
end
|
27
|
+
|
28
|
+
min_per_byte = 1000000
|
29
|
+
ebcb.set_min_box_value_per_byte(min_per_byte)
|
30
|
+
assert_equal(min_per_byte, ebcb.get_min_box_value_per_byte)
|
31
|
+
assert_nothing_raised do
|
32
|
+
ebcb.calc_box_size_bytes
|
33
|
+
end
|
34
|
+
|
35
|
+
new_amount = 123456789
|
36
|
+
new_box_value = Sigma::BoxValue.from_i64(new_amount)
|
37
|
+
ebcb.set_value(new_box_value)
|
38
|
+
assert_equal(new_box_value, ebcb.get_value)
|
39
|
+
end
|
40
|
+
|
41
|
+
def test_register_value
|
42
|
+
amount = 43000000
|
43
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
44
|
+
p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
|
45
|
+
p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
|
46
|
+
contract = Sigma::Contract.pay_to_address(p2pk_addr)
|
47
|
+
ebcb = assert_nothing_raised do
|
48
|
+
Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
|
49
|
+
end
|
50
|
+
constant_val = 1
|
51
|
+
constant = Sigma::Constant.with_i32(constant_val)
|
52
|
+
ebcb.set_register_value(Sigma::REGISTER_ID_ENUM[:r4], constant)
|
53
|
+
assert_equal(constant, ebcb.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
|
54
|
+
box = ebcb.build
|
55
|
+
assert_equal(constant, box.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
|
56
|
+
end
|
57
|
+
|
58
|
+
def test_delete_register
|
59
|
+
amount = 43000000
|
60
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
61
|
+
p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
|
62
|
+
p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
|
63
|
+
contract = Sigma::Contract.pay_to_address(p2pk_addr)
|
64
|
+
ebcb = assert_nothing_raised do
|
65
|
+
Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
|
66
|
+
end
|
67
|
+
constant_val = 1
|
68
|
+
constant = Sigma::Constant.with_i32(constant_val)
|
69
|
+
ebcb.set_register_value(Sigma::REGISTER_ID_ENUM[:r4], constant)
|
70
|
+
assert_equal(constant, ebcb.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
|
71
|
+
ebcb = ebcb.delete_register_value(Sigma::REGISTER_ID_ENUM[:r4])
|
72
|
+
assert_equal(nil, ebcb.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
|
73
|
+
box = ebcb.build
|
74
|
+
assert_equal(nil, box.get_register_value(Sigma::REGISTER_ID_ENUM[:r4]))
|
75
|
+
end
|
76
|
+
end
|
@@ -0,0 +1,219 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
require 'json'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
class Sigma::ErgoBox::Test < Test::Unit::TestCase
|
10
|
+
def test_box_id
|
11
|
+
str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
12
|
+
box_id = Sigma::BoxId.with_string(str)
|
13
|
+
new_str = box_id.to_s
|
14
|
+
assert_equal(str, new_str)
|
15
|
+
new_bytes = box_id.to_bytes
|
16
|
+
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]
|
17
|
+
assert_equal(expected_bytes, new_bytes)
|
18
|
+
end
|
19
|
+
|
20
|
+
def test_box_value
|
21
|
+
amount = 12345678
|
22
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
23
|
+
assert_equal(box_value.to_i64, amount)
|
24
|
+
end
|
25
|
+
|
26
|
+
def test_box_value_units_per_ergo
|
27
|
+
units_per_ergo = Sigma::BoxValue.units_per_ergo
|
28
|
+
expected_units_per_ergo = 1000000000
|
29
|
+
assert_equal(expected_units_per_ergo, units_per_ergo)
|
30
|
+
end
|
31
|
+
|
32
|
+
def test_box_value_sum_of
|
33
|
+
amount_one = 12345678
|
34
|
+
amount_two = 12345679
|
35
|
+
sum = amount_one + amount_two
|
36
|
+
bv_one = Sigma::BoxValue.from_i64(amount_one)
|
37
|
+
bv_two = Sigma::BoxValue.from_i64(amount_two)
|
38
|
+
bv_three = Sigma::BoxValue.sum_of(bv_one, bv_two)
|
39
|
+
assert_equal(bv_three.to_i64, sum)
|
40
|
+
end
|
41
|
+
|
42
|
+
def test_box_value_safe_user_min
|
43
|
+
bv = Sigma::BoxValue.safe_user_min
|
44
|
+
expected_safe_user_min = 1000000
|
45
|
+
assert_equal(expected_safe_user_min, bv.to_i64)
|
46
|
+
end
|
47
|
+
|
48
|
+
def test_ergo_box_initializer
|
49
|
+
box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
50
|
+
box_value_int = 67500000000
|
51
|
+
ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
|
52
|
+
tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
|
53
|
+
creation_height = 284761
|
54
|
+
index = 1
|
55
|
+
|
56
|
+
box_id = Sigma::BoxId.with_string(box_id_str)
|
57
|
+
box_value = Sigma::BoxValue.from_i64(box_value_int)
|
58
|
+
ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
|
59
|
+
contract = Sigma::Contract.from_ergo_tree(ergo_tree)
|
60
|
+
tx_id = Sigma::TxId.with_string(tx_id_str)
|
61
|
+
tokens = Sigma::Tokens.create
|
62
|
+
ergo_box = Sigma::ErgoBox.create(box_value: box_value, creation_height: creation_height,
|
63
|
+
contract: contract, tx_id: tx_id, index: index, tokens: tokens)
|
64
|
+
|
65
|
+
assert_equal(creation_height, ergo_box.get_creation_height)
|
66
|
+
assert_equal(box_id, ergo_box.get_box_id)
|
67
|
+
assert_equal(box_value, ergo_box.get_box_value)
|
68
|
+
assert_equal(ergo_tree, ergo_box.get_ergo_tree)
|
69
|
+
end
|
70
|
+
|
71
|
+
def test_ergo_box_json
|
72
|
+
box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
73
|
+
box_value_int = 67500000000
|
74
|
+
ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
|
75
|
+
tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
|
76
|
+
creation_height = 284761
|
77
|
+
index = 1
|
78
|
+
|
79
|
+
box_id = Sigma::BoxId.with_string(box_id_str)
|
80
|
+
box_value = Sigma::BoxValue.from_i64(box_value_int)
|
81
|
+
ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
|
82
|
+
|
83
|
+
payload = {
|
84
|
+
'boxId' => box_id_str,
|
85
|
+
'value' => box_value_int,
|
86
|
+
'ergoTree' => ergo_tree_encoded_str,
|
87
|
+
'assets' => [],
|
88
|
+
'creationHeight' => creation_height,
|
89
|
+
'additionalRegisters' => {},
|
90
|
+
'transactionId' => tx_id_str,
|
91
|
+
'index' => index
|
92
|
+
}
|
93
|
+
# EIP-12 Value can be a number or a string, in this case it is a string
|
94
|
+
payload_eip12 = payload.merge({'value' => box_value_int.to_s})
|
95
|
+
|
96
|
+
json_str = payload.to_json
|
97
|
+
|
98
|
+
ergo_box = Sigma::ErgoBox.with_json(json_str)
|
99
|
+
|
100
|
+
assert_equal(creation_height, ergo_box.get_creation_height)
|
101
|
+
assert_equal(box_id, ergo_box.get_box_id)
|
102
|
+
assert_equal(box_value, ergo_box.get_box_value)
|
103
|
+
assert_equal(ergo_tree, ergo_box.get_ergo_tree)
|
104
|
+
assert_equal(payload, JSON.parse(ergo_box.to_json))
|
105
|
+
assert_equal(payload_eip12, JSON.parse(ergo_box.to_json_eip12))
|
106
|
+
end
|
107
|
+
|
108
|
+
def test_ergo_boxes
|
109
|
+
box_id_str = "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"
|
110
|
+
box_value_int = 67500000000
|
111
|
+
ergo_tree_encoded_str = "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301"
|
112
|
+
tx_id_str = "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9"
|
113
|
+
creation_height = 284761
|
114
|
+
index = 1
|
115
|
+
|
116
|
+
box_id = Sigma::BoxId.with_string(box_id_str)
|
117
|
+
box_value = Sigma::BoxValue.from_i64(box_value_int)
|
118
|
+
ergo_tree = Sigma::ErgoTree.from_base16_encoded_string(ergo_tree_encoded_str)
|
119
|
+
contract = Sigma::Contract.from_ergo_tree(ergo_tree)
|
120
|
+
tx_id = Sigma::TxId.with_string(tx_id_str)
|
121
|
+
tokens = Sigma::Tokens.create
|
122
|
+
ergo_box = Sigma::ErgoBox.create(box_value: box_value, creation_height: creation_height,
|
123
|
+
contract: contract, tx_id: tx_id, index: index, tokens: tokens)
|
124
|
+
|
125
|
+
ergo_boxes = Sigma::ErgoBoxes.create
|
126
|
+
assert_equal(0, ergo_boxes.len)
|
127
|
+
|
128
|
+
ergo_boxes.add(ergo_box)
|
129
|
+
assert_equal(1, ergo_boxes.len)
|
130
|
+
|
131
|
+
retrieved_box = ergo_boxes.get(0)
|
132
|
+
assert_equal(ergo_box, retrieved_box)
|
133
|
+
|
134
|
+
nil_retrieved_box = ergo_boxes.get(1)
|
135
|
+
assert_equal(nil, nil_retrieved_box)
|
136
|
+
|
137
|
+
boxes_in_json = [ergo_box.to_json, retrieved_box.to_json]
|
138
|
+
ergo_boxes_from_json = Sigma::ErgoBoxes.from_json(boxes_in_json)
|
139
|
+
assert_equal(2, ergo_boxes_from_json.len)
|
140
|
+
assert_equal(ergo_box, ergo_boxes_from_json.get(0))
|
141
|
+
end
|
142
|
+
|
143
|
+
def test_ergo_box_candidates
|
144
|
+
# create
|
145
|
+
ebcs = assert_nothing_raised do
|
146
|
+
Sigma::ErgoBoxCandidates.create
|
147
|
+
end
|
148
|
+
|
149
|
+
# len
|
150
|
+
assert_equal(0, ebcs.len)
|
151
|
+
|
152
|
+
# get
|
153
|
+
assert_equal(nil, ebcs.get(0))
|
154
|
+
assert_equal(nil, ebcs.get(1))
|
155
|
+
|
156
|
+
# add
|
157
|
+
amount = 43000000
|
158
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
159
|
+
p2pk_addr_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
|
160
|
+
p2pk_addr = Sigma::Address.with_testnet_address(p2pk_addr_str)
|
161
|
+
contract = Sigma::Contract.pay_to_address(p2pk_addr)
|
162
|
+
ebcb = Sigma::ErgoBoxCandidateBuilder.create(box_value: box_value, contract: contract, creation_height: 0)
|
163
|
+
cbox = ebcb.build
|
164
|
+
ebcs.add(cbox)
|
165
|
+
assert_equal(1, ebcs.len)
|
166
|
+
assert_equal(cbox, ebcs.get(0))
|
167
|
+
assert_equal(nil, ebcs.get(1))
|
168
|
+
end
|
169
|
+
|
170
|
+
def test_ergo_box_assets_data
|
171
|
+
# create
|
172
|
+
amount = 12345678
|
173
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
174
|
+
tokens = Sigma::Tokens.create
|
175
|
+
str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
|
176
|
+
token_id = Sigma::TokenId.from_base16_encoded_string(str)
|
177
|
+
amount = 12345678
|
178
|
+
token_amount = Sigma::TokenAmount.with_i64(amount)
|
179
|
+
token = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
|
180
|
+
tokens.add(token)
|
181
|
+
ergo_box_assets_data = Sigma::ErgoBoxAssetsData.create(box_value: box_value, tokens: tokens)
|
182
|
+
# get_box_value
|
183
|
+
assert_equal(box_value, ergo_box_assets_data.get_box_value)
|
184
|
+
# get_tokens
|
185
|
+
box_tokens = ergo_box_assets_data.get_box_tokens
|
186
|
+
assert_equal(tokens.len, box_tokens.len)
|
187
|
+
assert_equal(tokens.get(0), box_tokens.get(0))
|
188
|
+
assert_equal(tokens.get(1), box_tokens.get(1))
|
189
|
+
end
|
190
|
+
|
191
|
+
def test_ergo_box_assets_data_list
|
192
|
+
# create
|
193
|
+
ebs = assert_nothing_raised do
|
194
|
+
Sigma::ErgoBoxAssetsDataList.create
|
195
|
+
end
|
196
|
+
|
197
|
+
# len
|
198
|
+
assert_equal(0, ebs.len)
|
199
|
+
|
200
|
+
# get
|
201
|
+
assert_equal(nil, ebs.get(0))
|
202
|
+
assert_equal(nil, ebs.get(1))
|
203
|
+
|
204
|
+
# add
|
205
|
+
amount = 12345678
|
206
|
+
box_value = Sigma::BoxValue.from_i64(amount)
|
207
|
+
tokens = Sigma::Tokens.create
|
208
|
+
str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
|
209
|
+
token_id = Sigma::TokenId.from_base16_encoded_string(str)
|
210
|
+
amount = 12345678
|
211
|
+
token_amount = Sigma::TokenAmount.with_i64(amount)
|
212
|
+
token = Sigma::Token.create(token_id: token_id, token_amount: token_amount)
|
213
|
+
tokens.add(token)
|
214
|
+
ergo_box_assets_data = Sigma::ErgoBoxAssetsData.create(box_value: box_value, tokens: tokens)
|
215
|
+
ebs.add(ergo_box_assets_data)
|
216
|
+
assert_equal(1, ebs.len)
|
217
|
+
assert_equal(ergo_box_assets_data, ebs.get(0))
|
218
|
+
end
|
219
|
+
end
|
@@ -0,0 +1,26 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'bundler/setup'
|
3
|
+
require 'test/unit'
|
4
|
+
require 'json'
|
5
|
+
|
6
|
+
require_relative '../../lib/sigma.rb'
|
7
|
+
require_relative '../test_utils.rb'
|
8
|
+
|
9
|
+
include Sigma
|
10
|
+
|
11
|
+
class ErgoStateContext::Test < Test::Unit::TestCase
|
12
|
+
def test_ergo_state_context
|
13
|
+
block_header = BlockHeader.with_json(TestSeeds.block_header_json)
|
14
|
+
pre_header = PreHeader.with_block_header(block_header)
|
15
|
+
block_headers = TestSeeds.block_headers_from_json
|
16
|
+
assert_nothing_raised do
|
17
|
+
ctx = ErgoStateContext.create(pre_header: pre_header, headers: block_headers)
|
18
|
+
end
|
19
|
+
# invalid # of headers
|
20
|
+
invalid_headers_json = Array.new(8) { TestSeeds.block_header_json }
|
21
|
+
invalid_block_headers = BlockHeaders.from_json(invalid_headers_json)
|
22
|
+
assert_raises do
|
23
|
+
ctx = ErgoStateContext.create(pre_header: pre_header, headers: invalid_block_headers)
|
24
|
+
end
|
25
|
+
end
|
26
|
+
end
|