def __init__(self,
client: ExonumClient,
instance_name: str = "crypto",
version: str = "0.2.0"):
self.client = client
service_name = "exonum-cryptocurrency"
self.service_version = version
self.instance_name = instance_name
self.loader = client.protobuf_loader()
self.loader.initialize()
self.loader.load_main_proto_files()
self.loader.load_service_proto_files(runtime_id=0,
artifact_name="exonum-supervisor",
artifact_version="1.0.0")
self.loader.load_service_proto_files(
runtime_id=0,
artifact_name=service_name,
artifact_version=self.service_version)
self.cryptocurrency_module = ModuleManager.import_service_module(
service_name, self.service_version, "service")
self.types_module = ModuleManager.import_service_module(
service_name, self.service_version, "exonum.crypto.types")
instance_id = client.public_api.get_instance_id_by_name(
self.instance_name)
self.msg_generator = MessageGenerator(
instance_id=instance_id,
artifact_name=service_name,
artifact_version=self.service_version)
def __init__(self, client: ExonumClient):
self.client = client
cryptocurrency_service_name = "exonum-cryptocurrency-advanced"
cryptocurrency_service_version = "0.13.0-rc.2"
self.loader = client.protobuf_loader()
self.loader.initialize()
self.loader.load_main_proto_files()
self.loader.load_service_proto_files(
runtime_id=0,
artifact_name="exonum-supervisor",
artifact_version="0.13.0-rc.2",
)
self.loader.load_service_proto_files(
runtime_id=0,
artifact_name=cryptocurrency_service_name,
artifact_version=cryptocurrency_service_version,
)
self.cryptocurrency_module = ModuleManager.import_service_module(
cryptocurrency_service_name, cryptocurrency_service_version,
"service")
self.types_module = ModuleManager.import_service_module(
cryptocurrency_service_name, cryptocurrency_service_version,
"types")
instance_id = client.public_api.get_instance_id_by_name("crypto")
self.msg_generator = MessageGenerator(
instance_id=instance_id,
artifact_name=cryptocurrency_service_name,
artifact_version=cryptocurrency_service_version)
def run() -> None:
"""Example of downloading the Protobuf sources and using the compiled
module."""
client = ExonumClient(hostname="127.0.0.1", public_api_port=8080, private_api_port=8081)
# Create ProtobufLoader via context manager (so that we will not have to
# initialize/deinitialize it manually):
with client.protobuf_loader() as loader:
# Load core proto files:
loader.load_main_proto_files()
# Load proto files for the Exonum supervisor service:
loader.load_service_proto_files(RUST_RUNTIME_ID, "exonum-supervisor:0.12.0")
# Load the main module (runtime.proto):
main_module = ModuleManager.import_main_module("runtime")
# Create a Protobuf message object:
artifact_id = main_module.ArtifactId()
artifact_id.runtime_id = RUST_RUNTIME_ID
artifact_id.name = "some_service:0.1.0"
# Working with Protobuf objects, you have to follow Protobuf Python API
# conventions. See Protobuf Python API docs for details:
instance_spec = main_module.InstanceSpec()
instance_spec.artifact.CopyFrom(artifact_id)
# Load the service module (service.proto from the supervisor service):
service_module = ModuleManager.import_service_module("exonum-supervisor:0.12.0", "service")
# Workflow is the same as for the main modules:
_deploy_request = service_module.DeployRequest()
def run() -> None:
"""This example creates two wallets (for Alice and Bob) and performs several
transactions between these wallets."""
client = ExonumClient(hostname="127.0.0.1",
public_api_port=8080,
private_api_port=8081)
with client.protobuf_loader() as loader:
# Load and compile proto files:
loader.load_main_proto_files()
loader.load_service_proto_files(RUST_RUNTIME_ID,
CRYPTOCURRENCY_ARTIFACT_NAME,
CRYPTOCURRENCY_ARTIFACT_VERSION)
instance_id = get_cryptocurrency_instance_id(client)
cryptocurrency_message_generator = MessageGenerator(
instance_id, CRYPTOCURRENCY_ARTIFACT_NAME,
CRYPTOCURRENCY_ARTIFACT_VERSION)
alice_keypair = create_wallet(client, cryptocurrency_message_generator,
"Alice")
bob_keypair = create_wallet(client, cryptocurrency_message_generator,
"Bob")
alice_balance = get_balance(client, alice_keypair.public_key)
bob_balance = get_balance(client, bob_keypair.public_key)
print("Created the wallets for Alice and Bob. Balance:")
print(f" Alice => {alice_balance}")
print(f" Bob => {bob_balance}")
amount = 10
alice_balance, bob_balance = transfer(
client, cryptocurrency_message_generator, alice_keypair,
bob_keypair.public_key, amount)
print(f"Transferred {amount} tokens from Alice's wallet to Bob's one")
print(f" Alice => {alice_balance}")
print(f" Bob => {bob_balance}")
amount = 25
bob_balance, alice_balance = transfer(
client, cryptocurrency_message_generator, bob_keypair,
alice_keypair.public_key, amount)
print(f"Transferred {amount} tokens from Bob's wallet to Alice's one")
print(f" Alice => {alice_balance}")
print(f" Bob => {bob_balance}")
def __init__(self, client: ExonumClient):
self.client = client
cryptocurrency_service_name = 'exonum-cryptocurrency-advanced:0.13.0-rc.2'
self.loader = client.protobuf_loader()
self.loader.initialize()
self.loader.load_main_proto_files()
self.loader.load_service_proto_files(
runtime_id=0, service_name='exonum-supervisor:0.13.0-rc.2')
self.loader.load_service_proto_files(
runtime_id=0, service_name=cryptocurrency_service_name)
self.cryptocurrency_module = ModuleManager.import_service_module(
cryptocurrency_service_name, 'service')
self.types_module = ModuleManager.import_service_module(
cryptocurrency_service_name, 'types')
instance_id = client.get_instance_id_by_name("crypto")
self.msg_generator = MessageGenerator(
instance_id=instance_id, artifact_name=cryptocurrency_service_name)
def run() -> None:
"""This is an example script for deploying the Cryptocurrency Advanced
service.
This script is intended only to demonstrate client possibilities.
For actual deployment consider using `exonum-launcher` tool."""
client = ExonumClient(hostname="127.0.0.1",
public_api_port=8080,
private_api_port=8081)
# Create better-looking aliases for constants.
service_name = CRYPTOCURRENCY_ARTIFACT_NAME
service_version = CRYPTOCURRENCY_ARTIFACT_VERSION
instance_name = CRYPTOCURRENCY_INSTANCE_NAME
with client.protobuf_loader() as loader:
# Load and compile proto files:
loader.load_main_proto_files()
loader.load_service_proto_files(RUST_RUNTIME_ID,
SUPERVISOR_ARTIFACT_NAME,
SUPERVISOR_ARTIFACT_VERSION)
try:
print(f"Started deploying `{service_name}` artifact.")
deploy_service(client, service_name, service_version)
print(f"Artifact `{service_name}` successfully deployed.")
print(f"Started enablind `{instance_name}` instance.")
instance_id = start_service(client, service_name, service_version,
instance_name)
# If no exception has occurred during the previous calls, the service
# has started successfully:
print(
f"Service instance '{instance_name}' (artifact '{service_name}') started with ID {instance_id}."
)
except RuntimeError as err:
print(
f"Service instance '{instance_name}' (artifact '{service_name}') deployment failed with error {err}"
)
def run_example(source: str) -> None:
# Create client.
client = ExonumClient(hostname="127.0.0.1", public_api_port=8080, private_api_port=8081)
# Setup protobuf provider.
setup_protobuf_provider(client.protobuf_provider, source)
# Create ProtobufLoader via context manager (so that we will not have to
# initialize/deinitialize it manually):
with client.protobuf_loader() as loader:
# Load core proto files:
loader.load_main_proto_files()
# Load proto files for the Exonum supervisor service:
loader.load_service_proto_files(RUST_RUNTIME_ID, SERVICE_NAME, SERVICE_VERSION)
# Load the main module (exonum/crypto/type.proto).
types_module = ModuleManager.import_main_module("exonum.crypto.types")
# Create a Protobuf message object:
public_key = types_module.PublicKey()
public_key.data = bytes(i for i in range(32))
# Load the service module (service.proto from the cryptocurrency-advanced service).
# Note that we load "service" module, which is absent in current version
# of the service, it only exists in Exonum 1.0.
service_module = ModuleManager.import_service_module(SERVICE_NAME, SERVICE_VERSION, "service")
# Note that if we want to work with service module, we should use types also from that module.
# That's required because of the inner python Protobuf implementation check system.
types_module = ModuleManager.import_service_module(SERVICE_NAME, SERVICE_VERSION, "exonum.crypto.types")
# Workflow is the same as for the main modules:
transfer = service_module.Transfer()
to = types_module.Hash()
to.data = bytes(i for i in range(32))
# Working with Protobuf objects, you have to follow Protobuf Python API conventions.
# See Protobuf Python API docs for details.
transfer.to.CopyFrom(to)
transfer.amount = 10
transfer.seed = 1
def run() -> None:
"""This is an example script for deploying the Cryptocurrency Advanced
service.
This script is intended only to demonstrate client possibilities.
For actual deployment consider using `exonum-launcher` tool."""
client = ExonumClient(hostname="127.0.0.1",
public_api_port=8080,
private_api_port=8081)
# Name of the artifact:
service_name = "exonum-cryptocurrency-advanced:0.12.0"
# Name of the service instance that we want to create:
instance_name = "XNM"
with client.protobuf_loader() as loader:
# Load and compile proto files:
loader.load_main_proto_files()
loader.load_service_proto_files(RUST_RUNTIME_ID,
"exonum-supervisor:0.12.0")
try:
print(f"Started deploying `{service_name}` artifact.")
deploy_service(client, service_name)
print(f"Artifact `{service_name}` successfully deployed.")
print(f"Started enablind `{instance_name}` instance.")
instance_id = start_service(client, service_name, instance_name)
# If no exception has occured during the previous calls, the service
# has started successfully:
print(
f"Service instance '{instance_name}' (artifact '{service_name}') started with ID {instance_id}."
)
except RuntimeError as err:
print(
f"Service instance '{instance_name}' (artifact '{service_name}') deployment failed with error {err}"
)
def run() -> None:
"""This example creates a wallet in the Cryptocurrency service, retrieves
proofs for the wallet and verifies them.
For the example to work, be sure to have `exonum-cryptocurrency-advanced`
service instance with name `XNM` deployed."""
client = ExonumClient(hostname="127.0.0.1",
public_api_port=8080,
private_api_port=8081)
with client.protobuf_loader() as loader:
# Load and compile proto files:
loader.load_main_proto_files()
loader.load_service_proto_files(RUST_RUNTIME_ID,
CRYPTOCURRENCY_ARTIFACT_NAME)
instance_id = get_cryptocurrency_instance_id(client)
cryptocurrency_message_generator = MessageGenerator(
instance_id, CRYPTOCURRENCY_ARTIFACT_NAME)
alice_keypair = create_wallet(client, cryptocurrency_message_generator,
"Alice")
wallet_info_response = client.get_service(
CRYPTOCURRENCY_INSTANCE_NAME, "v1/wallets/info?pub_key={}".format(
alice_keypair.public_key.hex()))
ensure_status_code(wallet_info_response)
wallet_info = wallet_info_response.json()
# `MapProof` to the whole Exonum state hash:
proof_to_table = wallet_info["wallet_proof"]["to_table"]
# Expected hash of the proof to the table is a state hash of the block:
expected_to_table_hash_raw = wallet_info["block_proof"]["block"][
"state_hash"]
expected_to_table_hash = Hash(
bytes.fromhex(expected_to_table_hash_raw))
# Verify the proof to the table:
verify_proof_to_table(proof_to_table, expected_to_table_hash)
# `MapProof` to the wallet as a part of the Cryptocurrency schema:
proof_to_wallet = wallet_info["wallet_proof"]["to_wallet"]
# Expected hash of the proof to the wallet is the value stored in the
# proof to the table:
expected_to_wallet_hash_raw = wallet_info["wallet_proof"]["to_table"][
"entries"][0]["value"]
expected_to_wallet_hash = Hash(
bytes.fromhex(expected_to_wallet_hash_raw))
# Verify the proof to the wallet:
verify_proof_to_wallet(proof_to_wallet, expected_to_wallet_hash)
# `ListProof` for the transactions associtated with the wallet:
proof_wallet_history = wallet_info["wallet_history"]["proof"]
# Expected hash for the wallet history is the hash stored in the proof
# to the wallet:
expected_history_hash_raw = wallet_info["wallet_proof"]["to_wallet"][
"entries"][0]["value"]["history_hash"]
expected_history_hash = Hash(bytes(expected_history_hash_raw["data"]))
# Verify the proof for the wallet history:
verify_wallet_history_proof(proof_wallet_history,
expected_history_hash)
