Mirroristas/planetmint
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint.git synced 2025-06-11 08:36:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added zenroom test

Browse Source 
Signed-off-by: Sangat Das <sangatdas5@gmail.com>
This commit is contained in:
Sangat Das 2022-02-21 08:30:24 +00:00
parent ecb4b6dc74
commit 5f53ed0876
2 changed files with 146 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
acceptance/python/src/conftest.py Normal file
View File

@ -0,0 +1,89 @@
# Copyright © 2020 Interplanetary Database Association e.V.,
# Planetmint and IPDB software contributors.
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are CC-BY-4.0
import pytest
GENERATE_KEYPAIR = \
"""Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': Create the keypair
Given that I am known as 'Pippo'
When I create the ecdh key
When I create the testnet key
Then print data"""
# secret key to public key
SK_TO_PK = \
"""Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': Create the keypair
Given that I am known as '{}'
Given I have the 'keys'
When I create the ecdh public key
When I create the testnet address
Then print my 'ecdh public key'
Then print my 'testnet address'"""
FULFILL_SCRIPT = \
"""Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': Bob verifies the signature from Alice
Given I have a 'ecdh public key' from 'Alice'
Given that I have a 'string dictionary' named 'houses' inside 'asset'
Given I have a 'signature' named 'data.signature' inside 'result'
When I verify the 'houses' has a signature in 'data.signature' by 'Alice'
Then print the string 'ok'"""
HOUSE_ASSETS = {
"data": {
"houses": [
{
"name": "Harry",
"team": "Gryffindor",
},
{
"name": "Draco",
"team": "Slytherin",
}
],
}
}
ZENROOM_DATA = {
'also': 'more data'
}
CONDITION_SCRIPT = """Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': create the signature of an object
Given I have the 'keys'
Given that I have a 'string dictionary' named 'houses' inside 'asset'
When I create the signature of 'houses'
When I rename the 'signature' to 'data.signature'
Then print the 'data.signature'"""
@pytest.fixture
def gen_key_zencode():
return GENERATE_KEYPAIR
@pytest.fixture
def secret_key_to_private_key_zencode():
return SK_TO_PK
@pytest.fixture
def fulfill_script_zencode():
return FULFILL_SCRIPT
@pytest.fixture
def condition_script_zencode():
return CONDITION_SCRIPT
@pytest.fixture
def zenroom_house_assets():
return HOUSE_ASSETS
@pytest.fixture
def zenroom_data():
return ZENROOM_DATA

236
acceptance/python/src/test_zenroom.py
View File

