@did-btcr2/method 0.43.0 → 0.45.0

package/dist/cjs/index.js

@@ -1,30 +1,20 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -53,6 +43,8 @@ __export(index_exports, {
   GenesisDocument: () => GenesisDocument,
   ID_PLACEHOLDER_VALUE: () => ID_PLACEHOLDER_VALUE,
   Identifier: () => Identifier,
+  MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX: () => MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX,
+  MULTIKEY_VERIFICATION_METHOD_TYPE: () => MULTIKEY_VERIFICATION_METHOD_TYPE,
   P2PKH_BEACON_TX_VSIZE: () => P2PKH_BEACON_TX_VSIZE,
   P2TR_BEACON_TX_VSIZE: () => P2TR_BEACON_TX_VSIZE,
   P2WPKH_BEACON_TX_VSIZE: () => P2WPKH_BEACON_TX_VSIZE,
@@ -70,6 +62,7 @@ __export(index_exports, {
   deriveSingletonAddress: () => deriveSingletonAddress,
   detectSingletonScriptKind: () => detectSingletonScriptKind,
   extractOpReturnSignal: () => extractOpReturnSignal,
+  isMultikeyVerificationMethod: () => isMultikeyVerificationMethod,
   opReturnScript: () => opReturnScript,
   resolveBtcr2SenderPk: () => resolveBtcr2SenderPk,
   resolveChangeAddress: () => resolveChangeAddress
@@ -132,8 +125,8 @@ var DUST_LIMIT_SATS = {
   p2tr: 330
 };
 function beaconTxVsize(beaconKind, changeKind) {
-  const base2 = SINGLETON_BEACON_TX_VSIZE[beaconKind] - CHANGE_OUTPUT_VBYTES[beaconKind];
-  return base2 + CHANGE_OUTPUT_VBYTES[changeKind];
+  const base = SINGLETON_BEACON_TX_VSIZE[beaconKind] - CHANGE_OUTPUT_VBYTES[beaconKind];
+  return base + CHANGE_OUTPUT_VBYTES[changeKind];
 }
 function detectSingletonScriptKind(bitcoinAddress, network) {
   const decoded = (0, import_btc_signer.Address)(network).decode(bitcoinAddress);
@@ -686,882 +679,6 @@ var import_btc_signer2 = require("@scure/btc-signer");
 
 // src/utils/appendix.ts
 var import_dids = require("@web5/dids");
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bytes.js
-var empty = new Uint8Array(0);
-function equals(aa, bb) {
-  if (aa === bb) {
-    return true;
-  }
-  if (aa.byteLength !== bb.byteLength) {
-    return false;
-  }
-  for (let ii = 0; ii < aa.byteLength; ii++) {
-    if (aa[ii] !== bb[ii]) {
-      return false;
-    }
-  }
-  return true;
-}
-function coerce(o) {
-  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
-    return o;
-  }
-  if (o instanceof ArrayBuffer) {
-    return new Uint8Array(o);
-  }
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
-  }
-  throw new Error("Unknown type, must be binary type");
-}
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/base-x.js
-function base(ALPHABET, name) {
-  if (ALPHABET.length >= 255) {
-    throw new TypeError("Alphabet too long");
-  }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) {
-      throw new TypeError(x + " is ambiguous");
-    }
-    BASE_MAP[xc] = i;
-  }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256);
-  var iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode4(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      pbegin++;
-    }
-    var it2 = size - length2;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
-    }
-    return str;
-  }
-  function decodeUnsafe(source) {
-    if (typeof source !== "string") {
-      throw new TypeError("Expected String");
-    }
-    if (source.length === 0) {
-      return new Uint8Array();
-    }
-    var psz = 0;
-    if (source[psz] === " ") {
-      return;
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    var size = (source.length - psz) * FACTOR + 1 >>> 0;
-    var b256 = new Uint8Array(size);
-    while (source[psz]) {
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-      if (carry === 255) {
-        return;
-      }
-      var i2 = 0;
-      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      psz++;
-    }
-    if (source[psz] === " ") {
-      return;
-    }
-    var it4 = size - length2;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j2 = zeroes;
-    while (it4 !== size) {
-      vch[j2++] = b256[it4++];
-    }
-    return vch;
-  }
-  function decode6(string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) {
-      return buffer;
-    }
-    throw new Error(`Non-${name} character`);
-  }
-  return {
-    encode: encode4,
-    decodeUnsafe,
-    decode: decode6
-  };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base.js
-var Encoder = class {
-  name;
-  prefix;
-  baseEncode;
-  constructor(name, prefix, baseEncode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-  encode(bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`;
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-var Decoder = class {
-  name;
-  prefix;
-  baseDecode;
-  prefixCodePoint;
-  constructor(name, prefix, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    const prefixCodePoint = prefix.codePointAt(0);
-    if (prefixCodePoint === void 0) {
-      throw new Error("Invalid prefix character");
-    }
-    this.prefixCodePoint = prefixCodePoint;
-    this.baseDecode = baseDecode;
-  }
-  decode(text) {
-    if (typeof text === "string") {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-      }
-      return this.baseDecode(text.slice(this.prefix.length));
-    } else {
-      throw Error("Can only multibase decode strings");
-    }
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-};
-var ComposedDecoder = class {
-  decoders;
-  constructor(decoders) {
-    this.decoders = decoders;
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-  decode(input) {
-    const prefix = input[0];
-    const decoder = this.decoders[prefix];
-    if (decoder != null) {
-      return decoder.decode(input);
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-    }
-  }
-};
-function or(left, right) {
-  return new ComposedDecoder({
-    ...left.decoders ?? { [left.prefix]: left },
-    ...right.decoders ?? { [right.prefix]: right }
-  });
-}
-var Codec = class {
-  name;
-  prefix;
-  baseEncode;
-  baseDecode;
-  encoder;
-  decoder;
-  constructor(name, prefix, baseEncode, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
-  }
-  encode(input) {
-    return this.encoder.encode(input);
-  }
-  decode(input) {
-    return this.decoder.decode(input);
-  }
-};
-function from({ name, prefix, encode: encode4, decode: decode6 }) {
-  return new Codec(name, prefix, encode4, decode6);
-}
-function baseX({ name, prefix, alphabet }) {
-  const { encode: encode4, decode: decode6 } = base_x_default(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode: encode4,
-    decode: (text) => coerce(decode6(text))
-  });
-}
-function decode2(string, alphabetIdx, bitsPerChar, name) {
-  let end = string.length;
-  while (string[end - 1] === "=") {
-    --end;
-  }
-  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-  let bits = 0;
-  let buffer = 0;
-  let written = 0;
-  for (let i = 0; i < end; ++i) {
-    const value = alphabetIdx[string[i]];
-    if (value === void 0) {
-      throw new SyntaxError(`Non-${name} character`);
-    }
-    buffer = buffer << bitsPerChar | value;
-    bits += bitsPerChar;
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 255 & buffer >> bits;
-    }
-  }
-  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
-    throw new SyntaxError("Unexpected end of data");
-  }
-  return out;
-}
-function encode2(data, alphabet, bitsPerChar) {
-  const pad = alphabet[alphabet.length - 1] === "=";
-  const mask = (1 << bitsPerChar) - 1;
-  let out = "";
-  let bits = 0;
-  let buffer = 0;
-  for (let i = 0; i < data.length; ++i) {
-    buffer = buffer << 8 | data[i];
-    bits += 8;
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & buffer >> bits];
-    }
-  }
-  if (bits !== 0) {
-    out += alphabet[mask & buffer << bitsPerChar - bits];
-  }
-  if (pad) {
-    while ((out.length * bitsPerChar & 7) !== 0) {
-      out += "=";
-    }
-  }
-  return out;
-}
-function createAlphabetIdx(alphabet) {
-  const alphabetIdx = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    alphabetIdx[alphabet[i]] = i;
-  }
-  return alphabetIdx;
-}
-function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
-  const alphabetIdx = createAlphabetIdx(alphabet);
-  return from({
-    prefix,
-    name,
-    encode(input) {
-      return encode2(input, alphabet, bitsPerChar);
-    },
-    decode(input) {
-      return decode2(input, alphabetIdx, bitsPerChar, name);
-    }
-  });
-}
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base32.js
-var base32 = rfc4648({
-  prefix: "b",
-  name: "base32",
-  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
-  bitsPerChar: 5
-});
-var base32upper = rfc4648({
-  prefix: "B",
-  name: "base32upper",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
-  bitsPerChar: 5
-});
-var base32pad = rfc4648({
-  prefix: "c",
-  name: "base32pad",
-  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
-  bitsPerChar: 5
-});
-var base32padupper = rfc4648({
-  prefix: "C",
-  name: "base32padupper",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
-  bitsPerChar: 5
-});
-var base32hex = rfc4648({
-  prefix: "v",
-  name: "base32hex",
-  alphabet: "0123456789abcdefghijklmnopqrstuv",
-  bitsPerChar: 5
-});
-var base32hexupper = rfc4648({
-  prefix: "V",
-  name: "base32hexupper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
-  bitsPerChar: 5
-});
-var base32hexpad = rfc4648({
-  prefix: "t",
-  name: "base32hexpad",
-  alphabet: "0123456789abcdefghijklmnopqrstuv=",
-  bitsPerChar: 5
-});
-var base32hexpadupper = rfc4648({
-  prefix: "T",
-  name: "base32hexpadupper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
-  bitsPerChar: 5
-});
-var base32z = rfc4648({
-  prefix: "h",
-  name: "base32z",
-  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
-  bitsPerChar: 5
-});
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base36.js
-var base36 = baseX({
-  prefix: "k",
-  name: "base36",
-  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
-});
-var base36upper = baseX({
-  prefix: "K",
-  name: "base36upper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-});
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base58.js
-var base58btc = baseX({
-  name: "base58btc",
-  prefix: "z",
-  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-});
-var base58flickr = baseX({
-  name: "base58flickr",
-  prefix: "Z",
-  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-});
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/varint.js
-var encode_1 = encode3;
-var MSB = 128;
-var REST = 127;
-var MSBALL = ~REST;
-var INT = Math.pow(2, 31);
-function encode3(num, out, offset) {
-  out = out || [];
-  offset = offset || 0;
-  var oldOffset = offset;
-  while (num >= INT) {
-    out[offset++] = num & 255 | MSB;
-    num /= 128;
-  }
-  while (num & MSBALL) {
-    out[offset++] = num & 255 | MSB;
-    num >>>= 7;
-  }
-  out[offset] = num | 0;
-  encode3.bytes = offset - oldOffset + 1;
-  return out;
-}
-var decode3 = read;
-var MSB$1 = 128;
-var REST$1 = 127;
-function read(buf, offset) {
-  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
-  do {
-    if (counter >= l) {
-      read.bytes = 0;
-      throw new RangeError("Could not decode varint");
-    }
-    b = buf[counter++];
-    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
-    shift += 7;
-  } while (b >= MSB$1);
-  read.bytes = counter - offset;
-  return res;
-}
-var N1 = Math.pow(2, 7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-var length = function(value) {
-  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
-};
-var varint = {
-  encode: encode_1,
-  decode: decode3,
-  encodingLength: length
-};
-var _brrp_varint = varint;
-var varint_default = _brrp_varint;
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/varint.js
-function decode4(data, offset = 0) {
-  const code = varint_default.decode(data, offset);
-  return [code, varint_default.decode.bytes];
-}
-function encodeTo(int, target, offset = 0) {
-  varint_default.encode(int, target, offset);
-  return target;
-}
-function encodingLength(int) {
-  return varint_default.encodingLength(int);
-}
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/digest.js
-function create(code, digest) {
-  const size = digest.byteLength;
-  const sizeOffset = encodingLength(code);
-  const digestOffset = sizeOffset + encodingLength(size);
-  const bytes = new Uint8Array(digestOffset + size);
-  encodeTo(code, bytes, 0);
-  encodeTo(size, bytes, sizeOffset);
-  bytes.set(digest, digestOffset);
-  return new Digest(code, size, digest, bytes);
-}
-function decode5(multihash) {
-  const bytes = coerce(multihash);
-  const [code, sizeOffset] = decode4(bytes);
-  const [size, digestOffset] = decode4(bytes.subarray(sizeOffset));
-  const digest = bytes.subarray(sizeOffset + digestOffset);
-  if (digest.byteLength !== size) {
-    throw new Error("Incorrect length");
-  }
-  return new Digest(code, size, digest, bytes);
-}
-function equals2(a, b) {
-  if (a === b) {
-    return true;
-  } else {
-    const data = b;
-    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
-  }
-}
-var Digest = class {
-  code;
-  size;
-  digest;
-  bytes;
-  /**
-   * Creates a multihash digest.
-   */
-  constructor(code, size, digest, bytes) {
-    this.code = code;
-    this.size = size;
-    this.digest = digest;
-    this.bytes = bytes;
-  }
-};
-
-// ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/cid.js
-function format(link, base2) {
-  const { bytes, version } = link;
-  switch (version) {
-    case 0:
-      return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encoder);
-    default:
-      return toStringV1(bytes, baseCache(link), base2 ?? base32.encoder);
-  }
-}
-var cache = /* @__PURE__ */ new WeakMap();
-function baseCache(cid) {
-  const baseCache2 = cache.get(cid);
-  if (baseCache2 == null) {
-    const baseCache3 = /* @__PURE__ */ new Map();
-    cache.set(cid, baseCache3);
-    return baseCache3;
-  }
-  return baseCache2;
-}
-var CID = class _CID {
-  code;
-  version;
-  multihash;
-  bytes;
-  "/";
-  /**
-   * @param version - Version of the CID
-   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param multihash - (Multi)hash of the of the content.
-   */
-  constructor(version, code, multihash, bytes) {
-    this.code = code;
-    this.version = version;
-    this.multihash = multihash;
-    this.bytes = bytes;
-    this["/"] = bytes;
-  }
-  /**
-   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
-   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
-   *
-   * @deprecated
-   */
-  get asCID() {
-    return this;
-  }
-  // ArrayBufferView
-  get byteOffset() {
-    return this.bytes.byteOffset;
-  }
-  // ArrayBufferView
-  get byteLength() {
-    return this.bytes.byteLength;
-  }
-  toV0() {
-    switch (this.version) {
-      case 0: {
-        return this;
-      }
-      case 1: {
-        const { code, multihash } = this;
-        if (code !== DAG_PB_CODE) {
-          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
-        }
-        if (multihash.code !== SHA_256_CODE) {
-          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
-        }
-        return _CID.createV0(multihash);
-      }
-      default: {
-        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
-      }
-    }
-  }
-  toV1() {
-    switch (this.version) {
-      case 0: {
-        const { code, digest } = this.multihash;
-        const multihash = create(code, digest);
-        return _CID.createV1(this.code, multihash);
-      }
-      case 1: {
-        return this;
-      }
-      default: {
-        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
-      }
-    }
-  }
-  equals(other) {
-    return _CID.equals(this, other);
-  }
-  static equals(self, other) {
-    const unknown = other;
-    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
-  }
-  toString(base2) {
-    return format(this, base2);
-  }
-  toJSON() {
-    return { "/": format(this) };
-  }
-  link() {
-    return this;
-  }
-  [Symbol.toStringTag] = "CID";
-  // Legacy
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return `CID(${this.toString()})`;
-  }
-  /**
-   * Takes any input `value` and returns a `CID` instance if it was
-   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-   * it will return value back. If `value` is not instance of this CID
-   * class, but is compatible CID it will return new instance of this
-   * `CID` class. Otherwise returns null.
-   *
-   * This allows two different incompatible versions of CID library to
-   * co-exist and interop as long as binary interface is compatible.
-   */
-  static asCID(input) {
-    if (input == null) {
-      return null;
-    }
-    const value = input;
-    if (value instanceof _CID) {
-      return value;
-    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
-      const { version, code, multihash, bytes } = value;
-      return new _CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
-    } else if (value[cidSymbol] === true) {
-      const { version, multihash, code } = value;
-      const digest = decode5(multihash);
-      return _CID.create(version, code, digest);
-    } else {
-      return null;
-    }
-  }
-  /**
-   * @param version - Version of the CID
-   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param digest - (Multi)hash of the of the content.
-   */
-  static create(version, code, digest) {
-    if (typeof code !== "number") {
-      throw new Error("String codecs are no longer supported");
-    }
-    if (!(digest.bytes instanceof Uint8Array)) {
-      throw new Error("Invalid digest");
-    }
-    switch (version) {
-      case 0: {
-        if (code !== DAG_PB_CODE) {
-          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
-        } else {
-          return new _CID(version, code, digest, digest.bytes);
-        }
-      }
-      case 1: {
-        const bytes = encodeCID(version, code, digest.bytes);
-        return new _CID(version, code, digest, bytes);
-      }
-      default: {
-        throw new Error("Invalid version");
-      }
-    }
-  }
-  /**
-   * Simplified version of `create` for CIDv0.
-   */
-  static createV0(digest) {
-    return _CID.create(0, DAG_PB_CODE, digest);
-  }
-  /**
-   * Simplified version of `create` for CIDv1.
-   *
-   * @param code - Content encoding format code.
-   * @param digest - Multihash of the content.
-   */
-  static createV1(code, digest) {
-    return _CID.create(1, code, digest);
-  }
-  /**
-   * Decoded a CID from its binary representation. The byte array must contain
-   * only the CID with no additional bytes.
-   *
-   * An error will be thrown if the bytes provided do not contain a valid
-   * binary representation of a CID.
-   */
-  static decode(bytes) {
-    const [cid, remainder] = _CID.decodeFirst(bytes);
-    if (remainder.length !== 0) {
-      throw new Error("Incorrect length");
-    }
-    return cid;
-  }
-  /**
-   * Decoded a CID from its binary representation at the beginning of a byte
-   * array.
-   *
-   * Returns an array with the first element containing the CID and the second
-   * element containing the remainder of the original byte array. The remainder
-   * will be a zero-length byte array if the provided bytes only contained a
-   * binary CID representation.
-   */
-  static decodeFirst(bytes) {
-    const specs = _CID.inspectBytes(bytes);
-    const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
-    if (multihashBytes.byteLength !== specs.multihashSize) {
-      throw new Error("Incorrect length");
-    }
-    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
-    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
-    const cid = specs.version === 0 ? _CID.createV0(digest) : _CID.createV1(specs.codec, digest);
-    return [cid, bytes.subarray(specs.size)];
-  }
-  /**
-   * Inspect the initial bytes of a CID to determine its properties.
-   *
-   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-   * bytes but for larger multicodec code values and larger multihash digest
-   * lengths these varints can be quite large. It is recommended that at least
-   * 10 bytes be made available in the `initialBytes` argument for a complete
-   * inspection.
-   */
-  static inspectBytes(initialBytes) {
-    let offset = 0;
-    const next = () => {
-      const [i, length2] = decode4(initialBytes.subarray(offset));
-      offset += length2;
-      return i;
-    };
-    let version = next();
-    let codec = DAG_PB_CODE;
-    if (version === 18) {
-      version = 0;
-      offset = 0;
-    } else {
-      codec = next();
-    }
-    if (version !== 0 && version !== 1) {
-      throw new RangeError(`Invalid CID version ${version}`);
-    }
-    const prefixSize = offset;
-    const multihashCode = next();
-    const digestSize = next();
-    const size = offset + digestSize;
-    const multihashSize = size - prefixSize;
-    return { version, codec, multihashCode, digestSize, multihashSize, size };
-  }
-  /**
-   * Takes cid in a string representation and creates an instance. If `base`
-   * decoder is not provided will use a default from the configuration. It will
-   * throw an error if encoding of the CID is not compatible with supplied (or
-   * a default decoder).
-   */
-  static parse(source, base2) {
-    const [prefix, bytes] = parseCIDtoBytes(source, base2);
-    const cid = _CID.decode(bytes);
-    if (cid.version === 0 && source[0] !== "Q") {
-      throw Error("Version 0 CID string must not include multibase prefix");
-    }
-    baseCache(cid).set(prefix, source);
-    return cid;
-  }
-};
-function parseCIDtoBytes(source, base2) {
-  switch (source[0]) {
-    // CIDv0 is parsed differently
-    case "Q": {
-      const decoder = base2 ?? base58btc;
-      return [
-        base58btc.prefix,
-        decoder.decode(`${base58btc.prefix}${source}`)
-      ];
-    }
-    case base58btc.prefix: {
-      const decoder = base2 ?? base58btc;
-      return [base58btc.prefix, decoder.decode(source)];
-    }
-    case base32.prefix: {
-      const decoder = base2 ?? base32;
-      return [base32.prefix, decoder.decode(source)];
-    }
-    case base36.prefix: {
-      const decoder = base2 ?? base36;
-      return [base36.prefix, decoder.decode(source)];
-    }
-    default: {
-      if (base2 == null) {
-        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
-      }
-      return [source[0], base2.decode(source)];
-    }
-  }
-}
-function toStringV0(bytes, cache2, base2) {
-  const { prefix } = base2;
-  if (prefix !== base58btc.prefix) {
-    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
-  }
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes).slice(1);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-}
-function toStringV1(bytes, cache2, base2) {
-  const { prefix } = base2;
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-}
-var DAG_PB_CODE = 112;
-var SHA_256_CODE = 18;
-function encodeCID(version, code, multihash) {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code);
-  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes, 0);
-  encodeTo(code, bytes, codeOffset);
-  bytes.set(multihash, hashOffset);
-  return bytes;
-}
-var cidSymbol = Symbol.for("@ipld/js-cid/CID");
-
-// src/utils/appendix.ts
 var Appendix = class _Appendix {
   /**
    * Extracts a DID fragment from a given input
@@ -1707,25 +824,12 @@ var Appendix = class _Appendix {
     rootCapability.invocationTarget = Identifier2;
     return rootCapability;
   }
-  /**
-   * Implements CAS Lookup Step from {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-beacon-signals | 7.2.e Process Beacon Signals }.
-   * @param {HashBytes} hashBytes The hash bytes to look up in the CAS system.
-   * @returns {Promise<string | undefined>} The content fetched from the CAS system, or undefined if not found.
-   */
-  static async fetchFromCas(hashBytes) {
-    const cid = CID.create(1, 1, create(1, hashBytes));
-    const { createHelia } = await import("helia");
-    const { strings } = await import("@helia/strings");
-    const helia = await createHelia();
-    const node = strings(helia);
-    return await node.get(cid, {});
-  }
 };
 
 // src/core/identifier.ts
 var import_common6 = require("@did-btcr2/common");
 var import_keypair = require("@did-btcr2/keypair");
-var import_base4 = require("@scure/base");
+var import_base = require("@scure/base");
 var Identifier = class _Identifier {
   /**
    * Implements {@link https://dcdpr.github.io/did-btcr2/#didbtcr2-identifier-encoding | 3.2 did:btcr2 Identifier Encoding}.
@@ -1787,7 +891,7 @@ var Identifier = class _Identifier {
       }
     }
     const dataBytes = new Uint8Array([nibbles[2 * 0] << 4 | nibbles[2 * 0 + 1], ...genesisBytes]);
-    return `did:btcr2:${import_base4.bech32m.encodeFromBytes(hrp, dataBytes)}`;
+    return `did:btcr2:${import_base.bech32m.encodeFromBytes(hrp, dataBytes)}`;
   }
   /**
    * Implements {@link https://dcdpr.github.io/did-btcr2/#didbtcr2-identifier-decoding | 3.3 did:btcr2 Identifier Decoding}.
@@ -1812,7 +916,7 @@ var Identifier = class _Identifier {
     if (!encoded) {
       throw new import_common6.IdentifierError(`Invalid method-specific id: ${identifier}`, import_common6.INVALID_DID, { identifier });
     }
-    const { prefix: hrp, bytes: dataBytes } = import_base4.bech32m.decodeToBytes(encoded);
+    const { prefix: hrp, bytes: dataBytes } = import_base.bech32m.decodeToBytes(encoded);
     if (!["x", "k"].includes(hrp)) {
       throw new import_common6.IdentifierError(`Invalid hrp: ${hrp}`, import_common6.INVALID_DID, { identifier });
     }
@@ -2233,9 +1337,18 @@ var BTCR2_DID_DOCUMENT_CONTEXT = [
   "https://www.w3.org/ns/did/v1.1",
   "https://btcr2.dev/context/v1"
 ];
+var MULTIKEY_VERIFICATION_METHOD_TYPE = "Multikey";
+var MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX = "zQ3s";
 var ID_PLACEHOLDER_VALUE = "did:btcr2:_";
 var BECH32M_CHARS = "";
 var DID_REGEX = /did:btcr2:(x1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*)/g;
+function isMultikeyVerificationMethod(vm) {
+  if (!Appendix.isDidVerificationMethod(vm)) {
+    return false;
+  }
+  const { type, publicKeyMultibase } = vm;
+  return type === MULTIKEY_VERIFICATION_METHOD_TYPE && typeof publicKeyMultibase === "string" && publicKeyMultibase.startsWith(MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX);
+}
 var DidVerificationMethod = class {
   id;
   type;
@@ -2243,6 +1356,20 @@ var DidVerificationMethod = class {
   publicKeyMultibase;
   secretKeyMultibase;
   constructor({ id, type, controller, publicKeyMultibase, secretKeyMultibase }) {
+    if (type !== MULTIKEY_VERIFICATION_METHOD_TYPE) {
+      throw new import_common9.DidDocumentError(
+        `Invalid verification method: type must be "${MULTIKEY_VERIFICATION_METHOD_TYPE}"`,
+        import_common9.INVALID_DID_DOCUMENT,
+        { id, type }
+      );
+    }
+    if (typeof publicKeyMultibase !== "string" || !publicKeyMultibase.startsWith(MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX)) {
+      throw new import_common9.DidDocumentError(
+        `Invalid verification method: publicKeyMultibase must start with "${MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX}"`,
+        import_common9.INVALID_DID_DOCUMENT,
+        { id, publicKeyMultibase }
+      );
+    }
     this.id = id;
     this.type = type;
     this.controller = controller;
@@ -2401,10 +1528,8 @@ var DidDocument = class _DidDocument {
    * @returns {boolean} True if the context is valid.
    */
   static isValidContext(context) {
-    if (!context) return false;
-    if (!Array.isArray(context)) return false;
-    if (!context.every((ctx) => typeof ctx === "string" && BTCR2_DID_DOCUMENT_CONTEXT.includes(ctx))) return false;
-    return true;
+    if (!Array.isArray(context) || context.length === 0) return false;
+    return BTCR2_DID_DOCUMENT_CONTEXT.every((required) => context.includes(required));
   }
   /**
    * Validates that the DID Document has a valid id.
@@ -2428,7 +1553,7 @@ var DidDocument = class _DidDocument {
    * @returns {boolean} True if the verification methods are valid.
    */
   static isValidVerificationMethods(verificationMethod) {
-    return Array.isArray(verificationMethod) && verificationMethod.every(Appendix.isDidVerificationMethod);
+    return Array.isArray(verificationMethod) && verificationMethod.every(isMultikeyVerificationMethod);
   }
   /**
    * Validates that the DID Document has valid services.
@@ -2970,16 +2095,16 @@ var DidBtcr2 = class {
         { sourceDocument, verificationMethodId }
       );
     }
-    if (verificationMethod.type !== "Multikey") {
+    if (verificationMethod.type !== MULTIKEY_VERIFICATION_METHOD_TYPE) {
       throw new import_common11.UpdateError(
-        'Invalid verificationMethod: verificationMethod.type must be "Multikey"',
+        `Invalid verificationMethod: verificationMethod.type must be "${MULTIKEY_VERIFICATION_METHOD_TYPE}"`,
         import_common11.INVALID_DID_DOCUMENT,
         verificationMethod
       );
     }
-    if (verificationMethod.publicKeyMultibase?.slice(0, 4) !== "zQ3s") {
+    if (!verificationMethod.publicKeyMultibase?.startsWith(MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX)) {
       throw new import_common11.UpdateError(
-        'Invalid verificationMethodId: publicKeyMultibase prefix must start with "zQ3s"',
+        `Invalid verificationMethodId: publicKeyMultibase prefix must start with "${MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX}"`,
         import_common11.INVALID_DID_DOCUMENT,
         verificationMethod
       );
@@ -3587,6 +2712,8 @@ var DidDocumentBuilder = class {
   GenesisDocument,
   ID_PLACEHOLDER_VALUE,
   Identifier,
+  MULTIKEY_PUBLIC_KEY_MULTIBASE_PREFIX,
+  MULTIKEY_VERIFICATION_METHOD_TYPE,
   P2PKH_BEACON_TX_VSIZE,
   P2TR_BEACON_TX_VSIZE,
   P2WPKH_BEACON_TX_VSIZE,
@@ -3604,6 +2731,7 @@ var DidDocumentBuilder = class {
   deriveSingletonAddress,
   detectSingletonScriptKind,
   extractOpReturnSignal,
+  isMultikeyVerificationMethod,
   opReturnScript,
   resolveBtcr2SenderPk,
   resolveChangeAddress