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); } } }