def delete(self):
try:
# Check if Organization exists
(found, _, _, _, _, _) = self._getorganizationbyname()
if not found:
self._printerr("\n{} doesn't exist!\n".format(self.args.name))
return
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
cmd = ContractCommand(config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="deleteOrganization",
contract_def=registry_contract_def)(
type_converter("bytes32")(
self.args.name)),
out_f=self.err_f,
err_f=self.err_f,
w3=self.w3,
ident=self.ident)
self._printerr(
"Creating transaction to delete organization {}...\n".format(
self.args.name))
try:
cmd.transact()
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if {} exists and you are its owner.\n"
.format(self.args.name))
self._error(e)
except Exception as e:
self._printerr("\nTransaction error!\nHINT: Check ORG_NAME.\n")
self._error(e)
def get_contract_address(cmd, contract_name, error_message=None):
# try to get from command line argument at or contractname_at
a = "at"
if (hasattr(cmd.args, a) and getattr(cmd.args, a)):
return cmd.w3.toChecksumAddress(getattr(cmd.args, a))
# try to get from command line argument contractname_at
a = "%s_at" % contract_name.lower()
if (hasattr(cmd.args, a) and getattr(cmd.args, a)):
return cmd.w3.toChecksumAddress(getattr(cmd.args, a))
# try to get from current session configuration
rez = cmd.config.get_session_field("current_%s_at" %
(contract_name.lower()),
exception_if_not_found=False)
if rez:
return cmd.w3.toChecksumAddress(rez)
error_message = error_message or "Fail to read %s address from \"networks\", you should specify address by yourself via --%s_at parameter" % (
contract_name, contract_name.lower())
chain_id = cmd.w3.version.network # this will raise exception if endpoint is invalid
# try to take address from networks
try:
contract_def = get_contract_def(contract_name)
networks = contract_def["networks"]
contract_address = networks.get(chain_id, {}).get("address", None)
if (not contract_address):
raise Exception()
contract_address = cmd.w3.toChecksumAddress(contract_address)
except:
raise Exception(error_message)
return contract_address
def add_contract_function_options(parser, contract_name):
add_contract_identity_arguments(parser)
contract_def = get_contract_def(contract_name)
parser.set_defaults(contract_def=contract_def)
fns = []
for fn in filter(lambda e: e["type"] == "function", contract_def["abi"]):
fns.append({
"name": fn["name"],
"named_inputs": [(i["name"], i["type"]) for i in fn["inputs"] if i["name"] != ""],
"positional_inputs": [i["type"] for i in fn["inputs"] if i["name"] == ""]
})
if len(fns) > 0:
subparsers = parser.add_subparsers(title="{} functions".format(contract_name), metavar="FUNCTION")
subparsers.required = True
for fn in fns:
fn_p = subparsers.add_parser(fn["name"], help="{} function".format(fn["name"]))
fn_p.set_defaults(fn="call")
fn_p.set_defaults(contract_function=fn["name"])
for i in fn["positional_inputs"]:
fn_p.add_argument(i, action=AppendPositionalAction, type=type_converter(i), metavar=i.upper())
for i in fn["named_inputs"]:
fn_p.add_argument("contract_named_input_{}".format(i[0]), type=type_converter(i[1]),
metavar="{}_{}".format(i[0].lstrip("_"), i[1].upper()))
fn_p.add_argument("--transact", action="store_const", const="transact", dest="fn",
help="invoke contract function as transaction")
add_transaction_arguments(fn_p)
def _get_channel_state_from_blockchain(self, channel_id):
abi = get_contract_def("MultiPartyEscrow")
channel_abi = abi_get_element_by_name(abi, "channels")
channel = self.call_contract_command("MultiPartyEscrow", "channels",
[channel_id])
channel = abi_decode_struct_to_dict(channel_abi, channel)
return channel
def _get_channel_state_from_blockchain(self, channel_id):
abi = get_contract_def("MultiPartyEscrow")
channel_abi = abi_get_element_by_name(abi, "channels")
channel = self.call_contract_command("MultiPartyEscrow", "channels", [channel_id])
channel = abi_decode_struct_to_dict(channel_abi, channel)
channel["channelId"] = channel_id
return channel
def _get_all_filtered_channels(self, topics_without_signature):
""" get all filtered chanels from blockchain logs """
mpe_address = self.get_mpe_address()
event_signature = self.ident.w3.sha3(text="ChannelOpen(uint256,uint256,address,address,address,bytes32,uint256,uint256)").hex()
topics = [event_signature] + topics_without_signature
logs = self.ident.w3.eth.getLogs({"fromBlock" : self.args.from_block, "address" : mpe_address, "topics" : topics})
abi = get_contract_def("MultiPartyEscrow")
event_abi = abi_get_element_by_name(abi, "ChannelOpen")
channels_ids = [get_event_data(event_abi, l)["args"]["channelId"] for l in logs]
return channels_ids
def read_default_contract_address(w3, contract_name):
try :
chain_id = w3.version.network # this will raise exception if endpoint is invalid
contract_def = get_contract_def(contract_name)
networks = contract_def["networks"]
contract_address = networks.get(chain_id, {}).get("address", None)
if (not contract_address):
raise Exception()
contract_address = w3.toChecksumAddress(contract_address)
except:
raise Exception()
return contract_address
def read_default_contract_address(w3, contract_name):
try:
chain_id = w3.version.network # this will raise exception if endpoint is invalid
contract_def = get_contract_def(contract_name)
networks = contract_def["networks"]
contract_address = networks.get(chain_id, {}).get("address", None)
if (not contract_address):
raise Exception()
contract_address = w3.toChecksumAddress(contract_address)
except:
raise Exception()
return contract_address
def create(self):
try:
# Check if Organization already exists
(found, _, _, _, _, _) = self._getorganizationbyname()
if found:
self._printerr("\n{} already exists!\n".format(self.args.name))
return
members = []
if self.args.members:
members_split = self.args.members.split(',')
for idx, m in enumerate(members_split):
members.append(
str(m).replace("[", "").replace("]", "").lower())
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
cmd = ContractCommand(
config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="createOrganization",
contract_def=registry_contract_def)(
type_converter("bytes32")(self.args.name), [
type_converter("address")(member)
for member in members
]),
out_f=self.err_f,
err_f=self.err_f,
w3=self.w3,
ident=self.ident)
self._printerr(
"Creating transaction to create organization {}...\n".format(
self.args.name))
try:
cmd.transact()
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if {} already exists.\n"
.format(self.args.name))
self._error(e)
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if address is a 40-length hexadecimal.\n"
)
self._error(e)
def get_organization_list(iblockchain):
response = None
try:
registry_contract_def = get_contract_def("Registry")
registry_address = iblockchain._getstring("registry_at")
response = ContractCommand(config=iblockchain.config,
args=iblockchain.get_contract_argser(
contract_address=registry_address,
contract_function="listOrganizations",
contract_def=registry_contract_def)(),
out_f=None,
err_f=None,
w3=iblockchain.w3,
ident=iblockchain.ident).call()
except Exception as e:
print(e)
return response
def change_owner(self):
try:
# Check if Organization exists
(found, _, owner, _, _, _) = self._getorganizationbyname()
if not found:
self._printerr("\n{} doesn't exist!\n".format(self.args.name))
return
new_owner = self.args.owner.lower()
new_owner = new_owner if new_owner.startswith(
"0x") else "0x" + new_owner
if new_owner == owner:
self._printerr("\n{} is the owner of!\n".format(
self.args.owner, self.args.name))
return
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
cmd = ContractCommand(
config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="changeOrganizationOwner",
contract_def=registry_contract_def)(
type_converter("bytes32")(self.args.name),
type_converter("address")(self.args.owner)),
out_f=self.err_f,
err_f=self.err_f,
w3=self.w3,
ident=self.ident)
self._printerr(
"Creating transaction to change organization {}'s owner...\n".
format(self.args.name))
try:
cmd.transact()
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if {} already exists.\n"
.format(self.args.name))
self._error(e)
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if address is a 40-length hexadecimal.\n"
)
self._error(e)
def get_service_price(iblockchain):
current_price = None
try:
agent_contract_def = get_contract_def("Agent")
agent_address = iblockchain.args.agent_address
current_price = ContractCommand(
config=iblockchain.config,
args=iblockchain.get_contract_argser(
contract_address=agent_address,
contract_function="currentPrice",
contract_def=agent_contract_def)(),
out_f=None,
err_f=None,
w3=iblockchain.w3,
ident=iblockchain.ident).call()
except Exception as e:
print(e)
return current_price
def get_ContractCommand(self, contract_name, contract_address, contract_fn, contract_params, is_silent = True):
contract_def = get_contract_def(contract_name)
if (is_silent):
out_f = None
err_f = None
else:
out_f = self.out_f
err_f = self.err_f
return ContractCommand(config= self.config,
args = self.get_contract_argser(
contract_address = contract_address,
contract_function = contract_fn,
contract_def = contract_def,
contract_name = contract_name)(*contract_params),
out_f = out_f,
err_f = err_f,
w3 = self.w3,
ident = self.ident)
def get_metadata_uri(iblockchain):
response = None
try:
agent_contract_def = get_contract_def("Agent")
agent_address = iblockchain.args.agent_address
response = ContractCommand(config=iblockchain.config,
args=iblockchain.get_contract_argser(
contract_address=agent_address,
contract_function="metadataURI",
contract_def=agent_contract_def)(),
out_f=None,
err_f=None,
w3=iblockchain.w3,
ident=iblockchain.ident).call()
return response
except Exception as e:
print(e)
return response
def _get_all_filtered_channels(self, topics_without_signature):
""" get all filtered chanels from blockchain logs """
mpe_address = self.get_mpe_address()
event_signature = self.ident.w3.sha3(
text=
"ChannelOpen(uint256,uint256,address,address,address,bytes32,uint256,uint256)"
).hex()
topics = [event_signature] + topics_without_signature
logs = self.ident.w3.eth.getLogs({
"fromBlock": self.args.from_block,
"address": mpe_address,
"topics": topics
})
abi = get_contract_def("MultiPartyEscrow")
event_abi = abi_get_element_by_name(abi, "ChannelOpen")
channels_ids = [
get_event_data(event_abi, l)["args"]["channelId"] for l in logs
]
return channels_ids
def list_services(self):
try:
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
try:
(found, org_service_list) = ContractCommand(
config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="listServicesForOrganization",
contract_def=registry_contract_def)(
type_converter("bytes32")(self.args.name)),
out_f=None,
err_f=None,
w3=self.w3,
ident=self.ident).call()
if found:
if org_service_list:
self._printerr("\nList of {}'s Services:".format(
self.args.name))
for idx, org_service in enumerate(org_service_list):
self._printerr("- {}".format(
org_service.partition(b"\0")[0].decode(
"utf-8")))
else:
self._printerr(
"\n{} exists but has no registered services.".
format(self.args.name))
else:
self._printerr("\n{} not registered on network.".format(
self.args.name))
except Exception as e:
self._printerr(
"\nCall error!\nHINT: Check your identity and session.\n")
self._error(e)
except Exception as e:
self._printerr("\nTransaction error!\nHINT: Check ORG_NAME.\n")
self._error(e)
def get_service_registration(iblockchain):
response = None
try:
registry_contract_def = get_contract_def("Registry")
registry_address = iblockchain._getstring("registry_at")
org_name = iblockchain.args.organization_name
serv_name = iblockchain.args.service_name
return ContractCommand(
config=iblockchain.config,
args=iblockchain.get_contract_argser(
contract_address=registry_address,
contract_function="getServiceRegistrationByName",
contract_def=registry_contract_def)(org_name,
serv_name),
out_f=None,
err_f=None,
w3=iblockchain.w3,
ident=iblockchain.ident).call()
except Exception as e:
print(e)
return response
def _getorganizationbyname(self):
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
try:
return ContractCommand(
config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="getOrganizationByName",
contract_def=registry_contract_def)(
type_converter("bytes32")(self.args.name)),
out_f=None,
err_f=None,
w3=self.w3,
ident=self.ident).call()
except Exception as e:
self._printerr(
"\nCall _getorganizationbyname() error!\nHINT: Check your identity and session.\n"
)
self._error(e)
def print_my_channels(self):
# TODO: check that it is faster to use events to get all channels with the given sender (instead of using channels directly)
event_signature = self.ident.w3.sha3(text="EventChannelOpen(uint256,address,address,uint256)").hex()
my_address_padded = pad_hex(self.ident.address.lower(), 256)
logs = self.ident.w3.eth.getLogs({"fromBlock" : self.args.from_block,
"address" : self.args.mpe_address.lower(),
"topics" : [event_signature, my_address_padded]})
# If we are sure that ABI will be fixed forever we can do like this:
# channels_ids = [int(l['data'],16) for l in logs]
abi = get_contract_def("MultiPartyEscrow")
event_abi = abi_get_element_by_name(abi, "EventChannelOpen")
channels_ids = [get_event_data(event_abi, l)["args"]["channelId"] for l in logs]
channel_abi = abi_get_element_by_name(abi, "channels")
self._printout("#id nonce recipient groupId value expiration(blocks)")
for i in channels_ids:
channel = self.call_contract_command("MultiPartyEscrow", self.args.mpe_address, "channels", [i])
channel = abi_decode_struct_to_dict(channel_abi, channel)
self._printout("%i %i %s %i %i %i"%(i, channel["nonce"], channel["recipient"], channel["groupId"],
channel["value"], channel["expiration"]))
def add_contract_function_options(parser, contract_name):
add_contract_identity_arguments(parser)
contract_def = get_contract_def(contract_name)
parser.set_defaults(contract_def=contract_def)
parser.set_defaults(contract_name=contract_name)
fns = []
for fn in filter(lambda e: e["type"] == "function", contract_def["abi"]):
fns.append({
"name": fn["name"],
"named_inputs": [(i["name"], i["type"]) for i in fn["inputs"] if i["name"] != ""],
"positional_inputs": [i["type"] for i in fn["inputs"] if i["name"] == ""]
})
if len(fns) > 0:
subparsers = parser.add_subparsers(title="{} functions".format(contract_name), metavar="FUNCTION")
subparsers.required = True
for fn in fns:
fn_p = subparsers.add_parser(fn["name"], help="{} function".format(fn["name"]))
fn_p.set_defaults(fn="call")
fn_p.set_defaults(contract_function=fn["name"])
for i in fn["positional_inputs"]:
fn_p.add_argument(i,
action=AppendPositionalAction,
type=type_converter(i),
metavar=i.upper())
for i in fn["named_inputs"]:
fn_p.add_argument("contract_named_input_{}".format(i[0]),
type=type_converter(i[1]),
metavar="{}_{}".format(i[0].lstrip("_"), i[1].upper()))
fn_p.add_argument("--transact",
action="store_const",
const="transact",
dest="fn",
help="Invoke contract function as transaction")
add_transaction_arguments(fn_p)
def print_all_channels_my(self):
# TODO: check that it is faster to use events to get all channels with the given sender (instead of using channels directly)
mpe_address = self.get_mpe_address()
event_signature = self.ident.w3.sha3(
text=
"ChannelOpen(uint256,address,address,bytes32,address,uint256,uint256)"
).hex()
my_address_padded = pad_hex(self.ident.address.lower(), 256)
logs = self.ident.w3.eth.getLogs({
"fromBlock":
self.args.from_block,
"address":
mpe_address,
"topics": [event_signature, my_address_padded]
})
# If we are sure that ABI will be fixed forever we can do like this:
# channels_ids = [int(l['data'],16) for l in logs]
abi = get_contract_def("MultiPartyEscrow")
event_abi = abi_get_element_by_name(abi, "ChannelOpen")
channels_ids = [
get_event_data(event_abi, l)["args"]["channelId"] for l in logs
]
self._print_channels_from_blockchain(channels_ids)
def list(self):
try:
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
org_list = ContractCommand(
config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="listOrganizations",
contract_def=registry_contract_def)(),
out_f=None,
err_f=None,
w3=self.w3,
ident=self.ident).call()
self._printerr("\nList of Organizations:")
for idx, organization in enumerate(org_list):
self._printerr("- {}".format(
organization.partition(b"\0")[0].decode("utf-8")))
except Exception as e:
self._printerr(
"\nCall error!\nHINT: Check your identity and session.\n")
self._error(e)
def rem_members(self):
try:
# Check if Organization exists and member is part of it
(found, _, _, members, _, _) = self._getorganizationbyname()
if not found:
self._printerr("\n{} doesn't exist!\n".format(self.args.name))
return
rem_members = []
members_split = self.args.members.split(',')
for idx, m in enumerate(members_split):
member_tmp = str(m).replace("[", "").replace("]", "").lower()
member_tmp = member_tmp if member_tmp.startswith(
"0x") else "0x" + member_tmp
rem_members.append(member_tmp)
members = [member.lower() for member in members]
for idx, rem_member in enumerate(rem_members[:]):
if rem_member not in members:
self._printerr(
"{} is not a member of organization {}".format(
rem_member, self.args.name))
rem_members.remove(rem_member)
if rem_members:
registry_contract_def = get_contract_def("Registry")
registry_address = self._getstring("registry_at")
cmd = ContractCommand(
config=self.config,
args=self.get_contract_argser(
contract_address=registry_address,
contract_function="removeOrganizationMembers",
contract_def=registry_contract_def)(
type_converter("bytes32")(self.args.name), [
type_converter("address")(member)
for member in rem_members
]),
out_f=self.err_f,
err_f=self.err_f,
w3=self.w3,
ident=self.ident)
self._printerr(
"Creating transaction to remove {} members from organization {}...\n"
.format(len(rem_members), self.args.name))
try:
cmd.transact()
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if {} already exists and you are its owner.\n"
.format(self.args.name))
self._error(e)
else:
self._printerr("No member was removed from {}!\n".format(
self.args.name))
except Exception as e:
self._printerr(
"\nTransaction error!\nHINT: Check if address is a 40-length hexadecimal.\n"
)
self._error(e)
