@silvana-one/api/dist/node/index.cjs

Silvana API

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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, 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: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// dist/node/index.js
var index_exports = {};
__export(index_exports, {
  airdropTokens: () => airdropTokens,
  approveNft: () => approveNft,
  burnTokens: () => burnTokens,
  buyNft: () => buyNft,
  buyTokens: () => buyTokens,
  cmsReadNft: () => cmsReadNft,
  cmsReserveNft: () => cmsReserveNft,
  cmsStoreNft: () => cmsStoreNft,
  config: () => config,
  faucet: () => faucet,
  fetchZekoFee: () => fetchZekoFee,
  getContractInfo: () => getContractInfo,
  getCurrentZekoSlot: () => getCurrentZekoSlot,
  getNftInfo: () => getNftInfo,
  getNftV2Info: () => getNftV2Info,
  getNonce: () => getNonce,
  getProof: () => getProof,
  getTokenBalance: () => getTokenBalance,
  getTokenHolders: () => getTokenHolders,
  getTokenInfo: () => getTokenInfo,
  getTransactions: () => getTransactions,
  launchNftCollection: () => launchNftCollection,
  launchToken: () => launchToken,
  mintNft: () => mintNft,
  mintTokens: () => mintTokens,
  prove: () => prove,
  redeemTokens: () => redeemTokens,
  sellNft: () => sellNft,
  sellTokens: () => sellTokens,
  sendTransaction: () => sendTransaction,
  tokenBid: () => tokenBid,
  tokenOffer: () => tokenOffer,
  transferNft: () => transferNft,
  transferTokens: () => transferTokens,
  txStatus: () => txStatus,
  updateTokenAdminWhitelist: () => updateTokenAdminWhitelist,
  updateTokenBidWhitelist: () => updateTokenBidWhitelist,
  updateTokenOfferWhitelist: () => updateTokenOfferWhitelist,
  waitForProofs: () => waitForProofs,
  waitForTransaction: () => waitForTransaction,
  withdrawTokenBid: () => withdrawTokenBid,
  withdrawTokenOffer: () => withdrawTokenOffer
});
module.exports = __toCommonJS(index_exports);

// dist/node/client/core/bodySerializer.js
var jsonBodySerializer = {
  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
};

// dist/node/client/core/params.js
var extraPrefixesMap = {
  $body_: "body",
  $headers_: "headers",
  $path_: "path",
  $query_: "query"
};
var extraPrefixes = Object.entries(extraPrefixesMap);

// dist/node/client/core/auth.js
var getAuthToken = async (auth, callback) => {
  const token = typeof callback === "function" ? await callback(auth) : callback;
  if (!token) {
    return;
  }
  if (auth.scheme === "bearer") {
    return `Bearer ${token}`;
  }
  if (auth.scheme === "basic") {
    return `Basic ${btoa(token)}`;
  }
  return token;
};

// dist/node/client/core/pathSerializer.js
var separatorArrayExplode = (style) => {
  switch (style) {
    case "label":
      return ".";
    case "matrix":
      return ";";
    case "simple":
      return ",";
    default:
      return "&";
  }
};
var separatorArrayNoExplode = (style) => {
  switch (style) {
    case "form":
      return ",";
    case "pipeDelimited":
      return "|";
    case "spaceDelimited":
      return "%20";
    default:
      return ",";
  }
};
var separatorObjectExplode = (style) => {
  switch (style) {
    case "label":
      return ".";
    case "matrix":
      return ";";
    case "simple":
      return ",";
    default:
      return "&";
  }
};
var serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
  if (!explode) {
    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
    switch (style) {
      case "label":
        return `.${joinedValues2}`;
      case "matrix":
        return `;${name}=${joinedValues2}`;
      case "simple":
        return joinedValues2;
      default:
        return `${name}=${joinedValues2}`;
    }
  }
  const separator = separatorArrayExplode(style);
  const joinedValues = value.map((v) => {
    if (style === "label" || style === "simple") {
      return allowReserved ? v : encodeURIComponent(v);
    }
    return serializePrimitiveParam({
      allowReserved,
      name,
      value: v
    });
  }).join(separator);
  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
};
var serializePrimitiveParam = ({ allowReserved, name, value }) => {
  if (value === void 0 || value === null) {
    return "";
  }
  if (typeof value === "object") {
    throw new Error("Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these.");
  }
  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
};
var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
  if (value instanceof Date) {
    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
  }
  if (style !== "deepObject" && !explode) {
    let values = [];
    Object.entries(value).forEach(([key, v]) => {
      values = [
        ...values,
        key,
        allowReserved ? v : encodeURIComponent(v)
      ];
    });
    const joinedValues2 = values.join(",");
    switch (style) {
      case "form":
        return `${name}=${joinedValues2}`;
      case "label":
        return `.${joinedValues2}`;
      case "matrix":
        return `;${name}=${joinedValues2}`;
      default:
        return joinedValues2;
    }
  }
  const separator = separatorObjectExplode(style);
  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
    allowReserved,
    name: style === "deepObject" ? `${name}[${key}]` : key,
    value: v
  })).join(separator);
  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
};

