def transfer(senderMnemonic, recipientAddress, amount, sequenceNumber):
senderWallet = LibraWallet(senderMnemonic)
senderAccount = senderWallet.get_account(0)
tx_script = '4c49425241564d0a010007014a00000004000000034e000000060000000c54000000060000000d5a0000000600000005600000002900000004890000002000000007a90000000e00000000000001000200010300020002040200030003020402063c53454c463e0c4c696272614163636f756e74046d61696e0f7061795f66726f6d5f73656e64657200000000000000000000000000000000000000000000000000000000000000000001020104000c000c0111010002'
sequence_number = int(sequenceNumber)
raw_tx = RawTransaction()
raw_tx.sender_account = bytes.fromhex(senderAccount.address)
raw_tx.sequence_number = sequence_number
raw_tx.max_gas_amount = 100000
raw_tx.gas_unit_price = 1
raw_tx.expiration_time = int(time.time()) + 10
raw_tx.program.code = bytes.fromhex(tx_script)
arg1 = raw_tx.program.arguments.add()
arg1.type = TransactionArgument.ADDRESS
arg1.data = bytes.fromhex(recipientAddress)
arg2 = raw_tx.program.arguments.add()
arg2.type = TransactionArgument.U64
arg2.data = (int(amount) * 1000000).to_bytes(8, 'little')
tx = raw_tx.SerializeToString()
request = SubmitTransactionRequest()
signed_tx = request.signed_txn
signed_tx.raw_txn_bytes = tx
signed_tx.sender_public_key = bytes.fromhex(senderAccount.public_key)
hashfn = sha3_256()
hashfn.update(
bytes.fromhex(
'46f174df6ca8de5ad29745f91584bb913e7df8dd162e3e921a5c1d8637c88d16')
)
hashfn.update(tx)
signature = senderAccount.sign(hashfn.digest())[:64]
signed_tx.sender_signature = signature
result = client.stub.SubmitTransaction(request)
return sequence_number + 1
def getBalanceByMnemonic():
functionName = "[getBalanceByMnemonic]"
print(functionName)
client = LibraClient()
data = request.get_json()
mnemonic = data["mnemonic"]
# wallet.to_mnemonic(),
wallet = LibraWallet(mnemonic)
# try :
# wallet = LibraWallet(mnemonic)
# except TypeError as error :
# print("Error : {}".format(error))
# return { "error" : error },400
account = wallet.get_account(0)
account_state_by_mnemonic = client.get_account_state(account)
print(account_state_by_mnemonic)
result = {
"mnemonic": mnemonic,
"address": account_state_by_mnemonic.authentication_key,
"balance": account_state_by_mnemonic.balance / config_coin,
"sequence_number": account_state_by_mnemonic.sequence_number,
"received_events_count":
account_state_by_mnemonic.received_events_count,
"sent_events_count": account_state_by_mnemonic.sent_events_count
}
print("result : {}".format(result))
return result, 200
def account(words=None):
print("\n")
wallet = LibraWallet() if words is None else LibraWallet(words)
account = wallet.get_account(0)
cprint(f"address: {account.address}", "blue")
cprint(f"mnemonic: {wallet.to_mnemonic()}", "blue")
cprint(f"public key: {account.public_key}", "blue")
cprint(f"private key: {account.private_key}", "blue")
if client.get_account_state(account) == None or round(
client.get_account_state(account).balance / 1000000) == 0:
balance = 0
cprint(f"Balance: 0 tLibra", "red")
else:
balance = round(client.get_account_state(account).balance / 1000000)
cprint(
f"Balance: {round(client.get_account_state(account).balance/1000000)} tLibra",
"green")
account_details = {
'address': account.address,
'mnemonic': wallet.to_mnemonic(),
'public_key': account.public_key,
'private_key': account.private_key,
'balance': balance
}
return account_details
def account(words=None):
wallet = LibraWallet() if words is None else LibraWallet(words)
account = wallet.get_account(0)
if client.get_account_state(account) == None or round(client.get_account_state(account).balance/1000000) == 0:
balance = 0
else:
balance = round(client.get_account_state(account).balance/1000000)
account_details = {
'address': account.address,
'mnemonic': wallet.to_mnemonic(),
'public_key': account.public_key,
'private_key': account.private_key,
'balance': balance
}
return account_details
def transfer():
functionName = "[transfer]"
print(functionName)
data = request.get_json()
sender = data['mnemonic'] #sender : mnemonic == SK
receiver = data['toAddress'] #receiver hash<hex> : PK
amount = int(data['amount']) * config_coin
if amount <= 0:
return {"massage": "Transfer fail requiry amount >= 1 "}, 400
#[EX]mnemonic : "zero job file nothing north ask gasp brush yard sand unhappy good"
client = LibraClient()
sender_wallet = LibraWallet(sender)
sender_account = sender_wallet.get_account(0)
sender_account_state = client.get_account_state(sender_account)
if sender_account_state.balance < amount:
return {
"massage":
"Transfer fail amount to transfer > now balance for wallet",
"sender": sender_account_state.authentication_key,
"now_balance": sender_account_state.balance
}, 400
sender_account = sender_wallet.get_account(0)
# Create a transfer transaction object to send 0.001 Libra to account2
Transaction = TransferTransaction(receiver, amount)
# Or to send to a plain hex address
# You can send a transaction by calling `send_transaction` function, which takes a sender `Account` and a `Transaction` object. You can also optionally passed `max_gas_amount`, `gas_unit_price`, and `expiration_time`.
client.send_transaction(sender_account, Transaction)
result = {
"massage": "Transfer success",
"sender": sender_account_state.authentication_key,
"receiver": receiver,
"amount": amount / config_coin
}
print("result : {}".format(result))
return result, 201
def getBalance():
functionName = "[getBalance]"
print(functionName)
client = LibraClient()
data = request.get_json()
mnemonic = data["mnemonic"]
address = data['address']
# wallet.to_mnemonic(),
wallet = LibraWallet(mnemonic)
# try :
# wallet = LibraWallet(mnemonic)
# except TypeError as error :
# print("Error : {}".format(error))
# return { "error" : error },400
account = wallet.get_account(0)
account_state_by_mnemonic = client.get_account_state(account)
print(account_state_by_mnemonic)
if account_state_by_mnemonic.authentication_key != address:
return {
"massage":
"inquiryBalance fail mnemonic no relational with address",
"mnemonic": mnemonic,
"address": address
}, 400
account_state = client.get_account_state(address)
result = {
"mnemonic": mnemonic,
"address": address,
"balance": account_state.balance / config_coin,
"sequence_number": account_state.sequence_number,
"received_events_count": account_state.received_events_count,
"sent_events_count": account_state.sent_events_count
}
print("result : {}".format(result))
return result, 200
def createWallet():
functionName = "[createWallet]"
print(functionName)
client = LibraClient() # Default client connecting to the official testnet
wallet = LibraWallet()
# data = request.get_json()
# amount = data['amount']
# yield from asyncio.sleep(5)
account = "AAAAA"
print("to_mnemonic : {}".format(wallet.to_mnemonic()))
print("to_mnemonic : {}".format(wallet.to_mnemonic()))
print("account: {}".format(account))
wallet = LibraWallet(wallet.to_mnemonic())
account = wallet.get_account(0)
print(client.mint_with_faucet(account,
1000 * config_coin)) #1 000 000 lan lan
account_state = "BBBBBB"
time.sleep(0.5)
account_state = client.get_account_state(account)
print("account_state : {}".format(account_state))
print("PK : {}".format(account_state.authentication_key))
result = {
"mnemonic": wallet.to_mnemonic(),
"address": account_state.authentication_key,
"balance": account_state.balance / config_coin,
"sequenceNumber": account_state.sequence_number,
"receivedEventsCount": account_state.received_events_count,
"sentEventsCount": account_state.sent_events_count
}
print("result : {}".format(result))
return result, 201
def mint(mnemonic, amount):
wallet = LibraWallet(mnemonic)
account = wallet.get_account(0)
client.mint_with_faucet(account, int(amount) * 1000000)
return balance(account)
def test_create_random_wallet():
wallet1 = LibraWallet()
assert len(wallet1.to_mnemonic().split()) == 12
wallet2 = LibraWallet(strength=256)
assert len(wallet2.to_mnemonic().split()) == 24
cprint("\nWelcome! Please select an option:\n", "yellow")
cprint("---" * 11, "yellow")
cprint("\n[CREATE] a new wallet\n[IMPORT] an existing mnemonic\n", "blue")
user_input = input("")
if user_input.lower() == "create" or user_input.lower() == "import":
if user_input.lower() == "create":
cprint(
"Are you sure? This will overwrite any previously saved mnemonic phrase.[y/n]",
"red")
ui2 = input("\n")
if ui2.lower() == "y":
wallet = LibraWallet()
cprint("\nYOUR MNEMONIC SEED IS:\n", "blue")
cprint(wallet.to_mnemonic(), "green")
cprint(
"\nThis will be saved to 'seed.txt'. For extra security, write it down somewhere.\n\n",
"blue")
with open("seed.txt", "w") as file:
file.write(wallet.to_mnemonic())
mnemonic = wallet.to_mnemonic()
break
if user_input.lower() == "import":
try:
with open("seed.txt", "r") as file: