diff --git a/src/libstore/content-address.cc b/src/libstore/content-address.cc
index fcf12a9cdfe..4b918cfcb9c 100644
--- a/src/libstore/content-address.cc
+++ b/src/libstore/content-address.cc
@@ -35,7 +35,7 @@ std::string renderLegacyContentAddress(LegacyContentAddress ca) {
                 + makeFileIngestionPrefix(fsh.method)
                 + fsh.hash.to_string(Base32, true);
         },
-        [](IPFSHash ih) {
+        [](IPFSHash<IPFSGitTreeNode> ih) {
             // FIXME do Base-32 for consistency
             return "ipfs:" + ih.to_string();
         }
@@ -86,7 +86,7 @@ LegacyContentAddress parseLegacyContentAddress(std::string_view rawCa) {
             .hash = Hash::parseNonSRIUnprefixed(rest, std::move(hashType)),
         };
     } else if (prefix == "ipfs") {
-        auto hash = IPFSHash::from_string(rest);
+        auto hash = IPFSHash<IPFSGitTreeNode>::from_string(rest);
         if (hash.hash.type != htSHA256)
             throw Error("This IPFS hash should have type SHA-256: %s", hash.to_string());
         return hash;
@@ -134,10 +134,7 @@ std::string renderContentAddress(ContentAddress ca)
                 .hash = fsh.hash
             }});
         },
-        [](IPFSInfo fsh) {
-            throw Error("ipfs info not handled");
-        },
-        [&](IPFSHash ih) {
+        [&](IPFSHashWithOptValue<IPFSGitTreeNode> ih) {
             result += "ipfs:";
             result += ih.to_string();
         },
@@ -214,7 +211,9 @@ ContentAddress parseContentAddress(std::string_view rawCa)
             refs,
         };
     } else if (tag == "ipfs") {
-        info = IPFSHash::from_string(rest);
+        info = IPFSHashWithOptValue<IPFSGitTreeNode> {
+            IPFSHash<IPFSGitTreeNode>::from_string(rest)
+        };
     } else
         throw UsageError("content address tag \"%s\" is unrecognized. Recogonized tages are \"text\", \"fixed\", or \"ipfs\"", tag);
 
@@ -241,10 +240,10 @@ void to_json(nlohmann::json& j, const LegacyContentAddress & ca) {
                 { "hash", foh.hash.to_string(Base32, false) },
             };
         },
-        [](IPFSHash ih) {
+        [](IPFSHash<IPFSGitTreeNode> ih) {
             return nlohmann::json {
                 { "type", "ipfs" },
-                { "hash", ih.to_string() },
+                { "hash", ih },
             };
         },
     }, ca);
@@ -270,97 +269,96 @@ void from_json(const nlohmann::json& j, LegacyContentAddress & ca) {
         throw Error("invalid type: %s", type);
 }
 
-// f01781114 is the cid prefix for a base16 cbor sha1. This hash
-// stores the ContentAddress information.
+// Needed until https://github.com/nlohmann/json/pull/2117
+
+void to_json(nlohmann::json& j, const std::optional<LegacyContentAddress> & c) {
+    if (!c)
+        j = nullptr;
+    else
+        to_json(j, *c);
+}
 
-void to_json(nlohmann::json& j, const ContentAddress & ca)
+void from_json(const nlohmann::json& j, std::optional<LegacyContentAddress> & c) {
+    if (j.is_null()) {
+        c = std::nullopt;
+    } else {
+        // Dummy value to set tag bit.
+        c = TextHash { .hash = Hash { htSHA256 } };
+        from_json(j, *c);
+    }
+}
+
+template<typename T>
+void to_json(nlohmann::json& j, const ContentAddressT<T> & c)
 {
-    if (std::holds_alternative<IPFSInfo>(ca.info)) {
-        auto info = std::get<IPFSInfo>(ca.info);
-
-        // FIXME: ipfs sort order is weird, it always puts type before
-        // references, so we rename it to qtype so it always comes
-        // before references
-        j = nlohmann::json {
-            { "qtype", "ipfs" },
-            { "name", ca.name },
-            { "references", info.references },
-            { "cid", nlohmann::json {
-                { "/", (IPFSHash { .hash = info.hash }).to_string() }
-            } }
-        };
-    } else throw Error("cannot convert to json");
+    j = nlohmann::json {
+        { "name", c.name },
+        { "info", c.info },
+    };
 }
 