// dist/node/client/client/utils.js
var PATH_PARAM_RE = /\{[^{}]+\}/g;
var defaultPathSerializer = ({ path, url: _url }) => {
  let url = _url;
  const matches = _url.match(PATH_PARAM_RE);
  if (matches) {
    for (const match of matches) {
      let explode = false;
      let name = match.substring(1, match.length - 1);
      let style = "simple";
      if (name.endsWith("*")) {
        explode = true;
        name = name.substring(0, name.length - 1);
      }
      if (name.startsWith(".")) {
        name = name.substring(1);
        style = "label";
      } else if (name.startsWith(";")) {
        name = name.substring(1);
        style = "matrix";
      }
      const value = path[name];
      if (value === void 0 || value === null) {
        continue;
      }
      if (Array.isArray(value)) {
        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
        continue;
      }
      if (typeof value === "object") {
        url = url.replace(match, serializeObjectParam({
          explode,
          name,
          style,
          value,
          valueOnly: true
        }));
        continue;
      }
      if (style === "matrix") {
        url = url.replace(match, `;${serializePrimitiveParam({
          name,
          value
        })}`);
        continue;
      }
      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
      url = url.replace(match, replaceValue);
    }
  }
  return url;
};
var createQuerySerializer = ({ allowReserved, array, object } = {}) => {
  const querySerializer = (queryParams) => {
    const search = [];
    if (queryParams && typeof queryParams === "object") {
      for (const name in queryParams) {
        const value = queryParams[name];
        if (value === void 0 || value === null) {
          continue;
        }
        if (Array.isArray(value)) {
          const serializedArray = serializeArrayParam({
            allowReserved,
            explode: true,
            name,
            style: "form",
            value,
            ...array
          });
          if (serializedArray)
            search.push(serializedArray);
        } else if (typeof value === "object") {
          const serializedObject = serializeObjectParam({
            allowReserved,
            explode: true,
            name,
            style: "deepObject",
            value,
            ...object
          });
          if (serializedObject)
            search.push(serializedObject);
        } else {
          const serializedPrimitive = serializePrimitiveParam({
            allowReserved,
            name,
            value
          });
          if (serializedPrimitive)
            search.push(serializedPrimitive);
        }
      }
    }
    return search.join("&");
  };
  return querySerializer;
};
var getParseAs = (contentType) => {
  if (!contentType) {
    return "stream";
  }
  const cleanContent = contentType.split(";")[0]?.trim();
  if (!cleanContent) {
    return;
  }
  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
    return "json";
  }
  if (cleanContent === "multipart/form-data") {
    return "formData";
  }
  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
    return "blob";
  }
  if (cleanContent.startsWith("text/")) {
    return "text";
  }
  return;
};
var setAuthParams = async ({ security, ...options }) => {
  for (const auth of security) {
    const token = await getAuthToken(auth, options.auth);
    if (!token) {
      continue;
    }
    const name = auth.name ?? "Authorization";
    switch (auth.in) {
      case "query":
        if (!options.query) {
          options.query = {};
        }
        options.query[name] = token;
        break;
      case "cookie":
        options.headers.append("Cookie", `${name}=${token}`);
        break;
      case "header":
      default:
        options.headers.set(name, token);
        break;
    }
    return;
  }
};
var buildUrl = (options) => {
  const url = getUrl({
    baseUrl: options.baseUrl,
    path: options.path,
    query: options.query,
    querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
    url: options.url
  });
  return url;
};
var getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
  let url = (baseUrl ?? "") + pathUrl;
  if (path) {
    url = defaultPathSerializer({ path, url });
  }
  let search = query ? querySerializer(query) : "";
  if (search.startsWith("?")) {
    search = search.substring(1);
  }
  if (search) {
    url += `?${search}`;
  }
  return url;
};
var mergeConfigs = (a, b) => {
  const config2 = { ...a, ...b };
  if (config2.baseUrl?.endsWith("/")) {
    config2.baseUrl = config2.baseUrl.substring(0, config2.baseUrl.length - 1);
  }
  config2.headers = mergeHeaders(a.headers, b.headers);
  return config2;
};
var mergeHeaders = (...headers) => {
  const mergedHeaders = new Headers();
  for (const header of headers) {
    if (!header || typeof header !== "object") {
      continue;
    }
    const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
    for (const [key, value] of iterator) {
      if (value === null) {
        mergedHeaders.delete(key);
      } else if (Array.isArray(value)) {
        for (const v of value) {
          mergedHeaders.append(key, v);
        }
      } else if (value !== void 0) {
        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
      }
    }
  }
  return mergedHeaders;
};
var Interceptors = class {
  constructor() {
    this._fns = [];
  }
  clear() {
    this._fns = [];
  }
  getInterceptorIndex(id) {
    if (typeof id === "number") {
      return this._fns[id] ? id : -1;
    } else {
      return this._fns.indexOf(id);
    }
  }
  exists(id) {
    const index = this.getInterceptorIndex(id);
    return !!this._fns[index];
  }
  eject(id) {
    const index = this.getInterceptorIndex(id);
    if (this._fns[index]) {
      this._fns[index] = null;
    }
  }
  update(id, fn) {
    const index = this.getInterceptorIndex(id);
    if (this._fns[index]) {
      this._fns[index] = fn;
      return id;
    } else {
      return false;
    }
  }
  use(fn) {
    this._fns = [...this._fns, fn];
    return this._fns.length - 1;
  }
};
var createInterceptors = () => ({
  error: new Interceptors(),
  request: new Interceptors(),
  response: new Interceptors()
});
var defaultQuerySerializer = createQuerySerializer({
  allowReserved: false,
  array: {
    explode: true,
    style: "form"
  },
  object: {
    explode: true,
    style: "deepObject"
  }
});
var defaultHeaders = {
  "Content-Type": "application/json"
};
var createConfig = (override = {}) => ({
  ...jsonBodySerializer,
  headers: defaultHeaders,
  parseAs: "auto",
  querySerializer: defaultQuerySerializer,
  ...override
});

