def test_intent_identifier_with_one_param():
account_id = "dm1p7ujcndcl7nudzwt8fglhx6wxnvqqqqqqqqqqqqqd8p9cq"
intent_id = identifier.encode_intent(account_id, currency_code="XUS")
assert intent_id == "diem://%s?c=%s" % (account_id, "XUS")
intent_id = identifier.encode_intent(account_id, currency_code="")
assert intent_id == "diem://%s" % account_id
intent_id = identifier.encode_intent(account_id, amount=122)
assert intent_id == "diem://%s?am=%s" % (account_id, 122)
intent_id = identifier.encode_intent(account_id, amount=0)
assert intent_id == "diem://%s" % account_id
intent_id = identifier.encode_intent(account_id, amount=-1)
assert intent_id == "diem://%s" % account_id
def gen_intent_id(
self,
user_name: str,
amount: int,
currency: typing.Optional[str] = testnet.TEST_CURRENCY_CODE,
) -> str:
account_id = self.gen_user_account_id(user_name)
return identifier.encode_intent(account_id, str(currency), amount)
def payment(self, user_id: int, amount: int) -> str:
account_id = identifier.encode_account(
self._children[0].account_address,
self._users[user_id],
identifier.TLB # testnet HRP
)
return identifier.encode_intent(account_id, testnet.TEST_CURRENCY_CODE,
amount)
def test_intent_identifier_with_sub_address(hrp_addresses):
hrp, enocded_addr_with_none_subaddr, enocded_addr_with_subaddr = hrp_addresses
account_id = identifier.encode_account(test_onchain_address, test_sub_address, hrp)
intent_id = identifier.encode_intent(account_id, "XUS", 123)
assert intent_id == "diem://%s?c=%s&am=%d" % (enocded_addr_with_subaddr, "XUS", 123)
intent = identifier.decode_intent(intent_id, hrp)
assert intent.account_address_bytes.hex() == test_onchain_address
assert intent.sub_address == bytes.fromhex(test_sub_address)
assert intent.currency_code == "XUS"
assert intent.amount == 123
def get_payment_uri(account_id):
try:
address = STATE[account_id].get_recv_addr()
return {
"id": address,
"account_id": account_id,
"payment_uri": identifier.encode_intent(address, "", 0),
}
except Exception as e:
return error_response(LOG, e)
def test_intent_identifier_with_sub_address():
account_id = identifier.encode_account(test_onchain_address,
test_sub_address, "lbr")
intent_id = identifier.encode_intent(account_id, "Coin1", 123)
assert intent_id == "diem://%s?c=%s&am=%d" % (enocded_addr_with_subaddr,
"Coin1", 123)
intent = identifier.decode_intent(intent_id, "lbr")
assert intent.account_address_bytes.hex() == test_onchain_address
assert intent.sub_address == bytes.fromhex(test_sub_address)
assert intent.currency_code == "Coin1"
assert intent.amount == 123
def test_intent_identifier():
child_vasp_address = "d738a0b9851305dfe1d17707f0841dbc"
user_sub_address = "9072d012034a880f"
currency_code = "XUS"
amount = 10_000_000
account_id = identifier.encode_account(
child_vasp_address,
utils.sub_address(user_sub_address),
identifier.TDM # testnet HRP
)
intent_id = identifier.encode_intent(account_id, currency_code, amount)
assert intent_id == "diem://tdm1p6uu2pwv9zvzalcw3wurlppqahjg895qjqd9gsrcr9dqh8?c=XUS&am=10000000"
def test_intent_identifier_without_params(hrp_addresses):
hrp, enocded_addr_with_none_subaddr, enocded_addr_with_subaddr = hrp_addresses
account_id = identifier.encode_account(test_onchain_address, None, hrp)
intent_id = identifier.encode_intent(account_id)
assert intent_id == "diem://%s" % enocded_addr_with_none_subaddr
intent = identifier.decode_intent(intent_id, hrp)
assert intent.account_address == utils.account_address(test_onchain_address)
assert intent.account_address_bytes.hex() == test_onchain_address
assert intent.sub_address is None
assert intent.currency_code is None
assert intent.amount is None
assert account_id == intent.account_id
def main():
# generate private key
private_key = Ed25519PrivateKey.generate()
# generate auth key
auth_key = AuthKey.from_public_key(private_key.public_key())
# create intent identifier
account_identifier = identifier.encode_account(
utils.account_address_hex(auth_key.account_address()), None,
identifier.TDM)
encoded_intent_identifier = identifier.encode_intent(
account_identifier, "XUS", 10000000)
print(f"Encoded IntentIdentifier: {encoded_intent_identifier}")
# 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}")
def payment(self, user_id: int, amount: int) -> str:
account_id = self._children[0].account_identifier(self._users[user_id])
return identifier.encode_intent(account_id, testnet.TEST_CURRENCY_CODE, amount)
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)
