async def __perform_payments(self):
for i in range(len(self._addr_txos)):
try:
inputs, outputs = self._gen_input_output(1, self._payment_fees)
except NoReqDataAvailableException:
break
req, _ = await payment.build_payment_req(self._wallet_handle,
self._submitter_did,
json.dumps(inputs),
json.dumps(outputs), None)
resp = await ledger.sign_and_submit_request(
self._pool_handle, self._wallet_handle, self._submitter_did,
req)
ensure_is_reply(resp)
try:
receipt_infos_json = await payment.parse_payment_response(
self._payment_method, resp)
receipt_infos = json.loads(
receipt_infos_json) if receipt_infos_json else []
for receipt_info in receipt_infos:
self._receipts.append(receipt_info["receipt"])
except Exception:
pass
async def __set_fees_once(cls, wallet_handle, set_fees, test_did,
payment_method, trustee_dids, pool_handle):
if not len(cls.__pool_fees):
if set_fees:
fees_req = await payment.build_set_txn_fees_req(
wallet_handle, test_did, payment_method,
json.dumps(set_fees))
for d in trustee_dids:
fees_req = await ledger.multi_sign_request(
wallet_handle, d, fees_req)
fees_resp = await ledger.submit_request(pool_handle, fees_req)
ensure_is_reply(fees_resp)
get_fees_req = await payment.build_get_txn_fees_req(
wallet_handle, test_did, payment_method)
get_fees_resp = await ledger.sign_and_submit_request(
pool_handle, wallet_handle, test_did, get_fees_req)
fees_set = json.loads(await payment.parse_get_txn_fees_response(
payment_method, get_fees_resp))
cls.__pool_fees = {
cls._get_txn_type_by_alis(alias): fees_amount
for alias, fees_amount in fees_set.items()
}
return cls.__pool_fees
async def _did_init(self, seed):
if len(set(seed)) != self._req_num_of_trustees:
raise RuntimeError(
"Number of trustee seeds must be eq to {}".format(
self._req_num_of_trustees))
if len(set(seed)) != len(seed):
raise RuntimeError("Duplicated seeds not allowed")
for s in seed:
self._test_did, self._test_verk = await self.did_create_my_did(
self._wallet_handle, json.dumps({'seed': s}))
is_trustee = await self.__is_trustee(self._test_did)
if is_trustee is False:
raise Exception(
"Submitter role must be TRUSTEE since "
"submitter have to create additional trustees to mint sources."
)
if is_trustee is None:
assert len(self._trustee_dids) >= 1
nym_req = await ledger.build_nym_request(
self._trustee_dids[0], self._test_did, self._test_verk,
None, "TRUSTEE")
nym_resp = await ledger.sign_and_submit_request(
self._pool_handle, self._wallet_handle,
self._trustee_dids[0], nym_req)
ensure_is_reply(nym_resp)
self._trustee_dids.append(self._test_did)
async def _taa_aml_init(self):
self._logger.info("_taa_aml_init")
while True:
# Continuously check for latest TAA
get_aml = await ledger.build_get_acceptance_mechanisms_request(self._test_did, None, None)
reply = await ledger.sign_and_submit_request(self._pool_handle, self._wallet_handle, self._test_did,
get_aml)
ensure_is_reply(reply)
data = json.loads(reply)['result']['data']
current_aml = data.get('aml', {}) if data else {}
# We reached desired state
if self.TestAcceptanceMechanism in current_aml:
break
# Check whether we can reach desired AML state at all
if data is not None:
raise RuntimeError("There is already incompatible TAA AML written to ledger")
# Try to set aml
set_aml = await ledger.build_acceptance_mechanisms_request(self._test_did,
json.dumps({self.TestAcceptanceMechanism: {}}),
self.TestAcceptanceMechanismVersion, None)
await ledger.sign_and_submit_request(self._pool_handle, self._wallet_handle, self._test_did, set_aml)
self._logger.info("_taa_aml_init done")
async def _pool_auth_rules_init(self):
get_auth_rule_req = await ledger.build_get_auth_rule_request(self._test_did, None, None, None, None, None)
get_auth_rule_resp = await ledger.sign_and_submit_request(self._pool_handle, self._wallet_handle, self._test_did, get_auth_rule_req)
ensure_is_reply(get_auth_rule_resp)
get_auth_rule_resp = json.loads(get_auth_rule_resp)
data_f = get_auth_rule_resp["result"].get("data", [])
if not data_f:
self._logger.warning("No auth rules found")
return
for auth_rule in data_f:
try:
metadata_addition = self._auth_rule_metadata.get(auth_rule['auth_type'], None)
if metadata_addition:
update_constraint(auth_rule['constraint'], metadata_addition)
auth_rule_req = await ledger.build_auth_rule_request(
self._test_did,
txn_type=auth_rule['auth_type'],
action=auth_rule['auth_action'],
field=auth_rule['field'],
old_value=auth_rule.get('old_value'),
new_value=auth_rule.get('new_value'),
constraint=json.dumps(auth_rule['constraint']),
)
auth_rule_resp = await ledger.sign_and_submit_request(self._pool_handle, self._wallet_handle, self._test_did, auth_rule_req)
ensure_is_reply(auth_rule_resp)
except Exception:
self._logger.exception(
"Failed to set auth rule with the following parameters: {} "
.format(auth_rule)
)
raise
self._logger.info("_pool_auth_rules_init done")
async def _get_taa(self, version: Optional[str] = None) -> Tuple[Optional[str], Optional[str], Optional[int]]:
options = json.dumps({'version': version}) if version else None
request = await ledger.build_get_txn_author_agreement_request(self._test_did, options)
reply = await ledger.sign_and_submit_request(self._pool_handle, self._wallet_handle, self._test_did, request)
ensure_is_reply(reply)
result = json.loads(reply)['result']
if result['data'] is None:
return "", "", None
return result['data']['text'], result['data']['version'], result['txnTime']
async def __mint_sources(self, payment_addresses, amount):
outputs = []
for payment_address in payment_addresses:
outputs.append({"recipient": payment_address, "amount": amount})
mint_req, _ = await payment.build_mint_req(self._wallet_handle,
self._test_did,
json.dumps(outputs), None)
mint_req = await self.multisig_req(mint_req)
mint_resp = await ledger.submit_request(self._pool_handle, mint_req)
ensure_is_reply(mint_resp)
async def _get_payment_sources(self, pmnt_addr):
get_ps_req, _ = await payment.build_get_payment_sources_request(self._wallet_handle, self._test_did, pmnt_addr)
get_ps_resp = await ledger.sign_and_submit_request(self._pool_handle, self._wallet_handle, self._test_did, get_ps_req)
ensure_is_reply(get_ps_resp)
source_infos_json = await payment.parse_get_payment_sources_response(self._payment_method, get_ps_resp)
source_infos = json.loads(source_infos_json)
payment_sources = []
for source_info in source_infos:
payment_sources.append((source_info["source"], source_info["amount"]))
return {pmnt_addr: payment_sources}
async def __ensure_submitter_is_trustee(self):
get_nym_req = await ledger.build_get_nym_request(self._submitter_did, self._submitter_did)
get_nym_resp = await ledger.sign_and_submit_request(self._pool_handle,
self._wallet_handle,
self._submitter_did,
get_nym_req)
get_nym_resp_obj = json.loads(get_nym_resp)
ensure_is_reply(get_nym_resp_obj)
res_data = json.loads(get_nym_resp_obj["result"]["data"])
if res_data["role"] != RGBasePayment.TRUSTEE_ROLE_CODE:
raise Exception("Submitter role must be TRUSTEE since "
"submitter have to create additional trustees to mint sources.")
async def _is_trustee(self, did) -> Optional[bool]:
"""
:return: None, if DID is not public, otherwise bool indicating whether this DID have trustee rights
"""
get_nym_req = await ledger.build_get_nym_request(did, did)
get_nym_resp = await ledger.sign_and_submit_request(
self._pool_handle, self._wallet_handle, did, get_nym_req)
get_nym_resp_obj = json.loads(get_nym_resp)
ensure_is_reply(get_nym_resp_obj)
data_f = get_nym_resp_obj["result"].get("data", None)
if data_f is None:
return None
res_data = json.loads(data_f)
return res_data["role"] == TRUSTEE_ROLE_CODE
async def __is_trustee(self, checking_did):
get_nym_req = await ledger.build_get_nym_request(
checking_did, checking_did)
get_nym_resp = await ledger.sign_and_submit_request(
self._pool_handle, self._wallet_handle, checking_did, get_nym_req)
get_nym_resp_obj = json.loads(get_nym_resp)
ensure_is_reply(get_nym_resp_obj)
data_f = get_nym_resp_obj["result"].get("data", None)
if data_f is None:
return None
res_data = json.loads(data_f)
if res_data["role"] != TRUSTEE_ROLE_CODE:
return False
return True
async def __mint_sources(self, payment_addresses, amount, by_val):
iters = (amount // by_val) + (1 if (amount % by_val) > 0 else 0)
mint_val = by_val
for i in range(iters):
outputs = []
if (i + 1) * by_val > amount:
mint_val = amount % by_val
for payment_address in payment_addresses:
outputs.append({"recipient": payment_address, "amount": mint_val})
mint_req, _ = await payment.build_mint_req(self._wallet_handle, self._test_did, json.dumps(outputs), None)
mint_req = await self.append_taa_acceptance(mint_req)
mint_req = await self.multisig_req(mint_req)
mint_resp = await ledger.submit_request(self._pool_handle, mint_req)
ensure_is_reply(mint_resp)
async def __mint_sources(self, payment_addresses, trustees_dids):
outputs = []
for payment_address in payment_addresses:
outputs.append({"recipient": payment_address, "amount": random.randint(1, RGBasePayment.AMOUNT_LIMIT)})
mint_req, _ = await payment.build_mint_req(self._wallet_handle,
self._submitter_did,
json.dumps(outputs),
None)
for trustee_did in trustees_dids:
mint_req = await ledger.multi_sign_request(self._wallet_handle, trustee_did, mint_req)
mint_resp = await ledger.submit_request(self._pool_handle, mint_req)
ensure_is_reply(mint_resp)
async def on_pool_create(self, pool_handle, wallet_handle, submitter_did,
*args, **kwargs):
await super().on_pool_create(pool_handle, wallet_handle, submitter_did,
*args, **kwargs)
fees_req = await payment.build_set_txn_fees_req(
wallet_handle, submitter_did, self._payment_method,
json.dumps({"101": 1}))
for trustee_did in [
self._submitter_did, *self._additional_trustees_dids
]:
fees_req = await ledger.multi_sign_request(self._wallet_handle,
trustee_did, fees_req)
resp = await ledger.submit_request(self._pool_handle, fees_req)
ensure_is_reply(resp)
async def _pool_fees_init(self):
if self._set_fees:
fees_req = await payment.build_set_txn_fees_req(
self._wallet_handle, self._test_did, self._payment_method,
json.dumps(self._set_fees))
fees_req = await self.multisig_req(fees_req)
fees_resp = await ledger.submit_request(self._pool_handle,
fees_req)
ensure_is_reply(fees_resp)
get_fees_req = await payment.build_get_txn_fees_req(
self._wallet_handle, self._test_did, self._payment_method)
get_fees_resp = await ledger.sign_and_submit_request(
self._pool_handle, self._wallet_handle, self._test_did,
get_fees_req)
self._pool_fees = json.loads(await payment.parse_get_txn_fees_response(
self._payment_method, get_fees_resp))
async def __set_fees_once(cls, wallet_handle, set_fees, test_did, payment_method, trustee_dids, pool_handle, auth_rule_metadata):
if not (len(cls.__pool_fees) or len(cls.__auth_rule_metadata)):
if set_fees:
fees_req = await payment.build_set_txn_fees_req(
wallet_handle, test_did, payment_method, json.dumps(set_fees))
for d in trustee_dids:
fees_req = await ledger.multi_sign_request(wallet_handle, d, fees_req)
fees_resp = await ledger.submit_request(pool_handle, fees_req)
ensure_is_reply(fees_resp)
get_fees_req = await payment.build_get_txn_fees_req(wallet_handle, test_did, payment_method)
get_fees_resp = await ledger.sign_and_submit_request(pool_handle, wallet_handle, test_did, get_fees_req)
alias_to_type_mapping = {metadata['fees']: txn_type for txn_type, metadata in auth_rule_metadata.items()}
fees_set = json.loads(await payment.parse_get_txn_fees_response(payment_method, get_fees_resp))
cls.__pool_fees = {alias_to_type_mapping[alias]: fees_amount for alias, fees_amount in fees_set.items() if alias in alias_to_type_mapping}
cls.__auth_rule_metadata = auth_rule_metadata
return cls.__pool_fees, cls.__auth_rule_metadata
async def __perform_payments(self):
for source, amount in self._sources_amounts:
address = random.choice(self._payment_addresses)
inputs = [source]
outputs = [{"recipient": address, "amount": amount}]
payment_req, _ = await payment.build_payment_req(self._wallet_handle,
self._submitter_did,
json.dumps(inputs),
json.dumps(outputs),
None)
payment_resp = await ledger.sign_and_submit_request(self._pool_handle,
self._wallet_handle,
self._submitter_did,
payment_req)
ensure_is_reply(payment_resp)
receipt_infos_json = await payment.parse_payment_response(self._payment_method, payment_resp)
receipt_infos = json.loads(receipt_infos_json)
receipt_info = receipt_infos[0]
self._receipts.append(receipt_info["receipt"])