// dist/node/client/client/client.js
var createClient = (config2 = {}) => {
  let _config = mergeConfigs(createConfig(), config2);
  const getConfig = () => ({ ..._config });
  const setConfig = (config3) => {
    _config = mergeConfigs(_config, config3);
    return getConfig();
  };
  const interceptors = createInterceptors();
  const request = async (options) => {
    const opts = {
      ..._config,
      ...options,
      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
      headers: mergeHeaders(_config.headers, options.headers)
    };
    if (opts.security) {
      await setAuthParams({
        ...opts,
        security: opts.security
      });
    }
    if (opts.requestValidator) {
      await opts.requestValidator(opts);
    }
    if (opts.body && opts.bodySerializer) {
      opts.body = opts.bodySerializer(opts.body);
    }
    if (opts.body === void 0 || opts.body === "") {
      opts.headers.delete("Content-Type");
    }
    const url = buildUrl(opts);
    const requestInit = {
      redirect: "follow",
      ...opts
    };
    let request2 = new Request(url, requestInit);
    for (const fn of interceptors.request._fns) {
      if (fn) {
        request2 = await fn(request2, opts);
      }
    }
    const _fetch = opts.fetch;
    let response = await _fetch(request2);
    for (const fn of interceptors.response._fns) {
      if (fn) {
        response = await fn(response, request2, opts);
      }
    }
    const result = {
      request: request2,
      response
    };
    if (response.ok) {
      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
        return opts.responseStyle === "data" ? {} : {
          data: {},
          ...result
        };
      }
      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
      let data;
      switch (parseAs) {
        case "arrayBuffer":
        case "blob":
        case "formData":
        case "json":
        case "text":
          data = await response[parseAs]();
          break;
        case "stream":
          return opts.responseStyle === "data" ? response.body : {
            data: response.body,
            ...result
          };
      }
      if (parseAs === "json") {
        if (opts.responseValidator) {
          await opts.responseValidator(data);
        }
        if (opts.responseTransformer) {
          data = await opts.responseTransformer(data);
        }
      }
      return opts.responseStyle === "data" ? data : {
        data,
        ...result
      };
    }
    const textError = await response.text();
    let jsonError;
    try {
      jsonError = JSON.parse(textError);
    } catch {
    }
    const error = jsonError ?? textError;
    let finalError = error;
    for (const fn of interceptors.error._fns) {
      if (fn) {
        finalError = await fn(error, response, request2, opts);
      }
    }
    finalError = finalError || {};
    if (opts.throwOnError) {
      throw finalError;
    }
    return opts.responseStyle === "data" ? void 0 : {
      error: finalError,
      ...result
    };
  };
  return {
    buildUrl,
    connect: (options) => request({ ...options, method: "CONNECT" }),
    delete: (options) => request({ ...options, method: "DELETE" }),
    get: (options) => request({ ...options, method: "GET" }),
    getConfig,
    head: (options) => request({ ...options, method: "HEAD" }),
    interceptors,
    options: (options) => request({ ...options, method: "OPTIONS" }),
    patch: (options) => request({ ...options, method: "PATCH" }),
    post: (options) => request({ ...options, method: "POST" }),
    put: (options) => request({ ...options, method: "PUT" }),
    request,
    setConfig,
    trace: (options) => request({ ...options, method: "TRACE" })
  };
};

