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
});
}
private IReadOnlyList <EventLog <T> > DecodeAllEventsAndFilter <T>(TransactionReceipt transactionReceipt)
where T : new()
{
return(transactionReceipt
.DecodeAllEvents <T>()
.Where(o => IsKnownAddress(o.Log.Address))
.ToList());
}
public async Task AddRepository(string name)
{
try {
_logger.LogInformation("Attempting to add repository {0}", name);
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Please provide a valid name for the repository");
}
if (!_contractService.ContractDeployed("RepositoryService"))
{
throw new Exception("The contract is not deployed");
}
string path = _ipfsService.SelectPath();
if (path == null)
{
throw new Exception("Please select a valid folder");
}
string cid = await _ipfsService.AddDirectoryOnIPFS(path);
string contractAd = _contractService.GetAddressDeployedContract("RepositoryService");
Web3 client = _userService.GetUser();
CreateRepositoryFunction crf = new CreateRepositoryFunction()
{
Name = name,
Cid = cid
};
var handler = client.Eth.GetContractTransactionHandler <CreateRepositoryFunction>();
TransactionReceipt tr = await handler.SendRequestAndWaitForReceiptAsync(contractAd, crf);
List <EventLog <RepositoryAddedEvent> > events = tr.DecodeAllEvents <RepositoryAddedEvent>();
if (events.Count > 0)
{
Console.WriteLine(string.Format("Repository {0} added", name));
}
RepositorySerialized repos = new RepositorySerialized()
{
CID = cid,
Name = name,
Path = path
};
WriteToRepositoryFile(repos);
} catch (Exception e) {
_logger.LogError("Something went wrong with the AddRepositoryFunction {0}", e.Message);
Console.WriteLine("Something went wrong with the execution of this function");
Console.Beep();
}
}
public TransactionResult ThenExpectAnEvent <TEventDTO>(TEventDTO expectedEvent) where TEventDTO : IEventDTO, new()
{
TestLogger.LogExpectedEvent(expectedEvent);
var events = TransactionReceipt.DecodeAllEvents <TEventDTO>();
var eventFirst = events.FirstOrDefault();
Assert.NotNull(eventFirst);
Stateprinter.Assert.AreEqual(
Stateprinter.PrintObject(expectedEvent),
Stateprinter.PrintObject(eventFirst.Event));
return(this);
}
public List <byte[]> GetMessageHashes(TransactionReceipt receipt)
{
var sentMessagesEvents = receipt.DecodeAllEvents <SentMessageEventDTO>();
Debug.WriteLine(Event <SentMessageEventDTO> .GetEventABI().Sha3Signature);
var sentMessages = new List <byte[]>();
foreach (var sentMessageEvent in sentMessagesEvents)
{
var relayMessage = new RelayMessageXDomainFunction();
relayMessage.Message = sentMessageEvent.Event.Message;
relayMessage.MessageNonce = sentMessageEvent.Event.MessageNonce;
relayMessage.Target = sentMessageEvent.Event.Target;
relayMessage.Sender = sentMessageEvent.Event.Sender;
sentMessages.Add(Sha3Keccack.Current.CalculateHash(relayMessage.GetCallData()));
}
return(sentMessages);
}
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
});
}
private static Dictionary <string, List <InteropTransfer> > GetInteropTransfers(Nexus nexus, Logger logger,
TransactionReceipt txr, EthAPI api, string[] swapAddresses)
{
logger.Debug($"get interop transfers for tx {txr.TransactionHash}");
var interopTransfers = new Dictionary <string, List <InteropTransfer> >();
Nethereum.RPC.Eth.DTOs.Transaction tx = null;
try
{
// tx to get the eth transfer if any
tx = api.GetTransaction(txr.TransactionHash);
}
catch (Exception e)
{
logger.Error("Getting eth tx failed: " + e.Message);
}
Console.WriteLine("txr: " + txr.Status);
logger.Debug("Transaction status: " + txr.Status.Value);
// check if tx has failed
if (txr.Status.Value == 0)
{
logger.Error($"tx {txr.TransactionHash} failed");
return(interopTransfers);
}
foreach (var a in swapAddresses)
{
Console.WriteLine("swap address: " + a);
}
var nodeSwapAddresses = swapAddresses.Select(x => BSCWallet.EncodeAddress(x));
var interopAddress = ExtractInteropAddress(tx);
Console.WriteLine("interop address: " + interopAddress);
// ERC721 (NFT)
// TODO currently this code block is mostly copypaste from BEP20 block, later make a single method for both...
//var erc721_events = txr.DecodeAllEvents<Nethereum.StandardNonFungibleTokenERC721.ContractDefinition.TransferEventDTOBase>();
//foreach (var evt in erc721_events)
//{
// var asset = EthUtils.FindSymbolFromAsset(nexus, evt.Log.Address);
// if (asset == null)
// {
// logger.Warning($"Asset [{evt.Log.Address}] not supported");
// continue;
// }
// var targetAddress = BSCWallet.EncodeAddress(evt.Event.To);
// var sourceAddress = BSCWallet.EncodeAddress(evt.Event.From);
// var tokenID = PBigInteger.Parse(evt.Event.TokenId.ToString());
// if (nodeSwapAddresses.Contains(targetAddress))
// {
// if (!interopTransfers.ContainsKey(evt.Log.TransactionHash))
// {
// interopTransfers.Add(evt.Log.TransactionHash, new List<InteropTransfer>());
// }
// string tokenURI = FetchTokenURI(evt.Log.Address, evt.Event.TokenId);
// interopTransfers[evt.Log.TransactionHash].Add
// (
// new InteropTransfer
// (
// BSCWallet.BSCPlatform,
// sourceAddress,
// DomainSettings.PlatformName,
// targetAddress,
// interopAddress,
// asset,
// tokenID,
// System.Text.Encoding.UTF8.GetBytes(tokenURI)
// )
// );
// }
//}
// BEP20
var bep20_events = txr.DecodeAllEvents <TransferEventDTO>();
foreach (var evt in bep20_events)
{
var asset = EthUtils.FindSymbolFromAsset(BSCWallet.BSCPlatform, nexus, evt.Log.Address);
if (asset == null)
{
logger.Warning($"Asset [{evt.Log.Address}] not supported");
continue;
}
var targetAddress = BSCWallet.EncodeAddress(evt.Event.To);
var sourceAddress = BSCWallet.EncodeAddress(evt.Event.From);
var amount = PBigInteger.Parse(evt.Event.Value.ToString());
if (nodeSwapAddresses.Contains(targetAddress))
{
if (!interopTransfers.ContainsKey(evt.Log.TransactionHash))
{
interopTransfers.Add(evt.Log.TransactionHash, new List <InteropTransfer>());
}
interopTransfers[evt.Log.TransactionHash].Add
(
new InteropTransfer
(
BSCWallet.BSCPlatform,
sourceAddress,
DomainSettings.PlatformName,
targetAddress,
interopAddress,
asset,
amount
)
);
}
}
Console.WriteLine("value: " + tx.Value);
Console.WriteLine("value: " + tx.Value.Value);
if (tx.Value != null && tx.Value.Value > 0)
{
var targetAddress = BSCWallet.EncodeAddress(tx.To);
var sourceAddress = BSCWallet.EncodeAddress(tx.From);
foreach (var a in nodeSwapAddresses)
{
Console.WriteLine("node swap address: " + a);
}
Console.WriteLine("target address: " + targetAddress);
if (nodeSwapAddresses.Contains(targetAddress))
{
var amount = PBigInteger.Parse(tx.Value.ToString());
if (!interopTransfers.ContainsKey(tx.TransactionHash))
{
interopTransfers.Add(tx.TransactionHash, new List <InteropTransfer>());
}
interopTransfers[tx.TransactionHash].Add
(
new InteropTransfer
(
BSCWallet.BSCPlatform,
sourceAddress,
DomainSettings.PlatformName,
targetAddress,
interopAddress,
"BSC", // TODO use const
amount
)
);
}
}
return(interopTransfers);
}
private static Dictionary <string, List <InteropTransfer> > GetInteropTransfers(Nexus nexus, Logger logger,
TransactionReceipt txr, EthAPI api, string swapAddress)
{
logger.Debug($"get interop transfers for tx {txr.TransactionHash}");
var interopTransfers = new Dictionary <string, List <InteropTransfer> >();
Nethereum.RPC.Eth.DTOs.Transaction tx = null;
try
{
// tx to get the eth transfer if any
tx = api.GetTransaction(txr.TransactionHash);
}
catch (Exception e)
{
logger.Error("Getting eth tx failed: " + e.Message);
}
logger.Debug("Transaction status: " + txr.Status.Value);
// check if tx has failed
if (txr.Status.Value == 0)
{
logger.Error($"tx {txr.TransactionHash} failed");
return(interopTransfers);
}
var nodeSwapAddress = EthereumWallet.EncodeAddress(swapAddress);
var events = txr.DecodeAllEvents <TransferEventDTO>();
var interopAddress = ExtractInteropAddress(tx);
// ERC20
foreach (var evt in events)
{
var asset = EthUtils.FindSymbolFromAsset(nexus, evt.Log.Address);
if (asset == null)
{
logger.Warning($"Asset [{evt.Log.Address}] not supported");
continue;
}
var targetAddress = EthereumWallet.EncodeAddress(evt.Event.To);
var sourceAddress = EthereumWallet.EncodeAddress(evt.Event.From);
var amount = PBigInteger.Parse(evt.Event.Value.ToString());
if (targetAddress.Equals(nodeSwapAddress))
{
if (!interopTransfers.ContainsKey(evt.Log.TransactionHash))
{
interopTransfers.Add(evt.Log.TransactionHash, new List <InteropTransfer>());
}
interopTransfers[evt.Log.TransactionHash].Add
(
new InteropTransfer
(
EthereumWallet.EthereumPlatform,
sourceAddress,
DomainSettings.PlatformName,
targetAddress,
interopAddress,
asset,
amount
)
);
}
}
if (tx.Value != null && tx.Value.Value > 0)
{
var targetAddress = EthereumWallet.EncodeAddress(tx.To);
var sourceAddress = EthereumWallet.EncodeAddress(tx.From);
if (targetAddress.Equals(nodeSwapAddress))
{
var amount = PBigInteger.Parse(tx.Value.ToString());
if (!interopTransfers.ContainsKey(tx.TransactionHash))
{
interopTransfers.Add(tx.TransactionHash, new List <InteropTransfer>());
}
interopTransfers[tx.TransactionHash].Add
(
new InteropTransfer
(
EthereumWallet.EthereumPlatform,
sourceAddress,
DomainSettings.PlatformName,
targetAddress,
interopAddress,
"ETH", // TODO use const
amount
)
);
}
}
return(interopTransfers);
}
private static Dictionary <string, List <InteropTransfer> > GetInteropTransfers(Nexus nexus, Logger logger,
TransactionReceipt txr, EthAPI api, string[] swapAddresses)
{
logger.Debug($"get interop transfers for tx {txr.TransactionHash}");
var interopTransfers = new Dictionary <string, List <InteropTransfer> >();
Nethereum.RPC.Eth.DTOs.Transaction tx = null;
try
{
// tx to get the eth transfer if any
tx = api.GetTransaction(txr.TransactionHash);
}
catch (Exception e)
{
logger.Error("Getting eth tx failed: " + e.Message);
}
logger.Debug("Transaction status: " + txr.Status.Value);
// check if tx has failed
if (txr.Status.Value == 0)
{
logger.Error($"tx {txr.TransactionHash} failed");
return(interopTransfers);
}
var nodeSwapAddresses = swapAddresses.Select(x => EthereumWallet.EncodeAddress(x));
Address interopAddress;
try
{
interopAddress = ExtractInteropAddress(tx, logger);
}
catch (Exception e)
{
if (e.ToString().Contains("Header byte out of range"))
{
// Ignoring this exception and skipping this tx.
// RecoverFromSignature() crashed and we cannot avoid it atm.
// Related to EIP-1559, example of probematic tx: https://etherscan.io/tx/0xb022c146d8d1e684de0c1faae43e7ce36afb6969719adfdcafcc5bb7d5913185
// TODO Fix by updating to new Nethereum and dealing with EIP-1559 better.
logger.Debug("Warning: Skipping 'Header byte out of range' tx: " + tx.TransactionHash);
return(interopTransfers);
}
else
{
throw;
}
}
// ERC721 (NFT)
// TODO currently this code block is mostly copypaste from ERC20 block, later make a single method for both...
//var erc721_events = txr.DecodeAllEvents<Nethereum.StandardNonFungibleTokenERC721.ContractDefinition.TransferEventDTOBase>();
//foreach (var evt in erc721_events)
//{
// var asset = EthUtils.FindSymbolFromAsset(nexus, evt.Log.Address);
// if (asset == null)
// {
// logger.Warning($"Asset [{evt.Log.Address}] not supported");
// continue;
// }
// var targetAddress = EthereumWallet.EncodeAddress(evt.Event.To);
// var sourceAddress = EthereumWallet.EncodeAddress(evt.Event.From);
// var tokenID = PBigInteger.Parse(evt.Event.TokenId.ToString());
// if (nodeSwapAddresses.Contains(targetAddress))
// {
// if (!interopTransfers.ContainsKey(evt.Log.TransactionHash))
// {
// interopTransfers.Add(evt.Log.TransactionHash, new List<InteropTransfer>());
// }
// string tokenURI = FetchTokenURI(evt.Log.Address, evt.Event.TokenId);
// interopTransfers[evt.Log.TransactionHash].Add
// (
// new InteropTransfer
// (
// EthereumWallet.EthereumPlatform,
// sourceAddress,
// DomainSettings.PlatformName,
// targetAddress,
// interopAddress,
// asset,
// tokenID,
// System.Text.Encoding.UTF8.GetBytes(tokenURI)
// )
// );
// }
//}
// ERC20
var erc20_events = txr.DecodeAllEvents <TransferEventDTO>();
foreach (var evt in erc20_events)
{
var asset = EthUtils.FindSymbolFromAsset(EthereumWallet.EthereumPlatform, nexus, evt.Log.Address);
if (asset == null)
{
logger.Warning($"Asset [{evt.Log.Address}] not supported");
continue;
}
var targetAddress = EthereumWallet.EncodeAddress(evt.Event.To);
var sourceAddress = EthereumWallet.EncodeAddress(evt.Event.From);
var amount = PBigInteger.Parse(evt.Event.Value.ToString());
if (nodeSwapAddresses.Contains(targetAddress))
{
if (!interopTransfers.ContainsKey(evt.Log.TransactionHash))
{
interopTransfers.Add(evt.Log.TransactionHash, new List <InteropTransfer>());
}
interopTransfers[evt.Log.TransactionHash].Add
(
new InteropTransfer
(
EthereumWallet.EthereumPlatform,
sourceAddress,
DomainSettings.PlatformName,
targetAddress,
interopAddress,
asset,
amount
)
);
}
}
if (tx.Value != null && tx.Value.Value > 0)
{
var targetAddress = EthereumWallet.EncodeAddress(tx.To);
var sourceAddress = EthereumWallet.EncodeAddress(tx.From);
if (nodeSwapAddresses.Contains(targetAddress))
{
var amount = PBigInteger.Parse(tx.Value.ToString());
if (!interopTransfers.ContainsKey(tx.TransactionHash))
{
interopTransfers.Add(tx.TransactionHash, new List <InteropTransfer>());
}
interopTransfers[tx.TransactionHash].Add
(
new InteropTransfer
(
EthereumWallet.EthereumPlatform,
sourceAddress,
DomainSettings.PlatformName,
targetAddress,
interopAddress,
"ETH", // TODO use const
amount
)
);
}
}
return(interopTransfers);
}