-void from_json(const nlohmann::json& j, ContentAddress & ca)
+template<typename T>
+void from_json(const nlohmann::json& j, ContentAddressT<T> & c)
 {
-    std::string_view type = j.at("qtype").get<std::string_view>();
-    if (type == "ipfs") {
-        auto cid = j.at("cid").at("/").get<std::string_view>();
-        ca = ContentAddress {
-            .name = j.at("name"),
-            .info = IPFSInfo {
-                IPFSHash::from_string(cid).hash,
-                j.at("references").get<PathReferences<IPFSRef>>(),
-            },
-        };
-    } else
-        throw Error("invalid type: %s", type);
+    c.name = j.at("name");
+    from_json(j.at("info"), c.info);
 }
 
-void to_json(nlohmann::json& j, const PathReferences<IPFSRef> & references)
+template<template <typename> class Ref>
+void to_json(nlohmann::json& j, const IPFSGitTreeNodeT<Ref> & c)
 {
-    auto refs = nlohmann::json::array();
-    for (auto & i : references.references) {
-        refs.push_back(nlohmann::json {
-            { "name", i.name },
-            { "cid", nlohmann::json {{ "/", i.hash.to_string() }} }
-        });
-    }
+    // FIXME: ipfs sort order is weird, it always puts type before
+    // references, so we rename it to qtype so it always comes
+    // before references
+    j = nlohmann::json {
+        { "gitTree", IPFSHash<void> { c.gitTree } },
+        { "zreferences", c.references },
+    };
+}
+
+template<template <typename> class Ref>
+void from_json(const nlohmann::json& j, IPFSGitTreeNodeT<Ref> & c)
+{
+    IPFSHash<void> temp {
+        .hash = Hash { htSHA256 }, // dummy val
+    };
+    from_json(j.at("gitTree"), temp);
+    c.gitTree = std::move(temp.hash);
+    from_json(j.at("zreferences"), c.references);
+}
 
+template<typename T>
+void to_json(nlohmann::json& j, const PathReferences<T> & references)
+{
     // FIXME: ipfs sort order is weird, it always puts references
     // before hasSelfReference, so we rename it to zhasSelfReferences
     // so it always comes after references
 
     j = nlohmann::json {
         { "zhasSelfReference", references.hasSelfReference },
-        { "references", refs }
+        { "references", references.references }
     };
 }
 
-void from_json(const nlohmann::json& j, PathReferences<IPFSRef> & references)
+template<typename T>
+void from_json(const nlohmann::json& j, PathReferences<T> & references)
 {
-    std::set<IPFSRef> refs;
-    for (auto & ref : j.at("references")) {
-        auto cid = ref.at("cid").at("/").get<std::string_view>();
-        refs.insert(IPFSRef {
-            .name = std::move(ref.at("name").get<std::string>()),
-            .hash = IPFSHash::from_string(cid).hash,
-        });
-    }
-    references = PathReferences<IPFSRef> {
+    std::set<T> refs;
+    nlohmann::from_json(j.at("references"), refs);
+    references = PathReferences<T> {
         .references = refs,
         .hasSelfReference = j.at("zhasSelfReference").get<bool>(),
     };
 }
 
-// Needed until https://github.com/nlohmann/json/pull/2117
+template
+void to_json(nlohmann::json& j, const IPFSHash<IPFSGitTreeNode> & c);
+template
+void from_json(const nlohmann::json& j, IPFSHash<IPFSGitTreeNode> & c);
 
-void to_json(nlohmann::json& j, const std::optional<LegacyContentAddress> & c) {
-    if (!c)
-        j = nullptr;
-    else
-        to_json(j, *c);
-}
-
-void from_json(const nlohmann::json& j, std::optional<LegacyContentAddress> & c) {
-    if (j.is_null()) {
-        c = std::nullopt;
-    } else {
-        // Dummy value to set tag bit.
-        c = TextHash { .hash = Hash { htSHA256 } };
-        from_json(j, *c);
-    }
-}
+template
+void to_json(nlohmann::json& j, const IPFSGitTreeNode & c);
+template
+void from_json(const nlohmann::json& j, IPFSGitTreeNode & c);
 
 }
