refactor(vm): align TIP-2935 deploy with create2 and use Storage for writes

Author: yanghang8612

framework/src/main/java/org/tron/core/db/HistoryBlockHashUtil.java

@@ -1,18 +1,16 @@
 package org.tron.core.db;
 
-import static java.lang.System.arraycopy;
-
 import com.google.protobuf.ByteString;
 import lombok.extern.slf4j.Slf4j;
 import org.bouncycastle.util.encoders.Hex;
-import org.tron.common.crypto.Hash;
 import org.tron.common.runtime.vm.DataWord;
 import org.tron.core.capsule.AccountCapsule;
 import org.tron.core.capsule.BlockCapsule;
 import org.tron.core.capsule.CodeCapsule;
 import org.tron.core.capsule.ContractCapsule;
-import org.tron.core.capsule.StorageRowCapsule;
+import org.tron.core.vm.program.Storage;
 import org.tron.protos.Protocol;
+import org.tron.protos.Protocol.Account;
 import org.tron.protos.contract.SmartContractOuterClass.SmartContract;
 
 /**
@@ -21,13 +19,9 @@
  * <p>Approach A1 — at proposal activation, deploy the BlockHashHistory bytecode
  * and minimal contract/account metadata via direct store writes; on every block
  * (before the tx loop) write the parent block hash to slot
- * {@code (blockNum - 1) % HISTORY_SERVE_WINDOW} via direct StorageRowStore write.
+ * {@code (blockNum - 1) % HISTORY_SERVE_WINDOW} via {@link Storage}.
  * No VM execution is needed for {@code set()}; user contracts read via normal
  * STATICCALL which executes the deployed bytecode.
- *
- * <p>Storage key layout replicates {@code Storage.compose()} for
- * {@code contractVersion=0}: first 16 bytes of {@code sha3(address)} followed by
- * the last 16 bytes of the 32-byte slot key.
  */
 @Slf4j(topic = "DB")
 public class HistoryBlockHashUtil {
@@ -38,6 +32,14 @@ public class HistoryBlockHashUtil {
   public static final byte[] HISTORY_STORAGE_ADDRESS =
       Hex.decode("410000f90827f1c53a10cb7a02335b175320002935");
 
+  // Recovered sender of the EIP-2935 presigned (no-private-key) deploy
+  // transaction on Ethereum, in TRON 21-byte form. Used as {@code originAddress}
+  // on the deployed SmartContract so the deployer-of-record matches Ethereum
+  // byte-for-byte; cross-chain tooling that inspects this field sees the same
+  // address on both sides.
+  public static final byte[] HISTORY_DEPLOYER_ADDRESS =
+      Hex.decode("413462413Af4609098e1E27A490f554f260213D685");
+
   // TIP-2935 runtime bytecode (83 bytes, no constructor prefix). Identical to
   // EIP-2935's so the same address resolves to the same code on both chains.
   public static final byte[] HISTORY_STORAGE_CODE = Hex.decode(
@@ -46,27 +48,36 @@ public class HistoryBlockHashUtil {
           + "611fff81430311604257611fff9006545f5260205ff3"
           + "5b5f5ffd5b5f35611fff60014303065500");
 
-  public static final String BLOCK_HASH_HISTORY_NAME = "BlockHashHistory";
-
-  private static final int PREFIX_BYTES = 16;
+  public static final String HISTORY_STORAGE_NAME = "BlockHashHistory";
+
+  // Account template for the new-account branch of {@code deploy()} (no prior
+  // state at the canonical address). Equivalent to create2's
+  // {@code createAccount(addr, name, Contract)}: only type, accountName, and
+  // address are set. The pre-existing-account branch never uses this template
+  // — it mutates the existing capsule in place to preserve balance / asset
+  // state, mirroring the CREATE2 collision path. Safe to share: the proto is
+  // immutable, and AccountCapsule mutations rebuild via {@code toBuilder}.
+  private static final Account HISTORY_STORAGE_ACCOUNT = Account.newBuilder()
+      .setType(Protocol.AccountType.Contract)
+      .setAccountName(ByteString.copyFromUtf8(HISTORY_STORAGE_NAME))
+      .setAddress(ByteString.copyFrom(HISTORY_STORAGE_ADDRESS))
+      .build();
+
+  // SmartContract template: every field is fixed at activation time, so the
+  // proto is immutable and shared across calls. Mirrors the create2 path's
+  // shape (version=0, contractAddress, consumeUserResourcePercent=100,
+  // originAddress) plus a descriptive name. No trxHash since activation is
+  // not a transaction.
+  private static final SmartContract HISTORY_STORAGE_CONTRACT = SmartContract.newBuilder()
+      .setName(HISTORY_STORAGE_NAME)
+      .setContractAddress(ByteString.copyFrom(HISTORY_STORAGE_ADDRESS))
+      .setOriginAddress(ByteString.copyFrom(HISTORY_DEPLOYER_ADDRESS))
+      .setConsumeUserResourcePercent(100L)
+      .build();
 
   private HistoryBlockHashUtil() {
   }
 
-  /**
-   * Compose the raw StorageRowStore key for {@code (address, slot)} at
-   * {@code contractVersion=0}. Must match {@code Storage.compose()} byte-for-byte
-   * so that a subsequent VM SLOAD(slot) at this address reads back the written value.
-   */
-  public static byte[] composeStorageKey(long slot, byte[] address) {
-    byte[] addrHash = Hash.sha3(address);
-    byte[] slotKey = new DataWord(slot).getData();
-    byte[] result = new byte[32];
-    arraycopy(addrHash, 0, result, 0, PREFIX_BYTES);
-    arraycopy(slotKey, PREFIX_BYTES, result, PREFIX_BYTES, PREFIX_BYTES);
-    return result;
-  }
-
   /**
    * Deploy the TIP-2935 BlockHashHistory contract at {@code HISTORY_STORAGE_ADDRESS}.
    * If foreign code or contract metadata already sits at the canonical address,
@@ -77,7 +88,9 @@ public static byte[] composeStorageKey(long slot, byte[] address) {
    * the only realistic way that branch fires, so it's belt-and-braces. A
    * pre-existing non-contract account at the address is the common case (anyone
    * can transfer TRX there to activate it as an EOA), so we upgrade its type to
-   * {@code Contract} in place, preserving balance/asset state.
+   * {@code Contract} in place — matching the CREATE2 collision branch
+   * ({@code updateAccountType} + {@code clearDelegatedResource}) and preserving
+   * balance/asset state.
    *
    * <p>Called only from {@code ProposalService} inside maintenance-time block
    * processing. Proposal validation rejects re-activation, so this runs at most
@@ -86,28 +99,27 @@ public static byte[] composeStorageKey(long slot, byte[] address) {
    * the {@code saveAllowTvmPrague(1)} write back atomically.
    */
   public static void deploy(Manager manager) {
-    byte[] addr = HISTORY_STORAGE_ADDRESS;
-    if (manager.getCodeStore().has(addr) || manager.getContractStore().has(addr)) {
+    if (manager.getCodeStore().has(HISTORY_STORAGE_ADDRESS)
+        || manager.getContractStore().has(HISTORY_STORAGE_ADDRESS)) {
       logger.warn("TIP-2935: foreign state at {}, skipping deploy",
-          Hex.toHexString(addr));
+          Hex.toHexString(HISTORY_STORAGE_ADDRESS));
       return;
     }
 
-    manager.getCodeStore().put(addr, new CodeCapsule(HISTORY_STORAGE_CODE));
-    manager.getContractStore().put(addr, new ContractCapsule(SmartContract.newBuilder()
-        .setName(BLOCK_HASH_HISTORY_NAME)
-        .setContractAddress(ByteString.copyFrom(addr))
-        .setOriginAddress(ByteString.copyFrom(addr))
-        .setConsumeUserResourcePercent(100L)
-        .setOriginEnergyLimit(0L)
-        .build()));
-
-    boolean preExistingAccount = manager.getAccountStore().has(addr);
-    AccountCapsule account = preExistingAccount
-        ? manager.getAccountStore().get(addr)
-        : new AccountCapsule(ByteString.copyFrom(addr), Protocol.AccountType.Contract);
-    account.updateAccountType(Protocol.AccountType.Contract);
-    manager.getAccountStore().put(addr, account);
+    manager.getCodeStore().put(HISTORY_STORAGE_ADDRESS,
+        new CodeCapsule(HISTORY_STORAGE_CODE));
+    manager.getContractStore().put(HISTORY_STORAGE_ADDRESS,
+        new ContractCapsule(HISTORY_STORAGE_CONTRACT));
+
+    AccountCapsule account = manager.getAccountStore().get(HISTORY_STORAGE_ADDRESS);
+    boolean accountExisting = account != null;
+    if (!accountExisting) {
+      account = new AccountCapsule(HISTORY_STORAGE_ACCOUNT);
+    } else {
+      account.updateAccountType(Protocol.AccountType.Contract);
+      account.clearDelegatedResource();
+    }
+    manager.getAccountStore().put(HISTORY_STORAGE_ADDRESS, account);
 
     // Flip the install marker only after all three store writes succeed; this
     // gates the per-block write() path so a skipped deploy never mutates
@@ -116,7 +128,7 @@ public static void deploy(Manager manager) {
     manager.getDynamicPropertiesStore().saveBlockHashHistoryInstalled(1L);
 
     logger.info("TIP-2935: deployed BlockHashHistory at {} (preExistingAccount={})",
-        Hex.toHexString(addr), preExistingAccount);
+        Hex.toHexString(HISTORY_STORAGE_ADDRESS), accountExisting);
   }
 
   /**
@@ -139,8 +151,8 @@ public static void write(Manager manager, BlockCapsule block) {
       return;
     }
     long slot = (block.getNum() - 1) % HISTORY_SERVE_WINDOW;
-    byte[] storageKey = composeStorageKey(slot, HISTORY_STORAGE_ADDRESS);
-    byte[] parentHash = block.getParentHash().getBytes();
-    manager.getStorageRowStore().put(storageKey, new StorageRowCapsule(storageKey, parentHash));
+    Storage storage = new Storage(HISTORY_STORAGE_ADDRESS, manager.getStorageRowStore());
+    storage.put(new DataWord(slot), new DataWord(block.getParentHash().getBytes()));
+    storage.commit();
   }
 }

framework/src/test/java/org/tron/core/db/HistoryBlockHashIntegrationTest.java

@@ -4,6 +4,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 import com.google.protobuf.ByteString;
@@ -18,10 +19,10 @@
 import org.tron.core.capsule.BlockCapsule;
 import org.tron.core.capsule.CodeCapsule;
 import org.tron.core.capsule.ContractCapsule;
-import org.tron.core.capsule.StorageRowCapsule;
 import org.tron.core.config.args.Args;
 import org.tron.core.store.DynamicPropertiesStore;
 import org.tron.core.store.StoreFactory;
+import org.tron.core.vm.program.Storage;
 import org.tron.core.vm.repository.RepositoryImpl;
 import org.tron.protos.Protocol;
 import org.tron.protos.contract.SmartContractOuterClass.SmartContract;
@@ -46,10 +47,18 @@ public void resetState() {
     chainBaseManager.getCodeStore().delete(addr);
     chainBaseManager.getContractStore().delete(addr);
     chainBaseManager.getAccountStore().delete(addr);
+    Storage storage = new Storage(addr, chainBaseManager.getStorageRowStore());
     for (long slot : new long[]{0L, 99L, 499L, 776L}) {
-      chainBaseManager.getStorageRowStore()
-          .delete(HistoryBlockHashUtil.composeStorageKey(slot, addr));
+      storage.put(new DataWord(slot), DataWord.ZERO());
     }
+    storage.commit();
+  }
+
+  private DataWord readSlot(long slot) {
+    Storage storage = new Storage(
+        HistoryBlockHashUtil.HISTORY_STORAGE_ADDRESS,
+        chainBaseManager.getStorageRowStore());
+    return storage.getValue(new DataWord(slot));
   }
 
   @Test
@@ -86,18 +95,15 @@ public void writeAfterActivationFillsStorageSlot() {
 
     HistoryBlockHashUtil.write(dbManager, block);
 
-    byte[] storageKey = HistoryBlockHashUtil.composeStorageKey(
-        499L, HistoryBlockHashUtil.HISTORY_STORAGE_ADDRESS);
-    StorageRowCapsule row = chainBaseManager.getStorageRowStore().get(storageKey);
-    assertNotNull(row);
-    assertArrayEquals(parentHash, row.getValue());
+    DataWord readBack = readSlot(499L);
+    assertNotNull(readBack);
+    assertArrayEquals(parentHash, readBack.getData());
   }
 
   @Test
   public void vmRepositoryReadsBackWrittenHash() {
-    // Full round-trip: direct-write -> VM Repository -> getStorageValue.
-    // Proves Storage.compose() on the read side agrees with
-    // HistoryBlockHashUtil.composeStorageKey() on the write side.
+    // Full round-trip: direct-write through Storage -> VM Repository -> getStorageValue.
+    // Proves write and read go through the same Storage.compose() layer.
     chainBaseManager.getDynamicPropertiesStore().saveAllowTvmPrague(1L);
     HistoryBlockHashUtil.deploy(dbManager);
 
@@ -143,9 +149,7 @@ public void noWriteBeforeActivation() {
     // before activation, so write() must early-return.
     HistoryBlockHashUtil.write(dbManager, block);
 
-    byte[] storageKey = HistoryBlockHashUtil.composeStorageKey(
-        99L, HistoryBlockHashUtil.HISTORY_STORAGE_ADDRESS);
-    assertFalse(chainBaseManager.getStorageRowStore().has(storageKey));
+    assertNull(readSlot(99L));
   }
 
   /**
@@ -167,11 +171,9 @@ public void writeForBlock1StoresGenesisHashAtSlot0() {
 
     HistoryBlockHashUtil.write(dbManager, block1);
 
-    byte[] key = HistoryBlockHashUtil.composeStorageKey(
-        0L, HistoryBlockHashUtil.HISTORY_STORAGE_ADDRESS);
-    StorageRowCapsule row = chainBaseManager.getStorageRowStore().get(key);
-    assertNotNull(row);
-    assertArrayEquals(genesisHash, row.getValue());
+    DataWord readBack = readSlot(0L);
+    assertNotNull(readBack);
+    assertArrayEquals(genesisHash, readBack.getData());
   }
 
   /**
@@ -192,9 +194,7 @@ public void writeIsNoOpForGenesisBlock() {
 
     HistoryBlockHashUtil.write(dbManager, genesis);
 
-    byte[] slot0Key = HistoryBlockHashUtil.composeStorageKey(
-        0L, HistoryBlockHashUtil.HISTORY_STORAGE_ADDRESS);
-    assertFalse(chainBaseManager.getStorageRowStore().has(slot0Key));
+    assertNull(readSlot(0L));
   }
 
   /**