cid

We need good patterns for ‘dereferencing’ dns-bound identifiers like many https://{dns} URLs into something like a multiformats/cid[1] [1]: https://github.com/multiformats/cid

Verification would require more data than CID itself provides (ipld document layout, chunking algorithm, max chunk sizes...). See https://github.com/multiformats/cid/issues/22

Essentially it's a separation of concerns. The content "address" (i.e. how we specify the content that is desired) and the content "location" (i.e. the connections which serve the content associated with an "address") are distinct. An "address" is also self validating. Hash addressing, where a hash of the data is the address of the data, are use to accomplish this. This is useful in many contexts and an [extra few bits][1] on the the front allow an address to represent much much more. "location" is by default a distributed hash table enabling the fulling distributed routing of content and by uses [Kademlia][0]. But the software could easily be configured to with fixed values for the hash table mapping any "address" to the same location which happens to be a cloud provider. Could you elaborate on what you mean by "anyone who keeps their AP

The goals are laudable, and sometimes a backwards-looking implementation can get traction faster than a forward-looking one. But the reliance on Pods and URL location-based identifiers roots it firmly in the past. I think the future is the robust content addressable distributed web. Which could give developers the same flexibility, and users the same friendly experience, but with everything virtualized in a peer to peer mesh. I’d like to see the developer smoothness of Solid married to future-proof content identifiers like this: https://github.com/ipld/cid/blob/master/README.md

> Generally, and this is just my gut feeling, I think that for any hash code written to disk or stored in some way having an identifier for the hashing algorithm used is such a common bite you in the ass later thing that it makes sense to always just do it from day one. To that end it’s easier to do day one if everyone agrees to a standard set of numeric codes. Yes, that's the basic idea of all multiformats: "it's never gonna change" is considered harmful. > Unifying here might allow git objects to be served natively over IPFS. IPFS can already do that thanks to the CID format: https://github.com/ipld/cid There's no good examples for Git specifically yet, but there's a good bunch of working code for transporting e.g. Ethereum and Zcash transaction blobs over IPFS. For Git it's in principle the same: import the raw object into IPFS, and st

Take a look at https://github.com/ipld/cid and the fs: handler and browser support mentioned in other comments.

I want to ditch the Nar format as soon as possible. IPFS's unixfs format is too rich however. When will the IPFS people finish up https://github.com/ipld/cid so we can link whatever content addressable data we want? I'd use git tree objects, despite SHA-1, because it's widely supported. Or do a format identical tree objects but with the IPFS's multihash and SHA-1 banned. Point is, underlying protocol should be agnostic to hashing scheme, we should have a trait/type class like /// Node in try trait Payload { type Hash: HashingTrait; fn unpack(Payload) -> (Vec<u8>, Set<Hash>); fn pack(Vec<u8>, Set<Hash>) -> Payload; // Implement either and get the other for free! fn hash_packed(p: Payload) -> Hash { hash_unpacked(packed(p)) fn hash_unpacked(p: (Vec<u8>, Set<Hash>)) -> Hash { hash_packed(packed(p)) } } any `