def test_xfer_handler_update_state(xfer_handler_1_0_0, xfer_txn,
payment_address, payment_address_2):
xfer_handler_1_0_0.update_state(xfer_txn, None, None)
token_state = xfer_handler_1_0_0.state
utxo_cache = xfer_handler_1_0_0.utxo_cache
assert int(
token_state.get((libsovtoken_address_to_address(payment_address_2) +
":2").encode(),
isCommitted=False)) == 10
assert utxo_cache.get(
libsovtoken_address_to_address(payment_address_2)) == '2:10'
assert token_state.get(
(libsovtoken_address_to_address(payment_address) + ":1").encode(),
isCommitted=False) == b''
def test_get_utxo_request_no_utxos(get_utxo_request, get_utxo_handler,
payment_address_2, add_utxo):
get_utxo_request.operation[ADDRESS] = libsovtoken_address_to_address(
payment_address_2)
result = get_utxo_handler.get_result(get_utxo_request)
assert result[STATE_PROOF]
assert len(result[OUTPUTS]) == 0
def insert_over_thousand_utxos(db_manager, payment_address):
token_state = db_manager.get_state(TOKEN_LEDGER_ID)
for i in range(1200):
token_state.set(
TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(payment_address), i),
str(i).encode())
def test_get_more_then_thousand_utxos(helpers, addresses,
nodeSetWithIntegratedTokenPlugin):
"""
test if we send more have more than a 1000 UTXO's we still receive a response.
"""
_, address_2 = addresses
states = [
n.db_manager.get_state(TOKEN_LEDGER_ID)
for n in nodeSetWithIntegratedTokenPlugin
]
utxos = []
for i in range(UTXO_LIMIT + 200):
amount = randint(1, 5)
key = TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(address_2), i + 5)
utxos.append((key, amount))
for state in states:
state.set(key, str(amount).encode())
request = helpers.request.get_utxo(address_2)
responses = helpers.sdk.send_and_check_request_objects([request])
for response in responses:
result = response[1]['result']
assert len(result[OUTPUTS]) == UTXO_LIMIT
for output in result[OUTPUTS]:
assert (TokenStaticHelper.create_state_key(output[ADDRESS],
output[SEQNO]),
output[AMOUNT]) in utxos
assert result.get(NEXT_SEQNO, None)
def insert_utxos_after_gap(db_manager, payment_address):
token_state = db_manager.get_state(TOKEN_LEDGER_ID)
for i in range(1300, 2400):
token_state.set(
TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(payment_address), i),
str(i).encode())
return 1300
def test_get_utxo_request_has_utxos(get_utxo_request, get_utxo_handler,
payment_address, add_utxo):
result = get_utxo_handler.get_result(get_utxo_request)
assert result[STATE_PROOF]
assert result[OUTPUTS]
assert len(result[OUTPUTS]) == 1
assert result[OUTPUTS][0].address == libsovtoken_address_to_address(
payment_address)
assert result[OUTPUTS][0].amount == 3
assert result[OUTPUTS][0].seqNo == 1
def test_xfer_handler_dynamic_validation_utxo_not_exists(
xfer_handler, invalid_amount_xfer_request_utxo_does_not_exist,
payment_address):
with pytest.raises(
InvalidFundsError,
message=
"InvalidFundsError(\"seq_nos {{2}} are not found in list of seq_nos_amounts for "
"address {} -- current list: ['1', '10']\",)".format(
libsovtoken_address_to_address(payment_address))):
xfer_handler.dynamic_validation(
invalid_amount_xfer_request_utxo_does_not_exist, 0)
def test_get_utxo_request_has_utxos(get_utxo_request, get_utxo_handler,
payment_address,
insert_over_thousand_utxos):
result = get_utxo_handler.get_result(get_utxo_request)
assert result[STATE_PROOF]
assert result[OUTPUTS]
assert len(result[OUTPUTS]) == UTXO_LIMIT
for i in range(UTXO_LIMIT):
assert result[OUTPUTS][i].address == libsovtoken_address_to_address(
payment_address)
assert result[OUTPUTS][i].seqNo == i
assert result[OUTPUTS][i].amount == i
def test_token_req_handler_update_state_XFER_PUBLIC_success(
helpers, addresses, xfer_handler_a):
[address1, address2] = addresses
seq_no = 1
inputs = [{"source": utxo_from_addr_and_seq_no(address1, seq_no)}]
outputs = [{"address": address2, "amount": 40}]
request = helpers.request.transfer(inputs, outputs)
txn = reqToTxn(request)
append_txn_metadata(txn, seq_no=seq_no)
xfer_handler_a.dynamic_validation(request)
xfer_handler_a.update_state(txn, None, request)
state_key = TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(address1), seq_no)
utxo_cache = xfer_handler_a.database_manager.get_store(UTXO_CACHE_LABEL)
key = utxo_cache._create_key(
Output(libsovtoken_address_to_address(address1), seq_no, 60))
assert utxo_cache._store._has_key(key)
try:
xfer_handler_a.state.get(state_key, False)
except Exception:
pytest.fail("This state key isn't in the state")
def test_get_utxo_request_has_utxos_with_from(get_utxo_request,
get_utxo_handler,
payment_address,
insert_over_thousand_utxos):
get_utxo_request.operation[FROM_SEQNO] = FROM_SHIFT
result = get_utxo_handler.get_result(get_utxo_request)
assert result[STATE_PROOF]
assert result[OUTPUTS]
assert len(result[OUTPUTS]) == UTXO_LIMIT
for i in range(FROM_SHIFT, FROM_SHIFT + UTXO_LIMIT):
assert result[OUTPUTS][
i - FROM_SHIFT].address == libsovtoken_address_to_address(
payment_address)
assert result[OUTPUTS][i - FROM_SHIFT].seqNo == i
assert result[OUTPUTS][i - FROM_SHIFT].amount == i
def test_get_utxo_request_has_utxos_with_from_between_the_numbers(
get_utxo_request, get_utxo_handler, payment_address,
insert_over_thousand_utxos, insert_utxos_after_gap):
gap = insert_utxos_after_gap
# there is a gap between 1200 and 1300 seqno's for this payment address
get_utxo_request.operation[FROM_SEQNO] = gap - 50
result = get_utxo_handler.get_result(get_utxo_request)
# 2300 utxos is too many for state proof, not checking it
assert result[OUTPUTS]
assert len(result[OUTPUTS]) == UTXO_LIMIT
for i in range(gap, gap + UTXO_LIMIT):
assert result[OUTPUTS][
i - gap].address == libsovtoken_address_to_address(payment_address)
assert result[OUTPUTS][i - gap].seqNo == i
assert result[OUTPUTS][i - gap].amount == i
def make_tokens(helpers, nodeSetWithIntegratedTokenPlugin, addresses):
address, address_2 = addresses
states = [n.db_manager.get_state(TOKEN_LEDGER_ID) for n in nodeSetWithIntegratedTokenPlugin]
utxos = []
for i in range(UTXO_LIMIT+200):
amount = randint(1, 5)
seq_no = i+5
key = TokenStaticHelper.create_state_key(libsovtoken_address_to_address(address), seq_no)
utxos.append((key, amount, seq_no))
for state in states:
state.set(key, str(amount).encode())
total = 1000
outputs = [{"address": address_2, "amount": total}]
helpers.general.do_mint(outputs)
def test_token_req_handler_get_result_success(helpers, addresses,
get_utxo_handler):
address1 = addresses[0]
request = helpers.request.get_utxo(address1)
results = get_utxo_handler.get_result(request)
state_proof = results.pop(STATE_PROOF)
address1 = libsovtoken_address_to_address(address1)
assert state_proof
assert results == {
ADDRESS: address1,
TXN_TYPE: GET_UTXO,
OUTPUTS: [Output(address=address1, seq_no=1, value=40)],
IDENTIFIER:
base58.b58encode(base58.b58decode_check(address1)).decode(),
TXN_PAYLOAD_METADATA_REQ_ID: request.reqId
}
def test_state_after_xfer(helpers, initial_mint, addresses,
nodeSetWithIntegratedTokenPlugin):
mint_seq_no = get_seq_no(initial_mint)
[address1, address2, *_] = addresses
inputs = helpers.general.get_utxo_addresses([address1])
inputs = [utxo for utxos in inputs for utxo in utxos]
outputs = [{"address": address2, "amount": 100}]
helpers.general.do_transfer(inputs, outputs)
key = TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(address1), mint_seq_no)
for n in nodeSetWithIntegratedTokenPlugin:
res = n.db_manager.get_state(TOKEN_LEDGER_ID).get(key)
assert not res
def mint_tokens_to_client(helpers, client_address):
outputs = [{ADDRESS: client_address, AMOUNT: MINT_TOKEN_AMOUNT}]
result = helpers.general.do_mint(outputs)
assert get_payload_data(result)[OUTPUTS][0] == {
ADDRESS: libsovtoken_address_to_address(client_address),
AMOUNT: MINT_TOKEN_AMOUNT
}
client_utxos = helpers.general.get_utxo_addresses([client_address])[0]
assert client_utxos[0][PAYMENT_ADDRESS] == client_address
assert client_utxos[0][AMOUNT] == MINT_TOKEN_AMOUNT
formatted_utxos = demo_logger.format_json(client_utxos)
demo_logger.log_header(step4_info)
demo_logger.log_blue(
"Minted {} tokens to Client".format(MINT_TOKEN_AMOUNT))
demo_logger.log_blue(
"Client address {} contained utxo:".format(client_address))
demo_logger.log_yellow(formatted_utxos)
return client_utxos
def test_get_more_then_thousand_utxos_with_from(
helpers, addresses, nodeSetWithIntegratedTokenPlugin):
"""
test if we send more have more than a thousand of UTXO's we will still receive a response.
"""
address_1, address_2 = addresses
states = [
n.db_manager.get_state(TOKEN_LEDGER_ID)
for n in nodeSetWithIntegratedTokenPlugin
]
utxos = []
for i in range(UTXO_LIMIT + 200):
amount = randint(1, 5)
seq_no = i + 5
key = TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(address_2), seq_no)
utxos.append((key, amount, seq_no))
for state in states:
state.set(key, str(amount).encode())
# NB: this transaction is needed just to update bls_store with new root hash
total = 1000
outputs = [{"address": address_1, "amount": total}]
mint_result = helpers.general.do_mint(outputs)
shift = 50
request = helpers.request.get_utxo(address_2, utxos[shift][2])
responses = helpers.sdk.send_and_check_request_objects([request])
utxos = utxos[shift:shift + UTXO_LIMIT]
for response in responses:
result = response[1]['result']
assert result[STATE_PROOF]
assert len(result[OUTPUTS]) == UTXO_LIMIT
for output in result[OUTPUTS]:
assert (TokenStaticHelper.create_state_key(output[ADDRESS],
output[SEQNO]),
output[AMOUNT], output[SEQNO]) in utxos
assert result.get(NEXT_SEQNO)
def check_fee_request_on_ledger(helpers, client_address, nym_result):
transactions = helpers.node.get_last_ledger_transaction_on_nodes(
TOKEN_LEDGER_ID)
for fee_txn in transactions:
fee_data = get_payload_data(fee_txn)
assert fee_data[OUTPUTS] == [{
ADDRESS:
libsovtoken_address_to_address(client_address),
AMOUNT:
MINT_TOKEN_AMOUNT - TXN_FEES[NYM_FEES_ALIAS]
}]
assert fee_data[FEES] == TXN_FEES[NYM_FEES_ALIAS]
assert get_seq_no(fee_txn) == 2
nym_seq_no = get_seq_no(nym_result)
helpers.node.assert_deducted_fees(NYM, nym_seq_no,
TXN_FEES[NYM_FEES_ALIAS])
formatted_txn = demo_logger.format_json(transactions[0])
demo_logger.log_header(step7_info)
demo_logger.log_blue("Fee transaction found on Payment ledger:")
demo_logger.log_yellow(formatted_txn)
def mint_tokens(payment_address, utxo_cache, db_manager):
addr = libsovtoken_address_to_address(payment_address)
utxo_cache.set(addr, "1:10".encode())
db_manager.get_state(TOKEN_LEDGER_ID).set((addr + ":1").encode(), "10".encode())
def add_utxo(payment_address, get_utxo_handler):
get_utxo_handler.state.set(
TokenStaticHelper.create_state_key(
libsovtoken_address_to_address(payment_address), 1), "3".encode())
