Example #1
0
        public async Task <string> CallSmartContract(SmartContractTransactionParameter scTransaction)
        {
            if (scTransaction == null)
            {
                throw new ArgumentNullException(nameof(scTransaction));
            }

            if (scTransaction.To == null)
            {
                throw new ArgumentNullException(nameof(scTransaction.To));
            }

            var httpClient = _httpClientFactory.BuildClient();
            var jParams    = new JArray();

            jParams.Add(scTransaction.To.ToHexString());
            jParams.Add(scTransaction.From.ToHexString());
            jParams.Add(scTransaction.Data.ToHexString());
            jParams.Add(scTransaction.Gas);
            jParams.Add(scTransaction.GasPrice);
            jParams.Add(scTransaction.Value);
            var jObj = new JObject();

            jObj.Add("id", Guid.NewGuid().ToString());
            jObj.Add("method", Constants.RpcOperations.ScCall);
            jObj.Add("params", jParams);
            var content = new StringContent(jObj.ToString(), System.Text.Encoding.UTF8, ContentType);
            var request = new HttpRequestMessage
            {
                Method     = HttpMethod.Post,
                Content    = content,
                RequestUri = GetUri()
            };

            var response = await httpClient.SendAsync(request).ConfigureAwait(false);

            var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

            string errorCode = null;
            var    jsonObj   = JObject.Parse(json);

            if (TryGetError(jsonObj, out errorCode))
            {
                throw new RpcException(errorCode);
            }

            var r = jsonObj.Value <string>("result");

            if (string.IsNullOrWhiteSpace(r))
            {
                return(null);
            }

            return(r);
        }
Example #2
0
        private void CallContract(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 smartContractTransactionParameter = new SmartContractTransactionParameter(_viewModel.SelectedSolidityContract.Address.FromHexString());

            smartContractTransactionParameter.Data = callValue.FromHexString();
            var rpcClient = new RpcClient(authenticatedWallet.Network);

            rpcClient.CallSmartContract(smartContractTransactionParameter).ContinueWith((t) =>
            {
                try
                {
                    var smartContractResult = t.Result;
                    Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayMessage(string.Format("Result of the operation : {0}", smartContractResult)));
                }
                catch (AggregateException)
                {
                    Application.Current.Dispatcher.Invoke(() => MainWindowStore.Instance().DisplayError("An error occured while trying to call the contract"));
                }
            });
        }