@zoralabs/protocol-sdk 0.7.0 → 0.7.1

package/dist/index.js

@@ -42,8 +42,8 @@ import { parseAbi } from "viem";
 var ZORA_API_BASE = "https://api.zora.co/";
 var OPEN_EDITION_MINT_SIZE = BigInt("18446744073709551615");
 var SUBGRAPH_CONFIG_BASE = "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
-function getSubgraph(name, version) {
-  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
+function getSubgraph(name, version2) {
+  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version2}/gn`;
 }
 var zora721Abi = parseAbi([
   "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
@@ -346,7 +346,7 @@ function migratePremintConfigToV2({
   };
 }
 var recoverCreatorFromCreatorAttribution = async ({
-  creatorAttribution: { version, domainName, structHash, signature },
+  creatorAttribution: { version: version2, domainName, structHash, signature },
   chainId,
   tokenContract
 }) => {
@@ -355,7 +355,7 @@ var recoverCreatorFromCreatorAttribution = async ({
       chainId,
       name: domainName,
       verifyingContract: tokenContract,
-      version
+      version: version2
     },
     types: {
       EIP712Domain: [
@@ -391,11 +391,11 @@ var supportedPremintVersions = async ({
   });
 };
 var supportsPremintVersion = async ({
-  version,
+  version: version2,
   tokenContract,
   publicClient
 }) => {
-  return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version);
+  return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version2);
 };
 async function getPremintCollectionAddress({
   publicClient,
@@ -419,7 +419,7 @@ async function getPremintCollectionAddress({
 }
 function applyUpdateToPremint({
   uid,
-  version,
+  version: version2,
   tokenConfig,
   tokenConfigUpdates
 }) {
@@ -430,7 +430,7 @@ function applyUpdateToPremint({
   const result = {
     deleted: false,
     uid,
-    version: version + 1,
+    version: version2 + 1,
     tokenConfig: updatedTokenConfig
   };
   return result;
@@ -1219,13 +1219,19 @@ function makePremintReturn({
       premintConfigVersion
     });
   };
+  const urls = makeUrls({
+    chainId,
+    address: collectionAddress,
+    uid: premintConfig.uid
+  });
   return {
     premintConfig,
     premintConfigVersion,
     typedDataDefinition,
     collectionAddress,
     signAndSubmit,
-    submit
+    submit,
+    urls
   };
 }
 async function signPremint({
@@ -2867,13 +2873,13 @@ var unwrapAndForwardEthPermitAndTypedDataDefinition = ({
   chainId,
   tokenIds,
   quantities,
-  from,
+  from: from2,
   callWithEth,
   safeTransferData,
   deadline,
   nonce
 }) => makePermitTransferBatchAndTypeData({
-  mintsOwner: from,
+  mintsOwner: from2,
   chainId,
   deadline,
   tokenIds,
@@ -2921,6 +2927,1148 @@ function createCollectorClient(params) {
     getMintCosts: (p) => mintClient.getMintCosts(p)
   };
 }
+
+// src/ipfs/arweave.ts
+function isArweaveURL(url) {
+  return url && typeof url === "string" ? url.startsWith("ar://") : false;
+}
+
+// ../../node_modules/multiformats/esm/vendor/varint.js
+var encode_1 = encode;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode(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;
+  encode.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode = 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,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../node_modules/multiformats/esm/src/varint.js
+var decode2 = (data, offset = 0) => {
+  const code = varint_default.decode(data, offset);
+  return [
+    code,
+    varint_default.decode.bytes
+  ];
+};
+var encodeTo = (int, target, offset = 0) => {
+  varint_default.encode(int, target, offset);
+  return target;
+};
+var encodingLength = (int) => {
+  return varint_default.encodingLength(int);
+};
+
+// ../../node_modules/multiformats/esm/src/bytes.js
+var empty = new Uint8Array(0);
+var 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;
+};
+var coerce3 = (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/multiformats/esm/src/hashes/digest.js
+var 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);
+};
+var decode3 = (multihash) => {
+  const bytes = coerce3(multihash);
+  const [code, sizeOffset] = decode2(bytes);
+  const [size, digestOffset] = decode2(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);
+};
+var equals2 = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    return a.code === b.code && a.size === b.size && equals(a.bytes, b.bytes);
+  }
+};
+var Digest = class {
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+};
+
+// ../../node_modules/multiformats/esm/vendor/base-x.js
+function base2(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 encode3(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 decode5(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode: encode3,
+    decodeUnsafe,
+    decode: decode5
+  };
+}
+var src = base2;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/multiformats/esm/src/bases/base.js
+var Encoder = class {
+  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 {
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    if (prefix.codePointAt(0) === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefix.codePointAt(0);
+    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 {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      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`);
+    }
+  }
+};
+var or = (left, right) => new ComposedDecoder({
+  ...left.decoders || { [left.prefix]: left },
+  ...right.decoders || { [right.prefix]: right }
+});
+var Codec = class {
+  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);
+  }
+};
+var from = ({ name, prefix, encode: encode3, decode: decode5 }) => new Codec(name, prefix, encode3, decode5);
+var baseX = ({ prefix, name, alphabet }) => {
+  const { encode: encode3, decode: decode5 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode3,
+    decode: (text) => coerce3(decode5(text))
+  });
+};
+var decode4 = (string, alphabet, bitsPerChar, name) => {
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+  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 = codes[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) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+};
+var 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) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while (out.length * bitsPerChar & 7) {
+      out += "=";
+    }
+  }
+  return out;
+};
+var rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode2(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode4(input, alphabet, bitsPerChar, name);
+    }
+  });
+};
+
+// ../../node_modules/multiformats/esm/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/esm/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/multiformats/esm/src/cid.js
+var CID = class _CID {
+  constructor(version2, code, multihash, bytes) {
+    this.code = code;
+    this.version = version2;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this.byteOffset = bytes.byteOffset;
+    this.byteLength = bytes.byteLength;
+    this.asCID = this;
+    this._baseCache = /* @__PURE__ */ new Map();
+    Object.defineProperties(this, {
+      byteOffset: hidden,
+      byteLength: hidden,
+      code: readonly,
+      version: readonly,
+      multihash: readonly,
+      bytes: readonly,
+      _baseCache: hidden,
+      asCID: hidden
+    });
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      default: {
+        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);
+      }
+    }
+  }
+  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 0. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return other && this.code === other.code && this.version === other.version && equals2(this.multihash, other.multihash);
+  }
+  toString(base3) {
+    const { bytes, version: version2, _baseCache } = this;
+    switch (version2) {
+      case 0:
+        return toStringV0(bytes, _baseCache, base3 || base58btc.encoder);
+      default:
+        return toStringV1(bytes, _baseCache, base3 || base32.encoder);
+    }
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      version: this.version,
+      hash: this.multihash.bytes
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "CID";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return "CID(" + this.toString() + ")";
+  }
+  static isCID(value) {
+    deprecate(/^0\.0/, IS_CID_DEPRECATION);
+    return !!(value && (value[cidSymbol] || value.asCID === value));
+  }
+  get toBaseEncodedString() {
+    throw new Error("Deprecated, use .toString()");
+  }
+  get codec() {
+    throw new Error('"codec" property is deprecated, use integer "code" property instead');
+  }
+  get buffer() {
+    throw new Error("Deprecated .buffer property, use .bytes to get Uint8Array instead");
+  }
+  get multibaseName() {
+    throw new Error('"multibaseName" property is deprecated');
+  }
+  get prefix() {
+    throw new Error('"prefix" property is deprecated');
+  }
+  static asCID(value) {
+    if (value instanceof _CID) {
+      return value;
+    } else if (value != null && value.asCID === value) {
+      const { version: version2, code, multihash, bytes } = value;
+      return new _CID(version2, code, multihash, bytes || encodeCID(version2, code, multihash.bytes));
+    } else if (value != null && value[cidSymbol] === true) {
+      const { version: version2, multihash, code } = value;
+      const digest = decode3(multihash);
+      return _CID.create(version2, code, digest);
+    } else {
+      return null;
+    }
+  }
+  static create(version2, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    switch (version2) {
+      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(version2, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version2, code, digest.bytes);
+        return new _CID(version2, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
+  }
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce3(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)
+    ];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode2(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version2 = next();
+    let codec = DAG_PB_CODE;
+    if (version2 === 18) {
+      version2 = 0;
+      offset = 0;
+    } else if (version2 === 1) {
+      codec = next();
+    }
+    if (version2 !== 0 && version2 !== 1) {
+      throw new RangeError(`Invalid CID version ${version2}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return {
+      version: version2,
+      codec,
+      multihashCode,
+      digestSize,
+      multihashSize,
+      size
+    };
+  }
+  static parse(source, base3) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base3);
+    const cid = _CID.decode(bytes);
+    cid._baseCache.set(prefix, source);
+    return cid;
+  }
+};
+var parseCIDtoBytes = (source, base3) => {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(source)
+      ];
+    }
+    case base32.prefix: {
+      const decoder = base3 || base32;
+      return [
+        base32.prefix,
+        decoder.decode(source)
+      ];
+    }
+    default: {
+      if (base3 == null) {
+        throw Error("To parse non base32 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [
+        source[0],
+        base3.decode(source)
+      ];
+    }
+  }
+};
+var toStringV0 = (bytes, cache, base3) => {
+  const { prefix } = base3;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
+  }
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes).slice(1);
+    cache.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var toStringV1 = (bytes, cache, base3) => {
+  const { prefix } = base3;
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes);
+    cache.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+var encodeCID = (version2, code, multihash) => {
+  const codeOffset = encodingLength(version2);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version2, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+};
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+var readonly = {
+  writable: false,
+  configurable: false,
+  enumerable: true
+};
+var hidden = {
+  writable: false,
+  enumerable: false,
+  configurable: false
+};
+var version = "0.0.0-dev";
+var deprecate = (range, message) => {
+  if (range.test(version)) {
+    console.warn(message);
+  } else {
+    throw new Error(message);
+  }
+};
+var IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.
+Following code pattern:
+
+if (CID.isCID(value)) {
+  doSomethingWithCID(value)
+}
+
+Is replaced with:
+
+const cid = CID.asCID(value)
+if (cid) {
+  // Make sure to use cid instead of value
+  doSomethingWithCID(cid)
+}
+`;
+
+// src/ipfs/ipfs.ts
+function isCID(str) {
+  if (!str)
+    return false;
+  try {
+    CID.parse(str);
+    return true;
+  } catch (e) {
+    if (/^(bafy|Qm)/.test(str))
+      return true;
+    return false;
+  }
+}
+function normalizeIPFSUrl(url) {
+  if (!url || typeof url !== "string")
+    return null;
+  url = url.replace(/"/g, "");
+  if (isNormalizedIPFSURL(url))
+    return url;
+  if (isCID(url))
+    return `ipfs://${url}`;
+  if (!isIPFSUrl(url))
+    return null;
+  if (isGatewayIPFSUrl(url)) {
+    const parsed = new URL(url.replace(/^\/\//, "http://"));
+    parsed.pathname = parsed.pathname.replace(/^\/ipfs\//, "");
+    const cid = parsed.toString().replace(`${parsed.protocol}//${parsed.host}/`, "");
+    return `ipfs://${cid}`;
+  }
+  return null;
+}
+function isNormalizedIPFSURL(url) {
+  return url && typeof url === "string" ? url.startsWith("ipfs://") : false;
+}
+function isGatewayIPFSUrl(url) {
+  if (url && typeof url === "string") {
+    try {
+      const parsed = new URL(url.replace(/^"|'(.*)"|'$/, "$1"));
+      return !isNormalizedIPFSURL(url) && parsed && parsed.pathname.startsWith("/ipfs/");
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function isIPFSUrl(url) {
+  return url ? isNormalizedIPFSURL(url) || isGatewayIPFSUrl(url) : false;
+}
+function isNormalizeableIPFSUrl(url) {
+  return url ? isIPFSUrl(url) || isCID(url) : false;
+}
+
+// src/ipfs/gateway.ts
+var IPFS_GATEWAY = "https://magic.decentralized-content.com";
+var ARWEAVE_GATEWAY = "https://arweave.net";
+function arweaveGatewayUrl(normalizedArweaveUrl) {
+  if (!normalizedArweaveUrl || typeof normalizedArweaveUrl !== "string")
+    return null;
+  return normalizedArweaveUrl.replace("ar://", `${ARWEAVE_GATEWAY}/`);
+}
+function ipfsGatewayUrl(url) {
+  if (!url || typeof url !== "string")
+    return null;
+  const normalizedIPFSUrl = normalizeIPFSUrl(url);
+  if (normalizedIPFSUrl) {
+    return normalizedIPFSUrl.replace("ipfs://", `${IPFS_GATEWAY}/ipfs/`);
+  }
+  return null;
+}
+function getFetchableUrl(uri) {
+  if (!uri || typeof uri !== "string")
+    return null;
+  if (uri.startsWith("http://"))
+    return null;
+  if (isNormalizeableIPFSUrl(uri)) {
+    return ipfsGatewayUrl(uri);
+  }
+  if (isArweaveURL(uri)) {
+    return arweaveGatewayUrl(uri);
+  }
+  if (/^(https|data|blob):/.test(uri)) {
+    return uri;
+  }
+  return null;
+}
+
+// src/ipfs/mimeTypes.ts
+var HTML = "text/html";
+var MARKDOWN = "text/markdown";
+var MARKDOWN_UTF8 = "text/markdown; charset=utf-8";
+var TEXT_PLAIN_UTF8 = "text/plain; charset=utf-8";
+var TEXT_PLAIN = "text/plain";
+var CSV = "text/csv";
+var NUMBERS = ".numbers";
+var EXCEL = ".xlsx";
+var PDF = "application/pdf";
+var JPG = "image/jpg";
+var JPEG = "image/jpeg";
+var PNG = "image/png";
+var WEBP = "image/webp";
+var SVG = "image/svg+xml";
+var TIFF = "image/tiff";
+var GIF = "image/gif";
+var isImage = (mimeType) => {
+  if (!mimeType)
+    return false;
+  return [JPG, JPEG, PNG, WEBP, SVG, TIFF, GIF].includes(mimeType);
+};
+var DEFAULT_THUMBNAIL_CID_HASHES = {
+  ["AUDIO" /* AUDIO */]: "bafkreidir5laqi26ta6ivnpe2zpekgrfcyi4tb5x6vhwmwnledmzxshfb4",
+  ["VIDEO" /* VIDEO */]: "bafkreifm4edadl3j5luoyvw4p6elxeqd77la7bulee6vhq5gq4chfk32mu",
+  ["HTML" /* HTML */]: "bafkreifgvi6xfwqy2l6g45csyokejpaib52ee7zrw6etrxl2tas4xkkclq",
+  ["ZIP" /* ZIP */]: "bafkreihe5rr5jbkwzegisjlhxbb7jw22xw5oilfmgd2re6tz6buo4pasdq",
+  // assuming all zip files are html directories
+  ["TEXT" /* TEXT */]: "bafkreiaez25nfgggzrnza2loxf6xueb2esm44pnyjyulwoslnipowrf56q",
+  default: "bafkreihcoahllisbpb4eeypdwtm7go5uh275wxd7wf2tantpxlpjhviok4"
+};
+var MP4 = "video/mp4";
+var QUICKTIME = "video/quicktime";
+var M4V = "video/x-m4v";
+var WEBM = "video/webm";
+var M4A = "audio/x-m4a";
+var MPEG = "audio/mpeg";
+var MP3 = "audio/mp3";
+var WAV = "audio/wav";
+var VND_WAV = "audio/vnd.wav";
+var VND_WAVE = "audio/vnd.wave";
+var WAVE = "audio/wave";
+var X_WAV = "audio/x-wav";
+var AIFF = "audio/aiff";
+var GLTF = "model/gltf+json";
+var GLB = "model/gltf-binary";
+var GLTF_EXT = ".gltf";
+var GLB_EXT = ".glb";
+var JSON_MIME_TYPE = "application/json";
+var ZIP = "application/zip";
+var mimeToMediaType = {
+  [HTML]: "HTML" /* HTML */,
+  [JPG]: "IMAGE" /* IMAGE */,
+  [JPEG]: "IMAGE" /* IMAGE */,
+  [PNG]: "IMAGE" /* IMAGE */,
+  [WEBP]: "IMAGE" /* IMAGE */,
+  [SVG]: "IMAGE" /* IMAGE */,
+  [TIFF]: "TIFF" /* TIFF */,
+  [GIF]: "IMAGE" /* IMAGE */,
+  [MP4]: "VIDEO" /* VIDEO */,
+  [WEBM]: "VIDEO" /* VIDEO */,
+  [QUICKTIME]: "VIDEO" /* VIDEO */,
+  [M4V]: "VIDEO" /* VIDEO */,
+  [MPEG]: "AUDIO" /* AUDIO */,
+  [MP3]: "AUDIO" /* AUDIO */,
+  [M4A]: "AUDIO" /* AUDIO */,
+  [VND_WAV]: "AUDIO" /* AUDIO */,
+  [VND_WAVE]: "AUDIO" /* AUDIO */,
+  [WAV]: "AUDIO" /* AUDIO */,
+  [WAVE]: "AUDIO" /* AUDIO */,
+  [X_WAV]: "AUDIO" /* AUDIO */,
+  [AIFF]: "AUDIO" /* AUDIO */,
+  [TEXT_PLAIN]: "TEXT" /* TEXT */,
+  [TEXT_PLAIN_UTF8]: "TEXT" /* TEXT */,
+  [MARKDOWN]: "TEXT" /* TEXT */,
+  [MARKDOWN_UTF8]: "TEXT" /* TEXT */,
+  [CSV]: "CSV" /* CSV */,
+  [NUMBERS]: "NUMBERS" /* NUMBERS */,
+  [EXCEL]: "EXCEL" /* EXCEL */,
+  [PDF]: "PDF" /* PDF */,
+  [ZIP]: "ZIP" /* ZIP */,
+  [GLTF]: "MODEL" /* MODEL */,
+  [GLTF_EXT]: "MODEL" /* MODEL */,
+  [GLB]: "MODEL" /* MODEL */,
+  // GLTF returns 'application/json' as the mimetype,
+  // and as the only JSON-encoded media we currently support,
+  // we assume that if the mimetype is JSON, it's a GLTF
+  [JSON_MIME_TYPE]: "MODEL" /* MODEL */,
+  [GLB_EXT]: "MODEL" /* MODEL */
+};
+function mimeTypeToMedia(mimeType) {
+  if (!mimeType)
+    return "UNKNOWN" /* UNKNOWN */;
+  return mimeToMediaType[mimeType] || "UNKNOWN" /* UNKNOWN */;
+}
+async function getMimeType(uri) {
+  if (!uri)
+    return uri;
+  const res = await fetch(uri, { method: "HEAD" });
+  let mimeType = res.headers.get("content-type");
+  return mimeType;
+}
+
+// src/ipfs/token-metadata.ts
+var makeTextTokenMetadata = (parameters) => {
+  const { name, textFileUrl, thumbnailUrl, attributes = [] } = parameters;
+  const content = textFileUrl ? {
+    mime: TEXT_PLAIN,
+    uri: textFileUrl
+  } : null;
+  const image = thumbnailUrl;
+  const animation_url = textFileUrl;
+  return {
+    name,
+    image,
+    animation_url,
+    content,
+    attributes
+  };
+};
+var makeMediaTokenMetadata = async ({
+  name,
+  description,
+  attributes = [],
+  mediaUrl,
+  thumbnailUrl
+}) => {
+  const contentUrl = mediaUrl;
+  const fetchableContentUrl = getFetchableUrl(contentUrl);
+  if (!fetchableContentUrl)
+    throw new Error(`Content url (${contentUrl}) is not fetchable`);
+  const mimeType = await getMimeType(fetchableContentUrl);
+  const mediaType = mimeTypeToMedia(mimeType);
+  let image = void 0;
+  let animation_url = null;
+  if (isImage(mimeType)) {
+    image = contentUrl;
+  } else {
+    image = thumbnailUrl;
+    animation_url = mediaUrl;
+  }
+  if (!image)
+    image = `ipfs://${DEFAULT_THUMBNAIL_CID_HASHES[mediaType] || DEFAULT_THUMBNAIL_CID_HASHES.default}`;
+  const content = contentUrl ? {
+    mime: mimeType || "application/octet-stream",
+    uri: contentUrl
+  } : null;
+  return {
+    name,
+    description,
+    image,
+    animation_url,
+    content,
+    attributes
+  };
+};
+
+// src/ipfs/text-metadata.ts
+var CHAR_LIMIT = 1111;
+var wrapText = ({
+  ctx,
+  text,
+  x,
+  y,
+  maxWidth,
+  lineHeight
+}) => {
+  let words = text.replaceAll("\n", " \n ").split(/ +/);
+  let line = "";
+  let testLine = "";
+  let lineArray = [];
+  for (var n = 0; n < words.length; n++) {
+    testLine += `${words[n]} `;
+    let metrics = ctx.measureText(testLine);
+    let testWidth = metrics.width;
+    if (words[n]?.includes("\n") || testWidth > maxWidth && n > 0) {
+      lineArray.push({ text: line, x, y });
+      y += lineHeight;
+      if (words[n]?.includes("\n")) {
+        line = ``;
+        testLine = ``;
+      } else {
+        line = `${words[n]} `;
+        testLine = `${words[n]} `;
+      }
+    } else {
+      line += `${words[n]} `;
+    }
+    if (n === words.length - 1) {
+      lineArray.push({ text: line, x, y });
+    }
+  }
+  return lineArray;
+};
+async function generateTextPreview(text) {
+  const trimmedText = text.trim().slice(0, CHAR_LIMIT);
+  const [width, height] = [500, 500];
+  const padding = 20;
+  const dpr = 2;
+  const fontFamily = "Inter";
+  const [fontSize, lineHeight] = [16, 24];
+  const [textColor, backgroundColor] = ["black", "white"];
+  return new Promise((resolve, reject) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return reject(new Error("Could not create canvas context"));
+    }
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, width * dpr, width * dpr);
+    ctx.fillStyle = textColor;
+    ctx.font = `${fontSize * dpr}px ${fontFamily}`;
+    const wrapped = wrapText({
+      ctx,
+      text: trimmedText,
+      x: padding * dpr,
+      y: fontSize * dpr + padding * dpr,
+      maxWidth: width * dpr - padding * 2 * dpr,
+      lineHeight: lineHeight * dpr
+    });
+    wrapped.forEach((line) => ctx.fillText(line.text, line.x, line.y));
+    canvas.toBlob((blob) => {
+      if (!blob) {
+        return reject(new Error("Could not create blob"));
+      }
+      resolve(new File([blob], "thumbnail.png", { type: "image/png" }));
+    });
+  });
+}
+function generateTextTitle(text) {
+  const firstLine = text.split("\n")[0];
+  const firstSentence = firstLine?.split(". ")[0];
+  if (firstSentence.length > 50) {
+    return firstSentence.slice(0, 50) + "...";
+  }
+  return firstSentence;
+}
+var toTextFile = (text) => new File([text], "Untitled.txt", { type: "text/plain" });
+async function generateTextNftMetadataFiles(text) {
+  const name = generateTextTitle(text);
+  const textFile = toTextFile(text);
+  const thumbnailFile = await generateTextPreview(text);
+  return {
+    name,
+    mediaUrlFile: textFile,
+    thumbnailFile
+  };
+}
 export {
   Create1155Client,
   Errors,
@@ -2950,6 +4098,7 @@ export {
   encodeCollectOnManager,
   encodePostSignatureInput,
   encodePremintForAPI,
+  generateTextNftMetadataFiles,
   getApiNetworkConfigForChain,
   getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
@@ -2969,11 +4118,13 @@ export {
   isPremintConfigV2,
   isValidSignature,
   makeCallWithEthSafeTransferData,
+  makeMediaTokenMetadata,
   makeMintRewardsRecipient,
   makeNewPremint,
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
+  makeTextTokenMetadata,
   makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,