async void CheckFreeUsage()
{
if (IsBandwidthWarningDismissed || (LastCheckBandwidthTime.AddSeconds(15) >= DateTime.Now))
{
return;
}
LastCheckBandwidthTime = DateTime.Now;
try
{
var account = await _tronConnection.Client.GetAccountAsync(new Protocol.Account
{
Address = ByteString.CopyFrom(WalletAddress.Decode58Check(_walletManager.Wallet.Address))
});
var accountNet = await _tronConnection.Client.GetAccountNetAsync(new Protocol.Account
{
Address = ByteString.CopyFrom(WalletAddress.Decode58Check(_walletManager.Wallet.Address))
});
if (account != null && !account.Address.IsEmpty)
{
var isBandwidthAvailable = false;
var token = await _tronConnection.Client.GetAssetIssueByIdAsync(new BytesMessage { Value = ByteString.CopyFromUtf8(AppConstants.TokenID) });
if (token != null && !token.OwnerAddress.IsEmpty)
{
// Check account free usage
if (accountNet.AssetNetUsed.ContainsKey(AppConstants.TokenID))
{
isBandwidthAvailable = (token.PublicFreeAssetNetLimit - accountNet.AssetNetUsed[AppConstants.TokenID]) >= 1000;
}
else
{
isBandwidthAvailable = false;
}
if (isBandwidthAvailable)
{
// Check total token free bandwidth
isBandwidthAvailable = token.FreeAssetNetLimit - token.PublicFreeAssetNetUsage >= 2500;
}
// Check own account bandwidth and balance
if (!isBandwidthAvailable)
{
isBandwidthAvailable = (accountNet.NetLimit + accountNet.FreeNetLimit - accountNet.NetUsed - accountNet.FreeNetUsed) >= 1000 || account.Balance > 20 * 1000;
}
IsBandwidthWarningVisible = !isBandwidthAvailable && !IsBandwidthWarningDismissed;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
async void OpenChatCommandExecuted()
{
IsBusy = true;
_userDialogs.ShowLoading(maskType: MaskType.Black);
try
{
await Task.Delay(1000);
var addressBytes = WalletAddress.Decode58Check(Address);
if (addressBytes != null)
{
var account = await _tronConnection.Client.GetAccountAsync(new Protocol.Account {
Address = ByteString.CopyFrom(addressBytes)
});
if (!account.Address.IsEmpty)
{
var group = await _syncServer.GetGroupAsync(Address, _walletManager.Wallet.Address);
if (group != null)
{
var navParams = new NavigationParameters();
navParams.Add("group", group);
await _navigationService.NavigateAsync("GroupPopupPage", navParams);
}
else
{
var user = await _syncServer.GetUserAsync(Address);
if (user != null)
{
var navParams = new NavigationParameters();
navParams.Add("address", Address);
await _navigationService.NavigateAsync("ChatPage", navParams);
}
else
{
_userDialogs.Toast("User is not registered or unable to load");
}
}
}
else
{
_userDialogs.Toast("User or Group is not yet activated");
}
}
else
{
_userDialogs.Toast("Not an user or group address");
}
}
catch (RpcException ex)
{
_userDialogs.Toast("Unable to load user");
}
_userDialogs.HideLoading();
IsBusy = false;
}
async void SelectCommandExecuted()
{
if (WalletAddress.Decode58Check(Address) != null)
{
var navParams = new NavigationParameters();
navParams.Add("selected_address", Address);
await _navigationService.GoBackAsync(navParams);
}
else
{
await _userDialogs.AlertAsync("No valid address", "Invalid");
}
}
public async Task <TransactionExtention> CreateTransactionAsync(string sender, string receiver, string data)
{
var contract = new TransferAssetContract
{
Amount = 1,
AssetName = ByteString.CopyFromUtf8(AppConstants.TokenID),
OwnerAddress = ByteString.CopyFrom(WalletAddress.Decode58Check(sender)),
ToAddress = ByteString.CopyFrom(WalletAddress.Decode58Check(receiver))
};
var transaction = await Client.TransferAssetAsync(contract);
if (transaction.Result.Result)
{
transaction.Transaction.RawData.Data = ByteString.CopyFromUtf8(data);
}
return(transaction);
}
public static PendingTokenMessage Create(string sender, string receiver, TokenMessage tokenMessage)
{
if (WalletAddress.Decode58Check(sender) == null)
{
throw new ArgumentException("invalid address", nameof(sender));
}
if (WalletAddress.Decode58Check(receiver) == null)
{
throw new ArgumentException("invalid address", nameof(receiver));
}
if (tokenMessage == null)
{
throw new ArgumentNullException(nameof(tokenMessage));
}
return(new PendingTokenMessage
{
Sender = sender,
Receiver = receiver,
Data = JsonConvert.SerializeObject(tokenMessage)
});
}
public override async void OnNavigatingTo(INavigationParameters parameters)
{
var navMode = parameters.GetNavigationMode();
if (navMode == NavigationMode.New)
{
if (parameters.TryGetValue(KnownNavigationParameters.XamlParam, out GroupInfo group) ||
parameters.TryGetValue("group", out group))
{
AddressQrCodeContent = group.TronAddress;
var dbGroup = await _database.Groups.GetByGroupID(group.GroupID);
if (dbGroup != null)
{
Group = dbGroup.ToGroupInfo();
}
group = await _syncServer.GetGroupAsync(group.GroupID, _walletManager.Wallet.Address);
if (group != null)
{
Group = group;
}
}
if (Group != null)
{
Users = new ObservableCollection <UserInfo>(Group.Users);
foreach (var user in Group.Users)
{
if (user.TronAddress.Equals(_walletManager.Wallet.Address))
{
GroupUserInfo = user;
}
}
EditName = Group.Name;
EditDescription = Group.Description;
EditImageUrl = Group.ImageUrl;
IsLoaded = true;
}
else
{
_userDialogs.Toast("Could not load group info");
await _navigationService.GoBackAsync();
}
}
else if (navMode == NavigationMode.Back)
{
if (parameters.TryGetValue("selected_address", out string address))
{
// Add user
if (WalletAddress.Decode58Check(address) != null)
{
_userDialogs.ShowLoading();
var user = await _syncServer.GetUserAsync(address);
if (user != null)
{
var ok = await _userDialogs.ConfirmAsync($"Do you want to add {user.Name}?", Group.Name);
if (ok)
{
try
{
var privKey = _walletManager.Wallet.Decrypt(Group.PrivateKey, Group.PublicKey);
var groupWallet = new Wallet(privKey);
var privKeyEnc = groupWallet.Encrypt(groupWallet.PrivateKey, user.PublicKey);
var pubKeyEnc = _walletManager.Wallet.Encrypt(user.TronAddress, AppConstants.PropertyAddressPublicKey);
var pendingId = await _tokenMessagesQueue.AddAsync(_walletManager.Wallet.Address, Group.TronAddress,
new AddUserToGroupTokenMessage
{
Address = pubKeyEnc,
PrivateKey = privKeyEnc
});
var waitResult = await _tokenMessagesQueue.WaitForAsync(pendingId);
await _userDialogs.AlertAsync($"{user.Name} will be added shortly", waitResult? "Added" : "Pending");
}
catch (Exception ex)
{
Debug.WriteLine(ex);
_userDialogs.Alert($"Something went wrong while adding {user.Name}", "Failed");
}
}
}
else
{
_userDialogs.Alert("Could not find user", "Adding Failed");
}
_userDialogs.HideLoading();
}
}
}
}
public override async void OnNavigatingTo(INavigationParameters parameters)
{
if (parameters.GetNavigationMode() == NavigationMode.New)
{
UserInfo chatPartner = null;
if (parameters.TryGetValue <ChatEntry>("ChatEntry", out var chat))
{
Chat = chat;
}
else if (parameters.TryGetValue("user", out UserInfo user))
{
chatPartner = user;
var dbChats = await _database.Chats.GetAll();
foreach (var dbChat in dbChats)
{
chat = dbChat.ToChatEntry();
if (chat.ChatPartner?.TronAddress == user.TronAddress)
{
Chat = chat;
}
}
}
else if (parameters.TryGetValue(KnownNavigationParameters.XamlParam, out object data) ||
parameters.TryGetValue("address", out data))
{
if (data is string address && WalletAddress.Decode58Check(address) != null)
{
var dbUser = await _database.Users.GetByAddress(address);
if (dbUser != null)
{
chatPartner = dbUser.ToUserInfo();
}
else
{
chatPartner = await _syncServer.GetUserAsync(address);
}
}
else if (data is ItemTappedEventArgs itemTappedEventArgs)
{
if (itemTappedEventArgs.ItemData is ChatEntry chatEntry)
{
Chat = chatEntry;
}
}
}
if (Chat == null && chatPartner != null)
{
Chat = new ChatEntry {
ID = 0, ChatPartner = chatPartner, Type = Enums.ChatType.Normal
};
}
if (Chat != null && Chat.Type == Enums.ChatType.Normal)
{
Title = Chat.ChatPartner.Name;
}
else
{
_userDialogs.Toast("not an user");
await _navigationService.GoBackAsync();
}
}
