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())