public string SignTransaction(string key, string to, BigInteger amount, BigInteger nonce, string data)
{
var transaction = new Transaction(to, amount, nonce, data);
transaction.Sign(new EthECKey(key.HexToByteArray(), true));
return(transaction.GetRLPEncoded().ToHex());
}
/// <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
});
}
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);
}
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 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;
}
}
}
private string SignTransaction(byte[] privateKey, Transaction transaction)
{
transaction.Sign(new EthECKey(privateKey, true));
return(transaction.GetRLPEncoded().ToHex());
}
private async Task <string> SignTransactionAsync(IEthECKeyExternalSigner externalSigner, Transaction transaction)
{
await transaction.SignExternallyAsync(externalSigner).ConfigureAwait(false);
return(transaction.GetRLPEncoded().ToHex());
}
