micro_ipfs.js

// for nodejs
if (typeof sha256 == 'undefined' && typeof require != 'undefined') { try { sha256 = require('./sha256.js').sha256; } catch (e) {console.log(e);} }

var micro_ipfs = (function() {
  var hexVarintToInteger = function(str) {
    var s = String(str);
    var total = 0;
    var offset = 1;
    for (var i = 0; i < s.length; i += 2) {
      var byte = parseInt(s.substring(i, i+2), 16);
      var isLast = null;
      if (byte >= 128) {
        byte -= 128;
        isLast = false;
      } else {
        isLast = true;
      }
      total += byte * offset;
      offset *= Math.pow(2,7);
    }
    return total;
  };
  
  var hexStringToIntegerList = function(str) {
    var s = String(str);
    var result = [];
    for (var i = 0; i < s.length; i+=2) {
      result[i/2] = parseInt(s.substring(i, i+2), 16);
    }
    return result;
  };
  
  var hexStringToString = function(str) {
    var s = String(str);
    var result = '';
    for (var i = 0; i < s.length; i+=2) {
      result += String.fromCharCode(parseInt(s.substring(i, i+2), 16));
    }
    return result;
  };
  
  var sha256IntegerListToMultihash = function(base, lst) {
    // 0x20 is the length of the hash.
    var i = 0;
    var result = [];
    if (base == 32) {
      // For some reason these are present in the base32 CIDs but not in the base16 CIDs
      result[i++] = parseInt('01', 16);
      result[i++] = parseInt('70', 16);
    }
    result[i++] = parseInt('12', 16);
    result[i++] = parseInt('20', 16);
    for (var j = 0; j < lst.length; j++) {
      result[j+i] = lst[j];
    }
    return result;
  };
  
  var integerListToLowercaseBase16Multibase = function(lst) {
    var result = '';
    for (var i = 0; i < lst.length; i++) {
      var hex = lst[i].toString(16);
      if (hex.length < 2) { hex = '0' + hex; }
      result += hex;
    }
    return 'f' + result;
  };
  
  var int8ListToBitList = function(lst) {
    var result = [];
    for (var i = 0; i < lst.length; i++) {
      result[i*8+0] = (lst[i] & 128) ? 1 : 0;
      result[i*8+1] = (lst[i] & 64) ? 1 : 0;
      result[i*8+2] = (lst[i] & 32) ? 1 : 0;
      result[i*8+3] = (lst[i] & 16) ? 1 : 0;
      result[i*8+4] = (lst[i] & 8) ? 1 : 0;
      result[i*8+5] = (lst[i] & 4) ? 1 : 0;
      result[i*8+6] = (lst[i] & 2) ? 1 : 0;
      result[i*8+7] = (lst[i] & 1) ? 1 : 0;
    }
    return result;
  };
  
  var base32StringToBitList = function(str) {
    var baseChars = 'abcdefghijklmnopqrstuvwxyz234567';
    var s = String(str);
    var result = [];
    for (var i = 0; i < s.length; i++) {
      var part = baseChars.indexOf(s[i]);
      //for (var j = 0; j < 6; j++) {
      //  result[i*6+j] = (part & Math.pow(2, 6-1-j)) ? 1 : 0;
      //}
      result[i*5+0] = (part & 16) ? 1 : 0;
      result[i*5+1] = (part & 8) ? 1 : 0;
      result[i*5+2] = (part & 4) ? 1 : 0;
      result[i*5+3] = (part & 2) ? 1 : 0;
      result[i*5+4] = (part & 1) ? 1 : 0;
    }
    return result;
  };
  
  // https://gist.github.com/diafygi/90a3e80ca1c2793220e5/, license: wtfpl
  var from_b58 = function(S,A){var d=[],b=[],i,j,c,n;for(i in S){j=0,c=A.indexOf(S[i]);if(c<0)return undefined;c||b.length^i?i:b.push(0);while(j in d||c){n=d[j];n=n?n*58+c:c;c=n>>8;d[j]=n%256;j++}}while(j--)b.push(d[j]);return new Uint8Array(b)};
  
  var base58StringToHexString = function(str) {
    var baseChars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
    var ints = from_b58(String(str), baseChars);
    var result = '';
    for (var i = 0; i < ints.length; i++) {
      var hex = ints[i].toString(16);
      if (hex.length < 2) { hex = '0' + hex; }
      result += hex;
    }
    return result;
  };
  
  var integerListToLowercaseBase32Multibase = function(lst) {
    var baseChars = 'abcdefghijklmnopqrstuvwxyz234567';
    var result = '';
    var l = int8ListToBitList(lst);
  
    for (var i = 0; i < l.length; i+= 5) {
      var get = function(j) { return ((i+j) < l.length) ? l[i+j] : 0; };
      var part = get(0) * 16 + get(1) * 8 + get(2) * 4 + get(3) * 2 + get(4) * 1;
      result += baseChars[part];
    }
    return 'b' + result;
  };
  
  var base32StringToBase16LowercaseMultibase = function(str) {
    var baseChars = '0123456789abcdef';
    var result = '';
    var l = base32StringToBitList(str);
  
    for (var i = 0; i < l.length; i+= 4) {
      var get = function(j) { return ((i+j) < l.length) ? l[i+j] : 0; };
      var part = get(0) * 8 + get(1) * 4 + get(2) * 2 + get(3) * 1;
      result += baseChars[part];
    }
    return 'f' + result;
  };
  
  var integerToHexVarint = function(i) {
    // This function takes a JavaScript integer and returns a hexadecimal string representing that integer encoded as a protobuf varint according to the rules explained at
    // https://developers.google.com/protocol-buffers/docs/encoding
    var result = '';
    if (i < 0) {
      throw "Negative integers are supported by Varints but not by this implementation.";
    } else if (i == 0) {
      return '00';
    } else {
      while (i > 0) {
        // Get the least significant 7 bits (0..127) of the integer and shift the rest
        var leastSignificantBits = i & 127;
        i = i >> 7;
        // if this is not the last chunk, set the most significant bit to indicate that the value will be continued in the next byte(s).
        if (i > 0) { leastSignificantBits |= 128; }
        // Convert to hexadecimal and pad with 0 to get two digits if needed
        var hex = leastSignificantBits.toString(16);
        if (hex.length < 2) { hex = '0' + hex; }
        result += hex;
      }
      return result;
    }
  }
  
  var utf8StringToHex = function(str) {
    // The input must already be a string for which .charCodeAt() always returns a value <256 (i.e. a string encoded into utf-8 and those values re-encoded into javascript's internal utf-16)
    var s = String(str);
    var result = '';
    for (var i = 0; i < s.length; i++) {
      var hex = s.charCodeAt(i).toString(16);
      if (hex.length < 2) { hex = '0' + hex; }
      result += hex;
    }
    return result;
  };
  
  var ipfsBlockWithLinks = function(object) {
    // object should be an { "Links": links, "Data": hex-encoded string } object
    // Aside from encoding differences, it should match the contents of the "ipfs object get --data-encoding=base64 Qm…hash" command
    //
    // "Links" should be an array of { 'Hash': cidv1Base16Lowercase, 'Size': Integer } objects.
    // This functions returns a hexadecimal string which encodes the ipfs block with the given links.
    // This is a partial implementation which is barely sufficient for re-hashing a file, many of the configurable values are hardcoded.
    // A Qm…hash can be converted to a "CIDv1 base16 lowercase" hash on the command-line using the following code:
    //   ipfs cid format -v 1 -b base16 -f='%m' Qm…hash
    //
    // "File" should be the hex-encoded (base 16, lowercase, no prefix) data, or "false" when the entry is not a DAG leaf
    //
    // The "Data" field as given by the following command
    //   ipfs object get --data-encoding=base64 Qm…hash | jq -r '.Data' | base64 -d | xxd -ps
    // is automatically generated using the "File" field if present and the various sizes etc.
  
    var links = object.Links;
    var fileHex = object.File;
    var result = '';
  
    for (var i = 0; i < links.length; i++) {
      var cid = links[i].Hash;
      var size = links[i].Size;
      var name = links[i].Name;
      var fileHex = object.File;
  
      result += '12';
  
      var encodedLink = ''
      // Some sort of separator or terminator
      encodedLink += '0a';
  
      // size of the CID (32 bytes + 2 bytes header = 34 bytes = 22 in hex)
      encodedLink += '22';
  
      if (cid[0] != 'f' || cid.length != 69) {
        if (cid[0] == 'Q' && cid[1] == 'm' && cid.length == 46) {
          cid = 'f' + base58StringToHexString(cid);
          if (cid[0] != 'f' || cid.length != 69) {
            throw "Internal error";
          }
        } else {
          throw "Expected a lowercase base16 CIDv1 or a Qm…hash in base58 (length 46). The base16 encoding should start with 'f'" +
          /*+*/ " and have a length of 32 bytes (64 hexadecimal characters) plus the leading prefix 'f1220' (length of 69 characters in total)" +
          /*+*/ " as described in https://github.com/multiformats/multibase. The given hash started with " + cid[0] + " and had a length of " + cid.length;
        }
      }
  
      // Add the CID.
      encodedLink += cid.substring(1);
  
      // Add a second hardcoded part of the encoding.
      encodedLink += '12';
      // length of filename
      encodedLink += integerToHexVarint(name.length);
      encodedLink += utf8StringToHex(name);
  
      encodedLink += '18';
  
      // Add the size.
      encodedLink += integerToHexVarint(size);
  
      var encodedLinkSize = encodedLink.length/2
      result += integerToHexVarint(encodedLinkSize);
      result += encodedLink;
    }
  
    // Generate the "Data" field
  
    var totalSize = (fileHex || '').length / 2;
    for (var i = 0; i < object.Links.length; i++) {
      totalSize += object.Links[i].ContentSize;
    }
  
    var encodedData = '';
    if (object.isFile) {
      //             '08'   '02'
      encodedData += '08' + '02';
      // field 12 seems to be optional (for DAG nodes with links (groups of blocks and directories))
      if (fileHex !== false) {
        encodedData += '12';
        encodedData += integerToHexVarint(totalSize);
        encodedData += fileHex;
      }
      //            '18' [8f b0 15 = total size of contents of the file = 35022300]
      encodedData += '18' + integerToHexVarint(totalSize);
      for (var j = 0; j < object.Links.length; j++) {
        // 20 [80 80 10 = size of contents of block 1 = 262144]
        // 20 [8f b0 05 = size of contents of block 2 = 88079]
        encodedData += '20';
        encodedData += integerToHexVarint(object.Links[j].ContentSize);
      }
    } else {
      // directory
      encodedData += '08' + '01';
    }
  
    // Some sort of separator or terminator
    result += '0a';
    var encodedDataSize = encodedData.length / 2;
    result += integerToHexVarint(encodedDataSize);
    result += encodedData;
  
    return result;
  };
  
  var ipfsHashWithLinks = function(base, object) {
    var block = hexStringToIntegerList(ipfsBlockWithLinks(object));
    //console.time('sha256');
    var sha = sha256(block);
    //console.timeEnd('sha256');
    var hash = sha256IntegerListToMultihash(base, sha);
    if (base == 16) {
      return { "hash" : integerListToLowercaseBase16Multibase(hash), "block" : block };
    } else {
      return { "hash" : integerListToLowercaseBase32Multibase(hash), "block" : block };
    }
  };

  return {
    utf8StringToHex: utf8StringToHex,
    hashWithLinks: ipfsHashWithLinks
  };
})();

