Initial Public FS and WebAssembly Work

[appcypher]

Summary

This PR implements the following features

• Initial Public FS implementation that immutable core, filetree merging, etc. will be based on.
• Rust unit tests
• A wasm-bindgen interface implementation.

This is the first of a few PRs that will implement the WNFSv2 Public file system.

Test plan (required)

• Testing the Rust core.

  cargo test -p wnfs

• Testing the wasm binding.

  cd crates/wasm

  wasm-pack test --chrome

  open http://127.0.0.1:8000

Closing issues

Fixes #4

Ongoing Issues

• Plan for Wasming WNFS incrementally oddsdk/ts-odd#371

[matheus23]

This may just be me learning rust:
Can we return a slice [u8] here instead of a Vec<u8>?
Why do we return something clone-on-write-able? I was thinking a user of get_block would never want to change the result, so if there's no need for writes, we won't need the Cow.

[matheus23]

This is cool!
I'm thinking it might be better if this were a normal function instead of a trait though.
Something akin to async fn load<T: Decode<C>, C: Codec, B: BlockStoreLookup>(blockStore: &B, cid: &Cid, decoder: c) -> Result<T>

This way we wouldn't have to re-implement load for all the different structs that implement BlockStore. They all should work the same.

[appcypher]

You are right. We don't need to make it a trait here.

[matheus23]

I'm highly in favor of going with only Rc<...> in here for now, instead of Rc<RefCell<...>>, and remove mutation from our algorithms currently.
@appcypher and I talked about this, I think mutation is used in the upsert function. It may be slightly more complex to do immutably, but it's definitely possible.
We need the immutability for some of our upcoming algorithms, namely the base-history-on stuff to construct previous links and the file tree merge algorithm. They like to early-return when they detect that the two trees they compare have the same reference. These early returns are important, since we don't want to recurse into the file tree deeply so we don't fetch deeper nodes.

[matheus23]

Yeah, that's a great question. I can only link an old internal discussion about this: https://talk.fission.codes/t/valid-paths-in-wnfs/2015

My thinking is, let's assume UTF8. Technically any byte array is valid (even ones that utf8-decoded include a slash), because of how the encoding into IPLD works out.

This is something we'd need to think about a little harder if we want to implement the pretty tree maybe.

[matheus23]

I think we might be able to go without the OpResult type.

• get_node returns an OpResult, but that means you get back a PublicNode in root_node and result, where I'd pretty much expect root_node to be the same thing that that's used to call get_node on.
• read returns an OpResult, but like get_node, it returns back the root_node you originally called read on.
• write returns the parent of the written node. That result isn't used anywhere at the moment.

diverged may not be needed when stuff is immutable, but I may just not really understand it yet! 😅

[matheus23]

First end-to-end public filesystem implementation! 🎉

Stephen and I talked about the comments I left above: The crux of it would be a change somewhat deeper down & technically only a refactor, the surface API would stay the same.
So let's capture that refactor (figuring out how/whether we can remove the RefCell, and make all algorithms only make use of mutation locally without needing a refcell and non-recursive) in an issue and we'll tackle that as the next PR. 👍
Technically we can continue poking the wasm blob this generates 😄