ipns-did/dist/index.js

Library for resolving, creating, and publishing DID documents over IPNS

var didResolver = require('did-resolver');
var IPNSMethod = require('ipns-did-resolver');
var multiformatMulticodec = require('multiformat-multicodec');
var sha2 = require('multiformats/hashes/sha2');
var json = require('@ipld/dag-json');
var cbor = require('@ipld/dag-cbor');
var pb = require('@ipld/dag-pb');
var didDoc = require('did-doc');
var ipns = require('ipns');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n["default"] = e;
  return n;
}

var IPNSMethod__namespace = /*#__PURE__*/_interopNamespace(IPNSMethod);
var json__namespace = /*#__PURE__*/_interopNamespace(json);
var cbor__namespace = /*#__PURE__*/_interopNamespace(cbor);
var pb__namespace = /*#__PURE__*/_interopNamespace(pb);
var ipns__namespace = /*#__PURE__*/_interopNamespace(ipns);

function _asyncIterator(iterable) {
  var method,
      async,
      sync,
      retry = 2;

  for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
    if (async && null != (method = iterable[async])) return method.call(iterable);
    if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
    async = "@@asyncIterator", sync = "@@iterator";
  }

  throw new TypeError("Object is not async iterable");
}

function AsyncFromSyncIterator(s) {
  function AsyncFromSyncIteratorContinuation(r) {
    if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
    var done = r.done;
    return Promise.resolve(r.value).then(function (value) {
      return {
        value: value,
        done: done
      };
    });
  }

  return AsyncFromSyncIterator = function (s) {
    this.s = s, this.n = s.next;
  }, AsyncFromSyncIterator.prototype = {
    s: null,
    n: null,
    next: function () {
      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
    },
    return: function (value) {
      var ret = this.s.return;
      return void 0 === ret ? Promise.resolve({
        value: value,
        done: !0
      }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
    },
    throw: function (value) {
      var thr = this.s.return;
      return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
    }
  }, new AsyncFromSyncIterator(s);
}

function _settle(pact, state, value) {
  if (!pact.s) {
    if (value instanceof _Pact) {
      if (value.s) {
        if (state & 1) {
          state = value.s;
        }

        value = value.v;
      } else {
        value.o = _settle.bind(null, pact, state);
        return;
      }
    }

    if (value && value.then) {
      value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
      return;
    }

    pact.s = state;
    pact.v = value;
    const observer = pact.o;

    if (observer) {
      observer(pact);
    }
  }
}

var _Pact = /*#__PURE__*/function () {
  function _Pact() {}

  _Pact.prototype.then = function (onFulfilled, onRejected) {
    var result = new _Pact();
    var state = this.s;

    if (state) {
      var callback = state & 1 ? onFulfilled : onRejected;

      if (callback) {
        try {
          _settle(result, 1, callback(this.v));
        } catch (e) {
          _settle(result, 2, e);
        }

        return result;
      } else {
        return this;
      }
    }

    this.o = function (_this) {
      try {
        var value = _this.v;

        if (_this.s & 1) {
          _settle(result, 1, onFulfilled ? onFulfilled(value) : value);
        } else if (onRejected) {
          _settle(result, 1, onRejected(value));
        } else {
          _settle(result, 2, value);
        }
      } catch (e) {
        _settle(result, 2, e);
      }
    };

    return result;
  };

  return _Pact;
}();

function _isSettledPact(thenable) {
  return thenable instanceof _Pact && thenable.s & 1;
}

function _for(test, update, body) {
  var stage;

  for (;;) {
    var shouldContinue = test();

    if (_isSettledPact(shouldContinue)) {
      shouldContinue = shouldContinue.v;
    }

    if (!shouldContinue) {
      return result;
    }

    if (shouldContinue.then) {
      stage = 0;
      break;
    }

    var result = body();

    if (result && result.then) {
      if (_isSettledPact(result)) {
        result = result.s;
      } else {
        stage = 1;
        break;
      }
    }

    if (update) {
      var updateValue = update();

      if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
        stage = 2;
        break;
      }
    }
  }

  var pact = new _Pact();

  var reject = _settle.bind(null, pact, 2);

  (stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
  return pact;

  function _resumeAfterBody(value) {
    result = value;

    do {
      if (update) {
        updateValue = update();

        if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
          updateValue.then(_resumeAfterUpdate).then(void 0, reject);
          return;
        }
      }

      shouldContinue = test();

      if (!shouldContinue || _isSettledPact(shouldContinue) && !shouldContinue.v) {
        _settle(pact, 1, result);

        return;
      }

      if (shouldContinue.then) {
        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
        return;
      }

      result = body();

      if (_isSettledPact(result)) {
        result = result.v;
      }
    } while (!result || !result.then);

    result.then(_resumeAfterBody).then(void 0, reject);
  }

  function _resumeAfterTest(shouldContinue) {
    if (shouldContinue) {
      result = body();

      if (result && result.then) {
        result.then(_resumeAfterBody).then(void 0, reject);
      } else {
        _resumeAfterBody(result);
      }
    } else {
      _settle(pact, 1, result);
    }
  }

  function _resumeAfterUpdate() {
    if (shouldContinue = test()) {
      if (shouldContinue.then) {
        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
      } else {
        _resumeAfterTest(shouldContinue);
      }
    } else {
      _settle(pact, 1, result);
    }
  }
}