var ipfs_self_hash = (function() {
    var ipfs = micro_ipfs;
    var get_root_with_vanity = function(vanity_attempt, ipfs_directory_hashes) {
      var find_link_entry = function() {
        for (var i = 0; i < ipfs_directory_hashes.tree.Links.length; i++) {
          if (ipfs_directory_hashes.tree.Links[i].Name == 'directory_hashes.js') {
            return i;
          }
        }
        console.error(ipfs_directory_hashes);
        console.error(ipfs_directory_hashes.tree.Links);
        throw "Could not find entry for directory_hashes.js";
      }
      var foo_link_entry = find_link_entry();
      ipfs_directory_hashes.tree.Links[foo_link_entry].Hash = "";
      ipfs_directory_hashes.tree.Links[foo_link_entry].Size = 0;
      ipfs_directory_hashes.vanity_number = vanity_attempt;
  
      // TODO: using JSON.stringify to recreate the file is more brittle, better store the stringified version as a hex string, and then decode it?
      var file_directory_hashes = 'jsonp_ipfs_directory_hashes(' + JSON.stringify(ipfs_directory_hashes) + ');\n';
      var foo = ipfs.hashWithLinks(16, {
        "Links": [],
        "isFile": true,
        "File": ipfs.utf8StringToHex(file_directory_hashes)
      });
  
      ipfs_directory_hashes.tree.Links[foo_link_entry].Hash = foo.hash;
      ipfs_directory_hashes.tree.Links[foo_link_entry].Size = foo.block.length;
  
      root = ipfs.hashWithLinks(32, ipfs_directory_hashes.tree);
      return root;
    };
  
    var expected_vanity_attempt = 32*32*32;
    var max_vanity_attempt = expected_vanity_attempt*10;
    function find_vanity_node(vanity_text, vanity_attempt, ipfs_directory_hashes) {
      if ((! (typeof vanity_text == 'string' || vanity_text instanceof String)) || vanity_text.length != 3) {
        throw 'find_vanity_node(vanity_text, ...) : expected a string of length 3';
      }
      var offset = 1;
      switch (vanity_text[2]) {
        case '4':
        case 'a':
        case 'e':
        case 'i':
        case 'm':
        case 'q':
        case 'u':
        case 'y':
          offset = 0;
      }
      while (true) {
        if (vanity_attempt > max_vanity_attempt) {
          // give up:
          throw 'Failed to brute-force a number that generates the desired vanity text.';
        } else {
          var root = get_root_with_vanity(vanity_attempt, ipfs_directory_hashes);
          if (root.hash[root.hash.length-1-offset] == vanity_text[2] && root.hash[root.hash.length-2-offset] == vanity_text[1]) {
            console.error(vanity_attempt + ' (' + Math.floor(100*vanity_attempt/expected_vanity_attempt) + '%)');
            if (root.hash[root.hash.length-3-offset] == vanity_text[0]) {
              return vanity_attempt;
            }
          }
          vanity_attempt++;
        }
      }
    };

    function find_vanity_browser_(offset, old_root, vanity_text, vanity_attempt, callback, ipfs_directory_hashes) {
      var root = get_root_with_vanity(vanity_attempt, ipfs_directory_hashes);
      if (vanity_attempt > max_vanity_attempt) {
        // give up:
        root = get_root_with_vanity(ipfs_directory_hashes.vanity_number, ipfs_directory_hashes)
        callback(root, 'timeout', false);
      } else {
        if (root.hash[root.hash.length-1-offset] == vanity_text[2]) {
          callback(old_root, '… ' + vanity_attempt + ' (' + Math.floor(100*vanity_attempt/expected_vanity_attempt) + '%)', false);
          if (root.hash[root.hash.length-2-offset] == vanity_text[1] && root.hash[root.hash.length-3-offset] == vanity_text[0]) {
            callback(root, vanity_attempt, true);
          } else {
            window.setTimeout(function() { find_vanity_browser_(offset, old_root, vanity_text, vanity_attempt + 1, callback, ipfs_directory_hashes); }, 0);
          }
        } else {
          window.setTimeout(function() { find_vanity_browser_(offset, old_root, vanity_text, vanity_attempt + 1, callback, ipfs_directory_hashes); }, 0);
        }
      }
    };

    var find_vanity_browser = function(old_root, vanity_text, vanity_attempt, callback, ipfs_directory_hashes) {
      if ((! (typeof vanity_text == 'string' || vanity_text instanceof String)) || vanity_text.length != 3) {
        throw 'find_vanity_node(vanity_text, ...) : expected a string of length 3';
      }
      var offset = 1;
      switch (vanity_text[2]) {
        case '4':
        case 'a':
        case 'e':
        case 'i':
        case 'm':
        case 'q':
        case 'u':
        case 'y':
          offset = 0;
      }
      return find_vanity_browser(offset, old_root, vanity_text, vanity_attempt, callback, ipfs_directory_hashes)
    };
  
    var debug = function(show_link) {
      var root = get_root_with_vanity(ipfs_directory_hashes.vanity_number, ipfs_directory_hashes);
      var vanity_text = ipfs_directory_hashes.vanity_text;
  
      if (root.hash[root.hash.length-1] == vanity_text[2] && root.hash[root.hash.length-2] == vanity_text[1] && root.hash[root.hash.length-3] == vanity_text[0]) {
        // vanity check is ok
        show_link(root, ipfs_directory_hashes.vanity_number, true);
      } else {
        // Brute-force to try to find a number that gives the desired last 3 characters
        show_link(root, '…', false);
        find_vanity_browser(root, vanity_text, 0, show_link, ipfs_directory_hashes);
      }
    };

    var get_link = function get_link() {
      var root = get_root_with_vanity(ipfs_directory_hashes.vanity_number, ipfs_directory_hashes);
      return root.hash;
    };
    
    return { get_link: get_link, find_vanity_browser: find_vanity_browser, find_vanity_node: find_vanity_node };
  })();

  function jsonp_ipfs_directory_hashes(arg) {
    ipfs_directory_hashes = arg;
  }

  if (typeof module != 'undefined') { module.exports = { micro_ipfs : micro_ipfs, ipfs_self_hash : ipfs_self_hash }; }