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);
}
