public AccountWithPublicKey GetAccountFromSecretPhrase(string secretPhrase)
{
var localAccountService = new LocalAccountService();
var accountWithPublicKey = localAccountService.GetAccount(AccountIdLocator.BySecretPhrase(secretPhrase));
return(accountWithPublicKey);
}
private void GetAccountProperties()
{
var localAccountService = new LocalAccountService();
TestSettings.Account1 = localAccountService.GetAccount(AccountIdLocator.BySecretPhrase(TestSettings.SecretPhrase1));
TestSettings.Account2 = localAccountService.GetAccount(AccountIdLocator.BySecretPhrase(TestSettings.SecretPhrase2));
}
static CreateTransaction()
{
var localCrypto = new LocalAccountService();
SecretPhrase = TestSettings.SecretPhrase1;
Account = localCrypto.GetAccount(AccountIdLocator.BySecretPhrase(SecretPhrase));
}
public string GeneratePasswordWithAccountEnding(string ending)
{
if (string.IsNullOrWhiteSpace(ending))
{
throw new ArgumentException("Must have a value", nameof(ending));
}
if (ending.Length > 5)
{
throw new ArgumentException("Ending is too long, maximum 5 chars is allowed", nameof(ending));
}
if (ending.ToCharArray().ToList().Any(c => !AllowedAccountCharacters.Contains(c)))
{
throw new ArgumentException($"Illegal characters: {ending}, only these are allowed: {AllowedAccountCharacters}", nameof(ending));
}
var found = false;
var password = string.Empty;
while (!found)
{
password = GeneratePassword();
var account = _localAccountService.GetAccount(AccountIdLocator.BySecretPhrase(password));
if (account.AccountRs.EndsWith(ending))
{
found = true;
}
}
return(password);
}
public AccountWithPublicKey GetAccount(AccountIdLocator locator)
{
var publicKey = !string.IsNullOrEmpty(locator.SecretPhrase)
? _crypto.GetPublicKey(locator.SecretPhrase)
: locator.PublicKey;
var accountId = _crypto.GetAccountIdFromPublicKey(publicKey);
return(new AccountWithPublicKey(accountId, publicKey));
}
private async Task CheckShufflingDistributionTransactions()
{
if (!_knownTransactions.Any())
{
var shufflings = (await _nxtServer.GetShufflingsStageDone()).ToList();
var localAccountService = new LocalAccountService();
var found = false;
var shufflingIndex = 0;
while (!found && shufflings.Count() > shufflingIndex)
{
var shuffling = shufflings[shufflingIndex];
foreach (var recipientPublicKey in shuffling.RecipientPublicKeys)
{
var account = localAccountService.GetAccount(AccountIdLocator.ByPublicKey(recipientPublicKey));
if (_walletRepository.NxtAccount.AccountId == account.AccountId)
{
var participants = await _nxtServer.GetShufflingParticipants(shuffling.ShufflingId);
var lastParticipant = participants.Participants.Single(p => p.NextAccountId == 0);
var lastParticipantToVerify = participants.Participants.Single(p => p.NextAccountId == lastParticipant.AccountId);
var verifyShufflingTransactions = await _nxtServer.GetTransactionsAsync(lastParticipantToVerify.AccountRs, TransactionSubType.ShufflingVerification);
var verifyShufflingTransaction = verifyShufflingTransactions.Single(t => ((ShufflingVerificationAttachment)t.Attachment).ShufflingId == shuffling.ShufflingId);
var block = await _nxtServer.GetBlockAsync(verifyShufflingTransaction.Height);
var transaction = new ShufflingDistributionTransaction
{
AccountFrom = Transaction.GeneratedFromAddress,
AccountTo = _walletRepository.NxtAccount.AccountRs,
Height = verifyShufflingTransaction.Height,
IsConfirmed = true,
NqtAmount = shuffling.Amount.Nqt,
Message = "[Shuffling Distribution]",
NqtFee = 0,
RecipientPublicKey = recipientPublicKey.ToHexString(),
ShufflingId = (long)shuffling.ShufflingId,
Timestamp = block.Timestamp,
TransactionType = TransactionType.ShufflingDistribution,
UserIsTransactionSender = false,
UserIsTransactionRecipient = true
};
_newTransactions.Add(transaction);
found = true;
break;
}
}
shufflingIndex++;
}
}
}
private void SetupAccounts(string readOnlyAccount)
{
IsReadOnlyAccount = !string.IsNullOrEmpty(readOnlyAccount);
if (IsReadOnlyAccount)
{
NxtAccount = readOnlyAccount;
}
else
{
NxtAccountWithPublicKey = new LocalAccountService().GetAccount(AccountIdLocator.BySecretPhrase(SecretPhrase));
NxtAccount = NxtAccountWithPublicKey;
}
}
private static void Main()
{
var generator = new LocalPasswordGenerator();
var accountService = new LocalAccountService();
Console.Write("Enter desired ending:");
var ending = Console.ReadLine();
var secretPhrase = generator.GeneratePasswordWithAccountEnding(ending);
var account = accountService.GetAccount(AccountIdLocator.BySecretPhrase(secretPhrase));
Console.WriteLine($"Generated NXT Address: {account.AccountRs}");
Console.WriteLine($"Secret phrase: {secretPhrase}");
Console.WriteLine("Press enter to quit.");
Console.ReadLine();
}
public async Task <NxtAccount> AddAccount()
{
var localPasswordGenerator = new LocalPasswordGenerator();
var localAccountService = new LocalAccountService();
var secretPhrase = localPasswordGenerator.GeneratePassword();
var accountWithPublicKey = localAccountService.GetAccount(AccountIdLocator.BySecretPhrase(secretPhrase));
var account = new NxtAccount
{
Address = accountWithPublicKey.AccountRs,
SecretPhrase = secretPhrase,
BalanceNqt = 0
};
await wallet.AddAccount(account);
return(account);
}
public LocalGeneratedToken GenerateToken(string secretPhrase, string message, DateTime?timestamp = null)
{
var messageBytes = Encoding.UTF8.GetBytes(message);
if (!timestamp.HasValue)
{
timestamp = DateTime.UtcNow;
}
var datetimeConverter = new DateTimeConverter();
var nxtTimestamp = datetimeConverter.GetNxtTimestamp(timestamp.Value);
var tokenString = _crypto.GenerateToken(secretPhrase, messageBytes, nxtTimestamp);
var generatedToken = new LocalGeneratedToken
{
Timestamp = datetimeConverter.GetFromNxtTime(nxtTimestamp),
Token = tokenString,
Valid = true,
Account = _localAccountService.GetAccount(AccountIdLocator.BySecretPhrase(secretPhrase))
};
return(generatedToken);
}
private void TestDecodeToken()
{
var random = new Random();
using (Logger = new TestsessionLogger(_logger))
{
for (var i = 0; i < 100; i++)
{
var expected = BuildRandomString(random);
var token = _localTokenService.GenerateToken(TestSettings.SecretPhrase1, expected);
var decodedToken = _localTokenService.DecodeToken(expected, token.Token);
var serviceDecodedToken = _tokenService.DecodeToken(expected, token.Token).Result;
var account = _localAccountService.GetAccount(AccountIdLocator.ByPublicKey(decodedToken.PublicKey));
AssertEquals(token.Timestamp, decodedToken.Timestamp, nameof(decodedToken.Timestamp));
AssertEquals(serviceDecodedToken.Account, account.AccountId, nameof(decodedToken.PublicKey));
AssertEquals(serviceDecodedToken.AccountRs, account.AccountRs, nameof(decodedToken.PublicKey));
AssertEquals(TestSettings.Account1.PublicKey.ToHexString(), decodedToken.PublicKey.ToHexString(), nameof(decodedToken.PublicKey));
AssertIsTrue(decodedToken.Valid, nameof(decodedToken.Valid));
}
}
}
public async Task Init()
{
var accountIdReply = await _accountService.GetAccountId(AccountIdLocator.BySecretPhrase(_secretPhrase));
_accountId = accountIdReply.AccountId;
}
