From ffe4112586fd54ba7fcb577e6587877b1ab8fd82 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 2 Jul 2020 17:43:50 +0000
Subject: [PATCH 01/13] Change content address data types

Header is valid, but rest of the code needs to be adapted.
---
 src/libstore/content-address.hh | 41 +++++++++++++++++++++++++--------
 1 file changed, 31 insertions(+), 10 deletions(-)

diff --git a/src/libstore/content-address.hh b/src/libstore/content-address.hh
index 83a9b233669..40b945f5230 100644
--- a/src/libstore/content-address.hh
+++ b/src/libstore/content-address.hh
@@ -30,10 +30,18 @@ struct FixedOutputHash {
     std::string printMethodAlgo() const;
 };
 
+// Deref is a phantom parameter that just signifies what the hash should
+// dereference too.
+template<typename Deref>
 struct IPFSHash {
     Hash hash;
 };
 
+template<template <typename> class Ref>
+struct IPFSGitTreeNodeT;
+
+typedef IPFSHash<IPFSGitTreeNodeT<IPFSHash>> IPFSGitTreeReference;
+
 /*
   We've accumulated several types of content-addressed paths over the years;
   fixed-output derivations support multiple hash algorithms and serialisation
@@ -48,7 +56,7 @@ struct IPFSHash {
 typedef std::variant<
     TextHash, // for paths computed by makeTextPath() / addTextToStore
     FixedOutputHash, // for path computed by makeFixedOutputPath
-    IPFSHash
+    IPFSGitTreeReference
 > LegacyContentAddress;
 
 /* Compute the prefix to the hash algorithm which indicates how the files were
@@ -133,25 +141,38 @@ struct FixedOutputInfo : FixedOutputHash {
     PathReferences<StorePath> references;
 };
 
-struct IPFSInfo : IPFSHash {
+template<typename Underlying>
+struct ContentAddressT;
+
+template<template <typename> class Ref>
+struct IPFSGitTreeNodeT {
+	Hash gitTree;
     // References for the paths
-    PathReferences<StorePath> references;
+    PathReferences<ContentAddressT<Ref<IPFSGitTreeNodeT<Ref>>>> references;
 };
 
-struct ContentAddress {
+typedef IPFSGitTreeNodeT<IPFSHash> IPFSGitTreeNode;
+
+// FIXME names
+typedef std::variant<
+    TextInfo,
+    FixedOutputInfo,
+    IPFSGitTreeReference
+> ContentAddressWithoutName;
+
+template<typename Underlying>
+struct ContentAddressT {
     std::string name;
-    std::variant<
-        TextInfo,
-        FixedOutputInfo,
-        IPFSInfo
-    > info;
+    Underlying info;
 
-    bool operator < (const ContentAddress & other) const
+    bool operator < (const ContentAddressT<Underlying> & other) const
     {
         return name < other.name;
     }
 };
 
+typedef ContentAddressT<ContentAddressWithoutName> ContentAddress;
+
 std::string renderContentAddress(ContentAddress ca);
 
 ContentAddress parseContentAddress(std::string_view rawCa);

From 0d20c9d49428de053de60f7657794cc91bf20177 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 2 Jul 2020 19:12:15 +0000
Subject: [PATCH 02/13] WIP start converting the rest

---
 src/libstore/content-address.cc     | 12 ++++--------
 src/nix/make-content-addressable.cc |  4 ++--
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/libstore/content-address.cc b/src/libstore/content-address.cc
index 22b8712c3b7..c28a2094703 100644
--- a/src/libstore/content-address.cc
+++ b/src/libstore/content-address.cc
@@ -36,7 +36,7 @@ std::string renderLegacyContentAddress(LegacyContentAddress ca) {
                  + fsh.hash.to_string(Base32, true);
         },
         [](IPFSHash fsh) {
-             return "ipfs:"
+             return "ipfs-git:"
                  + fsh.hash.to_string(Base32, true);
         }
     }, ca);
@@ -74,7 +74,7 @@ LegacyContentAddress parseLegacyContentAddress(std::string_view rawCa) {
                     .hash = Hash(string(hashRaw)),
                 };
             }
-        } else if (prefix == "ipfs") {
+        } else if (prefix == "ipfs-git") {
             Hash hash = Hash(rawCa.substr(prefixSeparator+1, string::npos));
             if (*hash.type != htSHA1)
                 throw Error("the ipfs hash should have type SHA1");
@@ -200,12 +200,8 @@ ContentAddress parseContentAddress(std::string_view rawCa)
             auto ca_ = std::get<IPFSHash>(ca);
             return ContentAddress {
                 .name = name,
-                .info = IPFSInfo {
-                    {.hash = ca_.hash,},
-                    .references = PathReferences<StorePath> {
-                        .references = references,
-                        .hasSelfReference = hasSelfReference,
-                    },
+                .info = IPFSGitTreeReference {
+                    .hash = ca_.hash,
                 },
             };
         } else throw Error("unknown content address type");
diff --git a/src/nix/make-content-addressable.cc b/src/nix/make-content-addressable.cc
index a19d3875d58..8a200acfad8 100644
--- a/src/nix/make-content-addressable.cc
+++ b/src/nix/make-content-addressable.cc
@@ -105,11 +105,11 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
                 ContentAddress {
                     .name = std::string { path.name() },
                     .info = ipfsContent ?
-                      std::variant<TextInfo, FixedOutputInfo, IPFSInfo> {IPFSInfo {
+                      ContentAddressWithoutName {IPFSInfo {
                           { .hash = gitHash },
                           std::move(refs),
                       }}
-                    : std::variant<TextInfo, FixedOutputInfo, IPFSInfo> {FixedOutputInfo {
+                    : ContentAddressWithoutName {FixedOutputInfo {
                           {
                               .method = FileIngestionMethod::Recursive,
                               .hash = narHash,

From 4287b89cdfcd657093e12c457882cf6347dde3f7 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Mon, 6 Jul 2020 22:03:53 +0000
Subject: [PATCH 03/13] Allow storings some tree and not just hash for IPFS

---
 src/libstore/content-address.hh | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/libstore/content-address.hh b/src/libstore/content-address.hh
index c14ed189515..7d8d9e733f1 100644
--- a/src/libstore/content-address.hh
+++ b/src/libstore/content-address.hh
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <nlohmann/json.hpp>
+#include <memory>
 #include <variant>
 
 #include "hash.hh"
@@ -40,8 +41,6 @@ struct IPFSHash {
 template<template <typename> class Ref>
 struct IPFSGitTreeNodeT;
 
-typedef IPFSHash<IPFSGitTreeNodeT<IPFSHash>> IPFSGitTreeReference;
-
 /*
   We've accumulated several types of content-addressed paths over the years;
   fixed-output derivations support multiple hash algorithms and serialisation
@@ -56,7 +55,7 @@ typedef IPFSHash<IPFSGitTreeNodeT<IPFSHash>> IPFSGitTreeReference;
 typedef std::variant<
     TextHash, // for paths computed by makeTextPath() / addTextToStore
     FixedOutputHash, // for path computed by makeFixedOutputPath
-    IPFSGitTreeReference
+    IPFSHash<IPFSGitTreeNodeT<IPFSHash>>
 > LegacyContentAddress;
 
 /* Compute the prefix to the hash algorithm which indicates how the files were
@@ -159,11 +158,21 @@ struct IPFSGitTreeNodeT {
 
 typedef IPFSGitTreeNodeT<IPFSHash> IPFSGitTreeNode;
 
+/* The point of this is to store data that hasn't yet been put in IPFS
+   so we don't have a dangling hash. If someday Nix was more integrated
+   with IPFS such that it always had at least IPFS offline/local
+   storage, we wouldn't need this. */
+template<typename Deref>
+struct IPFSHashWithOptValue : IPFSHash<Deref> {
+	// N.B. shared_ptr is nullable
+    std::shared_ptr<Deref> value;
+};
+
 // FIXME names
 typedef std::variant<
     TextInfo,
     FixedOutputInfo,
