def complete_recovery(self, member_id, recovery_operations, privileged_key,
crypto_engine: CryptoEngine):
standard_key = crypto_engine.generate_key(Key.STANDARD)
low_key = crypto_engine.generate_key(Key.LOW)
signer = crypto_engine.create_signer(Key.PRIVILEGED)
operations = []
for recovery_operation in recovery_operations:
member_operation = MemberOperation(recover=recovery_operation)
operations.append(member_operation)
operations.extend(
utils.to_add_key_operations(
[privileged_key, standard_key, low_key]))
get_member_request = GetMemberRequest(member_id=member_id)
with self._unauthenticated_channel as channel:
get_member_response = channel.stub.GetMember(get_member_request)
member_update = MemberUpdate(
member_id=member_id,
prev_hash=get_member_response.member.last_hash,
operations=operations)
signature = Signature(
key_id=signer.id,
member_id=member_id,
signature=signer.sign_proto_message(member_update))
update_member_request = UpdateMemberRequest(update=member_update,
update_signature=signature)
with self._unauthenticated_channel as channel:
member_update_response = channel.stub.UpdateMember(
update_member_request)
return member_update_response.member
def use_default_recovery_rule(self):
signer = self.crypto_engine.create_signer(Key.PRIVILEGED)
member = self.get_member(self.member_id)
default_agent_request = GetDefaultAgentRequest()
with self._channel as channel:
default_agent_response = channel.stub.GetDefaultAgent(
default_agent_request
)
rule = RecoveryRule(primary_agent=default_agent_response.member_id)
recovery_rule_operation = MemberRecoveryRulesOperation(
recovery_rule=rule
)
operation = MemberOperation(recovery_rules=recovery_rule_operation)
member_update = MemberUpdate(
member_id=member.id,
prev_hash=member.last_hash,
operations=[operation]
)
signature = Signature(
key_id=signer.id,
member_id=member.id,
signature=signer.sign_proto_message(member_update)
)
request = UpdateMemberRequest(
update=member_update, update_signature=signature
)
with self._channel as channel:
response = channel.stub.UpdateMember(request)
return response # check
def authorize_recovery(self, authorization):
signer = self.crypto_engine.create_signer(Key.PRIVILEGED)
signature = Signature(
key_id=signer.id,
member_id=self.member_id,
signature=signer.sign_proto_message(authorization)
)
return signature
def create_member(self, member_id, operations, metadata, signer):
update = MemberUpdate(member_id=member_id, operations=operations)
signature = Signature(key_id=signer.id,
member_id=member_id,
signature=signer.sign_proto_message(update))
request = UpdateMemberRequest(update=update,
update_signature=signature,
metadata=metadata)
# print("REQUEST: " + utils.proto_message_to_bytes(request).decode())
with self._unauthenticated_channel as channel:
response = channel.stub.UpdateMember(request)
return response.member
def cancel_token(self, token):
signer = self.crypto_engine.create_signer(Key.LOW)
signature = Signature(
member_id=self.member_id,
key_id=signer.id,
signature=signer.sign(
self._token_action_from_token(token, 'cancelled').encode()
)
)
request = CancelTokenRequest(token_id=token.id, signature=signature)
with self._channel as channel:
response = channel.stub.CancelToken(request)
return response.result
def create_transfer(self, payload):
signer = self.crypto_engine.create_signer(Key.LOW)
payload_signature = Signature(
member_id=self.member_id,
key_id=signer.id,
signature=signer.sign_proto_message(payload)
)
request = CreateTransferRequest(
payload=payload, payload_signature=payload_signature
)
with self._channel as channel:
response = channel.stub.CreateTransfer(request)
return response.transfer
def endorse_token(self, token, key_level):
signer = self.crypto_engine.create_signer(key_level)
signature = Signature(
key_id=signer.id,
member_id=self.member_id,
signature=signer.sign(
self._token_action_from_token(token, 'endorsed').encode()
)
)
request = EndorseTokenRequest(token_id=token.id, signature=signature)
with self._channel as channel:
response = channel.stub.EndorseToken(request)
return response.result
def add_address(self, name, address):
signer = self.crypto_engine.create_signer(Key.LOW)
signature = Signature(
key_id=signer.id,
member_id=self.member_id,
signature=signer.sign_proto_message(address)
)
request = AddAddressRequest(
name=name, address=address, address_signature=signature
)
with self._channel as channel:
response = channel.stub.AddAddress(request)
return response.address
def remove_trusted_beneficiary(self, payload):
signer = self.crypto_engine.create_signer(Key.STANDARD)
signature = Signature(
key_id=signer.id,
member_id=self.member_id,
signature=signer.sign_proto_message(payload)
)
trusted_beneficiary = TrustedBeneficiary(
payload=payload, signature=signature
)
request = RemoveTrustedBeneficiaryRequest(
trusted_beneficiary=trusted_beneficiary
)
with self._channel as channel:
response = channel.stub.RemoveTrustedBeneficiary(request)
return response # TODO: check
def create(cls, callback_url):
query = urlsplit(callback_url).query
params = {k: v[0] for k, v in parse_qs(query).items()}
if cls.TOKEN_ID_FIELD not in params or cls.STATE_FIELD not in params:
raise CallbackParametersError(
"Invalid or missing parameters in token request query."
)
token_id = params[cls.TOKEN_ID_FIELD]
state_json = json.loads(params[cls.STATE_FIELD])
signature_json = json.loads(params[cls.SIGNATURE_FIELD])
signature = Signature(
member_id=signature_json['memberId'],
key_id=signature_json['keyId'],
signature=signature_json['signature']
)
return cls(token_id, state_json, signature)
def complete_recovery_with_default_rule(self, member_id, verification_id,
code, crypto_engine: CryptoEngine):
privileged_key = crypto_engine.generate_key(Key.PRIVILEGED)
standard_key = crypto_engine.generate_key(Key.STANDARD)
low_key = crypto_engine.generate_key(Key.LOW)
signer = crypto_engine.create_signer(Key.PRIVILEGED)
complete_request = CompleteRecoveryRequest(
verification_id=verification_id, code=code, key=privileged_key)
with self._unauthenticated_channel as channel:
complete_response = channel.stub.CompleteRecovery(complete_request)
member_request = GetMemberRequest(member_id=member_id)
with self._unauthenticated_channel as channel:
member_response = channel.stub.GetMember(member_request)
member_recovery_operation = MemberOperation(
recover=complete_response.recovery_entry)
operations = utils.to_add_key_operations(
[privileged_key, standard_key, low_key])
operations.append(member_recovery_operation)
member_update = MemberUpdate(
member_id=member_id,
prev_hash=member_response.member.last_hash,
operations=operations)
signature = Signature(
key_id=signer.id,
member_id=member_id,
signature=signer.sign_proto_message(member_update))
update_member_request = UpdateMemberRequest(update=member_update,
update_signature=signature)
with self._unauthenticated_channel as channel:
member_update_response = channel.stub.UpdateMember(
update_member_request)
return member_update_response.member
def update_member(self, member, operations, metadata=None):
signer = self.crypto_engine.create_signer(Key.PRIVILEGED)
member_update = MemberUpdate(
member_id=member.id,
prev_hash=member.last_hash,
operations=operations
)
signature = Signature(
member_id=member.id,
key_id=signer.id,
signature=signer.sign_proto_message(member_update)
)
if metadata is None:
metadata = []
request = UpdateMemberRequest(
update=member_update,
update_signature=signature,
metadata=metadata
)
with self._channel as channel:
response = channel.stub.UpdateMember(request)
return response.member