def test_nym_send_twice(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
for i in range(2):
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
if i == 0:
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
else:
# TODO(INDY-1069): Ugly hack to deal with old libindy which raises exception on REJECT,
# in fact it should be simple:
# assert result['op'] == REJECT
try:
json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert False
except IndyError as ex:
assert ex.error_code == ErrorCode.LedgerInvalidTransaction
def test_nym_send_twice(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
for i in range(2):
request = looper.loop.run_until_complete(build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(sign_request(wallet_handle, identifier, request))
if i == 0:
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
else:
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REJECT
def test_idr_cache_update_after_catchup(txnPoolNodeSet, looper,
sdk_pool_handle, sdk_wallet_steward,
tconf, tdir, allPluginsPath):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=True)
looper.removeProdable(node_to_disconnect)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
restarted_node = start_stopped_node(node_to_disconnect, looper, tconf,
tdir, allPluginsPath)
txnPoolNodeSet[-1] = restarted_node
waitNodeDataEquality(looper, restarted_node, *txnPoolNodeSet[:-1])
req_handler = restarted_node.get_req_handler(DOMAIN_LEDGER_ID)
root_hash = req_handler.ts_store.get_equal_or_prev(
get_txn_time(result['result']))
key = domain.make_state_path_for_nym(idr)
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def test_idr_cache_update_after_catchup(txnPoolNodeSet,
looper,
sdk_pool_handle,
sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
req_handler = node_to_disconnect.getDomainReqHandler()
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=False)
looper.runFor(2)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(sign_request(wallet_handle, identifier, request))
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
reconnect_node_and_ensure_connected(looper, txnPoolNodeSet, node_to_disconnect.name)
waitNodeDataEquality(looper, node_to_disconnect, *txnPoolNodeSet)
key = domain.make_state_path_for_nym(idr)
root_hash = req_handler.ts_store.get_equal_or_prev(result['result']['txnTime'])
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def test_idr_cache_update_after_catchup(txnPoolNodeSet,
looper,
sdk_pool_handle,
sdk_wallet_steward,
tconf,
tdir,
allPluginsPath):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=True)
looper.removeProdable(node_to_disconnect)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(sign_request(wallet_handle, identifier, request))
result = json.loads(looper.loop.run_until_complete(submit_request(sdk_pool_handle, req_signed)))
restarted_node = start_stopped_node(node_to_disconnect, looper,
tconf, tdir, allPluginsPath)
txnPoolNodeSet[-1] = restarted_node
waitNodeDataEquality(looper, restarted_node, *txnPoolNodeSet[:-1])
req_handler = restarted_node.getDomainReqHandler()
root_hash = req_handler.ts_store.get_equal_or_prev(get_txn_time(result['result']))
key = domain.make_state_path_for_nym(idr)
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def verify_payment_on_ledger(pool_handle, receipts):
try:
requests = run_array([
payment.build_verify_payment_req(-1, None, receipt)
for receipt in receipts
])
responses = run_array([
ledger.submit_request(pool_handle,
list(request.result())[0])
for request in requests[0]
])
results = run_array([
payment.parse_verify_payment_response(PAYMENT_METHOD,
response.result())
for response in responses[0]
])
for receipt in [result.result() for result in results[0]]:
if len(json.loads(receipt)['sources']) == 0:
raise Exception('Payment failed')
return
except IndyError as err:
handle_payment_error(err)
def test_nym_send_twice(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
for i in range(2):
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
if i == 0:
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
else:
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REJECT
def send_transaction(pool_handle: int, transaction: str):
try:
response = json.loads(
run_coroutine(ledger.submit_request(pool_handle, transaction)))
if response['op'] != 'REPLY':
raise Exception(response['reason'])
except IndyError as err:
if err.error_code == ErrorCode.CommonInvalidStructure:
raise Exception('Invalid Transaction')
if err.error_code == ErrorCode.PoolLedgerTimeout:
raise Exception('Cannot get response from Ledger')
raise Exception(err.message)
def test_get_txn_after_bls_key_rotation(looper, txnPoolNodeSet,
sdk_wallet_stewards,
sdk_wallet_trustee,
sdk_wallet_client,
sdk_pool_handle):
check_update_bls_key(node_num=0, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
check_update_bls_key(node_num=1, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
check_update_bls_key(node_num=2, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
check_update_bls_key(node_num=3, saved_multi_sigs_count=4,
looper=looper, txnPoolNodeSet=txnPoolNodeSet,
sdk_wallet_stewards=sdk_wallet_stewards,
sdk_wallet_client=sdk_wallet_client,
sdk_pool_handle=sdk_pool_handle,
pool_refresh=False)
# Stop receiving of commits in a circle, so all nodes will have different sets of multi signatures
with delay_rules_without_processing(txnPoolNodeSet[0].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[3].name)):
with delay_rules_without_processing(txnPoolNodeSet[1].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[0].name)):
with delay_rules_without_processing(txnPoolNodeSet[2].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[1].name)):
with delay_rules_without_processing(txnPoolNodeSet[3].nodeIbStasher, cDelay(delay=1200, sender_filter=txnPoolNodeSet[2].name)):
did_future = create_and_store_my_did(sdk_wallet_client[0], "{}")
did, verkey = looper.loop.run_until_complete(did_future)
nym_request_future = ledger.build_nym_request(sdk_wallet_trustee[1], did, verkey, None, None)
nym_request = looper.loop.run_until_complete(nym_request_future)
nym_response_future = ledger.sign_and_submit_request(sdk_pool_handle, sdk_wallet_trustee[0], sdk_wallet_trustee[1], nym_request)
looper.loop.run_until_complete(nym_response_future)
get_txn_request_future = ledger.build_get_txn_request(sdk_wallet_client[1], "DOMAIN", 1)
get_txn_request = looper.loop.run_until_complete(get_txn_request_future)
get_txn_response_future = ledger.submit_request(sdk_pool_handle, get_txn_request)
looper.loop.run_until_complete(get_txn_response_future)
def sdk_send_signed_requests(pool_h, signed_reqs: Sequence):
return [(json.loads(req),
asyncio.ensure_future(submit_request(pool_h, req)))
for req in signed_reqs]
def sdk_get_txn(looper, sdk_pool_handle, seq_no, ledger_id):
get_txn_request_future = build_get_txn_request(None, ledger_id, seq_no)
get_txn_request = looper.loop.run_until_complete(get_txn_request_future)
get_txn_response_future = submit_request(sdk_pool_handle, get_txn_request)
get_txn_response = looper.loop.run_until_complete(get_txn_response_future)
return get_txn_response
def sdk_send_signed_requests(pool_h, signed_reqs: Sequence):
return [(json.loads(req),
asyncio.ensure_future(submit_request(pool_h, req)))
for req in signed_reqs]
