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); }
public async Task UpsertAsync(RPC.Eth.DTOs.Transaction transaction, TransactionReceipt receipt, bool failed, HexBigInteger timeStamp, bool hasVmStack = false, string error = null) { var tx = new CosmosTransaction(); tx.Map(transaction); tx.Map(receipt); tx.Failed = failed; tx.TimeStamp = (long)timeStamp.Value; tx.Error = error ?? string.Empty; tx.HasVmStack = hasVmStack; tx.UpdateRowDates(); await UpsertDocumentAsync(tx); }
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 async Task <IEnumerable <Rental> > GetAllContractsFromTenant(string tenant, string password) { var abi = @"[ { 'constant': true, 'inputs': [ { 'name': '', 'type': 'bytes32' }, { 'name': '', 'type': 'uint256' } ], 'name': 'rentals', 'outputs': [ { 'name': 'tenant', 'type': 'address' }, { 'name': 'tenant', 'type': 'address' }, { 'name': 'depositeAmount', 'type': 'uint256' }, { 'name': 'rentalPrice', 'type': 'uint256' }, { 'name': 'endtime', 'type': 'uint256' }, { 'name': 'itemId', 'type': 'uint256' } ], 'payable': false, 'stateMutability': 'view', 'type': 'function' }, { 'constant': false, 'inputs': [ { 'name': 'key', 'type': 'bytes32' }, { 'name': 'tenant', 'type': 'address' }, { 'name': 'depositeAmount', 'type': 'uint256' }, { 'name': 'rentalPrice', 'type': 'uint256' }, { 'name': 'endtime', 'type': 'uint256' }, { 'name': 'itemId', 'type': 'uint256' } ], 'name': 'StoreRental', 'outputs': [ { 'name': 'success', 'type': 'bool' } ], 'payable': false, 'stateMutability': 'nonpayable', 'type': 'function' } ]"; var byteCode = "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"; //a managed account uses personal_sendTransanction with the given password, this way we don't need to unlock the account for a certain period of time var account = new ManagedAccount(tenant, password); //using the specific geth web3 library to allow us manage the mining. var web3 = new Nethereum.Web3.Web3("http://127.0.0.1:7545"); var receipt = new TransactionReceipt(); try { receipt = await web3.Eth.DeployContract.SendRequestAndWaitForReceiptAsync(byteCode, tenant, new HexBigInteger(900000)); } catch (Exception e) { Console.WriteLine(e); throw; } var contractAddress = receipt.ContractAddress; var contract = web3.Eth.GetContract(abi, contractAddress); var documentsFunction = contract.GetFunction("rentals"); var result = new Rental(); try { result = await documentsFunction.CallDeserializingToObjectAsync <Rental>("key1", 0); } catch (Exception e) { Console.WriteLine(e); throw; } return(null); }
public ReceiptForRpc(Keccak txHash, TransactionReceipt receipt) { TransactionHash = txHash; TransactionIndex = receipt.Index; BlockHash = receipt.BlockHash; BlockNumber = receipt.BlockNumber; CumulativeGasUsed = receipt.GasUsedTotal; GasUsed = receipt.GasUsed; From = receipt.Sender; To = receipt.Recipient; ContractAddress = receipt.ContractAddress; Logs = receipt.Logs.Select((l, idx) => new LogEntryForRpc(receipt, l, idx)).ToArray(); LogsBloom = receipt.Bloom; Root = receipt.PostTransactionState; Status = receipt.StatusCode; Error = receipt.Error; }
public dynamic SendEtherToExchange(dynamic transactionDto, dynamic walletDto, string toAddress) { try { dynamic obj = null; string url = GetRPCUrl(walletDto.Network); string mKey = CryptoLib.Decrypt(walletDto.MasterKey); string mneumonicWords = CryptoLib.Decrypt(walletDto.Mnemonic); string passphrase = CryptoLib.Decrypt(walletDto.PassPhrase); var account = GetAccount(mneumonicWords, passphrase, transactionDto.AddressIndex); Web3 web3 = new Web3(account, url); var gasPrice = Nethereum.Signer.Transaction.DEFAULT_GAS_PRICE; // var gasPrice = Web3.Convert.ToWei(1.5, UnitConversion.EthUnit.Gwei); var gasLimit = Nethereum.Signer.Transaction.DEFAULT_GAS_LIMIT; var balance = web3.Eth.GetBalance.SendRequestAsync(account.Address).Result; //TODO: Check fee and use default fee var fee = gasPrice * gasLimit; var maxfee = Web3.Convert.ToWei(transactionDto.MaxFee.GetValueOrDefault(), UnitConversion.EthUnit.Ether); if (fee >= maxfee) { fee = Web3.Convert.ToWei(transactionDto.DefaultFees.GetValueOrDefault(), UnitConversion.EthUnit.Ether); } var amountToSend = balance - fee; var amountToSendInEther = UnitConversion.Convert.FromWei(amountToSend, 18); TransactionReceipt receipt = web3.Eth.GetEtherTransferService().TransferEtherAndWaitForReceiptAsync(toAddress, amountToSendInEther, UnitConversion.Convert.FromWei(gasPrice, 9), gasLimit).Result; if (receipt != null) { if (receipt.Status.Value == 1) { obj = new ExpandoObject(); obj.TransactionHash = receipt.TransactionHash; obj.Fees = UnitConversion.Convert.FromWei(fee, 18); obj.Amount = amountToSendInEther; obj.TotalAmount = UnitConversion.Convert.FromWei(balance, 18); } } return(obj); } catch (Exception ex) { throw new Exception(); } }
public static ContractHandler DeployRSKKeyManagmentContract(Web3 web3, TransactionReceipt transactionReceiptDeployment, out string contractAddress) { var rSKKeyManagementDeployment = new RSKKeyManagementDeployment(); transactionReceiptDeployment = web3.Eth.GetContractDeploymentHandler <RSKKeyManagementDeployment>() .SendRequestAndWaitForReceiptAsync(rSKKeyManagementDeployment) .ConfigureAwait(false) .GetAwaiter() .GetResult(); contractAddress = transactionReceiptDeployment.ContractAddress; var contractHandler = web3.Eth.GetContractHandler(contractAddress); return(contractHandler); }
public async Task Excludes_Contract_Creation_Calls_For_Other_Contracts() { var builder = new ContractSpecificFilterBuilder(ContractAddress1); var tx = new Transaction { To = null }; var receipt = new TransactionReceipt { ContractAddress = AnotherAddress }; Assert.True(await builder.FilterContainer.TransactionFilters.IsMatchAsync((tx))); Assert.False(await builder.FilterContainer.TransactionReceiptFilters.IsMatchAsync((receipt))); }
/// <summary> /// Get Receipt Proof /// </summary> /// <param name="transactionId"></param> /// <returns></returns> public async Task <TransactionReceiptResponse> GetReceiptProof(string transactionId) { if (!String.IsNullOrEmpty(SyncerUrl)) { try { HttpClient client = new HttpClient(); client.BaseAddress = new Uri(SyncerUrl); HttpResponseMessage response = await client.GetAsync($"tx/{transactionId}/receipt/proof"); if (response.StatusCode == HttpStatusCode.OK) { string contentString = await response.Content.ReadAsStringAsync(); TransactionReceiptResponse receiptProofResponse = JsonConvert.DeserializeObject <TransactionReceiptResponse>(contentString); return(receiptProofResponse); } } catch (Exception ex) { throw new Exception($"Could not fetch the Receipt Proof from the syncer URL because {ex.Message}"); } } else { try { EthGetTransactionReceipt transactionByHash = ParentWeb3.Eth.Transactions.GetTransactionReceipt; TransactionReceipt tx = await transactionByHash.SendRequestAsync(transactionId); TransactionReceiptResponse transactionReceiptResponse = new TransactionReceiptResponse() { Value = tx }; return(transactionReceiptResponse); } catch (Exception ex) { throw new Exception($"Could not fetch te receipt proof because {ex.Message}"); } } return(null); }
public static TransactionReceiptVO CreateSampleTransaction() { Block block = new Block { Number = new HexBigInteger(new BigInteger(10)) }; var tx = new Transaction { BlockNumber = block.Number, TransactionHash = "0x19ce02e0b4fdf5cfee0ed21141b38c2d88113c58828c771e813ce2624af127cd", TransactionIndex = new HexBigInteger(new BigInteger(0)) }; var receipt = new TransactionReceipt { }; return(new TransactionReceiptVO(block, tx, receipt, false)); }
public void AddTransaction(TransactionReceipt transaction) { /* write transaction to storage */ var prefixTx = EntryPrefix.TransactionByHash.BuildPrefix(transaction.Hash); _rocksDbContext.Save(prefixTx, transaction.ToByteArray()); /* add transaction to pool */ var raw = _rocksDbContext.Get(EntryPrefix.TransactionPool.BuildPrefix()); var pool = raw != null?raw.ByteArrayToTransactionHashList() : new List <UInt256>(); if (pool.Contains(transaction.Hash)) { return; } pool.Add(transaction.Hash); _rocksDbContext.Save(EntryPrefix.TransactionPool.BuildPrefix(), pool.TransactionHashListToByteArray()); }
/// <summary> /// Check transaction confirmations /// </summary> /// <param name="txId">The transaction hash</param> /// <returns>Tuple<Null => Unconfirmed else the number of confirmations, Succeeded or Failed></returns> public async Task <Tuple <ulong?, bool> > getTransactionConfirmations(string txId) { TransactionReceipt transactionReceipt = await _web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(txId); if (transactionReceipt != null) { return(new Tuple <ulong?, bool>( !transactionReceipt.BlockNumber.Value.IsZero ? (ulong)transactionReceipt.BlockNumber.Value - await getLastBlock() : (ulong?)null, transactionReceipt.Status.Value == 1)); } else { return(new Tuple <ulong?, bool>(null, false)); } }
private async Task ProcessUndecodedEvents(TransactionReceipt transactionReceipt) { try { foreach (var log in transactionReceipt.Logs) { var contractAddress = log["address"].ToObject <string>(); if (!IsKnownAddress(contractAddress)) { continue; } var evt = new UndecodedEvent { TransactionHash = transactionReceipt.TransactionHash, Index = log["logIndex"].ToObject <string>(), OriginAddress = contractAddress, Data = log["data"].ToObject <string>(), Topics = log["topics"].ToObject <string[]>(), ObservedAt = DateTime.UtcNow, Id = Guid.NewGuid().ToString(), }; await _undecodedEventPublishingService.PublishAsync(evt); _log.Info($"{nameof(UndecodedEvent)} has been published", evt); } } catch (Exception e) { #region Logging _log.Error ( e, $"Failed to process undecoded transaction [{transactionReceipt.TransactionHash}].", new { transactionHash = transactionReceipt.TransactionHash } ); #endregion throw; } }
public bool VerifyTransactionImmediately(TransactionReceipt receipt, bool useNewChainId, bool cacheEnabled) { if (receipt is null) { throw new ArgumentNullException(nameof(receipt)); } /* validate transaction hash */ if (!receipt.Hash.Equals(receipt.FullHash(useNewChainId))) { return(false); } try { /* try to verify signature using public key cache to avoid EC recover */ if (cacheEnabled && _publicKeyCache.TryGetValue(receipt.Transaction.From, out var publicKey)) { return(VerifyTransactionImmediately(receipt, publicKey, useNewChainId)); } /* recover EC to get public key from signature to compute address */ publicKey = receipt.RecoverPublicKey(useNewChainId); var address = publicKey.GetAddress(); /* check if recovered address from public key is valid */ if (!address.Equals(receipt.Transaction.From)) { return(false); } /* try to remember public key for this address */ if (cacheEnabled) { _publicKeyCache.Add(receipt.Transaction.From, publicKey); } } catch (Exception ex) { Logger.LogWarning($"Failed to verify transaction: {ex}"); return(false); } return(true); }
private async Task DeployWatchdogsAsync() { string transactionHash = await WatchdogService.DeployContractAsync( Web3, AddressFrom, new string[] { AddressFrom, AddressFrom2 }, new BigInteger(2), new HexBigInteger(3905820)); Assert.NotNull(transactionHash); TransactionReceipt receipt = await Web3.Eth.Transactions.GetTransactionReceipt. SendRequestAsync(transactionHash); Watchdogs = new WatchdogService(Web3, receipt.ContractAddress); transactionHash = await IDController.SetWatchDogsAsync(AddressFrom, Watchdogs.GetAddress(), new HexBigInteger(3905820)); Assert.NotNull(transactionHash); }
/// <summary> /// Waits for this transactin to be processed. /// WARNING: not supported in webgl builds! /// </summary> /// <param name="tokenSource">Cancellation source</param> /// <returns>Receipt of the transaction</returns> public async Task <TransactionReceipt> Wait(CancellationTokenSource tokenSource = null) { TransactionReceipt receipt = await web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(TxId); while (receipt == null) { if (tokenSource != null && tokenSource.IsCancellationRequested) { break; } await Task.Delay(1000); //TODO: in webgl build this must be swapped for sth else!! //This could be rewritten if we support websocket connections, or we could also create some external mechanism for waiting //so this could be overwriten by custom implementations receipt = await web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(TxId); } return(receipt); }
public TransactionResult(TransactionReceipt receipt) { TransactionHash = receipt.TransactionHash; TransactionIndex = receipt.TransactionIndex.Value; BlockHash = receipt.BlockHash; BlockNumber = receipt.BlockNumber.Value; CumulativeGasUsed = receipt.CumulativeGasUsed.Value; GasUsed = receipt.GasUsed.Value; ContractAddress = receipt.ContractAddress; if (receipt.Status.Value == 1) { Status = "Transaction succeeded."; } else { Status = "Transaction failed!"; } }
public ParityLikeTxTrace ParityTrace(Keccak txHash, ParityTraceTypes parityTraceTypes) { byte[] traceBytes = _traceDb.Get(txHash); if (traceBytes != null) { return(Rlp.Decode <ParityLikeTxTrace>(traceBytes)); } TransactionReceipt transactionReceipt = _receiptStorage.Get(txHash); Block block = _blockTree.FindBlock(transactionReceipt.BlockNumber); if (block == null) { throw new InvalidOperationException("Only historical blocks"); } return(ParityTrace(block, txHash, parityTraceTypes)); }
protected async Task DeployIDControllerAsync() { string transactionHash = await IDControllerService.DeployContractAsync( Web3, AddressFrom, ID.GetAddress(), new HexBigInteger(3905820)); Assert.NotNull(transactionHash); TransactionReceipt receipt = await Web3.Eth.Transactions.GetTransactionReceipt. SendRequestAsync(transactionHash); IDController = new IDControllerService(Web3, receipt.ContractAddress); //Change the owner of the ID to make the ID controller the owner transactionHash = await ID.ChangeOwnerAsync(AddressFrom, IDController.GetAddress(), new HexBigInteger(3905820)); Assert.NotNull(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"); } }
private OperatingError _InvokeContract( UInt160 addressTo, byte[] input, TransactionReceipt receipt, IBlockchainSnapshot snapshot, bool isSystemContract ) { var transaction = receipt.Transaction; var context = new InvocationContext(receipt.Transaction.From, snapshot, receipt); try { if (receipt.GasUsed > transaction.GasLimit) { return(OperatingError.OutOfGas); } var result = ContractInvoker.Invoke(addressTo, context, input, transaction.GasLimit - receipt.GasUsed); receipt.GasUsed += result.GasUsed; if (result.Status != ExecutionStatus.Ok) { return(OperatingError.ContractFailed); } if (receipt.GasUsed > transaction.GasLimit) { return(OperatingError.OutOfGas); } /* this OnSystemContractInvoked is useful for internal communication (for example - during keyGeneration) */ if (isSystemContract) { OnSystemContractInvoked?.Invoke(this, context); } return(OperatingError.Ok); } catch (OutOfGasException e) { receipt.GasUsed += e.GasUsed; } catch (Exception e) { Logger.LogWarning($"Failed contract execution: {e}"); return(OperatingError.InvalidContract); } return(OperatingError.OutOfGas); }
private async Task ProcessTransferEvents(TransactionReceipt transactionReceipt) { try { var events = DecodeAllEventsAndFilter <SentEventDTO>(transactionReceipt); foreach (var @event in events) { if (string.IsNullOrEmpty(@event.Event.From) || string.IsNullOrEmpty(@event.Event.To)) { continue; } var evt = new TransferEvent { SourceAddress = @event.Event.From, TargetAddress = @event.Event.To, Amount = Money18.CreateFromAtto(@event.Event.Amount), EventIndex = (int)@event.Log.LogIndex.Value, TransactionHash = @event.Log.TransactionHash, ObservedAt = DateTime.UtcNow, }; await _transferEventPublishingService.PublishAsync(evt); _log.Info($"{nameof(TransferEvent)} has been published", evt); } } catch (Exception e) { #region Logging _log.Error ( e, $"Failed to process transfer events from transaction [{transactionReceipt.TransactionHash}].", new { transactionHash = transactionReceipt.TransactionHash } ); #endregion throw; } }
public async Task UpsertAsync(Nethereum.RPC.Eth.DTOs.Transaction transaction, TransactionReceipt transactionReceipt, bool failed, HexBigInteger timeStamp, bool hasVmStack = false, string error = null) { var transactionEntity = Nethereum.BlockchainStore.SQL.Transaction.CreateTransaction(transaction, transactionReceipt, failed, timeStamp, hasVmStack, error); try { TransactionList.Add(transactionEntity); } catch (System.Exception e) { throw e; } //await InsertOrUpdate(transactionEntity); }
/// <summary> /// Verify Transaction: /// 1. raw transaction in hex /// 2. raw signature in hex /// </summary> /// <param name="arguments"></param> /// <returns></returns> public string VerifyTransaction(string[] arguments) { var tx = Transaction.Parser.ParseFrom(arguments[1].HexToBytes()); bool useNewChainId = HardforkHeights.IsHardfork_9Active(_blockManager.GetHeight() + 1); var sig = arguments[2].HexToBytes().ToSignature(useNewChainId); var accepted = new TransactionReceipt { Transaction = tx, Hash = tx.FullHash(sig, useNewChainId), Signature = sig }; var txValid = _transactionManager.Verify(accepted, useNewChainId) == OperatingError.Ok; var sigValid = _transactionManager.VerifySignature(accepted, useNewChainId, true) == OperatingError.Ok; Console.WriteLine($"Tx Hash: {accepted.Hash}"); Console.WriteLine("Transaction validity: " + txValid); Console.WriteLine(sigValid ? "Signature validity: OK" : "Signature validity: INVALID"); return($"{txValid && sigValid}"); }
public async Task RegisterUsername() { try { string username; if (!_contractService.ContractDeployed("UserService")) { throw new Exception("The contract is not deployed"); } string contract_ad = _contractService.GetAddressDeployedContract("UserService"); do { Console.Write("No username registered, Please provide a username: "******"Registering username for {0} gas", gasprice.Value.ToString()); TransactionReceipt receipt = await _functionHandler.SendRequestAndWaitForReceiptAsync(contract_ad, addFunction); if (receipt.Failed()) { throw new Exception("Something went wrong"); } //Decode event //List<EventLog<>> events = receipt.DecodeAllEvents<> } catch (Exception e) { _logger.LogError("Something went wrong with the RegisterUsername function: {0}", e.Message); Console.WriteLine("Something went wrong with Registering a username"); Console.Beep(); System.Environment.Exit(1); } }
public async Task ProcessTransactionAsync( Transaction transaction, TransactionReceipt transactionReceipt, HexBigInteger blockTimestamp) { var transactionHash = transaction.TransactionHash; var hasStackTrace = false; JObject stackTrace = null; var error = string.Empty; var hasError = transactionReceipt.Failed(); if (EnabledVmProcessing) { try { stackTrace = await _vmStackProxy .GetTransactionVmStack(transactionHash) .ConfigureAwait(false); } catch { } if (stackTrace != null) { error = _vmStackErrorChecker.GetError(stackTrace); hasError = !string.IsNullOrEmpty(error); hasStackTrace = true; await _transactionVmStackHandler.HandleAsync (new TransactionVmStack(transactionHash, transaction.To, stackTrace)); } } await _transactionHandler.HandleTransactionAsync( new TransactionWithReceipt( transaction, transactionReceipt, hasError, blockTimestamp, error, hasStackTrace)); }
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 void Test_InvalidMintController() { var tx = new TransactionReceipt(); var context = new InvocationContext(_mintCntrlAdd, _stateManager.LastApprovedSnapshot, tx); var contract = new NativeTokenContract(context); // set minter { var input = ContractEncoder.Encode(Lrc20Interface.MethodSetMinter, _minterAdd); var call = _contractRegisterer.DecodeContract(context, ContractRegisterer.NativeTokenContract, input); Assert.IsNotNull(call); var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000); Assert.AreEqual(ExecutionStatus.Ok, contract.SetMinter(_minterAdd, frame)); var decoder = new ContractDecoder(frame.ReturnValue); var res = decoder.Decode("uint160")[0] as UInt160 ?? throw new Exception("Invalid return value format"); Assert.AreEqual(_minterAdd, res); } // set the allowedSupply { context = new InvocationContext(_stateManager.LastApprovedSnapshot.Balances.GetMinter(), _stateManager.LastApprovedSnapshot, tx); contract = new NativeTokenContract(context); var input = ContractEncoder.Encode(Lrc20Interface.MethodSetAllowedSupply, Money.Parse("10000")); var call = _contractRegisterer.DecodeContract(context, ContractRegisterer.NativeTokenContract, input); Assert.IsNotNull(call); var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000); Assert.AreEqual(ExecutionStatus.ExecutionHalted, contract.SetAllowedSupply(Money.Parse("10000").ToUInt256(), frame)); } // verify allowedSupply { var input = ContractEncoder.Encode(Lrc20Interface.MethodGetAllowedSupply); var call = _contractRegisterer.DecodeContract(context, ContractRegisterer.NativeTokenContract, input); Assert.IsNotNull(call); var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000); Assert.AreEqual(ExecutionStatus.Ok, contract.GetAllowedSupply(frame)); var decoder = new ContractDecoder(frame.ReturnValue); var res = decoder.Decode("uint256")[0] as UInt256 ?? throw new Exception("Invalid return value format"); Assert.AreEqual(Money.Parse("0"), res.ToMoney()); } }
private ContractDeployment GetContractDeployment <T>() where T : ContractDeploymentMessage, new() { T contract = new T(); ContractDeployment deployment = null; WatchContractDeployment watchContractDeployment = null; SimpleStorageDeployment simpleStorageDeployment = null; if (contract is WatchContractDeployment) { watchContractDeployment = contract as WatchContractDeployment; } else if (contract is SimpleStorageDeployment) { simpleStorageDeployment = contract as SimpleStorageDeployment; } try { deployment = this.context.ContractDeployments.Where(s => s.ByteCode == contract.ByteCode && s.ServerUrl == this.url).First(); } catch (InvalidOperationException ex) { logger.LogError($"contract does not currently exist: {ex}"); } if (deployment == null) { deployment = new ContractDeployment(); if (watchContractDeployment != null) { watchContractDeployment.GasPrice = 0; TransactionReceipt receipt = WatchContractService.DeployContractAndWaitForReceiptAsync(web3, watchContractDeployment).GetAwaiter().GetResult(); deployment.DeploymentAddress = receipt.ContractAddress; deployment.ByteCode = watchContractDeployment.ByteCode; } else if (simpleStorageDeployment != null) { simpleStorageDeployment.GasPrice = 0; TransactionReceipt receipt = SimpleStorageService.DeployContractAndWaitForReceiptAsync(web3, simpleStorageDeployment).GetAwaiter().GetResult(); deployment.DeploymentAddress = receipt.ContractAddress; deployment.ByteCode = simpleStorageDeployment.ByteCode; } deployment.ServerUrl = this.url; this.context.Add(deployment); this.context.SaveChanges(); } return(deployment); }
public async Task <string> Test() { //The compiled solidity contract to be deployed //contract test { function multiply(uint a) returns(uint d) { return a * 7; } } var contractByteCode = "0x606060405260728060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa1146037576035565b005b604b60048080359060200190919050506061565b6040518082815260200191505060405180910390f35b6000600782029050606d565b91905056"; var abi = @"[{""constant"":false,""inputs"":[{""name"":""a"",""type"":""uint256""}],""name"":""multiply"",""outputs"":[{""name"":""d"",""type"":""uint256""}],""type"":""function""}]"; var addressFrom = "0x12890d2cce102216644c59dae5baed380d84830c"; var web3 = new Web3(); //deploy the contract, no need to use the abi as we don't have a constructor var transactionHash = await web3.Eth.DeployContract.SendRequestAsync(contractByteCode, addressFrom); //the contract should be mining now //get the contract address TransactionReceipt receipt = null; //wait for the contract to be mined to the address while (receipt == null) { await Task.Delay(500); receipt = await web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(transactionHash); } var contract = web3.Eth.GetContract(abi, receipt.ContractAddress); //get the function by name var multiplyFunction = contract.GetFunction("multiply"); //do a function call (not transaction) and get the result var result = await multiplyFunction.CallAsync <int>(69); //visual test return("The result of deploying a contract and calling a function to multiply 7 by 69 is: " + result + " and should be 483"); }