public async Task AccountUpdateTest()
{
var resp = await Api.LookupAccountNamesAsync(new[] { User.Login }, CancellationToken.None).ConfigureAwait(false);
var acc = resp.Result[0];
var op = new AccountUpdateOperation(User.Login, acc.MemoKey, acc.JsonMetadata);
await Post(User.ActiveKeys, false, op).ConfigureAwait(false);
}
public TransferCoreTransaction(long accountId, long receiverAccountId, long amount, string reason) : base(CoreTransactionTypes.Transfer, accountId)
{
ReceiverAccountId = receiverAccountId;
Amount = amount;
Reason = reason;
if (!AccountUpdateOperation.IsReasonValid(reason))
{
throw new ArgumentException("Reason text is invalid", nameof(reason));
}
}
public async Task AccountUpdateTest()
{
var args = new FindAccountsArgs
{
Accounts = new[] { User.Login }
};
var resp = await Api.FindAccountsAsync(args, CancellationToken.None).ConfigureAwait(false);
var acc = resp.Result.Accounts[0];
var op = new AccountUpdateOperation(User.Login, acc.MemoKey, acc.JsonMetadata);
await Post(User.ActiveKeys, false, op).ConfigureAwait(false);
}
public async Task AccountUpdateTest()
{
var resp = Api.LookupAccountNames(new[] { User.Login }, CancellationToken.None);
WriteLine(resp);
Assert.IsFalse(resp.IsError);
var acc = resp.Result[0];
var op = new AccountUpdateOperation(User.Login, acc.MemoKey, acc.JsonMetadata);
var response = Post(User.ActiveKeys, false, op);
Assert.IsFalse(response.IsError, response.GetErrorMessage());
}
public override async Task <OperationResult <VoidResponse> > UpdateUserProfile(UpdateUserProfileModel model, CancellationToken ct)
{
return(await Task.Run(() =>
{
if (!TryReconnectChain(ct))
{
return new OperationResult <VoidResponse>(new AppError(LocalizationKeys.EnableConnectToBlockchain));
}
var keys = ToKeyArr(model.ActiveKey);
if (keys == null)
{
return new OperationResult <VoidResponse>(new AppError(LocalizationKeys.WrongPrivateActimeKey));
}
var findAccountsArgs = new FindAccountsArgs
{
Accounts = new[] { model.Login }
};
var resp = _operationManager.FindAccounts(findAccountsArgs, CancellationToken.None);
var result = new OperationResult <VoidResponse>();
if (resp.IsError)
{
OnError(resp, result);
return result;
}
var profile = resp.Result.Accounts.Length == 1 ? resp.Result.Accounts[0] : null;
if (profile == null)
{
result.Error = new BlockchainError(LocalizationKeys.UnexpectedProfileData);
return result;
}
var editedMeta = UpdateProfileJson(profile.JsonMetadata, model);
var op = new AccountUpdateOperation(model.Login, profile.MemoKey, editedMeta);
var resp2 = _operationManager.BroadcastOperationsSynchronous(keys, ct, op);
if (!resp2.IsError)
{
result.Result = new VoidResponse();
}
else
{
OnError(resp2, result);
}
return result;
}, ct));
}
public override async Task <OperationResult <VoidResponse> > UpdateUserProfile(UpdateUserProfileModel model, CancellationToken ct)
{
var isConnected = await TryReconnectChain(ct);
if (!isConnected)
{
return(new OperationResult <VoidResponse>(new ValidationException(LocalizationKeys.EnableConnectToBlockchain)));
}
var keys = ToKeyArr(model.ActiveKey);
if (keys == null)
{
return(new OperationResult <VoidResponse>(new ValidationException(LocalizationKeys.WrongPrivateActimeKey)));
}
var resp = await _operationManager.LookupAccountNames(new[] { model.Login }, CancellationToken.None);
var result = new OperationResult <VoidResponse>();
if (resp.IsError)
{
result.Exception = new RequestException(resp);
return(result);
}
var profile = resp.Result.Length == 1 ? resp.Result[0] : null;
if (profile == null)
{
result.Exception = new ValidationException(LocalizationKeys.UnexpectedProfileData);
return(result);
}
var editedMeta = UpdateProfileJson(profile.JsonMetadata, model);
var op = new AccountUpdateOperation(model.Login, profile.MemoKey, editedMeta);
var resp2 = await _operationManager.BroadcastOperationsSynchronous(keys, ct, op);
if (resp2.IsError)
{
result.Exception = new RequestException(resp2);
}
else
{
result.Result = new VoidResponse();
}
return(result);
}
public override async Task <OperationResult <VoidResponse> > UpdateUserProfile(UpdateUserProfileModel model, CancellationToken ct)
{
var isConnected = await TryReconnectChain(ct);
if (!isConnected)
{
return(new OperationResult <VoidResponse>(new ValidationException(LocalizationKeys.EnableConnectToBlockchain)));
}
var keys = ToKeyArr(model.ActiveKey);
if (keys == null)
{
return(new OperationResult <VoidResponse>(new ValidationException(LocalizationKeys.WrongPrivateActimeKey)));
}
var args = new FindAccountsArgs
{
Accounts = new[] { model.Login }
};
var resp = await _operationManager.FindAccounts(args, CancellationToken.None);
var result = new OperationResult <VoidResponse>();
if (resp.IsError)
{
result.Exception = new RequestException(resp);
return(result);
}
var profile = resp.Result.Accounts.Length == 1 ? resp.Result.Accounts[0] : null;
if (profile == null)
{
result.Exception = new ValidationException(LocalizationKeys.UnexpectedProfileData);
return(result);
}
var editedMeta = UpdateProfileJson(profile.JsonMetadata, model);
var op = new AccountUpdateOperation(model.Login, profile.MemoKey, editedMeta);
return(await Broadcast(keys, new BaseOperation[] { op }, ct));
}
public async Task AccountUpdateTest()
{
var args = new FindAccountsArgs()
{
Accounts = new[] { User.Login }
};
var resp = Api.FindAccounts(args, CancellationToken.None);
Console.WriteLine(resp.Error);
Assert.IsFalse(resp.IsError);
Console.WriteLine(JsonConvert.SerializeObject(resp.Result));
var acc = resp.Result.Accounts[0];
var op = new AccountUpdateOperation(User.Login, acc.MemoKey, acc.JsonMetadata);
var response = Post(User.ActiveKeys, false, op);
Assert.IsFalse(response.IsError, response.GetErrorMessage());
}
protected override bool Parse(ArgumentsParser arguments)
{
targetaccount = arguments.Long(nameof(targetaccount), -1);
reason = arguments.String(nameof(reason), null);
password = arguments.String(nameof(password), null);
var amountstr = arguments.String(nameof(amount), null);
if (targetaccount < 0 || string.IsNullOrWhiteSpace(amountstr) || !WalletApp.IsValidPassword(password) || !AccountUpdateOperation.IsReasonValid(reason))
{
return(false);
}
var hasDot = false;
foreach (var c in amountstr)
{
if (c == '.' && !hasDot)
{
hasDot = true;
continue;
}
if (!(c >= '0' && c <= '9'))
{
SetError("Amount invalid");
return(false);
}
}
if (!decimal.TryParse(amountstr, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var d))
{
SetError("Amount invalid");
return(false);
}
amount = Currency.ToHel(d);
return(amount > 0);
}
TransactionResultTypes ConsumeTransaction(CoreTransaction transaction, bool addExtraTime)
{
if (transaction.IsExpired(addExtraTime))
{
return(TransactionResultTypes.Expired);
}
var r = _coreChain.BlockStorage.HistoryContainsTransactionOrRegistration(transaction);
if (r != TransactionResultTypes.Ok)
{
return(r);
}
var coreType = transaction.TransactionType;
if (coreType != CoreTransactionTypes.AccountRegistration)
{
var account = GetCoreAccount(transaction.AccountId);
if (account == null)
{
return(TransactionResultTypes.InvalidCoreAccount);
}
var key = account.AccountKey;
if (coreType == CoreTransactionTypes.ChainUpdate)
{
var update = transaction as ChainUpdateCoreTransaction;
var chain = GetChainInfo(update.ChainId);
var keyIndex = update.SignKeyIndex;
if (keyIndex != Protocol.CoreAccountSignKeyIndex)
{
var result = CheckChainKey(update.ChainId, keyIndex, true, ref key);
if (result != TransactionResultTypes.Ok)
{
return(result);
}
}
else if (transaction.AccountId != chain.AccountId)
{
return(TransactionResultTypes.InvalidCoreAccount);
}
}
else if (coreType == CoreTransactionTypes.ServiceBlock)
{
var serviceBlockTransaction = transaction as ServiceBlockCoreTransaction;
var block = serviceBlockTransaction.ServiceBlock;
key = _coreChain.GetValidPublicChainKeyWithFlags(block.ChainId, block.ChainIndex, block.Issuer, PublicChainKeyFlags.ServiceChainVoteKey, transaction.Timestamp)?.PublicKey;
}
if (!transaction.IsSignatureValid(key))
{
return(TransactionResultTypes.InvalidSignature);
}
}
else
{
var register = transaction as AccountRegistrationCoreTransaction;
if (!transaction.IsSignatureValid(register.PublicKey))
{
return(TransactionResultTypes.InvalidSignature);
}
}
if (coreType == CoreTransactionTypes.AccountRegistration)
{
var registration = transaction as AccountRegistrationCoreTransaction;
var account = new CoreAccount(NextAccountId, registration.PublicKey);
_accounts[account.AccountId] = account;
NextAccountId++;
_blockInfo.AddNewAccount(registration, account);
return(TransactionResultTypes.Ok);
}
if (coreType == CoreTransactionTypes.ChainRegistration || coreType == CoreTransactionTypes.ChainUpdate)
{
var update = transaction as ChainUpdateCoreTransaction;
var registration = transaction as ChainRegistrationCoreTransaction;
var isUpdate = update != null;
var account = GetCoreAccount(transaction.AccountId);
if (account == null)
{
return(TransactionResultTypes.InvalidCoreAccount);
}
ChainInfo chain = null;
if (isUpdate)
{
chain = GetChainInfo(update.ChainId);
if (chain == null)
{
return(TransactionResultTypes.ChainNotFound);
}
}
if (!registration.ChainWebsite.IsValdiUrl())
{
return(TransactionResultTypes.InvalidChainWebsite);
}
if (registration.ChainName != null && registration.ChainName.Length > ChainRegistrationCoreTransaction.MaxNameLength)
{
return(TransactionResultTypes.InvalidChainName);
}
foreach (var endPoint in registration.PublicEndpoints)
{
if (!endPoint.IsValdiUrl(false))
{
return(TransactionResultTypes.InvalidChainEndpoint);
}
}
var indices = new HashSet <short>();
foreach (var chainKey in registration.ChainKeys)
{
if (indices.Contains(chainKey.KeyIndex))
{
return(TransactionResultTypes.InvaidChainKey);
}
indices.Add(chainKey.KeyIndex);
}
foreach (var purchase in registration.Purchases)
{
if (purchase.PurchaseType == PurchaseTypes.None)
{
return(TransactionResultTypes.InvalidChainPurchase);
}
foreach (var p in registration.Purchases)
{
if (purchase == p)
{
continue;
}
if (p.PurchaseItemId == purchase.PurchaseItemId && p.PurchaseGroupId == purchase.PurchaseGroupId)
{
return(TransactionResultTypes.InvalidChainPurchase);
}
if (p.PurchaseGroupId == purchase.PurchaseGroupId && p.PurchaseType != purchase.PurchaseType)
{
return(TransactionResultTypes.InvalidChainPurchase);
}
}
}
if (!isUpdate)
{
chain = new ChainInfo(NextChainId, registration.AccountId, registration.ChainName, registration.ChainWebsite);
var operation = new ChainInfoOperation(chain.ChainId, chain.AccountId, chain.Name, chain.Website, registration.Timestamp, registration.ChainKeys, registration.PublicEndpoints, registration.Purchases);
_chains[chain.ChainId] = chain;
NextChainId++;
_blockInfo.AddChainUpdate(registration, operation);
}
else
{
var result = chain.IsUpdateValid(update);
if (result != TransactionResultTypes.Ok)
{
return(result);
}
var operation = new ChainInfoOperation(chain.ChainId, update.AccountId, update.ChainName, update.ChainWebsite, registration.Timestamp, update.ChainKeys, update.PublicEndpoints, update.Purchases, update.RevokeChainKeys, update.RemovePublicEndPoints, update.RemovePurchaseItems);
_blockInfo.AddChainUpdate(update, operation);
}
return(TransactionResultTypes.Ok);
}
if (coreType == CoreTransactionTypes.Transfer)
{
var transfer = transaction as TransferCoreTransaction;
if (!AccountUpdateOperation.IsReasonValid(transfer.Reason))
{
return(TransactionResultTypes.InvalidTransferReason);
}
if (transfer.AccountId == transfer.ReceiverAccountId)
{
return(TransactionResultTypes.InvalidReceiverAccount);
}
var sender = GetCoreAccount(transfer.AccountId);
var receiver = GetCoreAccount(transfer.ReceiverAccountId);
if (receiver == null)
{
return(TransactionResultTypes.InvalidReceiverAccount);
}
if (sender != null)
{
var amount = transfer.Amount;
if (sender.CanTransfer(amount))
{
sender.RemoveFromTranfser(amount);
receiver.AddFromTransfer(amount);
_blockInfo.AddTransfer(transfer);
return(TransactionResultTypes.Ok);
}
return(TransactionResultTypes.InsuficientBalance);
}
return(TransactionResultTypes.InvalidTransaction);
}
if (coreType == CoreTransactionTypes.ServiceBlock)
{
var serviceBlockTransaction = (transaction as ServiceBlockCoreTransaction);
var block = serviceBlockTransaction.ServiceBlock;
var chainInfo = GetChainInfo(block.ChainId);
if (chainInfo == null)
{
return(TransactionResultTypes.ChainNotFound);
}
if (block.TransactionCount == 0)
{
return(TransactionResultTypes.InvalidTransaction);
}
var state = chainInfo.LastState;
if ((state.BlockId + 1) != block.BlockId)
{
return(TransactionResultTypes.InvalidBlock);
}
foreach (var serviceTransaction in block.Transactions)
{
var serviceType = serviceTransaction.TransactionType;
var accountId = serviceTransaction.AccountId;
var account = GetCoreAccount(accountId);
if (account == null)
{
return(TransactionResultTypes.InvalidCoreAccount);
}
if (!serviceTransaction.IsSignatureValid(account.AccountKey))
{
return(TransactionResultTypes.InvalidSignature);
}
if (serviceType == ServiceTransactionTypes.Join)
{
var joinTransaction = serviceTransaction as JoinServiceTransaction;
var key = joinTransaction.AccountKey;
if (key == null || (key != null && key.IsKeySignatureValid(account.AccountKey)))
{
continue;
}
return(TransactionResultTypes.InvalidSignature);
}
if (serviceType == ServiceTransactionTypes.Purchase)
{
var purchaseTransaction = serviceTransaction as PurchaseServiceTransaction;
var buyer = GetCoreAccount(purchaseTransaction.AccountId);
var receiver = GetCoreAccount(purchaseTransaction.ReceiverAccountId);
if (buyer != null && receiver != null && chainInfo.IsPurchaseValid(purchaseTransaction.PurchaseGroupId, purchaseTransaction.PurchaseItemId, purchaseTransaction.Price))
{
var chainAccount = GetCoreAccount(chainInfo.AccountId);
if (chainAccount != null && buyer.CanPurchase(purchaseTransaction.Price))
{
//buyer.Purchase(purchaseTransaction.Price, chainAccount);
continue;
}
return(TransactionResultTypes.CannotPurchase);
}
return(TransactionResultTypes.InvalidCoreAccount);
}
if (serviceType == ServiceTransactionTypes.RequestRevenue)
{
var totalRevenue = chainInfo.GetTotalAccountRevenue(transaction.Timestamp);
var totalPayout = chainInfo.TotalAccountPayout;
var availablePayout = totalRevenue - totalPayout;
var revenueTransaction = serviceTransaction as RequestRevenueServiceTransaction;
if (availablePayout >= revenueTransaction.PayoutAmount)
{
continue;
}
}
return(TransactionResultTypes.InvalidTransaction);
}
if (!_coreChain.IsBlockProposalSignatureValid(block, serviceBlockTransaction.ProposalSignatures))
{
return(TransactionResultTypes.InvalidBlockSignature);
}
_blockInfo.AddServiceBlock(serviceBlockTransaction);
return(TransactionResultTypes.Ok);
}
return(TransactionResultTypes.InvalidTransaction);
}
public AccountTable(long blockNum, short trxNum, short opNum, DateTime timestamp, AccountUpdateOperation operation)
: base(blockNum, trxNum, opNum, timestamp)
{
Login = operation.Account;
JsonData = operation.JsonMetadata;
}
