Upgrade to supporting Cid, and cbor encoding.

Implement dag api.
Partially Implement IpldNode, though it's not used yet.
Bump version to 1.1.0, and increase minimum IPFS version to 0.4.5

Author: ianopolous

lib/cid.jar

@@ -1,17 +1,17 @@
 package io.ipfs.api;
 
+import io.ipfs.cid.*;
 import io.ipfs.multihash.Multihash;
 import io.ipfs.multiaddr.MultiAddress;
 
 import java.io.*;
 import java.net.*;
 import java.util.*;
-import java.util.function.*;
 import java.util.stream.*;
 
 public class IPFS {
 
-    public static final String MIN_VERSION = "0.4.3";
+    public static final String MIN_VERSION = "0.4.5";
     public enum PinType {all, direct, indirect, recursive}
     public List<String> ObjectTemplates = Arrays.asList("unixfs-dir");
     public List<String> ObjectPatchTypes = Arrays.asList("add-link", "rm-link", "set-data", "append-data");
@@ -25,6 +25,7 @@ public enum PinType {all, direct, indirect, recursive}
     public final Swarm swarm = new Swarm();
     public final Bootstrap bootstrap = new Bootstrap();
     public final Block block = new Block();
+    public final Dag dag = new Dag();
     public final Diag diag = new Diag();
     public final Config config = new Config();
     public final Refs refs = new Refs();
@@ -138,7 +139,7 @@ public List<Multihash> local() throws IOException {
             String jsonStream = new String(retrieve("refs/local"));
             return JSONParser.parseStream(jsonStream).stream()
                     .map(m -> (String) (((Map) m).get("Ref")))
-                    .map(Multihash::fromBase58)
+                    .map(Cid::decode)
                     .collect(Collectors.toList());
         }
     }
