Imported base58 and started to use Multihash

Author: ianopolous

src/org/ipfs/Base58.java

@@ -0,0 +1,89 @@
+package org.ipfs;
+
+/**
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.math.BigInteger;
+
+/**
+ * A custom form of base58 is used to encode BitCoin addresses. Note that this is not the same base58 as used by
+ * Flickr, which you may see reference to around the internet.<p>
+ *
+ * Satoshi says: why base-58 instead of standard base-64 encoding?<p>
+ *
+ * <ul>
+ * <li>Don't want 0OIl characters that look the same in some fonts and
+ *    could be used to create visually identical looking account numbers.</li>
+ * <li>A string with non-alphanumeric characters is not as easily accepted as an account number.</li>
+ * <li>E-mail usually won't line-break if there's no punctuation to break at.</li>
+ * <li>Doubleclicking selects the whole number as one word if it's all alphanumeric.</li>
+ * </ul>
+ */
+public class Base58 {
+    private static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    private static final BigInteger BASE = BigInteger.valueOf(58);
+
+    public static String encode(byte[] input) {
+        // TODO: This could be a lot more efficient.
+        BigInteger bi = new BigInteger(1, input);
+        StringBuffer s = new StringBuffer();
+        while (bi.compareTo(BASE) >= 0) {
+            BigInteger mod = bi.mod(BASE);
+            s.insert(0, ALPHABET.charAt(mod.intValue()));
+            bi = bi.subtract(mod).divide(BASE);
+        }
+        s.insert(0, ALPHABET.charAt(bi.intValue()));
+        // Convert leading zeros too.
+        for (byte anInput : input) {
+            if (anInput == 0)
+                s.insert(0, ALPHABET.charAt(0));
+            else
+                break;
+        }
+        return s.toString();
+    }
+
+    public static byte[] decode(String input) {
+        byte[] bytes = decodeToBigInteger(input).toByteArray();
+        // We may have got one more byte than we wanted, if the high bit of the next-to-last byte was not zero. This
+        // is because BigIntegers are represented with twos-compliment notation, thus if the high bit of the last
+        // byte happens to be 1 another 8 zero bits will be added to ensure the number parses as positive. Detect
+        // that case here and chop it off.
+        boolean stripSignByte = bytes.length > 1 && bytes[0] == 0 && bytes[1] < 0;
+        // Count the leading zeros, if any.
+        int leadingZeros = 0;
+        for (int i = 0; input.charAt(i) == ALPHABET.charAt(0); i++) {
+            leadingZeros++;
+        }
+        // Now cut/pad correctly. Java 6 has a convenience for this, but Android can't use it.
+        byte[] tmp = new byte[bytes.length - (stripSignByte ? 1 : 0) + leadingZeros];
+        System.arraycopy(bytes, stripSignByte ? 1 : 0, tmp, leadingZeros, tmp.length - leadingZeros);
+        return tmp;
+    }
+
+    public static BigInteger decodeToBigInteger(String input) {
+        BigInteger bi = BigInteger.valueOf(0);
+        // Work backwards through the string.
+        for (int i = input.length() - 1; i >= 0; i--) {
+            int alphaIndex = ALPHABET.indexOf(input.charAt(i));
+            if (alphaIndex == -1) {
+                throw new IllegalStateException("Illegal character " + input.charAt(i) + " at " + i);
+            }
+            bi = bi.add(BigInteger.valueOf(alphaIndex).multiply(BASE.pow(input.length() - 1 - i)));
+        }
+        return bi;
+    }
+}

src/org/ipfs/IPFS.java

@@ -145,7 +145,7 @@ public List<MerkleNode> put(List<byte[]> data) throws IOException {
 
         public MerkleNode get(MerkleNode merkleObject) throws IOException {
             Map json = (Map)retrieveAndParse("object/get?stream-channels=true&arg=" + merkleObject.hash);
-            json.put("Hash", merkleObject.hash);
+            json.put("Hash", merkleObject.hash.toBase58());
             return MerkleNode.fromJSON(json);
         }
 

src/org/ipfs/MerkleNode.java

@@ -5,7 +5,7 @@
 
 public class MerkleNode {
     public final Optional<String> name;
-    public final String hash;
+    public final Multihash hash;
     public final Optional<Integer> size;
     public final Optional<Integer> type;
     public final List<MerkleNode> links;
@@ -21,7 +21,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 = hash;
+        this.hash = Multihash.fromBase58(hash);
         this.size = size;
         this.type = type;
         this.links = links;

src/org/ipfs/Multihash.java

@@ -33,21 +33,19 @@ public static Type lookup(int t) {
     }
 
     public final Type type;
-    public final byte size;
     public final byte[] hash;
 
-    public Multihash(Type type, byte size, byte[] hash) {
-        if ((size & 0xff) != hash.length)
-            throw new IllegalStateException("Incorrect size: " + (size&0xff) + " != "+hash.length);
+    public Multihash(Type type, byte[] hash) {
+        if (hash.length > 127)
+            throw new IllegalStateException("Unsupported hash size: "+hash.length);
         if (hash.length != type.length)
             throw new IllegalStateException("Incorrect hash length: " + hash.length + " != "+type.length);
         this.type = type;
-        this.size = size;
         this.hash = hash;
     }
 
     public Multihash(byte[] multihash) {
-        this(Type.lookup(multihash[0] & 0xff), multihash[1], Arrays.copyOfRange(multihash, 2, multihash.length));
+        this(Type.lookup(multihash[0] & 0xff), Arrays.copyOfRange(multihash, 2, multihash.length));
     }
 
     public byte[] toBytes() {
@@ -58,13 +56,34 @@ public byte[] toBytes() {
         return res;
     }
 
+    @Override
+    public String toString() {
+        return toBase58();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof Multihash))
+            return false;
+        return type == ((Multihash) o).type && Arrays.equals(hash, ((Multihash) o).hash);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(hash) ^ type.hashCode();
+    }
+
     public String toHex() {
         StringBuilder res = new StringBuilder();
         for (byte b: toBytes())
             res.append(String.format("%x", b&0xff));
         return res.toString();
     }
 
+    public String toBase58() {
+        return Base58.encode(toBytes());
+    }
+
     public static Multihash fromHex(String hex) {
         if (hex.length() % 2 != 0)
             throw new IllegalStateException("Uneven number of hex digits!");
@@ -73,4 +92,8 @@ public static Multihash fromHex(String hex) {
             bout.write(Integer.valueOf(hex.substring(i, i+2), 16));
         return new Multihash(bout.toByteArray());
     }
+
+    public static Multihash fromBase58(String base58) {
+        return new Multihash(Base58.decode(base58));
+    }
 }

test/org/ipfs/Test.java

@@ -6,6 +6,15 @@
 public class Test {
 
     IPFS ipfs = new IPFS("127.0.0.1", 5001);
+    @org.junit.Test
+    public void base58Test() {
+        String input = "QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB";
+        byte[] output = Base58.decode(input);
+        String encoded = Base58.encode(output);
+        if (!encoded.equals(input))
+            throw new IllegalStateException("Incorrect base58! "+ input + " => "+encoded);
+    }
+
 
     @org.junit.Test
     public void singleFileTest() {
@@ -139,7 +148,7 @@ public void dhtTest() {
             Map findprovs = ipfs.dht.findprovs(pointer);
             List<NodeAddress> peers = ipfs.swarm.peers();
             Map query = ipfs.dht.query(peers.get(0));
-            Map find = ipfs.dht.findpeer(peers.get(0));
+//            Map find = ipfs.dht.findpeer(peers.get(0));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }