public static void Main(string[] args)
{
StorageCell m = new StorageCell( );
m.Put("Hello");
Console.WriteLine(m.Get( ));
}
public void Non_existing()
{
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
IReleaseSpec spec = MuirGlacier.Instance;
MemDb stateDb = new MemDb();
TrieStore trieStore = new TrieStore(stateDb, Logger);
StateProvider provider = new StateProvider(trieStore, new MemDb(), Logger);
StorageProvider storageProvider = new StorageProvider(trieStore, provider, Logger);
void CommitEverything()
{
storageProvider.Commit();
storageProvider.CommitTrees(0);
provider.Commit(spec);
provider.CommitTree(0);
}
provider.CreateAccount(_address1, 1);
storageProvider.Set(storageCell, new byte[] { 1 });
CommitEverything();
Keccak stateRoot0 = provider.StateRoot;
StateReader reader =
new StateReader(new TrieStore(stateDb, LimboLogs.Instance), Substitute.For <IDb>(), Logger);
Keccak storageRoot = reader.GetStorageRoot(stateRoot0, _address1);
reader.GetStorage(storageRoot, storageCell.Index + 1).Should().BeEquivalentTo(new byte[] { 0 });
reader.GetStorage(Keccak.EmptyTreeHash, storageCell.Index + 1).Should().BeEquivalentTo(new byte[] { 0 });
}
public async Task Can_ask_about_storage_in_parallel()
{
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
IReleaseSpec spec = MuirGlacier.Instance;
MemDb stateDb = new MemDb();
TrieStore trieStore = new TrieStore(stateDb, Logger);
StateProvider provider = new StateProvider(trieStore, new MemDb(), Logger);
StorageProvider storageProvider = new StorageProvider(trieStore, provider, Logger);
void UpdateStorageValue(byte[] newValue)
{
storageProvider.Set(storageCell, newValue);
}
void AddOneToBalance()
{
provider.AddToBalance(_address1, 1, spec);
}
void CommitEverything()
{
storageProvider.Commit();
storageProvider.CommitTrees(0);
provider.Commit(spec);
provider.CommitTree(0);
}
provider.CreateAccount(_address1, 1);
CommitEverything();
AddOneToBalance();
UpdateStorageValue(new byte[] { 1 });
CommitEverything();
Keccak stateRoot0 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 2 });
CommitEverything();
Keccak stateRoot1 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 3 });
CommitEverything();
Keccak stateRoot2 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 4 });
CommitEverything();
Keccak stateRoot3 = provider.StateRoot;
StateReader reader =
new StateReader(new TrieStore(stateDb, LimboLogs.Instance), Substitute.For <IDb>(), Logger);
Task a = StartStorageTask(reader, stateRoot0, storageCell, new byte[] { 1 });
Task b = StartStorageTask(reader, stateRoot1, storageCell, new byte[] { 2 });
Task c = StartStorageTask(reader, stateRoot2, storageCell, new byte[] { 3 });
Task d = StartStorageTask(reader, stateRoot3, storageCell, new byte[] { 4 });
await Task.WhenAll(a, b, c, d);
}
public void Things_are_cold_to_start_with()
{
EvmState evmState = new EvmState(10000, new ExecutionEnvironment(), ExecutionType.Call, true, false);
StorageCell storageCell = new StorageCell(TestItem.AddressA, 1);
evmState.IsCold(TestItem.AddressA).Should().BeTrue();
evmState.IsCold(storageCell).Should().BeTrue();
}
public void Can_collect_stats()
{
MemDb memDb = new MemDb();
IDb stateDb = memDb;
TrieStore trieStore = new TrieStore(stateDb, new MemoryLimit(0.MB()), Persist.EveryBlock, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(trieStore, stateDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance);
stateProvider.CreateAccount(TestItem.AddressA, 1);
Keccak codeHash = stateProvider.UpdateCode(new byte[] { 1, 2, 3 });
stateProvider.UpdateCodeHash(TestItem.AddressA, codeHash, Istanbul.Instance);
stateProvider.CreateAccount(TestItem.AddressB, 1);
Keccak codeHash2 = stateProvider.UpdateCode(new byte[] { 1, 2, 3, 4 });
stateProvider.UpdateCodeHash(TestItem.AddressB, codeHash2, Istanbul.Instance);
for (int i = 0; i < 1000; i++)
{
StorageCell storageCell = new StorageCell(TestItem.AddressA, (UInt256)i);
storageProvider.Set(storageCell, new byte[] { (byte)i });
}
storageProvider.Commit();
stateProvider.Commit(Istanbul.Instance);
storageProvider.CommitTrees(0);
stateProvider.CommitTree(0);
storageProvider.CommitTrees(1);
stateProvider.CommitTree(1);
memDb.Delete(codeHash2); // missing code
Keccak storageKey = new Keccak("0x345e54154080bfa9e8f20c99d7a0139773926479bc59e5b4f830ad94b6425332");
memDb.Delete(storageKey); // deletes some storage
trieStore.ClearCache();
TrieStatsCollector statsCollector = new TrieStatsCollector(stateDb, LimboLogs.Instance);
stateProvider.Accept(statsCollector, stateProvider.StateRoot);
var stats = statsCollector.Stats;
stats.CodeCount.Should().Be(1);
stats.MissingCode.Should().Be(1);
stats.NodesCount.Should().Be(1348);
stats.StateBranchCount.Should().Be(1);
stats.StateExtensionCount.Should().Be(1);
stats.AccountCount.Should().Be(2);
stats.StorageCount.Should().Be(1343);
stats.StorageBranchCount.Should().Be(337);
stats.StorageExtensionCount.Should().Be(12);
stats.StorageLeafCount.Should().Be(994);
stats.MissingStorage.Should().Be(1);
}
public void Can_warm_storage_up_twice()
{
EvmState evmState = new EvmState(10000, new ExecutionEnvironment(), ExecutionType.Call, true, false);
Address address = TestItem.AddressA;
StorageCell storageCell = new StorageCell(address, 1);
evmState.WarmUp(storageCell);
evmState.WarmUp(storageCell);
evmState.IsCold(storageCell).Should().BeFalse();
}
public void Get_storage()
{
/* all testing will be touching just a single storage cell */
var storageCell = new StorageCell(TestItem.AddressA, 1);
/* to start with we need to create an account that we will be setting storage at */
_stateProvider.CreateAccount(storageCell.Address, UInt256.One);
_stateProvider.Commit(MuirGlacier.Instance);
_stateProvider.CommitTree();
/* at this stage we have an account with empty storage at the address that we want to test */
byte[] initialValue = new byte[] { 1, 2, 3 };
_storageProvider.Set(storageCell, initialValue);
_storageProvider.Commit();
_storageProvider.CommitTrees();
_stateProvider.Commit(MuirGlacier.Instance);
_stateProvider.CommitTree();
var retrieved =
_blockchainBridge.GetStorage(storageCell.Address, storageCell.Index, _stateProvider.StateRoot);
retrieved.Should().BeEquivalentTo(initialValue);
/* at this stage we set the value in storage to 1,2,3 at the tested storage cell */
/* Now we are testing scenario where the storage is being changed by the block processor.
* To do that we create some different storage / state access stack that represents the processor.
* It is a different stack of objects than the one that is used by the blockchain bridge. */
byte[] newValue = new byte[] { 1, 2, 3, 4, 5 };
StateProvider processorStateProvider =
new StateProvider(_dbProvider.StateDb, _dbProvider.CodeDb, LimboLogs.Instance);
processorStateProvider.StateRoot = _stateProvider.StateRoot;
StorageProvider processorStorageProvider =
new StorageProvider(_dbProvider.StateDb, processorStateProvider, LimboLogs.Instance);
processorStorageProvider.Set(storageCell, newValue);
processorStorageProvider.Commit();
processorStorageProvider.CommitTrees();
processorStateProvider.Commit(MuirGlacier.Instance);
processorStateProvider.CommitTree();
/* At this stage the DB should have the storage value updated to 5.
* We will try to retrieve the value by taking the state root from the processor.*/
retrieved =
_blockchainBridge.GetStorage(storageCell.Address, storageCell.Index, processorStateProvider.StateRoot);
retrieved.Should().BeEquivalentTo(newValue);
/* If it failed then it means that the blockchain bridge cached the previous call value */
}
public void ReportStorageRead(StorageCell storageCell)
{
for (int index = 0; index < _txTracers.Count; index++)
{
ITxTracer innerTracer = _txTracers[index];
if (innerTracer.IsTracingStorage)
{
innerTracer.ReportStorageRead(storageCell);
}
}
}
public void ReportStorageRead(StorageCell storageCell)
{
for (var index = 0; index < _txTracers.Length; index++)
{
var innerTracer = _txTracers[index];
if (innerTracer.IsTracingStorage)
{
innerTracer.ReportStorageRead(storageCell);
}
}
}
public void Storage_to_commit_keeps_it_warm()
{
EvmState parentEvmState = new EvmState(10000, new ExecutionEnvironment(), ExecutionType.Call, true, false);
EvmState evmState = new EvmState(10000, new ExecutionEnvironment(), ExecutionType.Call, true, false);
StorageCell storageCell = new StorageCell(TestItem.AddressA, 1);
evmState.WarmUp(storageCell);
evmState.CommitToParent(parentEvmState);
parentEvmState.IsCold(storageCell).Should().BeFalse();
}
public void ReportStorageChange(StorageCell storageCell, byte[] before, byte[] after)
{
for (var index = 0; index < _txTracers.Length; index++)
{
var innerTracer = _txTracers[index];
if (innerTracer.IsTracingStorage)
{
innerTracer.ReportStorageChange(storageCell, before, after);
}
}
}
protected void AssertStorage(StorageCell storageCell, UInt256 expectedValue)
{
_callIndex++;
if (!TestState.AccountExists(storageCell.Address))
{
Assert.AreEqual(expectedValue.ToBigEndian().WithoutLeadingZeros().ToArray(), new byte[] { 0 }, $"storage {storageCell}, call {_callIndex}");
}
else
{
byte[] actualValue = Storage.Get(storageCell);
Assert.AreEqual(expectedValue.ToBigEndian().WithoutLeadingZeros().ToArray(), actualValue, $"storage {storageCell}, call {_callIndex}");
}
}
private Task StartStorageTask(StateReader reader, Keccak stateRoot, StorageCell storageCell, byte[] value)
{
return(Task.Run(
() =>
{
for (int i = 0; i < 1000; i++)
{
Keccak storageRoot = reader.GetStorageRoot(stateRoot, storageCell.Address);
byte[] result = reader.GetStorage(storageRoot, storageCell.Index);
result.Should().BeEquivalentTo(value);
}
}));
}
protected void AssertStorage(StorageCell storageCell, BigInteger expectedValue)
{
_callIndex++;
if (!TestState.AccountExists(storageCell.Address))
{
Assert.AreEqual(expectedValue.ToBigEndianByteArray(), new byte[1] {
0
}, $"storage {storageCell}, call {_callIndex}");
}
else
{
byte[] actualValue = Storage.Get(storageCell);
Assert.AreEqual(expectedValue.ToBigEndianByteArray(), actualValue, $"storage {storageCell}, call {_callIndex}");
}
}
public void Regression_mainnet_226522()
{
_blockNumber = 1;
Address deployed = ContractAddress.From(TestItem.AddressC, 0);
StorageCell storageCell = new StorageCell(deployed, 1);
byte[] deployedCode = new byte[106]; // cost is * 200
byte[] initCode = Prepare.EvmCode
.PushData(1)
.PushData(1)
.Op(Instruction.SSTORE)
.PushData(0)
.PushData(1)
.Op(Instruction.SSTORE) // here we reset storage so we would get refund of 15000 gas
.ForInitOf(deployedCode).Done;
byte[] createCode = Prepare.EvmCode
.Create(initCode, 0)
.PushData(0)
.Op(Instruction.SSTORE)
.Done;
TestState.CreateAccount(TestItem.AddressC, 1.Ether());
Keccak createCodeHash = TestState.UpdateCode(createCode);
TestState.UpdateCodeHash(TestItem.AddressC, createCodeHash, Spec);
byte[] code = Prepare.EvmCode
.Call(TestItem.AddressC, 32000 + 20003 + 20000 + 5000 + 500 + 0) // not enough
.Done;
var receipt = Execute(code);
byte[] result = Storage.Get(storageCell);
Assert.AreEqual(new byte[] { 0 }, result, "storage reverted");
Assert.AreEqual(83199, receipt.GasSpent, "with refund");
byte[] returnData = Storage.Get(new StorageCell(TestItem.AddressC, 0));
Assert.AreEqual(deployed.Bytes, returnData, "address returned");
}
public void StorageCellClicked(StorageCell cell)
{
if(cell!=null){
if(fuseISODlg.gameObject.activeInHierarchy){
//fuseISODlg.initFuseISODlgCell(cell.equipData.equipDef.id);
}
}
}
public void StorageCellClicked(StorageCell cell)
{
// Debug.LogError("StorageCellClicked");
TeamDlg.instance.StorageCellClicked (cell);
}
public async Task Get_storage()
{
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
/* all testing will be touching just a single storage cell */
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
TrieStore trieStore = new TrieStore(dbProvider.StateDb, Logger);
StateProvider state = new StateProvider(trieStore, dbProvider.CodeDb, Logger);
StorageProvider storage = new StorageProvider(trieStore, state, Logger);
/* to start with we need to create an account that we will be setting storage at */
state.CreateAccount(storageCell.Address, UInt256.One);
state.Commit(MuirGlacier.Instance);
state.CommitTree(1);
/* at this stage we have an account with empty storage at the address that we want to test */
byte[] initialValue = new byte[] { 1, 2, 3 };
storage.Set(storageCell, initialValue);
storage.Commit();
storage.CommitTrees(2);
state.Commit(MuirGlacier.Instance);
state.CommitTree(2);
StateReader reader = new StateReader(
new TrieStore(dbProvider.StateDb, LimboLogs.Instance), dbProvider.CodeDb, Logger);
var account = reader.GetAccount(state.StateRoot, _address1);
var retrieved = reader.GetStorage(account.StorageRoot, storageCell.Index);
retrieved.Should().BeEquivalentTo(initialValue);
/* at this stage we set the value in storage to 1,2,3 at the tested storage cell */
/* Now we are testing scenario where the storage is being changed by the block processor.
* To do that we create some different storage / state access stack that represents the processor.
* It is a different stack of objects than the one that is used by the blockchain bridge. */
byte[] newValue = new byte[] { 1, 2, 3, 4, 5 };
StateProvider processorStateProvider =
new StateProvider(trieStore, new MemDb(), LimboLogs.Instance);
processorStateProvider.StateRoot = state.StateRoot;
StorageProvider processorStorageProvider =
new StorageProvider(trieStore, processorStateProvider, LimboLogs.Instance);
processorStorageProvider.Set(storageCell, newValue);
processorStorageProvider.Commit();
processorStorageProvider.CommitTrees(3);
processorStateProvider.Commit(MuirGlacier.Instance);
processorStateProvider.CommitTree(3);
/* At this stage the DB should have the storage value updated to 5.
* We will try to retrieve the value by taking the state root from the processor.*/
retrieved =
reader.GetStorage(processorStateProvider.GetStorageRoot(storageCell.Address), storageCell.Index);
retrieved.Should().BeEquivalentTo(newValue);
/* If it failed then it means that the blockchain bridge cached the previous call value */
}
private bool hitSlot(StorageCell cell)
{
Ray ray = this.uiCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hit = new RaycastHit();
if(cell.collider.Raycast(ray,out hit,10000)){
Debug.Log("hit "+cell.gameObject.name);
return true;
}else{
return false;
}
}
public void Chaotic_test()
{
const int accountsCount = 100;
CryptoRandom random = new CryptoRandom();
List <AddressWithStorage> addressesWithStorage = new List <AddressWithStorage>();
for (int i = 0; i < accountsCount; i++)
{
AddressWithStorage addressWithStorage = new AddressWithStorage();
addressWithStorage.StorageCells = new StorageCell[i];
byte[] addressBytes = random.GenerateRandomBytes(20);
addressWithStorage.Address = new Address(addressBytes);
for (int j = 0; j < i; j++)
{
byte[] storageIndex = random.GenerateRandomBytes(32);
UInt256 index = new UInt256(storageIndex);
StorageCell storageCell = new StorageCell(addressWithStorage.Address, index);
addressWithStorage.StorageCells[j] = storageCell;
}
addressesWithStorage.Add(addressWithStorage);
}
IDb memDb = new MemDb();
TrieStore trieStore = new TrieStore(memDb, LimboLogs.Instance);
StateTree tree = new StateTree(trieStore, LimboLogs.Instance);
for (int i = 0; i < accountsCount; i++)
{
Account account = Build.An.Account.WithBalance((UInt256)i).TestObject;
StorageTree storageTree = new StorageTree(trieStore, Keccak.EmptyTreeHash, LimboLogs.Instance);
for (int j = 0; j < i; j++)
{
storageTree.Set(addressesWithStorage[i].StorageCells[j].Index, new byte[1] {
1
});
}
storageTree.UpdateRootHash();
storageTree.Commit(0);
account = account.WithChangedStorageRoot(storageTree.RootHash);
tree.Set(addressesWithStorage[i].Address, account);
}
tree.UpdateRootHash();
tree.Commit(0);
for (int i = 0; i < accountsCount; i++)
{
AccountProofCollector collector = new AccountProofCollector(addressesWithStorage[i].Address, addressesWithStorage[i].StorageCells.Select(sc => sc.Index).ToArray());
tree.Accept(collector, tree.RootHash, true);
AccountProof accountProof = collector.BuildResult();
accountProof.Address.Should().Be(addressesWithStorage[i].Address);
accountProof.Balance.Should().Be((UInt256)i);
accountProof.Nonce.Should().Be(0);
accountProof.CodeHash.Should().Be(Keccak.OfAnEmptyString);
if (i != 0)
{
accountProof.StorageRoot.Should().NotBe(Keccak.EmptyTreeHash);
}
accountProof.StorageProofs.Length.Should().Be(i);
for (int j = 0; j < i; j++)
{
byte[] indexBytes = new byte[32];
addressesWithStorage[i].StorageCells[j].Index.ToBigEndian(indexBytes.AsSpan());
accountProof.StorageProofs[j].Key.ToHexString().Should().Be(indexBytes.ToHexString(), $"{i} {j}");
TrieNode node = new TrieNode(NodeType.Unknown, accountProof.StorageProofs[j].Proof.Last());
node.ResolveNode(null);
// TestContext.Write($"|[{i},{j}]");
if (node.Value.Length != 1)
{
TestContext.WriteLine();
TestContext.WriteLine(addressesWithStorage[i].Address);
TestContext.WriteLine(i);
foreach (StorageCell storageCell in addressesWithStorage[i].StorageCells)
{
TestContext.WriteLine("storage: " + storageCell.Index);
}
}
node.Value.Should().BeEquivalentTo(new byte[] { 1 });
}
}
}
public void WarmUp(StorageCell storageCell)
{
AccessedStorageCells.Add(storageCell);
}
public void ReportStorageRead(StorageCell storageCell)
{
throw new NotImplementedException();
}
public void ReportStorageChange(StorageCell storageCell, byte[] before, byte[] after)
{
throw new NotImplementedException();
}
private void ShowHighLight(StorageCell cell, bool highLight)
{
this.isHighLight = false;
if(cell.equipData == null){
if (highLight) {
cell.Bg.spriteName = (storagePanel.currentFilter == StoragePanel.FILTER.OWN_ISO)?ISO_Checked:Gear_Checked;
}else{
cell.Bg.spriteName = (storagePanel.currentFilter == StoragePanel.FILTER.OWN_ISO)?ISO_UnChecked:Gear_UnChecked;
}
if(storagePanel != null)
{
storagePanel.setHighlightOnSlot(null);
storagePanel.SetInfoBar (null,null,null);
}
}else{
if (highLight) {
cell.Bg.spriteName = (cell.equipData.equipDef.type == EquipData.Type.ISO)? ISO_Checked:Gear_Checked;
cell.Bg.MakePixelPerfect ();
if(storagePanel != null)
{
storagePanel.setHighlightOnSlot(null);
storagePanel.SetInfoBar (this.equipData,this.Icon_Gear.atlas,this.Icon_Gear.spriteName);
}
} else {
cell.Bg.spriteName = (cell.equipData.equipDef.type == EquipData.Type.ISO)? ISO_UnChecked:Gear_UnChecked;
cell.Bg.MakePixelPerfect ();
}
}
}
public void ReportStorageRead(StorageCell storageCell)
{
_currentTxTracer.ReportStorageRead(storageCell);
}
public bool IsCold(StorageCell storageCell)
{
return(_accessedStorageKeys is null || !AccessedStorageCells.Contains(storageCell));
}
public void ReportStorageRead(StorageCell storageCell) => throw new InvalidOperationException(ErrorMessage);
public void ReportStorageRead(StorageCell storageCell)
{
// implicit knowledge here that if we read storage then for sure we have at least asked for the account's balance
// and so we do not need to add account to Accounts
Storages.Add(storageCell);
}
public void _Test_storage_failed_case(string historicallyFailingCase)
{
string[] lines = historicallyFailingCase.Split(Environment.NewLine);
int storageCount = lines.Length - 2;
IDb memDb = new MemDb();
TrieStore trieStore = new TrieStore(memDb, LimboLogs.Instance);
StateTree tree = new StateTree(trieStore, LimboLogs.Instance);
Address address = new Address(Bytes.FromHexString(lines[0]));
int accountIndex = int.Parse(lines[1]);
UInt256[] indexes = new UInt256[storageCount];
for (int j = 0; j < storageCount; j++)
{
indexes[j] = UInt256.Parse(lines[j + 2].Replace("storage: ", string.Empty));
}
AddressWithStorage addressWithStorage = new AddressWithStorage();
addressWithStorage.StorageCells = new StorageCell[storageCount];
addressWithStorage.Address = address;
StorageTree storageTree = new StorageTree(trieStore, Keccak.EmptyTreeHash, LimboLogs.Instance);
for (int j = 0; j < storageCount; j++)
{
UInt256 index = UInt256.Parse(lines[j + 2].Replace("storage: ", string.Empty));
StorageCell storageCell = new StorageCell(address, index);
addressWithStorage.StorageCells[j] = storageCell;
byte[] rawKey = new byte[32];
addressWithStorage.StorageCells[j].Index.ToBigEndian(rawKey);
TestContext.WriteLine($"Set {Keccak.Compute(rawKey).Bytes.ToHexString()}");
storageTree.Set(addressWithStorage.StorageCells[j].Index, new byte[] { 1 });
storageTree.UpdateRootHash();
storageTree.Commit(0);
}
Account account = Build.An.Account.WithBalance((UInt256)accountIndex).WithStorageRoot(storageTree.RootHash).TestObject;
tree.Set(addressWithStorage.Address, account);
tree.UpdateRootHash();
tree.Commit(0);
TreeDumper treeDumper = new TreeDumper();
tree.Accept(treeDumper, tree.RootHash, true);
TestContext.WriteLine(treeDumper.ToString());
AccountProofCollector collector = new AccountProofCollector(address, indexes);
tree.Accept(collector, tree.RootHash, true);
AccountProof accountProof = collector.BuildResult();
accountProof.Address.Should().Be(address);
accountProof.Balance.Should().Be((UInt256)accountIndex);
accountProof.Nonce.Should().Be(0);
accountProof.CodeHash.Should().Be(Keccak.OfAnEmptyString);
if (accountIndex != 0)
{
accountProof.StorageRoot.Should().NotBe(Keccak.EmptyTreeHash);
}
accountProof.StorageProofs.Length.Should().Be(accountIndex);
for (int j = 0; j < accountProof.StorageProofs.Length; j++)
{
TrieNode node = new TrieNode(NodeType.Unknown, accountProof.StorageProofs[j].Proof.Last());
node.ResolveNode(new TrieStore(memDb, NullLogManager.Instance));
if (node.Value.Length != 1)
{
TestContext.WriteLine($"{j}");
// throw new InvalidDataException($"{j}");
}
}
}
public static async void UpdateStorageCell(StorageCell storageCell)
{
await SQLDatabase.UpdateAsync(storageCell);
}
public void ReportStorageChange(StorageCell storageCell, byte[] before, byte[] after)
{
_currentTxTracer.ReportStorageChange(storageCell, before, after);
}
public void ReportStorageRead(StorageCell storageCell) => throw new OperationCanceledException(ErrorMessage);
public void ReportStorageChange(StorageCell storageCell, byte[] before, byte[] after) => throw new InvalidOperationException(ErrorMessage);
public Change(ChangeType changeType, StorageCell storageCell, byte[] value)
{
StorageCell = storageCell;
Value = value;
ChangeType = changeType;
}
