public static bool OnGetBlockById(JToken id, string method, JArray parameters, out JToken result)
{
result = new JObject();
if (parameters == null || parameters.Count != 1)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, "Invalid parameters");
return(false);
}
try
{
SHA256Hash hash = SHA256Hash.Wrap(parameters[0].ToString().HexToBytes());
BlockCapsule block = Manager.Instance.DBManager.GetBlockById(hash);
BlockExtention block_extention = RpcApiService.CreateBlockExtention(block);
result = JToken.FromObject(block_extention.ToByteArray());
}
catch (System.Exception e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.UNKNOWN_ERROR, e.Message);
return(false);
}
return(true);
}
public static bool OnGetBlockByLatestNum(JToken id, string method, JArray parameters, out JToken result)
{
result = new JObject();
if (parameters == null || parameters.Count != 0)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, "Invalid parameters");
return(false);
}
try
{
List <BlockCapsule> blocks = Manager.Instance.DBManager.Block.GetBlockByLatestNum(1);
if (blocks == null || blocks.Count == 0)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INTERNAL_ERROR, "Can not load latest block.");
}
BlockExtention block_extention = RpcApiService.CreateBlockExtention(blocks[0]);
result = JToken.FromObject(block_extention.ToByteArray());
}
catch (InvalidCastException e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, e.Message);
return(false);
}
catch (System.Exception e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.UNKNOWN_ERROR, e.Message);
return(false);
}
return(true);
}
/// <summary>
/// Get block information
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0] : Block number (optional)
/// </param>
/// <returns></returns>
public static bool GetBlock(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <block number>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters != null && parameters.Length > 1)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
try
{
RpcApiResult result = null;
BlockExtention block = null;
if (parameters == null)
{
Console.WriteLine("Get current block.");
result = RpcApi.GetBlockByLatestNum(out block);
}
else
{
if (!long.TryParse(parameters[0], out long block_num))
{
Console.WriteLine("Invalid block number");
return(true);
}
result = RpcApi.GetBlock(block_num, out block);
}
if (result.Result)
{
Console.WriteLine(PrintUtil.PrintBlockExtention(block));
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
public static RpcApiResult GetBlockByLatestNum(out BlockExtention block)
{
block = null;
JObject receive = SendCommand(RpcCommand.Block.GetBlockByLatestNum, new JArray()
{
});
if (receive.TryGetValue("error", out JToken value))
{
return(new RpcApiResult(false, value["code"].ToObject <int>(), value["message"].ToObject <string>()));
}
block = BlockExtention.Parser.ParseFrom(receive["result"].ToObject <byte[]>());
return(RpcApiResult.Success);
}
public static BlockExtention CreateBlockExtention(BlockCapsule block)
{
if (block == null)
{
return(null);
}
BlockExtention block_extention = new BlockExtention();
block_extention.BlockHeader = block.Instance.BlockHeader;
block_extention.Blockid = ByteString.CopyFrom(block.Id.Hash);
foreach (Transaction transaction in block.Instance.Transactions)
{
block_extention.Transactions.Add(CreateTransactionExtention(new TransactionCapsule(transaction)));
}
return(block_extention);
}
public void Handle(TransactionExtention transaction, BlockExtention block, System.IServiceProvider serviceProvider, ref int converseTransactionCounter)
{
// Parse transaction contract data
if (transaction.Transaction.RawData.Contract.Count <= 0)
{
return;
}
var contract = transaction.Transaction.RawData.Contract[0];
if (contract.Type != Protocol.Transaction.Types.Contract.Types.ContractType.TransferAssetContract)
{
return;
}
var transferAssetContract = contract.Parameter.Unpack <TransferAssetContract>();
if (transferAssetContract.AssetName.ToStringUtf8() != (unchecked ((ulong)block.BlockHeader.RawData.Number) <=
_blockConfiguration.SyncUntilBlockWithTokenName ? _token.Name : _token.Id))
{
return;
}
converseTransactionCounter++;
// Get the TRON-Public Address
var senderAddress = Utils.Address.FromByteString(transferAssetContract.OwnerAddress);
var receiverAddress = Utils.Address.FromByteString(transferAssetContract.ToAddress);
var senderUser = DatabaseContext.CreateUsersWhenNotExist(new[] { senderAddress, receiverAddress }).Find(u => u.Address == senderAddress);
if (string.IsNullOrEmpty(senderUser.PublicKey))
{
var publicKey = transaction.Transaction.GetPublicKey();
if (publicKey != null)
{
senderUser.PublicKey = publicKey.EncodeBase64();
}
}
DatabaseContext.SaveChanges();
// Get message + transactionHash
var transactionHash = Crypto.Sha256.Hash(transaction.Transaction.RawData.ToByteArray())
.ToHexString()
.ToLower();
var message = transaction.Transaction.RawData.Data.ToStringUtf8();
_logger.Log.LogDebug(Logger.NewTransaction, "Handle new Transaction with Hash '{TransactionHash}'!", transactionHash);
try
{
var action = JsonConvert.DeserializeObject <Action.Action>(message);
if (action == null)
{
return;
}
_logger.Log.LogDebug(Logger.NewTransaction, "Handle Action " + action.Type.ToString() + "!");
// Actions only valid when sent to propertyAddress
if (Action.Constants.PropertyAddressTypes.Contains(action.Type))
{
if (receiverAddress != Singleton.WalletClient.WalletClient.PropertyAddress?.Address)
{
_logger.Log.LogDebug(Logger.ActionPropertyAddressInvalid, "This Action needs PropertyAddress as receiver!");
return;
}
}
var context = new Action.Context()
{
Sender = senderAddress,
Receiver = receiverAddress,
Message = message,
Transaction = transaction.Transaction,
TransactionHash = transactionHash,
Block = block,
ServiceProvider = serviceProvider,
DatabaseContext = DatabaseContext,
Logger = _logger,
};
switch (action.Type)
{
case Action.Type.UserChangeNickname:
Singleton.WalletClient.ActionHandlers.UserChangeNickname.Handle(context);
break;
case Action.Type.UserChangeStatus:
Singleton.WalletClient.ActionHandlers.UserChangeStatus.Handle(context);
break;
case Action.Type.UserChangeProfilePicture:
Singleton.WalletClient.ActionHandlers.UserChangeProfilePicture.Handle(context);
break;
case Action.Type.UserBlockUser:
Singleton.WalletClient.ActionHandlers.UserBlockUser.Handle(context);
break;
case Action.Type.UserSendMessage:
Singleton.WalletClient.ActionHandlers.UserSendMessage.Handle(context);
break;
case Action.Type.UserAddDeviceId:
Singleton.WalletClient.ActionHandlers.UserAddDeviceId.Handle(context);
break;
case Action.Type.GroupCreate:
Singleton.WalletClient.ActionHandlers.GroupCreate.Handle(context);
break;
case Action.Type.GroupChangeName:
Singleton.WalletClient.ActionHandlers.GroupChangeName.Handle(context);
break;
case Action.Type.GroupChangeDescription:
Singleton.WalletClient.ActionHandlers.GroupChangeDescription.Handle(context);
break;
case Action.Type.GroupChangePicture:
Singleton.WalletClient.ActionHandlers.GroupChangePicture.Handle(context);
break;
case Action.Type.GroupAddUser:
Singleton.WalletClient.ActionHandlers.GroupAddUser.Handle(context);
break;
case Action.Type.GroupKickUser:
Singleton.WalletClient.ActionHandlers.GroupKickUser.Handle(context);
break;
case Action.Type.GroupSetUserRank:
Singleton.WalletClient.ActionHandlers.GroupSetUserRank.Handle(context);
break;
case Action.Type.GroupJoin:
Singleton.WalletClient.ActionHandlers.GroupJoin.Handle(context);
break;
case Action.Type.GroupLeave:
Singleton.WalletClient.ActionHandlers.GroupLeave.Handle(context);
break;
case Action.Type.GroupMessage:
Singleton.WalletClient.ActionHandlers.GroupMessage.Handle(context);
break;
//case Action.Type.GroupSetPublic:
// break;
default:
_logger.Log.LogDebug(Logger.InvalidActionType, "Invalid ActionType({Type})!", action.Type);
break;
}
}
catch (Newtonsoft.Json.JsonException e)
{
_logger.Log.LogDebug(Logger.InvalidJsonFormat, "Could not parse JSON! Error: {Message}", e.Message);
}
}
