Exemplo n.º 1
0
def test_chain_set_fees_and_nym_batch_size_2(looper, helpers,
                                             nodeSetWithIntegratedTokenPlugin,
                                             sdk_pool_handle,
                                             sdk_wallet_trustee, mint_tokens,
                                             addresses, poolConfigWTFF):
    """
    Set FEES for NYM with cost 2

    Send any transaction to config ledger.

    Send NYM with fees 2 from A

    Set FEES for NYM with cost 3

    Send any transaction to config ledger.

    Send NYM with fees 3 from A

    Check that first NYM is not written and second NYM is.
    """
    A, B = addresses
    current_amount = get_amount_from_token_txn(mint_tokens)
    seq_no = get_seq_no(mint_tokens)

    # Set fees and some config txn
    fees_nym_2 = {NYM_FEES_ALIAS: 2}
    fees_2_resp = helpers.general.set_fees_without_waiting(fees_nym_2)
    sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee,
                         poolConfigWTFF)
    sdk_get_and_check_replies(looper, fees_2_resp)

    # NYM with fees 2 from A
    _, _, b_2_nym = send_and_check_nym_with_fees(helpers, {'fees': fees_nym_2},
                                                 seq_no,
                                                 looper, [A],
                                                 current_amount,
                                                 check_reply=False)
    # Set fees for NYM to 3
    fees_nym_3 = {NYM_FEES_ALIAS: 3}
    fees_3_resp = helpers.general.set_fees_without_waiting(fees_nym_3)
    sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee,
                         poolConfigWTFF)
    sdk_get_and_check_replies(looper, fees_3_resp)

    # Send NYM with fees 3
    current_amount, seq_no, b_3_nym = send_and_check_nym_with_fees(
        helpers, {'fees': fees_nym_3},
        seq_no,
        looper, [A],
        current_amount,
        check_reply=False)

    with pytest.raises(RequestRejectedException):
        sdk_get_and_check_replies(looper, b_2_nym)
    sdk_get_and_check_replies(looper, b_3_nym)
    a_get = helpers.general.do_get_utxo(A)
    assert a_get[OUTPUTS][1][AMOUNT] == current_amount
    assert a_get[OUTPUTS][1][SEQNO] == seq_no

    ensure_all_nodes_have_same_data(looper, nodeSetWithIntegratedTokenPlugin)
Exemplo n.º 2
0
def test_only_trustee_send_pool_config_writes_true_force_false(
        nodeSet, looper, sdk_pool_handle, sdk_wallet_trustee, poolConfigWTFF):
    sdk_wallet_steward = sdk_add_new_nym(looper, sdk_pool_handle,
                                         sdk_wallet_trustee, 'tmpname',
                                         STEWARD_STRING)
    req = sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_steward,
                               poolConfigWTFF)
    sdk_get_bad_response(looper, [req], RequestRejectedException, 'cannot do')
Exemplo n.º 3
0
def test_only_trustee_send_pool_config_writes_false_force_true(
        nodeSet, looper, sdk_pool_handle, sdk_wallet_trustee, poolConfigWFFT):
    sdk_wallet_steward = sdk_add_new_nym(looper, sdk_pool_handle,
                                         sdk_wallet_trustee, 'tmpname',
                                         STEWARD_STRING)
    req = sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_steward,
                               poolConfigWFFT)
    sdk_get_bad_response(looper, [req], RequestNackedException,
                         "Not enough TRUSTEE signatures")
Exemplo n.º 4
0
def test_only_trustee_send_pool_config_writes_true_force_true(
        nodeSet, looper, sdk_pool_handle, sdk_wallet_trustee, poolConfigWTFT):
    sdk_wallet_steward = sdk_add_new_nym(looper, sdk_pool_handle,
                                         sdk_wallet_trustee, 'tmpname',
                                         STEWARD_STRING)
    req = sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_steward,
                               poolConfigWTFT)
    sdk_get_bad_response(looper, [req], RequestNackedException,
                         'role is not accepted')
