[WIP] Implementation of EIP-1153: Transient Storage using Disk Persistence and Lifecycle Management

[snissn]

Description

This WIP PR introduces transient storage support in the Filecoin EVM, conceptually aligning with Ethereum's EIP-1153. Transient storage functionality is implemented with a tombstone mechanism for lifecycle tracking keyed by transaction identifiers (origin and nonce). While the core implementation is in place, work remains on validating the transient data's lifecycle and completing associated tests.

---

Current Progress

State Modifications:

1. Persistent Transient Data:

   • A Cid variable has been added to represent transient storage.

   pub transient_state: Cid

2. Lifecycle Tracking:

   • Introduced TransientDataLifespan to track lifecycle with origin ActorID and nonce.

   pub struct TransientDataLifespan {
       pub origin: ActorID,
       pub nonce: u64,
   }

New Operations:

1. TLOAD: Retrieves transient data while ensuring lifecycle validity.
2. TSTORE: Updates transient data and lifecycle.
3. Lifecycle validation (TODO): Compare transaction metadata with stored tombstone.

---

Remaining TODOs

1. Liveliness Check for Transient Data:

   • Validate that transient data is only accessible within the valid transaction context by comparing the tombstone (stored origin and nonce) with the current transaction.

   Code Location:

   • get_transient_storage and set_transient_storage in actors/evm/src/interpreter/system.rs.

   // TODO check tombstone for liveliness of data

2. Test Coverage:

   • Write tests to verify:
     • Transient data lifecycle (e.g., expiration between transactions).
     • Liveliness checks during nested and delegate calls.
     • Behavior when accessing invalid or expired transient data.
   • Existing transient storage operations (TLOAD, TSTORE) are partially tested.

   Code Location:

   • actors/evm/src/interpreter/instructions/storage.rs (Test module)

   // TODO test transient storage lifecycle

3. Edge Case Handling:

   • Ensure transient data is cleared appropriately in all scenarios, including contract self-destruct or re-creation.

---

Testing

Implemented Tests:

• test_tload: Validates TLOAD operation when data exists.
• test_tload_oob: Ensures out-of-bounds TLOAD returns zero.
• test_tstore: Confirms TSTORE updates transient data correctly.

Pending Tests:

• Liveliness and lifecycle tests (TODO in the test module).
• System-wide validation tests for lifecycle management.

---

Tradeoffs and Considerations

1. Increased Storage Overhead:

   • Adds transient_state and transient_data_lifespan to State.

2. Gas Inefficiency:

   • Current approach persists transient data, diverging from EIP-1153's ephemeral storage design.

---

Checklist

• Core implementation of TLOAD and TSTORE.
• Integration with State and System.
• Basic tests for TLOAD and TSTORE.
• Lifecycle validation for transient data (TODO).
• Comprehensive test coverage (TODO).

---

Next Steps

• Complete lifecycle validation in System.
• Implement and validate lifecycle tests.

---

References

• EIP-1153: Transient Storage: Link to EIP-1153
• Related Discussions: EIP-1153: Transient Storage FIPs#855 (reply in thread)

---

Review Feedback

Incorporates feedback from @Stebalien:

• Minimize unnecessary writes when clearing transient data.
• Keep State clean unless other updates occur.

---

Note: This PR is marked as WIP until lifecycle validation and associated tests are complete. Feedback on the current implementation and suggestions for completing TODOs are welcome!

[Stebalien]

Can we combine these? That'll let us store a single "null" if there is no transient data.

[Stebalien]

It would be nice if we could load this lazily on first-use, or even just if non-empty.

[rvagg]

I'd be interested to know what these errors are and how you end up diagnosing the problem, for my own educational purposes because your commented code looks like it should work.

[Stebalien]

It's because self.rt.store() doesn't implement clone, while &... does, so rust is helpfully creating a reference for you.

Note: the new function explicitly requires that the store be clonable.

Options are:

1. Lift that requirement up to the impl level.
2. Use self.transient_slots.into_store() to "take" the existing store.