def test_transaction_v3_invalid_nid(self):
MockBlockchain = namedtuple("MockBlockchain",
"find_nid find_tx_by_key")
nids = list(range(0, 1000))
random.shuffle(nids)
tb = TransactionBuilder.new("0x3", None, self.tx_versioner)
tb.step_limit = 1000000
tb.value = 100000
tb.signer = self.signer
tb.to_address = ExternalAddress(os.urandom(20))
tb.nid = nids[0]
tb.nonce = random.randint(0, 100000)
tb.data = "test"
tb.data_type = "message"
tx = tb.build()
expected_nid = nids[1]
mock_blockchain = MockBlockchain(find_nid=lambda: hex(expected_nid),
find_tx_by_key=lambda _: False)
tv = TransactionVerifier.new(tx.version, tx.type(), self.tx_versioner)
self.assertRaises(TransactionInvalidNidError,
lambda: tv.verify(tx, mock_blockchain))
self.assertRaises(TransactionInvalidNidError,
lambda: tv.pre_verify(tx, nid=expected_nid))
def test_prep_changed_by_penalty_if_exists_next_reps_hash_and_next_leader(self, header_factory):
header = header_factory(next_leader=ExternalAddress(os.urandom(ExternalAddress.size)),
reps_hash=Hash32(os.urandom(Hash32.size)),
next_reps_hash=Hash32(os.urandom(Hash32.size)))
assert header.prep_changed
assert header.prep_changed_reason == NextRepsChangeReason.TermEnd
def add_attrs_to_v3_builder(tx_builder):
# Attributes that must be assigned
tx_builder.to_address = ExternalAddress(os.urandom(ExternalAddress.size))
tx_builder.value: int = 10000
tx_builder.step_limit: int = 10000
tx_builder.nid: int = 3
tx_builder.nonce: int = 10000
return tx_builder
def test_from_address_returns_its_addr_if_exists(
self, tx_builder_factory: TxBuilderFactory, tx_version):
tx_builder = tx_builder_factory(tx_version)
expected_addr = ExternalAddress(os.urandom(ExternalAddress.size))
tx_builder.from_address = expected_addr
built_addr = tx_builder.build_from_address()
assert expected_addr == built_addr
def test_transaction_v2(self):
tb = TransactionBuilder.new("0x2", None, self.tx_versioner)
tb.fee = 1000000
tb.value = 100000
tb.signer = self.signer
tb.to_address = ExternalAddress(os.urandom(20))
tb.nonce = random.randint(0, 100000)
tx = tb.build()
tv = TransactionVerifier.new("0x2", tx.type(), self.tx_versioner)
tv.verify(tx)
ts = TransactionSerializer.new("0x2", tx.type(), self.tx_versioner)
tx_raw_data = ts.to_raw_data(tx)
self.assertEqual(ts.from_(tx_raw_data), tx)
def test_transaction_v2_duplicate_hash(self):
MockBlockchain = namedtuple("MockBlockchain", "find_nid find_tx_by_key")
tb = TransactionBuilder.new("0x2", None, self.tx_versioner)
tb.fee = 1000000
tb.value = 100000
tb.signer = self.signer
tb.to_address = ExternalAddress(os.urandom(20))
tb.nonce = random.randint(0, 100000)
tx = tb.build()
mock_blockchain = MockBlockchain(find_nid=lambda: hex(3),
find_tx_by_key=lambda _: True)
tv = TransactionVerifier.new(tx.version, tx.type(), self.tx_versioner)
self.assertRaises(TransactionDuplicatedHashError, lambda: tv.verify(tx, mock_blockchain))
def test_transaction_genesis(self):
tb = TransactionBuilder.new("genesis", None, self.tx_versioner)
tb.accounts = [{
"name": "test0",
"address": ExternalAddress(os.urandom(20)).hex_hx(),
"balance": "0x12221231"
}]
tb.message = "Icon Loop"
tx = tb.build(False)
tv = TransactionVerifier.new("genesis", tx.type(), self.tx_versioner)
tv.verify(tx)
ts = TransactionSerializer.new("genesis", tx.type(), self.tx_versioner)
tx_raw_data = ts.to_raw_data(tx)
self.assertEqual(ts.from_(tx_raw_data), tx)
def test_transaction_v2_unsigned(self):
signer = Signer.new()
tb = TransactionBuilder.new("0x2", None, self.tx_versioner)
tb.fee = 1000000
tb.value = 100000
tb.from_address = ExternalAddress.fromhex_address(signer.address)
tb.to_address = ExternalAddress(os.urandom(20))
tb.nonce = random.randint(0, 100000)
tx = tb.build(is_signing=False)
tv = TransactionVerifier.new("0x2", tx.type(), self.tx_versioner)
self.assertRaises(TransactionInvalidSignatureError, lambda: tv.verify(tx))
self.assertRaises(TransactionInvalidSignatureError, lambda: tv.pre_verify(tx))
tb.signer = signer
signed_tx = tb.sign_transaction(tx)
tv.verify(signed_tx)
tv.pre_verify(signed_tx)
def test_transaction_v3_unsigned(self):
signer = Signer.new()
tb = TransactionBuilder.new("0x3", None, self.tx_versioner)
tb.step_limit = 1000000
tb.value = 100000
tb.from_address = ExternalAddress.fromhex_address(signer.address)
tb.to_address = ExternalAddress(os.urandom(20))
tb.nid = 3
tb.nonce = random.randint(0, 100000)
tb.data = "test"
tb.data_type = "message"
tx = tb.build(False)
tv = TransactionVerifier.new("0x3", tx.type(), self.tx_versioner)
self.assertRaises(TransactionInvalidSignatureError, lambda: tv.verify(tx))
self.assertRaises(TransactionInvalidSignatureError, lambda: tv.pre_verify(tx, nid=3))
tb.signer = signer
signed_tx = tb.sign_transaction(tx)
tv.verify(signed_tx)
tv.pre_verify(signed_tx, nid=3)
def test_url(self, rest_client: RestClient, rest_method: RestMethod):
url = rest_client.create_url(rest_client._target, rest_method)
assert url == request_urls[rest_method]
@pytest.mark.parametrize("rest_method", RestMethod)
def test_params(self, rest_client: RestClient, rest_method: RestMethod):
params = rest_client.create_params(rest_method,
request_params[rest_method])
params.pop('id', None)
assert params == request_params_results[rest_method]
tv = TransactionVersioner()
tb = TransactionBuilder.new(version="0x2", type_=None, versioner=tv)
tb.signer = Signer.new()
tb.to_address = ExternalAddress(os.urandom(20))
tb.fee = 10
tb.value = 1000
tb.nonce = 123
request_tx2 = tb.build()
request_tx2_param = TransactionSerializer.new("0x2", None,
tv).to_raw_data(request_tx2)
request_tx2_param["from_"] = request_tx2_param.pop("from")
tb = TransactionBuilder.new(version="0x3", type_=None, versioner=tv)
tb.step_limit = 1000000
tb.value = 100000
tb.signer = Signer.new()
tb.to_address = ExternalAddress(os.urandom(20))
tb.nid = 3
tb.nonce = 1
def test_prep_is_not_changed_if_next_reps_hash_is_empty(self, header_factory):
header = header_factory(next_leader=ExternalAddress(os.urandom(ExternalAddress.size)),
reps_hash=Hash32(os.urandom(Hash32.size)),
next_reps_hash=Hash32.empty())
assert not header.prep_changed