-    IPFSGitTreeReference
+    IPFSHashWithOptValue<IPFSGitTreeNodeT<IPFSHashWithOptValue>>
 > ContentAddressWithoutName;
 
 template<typename Underlying>

From acbda9c9be0b5b6262b0336e048103bca467864d Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Tue, 7 Jul 2020 02:49:22 +0000
Subject: [PATCH 04/13] WIP

---
 src/libstore/content-address.cc     | 50 +++++++++++----------
 src/libstore/content-address.hh     | 46 +++++++------------
 src/nix/make-content-addressable.cc | 70 +++++++++++++++++++++--------
 3 files changed, 95 insertions(+), 71 deletions(-)

diff --git a/src/libstore/content-address.cc b/src/libstore/content-address.cc
index 0c41e875fae..4add3873f8f 100644
--- a/src/libstore/content-address.cc
+++ b/src/libstore/content-address.cc
@@ -272,7 +272,7 @@ void to_json(nlohmann::json& j, const ContentAddress & ca)
             { "qtype", "ipfs" },
             { "name", ca.name },
             { "references", info.references },
-            { "cid", nlohmann::json { { "/", "f01781114" + info.hash.to_string(Base16, false) } } }
+            { "cid", to_json(info) },
         };
     } else throw Error("cannot convert to json");
 }
@@ -281,29 +281,35 @@ void from_json(const nlohmann::json& j, ContentAddress & ca)
 {
     std::string_view type = j.at("qtype").get<std::string_view>();
     if (type == "ipfs") {
-        auto cid = j.at("cid").at("/").get<std::string_view>();
-        if (cid.substr(0, 9) != "f01781114")
-            throw Error("cid '%s' is wrong type for ipfs hash", cid);
         ca = ContentAddress {
             .name = j.at("name"),
-            .info = IPFSInfo {
-                Hash::parseAny(cid.substr(9), htSHA1),
-                j.at("references").get<PathReferences<StorePath>>(),
-            },
+            .info = from_json(j.at("cid")),
         };
     } else
         throw Error("invalid type: %s", type);
 }
 
-void to_json(nlohmann::json& j, const PathReferences<StorePath> & references)
+// TODO should be sha-256 for this
+
+void to_json(nlohmann::json& j, const IPFSHash<IPFSGitTreeNode<IpfsHash>> & c) {
+    j = { "/", "f01781114" + c.hash.to_string(Base16, false) };
+}
+
+void from_json(const nlohmann::json& j, IPFSHash<IPFSGitTreeNode<IpfsHash>> & c) {
+    auto cid = j.at("/").get<std::string_view>();
+    if (cid.substr(0, 9) != "f01781114")
+        throw Error("cid '%s' is wrong type for ipfs hash", cid);
+    c = IPFSHash<IPFSGitTreeNode<IPFSHash>> {
+        Hash::parseAny(cid.substr(9), htSHA1),
+    };
+}
+
+template<typename T>
+void to_json(nlohmann::json& j, const PathReferences<T> & references)
 {
     auto refs = nlohmann::json::array();
     for (auto & i : references.references) {
-        auto hash = Hash::parseAny(i.hashPart(), htSHA1);
-        refs.push_back(nlohmann::json {
-            { "name", i.name() },
-            { "cid", nlohmann::json {{ "/", "f01711114" + hash.to_string(Base16, false) }} }
-        });
+        refs.push_back(to_json(i));
     }
 
     // FIXME: ipfs sort order is weird, it always puts references
@@ -316,17 +322,13 @@ void to_json(nlohmann::json& j, const PathReferences<StorePath> & references)
     };
 }
 
