def METHOD_NAME(self):
    priv_key = default_config["GENESIS_PRI_KEY"]
    sender = eth_utils.encode_hex(priv_to_addr(priv_key))
    # check storage root of non-existent contract
    root = self.rpc[FULLNODE0].get_storage_root("0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6")
    assert_equal(root["delta"], None)
    assert_equal(root["delta"], None)
    assert_equal(root["delta"], None)
    # deploy storage test contract
    bytecode_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), CONTRACT_PATH)
    assert(os.path.isfile(bytecode_file))
    bytecode = open(bytecode_file).read()
    _, contractAddr = self.deploy_contract(sender, priv_key, bytecode)
    # get storage root; expect: (D0, I0, S0) = (?, NULL, NULL)
    root0 = self.rpc[FULLNODE0].get_storage_root(contractAddr)
    assert_is_hash_string(root0["delta"])
    assert_equal(root0["intermediate"], None)
    assert_equal(root0["snapshot"], None)
    # update storage; expect: (D1, I1, S1) == (?, I0, S0)
    # NOTE: call_contract will generate some blocks but it should be < SNAPSHOT_EPOCH_COUNT
    self.call_contract(sender, priv_key, contractAddr, encode_hex_0x(keccak(b"increment()")))
    root1 = self.rpc[FULLNODE0].get_storage_root(contractAddr)
    assert_is_hash_string(root1["delta"])
    assert_ne(root1["delta"], root0["delta"] )
    assert_equal(root1["intermediate"], None)
    assert_equal(root1["snapshot"], None)
    # go to next era
    self.rpc[FULLNODE0].generate_blocks(SNAPSHOT_EPOCH_COUNT)
    # get storage root; expect: (D2, I2, S2) == (NULL, D1, NULL)
    # (the previous delta trie became the current intermediate trie)
    root2 = self.rpc[FULLNODE0].get_storage_root(contractAddr)
    assert_equal(root2["delta"], None)
    assert_equal(root2["intermediate"], root1["delta"])
    assert_equal(root2["snapshot"], None)
    # update storage; expect: (D3, I3, S3) == (?, I2, S2)
    # NOTE: call_contract will generate some blocks but it should be < SNAPSHOT_EPOCH_COUNT
    self.call_contract(sender, priv_key, contractAddr, encode_hex_0x(keccak(b"increment()")))
    root3 = self.rpc[FULLNODE0].get_storage_root(contractAddr)
    assert_is_hash_string(root3["delta"])
    assert_ne(root3["delta"], root2["delta"] )
    assert_equal(root3["intermediate"], root2["intermediate"])
    assert_equal(root3["snapshot"], root2["snapshot"])
    # go to next era
    self.rpc[FULLNODE0].generate_blocks(SNAPSHOT_EPOCH_COUNT)
    # get storage root; expect: (D4, I4, S4) == (NULL, D3, ?)
    # (the previous delta trie became the current intermediate trie)
    # (note that storage root in the snapshot will not match due to differences in padding)
    root4 = self.rpc[FULLNODE0].get_storage_root(contractAddr)
    assert_equal(root4["delta"], None)
    assert_equal(root4["intermediate"], root3["delta"])
    assert_is_hash_string(root4["snapshot"])
    # check if other node's storage root matches
    sync_blocks(self.nodes[:])
    wait_until(lambda: self.rpc[FULLNODE0].epoch_number("latest_state")
               == self.rpc[FULLNODE1].epoch_number("latest_state"))
    root = self.rpc[FULLNODE1].get_storage_root(contractAddr)
    assert(root == root4)
    # destroy account
    # NOTE: call_contract will generate some blocks but it should be < SNAPSHOT_EPOCH_COUNTs
    self.call_contract(sender, priv_key, contractAddr, encode_hex_0x(keccak(b"destroy()")))
    root5 = self.rpc[FULLNODE0].get_storage_root(contractAddr)
    assert_equal(root5["delta"], "TOMBSTONE")
    assert_equal(root5["intermediate"], root4["intermediate"])
    assert_equal(root5["snapshot"], root4["snapshot"])
    self.log.info("Pass")