def test_append_txn_metadata():
txn = init_empty_txn(txn_type=NODE, protocol_version="3")
set_payload_data(txn, {"somekey": "somevalue"})
append_payload_metadata(txn, frm="DID1", req_id=12345)
append_txn_metadata(txn, seq_no=144, txn_time=12345678, txn_id="dddd")
expected = SortedDict({
"reqSignature": {},
"txn": {
"data": {
"somekey": "somevalue"
},
"metadata": {
"from": "DID1",
"reqId": 12345,
},
"protocolVersion": "3",
"type": NODE,
},
"txnMetadata": {
"seqNo": 144,
"txnId": "dddd",
"txnTime": 12345678,
},
"ver": "1"
})
assert SortedDict(expected) == SortedDict(txn)
def test_append_payload_metadata():
txn = init_empty_txn(txn_type=NODE, protocol_version="3")
set_payload_data(txn, {"somekey": "somevalue"})
append_payload_metadata(txn,
frm="DID1",
req_id=12345,
digest="random req digest",
payload_digest="random payload")
expected = SortedDict({
"reqSignature": {},
"txn": {
"data": {
"somekey": "somevalue"
},
"metadata": {
"from": "DID1",
"reqId": 12345,
"digest": "random req digest",
"payloadDigest": "random payload"
},
"protocolVersion": "3",
"type": NODE,
},
"txnMetadata": {},
"ver": "1"
})
assert SortedDict(expected) == SortedDict(txn)
def node_txn(steward_nym, node_name, nym, ip, node_port, client_port,
client_ip=None, blskey=None, services=None, txn_id=None,
seq_no=None,
protocol_version=CURRENT_PROTOCOL_VERSION, bls_key_proof=None):
txn = init_empty_txn(txn_type=NODE, protocol_version=protocol_version)
txn = append_payload_metadata(txn, frm=steward_nym)
txn_data = {
TARGET_NYM: nym,
DATA: {
CLIENT_IP: client_ip or ip,
ALIAS: node_name,
CLIENT_PORT: client_port,
NODE_IP: ip,
NODE_PORT: node_port,
SERVICES: services or [VALIDATOR],
BLS_KEY: blskey,
BLS_KEY_PROOF: bls_key_proof
},
}
txn = set_payload_data(txn, txn_data)
txn_id = txn_id or sha256(node_name.encode()).hexdigest()
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def test_no_state_proofs_if_protocol_version_less(request_handler):
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
role = "2"
verkey = "~7TYfekw4GUagBnBVCqPjiC"
seq_no = 0
txn_time = int(time.time())
# Adding nym
data = {
f.IDENTIFIER.nm: nym,
ROLE: role,
VERKEY: verkey,
f.SEQ_NO.nm: seq_no,
TXN_TIME: txn_time,
}
txn = append_txn_metadata(reqToTxn(Request(operation=data)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
request_handler.updateNym(nym, txn)
request_handler.state.commit()
multi_sig = save_multi_sig(request_handler)
# Getting nym
request = Request(operation={TARGET_NYM: nym}, signatures={})
result = request_handler.handleGetNymReq(request)
assert STATE_PROOF not in result
def node_txn(steward_nym,
node_name,
nym,
ip,
node_port,
client_port,
client_ip=None,
blskey=None,
services=None,
txn_id=None,
seq_no=None):
txn = init_empty_txn(txn_type=NODE)
txn = append_payload_metadata(txn, frm=steward_nym)
txn_data = {
TARGET_NYM: nym,
DATA: {
CLIENT_IP: client_ip or ip,
ALIAS: node_name,
CLIENT_PORT: client_port,
NODE_IP: ip,
NODE_PORT: node_port,
SERVICES: services or [VALIDATOR],
BLS_KEY: blskey
},
}
txn = set_payload_data(txn, txn_data)
txn_id = txn_id or sha256(node_name.encode()).hexdigest()
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def test_no_state_proofs_if_protocol_version_less(write_manager, read_manager,
db_manager):
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
role = "2"
verkey = "~7TYfekw4GUagBnBVCqPjiC"
identifier = "6ouriXMZkLeHsuXrN1X1fd"
seq_no = 0
txn_time = int(time.time())
# Adding nym
data = {
TARGET_NYM: nym,
ROLE: role,
VERKEY: verkey,
}
txn = append_txn_metadata(reqToTxn(
Request(operation=data,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = set_type(txn, NYM)
txn = append_payload_metadata(txn, frm=nym)
write_manager.update_state(txn)
db_manager.get_state(DOMAIN_LEDGER_ID).commit()
multi_sig = save_multi_sig(db_manager)
# Getting nym
request = Request(operation={
TARGET_NYM: nym,
TXN_TYPE: GET_NYM,
},
signatures={})
result = read_manager.get_result(request)
assert STATE_PROOF not in result
def nym_txn(nym,
name=None,
verkey=None,
role=None,
creator=None,
txn_id=None,
seq_no=None):
txn = init_empty_txn(NYM)
txn_data = {
TARGET_NYM: nym,
}
if verkey is not None:
txn_data[VERKEY] = verkey
if role is not None:
txn_data[ROLE] = role
if name is not None:
txn_data[ALIAS] = name
set_payload_data(txn, txn_data)
txn = append_payload_metadata(txn, frm=creator)
if txn_id:
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def test_state_proofs_for_get_claim_def(write_manager, read_manager,
db_manager):
# Adding claim def
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
seq_no = 0
txn_time = int(time.time())
identifier = "6ouriXMZkLeHsuXrN1X1fd"
schema_seqno = 0
signature_type = 'CL'
key_components = '{"key_components": []}'
tag = 'tag1'
txn = {
TXN_TYPE: CLAIM_DEF,
TARGET_NYM: nym,
CLAIM_DEF_SCHEMA_REF: schema_seqno,
CLAIM_DEF_PUBLIC_KEYS: key_components,
CLAIM_DEF_TAG: tag
}
txn = append_txn_metadata(reqToTxn(
Request(operation=txn,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
write_manager.update_state(txn)
db_manager.get_state(DOMAIN_LEDGER_ID).commit()
multi_sig = save_multi_sig(db_manager)
# Getting claim def
request = Request(operation={
IDENTIFIER: nym,
CLAIM_DEF_FROM: nym,
CLAIM_DEF_SCHEMA_REF: schema_seqno,
CLAIM_DEF_SIGNATURE_TYPE: signature_type,
CLAIM_DEF_TAG: tag,
TXN_TYPE: GET_CLAIM_DEF,
},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = read_manager.get_result(request)
proof = extract_proof(result, multi_sig)
assert result[DATA] == key_components
# Verifying signed state proof
path = domain.make_state_path_for_claim_def(nym, schema_seqno,
signature_type, tag)
assert is_proof_verified(db_manager, proof, path, key_components, seq_no,
txn_time)
def append_old_payload_metadata(txn,
frm=None,
req_id=None,
digest=None,
payload_digest=None,
taa_acceptance=None):
txn = append_payload_metadata(txn, frm, req_id, digest, payload_digest,
taa_acceptance)
metadata = txn[TXN_PAYLOAD][TXN_PAYLOAD_METADATA]
del metadata[TXN_PAYLOAD_METADATA_PAYLOAD_DIGEST]
metadata[TXN_PAYLOAD_METADATA_DIGEST] = payload_digest
return txn
def test_append_payload_metadata():
txn = init_empty_txn(txn_type=NODE, protocol_version="3")
set_payload_data(txn, {"somekey": "somevalue"})
append_payload_metadata(txn, frm="DID1",
req_id=12345,
digest="random req digest")
expected = SortedDict({
"reqSignature": {},
"txn": {
"data": {"somekey": "somevalue"},
"metadata": {
"from": "DID1",
"reqId": 12345,
"digest": "random req digest"
},
"protocolVersion": "3",
"type": NODE,
},
"txnMetadata": {
},
"ver": "1"
})
assert SortedDict(expected) == SortedDict(txn)
def test_state_proofs_for_get_claim_def(request_handler):
# Adding claim def
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
seq_no = 0
txn_time = int(time.time())
identifier = "6ouriXMZkLeHsuXrN1X1fd"
schema_seqno = 0
signature_type = 'CL'
key_components = '{"key_components": []}'
txn = {
TXN_TYPE: CLAIM_DEF,
TARGET_NYM: nym,
REF: schema_seqno,
DATA: key_components
}
txn = append_txn_metadata(reqToTxn(
Request(operation=txn,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
request_handler._addClaimDef(txn)
request_handler.state.commit()
multi_sig = save_multi_sig(request_handler)
# Getting claim def
request = Request(operation={
IDENTIFIER: nym,
ORIGIN: nym,
REF: schema_seqno,
SIGNATURE_TYPE: signature_type
},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = request_handler.handleGetClaimDefReq(request)
proof = extract_proof(result, multi_sig)
assert result[DATA] == key_components
# Verifying signed state proof
path = domain.make_state_path_for_claim_def(nym, schema_seqno,
signature_type)
assert is_proof_verified(request_handler, proof, path, key_components,
seq_no, txn_time)
def test_append_txn_metadata():
txn = init_empty_txn(txn_type=NODE, protocol_version="3")
set_payload_data(txn, {"somekey": "somevalue"})
append_payload_metadata(txn, frm="DID1", req_id=12345)
append_txn_metadata(txn, seq_no=144, txn_time=12345678, txn_id="dddd")
expected = SortedDict({
"reqSignature": {},
"txn": {
"data": {"somekey": "somevalue"},
"metadata": {
"from": "DID1",
"reqId": 12345,
},
"protocolVersion": "3",
"type": NODE,
},
"txnMetadata": {
"seqNo": 144,
"txnId": "dddd",
"txnTime": 12345678,
},
"ver": "1"
})
assert SortedDict(expected) == SortedDict(txn)
def test_state_proofs_for_get_schema(write_manager, read_manager, db_manager):
# Adding schema
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
seq_no = 0
txn_time = int(time.time())
identifier = "6ouriXMZkLeHsuXrN1X1fd"
schema_name = "schema_a"
schema_version = "1.0"
# data = '{"name": "schema_a", "version": "1.0"}'
schema_key = {SCHEMA_NAME: schema_name, SCHEMA_VERSION: schema_version}
data = {**schema_key, SCHEMA_ATTR_NAMES: ["Some_Attr", "Attr1"]}
txn = {
TXN_TYPE: SCHEMA,
DATA: data,
}
txn = append_txn_metadata(reqToTxn(
Request(operation=txn,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
write_manager.update_state(txn)
db_manager.get_state(DOMAIN_LEDGER_ID).commit()
multi_sig = save_multi_sig(db_manager)
# Getting schema
request = Request(operation={
TARGET_NYM: nym,
DATA: schema_key,
TXN_TYPE: GET_SCHEMA
},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = read_manager.get_result(request)
proof = extract_proof(result, multi_sig)
assert result[DATA] == data
data.pop(NAME)
data.pop(VERSION)
# Verifying signed state proof
path = domain.make_state_path_for_schema(nym, schema_name, schema_version)
assert is_proof_verified(db_manager, proof, path, data, seq_no, txn_time)
def test_state_proofs_for_get_context(write_manager, read_manager, db_manager):
# Adding context
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
seq_no = 0
txn_time = int(time.time())
identifier = "6ouriXMZkLeHsuXrN1X1fd"
context_name = "context_a"
context_version = "1.0"
meta = {
CONTEXT_NAME: context_name,
CONTEXT_VERSION: context_version,
RS_TYPE: CONTEXT_TYPE
}
data = {CONTEXT_CONTEXT: {"ex": "https://example.org/examples#"}}
txn = {TXN_TYPE: SET_CONTEXT, DATA: data, META: meta}
txn = append_txn_metadata(reqToTxn(
Request(operation=txn,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
write_manager.update_state(txn)
db_manager.get_state(DOMAIN_LEDGER_ID).commit()
multi_sig = save_multi_sig(db_manager)
# Getting context
request = Request(operation={
TARGET_NYM: nym,
META: meta,
TXN_TYPE: GET_CONTEXT
},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = read_manager.get_result(request)
proof = extract_proof(result, multi_sig)
assert result[DATA][DATA] == data
# Verifying signed state proof
path = domain.make_state_path_for_context(nym, context_name,
context_version)
value = {META: meta, DATA: data}
assert is_proof_verified(db_manager, proof, path, value, seq_no, txn_time)
def test_state_proofs_for_get_schema(request_handler):
# Adding schema
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
seq_no = 0
txn_time = int(time.time())
schema_name = "schema_a"
schema_version = "1.0"
# data = '{"name": "schema_a", "version": "1.0"}'
schema_key = {NAME: schema_name, VERSION: schema_version}
data = {**schema_key, "Some_Attr": "Attr1"}
txn = {
TXN_TYPE: SCHEMA,
DATA: data,
}
txn = append_txn_metadata(reqToTxn(Request(operation=txn)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
request_handler._addSchema(txn)
request_handler.state.commit()
multi_sig = save_multi_sig(request_handler)
# Getting schema
request = Request(operation={
TARGET_NYM: nym,
DATA: schema_key
},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = request_handler.handleGetSchemaReq(request)
proof = extract_proof(result, multi_sig)
assert result[DATA] == data
data.pop(NAME)
data.pop(VERSION)
# Verifying signed state proof
path = domain.make_state_path_for_schema(nym, schema_name, schema_version)
assert is_proof_verified(request_handler, proof, path, data, seq_no,
txn_time)
def test_state_proofs_for_get_nym(request_handler):
nym = 'Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv'
role = "2"
verkey = "~7TYfekw4GUagBnBVCqPjiC"
seq_no = 0
txn_time = int(time.time())
# Adding nym
data = {
f.IDENTIFIER.nm: nym,
ROLE: role,
VERKEY: verkey,
f.SEQ_NO.nm: seq_no,
TXN_TIME: txn_time,
}
txn = append_txn_metadata(reqToTxn(Request(operation=data)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
request_handler.updateNym(nym, txn)
request_handler.state.commit()
multi_sig = save_multi_sig(request_handler)
# Getting nym
request = Request(operation={TARGET_NYM: nym},
signatures={},
protocolVersion=CURRENT_PROTOCOL_VERSION)
result = request_handler.handleGetNymReq(request)
proof = extract_proof(result, multi_sig)
# Verifying signed state proof
path = request_handler.nym_to_state_key(nym)
encoded_value = request_handler.stateSerializer.serialize(data)
proof_nodes = base64.b64decode(proof[PROOF_NODES])
root_hash = base58.b58decode(proof[ROOT_HASH])
verified = request_handler.state.verify_state_proof(root_hash,
path,
encoded_value,
proof_nodes,
serialized=True)
assert verified
def prep_multi_sig(write_manager, db_manager, nym, role, verkey, seq_no):
txn_time = int(time.time())
identifier = "6ouriXMZkLeHsuXrN1X1fd"
# Adding nym
data = {
TARGET_NYM: nym,
ROLE: role,
VERKEY: verkey,
}
txn = append_txn_metadata(reqToTxn(
Request(operation=data,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = set_type(txn, NYM)
txn = append_payload_metadata(txn, frm=nym)
write_manager.update_state(txn)
db_manager.get_state(DOMAIN_LEDGER_ID).commit()
multi_sig = save_multi_sig(db_manager)
return data, multi_sig
def nym_txn(nym, name=None, verkey=None, role=None, creator=None, txn_id=None, seq_no=None,
protocol_version=CURRENT_PROTOCOL_VERSION):
txn = init_empty_txn(NYM, protocol_version=protocol_version)
txn_data = {
TARGET_NYM: nym,
}
if verkey is not None:
txn_data[VERKEY] = verkey
if role is not None:
txn_data[ROLE] = role
if name is not None:
txn_data[ALIAS] = name
set_payload_data(txn, txn_data)
txn = append_payload_metadata(txn,
frm=creator)
if txn_id:
txn = append_txn_metadata(txn, txn_id=txn_id)
if seq_no:
txn = append_txn_metadata(txn, seq_no=seq_no)
return txn
def prep_multi_sig(request_handler, nym, role, verkey, seq_no):
txn_time = int(time.time())
identifier = "6ouriXMZkLeHsuXrN1X1fd"
# Adding nym
data = {
f.IDENTIFIER.nm: nym,
ROLE: role,
VERKEY: verkey,
f.SEQ_NO.nm: seq_no,
TXN_TIME: txn_time,
}
txn = append_txn_metadata(reqToTxn(
Request(operation=data,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=identifier)),
seq_no=seq_no,
txn_time=txn_time)
txn = append_payload_metadata(txn, frm=nym)
request_handler.updateNym(nym, txn)
request_handler.state.commit()
multi_sig = save_multi_sig(request_handler)
return data, multi_sig
