def test_revert_works_for_fees_before_catch_up_on_all_nodes(
looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle,
sdk_wallet_trustee, fees_set, address_main, mint_tokens):
node_set = [n.nodeIbStasher for n in nodeSetWithIntegratedTokenPlugin]
with delay_rules(node_set, cDelay()):
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, True, retryWait=0.2, timeout=15))
sdk_send_signed_requests(sdk_pool_handle,
[json.dumps(request.as_dict)])
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, False, retryWait=0.2, timeout=15))
for n in nodeSetWithIntegratedTokenPlugin:
n.start_catchup()
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(lambda: assertExp(n.mode == Mode.participating)))
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, True, retryWait=0.2, timeout=15))
ensure_all_nodes_have_same_data(looper, nodeSetWithIntegratedTokenPlugin)
def test_send_claim_def_with_fees(helpers,
looper,
nodeSetWithIntegratedTokenPlugin,
sdk_wallet_trustee,
sdk_pool_handle,
schema_json,
fees_set, address_main, mint_tokens):
req = helpers.request.claim_def(schema_json, sdk_wallet=sdk_wallet_trustee)
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
utxos = [{"source": utxo_from_addr_and_seq_no(address_main, init_seq_no),
AMOUNT: amount}]
req = Request(**json.loads(req))
req = add_fees_request_with_address(
helpers,
fees_set,
req,
address_main,
utxos=utxos
)
token_len = len(nodeSetWithIntegratedTokenPlugin[0].ledgers[-1])
write_rep = helpers.sdk.send_and_check_request_objects([req], wallet=sdk_wallet_trustee)
assert token_len == len(nodeSetWithIntegratedTokenPlugin[0].ledgers[-1]) - 1
assert get_last_token_txn(nodeSetWithIntegratedTokenPlugin)[1]['txn']['data']['fees'] == CLAIM_DEF_FEE
added_claim_def_id = write_rep[0][1]['result'][TXN_METADATA][TXN_METADATA_ID]
request = looper.loop.run_until_complete(build_get_cred_def_request(sdk_wallet_trustee[1], added_claim_def_id))
read_rep = sdk_get_and_check_replies(looper,
[sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
assert req.operation[DATA] == read_rep[0][1]['result'][DATA]
def test_send_nym_with_fees(helpers, looper, nodeSetWithIntegratedTokenPlugin,
sdk_wallet_trustee, sdk_wallet_steward,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
req = helpers.request.nym_new(sdk_wallet=sdk_wallet_trustee)
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
utxos = [{
"source": utxo_from_addr_and_seq_no(address_main, init_seq_no),
AMOUNT: amount
}]
req = Request(**json.loads(req))
req = add_fees_request_with_address(helpers,
fees_set,
req,
address_main,
utxos=utxos)
token_len = len(nodeSetWithIntegratedTokenPlugin[0].ledgers[-1])
helpers.sdk.send_and_check_request_objects([req],
wallet=sdk_wallet_trustee)
assert token_len == len(
nodeSetWithIntegratedTokenPlugin[0].ledgers[-1]) - 1
assert get_last_token_txn(
nodeSetWithIntegratedTokenPlugin)[1]['txn']['data']['fees'] == NYM_FEE
request = looper.loop.run_until_complete(
build_get_nym_request(sdk_wallet_trustee[1], req.operation['dest']))
read_rep = sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)
])
reply = json.loads(read_rep[0][1]['result'][DATA])
assert req.operation['dest'] == reply['dest']
assert req.operation['verkey'] == reply['verkey']
def add_new_node(helpers, looper, node_set, sdk_wallet, current_amount, seq_no,
fees_set, sdk_pool_handle, tdir, tconf, allPluginsPath,
address, do_post_node_creation, node_class):
new_did, verkey = helpers.wallet.create_did(sdk_wallet=sdk_wallet)
req = helpers.request.nym(sdk_wallet=sdk_wallet,
alias="new_steward",
role=STEWARD_STRING,
dest=new_did,
verkey=verkey)
utxos = [{ADDRESS: address, AMOUNT: current_amount, f.SEQ_NO.nm: seq_no}]
req = add_fees_request_with_address(helpers,
fees_set,
req,
address,
utxos=utxos)
current_amount, seq_no, _ = send_and_check_nym_with_fees(helpers,
fees_set,
seq_no,
looper,
addresses,
current_amount,
nym_with_fees=req)
new_steward_wallet_handle = sdk_wallet[0], new_did
new_node = sdk_add_new_node(looper,
sdk_pool_handle,
new_steward_wallet_handle,
'Epsilon',
tdir,
tconf,
allPluginsPath=allPluginsPath,
do_post_node_creation=do_post_node_creation,
nodeClass=node_class)
node_set.append(new_node)
looper.run(checkNodesConnected(node_set))
waitNodeDataEquality(looper, new_node, *node_set[:-1])
def test_create_did_without_endorser_payment(looper, nodeSetWithIntegratedTokenPlugin, nym_txn_data, sdk_pool_handle,
fees_set, address_main, mint_tokens, changed_auth_rule,
sdk_wallet_trustee, helpers):
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee)
wh, alias, sender_did, sender_verkey = nym_txn_data
req = looper.loop.run_until_complete(
build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE))
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
utxos = [{"source": utxo_from_addr_and_seq_no(address_main, init_seq_no),
AMOUNT: amount}]
req = Request(**json.loads(req))
req = add_fees_request_with_address(
helpers,
fees_set,
req,
address_main,
utxos=utxos
)
rep = helpers.sdk.send_and_check_request_objects([req], wallet=(wh, sender_did))
details = get_nym_details(nodeSetWithIntegratedTokenPlugin[0].states[1], sender_did, is_committed=True)
assert details[ROLE] == NEW_ROLE
assert details[VERKEY] == sender_verkey
def test_valid_fees_invalid_payload(helpers, fees_set, mint_tokens,
address_main, sdk_wallet_client):
"""
The fee part of the txn is valid but the payload fails dynamic validation
(unauthorised request)
"""
req = helpers.request.nym(sdk_wallet=sdk_wallet_client)
req = add_fees_request_with_address(helpers, fees_set, req, address_main)
with pytest.raises(RequestRejectedException):
helpers.sdk.send_and_check_request_objects([req], sdk_wallet_client)
def test_fees_extra_field(helpers, address_main, mint_tokens, fees_set):
"""
The fees section has an extra field.
"""
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
fees = request.fees
fees.append([])
request.fees = fees
with pytest.raises(RequestNackedException):
helpers.sdk.send_and_check_request_objects([request])
def req_with_fees(helpers, fees_set, address_main, fees):
request = helpers.request.nym()
utxos = [{
"source": utxo_from_addr_and_seq_no(address_main, 1),
AMOUNT: fees.get(NYM_FEES_ALIAS)
}]
return add_fees_request_with_address(
helpers,
fees_set,
request,
address_main,
utxos=utxos,
)
def test_valid_fees_invalid_payload_sig(helpers, fees_set, address_main,
mint_tokens):
"""
The fee part of the txn is valid but the payload has invalid signature
"""
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
sig = getattr(request, f.SIG.nm)
# Reverse the signature of NYM txn sender, making it invalid
sig = sig[::-1]
setattr(request, f.SIG.nm, sig)
with pytest.raises(RequestNackedException):
helpers.sdk.send_and_check_request_objects([request])
def test_fees_insufficient_sig(helpers, fees_set, address_main, mint_tokens):
"""
The fee amount is correct but signature over the fee is incorrect.
"""
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
fees = getattr(request, FEES)
# set only one signature instead of two
fees[2] = []
setattr(request, FEES, fees)
with pytest.raises(RequestNackedException):
helpers.sdk.send_and_check_request_objects([request])
def test_fees_incorrect_sig(helpers, fees_set, address_main, mint_tokens):
"""
The fee amount is correct but signature over the fee is incorrect.
"""
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
fees = getattr(request, FEES)
# reverse the signatures to make them incorrect
fees[2] = [sig[::-1] for sig in fees[2]]
setattr(request, FEES, fees)
with pytest.raises(RequestNackedException):
helpers.sdk.send_and_check_request_objects([request])
def test_revert_batches_with_fees_unset_fees_without_fee(
looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle,
sdk_wallet_trustee, sdk_wallet_steward, fees_set, address_main,
mint_tokens):
node_set = nodeSetWithIntegratedTokenPlugin
reverted_node = node_set[-1]
head_hash_before = get_head_hash_for_pool([reverted_node], TOKEN_LEDGER_ID)
uncommitted_size_before = get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID)
with delay_rules(reverted_node.nodeIbStasher, cDelay()):
request_check_health = helpers.request.nym()
request_check_health = add_fees_request_with_address(
helpers, fees_set, request_check_health, address_main)
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request_check_health)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
"""
We send only 1 txn with fees, and expects,
that we have only 1 uncommitted txn for token_ledger
"""
assert get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1
sdk_get_and_check_replies(looper, [r])
assert get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1
"""
Unset fees, for sending txn without fees
"""
helpers.node.reset_fees()
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward)
"""
We sent a NYM txn without fees and expects,
that count of uncommitted txns wasn`t changed
"""
assert get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1
"""
Initiate reverting procedure by calling start_catchup
"""
reverted_node.master_replica.revert_unordered_batches()
head_hash_after = get_head_hash_for_pool([reverted_node],
TOKEN_LEDGER_ID)
uncommitted_size_after = get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID)
assert head_hash_before == head_hash_after
assert uncommitted_size_before == uncommitted_size_after
def send_nym_with_fees(helpers,
address,
change_address,
fees_set,
adjust_fees=0):
(did, verkey) = helpers.wallet.create_did()
request = helpers.request.nym(dest=did, verkey=verkey)
request = add_fees_request_with_address(helpers,
fees_set,
request,
address,
change_address=change_address,
adjust_fees=adjust_fees)
helpers.sdk.send_and_check_request_objects([request])
return did
def test_revert_works_for_fees_after_view_change(
looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle,
sdk_wallet_trustee, fees_set, address_main, mint_tokens):
node_set = [n.nodeIbStasher for n in nodeSetWithIntegratedTokenPlugin]
with delay_rules(node_set, cDelay()):
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, True, retryWait=0.2, timeout=15))
committed_hash_before = get_committed_hash_for_pool(
nodeSetWithIntegratedTokenPlugin, DOMAIN_LEDGER_ID)
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, False, retryWait=0.2, timeout=15))
ensure_view_change(looper, nodeSetWithIntegratedTokenPlugin)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(lambda: assertExp(n.mode == Mode.participating)))
looper.run(
eventually(check_not_in_view_change,
nodeSetWithIntegratedTokenPlugin))
committed_hash_after = get_committed_hash_for_pool(
nodeSetWithIntegratedTokenPlugin, DOMAIN_LEDGER_ID)
assert committed_hash_before == committed_hash_after
ensure_all_nodes_have_same_data(looper,
nodeSetWithIntegratedTokenPlugin)
def _send_request(looper, helpers, fees, wallets_count, address, owner,
sdk_wallet_trustee, sdk_wallet_trustees, sdk_wallet_stewards,
sdk_wallet_clients, sdk_wallet_trust_anchors):
print(wallets_count)
wallets = sdk_wallet_trustees[:wallets_count.get(TRUSTEE, 0)] + \
sdk_wallet_stewards[:wallets_count.get(STEWARD, 0)] + \
sdk_wallet_clients[:wallets_count.get(IDENTITY_OWNER, 0)] + \
sdk_wallet_trust_anchors[:wallets_count.get(TRUST_ANCHOR, 0)]
# prepare owner parameter
if owner == TRUSTEE:
sender_wallet = sdk_wallet_trustees[0]
elif owner == STEWARD:
sender_wallet = sdk_wallet_stewards[0]
elif owner == IDENTITY_OWNER:
sender_wallet = sdk_wallet_clients[0]
elif owner == TRUST_ANCHOR:
sender_wallet = sdk_wallet_trust_anchors[0]
else:
sender_wallet = wallets[0]
target_dest = sdk_wallet_trustee[1] if owner == "-1" else sender_wallet[1]
# prepare data
data = SecretBox().encrypt(json.dumps({'name': 'Jaime'}).encode()).hex()
# create request
request = add_attribute(looper, sender_wallet, None, target_dest, enc=data)
request = sdk_json_to_request_object(json.loads(request))
request.signature = None
request.signatures = None
# add fees
request = add_fees_request_with_address(helpers, fees, request, address)
# sign request
request = sdk_multi_sign_request_objects(looper, wallets, [request])
return helpers.sdk.sdk_send_and_check(request)
