def __init__(self, source_public, user, peer_address, source_private=None):
assert (user or peer_address)
self.used = False
self.source_public_key = source_public
if None == source_private:
self.private_key = IrohaCrypto.private_key()
self.public_key = IrohaCrypto.derive_public_key(self.private_key)
else:
self.private_key = source_private
self.public_key = IrohaCrypto.derive_public_key(source_private)
assert (source_public == self.public_key.decode('utf-8'))
self.user = user
self.peer_address = peer_address
def save_to_wallet_db(account_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = account_id + ".priv"
public_key_file = account_id + ".pub"
open(private_key_file, "wb+").write(private_key)
open(public_key_file, "wb+").write(public_key)
def __init__(self, account_name, domain):
self.account_name = account_name
self.domain = domain
self.full_name = f"{self.account_name}@{self.domain}"
self.__private_key = IrohaCrypto.private_key()
self.public_key = IrohaCrypto.derive_public_key(self.__private_key)
self.iroha = Iroha(self.full_name)
def __init__(self, source_public, user, peer_address):
assert (user or peer_address)
self.source_public_key = source_public
self.private_key = IrohaCrypto.private_key()
self.public_key = IrohaCrypto.derive_public_key(self.private_key)
self.user = user
self.peer_address = peer_address
def create_agent(self, company_name, agent_name):
user_private_key = IrohaCrypto.private_key()
user_public_key = IrohaCrypto.derive_public_key(user_private_key)
commands = [
self.iroha.command('CreateAccount',
account_name=agent_name,
domain_id=company_name,
public_key=user_public_key),
self.iroha.command(
'GrantPermission',
account_id=get_full_acc(agent_name, company_name),
permission=primitive_pb2.can_set_my_account_detail),
self.iroha.command('AddSignatory',
account_id=self.admin_account,
public_key=user_public_key)
]
transaction = self.iroha.transaction(commands)
IrohaCrypto.sign_transaction(transaction, self.admin_private_key)
self.__send_transaction_and_print_status(transaction)
if self.__send_transaction_and_print_status(
transaction) == "COMMITTED":
return "Your private key: " + str(
user_private_key) + " Your public key: " + str(
user_public_key), 201
else:
return 'Internal Error', 500
def save_keys_to_file(account_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = account_id + '.priv'
public_key_file = account_id + '.pub'
open(private_key_file, 'wb+').write(private_key)
open(public_key_file, 'wb+').write(public_key)
def genesis_tx():
test_permissions = [
primitive_pb2.can_grant_can_transfer_my_assets,
primitive_pb2.can_receive, primitive_pb2.can_transfer
]
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.extend([
iroha.command('CreateAccount',
account_name='bob',
domain_id='test',
public_key=IrohaCrypto.derive_public_key(bob['key'])),
iroha.command('CreateAsset',
asset_name='coin',
domain_id='test',
precision=2),
iroha.command('AddAssetQuantity',
asset_id='coin#test',
amount='100.00'),
iroha.command('TransferAsset',
src_account_id=admin['id'],
dest_account_id=alice['id'],
asset_id='coin#test',
description='init top up',
amount='90.00')
])
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
def genesis_block(admin, alice, test_permissions, multidomain=False):
"""
Compose a set of common for all tests' genesis block transactions
:param admin: dict of id and private key of admin
:param alice: dict of id and private key of alice
:param test_permissions: permissions for users in test domain
:param multidomain: admin and alice accounts will be created in
different domains and the first domain users will have admin right
by default if True
:return: a list of Iroha.command's
"""
peer = primitive_pb2.Peer()
peer.address = '0.0.0.0:50541'
peer.peer_key = IrohaCrypto.derive_public_key(admin['key'])
commands = [
command('AddPeer', peer=peer),
command('CreateRole',
role_name='admin_role',
permissions=all_permissions()),
command('CreateRole',
role_name='test_role',
permissions=test_permissions)
]
if multidomain:
commands.append(
command('CreateDomain',
domain_id='first',
default_role='admin_role'))
commands.extend([
command('CreateDomain',
domain_id='second' if multidomain else 'test',
default_role='test_role'),
command('CreateAccount',
account_name='admin',
domain_id='first' if multidomain else 'test',
public_key=IrohaCrypto.derive_public_key(admin['key'])),
command('CreateAccount',
account_name='alice',
domain_id='second' if multidomain else 'test',
public_key=IrohaCrypto.derive_public_key(alice['key']))
])
if not multidomain:
commands.append(
command('AppendRole',
account_id=admin['id'],
role_name='admin_role'))
return commands
def generate_new_node_keys(node_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = node_id + ".priv"
public_key_file = node_id + ".pub"
open(private_key_file, "wb+").write(private_key)
open(public_key_file, "wb+").write(public_key)
return public_key
def generate_new_node_keys(node_id):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
private_key_file = node_id + '.priv'
public_key_file = node_id + '.pub'
open(private_key_file, 'wb+').write(private_key)
open(public_key_file, 'wb+').write(public_key)
return public_key
def genesis_tx():
test_permissions = [primitive_pb2.can_grant_can_remove_my_signatory]
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.append(
iroha.command('CreateAccount', account_name='bob', domain_id='test',
public_key=IrohaCrypto.derive_public_key(bob['key'])))
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
def remove_signatory_tx():
tx = iroha.transaction([
iroha.command('RemoveSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(alice['key']))
],
creator_account=bob['id'])
IrohaCrypto.sign_transaction(tx, bob['key'])
return tx
def __init__(self, private_key, name, domain, ip, public_info):
self.public_key = IrohaCrypto.derive_public_key(private_key)
self.name = name
self.domain = domain
self.domain.name = domain.name
ip_address = ip + ':50051'
self.network = IrohaGrpc(ip_address)
if domain.name == 'public':
self.public_info = public_info
def add_signatory_tx():
extra_key = IrohaCrypto.private_key()
tx = iroha.transaction([
iroha.command('AddSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(extra_key))
],
creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
def add_peer_tx():
peer_key = IrohaCrypto.private_key()
peer = primitive_pb2.Peer()
peer.address = '192.168.10.10:50541'
peer.peer_key = IrohaCrypto.derive_public_key(peer_key)
tx = iroha.transaction([
iroha.command('AddPeer', peer=peer)
], creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
def genesis_tx():
test_permissions = [primitive_pb2.can_set_quorum]
extra_key = IrohaCrypto.private_key()
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.append(
iroha.command('AddSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(extra_key)))
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
def CreateAccount(self, accName):
user = User()
user.Name = accName + "@" + "domain"
user.PrivKey = IrohaCrypto.private_key()
user.PubKey = IrohaCrypto.derive_public_key(user.PrivKey)
tx = self.iroha.transaction([
self.iroha.command('CreateAccount', account_name=accName, domain_id='domain',
public_key=user.PubKey)
])
IrohaCrypto.sign_transaction(tx, self.admin_private_key)
self.SendTxAndPrintstatus(tx)
users.append(user)
def grant_can_set_my_quorum_tx():
extra_key = IrohaCrypto.private_key()
tx = iroha.transaction([
iroha.command('GrantPermission',
account_id=bob['id'],
permission=primitive_pb2.can_set_my_quorum),
iroha.command('AddSignatory',
account_id=alice['id'],
public_key=IrohaCrypto.derive_public_key(extra_key))
],
creator_account=alice['id'])
IrohaCrypto.sign_transaction(tx, alice['key'])
return tx
async def create_accounts(i):
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
user_name = str(i)
init_cmds = [
iroha.command('CreateAccount',
account_name=user_name,
domain_id='test',
public_key=public_key)
]
init_tx = iroha.transaction(init_cmds, creator_account='admin@test')
ic.sign_transaction(init_tx, admin_private_key)
await send_transaction(init_tx)
def genesis_tx():
test_permissions = [primitive_pb2.can_append_role, primitive_pb2.can_add_peer]
second_role_permissions = [primitive_pb2.can_add_peer]
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.extend([
iroha.command('CreateRole', role_name='second_role', permissions=second_role_permissions),
iroha.command('CreateAccount', account_name='bob', domain_id='test',
public_key=IrohaCrypto.derive_public_key(bob['key'])),
iroha.command('AppendRole', account_id=alice['id'], role_name='second_role')
])
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
def add_user_to_db(userid,
guid,
conn,
tb_name=dbcfg['LEDGER_USER_TABLE_NAME']):
'''
Add a user to the Iroha ledger and the shared database.
N.B. userid should be in proper Iroha format, e.g. "user@domain".
The guid value (global platform-level user ID) should be passed from
the shared API, which will generate it.
'''
# check correct userid format
assert re.match(UID_PAT, userid) is not None, 'invalid userid format'
# empty placeholders for privkey / pubkey
privkey, pubkey = None, None
# check if userid already exists in SQL (for this ledger)
# this assumes that it is impossible to have user in SQL but not in Iroha...
if userid in get_user_data(conn)['LedgerUserID']:
warnings.warn('User already exists - nothing to add')
return
# check if userid already exists in Iroha (but not SQL yet)
if get_iroha_user_info(
userid).account_response.account.account_id != userid:
# we need to create a new account entirely
privkey = IrohaCrypto.private_key()
pubkey = IrohaCrypto.derive_public_key(privkey)
status = create_iroha_user_account(userid, pubkey)
# check status for correctness, throw if bad status
if status[0][0] == 'STATELESS_VALIDATION_FAILED':
warnings.warn('User create transaction failed - check tx format')
return
if status[0][0] == 'COMMITTED':
print('Successfully created user {} in Iroha'.format(userid))
# once we know that the account exists in Iroha, add it to SQL as well
ledgerid = get_ledgerids(conn, lname='Iroha')
if privkey is None:
privkey = ''
else:
privkey = str(privkey)[2:-1] # string representation of hex bytes
if pubkey is None:
pubkey = ''
else:
pubkey = str(pubkey)[2:-1] # string representation of hex bytes
user_info = (guid, ledgerid, userid, privkey, pubkey)
sql_qry = 'INSERT INTO {} VALUES (?,?,?,?,?)'.format(tb_name)
c = conn.cursor()
c.execute(sql_qry, user_info)
conn.commit()
print('Added user information for userid {} to SQL'.format(userid))
def create_client(self, client_name):
user_private_key = IrohaCrypto.private_key()
user_public_key = IrohaCrypto.derive_public_key(user_private_key)
commands = [
self.iroha.command('CreateAccount', account_name=client_name, domain_id="test",
public_key=user_public_key),
]
transaction = self.iroha.transaction(commands)
IrohaCrypto.sign_transaction(transaction, self.admin_private_key)
self.__send_transaction_and_print_status(transaction)
tx = self.iroha.transaction([
self.iroha.command('GrantPermission', account_id='admin@test',
permission=primitive_pb2.can_set_my_account_detail)
])
IrohaCrypto.sign_transaction(tx, user_private_key)
if self.__send_transaction_and_print_status(transaction) == "COMMITTED":
return "Your key: " + user_private_key, 201
else:
return 'Internal Error', 500
if sys.version_info[0] < 3:
raise Exception('Python 3 or a more recent version is required.')
IROHA_HOST_ADDR = os.getenv('IROHA_HOST_ADDR', '127.0.0.1')
IROHA_PORT = os.getenv('IROHA_PORT', '50051')
net = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR, IROHA_PORT))
# Define necessary constants we will need throughout the app
ADMIN_ACCOUNT_ID = os.getenv('ADMIN_ACCOUNT_ID', 'admin@test')
ADMIN_PRIVATE_KEY = os.getenv(
'ADMIN_PRIVATE_KEY',
'72a9eb49c0cd469ed64f653e33ffc6dde475a6b9fd8be615086bce7c44b5a8f8')
ADMIN_PUBLIC_KEY = ic.derive_public_key(ADMIN_PRIVATE_KEY)
GAME_ACCOUNT_ID = 'match@games'
GAME_PRIVATE_KEY = '9b965ebbd194dc538735310740e6667cb8222811c5e4e8e917a6fbe77deeb6dc'
GAME_PUBLIC_KEY = ic.derive_public_key(GAME_PRIVATE_KEY)
ALICE_ACCOUNT_ID = 'alice@games'
ALICE_PRIVATE_KEY = '7384819f00d820e291f0dc9f1fce827d9f94ad508bf5252fb310916465b94f17'
ALICE_PUBLIC_KEY = ic.derive_public_key(ALICE_PRIVATE_KEY)
BOB_ACCOUNT_ID = 'bob@games'
BOB_PRIVATE_KEY = '4125f29b841b6bab5ab9bc830e19629e86a51fcb77c9554fdf3d8af41780573b'
BOB_PUBLIC_KEY = ic.derive_public_key(BOB_PRIVATE_KEY)
iroha = Iroha(ADMIN_ACCOUNT_ID)
# BSMD configuration
######################
asset_id = 'fedcoin#federated'
# Replace localhost with an IP address of a node running the blockchain
network = IrohaGrpc('18.191.46.178:50051')
domain_id = 'federated'
admin_private_key = 'f101537e319568c765b2cc89698325604991dca57b9716b58016b253506cab70'
iroha = Iroha('admin@test')
default_role = 'user'
asset_name = 'fedcoin'
asset_precision = 2
# chief node
######################
chief_private_key = '054e294d86bedf9a43cf20542cade6e57addfd4294a276042be4ba83c73f8d9e'
chief_public_key = IrohaCrypto.derive_public_key(chief_private_key)
chief_name = 'chief'
chief_account_id = chief_name + '@' + domain_id
iroha_chief = Iroha('chief@federated')
# worker1 node
######################
worker1_private_key = '7a3a8efe3fbfac57af55e8d2a4b20e27b19444c4d240924dd1bd57701a5a0731'
worker1_public_key = IrohaCrypto.derive_public_key(worker1_private_key)
worker1_name = 'worker1'
worker1_account_id = worker1_name + '@' + domain_id
iroha_worker1 = Iroha('worker1@federated')
# worker2 node
# Copyright Soramitsu Co., Ltd. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
#
from iroha import Iroha, IrohaCrypto
from iroha import primitive_pb2
import commons
admin = commons.new_user('admin@test')
alice = commons.new_user('alice@test')
iroha = Iroha(admin['id'])
peer_key = IrohaCrypto.private_key()
peer = primitive_pb2.Peer()
peer.address = '192.168.10.10:50541'
peer.peer_key = IrohaCrypto.derive_public_key(peer_key)
@commons.hex
def genesis_tx():
test_permissions = [primitive_pb2.can_remove_peer]
genesis_commands = commons.genesis_block(admin, alice, test_permissions)
genesis_commands.append(Iroha.command('AddPeer', peer=peer))
tx = iroha.transaction(genesis_commands)
IrohaCrypto.sign_transaction(tx, admin['key'])
return tx
@commons.hex
def remove_peer_tx():
peer_key = IrohaCrypto.private_key()
def generate_keypair():
private_key = ic.private_key()
public_key = ic.derive_public_key(private_key)
return public_key, private_key
raise Exception("Python 3 or a more recent version is required.")
# Here is the information about the environment and admin account information:
IROHA_HOST_ADDR = os.getenv("IROHA_HOST_ADDR", "127.0.0.1")
IROHA_PORT = os.getenv("IROHA_PORT", "50051")
ADMIN_ACCOUNT_ID = os.getenv("ADMIN_ACCOUNT_ID", "admin@test")
ADMIN_PRIVATE_KEY = os.getenv(
"ADMIN_PRIVATE_KEY",
"f101537e319568c765b2cc89698325604991dca57b9716b58016b253506cab70",
)
iroha = Iroha(ADMIN_ACCOUNT_ID)
net = IrohaGrpc("{}:{}".format(IROHA_HOST_ADDR, IROHA_PORT))
test_private_key = IrohaCrypto.private_key()
test_public_key = IrohaCrypto.derive_public_key(test_private_key).decode(
"utf-8")
@integration_helpers.trace
def create_contract():
bytecode = "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"
"""Bytecode was generated using remix editor https://remix.ethereum.org/ from file role.sol. """
tx = iroha.transaction(
[iroha.command("CallEngine", caller=ADMIN_ACCOUNT_ID, input=bytecode)])
IrohaCrypto.sign_transaction(tx, ADMIN_PRIVATE_KEY)
net.send_tx(tx)
hex_hash = binascii.hexlify(IrohaCrypto.hash(tx))
for status in net.tx_status_stream(tx):
print(status)
return hex_hash
# IrohaGrpc net for peer 1, 2, 3
net_1 = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR_1, IROHA_PORT_1))
net_2 = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR_2, IROHA_PORT_2))
net_3 = IrohaGrpc('{}:{}'.format(IROHA_HOST_ADDR_3, IROHA_PORT_3))
# Admin Account loading with Admin's private key
ADMIN_PRIVATE_KEY = os.getenv(
'ADMIN_PRIVATE_KEY',
'f101537e319568c765b2cc89698325604991dca57b9716b58016b253506cab70')
# Admin's account
ADMIN_ACCOUNT_ID = os.getenv('ADMIN_ACCOUNT_ID', 'admin@test')
iroha_admin = Iroha(ADMIN_ACCOUNT_ID)
# Satoshi's crypto material generation
satoshi_private_key = IrohaCrypto.private_key()
satoshi_public_key = IrohaCrypto.derive_public_key(satoshi_private_key)
# Satoshi's account
SATOSHI_ACCOUNT_ID = os.getenv('SATOSHI_ACCOUNT_ID', 'satoshi@test')
iroha_satoshi = Iroha(SATOSHI_ACCOUNT_ID)
# Nakamoto's crypto material generation
nakamoto_private_key = IrohaCrypto.private_key()
nakamoto_public_key = IrohaCrypto.derive_public_key(nakamoto_private_key)
# Nakamoto's account
NAKAMOTO_ACCOUNT_ID = os.getenv('NAKAMOTO_ACCOUNT_ID', 'nakamoto@test')
iroha_nakamoto = Iroha(NAKAMOTO_ACCOUNT_ID)
print("""
Please ensure about MST in iroha config file.
""")
import json
if sys.version_info[0] < 3:
raise Exception('Python 3 or a more recent version is required.')
# For running this example first run the setup.py file
domain_individual = 'individual'
asset_individual = 'token'
domain_vehicle = 'vehicle'
asset_vehicle = 'coin'
# We will create 3 nodes to demonstrate functions of the BSMD.
#####################
# 2 Individual nodes
#####################
Johannes = 'johannes' # write al names with small caps
Johannes_private_key = 'e66dcb02367ae45449075839bbfedaf9ae4f9d579cb5601e82e0df341691ae2c'
Johannes_public_key = IrohaCrypto.derive_public_key(Johannes_private_key)
iroha_functions.create_account_with_assets(domain_individual, Johannes,
Johannes_public_key,
asset_individual, '1000')
#####################
David = 'david'
David_private_key = '2297b39c5331af17731d9bd6e04070e575b7ad9c18ca951cb6d5cd7b2abb240d'
David_public_key = IrohaCrypto.derive_public_key(David_private_key)
iroha_functions.create_account_with_assets(domain_individual, David,
David_public_key, asset_individual,
'1000')
# #####################
# # 1 Vehicle node
# #####################
Fiesta = 'fiesta'
Fiesta_private_key = '68e1e57b6ba06c45247937c3ea534a9560a63e6153a38a6ff0efef99ba774308'
import json
import logging
from iroha import Iroha, IrohaGrpc, IrohaCrypto
from math import exp, log
if sys.version_info[0] < 3:
raise Exception('Python 3 or a more recent version is required.')
logging.basicConfig(filename='slave_one.log',
filemode='w',
format='%(message)s',
level=logging.INFO)
# Slave node
slave_private_key = '7a3a8efe3fbfac57af55e8d2a4b20e27b19444c4d240924dd1bd57701a5a0731'
slave_public_key = IrohaCrypto.derive_public_key(slave_private_key)
slave_name = 'slave1'
domain_id = 'choice'
slave_account_id = slave_name + '@' + domain_id
iroha_slave = Iroha('slave1@choice')
# set the ip of one node in the iroha blockchain
asset_id = 'choicecoin#choice'
##################################
# Set corresponding IP
network = IrohaGrpc('18.216.92.47:50051')
##################################
def model(beta_car, beta_cost, beta_tt):
"""