def test_only_trustee_send_pool_config_writes_false_force_true(
        nodeSet, looper, sdk_pool_handle, sdk_wallet_trustee, poolConfigWFFT):
    sdk_wallet_steward = sdk_add_new_nym(looper, sdk_pool_handle,
                                         sdk_wallet_trustee, 'tmpname',
                                         STEWARD_STRING)
    req = sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_steward,
                               poolConfigWFFT)
    sdk_get_bad_response(looper, [req], RequestNackedException,
                         '{} can not do this action'.format(STEWARD_STRING))
Exemplo n.º 6
0
def test_send_pool_config_2_nodes_can_force_writes_false_force_true(
        nodeSet, looper, sdk_pool_handle, sdk_wallet_trustee, poolConfigWFFT):
    assert len(nodeSet) == 4

    node1 = nodeSet[2]
    node0 = nodeSet[3]

    check_pool_config_writable_set(nodeSet, True)

    disconnect_node_and_ensure_disconnected(
        looper, nodeSet, node0.name, stopNode=False)
    disconnect_node_and_ensure_disconnected(
        looper, nodeSet, node1.name, stopNode=False)

    sdk_pool_config_sent(looper, sdk_pool_handle,
                         sdk_wallet_trustee, poolConfigWFFT)

    looper.run(eventually(check_pool_config_writable_set,
                          nodeSet[0:2], False, retryWait=1, timeout=10))
Exemplo n.º 7
0
def test_chain_set_fees_and_xfer_batch_size_2(looper, helpers,
                                              nodeSetWithIntegratedTokenPlugin,
                                              sdk_pool_handle,
                                              sdk_wallet_trustee, mint_tokens,
                                              addresses, poolConfigWTFF):
    """
    Set FEES for XFER for 2

    Send any transaction to config ledger.

    Send XFER with fees 2 from A to B

    Set FEES for XFER for 3

    Send any transaction to config ledger.

    Send XFER with fees 3 from A to B

    Check that first XFER is not written and second XFER is.
    """
    A, B = addresses
    current_amount = get_amount_from_token_txn(mint_tokens)
    seq_no = get_seq_no(mint_tokens)
    transfer_summ = 20

    # Set fees and some config txn
    helpers.node.set_fees_directly({XFER_PUBLIC_FEES_ALIAS: 42})
    fees_xfer_2 = {XFER_PUBLIC_FEES_ALIAS: 2}
    fees_2_rsp = helpers.general.set_fees_without_waiting(fees_xfer_2)
    sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee,
                         poolConfigWTFF)
    sdk_get_and_check_replies(looper, fees_2_rsp)

    # XFER with fees 2 from A to B
    _, _, a_b_transfer_2 = send_and_check_transfer(helpers, [A, B],
                                                   fees_xfer_2,
                                                   looper,
                                                   current_amount,
                                                   seq_no,
                                                   transfer_summ=transfer_summ,
                                                   check_reply=False)
    # Set fees for XFER to 3
    fees_xfer_3 = {XFER_PUBLIC_FEES_ALIAS: 3}
    fees_3_rsp = helpers.general.set_fees_without_waiting(fees_xfer_3)
    sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee,
                         poolConfigWTFF)
    sdk_get_and_check_replies(looper, fees_3_rsp)

    # Send XFER with fees from A to B
    a_amount, seq_no, a_b_transfer_3 = send_and_check_transfer(
        helpers, [A, B],
        fees_xfer_3,
        looper,
        current_amount,
        seq_no,
        transfer_summ=transfer_summ,
        check_reply=False)
    for n in nodeSetWithIntegratedTokenPlugin:
        fee_rq = n.ledger_to_req_handler[CONFIG_LEDGER_ID]
        assert fee_rq.fees == fees_xfer_3

    with pytest.raises(RequestRejectedException):
        sdk_get_and_check_replies(looper, a_b_transfer_2)
    sdk_get_and_check_replies(looper, a_b_transfer_3)
    a_get = helpers.general.do_get_utxo(A)
    assert a_get[OUTPUTS][1][AMOUNT] == a_amount
    assert a_get[OUTPUTS][1][SEQNO] == seq_no

    b_get = helpers.general.do_get_utxo(B)
    assert b_get[OUTPUTS][0][AMOUNT] == transfer_summ
    assert b_get[OUTPUTS][0][SEQNO] == seq_no

    ensure_all_nodes_have_same_data(looper, nodeSetWithIntegratedTokenPlugin)