public static async Task <MultisigTransactionIdentifiers> SubmitTransactionAsync(Web3 web3, string contractAddress, string destination, BigInteger value, string data, BigInteger gas, BigInteger gasPrice)
{
IContractTransactionHandler <SubmitTransactionFunction> submitHandler = web3.Eth.GetContractTransactionHandler <SubmitTransactionFunction>();
var submitTransactionFunctionMessage = new SubmitTransactionFunction()
{
Destination = destination,
Value = value,
Data = Encoders.Hex.DecodeData(data),
Gas = gas,
GasPrice = Web3.Convert.ToWei(gasPrice, UnitConversion.EthUnit.Gwei)
};
TransactionReceipt submitTransactionReceipt = await submitHandler.SendRequestAndWaitForReceiptAsync(contractAddress, submitTransactionFunctionMessage).ConfigureAwait(false);
EventLog <SubmissionEventDTO> submission = submitTransactionReceipt.DecodeAllEvents <SubmissionEventDTO>().FirstOrDefault();
// Use -1 as an error indicator.
if (submission == null)
{
return new MultisigTransactionIdentifiers()
{
TransactionId = BigInteger.MinusOne
}
}
;
return(new MultisigTransactionIdentifiers()
{
TransactionHash = submitTransactionReceipt.TransactionHash, TransactionId = submission.Event.TransactionId
});
}
/// <summary>
/// Allows to execute a Safe transaction confirmed by required number of owners and then pays the account that submitted the transaction.
/// </summary>
/// <remarks>Note: The fees are always transferred, even if the user transaction fails.</remarks>
/// <param name="web3">Instance of the web3 client to execute the function against.</param>
/// <param name="proxyContract">The address of the Gnosis Safe proxy deployment that owns the wrapped STRAX contract.</param>
/// <param name="wrappedStraxContract">The address of the wrapped STRAX ERC20 contract.</param>
/// <param name="value">The Ether value of the transaction, if applicable. For ERC20 transfers this is 0.</param>
/// <param name="data">The ABI-encoded data of the transaction, e.g. if a contract method is being called. For ERC20 transfers this will be set.</param>
/// <param name="safeTxGas">Gas that should be used for the Safe transaction.</param>
/// <param name="baseGas">Gas costs that are independent of the transaction execution (e.g. base transaction fee, signature check, payment of the refund).</param>
/// <param name="gasPrice">Gas price that should be used for the payment calculation.</param>
/// <param name="signatureCount">The number of packed signatures included.</param>
/// <param name="signatures">Packed signature data ({bytes32 r}{bytes32 s}{uint8 v}).</param>
/// <returns>The transaction hash of the execution transaction.</returns>
public static async Task <string> ExecTransactionAsync(Web3 web3, string proxyContract, string wrappedStraxContract, BigInteger value, string data, BigInteger safeTxGas, BigInteger baseGas, BigInteger gasPrice, int signatureCount, byte[] signatures)
{
// These parameters are supplied to the function hardcoded:
// @param operation Operation type of Safe transaction. The Safe supports CALL (uint8 = 0), DELEGATECALL (uint8 = 1) and CREATE (uint8 = 2).
// @param gasToken Token address (or 0 if ETH) that is used for the payment.
// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).
IContractTransactionHandler <ExecTransactionFunction> execHandler = web3.Eth.GetContractTransactionHandler <ExecTransactionFunction>();
var execTransactionFunctionMessage = new ExecTransactionFunction()
{
To = proxyContract,
Value = value,
Data = Encoders.Hex.DecodeData(data),
Operation = 0, // CALL
SafeTxGas = safeTxGas,
BaseGas = baseGas,
GasPrice = Web3.Convert.ToWei(gasPrice, UnitConversion.EthUnit.Gwei),
GasToken = ETHClient.ZeroAddress,
RefundReceiver = ETHClient.ZeroAddress,
Signatures = signatures
};
TransactionReceipt execTransactionReceipt = await execHandler.SendRequestAndWaitForReceiptAsync(proxyContract, execTransactionFunctionMessage).ConfigureAwait(false);
return(execTransactionReceipt.TransactionHash);
}
public async Task <TransactionReceipt> Handle(CreateTemplateRequest aCreateTemplateRequest, CancellationToken aCancellationToken)
{
IContractTransactionHandler <CreateTemplateRequest> contractTransactionHandler =
Web3ContractManager.Web3.Eth.GetContractTransactionHandler <CreateTemplateRequest>();
HexBigInteger gasEstimate =
await contractTransactionHandler.EstimateGasAsync(EthereumSettings.NftCreatorAddress, aCreateTemplateRequest);
aCreateTemplateRequest.Gas = gasEstimate;
return(await contractTransactionHandler
.SendRequestAndWaitForReceiptAsync(EthereumSettings.NftCreatorAddress, aCreateTemplateRequest));
}
public static async Task <string> TransferOwnershipAsync(Web3 web3, string contractAddress, string newOwner)
{
IContractTransactionHandler <TransferOwnershipFunction> transferHandler = web3.Eth.GetContractTransactionHandler <TransferOwnershipFunction>();
var transfer = new TransferOwnershipFunction()
{
NewOwner = newOwner
};
TransactionReceipt transactionTransferReceipt = await transferHandler.SendRequestAndWaitForReceiptAsync(contractAddress, transfer).ConfigureAwait(false);
return(transactionTransferReceipt.TransactionHash);
}
/// <summary>
/// Normally the final mandatory confirmation will automatically call the execute.
/// This is provided in case it has to be called again due to an error condition.
/// </summary>
public static async Task <string> ExecuteTransactionAsync(Web3 web3, string contractAddress, BigInteger transactionId, BigInteger gas, BigInteger gasPrice)
{
IContractTransactionHandler <ExecuteTransactionFunction> executionHandler = web3.Eth.GetContractTransactionHandler <ExecuteTransactionFunction>();
var executeTransactionFunctionMessage = new ExecuteTransactionFunction()
{
TransactionId = transactionId,
Gas = gas,
GasPrice = Web3.Convert.ToWei(gasPrice, UnitConversion.EthUnit.Gwei)
};
TransactionReceipt executeTransactionReceipt = await executionHandler.SendRequestAndWaitForReceiptAsync(contractAddress, executeTransactionFunctionMessage).ConfigureAwait(false);
return(executeTransactionReceipt.TransactionHash);
}
public static async Task <string> TransferAsync(Web3 web3, string contractAddress, string recipient, BigInteger amount, BigInteger gas, BigInteger gasPrice)
{
IContractTransactionHandler <TransferFunction> transferHandler = web3.Eth.GetContractTransactionHandler <TransferFunction>();
var transfer = new TransferFunction()
{
To = recipient,
TokenAmount = amount,
Gas = gas,
GasPrice = Web3.Convert.ToWei(gasPrice, UnitConversion.EthUnit.Gwei)
};
TransactionReceipt transactionTransferReceipt = await transferHandler.SendRequestAndWaitForReceiptAsync(contractAddress, transfer).ConfigureAwait(false);
return(transactionTransferReceipt.TransactionHash);
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <returns></returns>
/// <exception cref="T:src.Contract.ContractException">Thrown if the transaction can not be completed</exception>
public async Task ConfirmUpdate()
{
IContractTransactionHandler <ConfirmUpdateFunction> updateTxHandler = _web3.Eth.GetContractTransactionHandler <ConfirmUpdateFunction>();
ConfirmUpdateFunction updateTx = new ConfirmUpdateFunction
{
FromAddress = _validatorAddress,
Gas = new BigInteger(500000)
};
TransactionReceipt confirmResponse = await updateTxHandler.SendRequestAndWaitForReceiptAsync(_ncContractAddress, updateTx);
bool?hasErrors = confirmResponse.HasErrors();
if (hasErrors.HasValue && hasErrors.Value)
{
throw new ContractException("Unable to confirm update");
}
}
public async Task <MintNftResponse> Handle(MintNftRequest aMintNftRequest, CancellationToken aCancellationToken)
{
IContractTransactionHandler <MintNftRequest> contractTransactionHandler =
Web3ContractManager.Web3.Eth.GetContractTransactionHandler <MintNftRequest>();
HexBigInteger gasEstimate =
await contractTransactionHandler.EstimateGasAsync(EthereumSettings.NftCreatorAddress, aMintNftRequest);
aMintNftRequest.Gas = gasEstimate;
TransactionReceipt transactionReceipt = await contractTransactionHandler
.SendRequestAndWaitForReceiptAsync(EthereumSettings.NftCreatorAddress, aMintNftRequest);
List <EventLog <MintNftEventDto> > mintNftEventDtos = transactionReceipt.DecodeAllEvents <MintNftEventDto>();
return(new MintNftResponse
{
MintNftEventDto = mintNftEventDtos.FirstOrDefault()?.Event,
TransactionReceipt = transactionReceipt
});
}
public static async Task <TransactionReceipt> asyncTransferAmount(string contractAddress, TransferFunction transfer, IContractTransactionHandler <TransferFunction> deploymentHandler)
{
return(await deploymentHandler.SendRequestAndWaitForReceiptAsync(contractAddress, transfer));
}