public override async Task SignAsync(CeloTransactionChainId transaction)
{
var txMessage = new EthereumSignTx
{
Nonce = transaction.Nonce,
GasPrice = transaction.GasPrice,
GasLimit = transaction.GasLimit,
To = transaction.ReceiveAddress,
Value = transaction.Value,
AddressNs = GetPath(),
ChainId = (uint)new BigInteger(transaction.ChainId)
};
if (transaction.Data.Length > 0)
{
txMessage.DataInitialChunk = transaction.Data;
txMessage.DataLength = (uint)transaction.Data.Length;
}
var signature = await TrezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
if (signature.SignatureS == null || signature.SignatureR == null)
{
throw new Exception("Signing failure or not accepted");
}
transaction.SetSignature(EthECDSASignatureFactory.FromComponents(signature.SignatureR, signature.SignatureS, (byte)signature.SignatureV));
}
/// <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 SignEthereumTransaction2()
{
var txMessage = new EthereumSignTx
{
Nonce = 10.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
GasPrice = 1000000000.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
GasLimit = 21000.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
To = "689c56aef474df92d44a1b70850f808488f9769c",
Value = BigInteger.Parse("10000000000000000000").ToBytesForRLPEncoding().ToHex().ToHexBytes(),
AddressNs = AddressPathBase.Parse <BIP44AddressPath>("m/44'/60'/0'/0/0").ToArray(),
ChainId = 1
};
var transaction = await TrezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
Assert.AreEqual(transaction.SignatureR.Length, 32);
Assert.AreEqual(transaction.SignatureS.Length, 32);
}
public async Task SignEthereumTransaction()
{
//Note: these are not reasonable values. They should not be used for a transaction. Looking for a better example here...
var txMessage = new EthereumSignTx
{
Nonce = 0.ToHexBytes(),
GasPrice = 1000000000.ToHexBytes(),
GasLimit = 21000.ToHexBytes(),
To = "689c56aef474df92d44a1b70850f808488f9769c",
Value = 100000000000000.ToHexBytes(),
AddressNs = new BIP44AddressPath(false, 60, 0, false, 0).ToArray(),
ChainId = 4
};
var transaction = await TrezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
Assert.AreEqual(transaction.SignatureR.Length, 32);
Assert.AreEqual(transaction.SignatureS.Length, 32);
}
public async Task SignEthereumTransaction()
{
await GetAndInitialize();
var txMessage = new EthereumSignTx
{
Nonce = 10.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
GasPrice = 1000000000.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
GasLimit = 21000.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
To = "689c56aef474df92d44a1b70850f808488f9769c".ToHexBytes(),
Value = BigInteger.Parse("10000000000000000000").ToBytesForRLPEncoding().ToHex().ToHexBytes(),
AddressNs = KeyPath.Parse("m/44'/60'/0'/0/0").Indexes,
ChainId = 1
};
var transaction = await KeepKeyManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
Assert.AreEqual(transaction.SignatureR.Length, 32);
Assert.AreEqual(transaction.SignatureS.Length, 32);
}
public async Task SignEthereumTransaction()
{
await GetAndInitialize();
//Note: these are not reasonable values. They should not be used for a transaction. Looking for a better example here...
var txMessage = new EthereumSignTx
{
Nonce = "0".ToHexBytes(),
GasPrice = 1000000000.ToHexBytes(),
GasLimit = 21000.ToHexBytes(),
To = "689c56aef474df92d44a1b70850f808488f9769c".ToHexBytes(),
Value = "de0b6b3a7640000".ToHexBytes(),
AddressNs = ManagerHelpers.GetAddressPath(false, 0, false, 0, 60),
ChainId = 1
};
var transaction = await TrezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
Assert.AreEqual(transaction.SignatureR.Length, 32);
Assert.AreEqual(transaction.SignatureS.Length, 32);
}
public override async Task SignAsync(Transaction transaction)
{
var txMessage = new EthereumSignTx
{
Nonce = transaction.Nonce,
GasPrice = transaction.GasPrice,
GasLimit = transaction.GasLimit,
To = transaction.ReceiveAddress,
Value = transaction.Value,
AddressNs = GetPath(),
};
if (transaction.Data.Length > 0)
{
txMessage.DataInitialChunk = transaction.Data;
txMessage.DataLength = (uint)transaction.Data.Length;
}
var signature = await TrezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
transaction.SetSignature(EthECDSASignatureFactory.FromComponents(signature.SignatureR, signature.SignatureS, (byte)signature.SignatureV));
}
public async Task <EthereumTxRequest> SignEthereumTransactionAsync(EthereumSignTx signTx)
{
return(await SendMessageAsync <EthereumTxRequest, EthereumSignTx>(signTx));
}
/// <summary>
/// TODO: This should be made in to a unit test but it's annoying to add the UI for a unit test as the Trezor requires human intervention for the pin
/// </summary>
/// <returns></returns>
private async static Task Go()
{
try
{
using (var trezorHid = await Connect())
{
using (var trezorManager = new TrezorManager(GetPin, trezorHid))
{
await trezorManager.InitializeAsync();
var tasks = new List <Task>();
for (var i = 0; i < 50; i++)
{
tasks.Add(DoGetAddress(trezorManager, i));
}
await Task.WhenAll(tasks);
for (var i = 0; i < 50; i++)
{
var address = await GetAddress(trezorManager, i);
Console.WriteLine($"Index: {i} (No change) - Address: {address}");
if (address != _Addresses[i])
{
throw new Exception("The ordering got messed up");
}
}
var ethAddress = await trezorManager.GetAddressAsync("ETH", 60, false, 0, false, AddressType.Ethereum);
Console.WriteLine($"First ETH address: {ethAddress}");
//This fails with 'Safety check failed'
//See https://github.com/trezor/trezor-mcu/issues/143
//https://github.com/trezor/trezor-mcu/blob/master/firmware/ethereum.c
//Which values here need leading zeros? Is Unicode the correct encoding?
var message = new EthereumSignMessage
{
AddressNs = KeyPath.Parse("m/44'/60'/0'/0/0").Indexes,
Message = Encoding.UTF8.GetBytes("Hello").ToHex().ToHexBytes()
};
var messageSignature = await trezorManager.SendMessageAsync <EthereumMessageSignature, EthereumSignMessage>(message);
//Same as first address
Console.WriteLine(ToHex(messageSignature.Address));
var signer = new Nethereum.Signer.EthereumMessageSigner();
var messageSignature2 = signer.EncodeUTF8AndSign("Hello2", new EthECKey(
"0x2e14c29aaecd1b7c681154d41f50c4bb8b6e4299a431960ed9e860e39cae6d29"));
// var recoveredAddress = signer.EncodeUTF8AndEcRecover("Hello", messageSignature.Signature.ToHex());
//Same as recovered address
//Console.WriteLine(recoveredAddress);
//var txMessage = new EthereumSignTx
//{
// Nonce = 1.ToHexBytes(),
// GasPrice = 1000000000.ToHexBytes(),
// GasLimit = 21000.ToHexBytes(),
// To = "689c56aef474df92d44a1b70850f808488f9769c".ToHexBytes(),
// Value = 1000000000000000.ToHexBytes(),
// //Value = "de0b6b3a7640000".ToHexBytes(),
// AddressNs = KeyPath.Parse("m/44'/60'/0'/0/0").Indexes,
// ChainId = 1
//};
var txMessage = new EthereumSignTx
{
Nonce = 10.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
GasPrice = 10.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
GasLimit = 21000.ToBytesForRLPEncoding().ToHex().ToHexBytes(),
To = "689c56aef474df92d44a1b70850f808488f9769c".ToHexBytes(),
Value = BigInteger.Parse("10000000000000000000").ToBytesForRLPEncoding().ToHex().ToHexBytes(),
//Value = "de0b6b3a7640000".ToHexBytes(),
AddressNs = KeyPath.Parse("m/44'/60'/0'/0/0").Indexes,
//ChainId = 1
};
var transaction = await trezorManager.SendMessageAsync <EthereumTxRequest, EthereumSignTx>(txMessage);
var transactionSigner = new TransactionSigner();
var sigature2 = transactionSigner.SignTransaction("0x2e14c29aaecd1b7c681154d41f50c4bb8b6e4299a431960ed9e860e39cae6d29",
"0x689c56aef474df92d44a1b70850f808488f9769c", 10, 10, 10, 21000);
var transactionRecovered = new Transaction(sigature2.HexToByteArray());
//var transactionChainId = new TransactionChainId(sigature2.HexToByteArray(), 1);
Console.WriteLine("All good");
Console.ReadLine();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadLine();
}
}
