public static TransactionExtention CreateTransactionExtention(TransactionCapsule transaction)
{
TransactionExtention extention = new TransactionExtention();
extention.Result = new Return();
try
{
extention.Transaction = transaction.Instance;
extention.Txid = ByteString.CopyFrom(transaction.Id.Hash);
extention.Result.Result = true;
extention.Result.Code = Return.Types.response_code.Success;
}
catch (ContractValidateException e)
{
extention.Result.Result = false;
extention.Result.Code = Return.Types.response_code.ContractValidateError;
extention.Result.Message = ByteString.CopyFromUtf8("Contract validate error " + e.Message);
Logger.Debug(
string.Format("ContractValidateException: {0}", e.Message));
}
catch (System.Exception e)
{
extention.Result.Result = false;
extention.Result.Code = Return.Types.response_code.ContractValidateError;
extention.Result.Message = ByteString.CopyFromUtf8(e.Message);
Logger.Debug("Exception caught" + e.Message);
}
return(extention);
}
public static bool OnGetTransactionById(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());
TransactionExtention transaction_extention = RpcApiService.GetTransactionById(hash);
result = JToken.FromObject(transaction_extention.ToByteArray());
}
catch (ItemNotFoundException e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.NOT_FOUN_ITEM, e.Message);
return(false);
}
catch (System.Exception e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.UNKNOWN_ERROR, e.Message);
return(false);
}
return(true);
}
private async Task <TransactionExtention> CreateTransactionAsync(string from, string to, long amount)
{
var fromAddress = Base58Encoder.DecodeFromBase58Check(from);
var toAddress = Base58Encoder.DecodeFromBase58Check(to);
var transferContract = new TransferContract
{
OwnerAddress = ByteString.CopyFrom(fromAddress),
ToAddress = ByteString.CopyFrom(toAddress),
Amount = amount
};
var transaction = new Transaction();
var contract = new Transaction.Types.Contract();
try
{
contract.Parameter = Google.Protobuf.WellKnownTypes.Any.Pack(transferContract);
}
catch (Exception)
{
return(new TransactionExtention
{
Result = new Return {
Result = false, Code = Return.Types.response_code.OtherError
},
});
}
var newestBlock = await _wallet.GetNowBlock2Async(new EmptyMessage());
contract.Type = Transaction.Types.Contract.Types.ContractType.TransferContract;
transaction.RawData = new Transaction.Types.raw();
transaction.RawData.Contract.Add(contract);
transaction.RawData.Timestamp = DateTime.Now.Ticks;
transaction.RawData.Expiration = newestBlock.BlockHeader.RawData.Timestamp + 10 * 60 * 60 * 1000;
var blockHeight = newestBlock.BlockHeader.RawData.Number;
var blockHash = Sha256Sm3Hash.Of(newestBlock.BlockHeader.RawData.ToByteArray()).GetBytes();
var bb = ByteBuffer.Allocate(8);
bb.PutLong(blockHeight);
var refBlockNum = bb.ToArray();
transaction.RawData.RefBlockHash = ByteString.CopyFrom(blockHash.SubArray(8, 8));
transaction.RawData.RefBlockBytes = ByteString.CopyFrom(refBlockNum.SubArray(6, 2));
var transactionExtension = new TransactionExtention
{
Transaction = transaction,
Txid = ByteString.CopyFromUtf8(transaction.GetTxid()),
Result = new Return {
Result = true, Code = Return.Types.response_code.Success
},
};
return(transactionExtension);
}
/// <summary>
/// Create proposal
/// </summary>
/// <param name="parameters"></param>
/// /// Parameter Index
/// [0~] : Proposal pair parameter
/// <returns></returns>
public static bool CreateProposal(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <id 1> <value 1> <id 2> <value 2> ...\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length < 2 || parameters.Length % 2 != 0)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
Dictionary <long, long> proposal = new Dictionary <long, long>();
for (int i = 0; i < parameters.Length; i += 2)
{
long id = long.Parse(parameters[i]);
long value = long.Parse(parameters[i + 1]);
proposal.Add(id, value);
}
RpcApiResult result = RpcApi.CreateProposalContract(owner_address,
proposal,
out ProposalCreateContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.ProposalCreateContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Update setting
/// </summary>
/// <param name="parameters"></param>
/// /// Parameter Index
/// [0] : Contract address
/// [1] : Consume user resource percent
/// <returns></returns>
public static bool UpdateSetting(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <address> <consume user resource percent>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length != 2)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
byte[] contract_address = Wallet.Base58ToAddress(parameters[0]);
long resource_percent = long.Parse(parameters[1]);
if (resource_percent > 100 || resource_percent < 0)
{
Console.WriteLine("Consume user resource percent must be 0 to 100.");
return(true);
}
RpcApiResult result = RpcApi.CreateUpdateSettingContract(owner_address,
contract_address,
resource_percent,
out UpdateSettingContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.UpdateSettingContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Update asset
/// </summary>
/// <param name="parameters"></param>
/// /// Parameter Index
/// [0] : Limit
/// [1] : Public limit
/// [2] : Description
/// [3] : url
/// <returns></returns>
public static bool UpdateAsset(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <limit> <public limit> <description> <url>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length != 4)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
long limit = long.Parse(parameters[0]);
long public_limit = long.Parse(parameters[1]);
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
byte[] description = Encoding.UTF8.GetBytes(parameters[2]);
byte[] url = Encoding.UTF8.GetBytes(parameters[3]);
RpcApiResult result = RpcApi.CreateUpdateAssetContract(owner_address,
description,
url,
limit,
public_limit,
out UpdateAssetContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.UpdateAssetContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Transfer asset
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0] : To address
/// [1] : Asset name
/// [2] : Amount
/// </param>
/// <returns></returns>
public static bool TransferAsset(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <to address> <asset name> <amount>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length != 3)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] to_address = Encoding.UTF8.GetBytes(parameters[0]);
byte[] asset_name = Encoding.UTF8.GetBytes(parameters[1]);
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
long amount = long.Parse(parameters[2]);
RpcApiResult result = RpcApi.CreateTransferAssetContract(to_address,
owner_address,
asset_name,
amount,
out TransferAssetContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.TransferAssetContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Vote
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0~] : vote pair parameter
/// </param>
/// <returns></returns>
public static bool VoteWitness(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <address 1> <amount 1> <address 2> <amount 2> ...\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length < 2 || parameters.Length % 2 != 0)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
Dictionary <byte[], long> votes = new Dictionary <byte[], long>(new ByteArrayEqualComparer());
for (int i = 0; i < parameters.Length; i += 2)
{
byte[] address = Wallet.Base58ToAddress(parameters[i]);
long amount = long.Parse(parameters[i + 1]);
votes.Add(address, amount);
}
RpcApiResult result = RpcApi.CreateVoteWitnessContract(owner_address,
votes,
out VoteWitnessContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.VoteWitnessContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Update setting
/// </summary>
/// <param name="parameters"></param>
/// /// Parameter Index
/// [0] : Proposal id
/// <returns></returns>
public static bool DeleteProposal(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <id>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length != 1)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
long id = long.Parse(parameters[0]);
RpcApiResult result = RpcApi.CreateProposalDeleteContract(owner_address,
id,
out ProposalDeleteContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.ProposalDeleteContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Update account permission
/// </summary>
/// <param name="parameters"></param>
/// /// Parameter Index
/// [0] : Owner address
/// [1] : Permission json
/// <returns></returns>
public static bool UpdateAccountPermission(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <owner address> <permission(json format)>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length != 2)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(parameters[0]);
string permission = parameters[2];
RpcApiResult result = RpcApi.CreateAccountPermissionUpdateContract(owner_address,
permission,
out AccountPermissionUpdateContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.AccountPermissionUpdateContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Transfer asset
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// </param>
/// <returns></returns>
public static bool UnfreezeAsset(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <to address> <asset name> <amount>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters != null)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
RpcApiResult result = RpcApi.CreateUnfreezeAssetContract(owner_address,
out UnfreezeAssetContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.UnfreezeAssetContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
public static TransactionExtention GetTransactionById(SHA256Hash hash)
{
TransactionExtention transaction_extention = null;
try
{
Transaction transaction = Manager.Instance.DBManager.GetTransactionById(hash);
if (transaction != null)
{
transaction_extention = CreateTransactionExtention(new TransactionCapsule(transaction));
}
else
{
throw new ItemNotFoundException("Not found transaction");
}
}
catch (System.Exception e)
{
throw e;
}
return(transaction_extention);
}
public static RpcApiResult CreateTransaction(IMessage contract,
ContractType contract_type,
out TransactionExtention transaction_extention)
{
try
{
transaction_extention = null;
JObject receive = SendCommand(RpcCommand.Transaction.CreateTransaction,
new JArray()
{
contract_type,
contract.ToByteArray()
});
if (receive.TryGetValue("error", out JToken value))
{
return(new RpcApiResult(false, value["code"].ToObject <int>(), value["message"].ToObject <string>()));
}
transaction_extention = TransactionExtention.Parser.ParseFrom(receive["result"].ToObject <byte[]>());
Return ret = transaction_extention.Result;
if (!ret.Result)
{
OutputTransactionErrorMessage((int)ret.Code, ret.Message.ToStringUtf8());
return(new RpcApiResult(false, RpcMessage.TRANSACTION_ERROR, ""));
}
}
catch (System.Exception e)
{
throw e;
}
return(RpcApiResult.Success);
}
public static RpcApiResult GetTransactionById(string transaction_id, out TransactionExtention transaction)
{
transaction = null;
try
{
JObject receive = SendCommand(RpcCommand.Transaction.GetTransactionById, new JArray()
{
transaction_id
});
if (receive.TryGetValue("error", out JToken value))
{
return(new RpcApiResult(false, value["code"].ToObject <int>(), value["message"].ToObject <string>()));
}
transaction = TransactionExtention.Parser.ParseFrom(receive["result"].ToObject <byte[]>());
}
catch (System.Exception e)
{
throw e;
}
return(RpcApiResult.Success);
}
public static bool OnCreateContract(JToken id, string method, JArray parameters, out JToken result)
{
result = new JObject();
if (parameters == null || parameters.Count != 2)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, "Invalid parameters");
return(false);
}
try
{
IMessage contract = null;
ContractType contract_type = (ContractType)parameters[0].ToObject <int>();
switch (contract_type)
{
case ContractType.AccountCreateContract:
contract = AccountCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.TransferContract:
contract = TransferContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.TransferAssetContract:
contract = TransferAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.VoteAssetContract:
contract = VoteAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.VoteWitnessContract:
contract = VoteWitnessContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.WitnessCreateContract:
contract = WitnessCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.AssetIssueContract:
contract = AssetIssueContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.WitnessUpdateContract:
contract = WitnessUpdateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ParticipateAssetIssueContract:
contract = ParticipateAssetIssueContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.AccountUpdateContract:
contract = AccountUpdateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.FreezeBalanceContract:
contract = FreezeBalanceContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UnfreezeBalanceContract:
contract = UnfreezeBalanceContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.WithdrawBalanceContract:
contract = WithdrawBalanceContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UnfreezeAssetContract:
contract = UnfreezeAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UpdateAssetContract:
contract = UpdateAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ProposalCreateContract:
contract = ProposalCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ProposalApproveContract:
contract = ProposalApproveContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ProposalDeleteContract:
contract = ProposalDeleteContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.SetAccountIdContract:
contract = SetAccountIdContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.CreateSmartContract:
contract = CreateSmartContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.TriggerSmartContract:
contract = TriggerSmartContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UpdateSettingContract:
contract = UpdateSettingContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeCreateContract:
contract = ExchangeCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeInjectContract:
contract = ExchangeInjectContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeWithdrawContract:
contract = ExchangeWithdrawContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeTransactionContract:
contract = ExchangeTransactionContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UpdateEnergyLimitContract:
contract = UpdateEnergyLimitContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.AccountPermissionUpdateContract:
contract = AccountPermissionUpdateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.CustomContract:
case ContractType.GetContract:
case ContractType.ClearAbicontract:
default:
break;
}
TransactionExtention transaction_extention = RpcApiService.CreateTransactionExtention(contract, contract_type);
result = JToken.FromObject(transaction_extention.ToByteArray());
}
catch (System.Exception e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, e.Message);
return(false);
}
return(true);
}
/// <summary>
/// Freeze balance
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0] : Amount
/// [1] : Duration time (day)
/// [2] : Energy / Bandwidth (default 0 : enerygy)
/// [3] : Address (optional)
/// </param>
/// <returns></returns>
public static bool FreezeBalance(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <amount> <duration> || [<energy/bandwidth>] || [<address>]\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length < 2 || parameters.Length > 4)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
byte[] address = null;
long amount = long.Parse(parameters[0]);
long duration = long.Parse(parameters[1]);
int resource_code = 0;
if (parameters.Length == 3)
{
try
{
resource_code = int.Parse(parameters[2]);
}
catch
{
address = Wallet.Base58ToAddress(parameters[3]);
}
}
else if (parameters.Length == 4)
{
resource_code = int.Parse(parameters[2]);
address = Wallet.Base58ToAddress(parameters[3]);
}
RpcApiResult result = RpcApi.CreateFreezeBalanceContract(owner_address,
address,
amount,
duration,
resource_code,
out FreezeBalanceContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.FreezeBalanceContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Send balance
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0] : To address
/// [1] : Balance amount
/// </param>
/// <returns></returns>
public static bool SendCoin(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <to address> <amount>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length != 2)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
byte[] to_address = Wallet.Base58ToAddress(parameters[0]);
long amount = long.Parse(parameters[1]);
RpcApiResult result = RpcApi.CreateTransaferContract(owner_address,
to_address,
amount,
out TransferContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.TransferContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
if (result.Result)
{
Console.WriteLine(
string.Format("Send {0} drop to {1} + successful. ", long.Parse(parameters[1]), parameters[0]));
}
else
{
Console.WriteLine(
string.Format("Send {0} drop to {1} + failed. ", long.Parse(parameters[1]), parameters[0]));
}
OutputResultMessage(RpcCommand.Transaction.SendCoin, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// UnFreeze balance
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0] : Energy / Bandwidth (default 0 : enerygy)
/// [1] : Address (optional)
/// </param>
/// <returns></returns>
public static bool UnFreezeBalance(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] <address>\n", command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length < 1 || parameters.Length > 2)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
try
{
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
byte[] address = null;
int resource_code = 0;
if (parameters.Length == 1)
{
try
{
resource_code = int.Parse(parameters[0]);
}
catch (System.Exception)
{
address = Wallet.Base58ToAddress(parameters[0]);
}
}
else if (parameters.Length == 2)
{
resource_code = int.Parse(parameters[0]);
address = Wallet.Base58ToAddress(parameters[1]);
}
RpcApiResult result = RpcApi.CreateUnfreezeBalanceContract(owner_address,
address,
resource_code,
out UnfreezeBalanceContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.UnfreezeBalanceContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
/// <summary>
/// Create asset issue
/// </summary>
/// <param name="parameters">
/// Parameter Index
/// [0] : Name
/// [1] : Description
/// [2] : Url
/// [3] : transaction count
/// [4] : count
/// [5] : Precision
/// [6] : Total supply
/// [7] : Free net limit
/// [8] : public free net limit
/// [9] : Start time
/// [10] : End time
/// [11-] : Pair frozen supply
/// </param>
/// <returns></returns>
public static bool CreateAssetIssue(string command, string[] parameters)
{
string[] usage = new string[] {
string.Format("{0} [command option] " +
"<name> <description> <url>" +
"<transaction count> <count>" +
"<precision>" +
"<total supply>" +
"<free net limit> <public free net limit>" +
"<start time> <end time>" +
"<amount 1> <days 1> <amount 2> <days 2> ...\n"
, command)
};
string[] command_option = new string[] { HelpCommandOption.Help };
if (parameters == null || parameters.Length < 11 || parameters.Length % 2 == 0)
{
OutputHelpMessage(usage, null, command_option, null);
return(true);
}
if (!RpcApi.IsLogin)
{
return(true);
}
try
{
int i = 0;
byte[] owner_address = Wallet.Base58ToAddress(RpcApi.KeyStore.Address);
string name = parameters[i++];
string description = parameters[i++];
string url = parameters[i++];
long total_supply = long.Parse(parameters[i++]);
int tx_num = int.Parse(parameters[i++]);
int num = int.Parse(parameters[i++]);
int precision = int.Parse(parameters[i++]);
long free_limit = long.Parse(parameters[i++]);
long public_free_limit = long.Parse(parameters[i++]);
DateTime start_time = DateTime.ParseExact(parameters[i++], "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None);
DateTime end_time = DateTime.ParseExact(parameters[i++], "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None);
Dictionary <long, long> frozen_supply = new Dictionary <long, long>();
for (int j = i; j < parameters.Length; j += 2)
{
frozen_supply.Add(
long.Parse(parameters[j + 0]),
long.Parse(parameters[j + 1])
);
}
RpcApiResult result = RpcApi.CreateAssetIssueContract(owner_address,
name,
description,
url,
tx_num,
num,
precision,
0,
total_supply,
free_limit,
public_free_limit,
start_time.ToTimestamp(),
end_time.ToTimestamp(),
frozen_supply,
out AssetIssueContract contract);
TransactionExtention transaction_extention = null;
if (result.Result)
{
result = RpcApi.CreateTransaction(contract,
ContractType.AssetIssueContract,
out transaction_extention);
}
if (result.Result)
{
result = RpcApi.ProcessTransactionExtention(transaction_extention);
}
OutputResultMessage(command, result.Result, result.Code, result.Message);
}
catch (System.Exception e)
{
Console.WriteLine(e.Message + "\n\n" + e.StackTrace);
}
return(true);
}
public static TransactionApprovedList GetTransactionApprovedList(Transaction transaction)
{
TransactionExtention transaction_extention = new TransactionExtention()
{
Transaction = transaction,
Txid = ByteString.CopyFrom(SHA256Hash.ToHash(transaction.RawData.ToByteArray())),
Result = new Return()
{
Result = true,
Code = Return.Types.response_code.Success
}
};
TransactionApprovedList approved = new TransactionApprovedList()
{
Transaction = transaction_extention
};
try
{
Contract contract = transaction.RawData.Contract[0];
byte[] owner_address = TransactionCapsule.GetOwner(contract);
AccountCapsule account = Manager.Instance.DBManager.Account.Get(owner_address);
if (account == null)
{
throw new PermissionException("Account is not exist.");
}
if (transaction.Signature.Count > 0)
{
byte[] hash = SHA256Hash.ToHash(transaction.RawData.ToByteArray());
foreach (var signature in transaction.Signature)
{
if (signature.Count() < 65)
{
throw new SignatureFormatException("Signature size is " + signature.Count());
}
byte[] signature_address = ECKey.SignatureToAddress(hash, ECDSASignature.ExtractECDSASignature(signature.ToByteArray()));
approved.ApprovedList.Add(ByteString.CopyFrom(signature_address));
}
}
approved.Result = new TransactionApprovedList.Types.Result()
{
Code = TransactionApprovedList.Types.Result.Types.response_code.Success
};
}
catch (SignatureFormatException e)
{
approved.Result = new TransactionApprovedList.Types.Result()
{
Code = TransactionApprovedList.Types.Result.Types.response_code.SignatureFormatError,
Message = e.Message
};
}
catch (SignatureException e)
{
approved.Result = new TransactionApprovedList.Types.Result()
{
Code = TransactionApprovedList.Types.Result.Types.response_code.ComputeAddressError,
Message = e.Message
};
}
catch (System.Exception e)
{
approved.Result = new TransactionApprovedList.Types.Result()
{
Code = TransactionApprovedList.Types.Result.Types.response_code.OtherError,
Message = e.Message
};
}
return(approved);
}
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);
}
}
public static TransactionSignWeight GetTransactionSignWeight(Transaction transaction)
{
TransactionSignWeight weight = new TransactionSignWeight();
TransactionExtention extention = new TransactionExtention();
weight.Result = new TransactionSignWeight.Types.Result();
extention.Result = new Return();
extention.Transaction = transaction;
extention.Txid = ByteString.CopyFrom(SHA256Hash.ToHash(transaction.RawData.ToByteArray()));
extention.Result.Result = true;
extention.Result.Code = Return.Types.response_code.Success;
weight.Transaction = extention;
try
{
Contract contract = transaction.RawData.Contract[0];
byte[] owner = TransactionCapsule.GetOwner(contract);
AccountCapsule account = Manager.Instance.DBManager.Account.Get(owner);
if (account == null)
{
throw new PermissionException("Account is not exist!");
}
int permission_id = contract.PermissionId;
Permission permission = account.GetPermissionById(permission_id);
if (permission == null)
{
throw new PermissionException("permission isn't exit");
}
if (permission_id != 0)
{
if (permission.Type != Permission.Types.PermissionType.Active)
{
throw new PermissionException("Permission type is error");
}
if (!CheckPermissionOprations(permission, contract))
{
throw new PermissionException("Permission denied");
}
}
weight.Permission = permission;
if (transaction.Signature.Count > 0)
{
List <ByteString> approves = new List <ByteString>();
weight.ApprovedList.AddRange(approves);
weight.CurrentWeight = TransactionCapsule.CheckWeight(permission,
new List <ByteString>(transaction.Signature),
SHA256Hash.ToHash(transaction.RawData.ToByteArray()),
approves);
}
if (weight.CurrentWeight >= permission.Threshold)
{
weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.EnoughPermission;
}
else
{
weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.NotEnoughPermission;
}
}
catch (SignatureFormatException e)
{
weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.SignatureFormatError;
weight.Result.Message = e.Message;
}
catch (SignatureException e)
{
weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.ComputeAddressError;
weight.Result.Message = e.Message;
}
catch (PermissionException e)
{
weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.PermissionError;
weight.Result.Message = e.Message;
}
catch (System.Exception e)
{
weight.Result.Code = TransactionSignWeight.Types.Result.Types.response_code.OtherError;
weight.Result.Message = e.Message;
}
return(weight);
}