-void from_json(const nlohmann::json& j, PathReferences<StorePath> & references)
+template<typename T>
+void from_json(const nlohmann::json& j, PathReferences<T> & references)
 {
-    StorePathSet refs;
-    for (auto & ref : j.at("references")) {
-        auto name = ref.at("name").get<std::string>();
-        auto cid = ref.at("cid").at("/").get<std::string>();
-        if (cid.substr(0, 9) != "f01711114")
-            throw Error("cid '%s' is wrong type for ipfs hash", cid);
-        auto hash = Hash::parseAny(cid.substr(9), htSHA1);
-        refs.insert(StorePath(hash, name));
-    }
+	std::vector<T> raw;
+	nlohmann::from_json(j.at("references"), raw);
+	std::set refs;
+	std::copy(raw, refs);
     references = PathReferences<StorePath> {
         .references = refs,
         .hasSelfReference = j.at("zhasSelfReference").get<bool>(),
diff --git a/src/libstore/content-address.hh b/src/libstore/content-address.hh
index 7d8d9e733f1..ed9fbe534d8 100644
--- a/src/libstore/content-address.hh
+++ b/src/libstore/content-address.hh
@@ -1,10 +1,10 @@
 #pragma once
 
 #include <nlohmann/json.hpp>
-#include <memory>
 #include <variant>
 
 #include "hash.hh"
+#include "ipfs.hh"
 #include "path.hh"
 
 namespace nix {
@@ -31,15 +31,8 @@ struct FixedOutputHash {
     std::string printMethodAlgo() const;
 };
 
-// Deref is a phantom parameter that just signifies what the hash should
-// dereference too.
-template<typename Deref>
-struct IPFSHash {
-    Hash hash;
-};
-
 template<template <typename> class Ref>
-struct IPFSGitTreeNodeT;
+struct IPFSGitTreeNode;
 
 /*
   We've accumulated several types of content-addressed paths over the years;
@@ -55,7 +48,7 @@ struct IPFSGitTreeNodeT;
 typedef std::variant<
     TextHash, // for paths computed by makeTextPath() / addTextToStore
     FixedOutputHash, // for path computed by makeFixedOutputPath
-    IPFSHash<IPFSGitTreeNodeT<IPFSHash>>
+    IPFSHash<IPFSGitTreeNode<IPFSHash>>
 > LegacyContentAddress;
 
 /* Compute the prefix to the hash algorithm which indicates how the files were
@@ -150,29 +143,17 @@ template<typename Underlying>
 struct ContentAddressT;
 
 template<template <typename> class Ref>
-struct IPFSGitTreeNodeT {
+struct IPFSGitTreeNode {
 	Hash gitTree;
     // References for the paths
-    PathReferences<ContentAddressT<Ref<IPFSGitTreeNodeT<Ref>>>> references;
-};
-
-typedef IPFSGitTreeNodeT<IPFSHash> IPFSGitTreeNode;
-
-/* The point of this is to store data that hasn't yet been put in IPFS
-   so we don't have a dangling hash. If someday Nix was more integrated
-   with IPFS such that it always had at least IPFS offline/local
-   storage, we wouldn't need this. */
-template<typename Deref>
-struct IPFSHashWithOptValue : IPFSHash<Deref> {
-	// N.B. shared_ptr is nullable
-    std::shared_ptr<Deref> value;
+    PathReferences<ContentAddressT<Ref<IPFSGitTreeNode<Ref>>>> references;
 };
 
 // FIXME names
 typedef std::variant<
     TextInfo,
     FixedOutputInfo,
-    IPFSHashWithOptValue<IPFSGitTreeNodeT<IPFSHashWithOptValue>>
+    IPFSHashWithOptValue<IPFSGitTreeNode<IPFSHashWithOptValue>>
 > ContentAddressWithoutName;
 
 template<typename Underlying>
@@ -193,10 +174,17 @@ std::string renderContentAddress(ContentAddress ca);
 
 ContentAddress parseContentAddress(std::string_view rawCa);
 
-void to_json(nlohmann::json& j, const ContentAddress & c);
-void from_json(const nlohmann::json& j, ContentAddress & c);
+template<template <typename> class Ref>
+void to_json(nlohmann::json& j, const IPFSGitTreeNode<Ref> & c);
+template<template <typename> class Ref>
+void from_json(const nlohmann::json& j, IPFSGitTreeNode<Ref> & c);
+
+void to_json(nlohmann::json& j, const IPFSHash<IPFSGitTreeNode<IPFSHash>> & c);
+void from_json(const nlohmann::json& j, IPFSHash<IPFSGitTreeNode<IPFSHash>> & c);
 
-void to_json(nlohmann::json& j, const PathReferences<StorePath> & c);
-void from_json(const nlohmann::json& j, PathReferences<StorePath> & c);
+template<typename T>
+void to_json(nlohmann::json& j, const PathReferences<T> & c);
+template<typename T>
+void from_json(const nlohmann::json& j, PathReferences<T> & c);
 
 }
diff --git a/src/nix/make-content-addressable.cc b/src/nix/make-content-addressable.cc
index b2de20d1555..971b2922314 100644
--- a/src/nix/make-content-addressable.cc
+++ b/src/nix/make-content-addressable.cc
@@ -46,7 +46,7 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
 
         std::reverse(paths.begin(), paths.end());
 
-        std::map<StorePath, StorePath> remappings;
+        std::map<StorePath, ContentAddress> remappings;
 
         auto jsonRoot = json ? std::make_unique<JSONObject>(std::cout) : nullptr;
         auto jsonRewrites = json ? std::make_unique<JSONObject>(jsonRoot->object("rewrites")) : nullptr;
@@ -61,15 +61,21 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
 
             StringMap rewrites;
 
-            PathReferences<StorePath> refs;
-            refs.hasSelfReference = oldInfo->hasSelfReference;
+            bool hasSelfReference = oldInfo->hasSelfReference;
+            std::set<StorePath> refPaths;
+            std::set<ContentAddress> refCAs;
             for (auto & ref : oldInfo->references) {
                 auto i = remappings.find(ref);
-                auto replacement = i != remappings.end() ? i->second : ref;
+                auto replacement = i != remappings.end()
+                    ? store->makeFixedOutputPathFromCA(i->second)
+                    : ref;
                 // FIXME: warn about unremapped paths?
                 if (replacement != ref)
                     rewrites.insert_or_assign(store->printStorePath(ref), store->printStorePath(replacement));
-                refs.references.insert(std::move(replacement));
+                if (i != remappings.end())
+                    refCAs.insert(i->second);
+                else
+                    refPaths.insert(ref);
             }
 
             *sink.s = rewriteStrings(*sink.s, rewrites);
@@ -100,22 +106,50 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
                 }
             }
 
+            ContentAddressWithoutName ca = ipfsContent
+                ? ContentAddressWithoutName {
+                    IPFSHashWithOptValue<IPFSGitTreeNode<IPFSHashWithOptValue>>::fromValue({
+                        .gitTree = *gitHash,
+                        { {}, hasSelfReference },
+                    })
+                }
+                : ContentAddressWithoutName {
+                    FixedOutputInfo {
+                        {
+                             .method = FileIngestionMethod::Recursive,
+                             .hash = narHash,
+                        },
+                        { {}, hasSelfReference },
+                    }
+                };
+
+            if (ipfsContent) {
+                auto & refs = std::get<IPFSHashWithOptValue<IPFSGitTreeNode<IPFSHashWithOptValue>>>(ca).value->references;
+                //refs.hasSelfReference = hasSelfReference;
+                if (refPaths.size() > 0)
+                    throw UsageError("IPFS+Git store paths must not have non-CA references");
+                for (auto & ca2 : refCAs) {
+                    auto p = std::get_if<2>(&ca2.info);
+                    if (!p) throw UsageError("IPFS+Git store paths must only have IPFS+Git references");
+                    refs.references.insert({
+                        .name = ca2.name,
+                        .info = *p
+                    });
+                }
+            } else {
+                auto & refs = std::get<FixedOutputInfo>(ca).references;
+                //refs.hasSelfReference = hasSelfReference;
+                for (auto & p : refPaths)
+                    refs.references.insert(p);
+                for (auto & ca : refCAs)
+                    refs.references.insert(store->makeFixedOutputPathFromCA(ca));
+            };
+
             ValidPathInfo info {
                 *store,
                 ContentAddress {
                     .name = std::string { path.name() },
-                    .info = ipfsContent ?
-                      ContentAddressWithoutName {IPFSInfo {
-                          { .hash = *gitHash },
-                          std::move(refs),
-                      }}
-                    : ContentAddressWithoutName {FixedOutputInfo {
-                          {
-                              .method = FileIngestionMethod::Recursive,
-                              .hash = narHash,
-                          },
-                          std::move(refs),
-                      }},
+                    .info = ca,
                 },
             };
             info.narHash = narHash;
