async def test_create_child_vasp():
client = create_client()
faucet = Faucet(client)
parent_vasp = await faucet.gen_account()
seq_num = await client.get_account_sequence(parent_vasp.account_address)
child_vasp = LocalAccount.generate()
payload = stdlib.encode_create_child_vasp_account_script_function(
coin_type=utils.currency_code(XUS),
child_address=child_vasp.account_address,
auth_key_prefix=child_vasp.auth_key.prefix(),
add_all_currencies=False,
child_initial_balance=100_000_000,
)
raw_txn = diem_types.RawTransaction(
sender=parent_vasp.account_address,
sequence_number=seq_num,
payload=payload,
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=XUS,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=chain_ids.TESTNET,
)
txn = parent_vasp.sign(raw_txn)
await client.submit(txn)
executed_txn = await client.wait_for_transaction(txn)
assert executed_txn is not None
def test_create_child_vasp():
client = testnet.create_client()
faucet = testnet.Faucet(client)
parent_vasp = faucet.gen_account()
seq_num = client.get_account_sequence(parent_vasp.account_address)
child_vasp = LocalAccount.generate()
currency = testnet.TEST_CURRENCY_CODE
raw_txn = diem_types.RawTransaction(
sender=parent_vasp.account_address,
sequence_number=seq_num,
payload=diem_types.TransactionPayload__Script(
stdlib.encode_create_child_vasp_account_script(
coin_type=utils.currency_code(currency),
child_address=child_vasp.account_address,
auth_key_prefix=child_vasp.auth_key.prefix(),
add_all_currencies=False,
child_initial_balance=100_000_000,
)
),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=testnet.CHAIN_ID,
)
txn = parent_vasp.sign(raw_txn)
client.submit(txn)
executed_txn = client.wait_for_transaction(txn)
assert executed_txn is not None
def create_transaction(sender, sender_account_sequence, script, currency):
return diem_types.RawTransaction(
sender=sender.account_address,
sequence_number=sender_account_sequence,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=testnet.CHAIN_ID,
)
def create_transaction(
sender: LocalAccount, script: diem_types.Script, seq: int, currency=XUS
) -> diem_types.RawTransaction:
return diem_types.RawTransaction(
sender=sender.account_address,
sequence_number=seq,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=chain_ids.TESTNET,
)
def create_transaction(
self, script: diem_types.Script) -> diem_types.SignedTransaction:
address = self.config.vasp_account_address()
seq = self.jsonrpc_client.get_account_sequence(address)
txn = diem_types.RawTransaction(
sender=address,
sequence_number=diem_types.st.uint64(seq),
payload=diem_types.TransactionPayload__Script(value=script),
max_gas_amount=diem_types.st.uint64(1_000_000),
gas_unit_price=diem_types.st.uint64(0),
gas_currency_code=self.config.gas_currency_code,
expiration_timestamp_secs=diem_types.st.uint64(
int(time.time()) + 30),
chain_id=diem_types.ChainId.from_int(self.config.chain_id),
)
sig = self.sign(utils.raw_transaction_signing_msg(txn))
return utils.create_signed_transaction(txn, self.public_key_bytes(),
sig)
def create_transaction(
cls,
account_name,
sender_account_sequence,
script,
gas_currency_code="XUS") -> diem_types.SignedTransaction:
account = cls.get_account(account_name)
raw_tx = diem_types.RawTransaction(
sender=account.account_address,
sequence_number=sender_account_sequence,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=gas_currency_code,
expiration_timestamp_secs=int(time()) + 30,
chain_id=cls.chain_id,
)
return account.sign(raw_tx)
async def test_p2p_above_threshold_by_reference_id():
client = create_client()
faucet = Faucet(client)
sender = await faucet.gen_account()
receiver = await faucet.gen_account()
await receiver.rotate_dual_attestation_info(client,
base_url="http://localhost")
amount = 20_000_000_000
reference_id = str(uuid.uuid4())
metadata, metadata_signing_msg = txnmetadata.travel_rule(
reference_id, sender.account_address, amount)
metadata_signature = receiver.compliance_key.sign(metadata_signing_msg)
payload = stdlib.encode_peer_to_peer_with_metadata_script_function(
currency=utils.currency_code(XUS),
payee=receiver.account_address,
amount=amount,
metadata=metadata,
metadata_signature=metadata_signature,
)
seq_num = await client.get_account_sequence(sender.account_address)
txn = diem_types.RawTransaction(
sender=sender.account_address,
sequence_number=seq_num,
payload=payload,
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=XUS,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=chain_ids.TESTNET,
)
signed_txn = sender.sign(txn)
await client.submit(signed_txn)
executed_txn = await client.wait_for_transaction(signed_txn)
assert executed_txn is not None
def listAccount(parent_vasp, child_vasp, initialBalance):
currency = testnet.TEST_CURRENCY_CODE
seq_num = client.get_account_sequence(parent_vasp.account_address)
raw_txn = diem_types.RawTransaction(
sender=parent_vasp.account_address,
sequence_number=seq_num,
payload=diem_types.TransactionPayload__Script(
stdlib.encode_create_child_vasp_account_script(
coin_type=utils.currency_code(currency),
child_address=child_vasp.account_address,
auth_key_prefix=child_vasp.auth_key.prefix(),
add_all_currencies=False,
child_initial_balance=initialBalance,
)),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=testnet.CHAIN_ID,
)
txn = parent_vasp.sign(raw_txn)
client.submit(txn)
executed_txn = client.wait_for_transaction(txn)
return executed_txn
async def test_p2p_under_threshold_by_subaddress():
client = create_client()
faucet = Faucet(client)
sender = await faucet.gen_account()
sender_subaddress = identifier.gen_subaddress()
receiver = await faucet.gen_account()
receiver_subaddress = identifier.gen_subaddress()
amount = 2_000_000
payload = stdlib.encode_peer_to_peer_with_metadata_script_function(
currency=utils.currency_code(XUS),
payee=receiver.account_address,
amount=amount,
metadata=txnmetadata.general_metadata(sender_subaddress,
receiver_subaddress),
metadata_signature=b"", # only travel rule metadata requires signature
)
seq_num = await client.get_account_sequence(sender.account_address)
txn = diem_types.RawTransaction(
sender=sender.account_address,
sequence_number=seq_num,
payload=payload,
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=XUS,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=chain_ids.TESTNET,
)
signed_txn = sender.sign(txn)
await client.submit(signed_txn)
executed_txn = await client.wait_for_transaction(signed_txn)
assert executed_txn is not None
script = stdlib.encode_peer_to_peer_with_metadata_script(
currency=utils.currency_code(currency),
payee=watched_account_addr,
amount=refill_amount,
metadata=txnmetadata.general_metadata(
from_subaddress=utils.account_address_bytes(
sender_account.account_address),
to_subaddress=utils.account_address_bytes(
watched_account_addr),
),
metadata_signature=b"",
)
raw_tx = diem_types.RawTransaction(
sender=sender_account.account_address,
sequence_number=sender_account_info.sequence_number,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time()) + 30,
chain_id=diem_types.ChainId.from_int(network_chainid),
)
tx = sender_account.sign(raw_tx)
print(
f"sending transaction from account {sender_account_addr_hex} "
f"(seq {sender_account_info.sequence_number}) "
f"to {watched_account_addr_hex}", )
diem_client.submit(tx)
diem_client.wait_for_transaction(tx, 30)
def main():
print("#1 connect to testnet")
client = testnet.create_client()
print("#2 Generate Keys")
# generate private key for sender account
sender_private_key = Ed25519PrivateKey.generate()
# generate auth key for sender account
sender_auth_key = AuthKey.from_public_key(sender_private_key.public_key())
print(
f"Generated sender address: {utils.account_address_hex(sender_auth_key.account_address())}"
)
print("#3 Create account")
faucet = testnet.Faucet(client)
testnet.Faucet.mint(faucet, sender_auth_key.hex(), 100000000, CURRENCY)
print("#4 Get account information")
sender_account = client.get_account(sender_auth_key.account_address())
events_key = sender_account.received_events_key
print("#5 Start event listener")
get_events_example.subscribe(client, events_key)
print("#6 Add money to account")
faucet = testnet.Faucet(client)
testnet.Faucet.mint(faucet, sender_auth_key.hex(), 10000000, CURRENCY)
print("#7 Generate Keys")
# generate private key for receiver account
receiver_private_key = Ed25519PrivateKey.generate()
# generate auth key for receiver account
receiver_auth_key = AuthKey.from_public_key(
receiver_private_key.public_key())
print(
f"Generated receiver address: {utils.account_address_hex(receiver_auth_key.account_address())}"
)
print("#8 Create second account")
faucet = testnet.Faucet(client)
testnet.Faucet.mint(faucet, receiver_auth_key.hex(), 1000000, CURRENCY)
print("#9 Generate IntentIdentifier")
account_identifier = identifier.encode_account(
utils.account_address_hex(receiver_auth_key.account_address()), None,
identifier.TDM)
encoded_intent_identifier = identifier.encode_intent(
account_identifier, CURRENCY, 10000000)
print(f"Encoded IntentIdentifier: {encoded_intent_identifier}")
print("#10 Deserialize IntentIdentifier")
intent_identifier = identifier.decode_intent(encoded_intent_identifier,
identifier.TDM)
print(
f"Account (HEX) from intent: {utils.account_address_hex(intent_identifier.account_address)}"
)
print(f"Amount from intent: {intent_identifier.amount}")
print(f"Currency from intent: {intent_identifier.currency_code}")
print("#11 Peer 2 peer transaction")
# create script
script = stdlib.encode_peer_to_peer_with_metadata_script(
currency=utils.currency_code(intent_identifier.currency_code),
payee=intent_identifier.account_address,
amount=intent_identifier.amount,
metadata=b'', # no requirement for metadata and metadata signature
metadata_signature=b'',
)
# create transaction
raw_transaction = diem_types.RawTransaction(
sender=sender_auth_key.account_address(),
sequence_number=sender_account.sequence_number,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=CURRENCY,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=testnet.CHAIN_ID,
)
# sign transaction
signature = sender_private_key.sign(
utils.raw_transaction_signing_msg(raw_transaction))
public_key_bytes = utils.public_key_bytes(sender_private_key.public_key())
signed_txn = utils.create_signed_transaction(raw_transaction,
public_key_bytes, signature)
# submit transaction
client.submit(signed_txn)
# wait for transaction
client.wait_for_transaction(signed_txn)
def main():
# connect to testnet
client = testnet.create_client()
# generate private key for sender account
sender_private_key = Ed25519PrivateKey.generate()
# generate auth key for sender account
sender_auth_key = AuthKey.from_public_key(sender_private_key.public_key())
print(
f"Generated sender address: {utils.account_address_hex(sender_auth_key.account_address())}"
)
# create sender account
faucet = testnet.Faucet(client)
testnet.Faucet.mint(faucet, sender_auth_key.hex(), 100000000, "XUS")
# get sender account
sender_account = client.get_account(sender_auth_key.account_address())
# generate private key for receiver account
receiver_private_key = Ed25519PrivateKey.generate()
# generate auth key for receiver account
receiver_auth_key = AuthKey.from_public_key(
receiver_private_key.public_key())
print(
f"Generated receiver address: {utils.account_address_hex(receiver_auth_key.account_address())}"
)
# create receiver account
faucet = testnet.Faucet(client)
testnet.Faucet.mint(faucet, receiver_auth_key.hex(), 10000000, CURRENCY)
# create script
script = stdlib.encode_peer_to_peer_with_metadata_script(
currency=utils.currency_code(CURRENCY),
payee=receiver_auth_key.account_address(),
amount=10000000,
metadata=b'', # no requirement for metadata and metadata signature
metadata_signature=b'',
)
# create transaction
raw_transaction = diem_types.RawTransaction(
sender=sender_auth_key.account_address(),
sequence_number=sender_account.sequence_number,
payload=diem_types.TransactionPayload__Script(script),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=CURRENCY,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=testnet.CHAIN_ID,
)
# sign transaction
signature = sender_private_key.sign(
utils.raw_transaction_signing_msg(raw_transaction))
public_key_bytes = utils.public_key_bytes(sender_private_key.public_key())
signed_txn = utils.create_signed_transaction(raw_transaction,
public_key_bytes, signature)
# submit transaction
client.submit(signed_txn)
# wait for transaction
client.wait_for_transaction(signed_txn)