function _catch(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

  if (result && result.then) {
    return result.then(void 0, recover);
  }

  return result;
}

function _finallyRethrows(body, finalizer) {
  try {
    var result = body();
  } catch (e) {
    return finalizer(true, e);
  }

  if (result && result.then) {
    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
  }

  return finalizer(false, result);
}

function index (opts) {
  var ipfs = opts.ipfs,
      multicodecs = opts.multicodecs;
  var multicodec = new multiformatMulticodec.BlockMulticodec({
    codecs: [json__namespace, pb__namespace, cbor__namespace].concat((multicodecs == null ? void 0 : multicodecs.codecs) || []),
    hashers: (multicodecs == null ? void 0 : multicodecs.hashers) || []
  });
  var ipnsResolver = IPNSMethod__namespace.getResolver(ipfs.block, ipfs.name, multicodec);
  var resolver = new didResolver.Resolver(ipnsResolver);
  return {
    /**
     * Resolve an IPNS method DID into a document.
     * @throws Will throw if DID method isn't `ipns`
     * @throws Will throw if IPNS cannot resolve into an IPFS CID
     * @throws Will throw if the document can't be found, or if the given path can't be followed
     */
    resolve: function resolve(did) {
      try {
        return Promise.resolve(resolver.resolve(did));
      } catch (e) {
        return Promise.reject(e);
      }
    },
    _publishValue: function _publishValue(value, codec, hasher) {
      try {
        if (codec === undefined) codec = cbor__namespace.code;
        if (hasher === undefined) hasher = sha2.sha256.code;
        return Promise.resolve(multicodec.encode({
          codec: codec,
          value: value,
          hasher: hasher
        })).then(function (serialized) {
          // Discard the returned CID, as we already got it during serialization;
          // and the ipfs-core API isn't as dynamic in what codecs it supports as we
          // are.
          return Promise.resolve(ipfs.block.put(serialized.bytes)).then(function () {
            return serialized.cid.toV1();
          });
        });
      } catch (e) {
        return Promise.reject(e);
      }
    },

    /**
     * Publish a DID document to IPNS using a given peer ID.
     * @param {DIDDocument} doc The DID document to publish
     * @param {Object} opts Document serialization options
     * @param {number} opts.codec Code of the codec used to serialize
     * @param {number} opts.hasher Code of the hasher used to serialize
     * @param {PeerId} peerId The peer ID (keypair) used to create the IPNS block
     * @param {number} lifetime The lifetime (TTL) of the published document, in milliseconds
     * @throws {TypeError} Will throw if the passed document isn't valid
     * @returns Returns the CIDs of the document and IPNS blocks
     */
    publishDid: function publishDid(doc, opts, peerId, lifetime) {
      try {
        var _iterator, _step, _iterator2, _step2;

        var _this2 = this;

        if (!didDoc.DIDDocument.isDoc(doc)) throw new TypeError("Passed doc isn't valid DID document");
        return Promise.resolve(_this2._publishValue(doc, opts.codec || cbor__namespace.code, opts.hasher || sha2.sha256.code)).then(function (ipfsCid) {
          var _exit;

          function _temp12(_result3) {
            return _exit ? _result3 : Promise.resolve(ipns__namespace.create(peerId, pathBytes, rev, lifetime)).then(function (ipnsEntry) {
              var _exit3;

              function _temp10(_result4) {
                return _exit3 ? _result4 : {
                  docCid: ipfsCid,
                  ipnsCid: ipnsCid
                };
              }

              var ipnsBlock = ipns__namespace.marshal(ipnsEntry);
              var _iteratorAbruptCompletion2 = false;
              var _didIteratorError2 = false;

              var _iteratorError2;

              var _temp9 = _finallyRethrows(function () {
                return _catch(function () {
                  _iterator2 = _asyncIterator(ipfs.dht.put(strkey, ipnsBlock));

                  var _temp5 = _for(function () {
                    return Promise.resolve(_iterator2.next()).then(function (_iterator2$next) {
                      return _iteratorAbruptCompletion2 = !(_step2 = _iterator2$next).done;
                    });
                  }, function () {
                    return !!(_iteratorAbruptCompletion2 = false);
                  }, function () {
                    var m = _step2.value;
                    ;
                  });

                  if (_temp5 && _temp5.then) return _temp5.then(function () {});
                }, function (err) {
                  _didIteratorError2 = true;
                  _iteratorError2 = err;
                });
              }, function (_wasThrown3, _result4) {
                function _temp8(_result5) {
                  if (_exit3) ;
                  if (_wasThrown3) throw _result4;
                  return _result4;
                }

                var _temp7 = _finallyRethrows(function () {
                  var _temp6 = function () {
                    if (_iteratorAbruptCompletion2 && _iterator2["return"] != null) {
                      return Promise.resolve(_iterator2["return"]()).then(function () {});
                    }
                  }();

                  if (_temp6 && _temp6.then) return _temp6.then(function () {});
                }, function (_wasThrown4, _result5) {
                  if (_didIteratorError2) {
                    throw _iteratorError2;
                  }

                  if (_wasThrown4) throw _result5;
                  return _result5;
                });

                return _temp7 && _temp7.then ? _temp7.then(_temp8) : _temp8(_temp7);
              });

              return _temp9 && _temp9.then ? _temp9.then(_temp10) : _temp10(_temp9);
            });
          }

          var ipfsPath = "/ipfs/" + ipfsCid.toString();
          var pathBytes = Buffer.from(ipfsPath);
          var ipnsCid = peerId.toCID();
          var strkey = "/ipns/" + ipnsCid.toString();
          var rev = BigInt(0);

          var _temp11 = _catch(function () {
            var _iteratorAbruptCompletion = false;
            var _didIteratorError = false;

            var _iteratorError;

            return _finallyRethrows(function () {
              return _catch(function () {
                _iterator = _asyncIterator(ipfs.dht.get(strkey));

                var _temp = _for(function () {
                  return Promise.resolve(_iterator.next()).then(function (_iterator$next) {
                    return _iteratorAbruptCompletion = !(_step = _iterator$next).done;
                  });
                }, function () {
                  return !!(_iteratorAbruptCompletion = false);
                }, function () {
                  var e = _step.value;

                  if (e.name === "VALUE") {
                    rev = ipns__namespace.unmarshal(e.value).sequence + BigInt(1);
                  }
                });

                if (_temp && _temp.then) return _temp.then(function () {});
              }, function (err) {
                _didIteratorError = true;
                _iteratorError = err;
              });
            }, function (_wasThrown, _result) {
              var _exit2;

              function _temp4(_result2) {
                if (_exit2) ;
                if (_wasThrown) throw _result;
                return _result;
              }

              var _temp3 = _finallyRethrows(function () {
                var _temp2 = function () {
                  if (_iteratorAbruptCompletion && _iterator["return"] != null) {
                    return Promise.resolve(_iterator["return"]()).then(function () {});
                  }
                }();

                if (_temp2 && _temp2.then) return _temp2.then(function () {});
              }, function (_wasThrown2, _result2) {
                if (_didIteratorError) {
                  throw _iteratorError;
                }

                if (_wasThrown2) throw _result2;
                return _result2;
              });

              return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
            });
          }, function () {});

          return _temp11 && _temp11.then ? _temp11.then(_temp12) : _temp12(_temp11);
        });
      } catch (e) {
        return Promise.reject(e);
      }
    },
    peerIdToDid: function peerIdToDid(peerId) {
      return "did:ipns:" + peerId.toCID();
    },
    domainToDid: function domainToDid(domain) {
      return "did:ipns:" + domain;
    }
  };
}

module.exports = index;
//# sourceMappingURL=index.js.map