public async Task <List <SmartContractTransaction> > GetSmartContractTransactionsForDeployedInstance(int smartContractDeployedInstanceId)
{
List <SmartContractTransaction> smartContractTransactions = new List <SmartContractTransaction>();
using (SqlConnection conn = new SqlConnection(DbConfiguration.ConnectionString))
{
SqlCommand sqlcmd = new SqlCommand(StoredProcedures.GetSmartContractTransactionsForDeployedInstance, conn);
sqlcmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@smartContractDeployedInstanceId",
SqlDbType = System.Data.SqlDbType.Int,
Value = smartContractDeployedInstanceId
});
conn.Open();
var reader = await sqlcmd.ExecuteReaderAsync();
while (reader.Read())
{
var smartContractTransaction = new SmartContractTransaction();
smartContractTransaction.SmartContractTransactionId = Convert.ToInt32(reader["SmartContractTransactionId"]);
smartContractTransaction.SmartContractDeployedInstanceId = Convert.ToInt32(reader["SmartContractDeployedInstanceId"]);
smartContractTransaction.TransactionHash = reader["TransactionHash"]?.ToString();
smartContractTransaction.TransactionUser = reader["TransactionUser"]?.ToString();
smartContractTransaction.SmartContractFunction = reader["SmartContractFunction"]?.ToString();
smartContractTransaction.SmartContractFunctionParameters = reader["SmartContractFunctionParameters"]?.ToString();
smartContractTransaction.CreatedDatetime = string.IsNullOrEmpty(reader["CreatedDatetime"]?.ToString()) ? DateTime.MinValue : Convert.ToDateTime(reader["CreatedDatetime"]);
smartContractTransaction.UpdatedDatetime = string.IsNullOrEmpty(reader["UpdatedDatetime"]?.ToString()) ? DateTime.MinValue : Convert.ToDateTime(reader["UpdatedDatetime"]);
smartContractTransactions.Add(smartContractTransaction);
}
}
return(smartContractTransactions);
}
public async Task <SmartContractTransaction> CreateSmartContractTransaction(SmartContractTransaction smartContractTransaction)
{
SmartContractTransaction mutatedSmartContractTransaction = null;
using (SqlConnection conn = new SqlConnection(DbConfiguration.ConnectionString))
{
SqlCommand sqlcmd = new SqlCommand(StoredProcedures.InsertSmartContractTransaction, conn);
sqlcmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@smartContractDeployedInstanceId",
SqlDbType = System.Data.SqlDbType.Int,
Value = smartContractTransaction.SmartContractDeployedInstanceId
});
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@transactionHash",
SqlDbType = System.Data.SqlDbType.VarChar,
Value = smartContractTransaction.TransactionHash
});
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@transactionUser",
SqlDbType = System.Data.SqlDbType.VarChar,
Value = smartContractTransaction.TransactionUser
});
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@smartContractFunction",
SqlDbType = System.Data.SqlDbType.VarChar,
Value = smartContractTransaction.SmartContractFunction
});
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@smartContractFunctionParameters",
SqlDbType = System.Data.SqlDbType.VarChar,
Value = smartContractTransaction.SmartContractFunctionParameters
});
conn.Open();
var reader = await sqlcmd.ExecuteReaderAsync();
if (reader.Read())
{
mutatedSmartContractTransaction = new SmartContractTransaction();
mutatedSmartContractTransaction.SmartContractTransactionId = Convert.ToInt32(reader["SmartContractTransactionId"]);
mutatedSmartContractTransaction.SmartContractDeployedInstanceId = Convert.ToInt32(reader["SmartContractDeployedInstanceId"]);
mutatedSmartContractTransaction.TransactionUser = reader["TransactionUser"]?.ToString();
mutatedSmartContractTransaction.SmartContractFunction = reader["SmartContractFunction"]?.ToString();
mutatedSmartContractTransaction.SmartContractFunctionParameters = reader["SmartContractFunctionParameters"]?.ToString();
mutatedSmartContractTransaction.CreatedDatetime = string.IsNullOrEmpty(reader["CreatedDatetime"]?.ToString()) ? DateTime.MinValue : Convert.ToDateTime(reader["CreatedDatetime"]);
mutatedSmartContractTransaction.UpdatedDatetime = string.IsNullOrEmpty(reader["UpdatedDatetime"]?.ToString()) ? DateTime.MinValue : Convert.ToDateTime(reader["UpdatedDatetime"]);
}
return(mutatedSmartContractTransaction);
}
}
public void WhenGetSmartContractAddr()
{
var adr = "6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0";
var transaction = new SmartContractTransaction();
transaction.From = adr.FromHexString();
transaction.Nonce = 1;
var res = transaction.GetSmartContractAddress();
Assert.IsTrue(res.Count() == 20);
}
private void PublishTransactionCall(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (_viewModel.SelectedSolidityContract == null)
{
MainWindowStore.Instance().DisplayError("Contract must be selected");
return;
}
if (_viewModel.SelectedFunctionDefinition == null)
{
MainWindowStore.Instance().DisplayError("Function must be selected");
return;
}
var callValue = _viewModel.SelectedFunctionDefinition.FunctionAgg.GetCallValue(_viewModel.SelectedFunctionDefinition.Parameters.Select(p => p.Value));
var rpcClient = new RpcClient(authenticatedWallet.Network);
var smartContractTransaction = new SmartContractTransaction
{
To = _viewModel.SelectedSolidityContract.Address.FromHexString(),
Data = callValue.FromHexString()
};
rpcClient.SendRawTransaction(smartContractTransaction).ContinueWith((t) =>
{
try
{
var txId = t.Result;
Application.Current.Dispatcher.Invoke(() =>
{
MainWindowStore.Instance().DisplayMessage(string.Format("A new transaction has been published : {0}", txId));
});
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to publish the transaction"));
}
});
}
public async Task <Dictionary <string, SmartContractTransaction> > GetSmartContractTransactionsInfoWithList(List <string> transactionsHashList)
{
string transactionHashCommaSeptList = string.Join(",", transactionsHashList.ToArray());
using (SqlConnection conn = new SqlConnection(DbConfiguration.ConnectionString))
{
SqlCommand sqlcmd = new SqlCommand(StoredProcedures.GetSmartContractTransactionInfoByHash, conn);
sqlcmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlcmd.Parameters.Add(new SqlParameter()
{
ParameterName = "@transactionHashCommaSepList",
SqlDbType = System.Data.SqlDbType.VarChar,
Value = transactionHashCommaSeptList
});
conn.Open();
var reader = await sqlcmd.ExecuteReaderAsync();
Dictionary <string, SmartContractTransaction> smartContractTransactionDict = new Dictionary <string, SmartContractTransaction>();
while (reader.Read())
{
var smartContractTransaction = new SmartContractTransaction();
smartContractTransaction.SmartContractTransactionId = Convert.ToInt32(reader["SmartContractTransactionId"]);
smartContractTransaction.SmartContractDeployedInstanceId = Convert.ToInt32(reader["SmartContractDeployedInstanceId"]);
smartContractTransaction.TransactionHash = reader["TransactionHash"]?.ToString();
smartContractTransaction.TransactionUser = reader["TransactionUser"]?.ToString();
smartContractTransaction.SmartContractFunction = reader["SmartContractFunction"]?.ToString();
smartContractTransaction.SmartContractFunctionParameters = reader["SmartContractFunctionParameters"]?.ToString();
smartContractTransaction.CreatedDatetime = string.IsNullOrEmpty(reader["CreatedDatetime"]?.ToString()) ? DateTime.MinValue : Convert.ToDateTime(reader["CreatedDatetime"]);
smartContractTransaction.UpdatedDatetime = string.IsNullOrEmpty(reader["UpdatedDatetime"]?.ToString()) ? DateTime.MinValue : Convert.ToDateTime(reader["UpdatedDatetime"]);
smartContractTransaction.Name = reader["Name"]?.ToString();
List <string> paramsFromDb = reader["SmartContractFunctionParameters"].ToString().Trim(new char[] { '[', ']' }).Split(',').ToList();
smartContractTransaction.SmartContractFunctionParametersList = paramsFromDb;
string abi = reader["Abi"].ToString();
List <string> paramNames = this.AbiToParamterNames(abi, smartContractTransaction.SmartContractFunction);
smartContractTransaction.SmartContractFunctionParamterNames = this.CreateParamInfo(paramNames, paramsFromDb);
smartContractTransactionDict[smartContractTransaction.TransactionHash] = smartContractTransaction;
}
return(smartContractTransactionDict);
}
}
public void WhenSerializeAndDeserializeBlockWithOneSContract()
{
var smartContractTransaction = new SmartContractTransaction
{
Data = new byte[4] {
9, 8, 7, 4
},
From = new byte[3] {
1, 2, 3
},
Nonce = 988
};
var block = new Block(null, NBits, NonceHelper.GetNonceUInt32());
block.Transactions.Add(smartContractTransaction);
var exceptedBlockHeader = block.GetHashHeader();
var serializedBlock = block.Serialize();
var deserializedBlock = Block.Deserialize(serializedBlock);
var blockHeader = deserializedBlock.GetHashHeader();
Assert.IsTrue(blockHeader.SequenceEqual(exceptedBlockHeader));
}
public async Task <SmartContractTransaction> ExecuteWriteFunction(SmartContractExecutionRequestPayload smartContractExecutionRequestPayload)
{
if (smartContractExecutionRequestPayload == null)
{
throw new ArgumentNullException(nameof(smartContractExecutionRequestPayload) + " is null");
}
if (smartContractExecutionRequestPayload.SmartContractDeployedInstanceId == 0)
{
throw new ArgumentException(nameof(smartContractExecutionRequestPayload.SmartContractDeployedInstanceId) + " is not valid");
}
if (string.IsNullOrEmpty(smartContractExecutionRequestPayload.TransactionUser))
{
throw new ArgumentException(nameof(smartContractExecutionRequestPayload.TransactionUser) + " is not valid");
}
try
{
var userDltAccount = await this.accountDb.GetUserDltAccountByLoginId(smartContractExecutionRequestPayload.TransactionUser);
var smartContractDeployedInstance = await this.smartContractDb.GetSmartContractDeployedInstance(smartContractExecutionRequestPayload.SmartContractDeployedInstanceId);
if (userDltAccount != null && smartContractDeployedInstance != null)
{
var smartContract = await this.smartContractDb.GetSmartContract(smartContractDeployedInstance.SmartContractId);
if (smartContract != null)
{
var web3 = new Web3Geth();
var unlockResult = await web3.Personal.UnlockAccount.SendRequestAsync(userDltAccount.Address, userDltAccount.PassPhrase, 120);
if (unlockResult)
{
var contract = web3.Eth.GetContract(smartContract.Abi, smartContractDeployedInstance.DeployedAddress);
var contractFunction = contract.GetFunction(smartContractExecutionRequestPayload.Function);
var param = smartContractExecutionRequestPayload.Parameters;
var functionDataParam = param.ToArray();
var gas = await contractFunction.EstimateGasAsync(userDltAccount.Address, new HexBigInteger(9000), null, functionDataParam);
string transactionHash = await contractFunction.SendTransactionAsync(userDltAccount.Address, gas, null, functionDataParam);
if (!string.IsNullOrEmpty(transactionHash))
{
SmartContractTransaction smartContractTransaction = new SmartContractTransaction()
{
SmartContractDeployedInstanceId = smartContractExecutionRequestPayload.SmartContractDeployedInstanceId,
SmartContractFunction = smartContractExecutionRequestPayload.Function,
TransactionHash = transactionHash,
TransactionUser = smartContractExecutionRequestPayload.TransactionUser,
SmartContractFunctionParameters = Newtonsoft.Json.JsonConvert.SerializeObject(smartContractExecutionRequestPayload.Parameters)
};
var updatedSmartContractTransaction = await this.smartContractDb.CreateSmartContractTransaction(smartContractTransaction);
return(updatedSmartContractTransaction);
}
else
{
throw new Exception("Generate transaction hash is null");
}
}
else
{
throw new Exception("Unable to unlock the transaction user DLT account for performing the DLT transaction");
}
}
else
{
throw new Exception("Unabel to unlock the account");
}
}
else
{
throw new Exception("Unable to find Smart Contract");
}
}
catch (Exception ex)
{
this.logger.LogException(ex, "An error occured in method SmartContractManager ==> ExecuteWriteFunction");
throw;
}
}
private JObject CallSmartContract(IEnumerable <string> parameters, string id, JObject response)
{
if (parameters == null || !parameters.Any())
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The to is not specified"));
}
IEnumerable <byte> callToPayload = null;
IEnumerable <byte> callFromPayload = null;
IEnumerable <byte> callDataPayload = null;
double callGas = 0,
callGasPrice = 0,
callScValue = 0;
try
{
callToPayload = parameters.First().FromHexString(); // TO
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The to cannot be decoded"));
}
if (parameters.Count() > 2)
{
try
{
callFromPayload = parameters.ElementAt(1).FromHexString(); // FROM
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The from cannot be decoded"));
}
}
if (parameters.Count() >= 3)
{
try
{
callDataPayload = parameters.ElementAt(2).FromHexString(); // DATA
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The data cannot be decoded"));
}
}
if (parameters.Count() >= 4)
{
try
{
callGas = double.Parse(parameters.ElementAt(3)); // GAS
}
catch (Exception) { }
}
if (parameters.Count() >= 5)
{
try
{
callGasPrice = double.Parse(parameters.ElementAt(4)); // GASPRICE
}
catch (Exception) { }
}
if (parameters.Count() >= 6)
{
try
{
callScValue = double.Parse(parameters.ElementAt(5)); // VALUE
}
catch (Exception) { }
}
var callSmartContractTx = new SmartContractTransaction
{
Data = callDataPayload,
From = callFromPayload,
To = callToPayload,
Gas = callGas,
GasPrice = callGasPrice,
Value = callScValue
};
try
{
_transactionValidator.Check(callSmartContractTx);
var executor = _solidityExecutor.Execute(callToPayload, callFromPayload, callDataPayload, true).Rollback();
var result = executor.GetProgram().GetResult().GetHReturn().ToHexString();
response["result"] = result;
return(response);
}
catch (ValidationException ex)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_VERIFY_ERROR, ex.Message));
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_VERIFY_ERROR, ErrorCodes.ErrorExecutionContract));
}
}
private JObject SendSmartContractTransaction(IEnumerable <string> parameters, string id, JObject response)
{
var blockChain = _blockChainStore.GetBlockChain();
if (parameters == null || !parameters.Any())
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The from & data are not specified"));
}
if (parameters.Count() < 2)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The data is not specified"));
}
IEnumerable <byte> fromPayload = null;
IEnumerable <byte> dataPayload = null;
IEnumerable <byte> toPayload = null;
double gas = 0,
gasPrice = 0,
scValue = 0;
int scNonce = 0;
try
{
fromPayload = parameters.First().FromHexString();
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The from cannot be decoded"));
}
try
{
dataPayload = parameters.ElementAt(1).FromHexString();
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The data cannot be decoded"));
}
if (parameters.Count() >= 3)
{
try
{
toPayload = parameters.ElementAt(2).FromHexString();
}
catch (Exception)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The to cannot be decoded"));
}
}
if (parameters.Count() >= 4)
{
try
{
gas = double.Parse(parameters.ElementAt(3));
}
catch (Exception) { }
}
if (parameters.Count() >= 5)
{
try
{
gasPrice = double.Parse(parameters.ElementAt(4));
}
catch (Exception) { }
}
if (parameters.Count() >= 6)
{
try
{
scValue = double.Parse(parameters.ElementAt(5));
}
catch (Exception) { }
}
if (parameters.Count() >= 7)
{
try
{
scNonce = int.Parse(parameters.ElementAt(6));
}
catch (Exception) { }
}
var smartContractTx = new SmartContractTransaction
{
Data = dataPayload,
From = fromPayload,
To = toPayload,
Gas = gas,
GasPrice = gasPrice,
Nonce = scNonce,
Value = scValue
};
try
{
_transactionValidator.Check(smartContractTx);
MemoryPool.Instance().AddTransaction(smartContractTx, blockChain.GetCurrentBlockHeight());
P2PConnectorEventStore.Instance().Broadcast(smartContractTx);
response["result"] = smartContractTx.GetTxId().ToHexString();
return(response);
}
catch (ValidationException ex)
{
return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_VERIFY_ERROR, ex.Message));
}
}
private void PublishContract(object sender, EventArgs e)
{
if (_viewModel == null)
{
return;
}
var authenticatedWallet = WalletStore.Instance().GetAuthenticatedWallet();
if (authenticatedWallet == null)
{
MainWindowStore.Instance().DisplayError("You're not authenticated");
return;
}
if (string.IsNullOrWhiteSpace(_viewModel.SmartContract))
{
MainWindowStore.Instance().DisplayError("The solidity contract must be filled in");
return;
}
var rpcClient = new RpcClient(authenticatedWallet.Network);
_publishedSolidityContract = null;
rpcClient.CompileSolidity(_viewModel.SmartContract).ContinueWith((t) =>
{
try
{
var compilationResult = t.Result;
if (compilationResult.Infos == null || !compilationResult.Infos.Any())
{
return;
}
UpdateSmartContractDefinition(compilationResult);
var newKey = _walletHelper.CreateNewAddress();
var fromAddr = newKey.GetPublicKeyHashed();
var smartContractTransaction = new SmartContractTransaction
{
From = fromAddr,
Data = compilationResult.Infos.First().Code.FromHexString(),
Nonce = NonceHelper.GetNonceInt32()
};
rpcClient.SendRawTransaction(smartContractTransaction).ContinueWith((c) =>
{
Application.Current.Dispatcher.Invoke(() =>
{
_viewModel.TransactionId = c.Result;
});
_publishedSolidityContract = new SolidityContractAggregate
{
Abi = compilationResult.Infos.First().AbiDefinition.ToString(),
Code = compilationResult.Infos.First().Code
};
});
}
catch (AggregateException)
{
Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to build the solidity contract"));
}
});
}
public SmartContractTransactionEventArgs(SmartContractTransaction transaction)
{
_transaction = transaction;
}
public long GetFee(SmartContractTransaction transaction, Networks network)
{
return(1);
}
public void Check(SmartContractTransaction transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
var blockChain = _blockChainStore.GetBlockChain();
var smartContracts = _smartContractStore.GetSmartContracts();
var vm = new SolidityVm();
var defaultCallValue = new DataWord(new byte[] { 0x00 });
if (transaction.To == null || !transaction.To.Any())
{
if (transaction.From == null || !transaction.From.Any())
{
throw new ArgumentNullException(nameof(transaction.From));
}
if (transaction.From.Count() != 20)
{
throw new ValidationException(ErrorCodes.FromInvalidLength);
}
if (transaction.Data == null || !transaction.Data.Any())
{
throw new ArgumentNullException(nameof(transaction.Data));
}
var scs = _smartContractStore.GetSmartContracts();
var program = new SolidityProgram(transaction.Data.ToList(), new SolidityProgramInvoke(new byte[0], new DataWord(transaction.From.ToArray()), defaultCallValue, scs)); // TRY TO GET THE CONTRACT.
try
{
while (!program.IsStopped())
{
vm.Step(program);
}
scs.Rollback();
var hReturn = program.GetResult().GetHReturn();
if (hReturn == null || !hReturn.Any())
{
throw new ValidationException(ErrorCodes.SmartContractNotValid);
}
}
catch (Exception)
{
throw new ValidationException(ErrorCodes.SmartContractNotValid);
}
}
else
{
if (transaction.To.Count() != 20)
{
throw new ValidationException(ErrorCodes.ToInvalidLength);
}
var smartContract = smartContracts.GetSmartContract(transaction.To);
if (smartContract == null)
{
throw new ValidationException(ErrorCodes.SmartContractDoesntExist);
}
}
}