@ -14,194 +14,72 @@ import hashlib
from cryptoconditions import ZenroomSha256 from cryptoconditions import ZenroomSha256
from json.decoder import JSONDecodeError from json.decoder import JSONDecodeError
# from zenroom import zencode_exec def test_zenroom(gen_key_zencode, secret_key_to_private_key_zencode, fulfill_script_zencode,
condition_script_zencode, zenroom_data, zenroom_house_assets):
alice = json.loads(ZenroomSha256.run_zenroom(gen_key_zencode).output)['keys']
bob = json.loads(ZenroomSha256.run_zenroom(gen_key_zencode).output)['keys']
# from bigchaindb_driver import BigchainDB zen_public_keys = json.loads(ZenroomSha256.run_zenroom(secret_key_to_private_key_zencode.format('Alice'),
# # bdb_root_url = 'https://ipdb3.riddleandcode.com' keys={'keys': alice}).output)
# bdb_root_url = 'http://localhost:9984/' zen_public_keys.update(json.loads(ZenroomSha256.run_zenroom(secret_key_to_private_key_zencode.format('Bob'),
# bdb = BigchainDB(bdb_root_url) keys={'keys': bob}).output))
# The procedure to generate the keyring cannot be # CRYPTO-CONDITIONS: instantiate an Ed25519 crypto-condition for buyer
# fixed in the code base, it depends on the particular zenSha = ZenroomSha256(script=fulfill_script_zencode, keys=zen_public_keys, data=zenroom_data)
# smart contract
GENERATE_KEYPAIR = \
"""Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': Create the keypair
Given that I am known as 'Pippo'
When I create the ecdh key
When I create the testnet key
Then print data"""
def genkey(): # CRYPTO-CONDITIONS: generate the condition uri
return json.loads(ZenroomSha256.run_zenroom(GENERATE_KEYPAIR).output)['keys'] condition_uri = zenSha.condition.serialize_uri()
# There is not a unique way of generating the public # CRYPTO-CONDITIONS: construct an unsigned fulfillment dictionary
# key, for example, for the testnet I don't want the unsigned_fulfillment_dict = {
# public key but the address (but there could exist 'type': zenSha.TYPE_NAME,
# a script in which the user want the public key and 'script': fulfill_script_zencode,
# not the address) 'keys': zen_public_keys,
# Thus we cannot fix it inside the script
# secret key to public key
SK_TO_PK = \
"""Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': Create the keypair
Given that I am known as '{}'
Given I have the 'keys'
When I create the ecdh public key
When I create the testnet address
Then print my 'ecdh public key'
Then print my 'testnet address'"""
def sk2pk(name, keys):
return json.loads(ZenroomSha256.run_zenroom(SK_TO_PK.format(name),
keys={'keys': keys}).output)
# Alice assert the composition of the houses
# zen_public_keys is an identity dictionary
alice, bob = genkey(), genkey()
print("============== ALICE KEYPAIR =================")
print(alice)
print("============== BOB KEYPAIR =================")
print(bob)
asset = {
"data": {
"houses": [
{
"name": "Harry",
"team": "Gryffindor",
},
{
"name": "Draco",
"team": "Slytherin",
}
],
} }
}
zen_public_keys = sk2pk('Alice', alice)
zen_public_keys.update(sk2pk('Bob', bob))
data = { output = {
'also': 'more data' 'amount': '1000',
} 'condition': {
print("============== PUBLIC IDENTITIES =================") 'details': unsigned_fulfillment_dict,
print(zen_public_keys) 'uri': condition_uri,
},
metadata = { 'data': zenroom_data,
} 'script': fulfill_script_zencode,
'conf': '',
version = '2.0' 'public_keys': (zen_public_keys['Alice']['ecdh_public_key'], ),
}
fulfill_script = """Rule input encoding base58
Rule output encoding base58
Scenario 'ecdh': Bob verifies the signature from Alice
Given I have a 'ecdh public key' from 'Alice'
Given that I have a 'string dictionary' named 'houses' inside 'asset'
Given I have a 'signature' named 'data.signature' inside 'result'
When I verify the 'houses' has a signature in 'data.signature' by 'Alice'
Then print the string 'ok'
"""
# CRYPTO-CONDITIONS: instantiate an Ed25519 crypto-condition for buyer
zenSha = ZenroomSha256(script=fulfill_script, keys=zen_public_keys, data=data)
# CRYPTO-CONDITIONS: generate the condition uri
condition_uri = zenSha.condition.serialize_uri()
# CRYPTO-CONDITIONS: construct an unsigned fulfillment dictionary
unsigned_fulfillment_dict = {
'type': zenSha.TYPE_NAME,
'script': fulfill_script,
'keys': zen_public_keys,
}
output = {
'amount': '1000',
'condition': {
'details': unsigned_fulfillment_dict,
'uri': condition_uri,
},
'data': data,
'script': fulfill_script,
'conf': '',
'public_keys': (zen_public_keys['Alice']['ecdh_public_key'], ),
}
input_ = { input_ = {
'fulfillment': None, 'fulfillment': None,
'fulfills': None, 'fulfills': None,
'owners_before': (zen_public_keys['Alice']['ecdh_public_key'], ), 'owners_before': (zen_public_keys['Alice']['ecdh_public_key'], ),
} }
token_creation_tx = { token_creation_tx = {
'operation': 'CREATE', 'operation': 'CREATE',
'asset': asset, 'asset': zenroom_house_assets,
'metadata': None, 'metadata': None,
'outputs': (output,), 'outputs': (output,),
'inputs': (input_,), 'inputs': (input_,),
'version': version, 'version': '2.0',
'id': None, 'id': None,
} }
# JSON: serialize the transaction-without-id to a json formatted string # JSON: serialize the transaction-without-id to a json formatted string
message = json.dumps( message = json.dumps(
token_creation_tx, token_creation_tx,
sort_keys=True, sort_keys=True,
separators=(',', ':'), separators=(',', ':'),
ensure_ascii=False, ensure_ascii=False,
) )
print("====== GENERATE RESULT (METADATA) =======") try:
condition_script = """Rule input encoding base58 assert(not zenSha.validate(message=message))
Rule output encoding base58 except JSONDecodeError:
Scenario 'ecdh': create the signature of an object pass
Given I have the 'keys' except ValueError:
Given that I have a 'string dictionary' named 'houses' inside 'asset' pass
When I create the signature of 'houses'
When I rename the 'signature' to 'data.signature'
Then print the 'data.signature'
"""
# THIS FILLS THE METADATA WITH THE RESULT message = zenSha.sign(message, condition_script_zencode, alice)
try: assert(zenSha.validate(message=message))
assert(not zenSha.validate(message=message))
except JSONDecodeError:
pass
except ValueError:
pass
message = zenSha.sign(message, condition_script, alice)
assert(zenSha.validate(message=message))
# now metadata looks like
# 'metadata': {'result': {'data.signature': {'r': 'fdoan0GYo9RGP8y0fq+PKZ9Q1V8+VqJtBkSMB1tUnGQ=', 's': 'RnJCEepYJcVgFG/Y6cRc/2DWPaz5Pe5NpdRWegrZk5A='}}}
# CRYPTO-CONDITIONS: generate the fulfillment uri
fulfillment_uri = zenSha.serialize_uri()
# add the fulfillment uri (signature)
token_creation_tx['inputs'][0]['fulfillment'] = fulfillment_uri
print(token_creation_tx)
# JSON: serialize the id-less transaction to a json formatted string
json_str_tx = json.dumps(
token_creation_tx,
sort_keys=True,
separators=(',', ':'),
ensure_ascii=False,
)
# SHA3: hash the serialized id-less transaction to generate the id
shared_creation_txid = hashlib.sha3_256(json_str_tx.encode()).hexdigest()
# add the id
token_creation_tx['id'] = shared_creation_txid
# exit()
# send CREATE tx into the bdb network
# returned_creation_tx = bdb.transactions.send_async(token_creation_tx)
# print(returned_creation_tx)