@@ -135,7 +169,7 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
             if (json)
                 jsonRewrites->attr(store->printStorePath(path), store->printStorePath(info.path));
 
-            remappings.insert_or_assign(std::move(path), std::move(info.path));
+            remappings.insert_or_assign(std::move(path), info.fullContentAddressOpt().value());
         }
     }
 };

From b6249fba0ee9647f6f0ed4b995e2f6ca5a58f001 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Tue, 7 Jul 2020 16:03:40 +0000
Subject: [PATCH 05/13] Add missing header

---
 src/libutil/ipfs.hh | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 src/libutil/ipfs.hh

diff --git a/src/libutil/ipfs.hh b/src/libutil/ipfs.hh
new file mode 100644
index 00000000000..3cf1f48e887
--- /dev/null
+++ b/src/libutil/ipfs.hh
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+
+#include "hash.hh"
+
+namespace nix {
+
+// Deref is a phantom parameter that just signifies what the hash should
+// dereference too.
+template<typename Deref>
+struct IPFSHash {
+    Hash hash;
+};
+
+/* The point of this is to store data that hasn't yet been put in IPFS
+   so we don't have a dangling hash. If someday Nix was more integrated
+   with IPFS such that it always had at least IPFS offline/local
+   storage, we wouldn't need this. */
+template<typename Deref>
+struct IPFSHashWithOptValue : IPFSHash<Deref> {
+	// N.B. shared_ptr is nullable
+    std::shared_ptr<Deref> value = nullptr;
+
+	// Will calculate and store hash from value
+    static IPFSHashWithOptValue fromValue(Deref value);
+};
+
+}

From 842dd4f3fd6221a50f516268271acd5b724f8631 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Wed, 8 Jul 2020 17:13:17 +0000
Subject: [PATCH 06/13] Use `IPFSGitTreeNode` typedef after all

---
 src/libstore/content-address.hh     | 20 +++++++++++---------
 src/nix/make-content-addressable.cc |  4 ++--
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/libstore/content-address.hh b/src/libstore/content-address.hh
index ed9fbe534d8..ada09abc906 100644
--- a/src/libstore/content-address.hh
+++ b/src/libstore/content-address.hh
@@ -32,7 +32,9 @@ struct FixedOutputHash {
 };
 
 template<template <typename> class Ref>