// dist/node/client/client.gen.js
var client = createClient(createConfig({
  baseUrl: "https://minatokens.com/api/v1/"
}));

// dist/node/client/sdk.gen.js
var launchNftCollection = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/launch",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var launchToken = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/launch",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getContractInfo = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/contract",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getNftInfo = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/nft",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getNftV2Info = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/nft-v2",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var faucet = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/faucet",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getTokenInfo = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/token",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getTokenBalance = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/balance",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getNonce = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/nonce",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getTokenHolders = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/holders",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getTransactions = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/info/transactions",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var prove = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/transaction/prove",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var getProof = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/transaction/proof",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var sendTransaction = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/transaction/send",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var txStatus = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/transaction/status",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var mintTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/mint",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var mintNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/mint",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var transferNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/transfer",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var cmsStoreNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/cms/store",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var cmsReadNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/cms/read",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var cmsReserveNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/cms/reserve",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var approveNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/approve",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var sellNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/sell",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var buyNft = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/nft/buy",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var transferTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/transfer",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var airdropTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/airdrop",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var redeemTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/redeem",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var burnTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/burn",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var tokenBid = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/bid/create",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var tokenOffer = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/offer/create",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var buyTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/offer/buy",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var sellTokens = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/bid/sell",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var withdrawTokenBid = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/bid/withdraw",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var withdrawTokenOffer = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/offer/withdraw",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var updateTokenBidWhitelist = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/bid/whitelist",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var updateTokenOfferWhitelist = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/offer/whitelist",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};
var updateTokenAdminWhitelist = (options) => {
  return (options.client ?? client).post({
    security: [
      {
        name: "x-api-key",
        type: "apiKey"
      }
    ],
    url: "/token/admin/whitelist",
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers
    }
  });
};

// dist/node/config.js
function config({ apiKey, chain, throwOnError }) {
  client.setConfig({
    headers: {
      "x-api-key": apiKey
    },
    baseUrl: chain === "zeko" ? "https://zekotokens.com/api/v1/" : chain === "devnet" ? "https://devnet.minatokens.com/api/v1/" : "https://minatokens.com/api/v1/",
    throwOnError: throwOnError ?? true
  });
}

