public async Task <HexBigInteger> EstimateGasAsync(string contractAddress, TFunctionMessage functionMessage = null)
{
if (functionMessage == null)
{
functionMessage = new TFunctionMessage();
}
SetEncoderContractAddress(contractAddress);
var callInput = FunctionMessageEncodingService.CreateCallInput(functionMessage);
try
{
if (TransactionManager.EstimateOrSetDefaultGasIfNotSet)
{
return(await TransactionManager.EstimateGasAsync(callInput).ConfigureAwait(false));
}
return(null);
}
catch (RpcResponseException rpcException)
{
ContractRevertExceptionHandler.HandleContractRevertException(rpcException);
throw;
}
catch (Exception)
{
var ethCall = new EthCall(TransactionManager.Client);
var result = await ethCall.SendRequestAsync(callInput).ConfigureAwait(false);
new FunctionCallDecoder().ThrowIfErrorOnOutput(result);
throw;
}
}
public Task <HexBigInteger> EstimateGasAsync(string contractAddress, TFunctionMessage functionMessage = null)
{
if (functionMessage == null)
{
functionMessage = new TFunctionMessage();
}
SetEncoderContractAddress(contractAddress);
var callInput = FunctionMessageEncodingService.CreateCallInput(functionMessage);
return(TransactionManager.EstimateGasAsync(callInput));
}
public async Task <string> SignTransactionAsync(string contractAddress, TFunctionMessage functionMessage = null)
{
if (functionMessage == null)
{
functionMessage = new TFunctionMessage();
}
SetEncoderContractAddress(contractAddress);
functionMessage.Gas = await GetOrEstimateMaximumGasAsync(functionMessage, contractAddress).ConfigureAwait(false);
var transactionInput = FunctionMessageEncodingService.CreateTransactionInput(functionMessage);
return(await TransactionManager.SignTransactionAsync(transactionInput).ConfigureAwait(false));
}
private void ValidateTx(
RelayResponse returnedTx,
TransactionInput transaction,
BigInteger txFee,
BigInteger gasPrice,
BigInteger gasLimit,
BigInteger nonce,
string relayHubAddress,
string relayAddress)
{
var tx = returnedTx.ToTransaction();
var signer = tx.Key.GetPublicAddress();
var functionEncodingService = new FunctionMessageEncodingService <RelayCallFunction>();
var relayCall = functionEncodingService.DecodeInput(new RelayCallFunction(), returnedTx.Input);
var returnedTxHash = GetTransactionHash(
relayCall.From,
relayCall.To,
relayCall.EncodedFunction.ToHex(),
relayCall.TransactionFee,
relayCall.GasPriceParam,
relayCall.GasLimit,
relayCall.NonceParam,
returnedTx.To,
signer);
var hash = GetTransactionHash(
transaction.From,
transaction.To,
transaction.Data,
txFee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
relayHubAddress,
relayAddress);
if (returnedTxHash.EnsureHexPrefix().ToLower() != hash.EnsureHexPrefix().ToLower() ||
signer.EnsureHexPrefix().ToLower() != relayAddress.EnsureHexPrefix().ToLower())
{
throw new GSNRelayInvalidResponseException();
}
}
public Task <string> QueryAsync(
string contractAddress,
TFunctionMessage contractFunctionMessage = null,
BlockParameter block = null)
{
if (contractFunctionMessage == null)
{
contractFunctionMessage = new TFunctionMessage();
}
if (block == null)
{
block = DefaultBlockParameter;
}
FunctionMessageEncodingService.SetContractAddress(contractAddress);
EnsureInitialiseAddress();
var callInput = FunctionMessageEncodingService.CreateCallInput(contractFunctionMessage);
return(EthCall.SendRequestAsync(callInput, block));
}
private void InitialiseEncodingService()
{
FunctionMessageEncodingService = new FunctionMessageEncodingService <TFunctionMessage>();
FunctionMessageEncodingService.DefaultAddressFrom = GetAccountAddressFrom();
}