diff --git a/src/libstore/content-address.hh b/src/libstore/content-address.hh
index 06878389381..035e4995dba 100644
--- a/src/libstore/content-address.hh
+++ b/src/libstore/content-address.hh
@@ -3,8 +3,8 @@
 #include <nlohmann/json.hpp>
 #include <variant>
 
-#include "ipfs.hh"
 #include "hash.hh"
+#include "ipfs.hh"
 #include "path.hh"
 
 namespace nix {
@@ -31,6 +31,11 @@ struct FixedOutputHash {
     std::string printMethodAlgo() const;
 };
 
+template<template <typename> class Ref>
+struct IPFSGitTreeNodeT;
+
+typedef IPFSGitTreeNodeT<IPFSHashWithOptValue> IPFSGitTreeNode;
+
 /*
   We've accumulated several types of content-addressed paths over the years;
   fixed-output derivations support multiple hash algorithms and serialisation
@@ -45,7 +50,7 @@ struct FixedOutputHash {
 typedef std::variant<
     TextHash, // for paths computed by makeTextPath() / addTextToStore
     FixedOutputHash, // for path computed by makeFixedOutputPath
-    IPFSHash
+    IPFSHash<IPFSGitTreeNode>
 > LegacyContentAddress;
 
 /* Compute the prefix to the hash algorithm which indicates how the files were
@@ -136,50 +141,54 @@ struct FixedOutputInfo : FixedOutputHash {
     PathReferences<StorePath> references;
 };
 
-// pair of name and a hash of a content address
-struct IPFSRef {
-    std::string name;
-    IPFSHash hash;
-
-    bool operator < (const IPFSRef & other) const
-    {
-        return name < other.name;
-        // FIXME second field
-    }
-};
+template<typename Underlying>
+struct ContentAddressT;
 
-struct IPFSInfo {
-    Hash hash;
+template<template <typename> class Ref>
+struct IPFSGitTreeNodeT {
+	Hash gitTree;
     // References for the paths
-    PathReferences<IPFSRef> references;
+    PathReferences<ContentAddressT<Ref<IPFSGitTreeNodeT<Ref>>>> references;
 };
 
+// FIXME names
 typedef std::variant<
     TextInfo,
     FixedOutputInfo,
-    IPFSInfo,
-    IPFSHash
+    IPFSHashWithOptValue<IPFSGitTreeNode>
 > ContentAddressWithoutName;
 
-struct ContentAddress {
+template<typename Underlying>
+struct ContentAddressT {
     std::string name;
-    ContentAddressWithoutName info;
+    Underlying info;
 
-    bool operator < (const ContentAddress & other) const
+    bool operator < (const ContentAddressT<Underlying> & other) const
     {
         return name < other.name;
         // FIXME second field
     }
 };
 
+typedef ContentAddressT<ContentAddressWithoutName> ContentAddress;
+
 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 IPFSGitTreeNodeT<Ref> & c);
+template<template <typename> class Ref>
+void from_json(const nlohmann::json& j, IPFSGitTreeNodeT<Ref> & c);
+
+template<typename T>
+void to_json(nlohmann::json& j, const ContentAddressT<T> & c);
+template<typename T>
+void from_json(const nlohmann::json& j, ContentAddressT<T> & c);
 
-void to_json(nlohmann::json& j, const PathReferences<IPFSRef> & c);
-void from_json(const nlohmann::json& j, PathReferences<IPFSRef> & 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/libstore/ipfs-binary-cache-store.cc b/src/libstore/ipfs-binary-cache-store.cc
index e5cb2149223..b175b36987c 100644
--- a/src/libstore/ipfs-binary-cache-store.cc
+++ b/src/libstore/ipfs-binary-cache-store.cc
@@ -511,10 +511,8 @@ 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<IPFSHash>(ca.info))
-        return "f01711220" + std::get<IPFSHash>(ca.info).hash.to_string(Base16, false);
-
-    assert(!std::holds_alternative<IPFSInfo>(ca.info));
+    } else if (std::holds_alternative<IPFSHashWithOptValue<IPFSGitTreeNode>>(ca.info))
+        return "f01711220" + std::get<IPFSHashWithOptValue<IPFSGitTreeNode>>(ca.info).hash.to_string(Base16, false);
 
     return std::nullopt;
 }
@@ -667,7 +665,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<IPFSGitTreeNode>>(*info.ca)) {
         auto nar = make_ref<std::string>(narSource.drain());
 
         AutoDelete tmpDir(createTempDir(), true);
@@ -677,27 +675,21 @@ void IPFSBinaryCacheStore::addToStore(const ValidPathInfo & info, Source & narSo
         auto key = ipfsCidFormatBase16(addGit((Path) tmpDir + "/tmp", std::string(info.path.hashPart()), info.hasSelfReference));
         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();
diff --git a/src/libstore/store-api.cc b/src/libstore/store-api.cc
index 668807a0dfc..ee02e4680f6 100644
--- a/src/libstore/store-api.cc
+++ b/src/libstore/store-api.cc
@@ -215,63 +215,30 @@ StorePath Store::makeTextPath(std::string_view name, const TextInfo & info) cons
         name);
 }
 
-static HashType getMultiHashTag(int tag)
+// FIXME move to content-address.cc
+IPFSHash<IPFSGitTreeNode> 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);
-    }
-    }
-}
-
-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;
-}
-
-static IPFSHash computeIPFSHash(const ContentAddress & info)
-{
-    assert(std::holds_alternative<IPFSInfo>(info.info));
+    nlohmann::json j { info };
 
-    nlohmann::json j = info;
+    auto pack = [&](auto & ref) {
+        ref = ref.template 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 IPFSHash { hashString(htSHA256, std::string(cbor.begin(), cbor.end())) };
+    return IPFSHash<IPFSGitTreeNode> {
+        hashString(htSHA256, std::string(cbor.begin(), cbor.end())),
+    };
 }
 
-StorePath Store::makeIPFSPath(std::string name, IPFSHash hash) const
+StorePath Store::makeIPFSPath(std::string_view name, IPFSHash<IPFSGitTreeNode> hash) const
 {
-    string type = "ipfs";
-    assert(hash.hash.type == htSHA256);
-    string cid = "f01711220" + hash.hash.to_string(Base16, false);
-
-    // copy paste from makeStorePath
-    string s = type + ":" + cid + ":" + storeDir + ":" + name;
-    auto h = compressHash(hashString(htSHA256, s), 20);
-    return StorePath(h, name);
+    return makeStorePath("ipfs-git", hash.hash, name);
 }
 
 StorePath Store::makeFixedOutputPathFromCA(const ContentAddress & info) const
@@ -284,12 +251,9 @@ StorePath Store::makeFixedOutputPathFromCA(const ContentAddress & info) const
         [&](FixedOutputInfo foi) {
             return makeFixedOutputPath(info.name, foi);
         },
-        [&](IPFSInfo io) {
-            return makeIPFSPath(info.name, computeIPFSHash(info));
+        [&](IPFSHash<IPFSGitTreeNode> ih) {
+            return makeIPFSPath(info.name, ih);
         },
-        [&](IPFSHash ic) {
-            return makeIPFSPath(info.name, ic);
-        }
     }, info.info);
 }
 
@@ -970,8 +934,10 @@ std::optional<ContentAddress> ValidPathInfo::fullContentAddressOpt() const
                 info.references = static_cast<PathReferences<StorePath>>(*this);
                 return ContentAddressWithoutName { info };
             },
-            [&](IPFSHash io) {
-                return ContentAddressWithoutName { io };
+            [&](IPFSHash<IPFSGitTreeNode> io) {
+                return ContentAddressWithoutName {
+                    IPFSHashWithOptValue<IPFSGitTreeNode> { io },
+                };
             },
         }, *ca),
     };
@@ -1036,14 +1002,14 @@ ValidPathInfo::ValidPathInfo(
             *(static_cast<PathReferences<StorePath> *>(this)) = foi.references;
             this->ca = FixedOutputHash { (FixedOutputHash) std::move(foi) };
         },
-        [this, &store, info](IPFSInfo foi) {
-            this->hasSelfReference = foi.references.hasSelfReference;
-            for (auto & ref : foi.references.references)
-                this->references.insert(store.makeIPFSPath(ref.name, ref.hash));
-            this->ca = IPFSHash { computeIPFSHash(info) };
-        },
-        [](IPFSHash foi) {
-            throw Error("cannot make a valid path from an ipfs hash without talking to the ipfs daemon");
+        [this, &store](IPFSHashWithOptValue<IPFSGitTreeNode> 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.name, ref.info));
+            }
+            // Else must add references manually after construction!
         },
     }, std::move(info.info));
 }
diff --git a/src/libstore/store-api.hh b/src/libstore/store-api.hh
index 950f3bc5dc8..7a1e0c14bc6 100644
--- a/src/libstore/store-api.hh
+++ b/src/libstore/store-api.hh
@@ -264,7 +264,7 @@ public:
 
     StorePath bakeCaIfNeeded(StorePathOrCA path) const;
 
-    StorePath makeIPFSPath(std::string name, IPFSHash hash) const;
+    StorePath makeIPFSPath(std::string_view name, IPFSHash<IPFSGitTreeNode> ref) const;
 
     /* This is the preparatory part of addToStore(); it computes the
        store path to which srcPath is to be copied.  Returns the store
@@ -767,5 +767,4 @@ std::pair<std::string, Store::Params> splitUriAndParams(const std::string & uri)
 
 std::optional<ContentAddress> getDerivationCA(const BasicDerivation & drv);
 
-
 }
diff --git a/src/libutil/hash.hh b/src/libutil/hash.hh
index 3a485a5bc4a..3f148325580 100644
--- a/src/libutil/hash.hh
+++ b/src/libutil/hash.hh
@@ -31,6 +31,10 @@ struct Hash
 
     HashType type;
 
+	/* Using and arbitrary dummy value is bad, but very useful for
+	   <nlohmann/json> so we do it anways */
+	Hash() : Hash { htSHA256 } { }
+
     /* Create a zero-filled hash object. */
     Hash(HashType type);
 
diff --git a/src/libutil/ipfs.cc b/src/libutil/ipfs.cc
index 2f0d6cc5072..af45297d210 100644
--- a/src/libutil/ipfs.cc
+++ b/src/libutil/ipfs.cc
@@ -1,11 +1,11 @@
 #include "ipfs.hh"
 
-namespace nix {
+namespace nix::untyped {
 
 // "f01711220" base-16, sha-256
 // "f01781114" base-16, sha-1
 
-std::string IPFSHash::to_string() const
+std::string toString(Hash hash)
 {
     std::string prefix;
     switch (hash.type) {
@@ -16,15 +16,28 @@ std::string IPFSHash::to_string() const
     return prefix + hash.to_string(Base16, false);
 }
 
-IPFSHash IPFSHash::from_string(std::string_view cid)
+Hash fromString(std::string_view cid)
 {
     auto prefix = cid.substr(0, 9);
     HashType algo = prefix == "f01781114" ? htSHA1
         : prefix == "f01711220" ? htSHA256
         : throw Error("cid '%s' is wrong type for ipfs hash", cid);
-    return IPFSHash {
-        Hash::parseNonSRIUnprefixed(cid.substr(9), algo)
-    };
+    return Hash::parseNonSRIUnprefixed(cid.substr(9), algo);
+}
+
+std::vector<uint8_t> pack(Hash hash)
+{
+	auto cid = toString(hash);
+    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));
+    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 acb01efa5a1..6b2d1aac18c 100644
--- a/src/libutil/ipfs.hh
+++ b/src/libutil/ipfs.hh
@@ -1,14 +1,84 @@
 #pragma once
 
+#include <memory>
+#include <nlohmann/json.hpp>
+
 #include "hash.hh"
 
 namespace nix {
 
-// hash of some IPFSInfo
+// Deref is a phantom parameter that just signifies what the hash should
+// dereference too.
+template<typename Deref>
 struct IPFSHash {
     Hash hash;
     std::string to_string() const;
-    static IPFSHash from_string(std::string_view cid);
+    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
+   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);
 };
 
+template<typename Deref>
+std::string IPFSHash<Deref>::to_string() const {
+    return untyped::toString(hash);
+}
+
+template<typename Deref>
+IPFSHash<Deref> IPFSHash<Deref>::from_string(std::string_view cid) {
+	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) {
+    j = nlohmann::json {
+        { "/", c.to_string() },
+    };
+}
+
+template<typename Deref>
+void from_json(const nlohmann::json& j, IPFSHash<Deref> & c) {
+    c = IPFSHash<Deref>::from_string(j.at("/").get<std::string_view>());
+}
+
+template<typename Deref>
+void to_json(nlohmann::json& j, const IPFSHashWithOptValue<Deref> & c) {
+    to_json(j, static_cast<const IPFSHash<Deref> &>(c));
+}
+
+template<typename Deref>
+void from_json(const nlohmann::json& j, IPFSHashWithOptValue<Deref> & c) {
+    from_json(j, static_cast<IPFSHash<Deref> &>(c));
+}
+
 }
diff --git a/src/nix/make-content-addressable.cc b/src/nix/make-content-addressable.cc
index c15fb7034c3..a0620513e50 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);
@@ -79,41 +85,66 @@ struct CmdMakeContentAddressable : StorePathsCommand, MixJSON
 
             auto narHash = hashModuloSink.finish().first;
 
-            ContentAddress ca {
-                .name = std::string { path.name() },
-                .info = FixedOutputInfo {
-                    {
-                        .method = FileIngestionMethod::Recursive,
-                        .hash = narHash,
-                    },
-                    refs,
-                },
-            };
-
             // ugh... we have to convert nar data to git.
+            std::optional<Hash> gitHash;
             if (ipfsContent) {
                 AutoDelete tmpDir(createTempDir(), true);
                 StringSource source(*sink.s);
                 restorePath((Path) tmpDir + "/tmp", source);
 
-                Hash gitHash = dumpGitHashWithCustomHash([&]{ return std::make_unique<HashModuloSink>(htSHA1, oldHashPart); }, (Path) tmpDir + "/tmp");
-
-                std::set<IPFSRef> ipfsRefs;
-                for (auto & ref : refs.references)
-                    ipfsRefs.insert(IPFSRef {
-                            .name = std::string(ref.name()),
-                            .hash = std::get<IPFSHash>(*store->queryPathInfo(ref)->ca)
-                        });
-                ca.info = IPFSInfo {
-                    .hash = gitHash,
-                    PathReferences<IPFSRef> {
-                        .references = ipfsRefs,
-                        .hasSelfReference = refs.hasSelfReference,
-                    },
-                };
+                gitHash = dumpGitHashWithCustomHash([&]{ return std::make_unique<HashModuloSink>(htSHA1, oldHashPart); }, (Path) tmpDir + "/tmp");
+
+                StringSink sink_;
+                RewritingSink rewritingSink(oldHashPart, std::string(oldHashPart.size(), 0), sink_);
+                dumpGit(htSHA1, (Path) tmpDir + "/tmp", rewritingSink);
             }
 
-            ValidPathInfo info { *store, ContentAddress { ca } };
+            ContentAddressWithoutName ca = ipfsContent
+                ? ContentAddressWithoutName {
+                    IPFSHashWithOptValue<IPFSGitTreeNode>::fromValue({
+                        .gitTree = *gitHash,
+                        { {}, hasSelfReference },
+                    })
+                }
+                : ContentAddressWithoutName {
+                    FixedOutputInfo {
+                        {
+                             .method = FileIngestionMethod::Recursive,
+                             .hash = narHash,
+                        },
+                        { {}, hasSelfReference },
+                    }
+                };
+
+            if (ipfsContent) {
+                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");
+                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 = ca,
+                },
+            };
             info.narHash = narHash;
             info.narSize = sink.s->size();
 
@@ -131,7 +162,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());
         }
     }
 };