(ol): Add basic types (#1085)

* (ol): Add basic types

* Revert ol-chain-types

* (ol/chain-types): Add chain types

* (ol/chain-types): Enhance types

* Derive IntEnum for TxTypeId

* Add a basic OLLog struct

Author: bewakes

Cargo.lock

@@ -48,7 +48,8 @@ members = [
   "crates/l1tx",
   "crates/ledger-types",
   "crates/mpt",
-  "crates/ol-chain-types",
+  "crates/ol/chain-types",
+  "crates/ol/state-types",
   "crates/ol-chainstate-types",
   "crates/params",
   "crates/primitives",
@@ -182,7 +183,9 @@ strata-ledger-types = { path = "crates/ledger-types" }
 strata-mmr = { path = "crates/util/mmr" }
 strata-mpt = { path = "crates/mpt" }
 strata-ol-chain-types = { path = "crates/ol-chain-types" }
+strata-ol-chain-types-new = { path = "crates/ol/chain-types" }
 strata-ol-chainstate-types = { path = "crates/ol-chainstate-types" }
+strata-ol-state-types = { path = "crates/ol/state-types" }
 strata-params = { path = "crates/params" }
 strata-primitives = { path = "crates/primitives" }
 strata-proofimpl-checkpoint = { path = "crates/proof-impl/checkpoint" }

Cargo.toml

@@ -45,8 +45,8 @@ impl_opaque_thin_wrapper!(SubjectId => RawSubjectId);
 pub type RawAccountTypeId = u16;
 
 /// Distinguishes between account types.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, IntEnum)]
 #[repr(u16)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, IntEnum)]
 pub enum AccountTypeId {
     /// "Inert" account type for a stub that exists but does nothing, but store
     /// balance.

crates/acct-types/src/id.rs

@@ -0,0 +1,17 @@
+[package]
+# TODO: replace the older ol-chain-types crate with this and remove "-new" suffix
+# "-new" is added to maintain compatibility with existing code without disruptive changes
+name = "strata-ol-chain-types-new"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+int-enum.workspace = true
+
+strata-acct-types.workspace = true
+strata-asm-common.workspace = true
+strata-primitives.workspace = true
+strata-snark-acct-types.workspace = true
+
+[lints]
+workspace = true

crates/ol/chain-types/Cargo.toml

@@ -0,0 +1,244 @@
+use strata_asm_common::AsmLogEntry;
+use strata_primitives::buf::{Buf32, Buf64};
+
+use crate::{Epoch, OLBlockId, OLTransaction, Slot};
+
+/// The Orchestration Layer(OL) block.
+#[derive(Clone, Debug)]
+pub struct OLBlock {
+    signed_header: SignedOLBlockHeader,
+    body: OLBlockBody,
+}
+
+impl OLBlock {
+    pub fn new(signed_header: SignedOLBlockHeader, body: OLBlockBody) -> Self {
+        Self {
+            signed_header,
+            body,
+        }
+    }
+
+    pub fn body(&self) -> &OLBlockBody {
+        &self.body
+    }
+
+    pub fn signed_header(&self) -> &SignedOLBlockHeader {
+        &self.signed_header
+    }
+
+    pub fn header(&self) -> &OLBlockHeader {
+        self.signed_header.header()
+    }
+}
+
+/// OL Block header with signature.
+#[derive(Clone, Debug)]
+pub struct SignedOLBlockHeader {
+    header: OLBlockHeader,
+    signature: Buf64,
+}
+
+impl SignedOLBlockHeader {
+    pub fn new(header: OLBlockHeader, signature: Buf64) -> Self {
+        Self { header, signature }
+    }
+
+    pub fn header(&self) -> &OLBlockHeader {
+        &self.header
+    }
+
+    pub fn signature(&self) -> Buf64 {
+        self.signature
+    }
+}
+
+/// OL Block header without signature.
+#[derive(Clone, Debug)]
+pub struct OLBlockHeader {
+    /// The timestamp the block was created at.
+    timestamp: u64,
+
+    /// Slot the block was created for.
+    slot: Slot,
+
+    /// Epoch the block was created in.
+    epoch: Epoch,
+
+    /// Parent block id.
+    parent_blkid: OLBlockId,
+
+    /// Root of the block body.
+    body_root: Buf32,
+
+    /// Root of the block logs.
+    logs_root: Buf32,
+
+    /// The state root resulting after the block execution.
+    state_root: Buf32,
+}
+
+impl OLBlockHeader {
+    pub fn new(
+        timestamp: u64,
+        slot: Slot,
+        epoch: Epoch,
+        parent_blkid: OLBlockId,
+        body_root: Buf32,
+        logs_root: Buf32,
+        state_root: Buf32,
+    ) -> Self {
+        Self {
+            timestamp,
+            slot,
+            epoch,
+            parent_blkid,
+            body_root,
+            logs_root,
+            state_root,
+        }
+    }
+
+    pub fn timestamp(&self) -> u64 {
+        self.timestamp
+    }
+
+    pub fn slot(&self) -> u64 {
+        self.slot
+    }
+
+    pub fn epoch(&self) -> u32 {
+        self.epoch
+    }
+
+    pub fn parent_blkid(&self) -> Buf32 {
+        self.parent_blkid
+    }
+
+    pub fn body_root(&self) -> Buf32 {
+        self.body_root
+    }
+
+    pub fn logs_root(&self) -> Buf32 {
+        self.logs_root
+    }
+
+    pub fn state_root(&self) -> Buf32 {
+        self.state_root
+    }
+}
+
+/// OL block body containing transactions and l1 updates
+#[derive(Clone, Debug)]
+pub struct OLBlockBody {
+    /// The transactions contained in an OL block.
+    tx_segment: OLTxSegment,
+
+    /// Updates from L1.
+    l1_update: L1Update,
+}
+
+impl OLBlockBody {
+    pub fn new(tx_segment: OLTxSegment, l1_update: L1Update) -> Self {
+        Self {
+            tx_segment,
+            l1_update,
+        }
+    }
+
+    pub fn txs(&self) -> &[OLTransaction] {
+        self.tx_segment.txs()
+    }
+
+    pub fn l1_update(&self) -> &L1Update {
+        &self.l1_update
+    }
+
+    pub fn tx_segment(&self) -> &OLTxSegment {
+        &self.tx_segment
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct OLTxSegment {
+    /// Transactions in the segment.
+    txs: Vec<OLTransaction>,
+    // Add other attributes.
+}
+
+impl OLTxSegment {
+    pub fn new(txs: Vec<OLTransaction>) -> Self {
+        Self { txs }
+    }
+
+    pub fn txs(&self) -> &[OLTransaction] {
+        &self.txs
+    }
+}
+
+/// Represents an update from L1.
+#[derive(Clone, Debug)]
+pub struct L1Update {
+    /// The state root before applying updates from L1.
+    pub preseal_state_root: Buf32,
+
+    /// L1 height the manifests are read upto.
+    pub new_l1_blk_height: u64,
+
+    /// L1 block hash the manifests are read upto.
+    pub new_l1_blkid: Buf32,
+
+    /// Manifests from last l1 height to the new l1 height.
+    pub manifests: Vec<AsmManifest>,
+}
+
+impl L1Update {
+    pub fn new(
+        preseal_state_root: Buf32,
+        new_l1_blk_height: u64,
+        new_l1_blkid: Buf32,
+        manifests: Vec<AsmManifest>,
+    ) -> Self {
+        Self {
+            preseal_state_root,
+            new_l1_blk_height,
+            new_l1_blkid,
+            manifests,
+        }
+    }
+
+    pub fn preseal_state_root(&self) -> Buf32 {
+        self.preseal_state_root
+    }
+
+    pub fn new_l1_blk_height(&self) -> u64 {
+        self.new_l1_blk_height
+    }
+
+    pub fn new_l1_blkid(&self) -> Buf32 {
+        self.new_l1_blkid
+    }
+}
+
+/// A manifest containing ASM data corresponding to a L1 block.
+#[derive(Debug, Clone)]
+pub struct AsmManifest {
+    /// L1 block id.
+    l1blkid: Buf32,
+
+    /// Logs from ASM STF.
+    logs: Vec<AsmLogEntry>,
+}
+
+impl AsmManifest {
+    pub fn new(l1blkid: Buf32, logs: Vec<AsmLogEntry>) -> Self {
+        Self { l1blkid, logs }
+    }
+
+    pub fn l1blkid(&self) -> Buf32 {
+        self.l1blkid
+    }
+
+    pub fn logs(&self) -> &[AsmLogEntry] {
+        &self.logs
+    }
+}