/*public Transaction SignTransaction(JObject t)
* {
* Transaction tr = new Transaction();
*
* try
* {
* tr.From = ByteArrayHelpers.FromHexString(addr);
* tr.To = Convert.FromBase64String(t["to"].ToString());
* tr.IncrementId = t["incr"].ToObject<ulong>();
* tr.MethodName = t["method"].ToObject<string>();
* var p = Convert.FromBase64String(t["params"].ToString());
* tr.Params = p.Length == 0 ? null : p;
*
* SignTransaction(tr);
*
* return tr;
* }
* catch (Exception e)
* {
* ;
* }
*
* return null;
* }*/
public Transaction SignTransaction(Transaction tx)
{
string addr = tx.From.Value.ToHex(true);
ECKeyPair kp = _keyStore.GetAccountKeyPair(addr);
if (kp == null)
{
throw new AccountLockedException(addr);
}
MemoryStream ms = new MemoryStream();
Serializer.Serialize(ms, tx);
byte[] b = ms.ToArray();
byte[] toSig = SHA256.Create().ComputeHash(b);
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(kp, toSig);
// Update the signature
tx.Sig = new Signature {
R = signature.R, S = signature.S, P = kp.PublicKey.Q.GetEncoded()
};
return(tx);
}
public void Main4Test()
{
Wallet.WalletClient wallet = GetMainNetWalletClient;
var keyTriple = new KeyTriple("B7E85CA5910922C49DCCB92EE48DFEC13A60674845CB7152C86B88F31DA6DC67");
byte[] hashTransaction1 = StringHelper.HexStringToByteArray("a7e974c6e69fb7741bf5e08de8a2d8f6617826c59422b440de22e0612b03c393");
BytesMessage bytesMessage1 = new BytesMessage();
bytesMessage1.Value = ByteString.CopyFrom(hashTransaction1);
Transaction transactionLoad1 = wallet.GetTransactionByIdAsync(bytesMessage1).GetAwaiter().GetResult();
Transaction.Types.Contract contract = transactionLoad1.RawData.Contract[0];
TransferContract transferContract = TransferContract.Parser.ParseFrom(contract.Parameter.Value.ToByteArray());
byte[] publicKeyOwner = transferContract.OwnerAddress.ToByteArray();
string encode = Base58.Encode(publicKeyOwner);
byte[] transactionRaw = transactionLoad1.RawData.ToByteArray();
byte[] hash = Sha256.Hash(transactionRaw);
string signBase64 = transactionLoad1.Signature[0].ToBase64();
byte[] byteArray = transactionLoad1.Signature[0].ToByteArray();
bool isSignatureValidFromBytes = new ECSigner().IsSignatureValidFromBytes(hash, byteArray, publicKeyOwner);
}
public void SignAndVerifyTransaction()
{
// Generate the key pair
ECKeyPair keyPair = new KeyPairGenerator().Generate();
Transaction tx = new Transaction();
tx.From = Address.FromRawBytes(CryptoHelpers.RandomFill(ADR_LENGTH));
tx.To = Address.FromRawBytes(CryptoHelpers.RandomFill(ADR_LENGTH));
Block block = new Block();
block.AddTransaction(tx);
// Serialize and hash the transaction
Hash hash = tx.GetHash();
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, hash.DumpByteArray());
ECVerifier verifier = new ECVerifier(keyPair);
Assert.True(verifier.Verify(signature, hash.DumpByteArray()));
}
public static Transaction BuildTransaction(Address adrTo = null, ulong nonce = 0, ECKeyPair keyPair = null)
{
keyPair = keyPair ?? new KeyPairGenerator().Generate();
var tx = new Transaction();
tx.From = keyPair.GetAddress();
tx.To = adrTo ?? Address.FromRawBytes(Hash.Generate().ToByteArray());
tx.IncrementId = nonce;
tx.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded())
};
tx.Fee = TxPoolConfig.Default.FeeThreshold + 1;
tx.MethodName = "hello world";
tx.Params = ByteString.CopyFrom(new Parameters
{
Params = { new Param
{
IntVal = 1
} }
}.ToByteArray());
// Serialize and hash the transaction
Hash hash = tx.GetHash();
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, hash.DumpByteArray());
// Update the signature
tx.Sig.R = ByteString.CopyFrom(signature.R);
tx.Sig.S = ByteString.CopyFrom(signature.S);
return(tx);
}
/// <summary>
/// This method sends authentification information to the distant peer and
/// start the authentification timer.
/// </summary>
/// <returns></returns>
private void StartAuthentification()
{
var nodeInfo = new NodeData {
Port = _port
};
ECSigner signer = new ECSigner();
ECSignature sig = signer.Sign(_nodeKey, nodeInfo.ToByteArray());
var nd = new Handshake
{
NodeInfo = nodeInfo,
PublicKey = ByteString.CopyFrom(_nodeKey.GetEncodedPublicKey()),
Height = CurrentHeight,
Version = GlobalConfig.ProtocolVersion,
R = ByteString.CopyFrom(sig.R),
S = ByteString.CopyFrom(sig.S)
};
byte[] packet = nd.ToByteArray();
_logger?.Trace($"Sending authentification : {{ port: {nd.NodeInfo.Port}, addr: {nd.PublicKey.ToByteArray().ToHex()} }}");
_messageWriter.EnqueueMessage(new Message {
Type = (int)MessageType.Auth, HasId = false, Length = packet.Length, Payload = packet
});
StartAuthTimer();
}
public Transaction SignTransaction(Transaction tx)
{
string addr = tx.From.Value.ToHex();
ECKeyPair kp = _keyStore.GetAccountKeyPair(addr);
if (kp == null)
{
Console.WriteLine("The following account is locked:" + addr);
return(null);
}
MemoryStream ms = new MemoryStream();
Serializer.Serialize(ms, tx);
byte[] b = ms.ToArray();
byte[] toSig = SHA256.Create().ComputeHash(b);
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(kp, toSig);
// Update the signature
tx.R = signature.R;
tx.S = signature.S;
tx.P = kp.PublicKey.Q.GetEncoded();
return(tx);
}
public void SignUnsignTest()
{
ECSigner ecSigner = new ECSigner();
var message = "test";
string sign = ecSigner.Sign(message);
bool isSignatureValid = ecSigner.IsSignatureValid(message, sign);
}
public async Task <JObject> SignHash(string address, string password, string hash)
{
var tryOpen = KeyStore.OpenAsync(address, password);
if (tryOpen == AElfKeyStore.Errors.WrongPassword)
{
return(new JObject()
{
["error"] = "Wrong password."
});
}
ECKeyPair kp = KeyStore.GetAccountKeyPair(address);
byte[] toSig = ByteArrayHelpers.FromHexString(hash);
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(kp, toSig);
// TODO: Standardize encoding
return(new JObject()
{
["R"] = signature.R,
["S"] = signature.S,
["P"] = kp.PublicKey.Q.GetEncoded()
});
}
public void SignUnsign2Test()
{
ECSigner ecSigner = new ECSigner("4C4CA01FBD362CABE6654337AC23B22496EE58D79CEDBEE26139D551BDCA5ADA");
string message = "test";
string sign = ecSigner.Sign(message);
bool isSignatureValid = ecSigner.IsSignatureValid(message, sign);
Assert.IsTrue(isSignatureValid);
}
/// <summary>
/// block signature
/// </summary>
/// <param name="keyPair"></param>
/// <exception cref="NotImplementedException"></exception>
public void Sign(ECKeyPair keyPair)
{
ECSigner signer = new ECSigner();
var hash = GetHash();
var bytes = hash.DumpByteArray();
ECSignature signature = signer.Sign(keyPair, bytes);
Header.P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded());
Header.R = ByteString.CopyFrom(signature.R);
Header.S = ByteString.CopyFrom(signature.S);
}
public void ATest()
{
ECSigner ecSigner = new ECSigner("F43EBCC94E6C257EDBE559183D1A8778B2D5A08040902C0F0A77A3343A1D0EA5");
byte[] encoded = ecSigner._keyPair.ECPublicKey.Q.GetEncoded();
byte[] computeHash = Sha3.Sha3256().ComputeHash(encoded, 1, 64);
string string2 = computeHash.ToHexString2();
String pubkey04 = "04e6a49d098ee94871252622b8a8b727e5cdf81b7138e5ac16591887f6e8c10e881e4b4250fa8c87f5b29ad020216a9ffd0acf5995a627d6c70e4dd274c54c20bd";
string hexString04 = Sha3.Sha3256().ComputeHash(pubkey04.FromHexToByteArray2(), 1, 64).ToHexString2();
}
public void VerifySignature_CorrectDataAndSig_ReturnsTrue()
{
ECKeyPair keyPair = new KeyPairGenerator().Generate();
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, message);
ECVerifier verifier = new ECVerifier(keyPair);
Assert.True(verifier.Verify(signature, message));
}
public void SignAndVerifyTransaction()
{
byte[] fromAdress = CryptoHelpers.RandomFill(ADR_LENGTH);
byte[] toAdress = CryptoHelpers.RandomFill(ADR_LENGTH);
// Generate the key pair
ECKeyPair keyPair = new KeyPairGenerator().Generate();
;
Transaction tx = new Transaction();
tx.From = Address.FromRawBytes(fromAdress);
tx.To = Address.FromRawBytes(toAdress);
tx.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded())
};
// Serialize and hash the transaction
Hash hash = tx.GetHash();
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, hash.DumpByteArray());
// Update the signature
tx.Sig.R = ByteString.CopyFrom(signature.R);
tx.Sig.S = ByteString.CopyFrom(signature.S);
// Serialize as for sending over the network
byte[] serializedTx = tx.Serialize();
/**** broadcast/receive *****/
Transaction dTx = Transaction.Parser.ParseFrom(serializedTx);
// Serialize and hash the transaction
Hash dHash = dTx.GetHash();
byte[] uncompressedPrivKey = tx.Sig.P.ToByteArray();
ECKeyPair recipientKeyPair = ECKeyPair.FromPublicKey(uncompressedPrivKey);
ECVerifier verifier = new ECVerifier(recipientKeyPair);
Assert.True(verifier.Verify(dTx.GetSignature(), dHash.DumpByteArray()));
}
public List <Transaction> CreateTx(Hash chainId)
{
var contractAddressZero = AddressHelpers.GetSystemContractAddress(chainId, GlobalConfig.GenesisBasicContract);
Console.WriteLine($"zero {contractAddressZero}");
var code = ExampleContractCode;
ECKeyPair keyPair = new KeyPairGenerator().Generate();
ECSigner signer = new ECSigner();
var txPrint = new Transaction()
{
From = keyPair.GetAddress(),
To = contractAddressZero,
IncrementId = NewIncrementId(),
MethodName = "Print",
Params = ByteString.CopyFrom(new Parameters()
{
Params =
{
new Param
{
StrVal = "AElf"
}
}
}.ToByteArray()),
Fee = TxPoolConfig.Default.FeeThreshold + 1
};
Hash hash = txPrint.GetHash();
ECSignature signature = signer.Sign(keyPair, hash.DumpByteArray());
txPrint.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded()),
R = ByteString.CopyFrom(signature.R),
S = ByteString.CopyFrom(signature.S),
};
var txs = new List <Transaction>()
{
txPrint
};
return(txs);
}
public void VerifySignature_WrongData_ReturnsFalse()
{
ECKeyPair keyPair = new KeyPairGenerator().Generate();
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, message);
// Change the message
message = new BigInteger("9682368737159881417056907351531570756676647951").ToByteArray();
ECVerifier verifier = new ECVerifier(keyPair);
Assert.False(verifier.Verify(signature, message));
}
public List <Transaction> CreateTx(Hash chainId)
{
var contractAddressZero =
AddressHelpers.GetSystemContractAddress(chainId, GlobalConfig.GenesisBasicContract);
var keyPair = new KeyPairGenerator().Generate();
var signer = new ECSigner();
var txPrint = new Transaction()
{
From = keyPair.GetAddress(),
To = contractAddressZero,
MethodName = "Print",
Params = ByteString.CopyFrom(new Parameters()
{
Params =
{
new Param
{
StrVal = "AElf"
}
}
}.ToByteArray()),
Fee = 0
};
var hash = txPrint.GetHash();
var signature = signer.Sign(keyPair, hash.DumpByteArray());
txPrint.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded()),
R = ByteString.CopyFrom(signature.R),
S = ByteString.CopyFrom(signature.S)
};
var txs = new List <Transaction>
{
txPrint
};
return(txs);
}
/// <summary>
/// Generate a system tx for parent chain block info and broadcast it.
/// </summary>
/// <returns></returns>
private async Task GenerateTransactionWithParentChainBlockInfo()
{
var parentChainBlockInfo = GetParentChainBlockInfo();
if (parentChainBlockInfo == null)
{
return;
}
try
{
var bn = await _blockChain.GetCurrentBlockHeightAsync();
bn = bn > 4 ? bn - 4 : 0;
var bh = bn == 0 ? Hash.Genesis : (await _blockChain.GetHeaderByHeightAsync(bn)).GetHash();
var bhPref = bh.Value.Where((x, i) => i < 4).ToArray();
var tx = new Transaction
{
From = _keyPair.GetAddress(),
To = AddressHelpers.GetSystemContractAddress(Config.ChainId,
SmartContractType.SideChainContract.ToString()),
RefBlockNumber = bn,
RefBlockPrefix = ByteString.CopyFrom(bhPref),
MethodName = "WriteParentChainBlockInfo",
Sig = new Signature
{
P = ByteString.CopyFrom(_keyPair.GetEncodedPublicKey())
},
Type = TransactionType.CrossChainBlockInfoTransaction,
Params = ByteString.CopyFrom(ParamsPacker.Pack(parentChainBlockInfo)),
Time = Timestamp.FromDateTime(DateTime.UtcNow)
};
// sign tx
var signature = new ECSigner().Sign(_keyPair, tx.GetHash().DumpByteArray());
tx.Sig.R = ByteString.CopyFrom(signature.R);
tx.Sig.S = ByteString.CopyFrom(signature.S);
await InsertTransactionToPool(tx);
_logger?.Trace($"Generated Cross chain info transaction {tx.GetHash()}");
}
catch (Exception e)
{
_logger?.Error(e, "PCB transaction generation failed.");
}
}
static void Main(string[] args)
{
ECKeyPair keyPair = KeyPairGenerator.Generate();
//Console.WriteLine(privateKey.ToString() + Environment.NewLine);
// Fake data
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, message);
message = new BigInteger("9682368737159881417056907351531570756676647951").ToByteArray();
ECVerifier verifier = new ECVerifier(keyPair);
bool isGood = verifier.Verify(signature, message);
Console.WriteLine(isGood);
}
private async Task <Transaction> GenerateTransactionAsync(string methodName, List <byte[]> parameters)
{
try
{
_logger?.Trace("Entered generating tx.");
var bn = await BlockChain.GetCurrentBlockHeightAsync();
bn = bn > 4 ? bn - 4 : 0;
var bh = bn == 0 ? Hash.Genesis : (await BlockChain.GetHeaderByHeightAsync(bn)).GetHash();
var bhPref = bh.Value.Where((x, i) => i < 4).ToArray();
var tx = new Transaction
{
From = _nodeKeyPair.Address,
To = ContractAddress,
RefBlockNumber = bn,
RefBlockPrefix = ByteString.CopyFrom(bhPref),
MethodName = methodName,
Sig = new Signature {
P = ByteString.CopyFrom(_nodeKeyPair.NonCompressedEncodedPublicKey)
},
Type = TransactionType.DposTransaction,
Params = ByteString.CopyFrom(ParamsPacker.Pack(parameters.Select(p => (object)p).ToArray()))
};
var signer = new ECSigner();
var signature = signer.Sign(_nodeKeyPair, tx.GetHash().DumpByteArray());
// Update the signature
tx.Sig.R = ByteString.CopyFrom(signature.R);
tx.Sig.S = ByteString.CopyFrom(signature.S);
_logger?.Trace("Leaving generating tx.");
MessageHub.Instance.Publish(StateEvent.ConsensusTxGenerated);
return(tx);
}
catch (Exception e)
{
_logger?.Trace(e, "Error while during generating DPoS tx.");
}
return(null);
}
public static (ECKeyPair, Handshake) CreateKeyPairAndHandshake(int port)
{
ECKeyPair key = new KeyPairGenerator().Generate();
var nodeInfo = new NodeData {
Port = port
};
ECSigner signer = new ECSigner();
ECSignature sig = signer.Sign(key, nodeInfo.ToByteArray());
var handshakeMsg = new Handshake
{
NodeInfo = nodeInfo,
PublicKey = ByteString.CopyFrom(key.GetEncodedPublicKey()),
R = ByteString.CopyFrom(sig.R),
S = ByteString.CopyFrom(sig.S),
};
return(key, handshakeMsg);
}
private Transaction GetTxToVerifyBlockProducer(Address contractAccountHash, ECKeyPair keyPair,
string recipientAddress, Timestamp timestamp, long roundId)
{
if (contractAccountHash == null || keyPair == null || recipientAddress == null)
{
_logger?.Error("Something wrong happened to consensus verification filter.");
return(null);
}
var tx = new Transaction
{
From = keyPair.GetAddress(),
To = contractAccountHash,
IncrementId = 0,
MethodName = "Validation",
Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded())
},
Params = ByteString.CopyFrom(ParamsPacker.Pack(
new StringValue {
Value = recipientAddress.RemoveHexPrefix()
}.ToByteArray(),
timestamp.ToByteArray(),
new Int64Value {
Value = roundId
}))
};
var signer = new ECSigner();
var signature = signer.Sign(keyPair, tx.GetHash().DumpByteArray());
// Update the signature
tx.Sig.R = ByteString.CopyFrom(signature.R);
tx.Sig.S = ByteString.CopyFrom(signature.S);
return(tx);
}
public List <Transaction> CreateTxs(Hash chainId)
{
var contractAddressZero = AddressHelpers.GetSystemContractAddress(chainId, GlobalConfig.GenesisBasicContract);
var code = ExampleContractCode;
ECKeyPair keyPair = new KeyPairGenerator().Generate();
ECSigner signer = new ECSigner();
var txnDep = new Transaction()
{
From = keyPair.GetAddress(),
To = contractAddressZero,
IncrementId = 0,
MethodName = "DeploySmartContract",
Params = ByteString.CopyFrom(ParamsPacker.Pack((int)0, code)),
Fee = TxPoolConfig.Default.FeeThreshold + 1,
Type = TransactionType.ContractTransaction
};
Hash hash = txnDep.GetHash();
ECSignature signature1 = signer.Sign(keyPair, hash.DumpByteArray());
txnDep.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded()),
R = ByteString.CopyFrom(signature1.R),
S = ByteString.CopyFrom(signature1.S),
};
var txInv_1 = new Transaction
{
From = keyPair.GetAddress(),
To = contractAddressZero,
IncrementId = 1,
MethodName = "Print",
Params = ByteString.CopyFrom(ParamsPacker.Pack("AElf")),
Fee = TxPoolConfig.Default.FeeThreshold + 1,
Type = TransactionType.ContractTransaction
};
ECSignature signature2 = signer.Sign(keyPair, txInv_1.GetHash().DumpByteArray());
txInv_1.Sig = new Signature {
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded()),
R = ByteString.CopyFrom(signature2.R),
S = ByteString.CopyFrom(signature2.S)
};
var txInv_2 = new Transaction
{
From = keyPair.GetAddress(),
To = contractAddressZero,
IncrementId = txInv_1.IncrementId,
MethodName = "Print",
Params = ByteString.CopyFrom(ParamsPacker.Pack("AElf")),
Fee = TxPoolConfig.Default.FeeThreshold + 1,
Type = TransactionType.ContractTransaction
};
ECSignature signature3 = signer.Sign(keyPair, txInv_2.GetHash().DumpByteArray());
txInv_2.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded())
};
txInv_2.Sig.R = ByteString.CopyFrom(signature3.R);
txInv_2.Sig.S = ByteString.CopyFrom(signature3.S);
var txs = new List <Transaction>()
{
txnDep, txInv_1, txInv_2
};
return(txs);
}
private void ProcessCommand(CmdParseResult parsedCmd, CliCommandDefinition def)
{
string error = def.Validate(parsedCmd);
if (!string.IsNullOrEmpty(error))
{
_screenManager.PrintError(error);
}
else
{
if (def is GetDeserializedResultCmd g)
{
try
{
var str = g.Validate(parsedCmd);
if (str != null)
{
_screenManager.PrintError(str);
return;
}
// RPC
var t = parsedCmd.Args.ElementAt(0);
var data = parsedCmd.Args.ElementAt(1);
byte[] sd;
try
{
sd = ByteArrayHelpers.FromHexString(data);
}
catch (Exception e)
{
_screenManager.PrintError("Wrong data formant.");
return;
}
object dd;
try
{
dd = Deserializer.Deserialize(t, sd);
}
catch (Exception e)
{
_screenManager.PrintError("Invalid data format");
return;
}
if (dd == null)
{
_screenManager.PrintError("Not supported type.");
return;
}
_screenManager.PrintLine(dd.ToString());
return;
}
catch (Exception e)
{
Console.WriteLine(e);
return;
}
}
if (def is LoadContractAbiCmd l)
{
error = l.Validate(parsedCmd);
if (!string.IsNullOrEmpty(error))
{
_screenManager.PrintError(error);
}
try
{
// RPC
HttpRequestor reqhttp = new HttpRequestor(_rpcAddress);
if (!parsedCmd.Args.Any())
{
if (_genesisAddress == null)
{
_screenManager.PrintError(ConnectionNeeded);
return;
}
parsedCmd.Args.Add(_genesisAddress);
//parsedCmd.Args.Add(Globals.GenesisBasicContract);
}
var addr = parsedCmd.Args.ElementAt(0);
Module m = null;
if (!_loadedModules.TryGetValue(addr, out m))
{
string resp = reqhttp.DoRequest(def.BuildRequest(parsedCmd).ToString());
if (resp == null)
{
_screenManager.PrintError(ServerConnError);
return;
}
if (resp.IsEmpty())
{
_screenManager.PrintError(NoReplyContentError);
return;
}
JObject jObj = JObject.Parse(resp);
var res = JObject.FromObject(jObj["result"]);
JToken ss = res["abi"];
byte[] aa = ByteArrayHelpers.FromHexString(ss.ToString());
MemoryStream ms = new MemoryStream(aa);
m = Serializer.Deserialize <Module>(ms);
_loadedModules.Add(addr, m);
}
var obj = JObject.FromObject(m);
_screenManager.PrintLine(obj.ToString());
}
catch (Exception e)
{
if (e is JsonReaderException)
{
_screenManager.PrintError(WrongInputFormat);
return;
}
return;
}
return;
}
if (def is DeployContractCommand dcc)
{
if (_genesisAddress == null)
{
_screenManager.PrintError(NotConnected);
return;
}
try
{
string err = dcc.Validate(parsedCmd);
if (!string.IsNullOrEmpty(err))
{
_screenManager.PrintLine(err);
return;
}
//string cat = parsedCmd.Args.ElementAt(0);
string filename = parsedCmd.Args.ElementAt(0);
// Read sc bytes
SmartContractReader screader = new SmartContractReader();
byte[] sc = screader.Read(filename);
string hex = sc.ToHex();
var name = GlobalConfig.GenesisBasicContract;
Module m = _loadedModules.Values.FirstOrDefault(ld => ld.Name.Equals(name));
if (m == null)
{
_screenManager.PrintError(AbiNotLoaded);
return;
}
Method meth = m.Methods.FirstOrDefault(mt => mt.Name.Equals(DeploySmartContract));
if (meth == null)
{
_screenManager.PrintError(MethodNotFound);
return;
}
byte[] serializedParams = meth.SerializeParams(new List <string> {
"1", hex
});
Transaction t = new Transaction();
t = CreateTransaction(parsedCmd.Args.ElementAt(2), _genesisAddress,
DeploySmartContract, serializedParams, TransactionType.ContractTransaction);
t = t.AddBlockReference(_rpcAddress);
MemoryStream ms = new MemoryStream();
Serializer.Serialize(ms, t);
byte[] b = ms.ToArray();
byte[] toSig = SHA256.Create().ComputeHash(b);
ECSigner signer = new ECSigner();
ECSignature signature;
ECKeyPair kp = _accountManager.GetKeyPair(parsedCmd.Args.ElementAt(2));
if (kp == null)
{
throw new AccountLockedException(parsedCmd.Args.ElementAt(2));
}
signature = signer.Sign(kp, toSig);
// Update the signature
t.Sig = new Signature {
R = signature.R, S = signature.S, P = kp.PublicKey.Q.GetEncoded()
};
var resp = SignAndSendTransaction(t);
if (resp == null)
{
_screenManager.PrintError(ServerConnError);
return;
}
if (resp.IsEmpty())
{
_screenManager.PrintError(NoReplyContentError);
return;
}
JObject jObj = JObject.Parse(resp);
string toPrint = def.GetPrintString(JObject.FromObject(jObj["result"]));
_screenManager.PrintLine(toPrint);
return;
}
catch (Exception e)
{
if (e is ContractLoadedException || e is AccountLockedException)
{
_screenManager.PrintError(e.Message);
return;
}
if (e is InvalidTransactionException)
{
_screenManager.PrintError(InvalidTransaction);
return;
}
if (e is JsonReaderException)
{
_screenManager.PrintError(WrongInputFormat);
return;
}
return;
}
}
// Execute
// 2 cases : RPC command, Local command (like account management)
if (def.IsLocal)
{
if (def is SendTransactionCmd c)
{
try
{
JObject j = JObject.Parse(parsedCmd.Args.ElementAt(0));
Transaction tr;
tr = ConvertFromJson(j);
string hex = tr.To.Value.ToHex();
Module m = null;
if (!_loadedModules.TryGetValue(hex.Replace("0x", ""), out m))
{
if (!_loadedModules.TryGetValue("0x" + hex.Replace("0x", ""), out m))
{
_screenManager.PrintError(AbiNotLoaded);
return;
}
}
Method method = m.Methods?.FirstOrDefault(mt => mt.Name.Equals(tr.MethodName));
if (method == null)
{
_screenManager.PrintError(MethodNotFound);
return;
}
JArray p = j["params"] == null ? null : JArray.Parse(j["params"].ToString());
tr.Params = j["params"] == null ? null : method.SerializeParams(p.ToObject <string[]>());
tr.type = TransactionType.ContractTransaction;
tr = tr.AddBlockReference(_rpcAddress);
_accountManager.SignTransaction(tr);
var resp = SignAndSendTransaction(tr);
if (resp == null)
{
_screenManager.PrintError(ServerConnError);
return;
}
if (resp.IsEmpty())
{
_screenManager.PrintError(NoReplyContentError);
return;
}
JObject jObj = JObject.Parse(resp);
string toPrint = def.GetPrintString(JObject.FromObject(jObj["result"]));
_screenManager.PrintLine(toPrint);
}
catch (Exception e)
{
if (e is AccountLockedException || e is InvalidTransactionException ||
e is InvalidInputException)
{
_screenManager.PrintError(e.Message);
}
if (e is JsonReaderException || e is FormatException)
{
_screenManager.PrintError(WrongInputFormat);
return;
}
}
}
else if (def is CallReadOnlyCmd)
{
JObject j = JObject.Parse(parsedCmd.Args.ElementAt(0));
Transaction tr;
tr = ConvertFromJson(j);
string hex = tr.To.Value.ToHex();
Module m = null;
if (!_loadedModules.TryGetValue(hex.Replace("0x", ""), out m))
{
if (!_loadedModules.TryGetValue("0x" + hex.Replace("0x", ""), out m))
{
_screenManager.PrintError(AbiNotLoaded);
return;
}
}
Method method = m.Methods?.FirstOrDefault(mt => mt.Name.Equals(tr.MethodName));
if (method == null)
{
_screenManager.PrintError(MethodNotFound);
return;
}
JArray p = j["params"] == null ? null : JArray.Parse(j["params"].ToString());
tr.Params = j["params"] == null ? null : method.SerializeParams(p.ToObject <string[]>());
var resp = CallTransaction(tr);
if (resp == null)
{
_screenManager.PrintError(ServerConnError);
return;
}
if (resp.IsEmpty())
{
_screenManager.PrintError(NoReplyContentError);
return;
}
JObject jObj = JObject.Parse(resp);
string toPrint = def.GetPrintString(JObject.FromObject(jObj["result"]));
_screenManager.PrintLine(toPrint);
}
else if (def is AccountCmd)
{
_accountManager.ProcessCommand(parsedCmd);
}
else if (def is CertificateCmd)
{
_certificatManager.ProcCmd(parsedCmd);
}
}
else
{
try
{
// RPC
HttpRequestor reqhttp = new HttpRequestor(_rpcAddress);
string resp = reqhttp.DoRequest(def.BuildRequest(parsedCmd).ToString(), def.GetUrl());
if (resp == null)
{
_screenManager.PrintError(ServerConnError);
return;
}
if (resp.IsEmpty())
{
_screenManager.PrintError(NoReplyContentError);
return;
}
JObject jObj = JObject.Parse(resp);
var j = jObj["result"];
if (j["error"] != null)
{
_screenManager.PrintLine(j["error"].ToString());
return;
}
if (j["result"]?["BasicContractZero"] != null)
{
_genesisAddress = j["result"]["BasicContractZero"].ToString();
}
string toPrint = def.GetPrintString(JObject.FromObject(j));
_screenManager.PrintLine(toPrint);
}
catch (Exception e)
{
if (e is UriFormatException)
{
_screenManager.PrintError(UriFormatEroor);
return;
}
if (e is JsonReaderException)
{
_screenManager.PrintError(WrongInputFormat);
return;
}
}
}
}
}
