public async Task Tree_tracker_start_stop_tracking([ValueSource(nameof(InsertLeafTestCases))] InsertLeafTest test) { var address = TestItem.Addresses[0]; var result = await InitializeTestRpc(address); var testRpc = result.TestRpc; BaselineTree baselineTree = BuildATree(); var fromContractAdress = ContractAddress.From(address, 0L); var baselineTreeHelper = new BaselineTreeHelper(testRpc.LogFinder, _baselineDb, _metadataBaselineDb, LimboNoErrorLogger.Instance); var contract = new MerkleTreeSHAContract(_abiEncoder, fromContractAdress); UInt256 nonce = 1L; for (int i = 0; i < test.ExpectedTreeCounts.Length; i++) { nonce = await InsertLeafFromArray(test.LeavesInTransactionsAndBlocks[i], nonce, testRpc, contract, address); await testRpc.AddBlock(); } var tracker = new BaselineTreeTracker(fromContractAdress, baselineTree, testRpc.BlockProcessor, baselineTreeHelper, testRpc.BlockFinder, LimboNoErrorLogger.Instance); Assert.AreEqual(test.ExpectedTreeCounts[test.ExpectedTreeCounts.Length - 1], baselineTree.Count); var afterStartTrackingCount = baselineTree.Count; for (int i = 0; i < test.ExpectedTreeCounts.Length; i++) { tracker.StopTracking(); nonce = await InsertLeafFromArray(test.LeavesInTransactionsAndBlocks[i], nonce, testRpc, contract, address); await testRpc.AddBlock(); tracker.StartTracking(); Assert.AreEqual(test.ExpectedTreeCounts[i] + afterStartTrackingCount, baselineTree.Count); } }
private void RecoverReceiptData(IReleaseSpec releaseSpec, TxReceipt receipt, Block block, Transaction transaction, int transactionIndex, long gasUsedBefore, bool force) { receipt.BlockHash = block.Hash; receipt.BlockNumber = block.Number; receipt.TxHash = transaction.Hash; receipt.Index = transactionIndex; receipt.Sender = transaction.SenderAddress ?? (force ? _ecdsa.RecoverAddress(transaction, !releaseSpec.ValidateChainId) : null); receipt.Recipient = transaction.IsContractCreation ? null : transaction.To; // how would it be in CREATE2? receipt.ContractAddress = transaction.IsContractCreation && transaction.SenderAddress is not null?ContractAddress.From(receipt.Sender, transaction.Nonce) : null; receipt.GasUsed = receipt.GasUsedTotal - gasUsedBefore; if (receipt.StatusCode != StatusCode.Success) { receipt.StatusCode = receipt.Logs.Length == 0 ? StatusCode.Failure : StatusCode.Success; } }
public void Of_contract(long nonce, string expectedAddress) { Address address = ContractAddress.From(TestItem.AddressA, (UInt256)nonce); Assert.AreEqual(address, new Address(expectedAddress)); }
private Address GetContractAddress() { return(ContractAddress.FromInstanceId(InstanceId)); }
private async Task <(Token sourceBalanceForToken, Token recipientBalanceForToken)> GetTokenBalancesAsync(INetworkAccount recipient, INetworkBlockHeader networkBlockHeader, ContractAddress faucetContractAddress, CancellationToken cancellationToken) { IReadOnlyDictionary <EthereumAddress, Erc20TokenBalance> balances = await this._ethereumAccountBalanceSource.GetErc20TokenBalancesAsync( addresses : new EthereumAddress[] { faucetContractAddress, recipient.Address }, networkBlockHeader : networkBlockHeader, tokenContract : this._tokenContract, cancellationToken : cancellationToken); if (!balances.TryGetValue(key: faucetContractAddress, out Erc20TokenBalance sourceTokenBalance)) { this._logger.LogCritical($"{recipient.Network.Name}: Could not retrieve {this._tokenContract.Symbol} balance for {faucetContractAddress}"); throw new InsufficientTokenException(); } if (!balances.TryGetValue(key: recipient.Address, out Erc20TokenBalance recipientTokenBalance)) { this._logger.LogCritical($"{recipient.Network.Name}: Could not retrieve {this._tokenContract.Symbol} balance for {recipient.Address}"); throw new InsufficientTokenException(); } return(sourceBalanceForToken : new Token(sourceTokenBalance), recipientBalanceForToken : new Token(recipientTokenBalance)); }
public GetScoreApiRequestMessage(ContractAddress address) : base("icx_getScoreApi", new Parameter(address)) { }
public Parameter(ContractAddress address) { Address = address.ToString(); }
public override string ToString() { return($"/{ChainId.DumpHex()}/{ContractAddress.DumpHex()}/{string.Join("/", Path)}"); }
/// <summary> /// Constructor. /// </summary> /// <param name="roundId">Round Id.</param> /// <param name="gameAddress">The Game Contract Address.</param> /// <param name="entropyCommit">Entropy Commit.</param> public StartGameRoundInput(GameRoundId roundId, ContractAddress gameAddress, Seed entropyCommit) { this.RoundId = roundId ?? throw new ArgumentNullException(nameof(roundId)); this.GameAddress = gameAddress ?? throw new ArgumentNullException(nameof(gameAddress)); this.EntropyCommit = entropyCommit ?? throw new ArgumentNullException(nameof(entropyCommit)); }
/// <inheritdoc /> public Task StartGameAsync(EthereumNetwork network, ContractAddress gameContract, INetworkBlockHeader blockHeader, CancellationToken cancellationToken) { INetworkSigningAccount account = this._ethereumAccountManager.GetAccount(network); return(this.TryToStartGameAsync(networkSigningAccount: account, gameContract: gameContract, blockHeader: blockHeader, cancellationToken: cancellationToken)); }
/// <inheritdoc /> public async Task TryToStartGameAsync(INetworkSigningAccount networkSigningAccount, ContractAddress gameContract, INetworkBlockHeader blockHeader, CancellationToken cancellationToken) { if (!this._contractInfo.Addresses.TryGetValue(key: networkSigningAccount.Network, out ContractAddress? gameManagerContractAddress)) { // Contract not supported on the network return; } await using (IObjectLock <EthereumAddress>?gameManagerLock = await this._gameManagerLockManager.TakeLockAsync(gameManagerContractAddress)) { if (gameManagerLock == null) { // something else has the game manager locked so is probably doing something important with it return; } bool canGameBeStarted = await this._gameRoundDataManager.CanStartAGameAsync(gameManagerContract: gameManagerContractAddress, (int)GameRoundParameters.InterGameDelay.TotalSeconds); if (!canGameBeStarted) { // Has active games don't start a new one return; } this._logger.LogInformation($"{blockHeader.Network.Name}: Starting new game of game contract {gameContract} using game manager: {gameManagerContractAddress}"); await this._gameManager.StartGameAsync(account : networkSigningAccount, gameContract : gameContract, networkBlockHeader : blockHeader, cancellationToken : cancellationToken); } }
public void After_3529_self_destruct_has_zero_refund(bool eip3529Enabled) { TestState.CreateAccount(TestItem.PrivateKeyA.Address, 100.Ether()); TestState.Commit(SpecProvider.GenesisSpec); TestState.CommitTree(0); byte[] baseInitCodeStore = Prepare.EvmCode .PushData(2) .PushData(2) .Op(Instruction.SSTORE).Done; byte[] baseInitCodeAfterStore = Prepare.EvmCode .ForInitOf( Prepare.EvmCode .PushData(1) .Op(Instruction.SLOAD) .PushData(1) .Op(Instruction.EQ) .PushData(17) .Op(Instruction.JUMPI) .PushData(1) .PushData(1) .Op(Instruction.SSTORE) .PushData(21) .Op(Instruction.JUMP) .Op(Instruction.JUMPDEST) .PushData(0) .Op(Instruction.SELFDESTRUCT) .Op(Instruction.JUMPDEST) .Done) .Done; byte[] baseInitCode = Bytes.Concat(baseInitCodeStore, baseInitCodeAfterStore); byte[] create2Code = Prepare.EvmCode .ForCreate2Of(baseInitCode) .Done; byte[] initOfCreate2Code = Prepare.EvmCode .ForInitOf(create2Code) .Done; Address deployingContractAddress = ContractAddress.From(TestItem.PrivateKeyA.Address, 0); Address deploymentAddress = ContractAddress.From(deployingContractAddress, new byte[32], baseInitCode); byte[] deploy = Prepare.EvmCode .Call(deployingContractAddress, 100000) .Op(Instruction.STOP).Done; byte[] byteCode1 = Prepare.EvmCode .Call(deploymentAddress, 100000) .Op(Instruction.STOP).Done; byte[] byteCode2 = Prepare.EvmCode .Call(deploymentAddress, 100000) .Op(Instruction.STOP).Done; long gasLimit = 1000000; EthereumEcdsa ecdsa = new(1, LimboLogs.Instance); // deploy create 2 Transaction tx0 = Build.A.Transaction.WithCode(initOfCreate2Code).WithGasLimit(gasLimit).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // invoke create 2 to deploy contract Transaction tx1 = Build.A.Transaction.WithCode(deploy).WithGasLimit(gasLimit).WithNonce(1).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // call contract once Transaction tx2 = Build.A.Transaction.WithCode(byteCode1).WithGasLimit(gasLimit).WithNonce(2).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // self destruct contract Transaction tx3 = Build.A.Transaction.WithCode(byteCode2).WithGasLimit(gasLimit).WithNonce(3).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; int gasUsedByTx3 = 37767; long blockNumber = eip3529Enabled ? LondonTestBlockNumber : LondonTestBlockNumber - 1; Block block = Build.A.Block.WithNumber(blockNumber).WithTransactions(tx0, tx1, tx2, tx3).WithGasLimit(2 * gasLimit).TestObject; ParityLikeTxTracer tracer0 = new(block, tx0, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx0, block.Header, tracer0); TestAllTracerWithOutput tracer = CreateTracer(); _processor.Execute(tx1, block.Header, tracer); tracer = CreateTracer(); _processor.Execute(tx2, block.Header, tracer); tracer = CreateTracer(); _processor.Execute(tx3, block.Header, tracer); long expectedRefund = eip3529Enabled ? 0 : 24000; Assert.AreEqual(expectedRefund, tracer.Refund); AssertGas(tracer, gasUsedByTx3 + GasCostOf.Transaction - Math.Min((gasUsedByTx3 + GasCostOf.Transaction) / (eip3529Enabled ? RefundHelper.MaxRefundQuotientEIP3529 : RefundHelper.MaxRefundQuotient), expectedRefund)); }
private static ContractAddressEntity Convert(ContractAddress contractAddress) { return(new(contractAddress)); }
/// <inheritdoc /> public Task <IReadOnlyList <GameHistory> > GetHistoryAsync(ContractAddress gameContractAddress, int maxHistoryItems) { return(this._database.QueryAsync(builder: this._gameHistoryBuilder, storedProcedure: @"Games.GameRound_GetCompletionHistory", new { GameContract = gameContractAddress, Items = maxHistoryItems })); }
/// <inheritdoc /> public Task <bool> CanStartAGameAsync(ContractAddress gameManagerContract, int interGameDelay) { return(this._database.QuerySingleAsync <object, bool>(storedProcedure: @"Games.GameRound_CanStartAGame", new { GameManagerContract = gameManagerContract, InterGameDelay = interGameDelay })); }
public void Destroy_restore_store_different_cells_previously_existing() { byte[] baseInitCodeStore = Prepare.EvmCode .PushData(2) .Op(Instruction.CALLVALUE) .Op(Instruction.SSTORE).Done; byte[] contractCode = Prepare.EvmCode .PushData(1) .Op(Instruction.SLOAD) .PushData(1) .Op(Instruction.EQ) .PushData(17) .Op(Instruction.JUMPI) .PushData(1) .PushData(1) .Op(Instruction.SSTORE) .PushData(21) .Op(Instruction.JUMP) .Op(Instruction.JUMPDEST) .PushData(0) .Op(Instruction.SELFDESTRUCT) .Op(Instruction.JUMPDEST) .Done; byte[] baseInitCodeAfterStore = Prepare.EvmCode .ForInitOf(contractCode) .Done; byte[] baseInitCode = Bytes.Concat(baseInitCodeStore, baseInitCodeAfterStore); byte[] create2Code = Prepare.EvmCode .ForCreate2Of(baseInitCode) .Done; byte[] initOfCreate2Code = Prepare.EvmCode .ForInitOf(create2Code) .Done; Address deployingContractAddress = ContractAddress.From(TestItem.PrivateKeyA.Address, 0); Address deploymentAddress = ContractAddress.From(deployingContractAddress, new byte[32], baseInitCode); byte[] deploy = Prepare.EvmCode .CallWithValue(deployingContractAddress, 100000) .Op(Instruction.STOP).Done; byte[] byteCode1 = Prepare.EvmCode .CallWithValue(deploymentAddress, 100000) .Op(Instruction.STOP).Done; byte[] byteCode2 = Prepare.EvmCode .CallWithValue(deploymentAddress, 100000) .Op(Instruction.STOP).Done; TestState.CreateAccount(TestItem.PrivateKeyA.Address, 100.Ether()); //TestState.Commit(SpecProvider.GenesisSpec); //TestState.CommitTree(0); TestState.CreateAccount(deploymentAddress, UInt256.One); Keccak codeHash = TestState.UpdateCode(contractCode); TestState.UpdateCodeHash(deploymentAddress, codeHash, MuirGlacier.Instance); Storage.Set(new StorageCell(deploymentAddress, 7), new byte[] { 7 }); Storage.Commit(); Storage.CommitTrees(0); TestState.Commit(MuirGlacier.Instance); TestState.CommitTree(0); long gasLimit = 1000000; EthereumEcdsa ecdsa = new(1, LimboLogs.Instance); // deploy create 2 Transaction tx0 = Build.A.Transaction.WithCode(initOfCreate2Code).WithGasLimit(gasLimit).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // call contract once Transaction tx1 = Build.A.Transaction.WithCode(byteCode1).WithGasLimit(gasLimit).WithNonce(1).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // self destruct contract Transaction tx2 = Build.A.Transaction.WithCode(byteCode2).WithGasLimit(gasLimit).WithNonce(2).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // deploy again using create2 Transaction tx3 = Build.A.Transaction.WithValue(3).WithCode(deploy).WithGasLimit(gasLimit).WithNonce(3).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // call newly deployed once Transaction tx4 = Build.A.Transaction.WithCode(byteCode1).WithGasLimit(gasLimit).WithNonce(4).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx0, tx1, tx2, tx3, tx4).WithGasLimit(2 * gasLimit).TestObject; ParityLikeTxTracer tracer = new(block, tx0, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx0, block.Header, tracer); tracer = new ParityLikeTxTracer(block, tx1, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx1, block.Header, tracer); // AssertStorage(new StorageCell(deploymentAddress, 7), 7); tracer = new ParityLikeTxTracer(block, tx2, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx2, block.Header, tracer); // AssertStorage(new StorageCell(deploymentAddress, 7), 0); tracer = new ParityLikeTxTracer(block, tx3, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx3, block.Header, tracer); AssertStorage(new StorageCell(deploymentAddress, 7), 0); tracer = new ParityLikeTxTracer(block, tx4, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx4, block.Header, tracer); AssertStorage(new StorageCell(deploymentAddress, 7), 0); }
public static void SeedUsersAndRoles(ISPContext context) { var roleStore = new RoleStore <IdentityRole>(context); var roleManager = new RoleManager <IdentityRole>(roleStore); var adminRole = new IdentityRole { Name = "Administrator" }; roleManager.Create(adminRole); var supportRole = new IdentityRole { Name = "Support" }; roleManager.Create(supportRole); var userRole = new IdentityRole { Name = "Subscriber" }; roleManager.Create(userRole); var userStore = new UserStore <User>(context); var userManager = new UserManager <User>(userStore); var administratorUser = new User() { UserName = "******", Email = "*****@*****.**", PhoneNumber = "+380000000000", FirstName = "root", LastName = "root", Balance = 0, DoB = DateTime.UtcNow.Date, RegistrationDate = DateTime.UtcNow }; userManager.Create(administratorUser, "rootroot"); userManager.AddToRole(administratorUser.Id, "Administrator"); var supportUser = new User() { UserName = "******", Email = "*****@*****.**", PhoneNumber = "+380000000000", FirstName = "support", LastName = "support", Balance = 0, DoB = DateTime.UtcNow.Date, RegistrationDate = DateTime.UtcNow }; userManager.Create(supportUser, "supportsupport"); userManager.AddToRole(supportUser.Id, "Support"); var subscriberUser = new User() { UserName = "******", Email = "*****@*****.**", PhoneNumber = "+380504700850", FirstName = "Илья", LastName = "Хованский", MiddleName = "Эдурадович", Balance = 1000, DoB = DateTime.UtcNow.Date, RegistrationDate = DateTime.UtcNow }; userManager.Create(subscriberUser, "testtesttest"); userManager.AddToRole(subscriberUser.Id, "Subscriber"); var subscriberUserAddress = new ContractAddress() { SubscriberId = subscriberUser.Id, ZIP = 61024, Department = "Харьковская область", City = "Харьков", Street = "улица Пушкинская", House = "79/1", Apartment = "5615" }; subscriberUser.ContractAddresses = new List <ContractAddress>(); subscriberUser.ContractAddresses.Add(subscriberUserAddress); context.SaveChanges(); }
public void Destroy_restore_store() { TestState.CreateAccount(TestItem.PrivateKeyA.Address, 100.Ether()); TestState.Commit(SpecProvider.GenesisSpec); TestState.CommitTree(); byte[] baseInitCodeStore = Prepare.EvmCode .PushData(2) .PushData(2) .Op(Instruction.SSTORE).Done; byte[] baseInitCodeAfterStore = Prepare.EvmCode .ForInitOf( Prepare.EvmCode .PushData(1) .Op(Instruction.SLOAD) .PushData(1) .Op(Instruction.EQ) .PushData(17) .Op(Instruction.JUMPI) .PushData(1) .PushData(1) .Op(Instruction.SSTORE) .PushData(21) .Op(Instruction.JUMP) .Op(Instruction.JUMPDEST) .PushData(0) .Op(Instruction.SELFDESTRUCT) .Op(Instruction.JUMPDEST) .Done) .Done; byte[] baseInitCode = Bytes.Concat(baseInitCodeStore, baseInitCodeAfterStore); byte[] create2Code = Prepare.EvmCode .ForCreate2Of(baseInitCode) .Done; byte[] initOfCreate2Code = Prepare.EvmCode .ForInitOf(create2Code) .Done; Address deployingContractAddress = ContractAddress.From(TestItem.PrivateKeyA.Address, 0); Address deploymentAddress = ContractAddress.From(deployingContractAddress, new byte[32], baseInitCode); byte[] deploy = Prepare.EvmCode .Call(deployingContractAddress, 100000) .Op(Instruction.STOP).Done; byte[] byteCode1 = Prepare.EvmCode .Call(deploymentAddress, 100000) .Op(Instruction.STOP).Done; byte[] byteCode2 = Prepare.EvmCode .Call(deploymentAddress, 100000) .Op(Instruction.STOP).Done; long gasLimit = 1000000; EthereumEcdsa ecdsa = new EthereumEcdsa(1, LimboLogs.Instance); // deploy create 2 Transaction tx0 = Build.A.Transaction.WithInit(initOfCreate2Code).WithGasLimit(gasLimit).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // invoke create 2 to deploy contract Transaction tx1 = Build.A.Transaction.WithInit(deploy).WithGasLimit(gasLimit).WithNonce(1).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // call contract once Transaction tx2 = Build.A.Transaction.WithInit(byteCode1).WithGasLimit(gasLimit).WithNonce(2).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // self destruct contract Transaction tx3 = Build.A.Transaction.WithInit(byteCode2).WithGasLimit(gasLimit).WithNonce(3).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // deploy again using create2 Transaction tx4 = Build.A.Transaction.WithInit(deploy).WithGasLimit(gasLimit).WithNonce(4).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; // call newly deployed once Transaction tx5 = Build.A.Transaction.WithInit(byteCode1).WithGasLimit(gasLimit).WithNonce(5).SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject; Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx0, tx1, tx2, tx3, tx4, tx5).WithGasLimit(2 * gasLimit).TestObject; ParityLikeTxTracer tracer0 = new ParityLikeTxTracer(block, tx0, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx0, block.Header, tracer0); // AssertStorage(new StorageCell(deploymentAddress, 1), 0); ParityLikeTxTracer tracer = new ParityLikeTxTracer(block, tx1, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx1, block.Header, tracer); // AssertStorage(new StorageCell(deploymentAddress, 1), 0); // AssertStorage(new StorageCell(deploymentAddress, 2), 2); tracer = new ParityLikeTxTracer(block, tx2, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx2, block.Header, tracer); // AssertStorage(new StorageCell(deploymentAddress, 1), 1); // AssertStorage(new StorageCell(deploymentAddress, 2), 2); tracer = new ParityLikeTxTracer(block, tx3, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx3, block.Header, tracer); // AssertStorage(new StorageCell(deploymentAddress, 1), 0); // AssertStorage(new StorageCell(deploymentAddress, 2), 0); tracer = new ParityLikeTxTracer(block, tx4, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx4, block.Header, tracer); // AssertStorage(new StorageCell(deploymentAddress, 1), 0); // AssertStorage(new StorageCell(deploymentAddress, 2), 2); tracer = new ParityLikeTxTracer(block, tx5, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff); _processor.Execute(tx5, block.Header, tracer); AssertStorage(new StorageCell(deploymentAddress, 1), 1); AssertStorage(new StorageCell(deploymentAddress, 2), 2); }