@@ -149,7 +150,7 @@ public class Pin {
         public List<Multihash> add(Multihash hash) throws IOException {
             return ((List<Object>)((Map)retrieveAndParse("pin/add?stream-channels=true&arg=" + hash)).get("Pins"))
                     .stream()
-                    .map(x -> Multihash.fromBase58((String)x))
+                    .map(x -> Cid.decode((String)x))
                     .collect(Collectors.toList());
         }
 
@@ -160,7 +161,7 @@ public Map<Multihash, Object> ls() throws IOException {
         public Map<Multihash, Object> ls(PinType type) throws IOException {
             return ((Map<String, Object>)(((Map)retrieveAndParse("pin/ls?stream-channels=true&t="+type.name())).get("Keys"))).entrySet()
                     .stream()
-                    .collect(Collectors.toMap(x -> Multihash.fromBase58(x.getKey()), x-> x.getValue()));
+                    .collect(Collectors.toMap(x -> Cid.decode(x.getKey()), x-> x.getValue()));
         }
 
         public List<Multihash> rm(Multihash hash) throws IOException {
@@ -169,7 +170,7 @@ public List<Multihash> rm(Multihash hash) throws IOException {
 
         public List<Multihash> rm(Multihash hash, boolean recursive) throws IOException {
             Map json = retrieveMap("pin/rm?stream-channels=true&r=" + recursive + "&arg=" + hash);
-            return ((List<Object>) json.get("Pins")).stream().map(x -> Multihash.fromBase58((String) x)).collect(Collectors.toList());
+            return ((List<Object>) json.get("Pins")).stream().map(x -> Cid.decode((String) x)).collect(Collectors.toList());
         }
     }
 
@@ -189,7 +190,12 @@ public byte[] get(Multihash hash) throws IOException {
         }
 
         public List<MerkleNode> put(List<byte[]> data) throws IOException {
-            Multipart m = new Multipart("http://" + host + ":" + port + version+"block/put?stream-channels=true", "UTF-8");
+            return put(data, Optional.empty());
+        }
+
+        public List<MerkleNode> put(List<byte[]> data, Optional<String> format) throws IOException {
+            String fmt = format.map(f -> "&format=" + f).orElse("");
+            Multipart m = new Multipart("http://" + host + ":" + port + version+"block/put?stream-channels=true" + fmt, "UTF-8");
             for (byte[] f : data)
                 m.addFilePart("file", new NamedStreamable.ByteArrayWrapper(f));
             String res = m.finish();
@@ -352,9 +358,9 @@ public List<MultiAddress> rm(MultiAddress addr, boolean all) throws IOException
         ipfs peers in the internet.
      */
     public class Swarm {
-        public List<MultiAddress> peers() throws IOException {
+        public List<Peer> peers() throws IOException {
             Map m = retrieveMap("swarm/peers?stream-channels=true");
-            return ((List<Object>)m.get("Strings")).stream().map(x -> new MultiAddress((String)x)).collect(Collectors.toList());
+            return ((List<Object>)m.get("Peers")).stream().map(Peer::fromJSON).collect(Collectors.toList());
         }
 
         public Map addrs() throws IOException {
@@ -373,6 +379,33 @@ public Map disconnect(String multiAddr) throws IOException {
         }
     }
 
+    public class Dag {
+        public byte[] get(Cid cid) throws IOException {
+            return retrieve("block/get?stream-channels=true&arg=" + cid);
+        }
+
+        public MerkleNode put(byte[] object) throws IOException {
+            return put("json", object, "cbor");
+        }
+
+        public MerkleNode put(String inputFormat, byte[] object) throws IOException {
+            return put(inputFormat, object, "cbor");
+        }
+
+        public MerkleNode put(byte[] object, String outputFormat) throws IOException {
+            return put("json", object, outputFormat);
+        }
+
+        public MerkleNode put(String inputFormat, byte[] object, String outputFormat) throws IOException {
+            block.put(Arrays.asList(object));
+            String prefix = "http://" + host + ":" + port + version;
+            Multipart m = new Multipart(prefix + "block/put/?stream-channels=true&input-enc=" + inputFormat + "&f=" + outputFormat, "UTF-8");
+            m.addFilePart("file", new NamedStreamable.ByteArrayWrapper(object));
+            String res = m.finish();
+            return MerkleNode.fromJSON(JSONParser.parse(res));
+        }
+    }
+
     public class Diag {
         public String net() throws IOException {
             return new String(retrieve("diag/net?stream-channels=true"));

lib/multibase.jar

@@ -0,0 +1,217 @@
+package io.ipfs.api;
+
+import io.ipfs.api.cbor.*;
+import io.ipfs.cid.*;
+import io.ipfs.multihash.*;
+
+import java.security.*;
+import java.util.*;
+import java.util.stream.*;
+
+public interface IpldNode extends Cborable {
+
+    Pair<IpldNode, List<String>> resolve(List<String> path);
+
+    /** Lists all paths within the object under 'path', and up to the given depth.
+     *  To list the entire object (similar to `find .`) pass "" and -1
+     * @param path
+     * @param depth
+     * @return
+     */
+    List<String> tree(String path, int depth);
+
+    /**
+     *
+     * @return calculate this objects Cid
+     */
+    default Cid cid() {
+        byte[] raw = rawData();
+        try {
+            MessageDigest md = MessageDigest.getInstance("SHA-256");
+            md.update(raw);
+            byte[] digest = md.digest();
+            Multihash h = new Multihash(Multihash.Type.sha2_256, digest);
+            return new Cid(1, Cid.Codec.DagCbor, h);
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     *
+     * @return size of this object when encoded
+     */
+    long size();
+
+    /**
+     *
+     * @return this object's serialization
+     */
+    byte[] rawData();
+
+    /**
+     *
+     * @return the merkle links from this object
+     */
+    List<Link> getLinks();
+
+    static IpldNode fromCBOR(CborObject cbor) {
+        return new CborIpldNode(cbor);
+    }
+
+    static IpldNode fromJSON(Object json) {
+        return new JsonIpldNode(json);
+    }
+
+    class CborIpldNode implements IpldNode {
+        private final CborObject base;
+
+        public CborIpldNode(CborObject base) {
+            this.base = base;
+        }
+
+        @Override
+        public CborObject toCbor() {
+            return base;
+        }
+
+        @Override
+        public Pair<IpldNode, List<String>> resolve(List<String> path) {
+            throw new IllegalStateException("Unimplemented!");
+        }
+
+        @Override
+        public List<String> tree(String path, int depth) {
+            return tree(base, path, depth);
+        }
+
+        private List<String> tree(CborObject base, String rawPath, int depth) {
+            String path = rawPath.startsWith("/") ? rawPath.substring(1) : rawPath;
+
+            if (depth == 0 || (path.equals("") && depth != -1))
+                return Collections.singletonList("");
+
+            if (base instanceof CborObject.CborMap) {
+                return ((CborObject.CborMap) base).values.entrySet()
+                        .stream()
+                        .flatMap(e -> {
+                            String name = ((CborObject.CborString) e.getKey()).value;
+                            if (path.startsWith(name) || depth == -1)
+                                return tree(e.getValue(), path.length() > 0 ? path.substring(name.length()) : path,
+                                        depth == -1 ? -1 : depth - 1)
+                                        .stream()
+                                        .map(p -> "/" + name + p);
+                            return Stream.empty();
+                        }).collect(Collectors.toList());
+            }
+            if (depth == -1)
+                return Collections.singletonList("");
+            return Collections.emptyList();
+        }
+
+        @Override
+        public long size() {
+            return rawData().length;
+        }
+
+        @Override
+        public byte[] rawData() {
+            return base.toByteArray();
+        }
+
+        @Override
+        public List<Link> getLinks() {
+            return getLinks(base);
+        }
+
+        private static List<Link> getLinks(CborObject base) {
+            if (base instanceof CborObject.CborMerkleLink)
+                return Collections.singletonList(new Link("", 0, ((CborObject.CborMerkleLink) base).target));
+            if (base instanceof CborObject.CborMap) {
+                return ((CborObject.CborMap) base).values.values()
+                        .stream()
+                        .flatMap(cbor -> getLinks(cbor).stream())
+                        .collect(Collectors.toList());
+            }
+            if (base instanceof CborObject.CborList) {
+                return ((CborObject.CborList) base).value
+                        .stream()
+                        .flatMap(cbor -> getLinks(cbor).stream())
+                        .collect(Collectors.toList());
+            }
+            return Collections.emptyList();
+        }
+    }
+
+    class JsonIpldNode implements IpldNode {
+        private final Object json;
+
+        public JsonIpldNode(Object json) {
+            this.json = json;
+        }
+
+        @Override
+        public CborObject toCbor() {
+            throw new IllegalStateException("Unimplemented!");
+        }
+
+        @Override
+        public Pair<IpldNode, List<String>> resolve(List<String> path) {
+            throw new IllegalStateException("Unimplemented!");
+        }
+
+        @Override
+        public List<String> tree(String path, int depth) {
+            throw new IllegalStateException("Unimplemented!");
+        }
+
+        @Override
+        public long size() {
+            return rawData().length;
+        }
+
+        @Override
+        public byte[] rawData() {
+            return JSONParser.toString(json).getBytes();
+        }
+
+        @Override
+        public List<Link> getLinks() {
+            throw new IllegalStateException("Unimplemented!");
+        }
+    }
+
+    class Link {
+        public final String name;
+        // Cumulative size of target
+        public final long size;
+        public final Multihash target;
+
+        public Link(String name, long size, Multihash target) {
+            this.name = name;
+            this.size = size;
+            this.target = target;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            Link link = (Link) o;
+
+            if (size != link.size) return false;
+            if (name != null ? !name.equals(link.name) : link.name != null) return false;
+            return target != null ? target.equals(link.target) : link.target == null;
+
+        }
+
+        @Override
+        public int hashCode() {
+            int result = name != null ? name.hashCode() : 0;
+            result = 31 * result + (int) (size ^ (size >>> 32));
+            result = 31 * result + (target != null ? target.hashCode() : 0);
+            return result;
+        }
+    }
+}

lib/multihash.jar

@@ -1,5 +1,6 @@
 package io.ipfs.api;
 
+import io.ipfs.cid.*;
 import io.ipfs.multihash.Multihash;
 
 import java.util.*;
@@ -23,7 +24,7 @@ public MerkleNode(String hash, Optional<String> name) {
 
     public MerkleNode(String hash, Optional<String> name, Optional<Integer> size, Optional<Integer> type, List<MerkleNode> links, Optional<byte[]> data) {
         this.name = name;
-        this.hash = Multihash.fromBase58(hash);
+        this.hash = Cid.decode(hash);
         this.size = size;
         this.type = type;
         this.links = links;