snarkvm_ledger_store/helpers/memory/
transaction.rs

1// Copyright (c) 2019-2025 Provable Inc.
2// This file is part of the snarkVM library.
3
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at:
7
8// http://www.apache.org/licenses/LICENSE-2.0
9
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16use crate::{
17    DeploymentStorage,
18    DeploymentStore,
19    ExecutionStorage,
20    ExecutionStore,
21    FeeStorage,
22    FeeStore,
23    TransactionStorage,
24    TransactionType,
25    TransitionStore,
26    helpers::memory::{MemoryMap, TransitionMemory},
27};
28use console::{
29    prelude::*,
30    program::{Identifier, ProgramID, ProgramOwner},
31    types::U8,
32};
33use snarkvm_synthesizer_program::Program;
34use snarkvm_synthesizer_snark::{Certificate, Proof, VerifyingKey};
35
36/// An in-memory transaction storage.
37#[derive(Clone)]
38pub struct TransactionMemory<N: Network> {
39    /// The mapping of `transaction ID` to `transaction type`.
40    id_map: MemoryMap<N::TransactionID, TransactionType>,
41    /// The deployment store.
42    deployment_store: DeploymentStore<N, DeploymentMemory<N>>,
43    /// The execution store.
44    execution_store: ExecutionStore<N, ExecutionMemory<N>>,
45    /// The fee store.
46    fee_store: FeeStore<N, FeeMemory<N>>,
47}
48
49#[rustfmt::skip]
50impl<N: Network> TransactionStorage<N> for TransactionMemory<N> {
51    type IDMap = MemoryMap<N::TransactionID, TransactionType>;
52    type DeploymentStorage = DeploymentMemory<N>;
53    type ExecutionStorage = ExecutionMemory<N>;
54    type FeeStorage = FeeMemory<N>;
55    type TransitionStorage = TransitionMemory<N>;
56
57    /// Initializes the transaction storage.
58    fn open(transition_store: TransitionStore<N, Self::TransitionStorage>) -> Result<Self> {
59        // Initialize the fee store.
60        let fee_store = FeeStore::<N, FeeMemory<N>>::open(transition_store)?;
61        // Initialize the deployment store.
62        let deployment_store = DeploymentStore::<N, DeploymentMemory<N>>::open(fee_store.clone())?;
63        // Initialize the execution store.
64        let execution_store = ExecutionStore::<N, ExecutionMemory<N>>::open(fee_store.clone())?;
65        // Return the transaction storage.
66        Ok(Self { id_map: MemoryMap::default(), deployment_store, execution_store, fee_store })
67    }
68
69    /// Returns the ID map.
70    fn id_map(&self) -> &Self::IDMap {
71        &self.id_map
72    }
73
74    /// Returns the deployment store.
75    fn deployment_store(&self) -> &DeploymentStore<N, Self::DeploymentStorage> {
76        &self.deployment_store
77    }
78
79    /// Returns the execution store.
80    fn execution_store(&self) -> &ExecutionStore<N, Self::ExecutionStorage> {
81        &self.execution_store
82    }
83
84    /// Returns the fee store.
85    fn fee_store(&self) -> &FeeStore<N, Self::FeeStorage> {
86        &self.fee_store
87    }
88}
89
90/// An in-memory deployment storage.
91#[derive(Clone)]
92#[allow(clippy::type_complexity)]
93pub struct DeploymentMemory<N: Network> {
94    /// The ID map.
95    id_map: MemoryMap<N::TransactionID, ProgramID<N>>,
96    /// The ID edition map.
97    id_edition_map: MemoryMap<N::TransactionID, u16>,
98    /// The edition map.
99    edition_map: MemoryMap<ProgramID<N>, u16>,
100    /// The reverse ID map.
101    reverse_id_map: MemoryMap<(ProgramID<N>, u16), N::TransactionID>,
102    /// The owner map.
103    owner_map: MemoryMap<(ProgramID<N>, u16), ProgramOwner<N>>,
104    /// The program map.
105    program_map: MemoryMap<(ProgramID<N>, u16), Program<N>>,
106    /// The checksum map.
107    checksum_map: MemoryMap<(ProgramID<N>, u16), [U8<N>; 32]>,
108    /// The verifying key map.
109    verifying_key_map: MemoryMap<(ProgramID<N>, Identifier<N>, u16), VerifyingKey<N>>,
110    /// The certificate map.
111    certificate_map: MemoryMap<(ProgramID<N>, Identifier<N>, u16), Certificate<N>>,
112    /// The fee store.
113    fee_store: FeeStore<N, FeeMemory<N>>,
114}
115
116#[rustfmt::skip]
117impl<N: Network> DeploymentStorage<N> for DeploymentMemory<N> {
118    type IDMap = MemoryMap<N::TransactionID, ProgramID<N>>;
119    type IDEditionMap = MemoryMap<N::TransactionID, u16>;
120    type EditionMap = MemoryMap<ProgramID<N>, u16>;
121    type ReverseIDMap = MemoryMap<(ProgramID<N>, u16), N::TransactionID>;
122    type OwnerMap = MemoryMap<(ProgramID<N>, u16), ProgramOwner<N>>;
123    type ProgramMap = MemoryMap<(ProgramID<N>, u16), Program<N>>;
124    type ChecksumMap = MemoryMap<(ProgramID<N>, u16), [U8<N>; 32]>;
125    type VerifyingKeyMap = MemoryMap<(ProgramID<N>, Identifier<N>, u16), VerifyingKey<N>>;
126    type CertificateMap = MemoryMap<(ProgramID<N>, Identifier<N>, u16), Certificate<N>>;
127    type FeeStorage = FeeMemory<N>;
128
129    /// Initializes the deployment storage.
130    fn open(fee_store: FeeStore<N, Self::FeeStorage>) -> Result<Self> {
131        Ok(Self {
132            id_map: MemoryMap::default(),
133            id_edition_map: MemoryMap::default(),
134            edition_map: MemoryMap::default(),
135            reverse_id_map: MemoryMap::default(),
136            owner_map: MemoryMap::default(),
137            program_map: MemoryMap::default(),
138            checksum_map: MemoryMap::default(),
139            verifying_key_map: MemoryMap::default(),
140            certificate_map: MemoryMap::default(),
141            fee_store,
142        })
143    }
144
145    /// Returns the ID map.
146    fn id_map(&self) -> &Self::IDMap {
147        &self.id_map
148    }
149
150    /// Returns the ID edition map.
151    fn id_edition_map(&self) -> &Self::IDEditionMap {
152        &self.id_edition_map
153    }
154
155    /// Returns the edition map.
156    fn edition_map(&self) -> &Self::EditionMap {
157        &self.edition_map
158    }
159
160    /// Returns the reverse ID map.
161    fn reverse_id_map(&self) -> &Self::ReverseIDMap {
162        &self.reverse_id_map
163    }
164
165    /// Returns the owner map.
166    fn owner_map(&self) -> &Self::OwnerMap {
167        &self.owner_map
168    }
169
170    /// Returns the program map.
171    fn program_map(&self) -> &Self::ProgramMap {
172        &self.program_map
173    }
174
175    /// Returns the checksum map.
176    fn checksum_map(&self) -> &Self::ChecksumMap {
177        &self.checksum_map
178    }
179
180    /// Returns the verifying key map.
181    fn verifying_key_map(&self) -> &Self::VerifyingKeyMap {
182        &self.verifying_key_map
183    }
184
185    /// Returns the certificate map.
186    fn certificate_map(&self) -> &Self::CertificateMap {
187        &self.certificate_map
188    }
189
190    /// Returns the fee store.
191    fn fee_store(&self) -> &FeeStore<N, Self::FeeStorage> {
192        &self.fee_store
193    }
194}
195
196/// An in-memory execution storage.
197#[derive(Clone)]
198#[allow(clippy::type_complexity)]
199pub struct ExecutionMemory<N: Network> {
200    /// The ID map.
201    id_map: MemoryMap<N::TransactionID, (Vec<N::TransitionID>, bool)>,
202    /// The reverse ID map.
203    reverse_id_map: MemoryMap<N::TransitionID, N::TransactionID>,
204    /// The inclusion map.
205    inclusion_map: MemoryMap<N::TransactionID, (N::StateRoot, Option<Proof<N>>)>,
206    /// The fee store.
207    fee_store: FeeStore<N, FeeMemory<N>>,
208}
209
210#[rustfmt::skip]
211impl<N: Network> ExecutionStorage<N> for ExecutionMemory<N> {
212    type IDMap = MemoryMap<N::TransactionID, (Vec<N::TransitionID>, bool)>;
213    type ReverseIDMap = MemoryMap<N::TransitionID, N::TransactionID>;
214    type InclusionMap = MemoryMap<N::TransactionID, (N::StateRoot, Option<Proof<N>>)>;
215    type FeeStorage = FeeMemory<N>;
216
217    /// Initializes the execution storage.
218    fn open(fee_store: FeeStore<N, Self::FeeStorage>) -> Result<Self> {
219        Ok(Self {
220            id_map: MemoryMap::default(),
221            reverse_id_map: MemoryMap::default(),
222            inclusion_map: MemoryMap::default(),
223            fee_store
224        })
225    }
226
227    /// Returns the ID map.
228    fn id_map(&self) -> &Self::IDMap {
229        &self.id_map
230    }
231
232    /// Returns the reverse ID map.
233    fn reverse_id_map(&self) -> &Self::ReverseIDMap {
234        &self.reverse_id_map
235    }
236
237    /// Returns the inclusion map.
238    fn inclusion_map(&self) -> &Self::InclusionMap {
239        &self.inclusion_map
240    }
241
242    /// Returns the fee store.
243    fn fee_store(&self) -> &FeeStore<N, Self::FeeStorage> {
244        &self.fee_store
245    }
246}
247
248/// An in-memory fee storage.
249#[derive(Clone)]
250#[allow(clippy::type_complexity)]
251pub struct FeeMemory<N: Network> {
252    /// The fee map.
253    fee_map: MemoryMap<N::TransactionID, (N::TransitionID, N::StateRoot, Option<Proof<N>>)>,
254    /// The reverse fee map.
255    reverse_fee_map: MemoryMap<N::TransitionID, N::TransactionID>,
256    /// The transition store.
257    transition_store: TransitionStore<N, TransitionMemory<N>>,
258}
259
260#[rustfmt::skip]
261impl<N: Network> FeeStorage<N> for FeeMemory<N> {
262    type FeeMap = MemoryMap<N::TransactionID, (N::TransitionID, N::StateRoot, Option<Proof<N>>)>;
263    type ReverseFeeMap = MemoryMap<N::TransitionID, N::TransactionID>;
264    type TransitionStorage = TransitionMemory<N>;
265
266    /// Initializes the fee storage.
267    fn open(transition_store: TransitionStore<N, Self::TransitionStorage>) -> Result<Self> {
268        Ok(Self {
269            fee_map: MemoryMap::default(),
270            reverse_fee_map: MemoryMap::default(),
271            transition_store,
272        })
273    }
274
275    /// Returns the fee map.
276    fn fee_map(&self) -> &Self::FeeMap {
277        &self.fee_map
278    }
279
280    /// Returns the reverse fee map.
281    fn reverse_fee_map(&self) -> &Self::ReverseFeeMap {
282        &self.reverse_fee_map
283    }
284
285    /// Returns the transition store.
286    fn transition_store(&self) -> &TransitionStore<N, Self::TransitionStorage> {
287        &self.transition_store
288    }
289}
snarkvm_ledger_store/helpers/memory/transaction.rs

snarkvm_ledger_store/helpers/memory/
transaction.rs