-struct IPFSGitTreeNode;
+struct IPFSGitTreeNodeT;
+
+typedef IPFSGitTreeNodeT<IPFSHashWithOptValue> IPFSGitTreeNode;
 
 /*
   We've accumulated several types of content-addressed paths over the years;
@@ -48,7 +50,7 @@ struct IPFSGitTreeNode;
 typedef std::variant<
     TextHash, // for paths computed by makeTextPath() / addTextToStore
     FixedOutputHash, // for path computed by makeFixedOutputPath
-    IPFSHash<IPFSGitTreeNode<IPFSHash>>
+    IPFSHash<IPFSGitTreeNode>
 > LegacyContentAddress;
 
 /* Compute the prefix to the hash algorithm which indicates how the files were
@@ -143,17 +145,17 @@ template<typename Underlying>
 struct ContentAddressT;
 
 template<template <typename> class Ref>
-struct IPFSGitTreeNode {
+struct IPFSGitTreeNodeT {
 	Hash gitTree;
     // References for the paths
-    PathReferences<ContentAddressT<Ref<IPFSGitTreeNode<Ref>>>> references;
+    PathReferences<ContentAddressT<Ref<IPFSGitTreeNodeT<Ref>>>> references;
 };
 
 // FIXME names
 typedef std::variant<
     TextInfo,
     FixedOutputInfo,
-    IPFSHashWithOptValue<IPFSGitTreeNode<IPFSHashWithOptValue>>
+    IPFSHashWithOptValue<IPFSGitTreeNode>
 > ContentAddressWithoutName;
 
 template<typename Underlying>
@@ -175,12 +177,12 @@ std::string renderContentAddress(ContentAddress ca);
 ContentAddress parseContentAddress(std::string_view rawCa);
 
 template<template <typename> class Ref>
-void to_json(nlohmann::json& j, const IPFSGitTreeNode<Ref> & c);
+void to_json(nlohmann::json& j, const IPFSGitTreeNodeT<Ref> & c);
 template<template <typename> class Ref>
-void from_json(const nlohmann::json& j, IPFSGitTreeNode<Ref> & c);
+void from_json(const nlohmann::json& j, IPFSGitTreeNodeT<Ref> & c);
 
-void to_json(nlohmann::json& j, const IPFSHash<IPFSGitTreeNode<IPFSHash>> & c);
-void from_json(const nlohmann::json& j, IPFSHash<IPFSGitTreeNode<IPFSHash>> & c);
+void to_json(nlohmann::json& j, const IPFSHash<IPFSGitTreeNode> & c);
+void from_json(const nlohmann::json& j, IPFSHash<IPFSGitTreeNode> & c);
 
 template<typename T>
 void to_json(nlohmann::json& j, const PathReferences<T> & c);
diff --git a/src/nix/make-content-addressable.cc b/src/nix/make-content-addressable.cc
index 971b2922314..fc16346711e 100644
--- a/src/nix/make-content-addressable.cc
+++ b/src/nix/make-content-addressable.cc
@@ -108,7 +108,7 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
 
             ContentAddressWithoutName ca = ipfsContent
                 ? ContentAddressWithoutName {
-                    IPFSHashWithOptValue<IPFSGitTreeNode<IPFSHashWithOptValue>>::fromValue({
+                    IPFSHashWithOptValue<IPFSGitTreeNode>::fromValue({
                         .gitTree = *gitHash,
                         { {}, hasSelfReference },
                     })
@@ -124,7 +124,7 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
                 };
 
             if (ipfsContent) {
-                auto & refs = std::get<IPFSHashWithOptValue<IPFSGitTreeNode<IPFSHashWithOptValue>>>(ca).value->references;
+                auto & refs = std::get<IPFSHashWithOptValue<IPFSGitTreeNode>>(ca).value->references;
                 //refs.hasSelfReference = hasSelfReference;
                 if (refPaths.size() > 0)
                     throw UsageError("IPFS+Git store paths must not have non-CA references");

From e723ced26d7fdd3941cb8a38df8df60d29ed280d Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Wed, 8 Jul 2020 23:14:06 +0000
Subject: [PATCH 07/13] remove cid commands

ensure-ca and path-info will do, soon
---
 src/nix/ipfs.cc | 69 -------------------------------------------------
 1 file changed, 69 deletions(-)
 delete mode 100644 src/nix/ipfs.cc

diff --git a/src/nix/ipfs.cc b/src/nix/ipfs.cc
deleted file mode 100644
index 0d2fb57a159..00000000000
--- a/src/nix/ipfs.cc
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "command.hh"
-#include "store-api.hh"
-#include "content-address.hh"
-
-using namespace nix;
-
-struct CmdEnsureCid : StoreCommand
-{
-    std::string cid;
-    std::string name;
-
-    CmdEnsureCid()
-    {
-        expectArg("cid", &cid);
-        expectArg("name", &name);
-    }
-
-    std::string description() override
-    {
-        return "put the cid into the store";
-    }
-
-    Category category() override { return catUtility; }
-
-    void run(ref<Store> store) override
-    {
-        ContentAddress ca {
-            .name = name,
-            .info = IPFSCid {
-                .cid = cid
-            }
-        };
-
-        store->ensurePath(ca);
-
-        std::cout
-            << store->printStorePath(store->makeFixedOutputPathFromCA(ca))
-            << std::endl;
-    }
-};
-
-static auto r1 = registerCommand<CmdEnsureCid>("ensure-cid");
-
-struct CmdGetCid : StorePathsCommand
-{
-    CmdGetCid()
-    {
-    }
-
-    std::string description() override
-    {
-        return "get the cid of a path";
-    }
-
-    Category category() override { return catUtility; }
-
-    void run(ref<Store> store, std::vector<StorePath> storePaths) override
-    {
-        for (auto & storePath : storePaths) {
-            auto info = store->queryPathInfo(storePath)->fullContentAddressOpt();
-            if (!info)
-                throw Error("path '%s' is not content addressed", store->printStorePath(storePath));
-            auto cid = computeIPFSCid(*info);
-            std::cout << cid << std::endl;
-        }
-    }
-};
-
-static auto r2 = registerCommand<CmdGetCid>("get-cid");

From caac4c4a59b2a5766308bc00d2236710867d6df7 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 9 Jul 2020 00:32:19 +0000
Subject: [PATCH 08/13] Make ipfs.cc with bigger definitions

---
 src/libutil/ipfs.cc | 59 +++++++++++++++++++++++++++++++++++++++++++++
 src/libutil/ipfs.hh | 42 +++++++++++++++++---------------
 2 files changed, 82 insertions(+), 19 deletions(-)
 create mode 100644 src/libutil/ipfs.cc

diff --git a/src/libutil/ipfs.cc b/src/libutil/ipfs.cc
new file mode 100644
index 00000000000..c0c8f8185e8
--- /dev/null
+++ b/src/libutil/ipfs.cc
@@ -0,0 +1,59 @@
+#include "ipfs.hh"
+
+namespace nix::untyped {
+
+// "f01711220" base-16, sha-256
+// "f01781114" base-16, sha-1
+
+std::string toString(Hash hash) const {
+    std::string prefix;
+    switch (hash.type) {
+    case htSHA1: prefix = "f01711220";
+    case htSHA256: prefix = "f01781114";
+    default: throw Error("hash type '%s' we don't yet export to IPFS", printHashType(hash.type));
+    }
+    return prefix + hash.to_string(Base16, false);
+}
+
+IPFSHash<Deref> fromString(std::string_view cid) {
+    auto prefix = cid.substr(0, 9);
+    HashType algo = prefix == "f01711220" ? htSHA256
+        : prefix == "f01781114" ? htSHA1
+        : throw Error("cid '%s' is wrong type for ipfs hash", cid);
+    return IPFSHash<Deref> {
+        .hash = Hash::parseNonSRIUnprefixed(cid.substr(9), algo),
+    };
+}
+
+static HashType getMultiHashTag(int tag)
+{
+    switch (tag) {
+    case 0x11: {
+        return htSHA1;
+    }
+    case 0x12: {
+        return htSHA256;
+    }
+    default: {
+        throw Error("tag '%i' is an unknown hash type", tag);
+    }
+    }
+}
+
+nlohmann::json pack(Hash hash) const {
+{
+	auto cid = to_string();
+    std::vector<uint8_t> result;
+    assert(cid[0] == 'f');
+    result.push_back(0x00);
+    result.push_back(std::stoi(cid.substr(1, 2), nullptr, 16));
+    result.push_back(std::stoi(cid.substr(3, 2), nullptr, 16));
+    result.push_back(std::stoi(cid.substr(5, 2), nullptr, 16));
+    result.push_back(std::stoi(cid.substr(7, 2), nullptr, 16));
+    HashType ht = getMultiHashTag(std::stoi(cid.substr(5, 2), nullptr, 16));
+    Hash hash = Hash::parseAny(cid.substr(9), ht);
+    for (unsigned int i = 0; i < hash.hashSize; i++)
+        result.push_back(hash.hash[i]);
+    return result;
+}
+
diff --git a/src/libutil/ipfs.hh b/src/libutil/ipfs.hh
index 1df80e329c1..6c200456337 100644
--- a/src/libutil/ipfs.hh
+++ b/src/libutil/ipfs.hh
@@ -14,6 +14,14 @@ struct IPFSHash {
     Hash hash;
     std::string to_string() const;
     static IPFSHash<Deref> from_string(std::string_view cid);
+    std::vector<uint8_t> pack() const;
+    nlohmann::json packForCBor() const;
+};
+
+namespace untyped {
+	std::string toString(Hash);
+	Hash fromString(std::string_view);
+    std::vector<uint8_t>pack(Hash);
 };
 
 /* The point of this is to store data that hasn't yet been put in IPFS
@@ -29,36 +37,32 @@ struct IPFSHashWithOptValue : IPFSHash<Deref> {
     static IPFSHashWithOptValue fromValue(Deref value);
 };
 
-// "f01711220" base-16, sha-256
-// "f01781114" base-16, sha-1
-
 template<typename Deref>
 std::string IPFSHash<Deref>::to_string() const {
-    std::string prefix;
-    switch (hash.type) {
-    case htSHA1: prefix = "f01711220";
-    case htSHA256: prefix = "f01781114";
-    default: throw Error("hash type '%s' we don't yet export to IPFS", printHashType(hash.type));
-    }
-    return prefix + hash.to_string(Base16, false);
+    return untyped::toString(hash);
 }
 
 template<typename Deref>
 IPFSHash<Deref> IPFSHash<Deref>::from_string(std::string_view cid) {
-    auto prefix = cid.substr(0, 9);
-    HashType algo = prefix == "f01711220" ? htSHA256
-        : prefix == "f01781114" ? htSHA1
-        : throw Error("cid '%s' is wrong type for ipfs hash", cid);
-    return IPFSHash<Deref> {
-        .hash = Hash::parseNonSRIUnprefixed(cid.substr(9), algo),
-    };
+	return IPFSHash<Deref> {
+		.hash = untyped::fromString(cid)
+	};
+}
+
+template<typename Deref>
+std::vector<uint8_t> IPFSHash<Deref>::pack() const {
+	return untyped::pack(hash);
+}
+
+template<typename Deref>
+nlohmann::json IPFSHash<Deref>::packForCBor() const {
+    return nlohmann::json::binary(pack(), 42);
 }
 
 template<typename Deref>
 void to_json(nlohmann::json& j, const IPFSHash<Deref> & c) {
-    std::string s = c.to_string();
     j = nlohmann::json {
-        { "/", s },
+        { "/", c.to_string() },
     };
 }
 

From 17e267de93fff981c9b4f247c7cea99cf7e0c492 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 9 Jul 2020 00:32:44 +0000
Subject: [PATCH 09/13] WIP on store-api

---
 src/libstore/store-api.cc | 107 +++++++++++---------------------------
 src/libstore/store-api.hh |   3 +-
 2 files changed, 30 insertions(+), 80 deletions(-)

diff --git a/src/libstore/store-api.cc b/src/libstore/store-api.cc
index 272a1f2613d..ae532ac846e 100644
--- a/src/libstore/store-api.cc
+++ b/src/libstore/store-api.cc
@@ -215,74 +215,29 @@ StorePath Store::makeTextPath(std::string_view name, const TextInfo & info) cons
         name);
 }
 
-static HashType getMultiHashTag(int tag)
+// FIXME move to content-address.cc
+Hash computeIPFSHash(const IPFSGitTreeNode & info)
 {
-    switch (tag) {
-    case 0x11: {
-        return htSHA1;
-    }
-    case 0x12: {
-        return htSHA256;
-    }
-    default: {
-        throw Error("tag '%i' is an unknown hash type", tag);
-    }
-    }
-}
+    nlohmann::json j { info };
 
-static std::vector<uint8_t> packMultihash(std::string cid)
-{
-    std::vector<uint8_t> result;
-    assert(cid[0] == 'f');
-    result.push_back(0x00);
-    result.push_back(std::stoi(cid.substr(1, 2), nullptr, 16));
-    result.push_back(std::stoi(cid.substr(3, 2), nullptr, 16));
-    result.push_back(std::stoi(cid.substr(5, 2), nullptr, 16));
-    result.push_back(std::stoi(cid.substr(7, 2), nullptr, 16));
-    HashType ht = getMultiHashTag(std::stoi(cid.substr(5, 2), nullptr, 16));
-    Hash hash = Hash::parseAny(cid.substr(9), ht);
-    for (unsigned int i = 0; i < hash.hashSize; i++)
-        result.push_back(hash.hash[i]);
-    return result;
-}
-
-Hash computeIPFSHash(const ContentAddress & info, HashType ht)
-{
-    nlohmann::json j = info;
+    auto pack = [&](auto & ref) {
+        ref = ref.get<IPFSHash<IPFSGitTreeNode>>().packForCBOR();
+	};
 
     // replace {"/": ...} with packed multihash
     // ipfs converts automatically between the two
-    j.at("cid") = nlohmann::json::binary(packMultihash(j.at("cid").at("/").get<std::string>()), 42);
+    pack(j.at("gitTree"));
     for (auto & ref : j.at("references").at("references"))
-        ref.at("cid") = nlohmann::json::binary(packMultihash(ref.at("cid").at("/").get<std::string>()), 42);
+        pack(ref);
 
     std::vector<std::uint8_t> cbor = nlohmann::json::to_cbor(j);
-    return hashString(ht, std::string(cbor.begin(), cbor.end()));
+    return hashString(htSHA256, std::string(cbor.begin(), cbor.end()));
 }
 
-std::string computeIPFSCid(const ContentAddress & info)
+StorePath Store::makeIPFSPath(std::string_view name, IPFSHash<IPFSGitTreeNode> hash) const
 {
-    return "f01711220" + computeIPFSHash(info, htSHA256).to_string(Base16, false);
-}
-
-StorePath Store::makeIPFSPath(IPFSHash<IPFSGitTreeNode> ref) const
-{
-    string type = "ipfs";
-
-    // copy pase from makeStorePath
-    string s = type + ":" + ref.first + ":" + storeDir + ":" + std::string(ref.second);
-    auto h = compressHash(hashString(htSHA256, s), 20);
-    return StorePath(h, ref.second);
-}
-
-StorePath Store::makeIPFSPath(std::string cid, std::string name) const
-{
-    return makeIPFSPath(IPFSHash<IPFSGitTreeNode>(cid, name));
-}
-
-StorePath Store::makeIPFSPath(const ContentAddress & info) const
-{
-    return makeIPFSPath(computeIPFSCid(info), info.name);
+	// `to_string` use IPFS-style multi* encoding for forward-compat.
+    return makeStorePath("ipfs-git", hash.hash, name);
 }
 
 StorePath Store::makeFixedOutputPathFromCA(const ContentAddress & info) const
@@ -295,12 +250,9 @@ StorePath Store::makeFixedOutputPathFromCA(const ContentAddress & info) const
         [&](FixedOutputInfo foi) {
             return makeFixedOutputPath(info.name, foi);
         },
-        [&](IPFSInfo io) {
-            return makeIPFSPath(info);
+        [&](IPFSHash<IPFSGitTreeNode> ih) {
+            return makeIPFSPath(info.name, ih);
         },
-        [&](IPFSCid ic) {
-            return makeIPFSPath(ic.cid, info.name);
-        }
     }, info.info);
 }
 
@@ -974,21 +926,17 @@ std::optional<ContentAddress> ValidPathInfo::fullContentAddressOpt() const
                 TextInfo info { th };
                 assert(!hasSelfReference);
                 info.references = references;
-                return std::variant<TextInfo, FixedOutputInfo, IPFSInfo, IPFSCid> { info };
+                return ContentAddressWithoutName { info };
             },
             [&](FixedOutputHash foh) {
                 FixedOutputInfo info { foh };
                 info.references = static_cast<PathReferences<StorePath>>(*this);
-                return std::variant<TextInfo, FixedOutputInfo, IPFSInfo, IPFSCid> { info };
+                return ContentAddressWithoutName { info };
             },
-            [&](IPFSHash io) {
-                IPFSInfo info { .hash = io.hash };
-                info.references.hasSelfReference = this->hasSelfReference;
-                for (auto & ref : this->references) {
-                    auto ca = *store.queryPathInfo(ref)->fullContentAddressOpt();
-                    info.references.references.insert(IPFSHash<IPFSGitTreeNode>(computeIPFSCid(ca), ref.name()));
-                }
-                return std::variant<TextInfo, FixedOutputInfo, IPFSInfo, IPFSCid> { info };
+            [&](IPFSHash<IPFSGitTreeNode> io) {
+                return ContentAddressWithoutName {
+                    IPFSHashWithOptValue { io },
+                };
             },
         }, *ca),
     };
@@ -1053,13 +1001,16 @@ ValidPathInfo::ValidPathInfo(
             *(static_cast<PathReferences<StorePath> *>(this)) = foi.references;
             this->ca = FixedOutputHash { (FixedOutputHash) std::move(foi) };
         },
-        [this, &store](IPFSInfo foi) {
-            this->hasSelfReference = foi.references.hasSelfReference;
-            for (auto & ref : foi.references.references)
-                this->references.insert(store.makeIPFSPath(ref));
-            this->ca = IPFSHash { foi.hash };
+        [this, &store](IPFSHashWithOptValue<IPFSGitTreeNode> ih) {
+            this->ca = IPFSHash { ih };
+            if (ih.value) {
+                this->hasSelfReference = ih.value->references.hasSelfReference;
+                for (auto & ref : ih.value->references.references)
+                    this->references.insert(store.makeIPFSPath(ref));
+            }
         },
-        [](IPFSCid foi) {
+        [](IPFSHash< foi) {
+            this->ca = IPFSHash { foi.hash };
             throw Error("cannot make a valid path from a cid");
         },
     }, std::move(info.info));
diff --git a/src/libstore/store-api.hh b/src/libstore/store-api.hh
index 2c830456884..2222be93095 100644
--- a/src/libstore/store-api.hh
+++ b/src/libstore/store-api.hh
@@ -771,8 +771,7 @@ std::pair<std::string, Store::Params> splitUriAndParams(const std::string & uri)
 
 std::optional<ContentAddress> getDerivationCA(const BasicDerivation & drv);
 
-Hash computeIPFSHash(const ContentAddress & info);
-std::string computeIPFSCid(const ContentAddress & info);
+Hash computeIPFSHash(const IPFSGitTreeNode & info);
 
 
 }

From 2da7fec3a34d9c8c7fc37c2ec404a58b96be64f2 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 9 Jul 2020 16:05:49 +0000
Subject: [PATCH 10/13] Get store-api.cc building

---
 src/libstore/store-api.cc | 12 ++++--------
 src/libutil/ipfs.hh       |  4 ++--
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/libstore/store-api.cc b/src/libstore/store-api.cc
index ae532ac846e..2a3b1ba3ec2 100644
--- a/src/libstore/store-api.cc
+++ b/src/libstore/store-api.cc
@@ -221,7 +221,7 @@ Hash computeIPFSHash(const IPFSGitTreeNode & info)
     nlohmann::json j { info };
 
     auto pack = [&](auto & ref) {
-        ref = ref.get<IPFSHash<IPFSGitTreeNode>>().packForCBOR();
+        ref = ref.template get<IPFSHash<IPFSGitTreeNode>>().packForCBOR();
 	};
 
     // replace {"/": ...} with packed multihash
@@ -935,7 +935,7 @@ std::optional<ContentAddress> ValidPathInfo::fullContentAddressOpt() const
             },
             [&](IPFSHash<IPFSGitTreeNode> io) {
                 return ContentAddressWithoutName {
-                    IPFSHashWithOptValue { io },
+                    IPFSHashWithOptValue<IPFSGitTreeNode> { io },
                 };
             },
         }, *ca),
@@ -1002,17 +1002,13 @@ ValidPathInfo::ValidPathInfo(
             this->ca = FixedOutputHash { (FixedOutputHash) std::move(foi) };
         },
         [this, &store](IPFSHashWithOptValue<IPFSGitTreeNode> ih) {
-            this->ca = IPFSHash { ih };
+            this->ca = static_cast<IPFSHash<IPFSGitTreeNode>>(ih);
             if (ih.value) {
                 this->hasSelfReference = ih.value->references.hasSelfReference;
                 for (auto & ref : ih.value->references.references)
-                    this->references.insert(store.makeIPFSPath(ref));
+                    this->references.insert(store.makeIPFSPath(ref.name, ref.info));
             }
         },
-        [](IPFSHash< foi) {
-            this->ca = IPFSHash { foi.hash };
-            throw Error("cannot make a valid path from a cid");
-        },
     }, std::move(info.info));
 }
 
diff --git a/src/libutil/ipfs.hh b/src/libutil/ipfs.hh
index 6c200456337..e693c4a5599 100644
--- a/src/libutil/ipfs.hh
+++ b/src/libutil/ipfs.hh
@@ -15,7 +15,7 @@ struct IPFSHash {
     std::string to_string() const;
     static IPFSHash<Deref> from_string(std::string_view cid);
     std::vector<uint8_t> pack() const;
-    nlohmann::json packForCBor() const;
+    nlohmann::json packForCBOR() const;
 };
 
 namespace untyped {
@@ -55,7 +55,7 @@ std::vector<uint8_t> IPFSHash<Deref>::pack() const {
 }
 
 template<typename Deref>
-nlohmann::json IPFSHash<Deref>::packForCBor() const {
+nlohmann::json IPFSHash<Deref>::packForCBOR() const {
     return nlohmann::json::binary(pack(), 42);
 }
 

From 4eb4d42b9bc3d6b5868aebb00b0745ef1f0c37f8 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 9 Jul 2020 17:07:19 +0000
Subject: [PATCH 11/13] Get ipfs.cc building

---
 src/libutil/ipfs.cc | 30 ++++++------------------------
 src/libutil/ipfs.hh |  2 +-
 2 files changed, 7 insertions(+), 25 deletions(-)

diff --git a/src/libutil/ipfs.cc b/src/libutil/ipfs.cc
index c0c8f8185e8..d628760b9b9 100644
--- a/src/libutil/ipfs.cc
+++ b/src/libutil/ipfs.cc
@@ -5,7 +5,7 @@ namespace nix::untyped {
 // "f01711220" base-16, sha-256
 // "f01781114" base-16, sha-1
 
-std::string toString(Hash hash) const {
+std::string toString(Hash hash) {
     std::string prefix;
     switch (hash.type) {
     case htSHA1: prefix = "f01711220";
@@ -15,34 +15,17 @@ std::string toString(Hash hash) const {
     return prefix + hash.to_string(Base16, false);
 }
 
-IPFSHash<Deref> fromString(std::string_view cid) {
+Hash fromString(std::string_view cid) {
     auto prefix = cid.substr(0, 9);
     HashType algo = prefix == "f01711220" ? htSHA256
         : prefix == "f01781114" ? htSHA1
         : throw Error("cid '%s' is wrong type for ipfs hash", cid);
-    return IPFSHash<Deref> {
-        .hash = Hash::parseNonSRIUnprefixed(cid.substr(9), algo),
-    };
+    return Hash::parseNonSRIUnprefixed(cid.substr(9), algo);
 }
 
-static HashType getMultiHashTag(int tag)
+std::vector<uint8_t> pack(Hash hash)
 {
-    switch (tag) {
-    case 0x11: {
-        return htSHA1;
-    }
-    case 0x12: {
-        return htSHA256;
-    }
-    default: {
-        throw Error("tag '%i' is an unknown hash type", tag);
-    }
-    }
-}
-
-nlohmann::json pack(Hash hash) const {
-{
-	auto cid = to_string();
+	auto cid = toString(hash);
     std::vector<uint8_t> result;
     assert(cid[0] == 'f');
     result.push_back(0x00);
@@ -50,10 +33,9 @@ nlohmann::json pack(Hash hash) const {
     result.push_back(std::stoi(cid.substr(3, 2), nullptr, 16));
     result.push_back(std::stoi(cid.substr(5, 2), nullptr, 16));
     result.push_back(std::stoi(cid.substr(7, 2), nullptr, 16));
-    HashType ht = getMultiHashTag(std::stoi(cid.substr(5, 2), nullptr, 16));
-    Hash hash = Hash::parseAny(cid.substr(9), ht);
     for (unsigned int i = 0; i < hash.hashSize; i++)
         result.push_back(hash.hash[i]);
     return result;
 }
 
+}
diff --git a/src/libutil/ipfs.hh b/src/libutil/ipfs.hh
index e693c4a5599..6b2d1aac18c 100644
--- a/src/libutil/ipfs.hh
+++ b/src/libutil/ipfs.hh
@@ -21,7 +21,7 @@ struct IPFSHash {
 namespace untyped {
 	std::string toString(Hash);
 	Hash fromString(std::string_view);
-    std::vector<uint8_t>pack(Hash);
+    std::vector<uint8_t> pack(Hash);
 };
 
 /* The point of this is to store data that hasn't yet been put in IPFS

From 3cb966ad47b25151f783b20413830ac4be992795 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 9 Jul 2020 17:58:29 +0000
Subject: [PATCH 12/13] Tiny step towards getting the IPFS store to compile

---
 src/libstore/ipfs-binary-cache-store.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/libstore/ipfs-binary-cache-store.cc b/src/libstore/ipfs-binary-cache-store.cc
index 270e8c59f83..ab0c67d8aee 100644
--- a/src/libstore/ipfs-binary-cache-store.cc
+++ b/src/libstore/ipfs-binary-cache-store.cc
@@ -511,7 +511,7 @@ std::optional<std::string> IPFSBinaryCacheStore::getCidFromCA(ContentAddress ca)
             assert(ca_.hash.type == htSHA1);
             return "f01781114" + ca_.hash.to_string(Base16, false);
         }
-    } else if (std::holds_alternative<IPFSInfo>(ca.info))
+    } else if (std::holds_alternative<IPFSHashWithOptValue<IPFSGitTreeNode>>(ca.info))
         return computeIPFSCid(ca);
     else if (std::holds_alternative<IPFSCid>(ca.info))
         return std::get<IPFSCid>(ca.info).cid;
@@ -655,7 +655,7 @@ void IPFSBinaryCacheStore::addToStore(const ValidPathInfo & info, Source & narSo
 
             return;
         }
-    } else if (info.ca && std::holds_alternative<IPFSHash>(*info.ca)) {
+    } else if (info.ca && std::holds_alternative<IPFSHash<IPSFGitTreeNode>>(*info.ca)) {
         auto nar = make_ref<std::string>(narSource.drain());
 
         AutoDelete tmpDir(createTempDir(), true);

From 76540c93d8fa53efafb44bc8764fe7d6a1c63751 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Thu, 9 Jul 2020 19:01:03 +0000
Subject: [PATCH 13/13] Everything compiles!

Just some link errors for knowingly-missing functions
---
 src/libstore/ipfs-binary-cache-store.cc | 32 ++++++++++---------------
 1 file changed, 13 insertions(+), 19 deletions(-)

diff --git a/src/libstore/ipfs-binary-cache-store.cc b/src/libstore/ipfs-binary-cache-store.cc
index 69aa089743b..854c15c1e7a 100644
--- a/src/libstore/ipfs-binary-cache-store.cc
+++ b/src/libstore/ipfs-binary-cache-store.cc
@@ -663,27 +663,21 @@ void IPFSBinaryCacheStore::addToStore(const ValidPathInfo & info, Source & narSo
         auto key = ipfsCidFormatBase16(addGit((Path) tmpDir + "/tmp", std::string(info.path.hashPart())));
         assert(std::string(key, 0, 9) == "f01781114");
 
-        IPFSInfo caWithRefs { .hash = Hash::parseAny(std::string(key, 9), htSHA1) };
-        caWithRefs.references.hasSelfReference = info.hasSelfReference;
-        for (auto & ref : info.references)
-            caWithRefs.references.references.insert(IPFSRef {
-                    .name = std::string(ref.name()),
-                    .hash = std::get<IPFSHash>(*queryPathInfo(ref)->ca)
-                });
-
-        auto fullCa = *info.fullContentAddressOpt();
-        auto cid = getCidFromCA(fullCa);
-
-        auto realCa = ContentAddress {
-            .name = std::string(info.path.name()),
-            .info = caWithRefs
+        IPFSGitTreeNode caWithRefs {
+            .gitTree = Hash::parseAny(key.substr(9), htSHA1),
         };
+        caWithRefs.references.hasSelfReference = info.hasSelfReference;
+        for (auto & ref : info.references) {
+            caWithRefs.references.references.insert(ContentAddressT<IPFSHashWithOptValue<IPFSGitTreeNode>> {
+                .name = std::string(ref.name()),
+                .info = IPFSHashWithOptValue<IPFSGitTreeNode> { IPFSHash<IPFSGitTreeNode> {
+                    .hash = std::get<IPFSHash<IPFSGitTreeNode>>(*queryPathInfo(ref)->ca),
+                }},
+            });
+        }
 
-        nlohmann::json json = realCa;
-
-        auto cid_ = ipfsCidFormatBase16(std::string(putIpfsDag(realCa, "sha2-256"), 6));
-        assert(cid_ == cid);
-        assert(cid_ == "f01711220" + std::get<IPFSHash>(*info.ca).hash.to_string(Base16, false));
+        auto cid = ipfsCidFormatBase16(std::string(putIpfsDag(caWithRefs, "sha2-256"), 6));
+        assert(cid == "f01711220" + std::get<IPFSHash<IPFSGitTreeNode>>(*info.ca).hash.to_string(Base16, false));
 
         auto narInfo = make_ref<NarInfo>(info);;
         narInfo->narSize = nar->size();