Clarity <-> MARF

sample-programs/names.clar

@@ -1,5 +1,5 @@
-(define burn-address 'SP000000000000000000002Q6VF78)
-(define (price-function (name int))
+(define-constant burn-address 'SP000000000000000000002Q6VF78)
+(define-private (price-function (name int))
   (if (< name 100000) 1000 100))
 
 (define-map name-map 
@@ -13,7 +13,7 @@
                 (name-price int))
   (if (is-ok? (contract-call! tokens token-transfer
                 burn-address name-price))
-      (begin (insert-entry! preorder-map
+      (begin (map-insert! preorder-map
                      (tuple (name-hash name-hash))
                      (tuple (paid name-price)
                             (buyer tx-sender)))
@@ -26,11 +26,11 @@
                 (salt int))
   (let ((preorder-entry
          (expects! ;; name _must_ have been preordered.
-           (fetch-entry preorder-map
-                      (tuple (name-hash (hash160 (xor name salt)))))
+           (map-get preorder-map
+             (tuple (name-hash (hash160 (xor name salt)))))
            (err "no preorder found")))
         (name-entry 
-         (fetch-entry name-map (tuple (name name)))))
+         (map-get name-map (tuple (name name)))))
     (if (and
          ;; name shouldn't *already* exist
          (is-none? name-entry)
@@ -41,10 +41,10 @@
          (eq? tx-sender
               (get buyer preorder-entry)))
         (if (and
-              (insert-entry! name-map
+              (map-insert! name-map
                         (tuple (name name))
                         (tuple (owner recipient-principal)))
-              (delete-entry! preorder-map
+              (map-delete! preorder-map
                         (tuple (name-hash (hash160 (xor name salt))))))
             (ok 0)
             (err "failed to insert new name entry"))

sample-programs/tokens.clar

@@ -1,13 +1,13 @@
 (define-map tokens ((account principal)) ((balance int)))
-(define (get-balance (account principal))
-  (default-to 0 (get balance (fetch-entry tokens (tuple (account account))))))
+(define-private (get-balance (account principal))
+  (default-to 0 (get balance (map-get tokens (tuple (account account))))))
 
-(define (token-credit! (account principal) (amount int))
+(define-private (token-credit! (account principal) (amount int))
   (if (<= amount 0)
       (err "must move positive balance")
       (let ((current-amount (get-balance account)))
         (begin
-          (set-entry! tokens (tuple (account account))
+          (map-set! tokens (tuple (account account))
                       (tuple (balance (+ amount current-amount))))
           (ok amount)))))
 
@@ -16,7 +16,7 @@
     (if (or (> amount balance) (<= amount 0))
         (err "must transfer positive balance and possess funds")
         (begin
-          (set-entry! tokens (tuple (account tx-sender))
+          (map-set! tokens (tuple (account tx-sender))
                       (tuple (balance (- balance amount))))
           (token-credit! to amount)))))
 

src/chainstate/stacks/index/marf.rs

@@ -79,7 +79,6 @@ use chainstate::stacks::index::Error as Error;
 
 use util::log;
 
-
 /// Merklized Adaptive-Radix Forest -- a collection of Merklized Adaptive-Radix Tries.
 pub struct MARF {
     storage: TrieFileStorage,
@@ -459,7 +458,7 @@ impl MARF {
     /// Instantiate the MARF using a TrieFileStorage instance, from the given path on disk.
     /// This will have the side-effect of instantiating a new fork table from the tries encoded on
     /// disk. Performant code should call this method sparingly.
-    pub fn from_path(path: &String) -> Result<MARF, Error> {
+    pub fn from_path(path: &str) -> Result<MARF, Error> {
         let mut file_storage = TrieFileStorage::new(path)?;
         match fs::metadata(path) {
             Ok(_) => {},
@@ -476,11 +475,12 @@ impl MARF {
     }
 
     /// Resolve a key from the MARF to a MARFValue with respect to the given block height.
-    pub fn get(&mut self, block_hash: &BlockHeaderHash, key: &String) -> Result<Option<MARFValue>, Error> {
+    pub fn get(&mut self, block_hash: &BlockHeaderHash, key: &str) -> Result<Option<MARFValue>, Error> {
         let cur_block_hash = self.storage.get_cur_block();
         let cur_block_rw = self.storage.readwrite();
 
         let path = TriePath::from_key(key);
+
         let leaf_opt_res = MARF::get_path(&mut self.storage, block_hash, &path)?;
 
         // restore
@@ -499,7 +499,7 @@ impl MARF {
     /// Insert the given (key, value) pair into the MARF.  Inserting the same key twice silently
     /// overwrites the existing key.  Succeeds if there are no storage errors.
     /// Must be called after a call to .begin() (will fail otherwise)
-    pub fn insert(&mut self, key: &String, value: &String) -> Result<(), Error> {
+    pub fn insert(&mut self, key: &str, value: MARFValue) -> Result<(), Error> {
         match self.open_chain_tip {
             None => {
                 Err(Error::WriteNotBegunError)
@@ -508,9 +508,9 @@ impl MARF {
                 let cur_block_hash = self.storage.get_cur_block();
                 let cur_block_rw = self.storage.readwrite();
 
-                let marf_value = MARFValue::from_value(value);
-                let marf_leaf = TrieLeaf::from_value(&vec![], marf_value);
+                let marf_leaf = TrieLeaf::from_value(&vec![], value);
                 let path = TriePath::from_key(key);
+
                 MARF::insert_leaf(&mut self.storage, block_hash, &path, &marf_leaf)?;
 
                 // restore
@@ -598,6 +598,11 @@ impl MARF {
         Ok(())
     }
 
+    /// Get open chain tip
+    pub fn get_open_chain_tip(&self) -> Option<&BlockHeaderHash> {
+        self.open_chain_tip.as_ref()
+    }
+
     /// Get all known chain tips
     pub fn chain_tips(&mut self) -> Vec<BlockHeaderHash> {
         self.storage.chain_tips()

src/chainstate/stacks/index/mod.rs

@@ -135,7 +135,7 @@ impl MARFValue {
     }
 
     /// Construct from a String that encodes a value inserted into the underlying data store
-    pub fn from_value(s: &String) -> MARFValue {
+    pub fn from_value(s: &str) -> MARFValue {
         let mut tmp = [0u8; 32];
 
         let mut hasher = TrieHasher::new();

src/chainstate/stacks/index/node.rs

@@ -128,7 +128,7 @@ impl_byte_array_newtype!(TriePath, u8, 32);
 pub const TRIEPATH_MAX_LEN : usize = 32;
 
 impl TriePath {
-    pub fn from_key(k: &String) -> TriePath {
+    pub fn from_key(k: &str) -> TriePath {
         let h = TrieHash::from_data(k.as_bytes());
         let mut hb = [0u8; TRIEPATH_MAX_LEN];
         hb.copy_from_slice(h.as_bytes());

src/chainstate/stacks/index/proofs.rs

@@ -1186,13 +1186,13 @@ mod test {
 
         // Block #1
         m.begin(&block_0, &block_1).unwrap();
-        let r = m.insert(&k1, &old_v);
+        let r = m.insert(&k1, MARFValue::from_value(&old_v));
         let (_, root_hash_1) = Trie::read_root(m.borrow_storage_backend()).unwrap();
         m.commit().unwrap();
 
         // Block #2
         m.begin(&block_1, &block_2).unwrap();
-        let r = m.insert(&k1, &new_v);
+        let r = m.insert(&k1, MARFValue::from_value(&new_v));
         let (_, root_hash_2) = Trie::read_root(m.borrow_storage_backend()).unwrap();
         m.commit().unwrap();
 

src/chainstate/stacks/index/storage.rs

@@ -391,7 +391,7 @@ pub struct TrieFileStorage {
 }
 
 impl TrieFileStorage {
-    pub fn new(dir_path: &String) -> Result<TrieFileStorage, Error> {
+    pub fn new(dir_path: &str) -> Result<TrieFileStorage, Error> {
         match fs::metadata(dir_path) {
             Ok(md) => {
                 if !md.is_dir() {
@@ -408,15 +408,16 @@ impl TrieFileStorage {
             }
         }
 
-        let partially_written_state = TrieFileStorage::scan_tmp_blocks(dir_path)?;
+        let dir_path = dir_path.to_string();
+        let partially_written_state = TrieFileStorage::scan_tmp_blocks(&dir_path)?;
         if partially_written_state.len() > 0 {
             return Err(Error::PartialWriteError);
         }
 
-        let fork_table = TrieFileStorage::read_fork_table(dir_path, &TrieFileStorage::block_sentinel())?;
+        let fork_table = TrieFileStorage::read_fork_table(&dir_path, &TrieFileStorage::block_sentinel())?;
 
         let ret = TrieFileStorage {
-            dir_path: dir_path.clone(),
+            dir_path,
             readonly: false,
 
             last_extended: None,
@@ -891,6 +892,16 @@ impl TrieFileStorage {
     pub fn open_block(&mut self, bhh: &BlockHeaderHash, readwrite: bool) -> Result<(), Error> {
         let block_fork_ptr = self.fork_table.get_fork_ptr(bhh)?;
 
+        let sentinel = TrieFileStorage::block_sentinel();
+        if *bhh == sentinel {
+            // just reset to newly opened state
+            self.cur_block_fd = None;
+            self.cur_block = sentinel;
+            self.cur_block_fork_ptr = None;
+            self.readonly = !readwrite;
+            return Ok(());
+        }
+
         if Some(*bhh) == self.last_extended {
             // nothing to do -- we're already ready.
             // just clear out.