// dist/node/wait.js
async function waitForProofs(jobId) {
  console.log("Job ID:", jobId);
  let errorCount = 0;
  const startTime = Date.now();
  console.log("Waiting for job result...");
  while (errorCount < 100 && Date.now() - startTime < 1e3 * 60 * 10) {
    try {
      const jobResults = (await getProof({ body: { jobId } })).data;
      const jobStatus = jobResults?.jobStatus;
      if (jobResults?.success === true && (jobStatus === "finished" || jobStatus === "used")) {
        return jobResults.results?.map((result) => result.hash ?? "") ?? [];
      }
      if (jobStatus === "failed") {
        console.error(`Job ${jobId} failed`);
        return void 0;
      }
    } catch (error) {
      errorCount++;
      console.error(error);
    }
    await sleep(1e4);
  }
  return void 0;
}
async function waitForTransaction(hash, timeout = 1e3 * 60 * 60 * 5) {
  console.log(`Waiting for transaction ${hash} to be included in a block...`);
  const startTime = Date.now();
  let status = "pending";
  let errorCount = 0;
  while (status !== "applied" && errorCount < 100 && Date.now() - startTime < timeout) {
    try {
      const result = (await txStatus({ body: { hash } })).data;
      status = result?.status ?? "pending";
      if (status === "failed") {
        throw new Error(`Transaction ${hash} failed: ${JSON.stringify({ result })}`);
      } else if (status === "applied") {
        console.log(`Transaction ${hash} included in a block`, result);
        return;
      }
    } catch (error) {
      errorCount++;
      console.error(error);
    }
    await sleep(3e4);
  }
  throw new Error(`Transaction ${hash} not included in a block, timeout or too many errors`);
}
async function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// dist/node/zeko.js
async function getCurrentZekoSlot(chain = "zeko") {
  try {
    const response = await fetch("https://api.minascan.io/node/devnet/v1/graphql", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        query: `
        query RuntimeConfig {
          runtimeConfig
        }
      `,
        variables: {}
      })
    });
    if (!response.ok) {
      console.error(`Failed to fetch runtime config: ${response.status} ${response.statusText} for chain ${chain}`);
      return void 0;
    }
    const { data: { runtimeConfig } } = await response.json();
    if (!runtimeConfig) {
      console.error(`No runtime config found for chain ${chain}`);
      return void 0;
    }
    if (!runtimeConfig.proof?.fork?.global_slot_since_genesis || typeof runtimeConfig.proof.fork.global_slot_since_genesis !== "number") {
      console.error(`No fork slot found for chain ${chain}`);
      return void 0;
    }
    if (!runtimeConfig.genesis?.genesis_state_timestamp || typeof runtimeConfig.genesis.genesis_state_timestamp !== "string") {
      console.error(`No genesis timestamp found for chain ${chain}`);
      return void 0;
    }
    const currentTimestamp = Date.now() / 1e3;
    const forkSlot = runtimeConfig?.proof?.fork?.global_slot_since_genesis;
    const genesisTimestamp = Date.parse(runtimeConfig?.genesis?.genesis_state_timestamp) / 1e3;
    return Math.floor(forkSlot + (currentTimestamp - genesisTimestamp) / 180);
  } catch (error) {
    console.error(`Failed to fetch runtime config: ${error?.message ?? error} for chain ${chain}`);
    return void 0;
  }
}
async function fetchZekoFee(params) {
  const { weight, buffer = 0.2, url = "https://devnet.zeko.io/graphql" } = params;
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        query: `
        query FeePerWeight($weight: Int!) {
          feePerWeightUnit(weight: $weight)
        }
      `,
        variables: { weight }
      })
    });
    if (!response.ok) {
      console.error("fetchZekoFee: Invalid response from Zeko", response.status, response.statusText);
      return void 0;
    }
    const { data } = await response.json();
    if (!data || !data.feePerWeightUnit) {
      console.error("fetchZekoFee: Invalid response from Zeko", data);
      return void 0;
    }
    return Math.ceil(data.feePerWeightUnit) + buffer * 1e9;
  } catch (error) {
    console.error("fetchZekoFee error", error?.message ?? error);
    return void 0;
  }
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  airdropTokens,
  approveNft,
  burnTokens,
  buyNft,
  buyTokens,
  cmsReadNft,
  cmsReserveNft,
  cmsStoreNft,
  config,
  faucet,
  fetchZekoFee,
  getContractInfo,
  getCurrentZekoSlot,
  getNftInfo,
  getNftV2Info,
  getNonce,
  getProof,
  getTokenBalance,
  getTokenHolders,
  getTokenInfo,
  getTransactions,
  launchNftCollection,
  launchToken,
  mintNft,
  mintTokens,
  prove,
  redeemTokens,
  sellNft,
  sellTokens,
  sendTransaction,
  tokenBid,
  tokenOffer,
  transferNft,
  transferTokens,
  txStatus,
  updateTokenAdminWhitelist,
  updateTokenBidWhitelist,
  updateTokenOfferWhitelist,
  waitForProofs,
  waitForTransaction,
  withdrawTokenBid,
  withdrawTokenOffer
});