public async Task Erc20ServiceUnitTest_SignAndCommitTransaction() { string from = TestConstants.PW_ADDRESS; Erc20Transaction ethTransaction = new Erc20Transaction() { FromAddress = from, GasAmount = 21000, GasPrice = 30000000000, ToAddress = _contractAddress, TokenAddress = _contractAddress, TokenAmount = 30000000000 }; string transactionHex = await _erc20Service.GetTransferTransactionRaw(ethTransaction); string signedTransaction = SignRawTransaction(transactionHex, _privateKey); string transactionHash = await _erc20Service.SubmitSignedTransaction(from, signedTransaction); Nethereum.Signer.Transaction transaction = new Nethereum.Signer.Transaction(signedTransaction.HexToByteArray()); _client.Verify(x => x.SendRequestAsync <string>(It.IsAny <Nethereum.JsonRpc.Client.RpcRequest>(), null), Times.Once); Assert.AreEqual(from, transaction.Key.GetPublicAddress()); Assert.AreEqual(_nonceCalc._nonceStorage[from].Value, new HexBigInteger(transaction.Nonce.ToHex())); Assert.AreEqual(ethTransaction.GasAmount, new HexBigInteger(transaction.GasLimit.ToHex())); Assert.AreEqual(new HexBigInteger(0).Value, new HexBigInteger(transaction.Value.ToHex())); Assert.AreEqual(ethTransaction.GasPrice, new HexBigInteger(transaction.GasPrice.ToHex())); Assert.AreEqual(ethTransaction.ToAddress.ToLower(), transaction.ReceiveAddress.ToHex().EnsureHexPrefix()); }
public async Task <string> SignAndSendRawTransaction(Nethereum.Signer.Transaction transaction) { transaction.Sign(new EthECKey(_sender_private_key.HexToByteArray(), isPrivate: true)); string signed_transaction_data = transaction.GetRLPEncoded().ToHex(); string tx_hash = await _web3geth.Eth.Transactions.SendRawTransaction.SendRequestAsync(signed_transaction_data); return(tx_hash); }
private string SignRawTransaction(string trHex, string privateKey) { var transaction = new Nethereum.Signer.Transaction(trHex.HexToByteArray()); var secret = new EthECKey(privateKey); transaction.Sign(secret); string signedHex = transaction.GetRLPEncoded().ToHex(); return(signedHex); }
private Nethereum.Signer.Transaction ConvertToTx(RelayResponse response) { var tx = new Nethereum.Signer.Transaction( response.To, response.Value.Value, response.Nonce.Value, response.GasPrice.Value, response.Gas.Value, response.Input); tx.SetSignature(new EthECDSASignature( new Org.BouncyCastle.Math.BigInteger(response.R.RemoveHexPrefix(), 16), new Org.BouncyCastle.Math.BigInteger(response.S.RemoveHexPrefix(), 16), response.V.HexToByteArray())); return(tx); }
public async Task <string> SendTransactionAsync <T>(T transaction) where T : TransactionInput { var ethSendTransaction = new EthSendRawTransaction(Client); var nonce = await GetNonceAsync(transaction); var value = transaction.Value?.Value ?? 0; var gasPrice = await EstimateGasPrice(); var gasValue = transaction.Gas?.Value ?? Transaction.DEFAULT_GAS_LIMIT; var tr = new Transaction(transaction.To, value, nonce, gasPrice, gasValue, transaction.Data); var hex = tr.GetRLPEncoded().ToHex(); var response = await _signatureApi.SignTransaction(new SignRequest { From = transaction.From, Transaction = hex }); return(await ethSendTransaction.SendRequestAsync(response.SignedTransaction.EnsureHexPrefix()).ConfigureAwait(false)); }
public Task <bool> IsValidTransactionHex(string transactionHex) { if (string.IsNullOrEmpty(transactionHex)) { return(Task.FromResult(false)); } try { var transaction = new Nethereum.Signer.Transaction(transactionHex.HexToByteArray()); } catch (Exception e) { return(Task.FromResult(false)); } return(Task.FromResult(true)); }
public async Task <string> BuildTransactionAsync( string from, string to, BigInteger amount, BigInteger gasAmount, BigInteger gasPrice) { var transaction = new NethereumTransaction ( to: to, amount: amount, nonce: await GetNextNonceAsync(from), gasPrice: gasPrice, gasLimit: gasAmount, data: null ); return(transaction .GetRLPEncoded() .ToHex(prefix: true)); }
public string SignTransaction( string transactionContext, string privateKey) { using (var eventHolder = _telemetryClient.StartEvent("TransactionSigned")) { try { var transactionBytes = transactionContext.HexToByteArray(); var transactionDto = MessagePackSerializer.Deserialize <UnsignedTransaction>(transactionBytes); var transaction = new NethereumTransaction ( to: transactionDto.To, amount: transactionDto.Amount, nonce: transactionDto.Nonce, gasPrice: transactionDto.GasPrice, gasLimit: transactionDto.GasAmount, data: null ); transaction.Sign ( key: new EthECKey(privateKey) ); return(transaction .GetRLPEncoded() .ToHex(prefix: true)); } catch (Exception) { eventHolder.TrackFailure("TransactionSigningFailed"); throw; } } }
public async Task Erc20ServiceUnitTest_TestGetTransaction() { string from = TestConstants.PW_ADDRESS; Erc20Transaction ethTransaction = new Erc20Transaction() { FromAddress = from, GasAmount = 21000, GasPrice = 30000000000, ToAddress = _contractAddress, TokenAddress = _contractAddress, TokenAmount = 30000000000 }; string transactionHex = await _erc20Service.GetTransferTransactionRaw(ethTransaction); Nethereum.Signer.Transaction transaction = new Nethereum.Signer.Transaction(transactionHex.HexToByteArray()); Assert.AreEqual(_nonceCalc._nonceStorage[from].Value, new HexBigInteger(transaction.Nonce.ToHex())); Assert.AreEqual(ethTransaction.GasAmount, new HexBigInteger(transaction.GasLimit.ToHex())); Assert.AreEqual(new HexBigInteger(0).Value, new HexBigInteger(transaction.Value.ToHex())); Assert.AreEqual(ethTransaction.GasPrice, new HexBigInteger(transaction.GasPrice.ToHex())); Assert.AreEqual(ethTransaction.ToAddress.ToLower(), transaction.ReceiveAddress.ToHex().EnsureHexPrefix()); Assert.IsNotNull(transaction.Data.ToHex().EnsureHexPrefix()); }
/// <summary> /// Gets the signed transaction data from the Trezor wallet. /// </summary> /// <param name="transaction"> The transaction to sign. </param> /// <param name="path"> The path of the address to sign the transaction with. </param> /// <param name="onSignatureRequestSent"> Action to call once the signature request has been sent. </param> /// <returns> Task returning the SignedTransactionDataHolder instance. </returns> protected override async Task <SignedTransactionDataHolder> GetSignedTransactionData(Transaction transaction, string path, Action onSignatureRequestSent) { var trezorManager = TrezorConnector.GetWindowsConnectedTrezor(GetSignedTransactionDataEnterPin); if (trezorManager == null) { return(null); } var signedTransactionResponse = (EthereumTxRequest)null; var signedTransactionRequest = new EthereumSignTx { Nonce = transaction.Nonce, AddressNs = KeyPath.Parse(path).Indexes, GasPrice = transaction.GasPrice, GasLimit = transaction.GasLimit, To = transaction.ReceiveAddress, Value = transaction.Value, DataInitialChunk = transaction.Data, DataLength = (uint)transaction.Data.Length, ChainId = (uint)ethereumNetworkSettings.networkType }; while (true) { try { signedTransactionResponse = await trezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(signedTransactionRequest, onSignatureRequestSent) .ConfigureAwait(false); break; } catch (FailureException <Failure> ) { if (forceCancel) { forceCancel = false; break; } if (trezorManager.PinRequest.HasValue && trezorManager.PinRequest == false) { break; } } } if (signedTransactionResponse == null) { return(new SignedTransactionDataHolder()); } return(new SignedTransactionDataHolder { signed = true, v = signedTransactionResponse.SignatureV, r = signedTransactionResponse.SignatureR, s = signedTransactionResponse.SignatureS }); }
public async Task <string> CreateAsync( string task_uuid, string flight_id, string pid, string ufid, string flight_code, string fs_flight_code, string departure_utc_offset_hours, string arrival_utc_offset_hours, string departure_airport, string arrival_airport, string scheduled_departure_date, string scheduled_departure_date_time, string scheduled_departure_date_time_local, string scheduled_arrival_date_time, string scheduled_arrival_date_time_local, BigInteger?nonce = null) { _logger.LogDebug("FDBC_Nethereum.SmartContracts.Flight.CreateAsync({task_uuid})", task_uuid); string sender_address = _settings.default_sender_address; string contract_abi = _settings.flight_contract_abi; string contract_bytecode = _settings.flight_contract_bytecode; //==================================== // deploy contract var from = sender_address; var gasLimit = new HexBigInteger(_settings.flight_contract_deploy_gas); var wei = new HexBigInteger(0); object[] values = new object[] { task_uuid, flight_id, pid, ufid, flight_code, fs_flight_code, departure_utc_offset_hours, arrival_utc_offset_hours, departure_airport, arrival_airport, scheduled_departure_date, scheduled_departure_date_time, scheduled_departure_date_time_local, scheduled_arrival_date_time, scheduled_arrival_date_time_local }; string tx_hash = ""; if (nonce != null) { string data = web3geth.Eth.DeployContract.GetData(contract_bytecode, contract_abi, values); Nethereum.Signer.Transaction signable_transcation = new Nethereum.Signer.Transaction( to: null, amount: wei, nonce: (BigInteger)nonce, gasPrice: Nethereum.Signer.Transaction.DEFAULT_GAS_PRICE, gasLimit: gasLimit.Value, data: data ); tx_hash = await _blockchain_manager.SignAndSendRawTransaction(signable_transcation); //_logger.LogDebug("SignAndSendRawTransaction(PrivateKey = {sender_private_key}, Signature = {@Signature}) => tx=hash = {tx_hash}", _blockchain_manager.sender_private_key, signable_transcation.Signature, tx_hash); } else { tx_hash = await web3geth.Eth.DeployContract.SendRequestAsync( abi : contract_abi, contractByteCode : contract_bytecode, from : from, gas : gasLimit, value : wei, values : values); } return(tx_hash); }
public async Task <string> SetFlightAllAttributes( string contract_address, string task_uuid, string status, string actual_departure_date_time, string actual_departure_date_time_local, string actual_arrival_date_time, string actual_arrival_date_time_local, string cancel_date_time, string cancel_date_time_local, string deleted, string flight_status_source, string flight_status_fed, string delay_notification_date_time, BigInteger?nonce = null ) { // SmartContract function doesn't take null as input for string status = status ?? ""; actual_departure_date_time = actual_departure_date_time ?? ""; actual_departure_date_time_local = actual_departure_date_time_local ?? ""; actual_arrival_date_time = actual_arrival_date_time ?? ""; actual_arrival_date_time_local = actual_arrival_date_time_local ?? ""; cancel_date_time = cancel_date_time ?? ""; cancel_date_time_local = cancel_date_time_local ?? ""; deleted = deleted ?? ""; flight_status_source = flight_status_source ?? ""; flight_status_fed = flight_status_fed ?? ""; delay_notification_date_time = delay_notification_date_time ?? ""; // Web3 string sender_address = _settings.default_sender_address; string contract_abi = _settings.flight_contract_abi; Contract contract = web3geth.Eth.GetContract(contract_abi, contract_address); string task_uuid_sha3 = $"0x{_web3geth.Sha3(task_uuid)}"; byte[] task_uuid_sha3_bytes32 = task_uuid_sha3.HexToByteArray(); Function set_function = contract.GetFunction("set_all"); var from = sender_address; var gasLimit = new HexBigInteger(_settings.flight_contract_set_all_gas); var wei = new HexBigInteger(0); object[] values = new object[] { task_uuid, status, actual_departure_date_time, actual_departure_date_time_local, actual_arrival_date_time, actual_arrival_date_time_local, cancel_date_time, cancel_date_time_local, deleted, flight_status_source, flight_status_fed, delay_notification_date_time }; string tx_hash = ""; if (nonce != null) { string data = set_function.GetData(values); Nethereum.Signer.Transaction signable_transcation = new Nethereum.Signer.Transaction( to: contract_address, amount: wei, nonce: (BigInteger)nonce, gasPrice: Nethereum.Signer.Transaction.DEFAULT_GAS_PRICE, gasLimit: gasLimit.Value, data: data ); tx_hash = await _blockchain_manager.SignAndSendRawTransaction(signable_transcation); } else { tx_hash = await set_function.SendTransactionAsync( from : from, gas : gasLimit, value : wei, functionInput : values ); } return(tx_hash); }
/// <summary> /// Signs a transaction using this IWallet. /// </summary> /// <typeparam name="T"> The type of the popup to display the transaction confirmation for. </typeparam> /// <param name="onTransactionSigned"> The action to call if the transaction is confirmed and signed. </param> /// <param name="gasLimit"> The gas limit to use with the transaction. </param> /// <param name="gasPrice"> The gas price to use with the transaction. </param> /// <param name="value"> The amount of ether in wei being sent along with the transaction. </param> /// <param name="addressFrom"> The address of the wallet signing the transaction. </param> /// <param name="addressTo"> The address the transaction is being sent to. </param> /// <param name="data"> The data sent along with the transaction. </param> /// <param name="path"> The path of the wallet to sign the transaction with. </param> /// <param name="displayInput"> The display input that goes along with the transaction request. </param> public void SignTransaction <T>( Action <TransactionSignedUnityRequest> onTransactionSigned, BigInteger gasLimit, BigInteger gasPrice, BigInteger value, string addressFrom, string addressTo, string data, string path, params object[] displayInput) where T : ConfirmTransactionPopupBase <T> { if (signingTransaction) { return; } signingTransaction = true; TransactionUtils.GetAddressTransactionCount(addressFrom).OnSuccess(async txCount => { var currentPopupType = popupManager.ActivePopupType; var transaction = new Transaction( txCount.ToBytesForRLPEncoding(), gasPrice.ToBytesForRLPEncoding(), gasLimit.ToBytesForRLPEncoding(), addressTo.HexToByteArray(), value.ToBytesForRLPEncoding(), data.HexToByteArray(), new byte[] { 0 }, new byte[] { 0 }, (byte)ethereumNetworkSettings.networkType); var signedTransactionData = await GetSignedTransactionData( transaction, path, () => MainThreadExecutor.QueueAction(() => popupManager.GetPopup <T>(true)?.SetConfirmationValues(null, gasLimit, gasPrice, displayInput))).ConfigureAwait(false); signingTransaction = false; if (signedTransactionData == null) { return; } else if (!signedTransactionData.signed) { if (currentPopupType != popupManager.ActivePopupType) { MainThreadExecutor.QueueAction(() => popupManager.CloseActivePopup()); } return; } var transactionChainId = new TransactionChainId( transaction.Nonce, transaction.GasPrice, transaction.GasLimit, transaction.ReceiveAddress, transaction.Value, transaction.Data, new byte[] { (byte)ethereumNetworkSettings.networkType }, signedTransactionData.r, signedTransactionData.s, new byte[] { (byte)signedTransactionData.v }); MainThreadExecutor.QueueAction(() => { onTransactionSigned?.Invoke(new TransactionSignedUnityRequest(transactionChainId.GetRLPEncoded().ToHex(), ethereumNetworkManager.CurrentNetwork.NetworkUrl)); popupManager.CloseAllPopups(); }); }); }
/// <summary> /// Abstract method used for getting the signed transaction data from the hardware wallet. /// </summary> /// <param name="transaction"> The Transaction object containing all the data to sign. </param> /// <param name="path"> The path of the address signing the transaction. </param> /// <param name="onSignatureRequestSent"> Action to call once the request for a transaction signature has been sent. </param> /// <returns> Task returning the SignedTransactionDataHolder instance. </returns> protected abstract Task <SignedTransactionDataHolder> GetSignedTransactionData(Transaction transaction, string path, Action onSignatureRequestSent);
/// <summary> /// Gets the signed transaction data from the Ledger wallet. /// </summary> /// <param name="transaction"> The transaction to sign. </param> /// <param name="path"> The path of the address to sign the transaction with. </param> /// <param name="onSignatureRequestSent"> Action to call once the signature request has been sent. </param> /// <returns> Task returning the SignedTransactionDataHolder instance. </returns> protected override async Task <SignedTransactionDataHolder> GetSignedTransactionData(Transaction transaction, string path, Action onSignatureRequestSent) { var ledgerManager = LedgerConnector.GetWindowsConnectedLedger(); var address = ledgerManager == null ? null : (await ledgerManager.GetPublicKeyResponse(Wallet.ELECTRUM_LEDGER_PATH.Replace("x", "0"), false, false).ConfigureAwait(false))?.Address; // Don't sign transaction if app is not Ethereum, or if the first address doesn't match the first address of the opened Ledger wallet. if (string.IsNullOrEmpty(address) || !address.EqualsIgnoreCase(addresses[1][0])) { return(null); } var addressIndex = path.Count(c => c == '/') - 1; var derivationData = Helpers.GetDerivationPathData(path); var request = new EthereumAppSignTransactionRequest(derivationData.Concat(transaction.GetRLPEncoded()).ToArray()); onSignatureRequestSent?.Invoke(); var response = await ledgerManager.SendRequestAsync <EthereumAppSignTransactionResponse, EthereumAppSignTransactionRequest>(request).ConfigureAwait(false); if (!response.IsSuccess) { return(new SignedTransactionDataHolder()); } return(new SignedTransactionDataHolder { signed = true, v = response.SignatureV, r = response.SignatureR, s = response.SignatureS }); }