@pollar/core 0.3.9

package/dist/index.js

@@ -0,0 +1,1496 @@
+'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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __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.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/@stellar/freighter-api/build/index.min.js
+var require_index_min = __commonJS({
+  "../../node_modules/@stellar/freighter-api/build/index.min.js"(exports$1, module) {
+    !(function(e, r) {
+      "object" == typeof exports$1 && "object" == typeof module ? module.exports = r() : "function" == typeof define && define.amd ? define([], r) : "object" == typeof exports$1 ? exports$1.freighterApi = r() : e.freighterApi = r();
+    })(exports$1, (() => (() => {
+      var e, r, E = { d: (e2, r2) => {
+        for (var o2 in r2) E.o(r2, o2) && !E.o(e2, o2) && Object.defineProperty(e2, o2, { enumerable: true, get: r2[o2] });
+      }, o: (e2, r2) => Object.prototype.hasOwnProperty.call(e2, r2), r: (e2) => {
+        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e2, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e2, "__esModule", { value: true });
+      } }, o = {};
+      E.r(o), E.d(o, { default: () => I, getNetwork: () => N, getNetworkDetails: () => s, getPublicKey: () => _, getUserInfo: () => R, isAllowed: () => C, isBrowser: () => c, isConnected: () => n, requestAccess: () => i, setAllowed: () => O, signAuthEntry: () => S, signBlob: () => A, signTransaction: () => t }), (function(e2) {
+        e2.CREATE_ACCOUNT = "CREATE_ACCOUNT", e2.FUND_ACCOUNT = "FUND_ACCOUNT", e2.ADD_ACCOUNT = "ADD_ACCOUNT", e2.IMPORT_ACCOUNT = "IMPORT_ACCOUNT", e2.IMPORT_HARDWARE_WALLET = "IMPORT_HARDWARE_WALLET", e2.LOAD_ACCOUNT = "LOAD_ACCOUNT", e2.MAKE_ACCOUNT_ACTIVE = "MAKE_ACCOUNT_ACTIVE", e2.UPDATE_ACCOUNT_NAME = "UPDATE_ACCOUNT_NAME", e2.GET_MNEMONIC_PHRASE = "GET_MNEMONIC_PHRASE", e2.CONFIRM_MNEMONIC_PHRASE = "CONFIRM_MNEMONIC_PHRASE", e2.CONFIRM_MIGRATED_MNEMONIC_PHRASE = "CONFIRM_MIGRATED_MNEMONIC_PHRASE", e2.RECOVER_ACCOUNT = "RECOVER_ACCOUNT", e2.CONFIRM_PASSWORD = "CONFIRM_PASSWORD", e2.REJECT_ACCESS = "REJECT_ACCESS", e2.GRANT_ACCESS = "GRANT_ACCESS", e2.SIGN_TRANSACTION = "SIGN_TRANSACTION", e2.SIGN_BLOB = "SIGN_BLOB", e2.SIGN_AUTH_ENTRY = "SIGN_AUTH_ENTRY", e2.HANDLE_SIGNED_HW_TRANSACTION = "HANDLE_SIGNED_HW_TRANSACTION", e2.REJECT_TRANSACTION = "REJECT_TRANSACTION", e2.SIGN_FREIGHTER_TRANSACTION = "SIGN_FREIGHTER_TRANSACTION", e2.SIGN_FREIGHTER_SOROBAN_TRANSACTION = "SIGN_FREIGHTER_SOROBAN_TRANSACTION", e2.ADD_RECENT_ADDRESS = "ADD_RECENT_ADDRESS", e2.LOAD_RECENT_ADDRESSES = "LOAD_RECENT_ADDRESSES", e2.SIGN_OUT = "SIGN_OUT", e2.SHOW_BACKUP_PHRASE = "SHOW_BACKUP_PHRASE", e2.SAVE_ALLOWLIST = "SAVE_ALLOWLIST", e2.SAVE_SETTINGS = "SAVE_SETTINGS", e2.LOAD_SETTINGS = "LOAD_SETTINGS", e2.GET_CACHED_ASSET_ICON = "GET_CACHED_ASSET_ICON", e2.CACHE_ASSET_ICON = "CACHE_ASSET_ICON", e2.GET_CACHED_ASSET_DOMAIN = "GET_CACHED_ASSET_DOMAIN", e2.CACHE_ASSET_DOMAIN = "CACHE_ASSET_DOMAIN", e2.GET_BLOCKED_ACCOUNTS = "GET_BLOCKED_ACCOUNTS", e2.GET_BLOCKED_DOMAINS = "GET_BLOCKED_DOMAINS", e2.ADD_CUSTOM_NETWORK = "ADD_CUSTOM_NETWORK", e2.CHANGE_NETWORK = "CHANGE_NETWORK", e2.REMOVE_CUSTOM_NETWORK = "REMOVE_CUSTOM_NETWORK", e2.EDIT_CUSTOM_NETWORK = "EDIT_CUSTOM_NETWORK", e2.RESET_EXP_DATA = "RESET_EXP_DATA", e2.ADD_TOKEN_ID = "ADD_TOKEN_ID", e2.GET_TOKEN_IDS = "GET_TOKEN_IDS", e2.REMOVE_TOKEN_ID = "REMOVE_TOKEN_ID", e2.GET_MIGRATABLE_ACCOUNTS = "GET_MIGRATABLE_ACCOUNTS", e2.GET_MIGRATED_MNEMONIC_PHRASE = "GET_MIGRATED_MNEMONIC_PHRASE", e2.MIGRATE_ACCOUNTS = "MIGRATE_ACCOUNTS";
+      })(e || (e = {})), (function(e2) {
+        e2.REQUEST_ACCESS = "REQUEST_ACCESS", e2.REQUEST_PUBLIC_KEY = "REQUEST_PUBLIC_KEY", e2.SUBMIT_TRANSACTION = "SUBMIT_TRANSACTION", e2.SUBMIT_BLOB = "SUBMIT_BLOB", e2.SUBMIT_AUTH_ENTRY = "SUBMIT_AUTH_ENTRY", e2.REQUEST_NETWORK = "REQUEST_NETWORK", e2.REQUEST_NETWORK_DETAILS = "REQUEST_NETWORK_DETAILS", e2.REQUEST_CONNECTION_STATUS = "REQUEST_CONNECTION_STATUS", e2.REQUEST_ALLOWED_STATUS = "REQUEST_ALLOWED_STATUS", e2.SET_ALLOWED_STATUS = "SET_ALLOWED_STATUS", e2.REQUEST_USER_INFO = "REQUEST_USER_INFO";
+      })(r || (r = {}));
+      const T = (e2) => {
+        const E2 = Date.now() + Math.random();
+        return window.postMessage({ source: "FREIGHTER_EXTERNAL_MSG_REQUEST", messageId: E2, ...e2 }, window.location.origin), new Promise(((o2) => {
+          let T2 = 0;
+          e2.type !== r.REQUEST_CONNECTION_STATUS && e2.type !== r.REQUEST_PUBLIC_KEY || (T2 = setTimeout((() => {
+            o2({ isConnected: false, publicKey: "" }), window.removeEventListener("message", _2);
+          }), 2e3));
+          const _2 = (e3) => {
+            var r2, t2;
+            e3.source === window && "FREIGHTER_EXTERNAL_MSG_RESPONSE" === (null === (r2 = null == e3 ? void 0 : e3.data) || void 0 === r2 ? void 0 : r2.source) && (null === (t2 = null == e3 ? void 0 : e3.data) || void 0 === t2 ? void 0 : t2.messagedId) === E2 && (o2(e3.data), window.removeEventListener("message", _2), clearTimeout(T2));
+          };
+          window.addEventListener("message", _2, false);
+        }));
+      }, _ = () => c ? (async () => {
+        let e2 = { publicKey: "", error: "" };
+        try {
+          e2 = await T({ type: r.REQUEST_PUBLIC_KEY });
+        } catch (e3) {
+          console.error(e3);
+        }
+        const { publicKey: E2, error: o2 } = e2;
+        if (o2) throw o2;
+        return E2;
+      })() : Promise.resolve(""), t = (e2, E2) => c ? (async (e3, E3, o2) => {
+        let _2 = "", t2 = "", A2 = "";
+        "object" == typeof E3 ? (_2 = E3.network || "", t2 = E3.accountToSign || "", A2 = E3.networkPassphrase || "") : (_2 = E3 || "", t2 = "");
+        let S2 = { signedTransaction: "", error: "" };
+        try {
+          S2 = await T({ transactionXdr: e3, network: _2, networkPassphrase: A2, accountToSign: t2, type: r.SUBMIT_TRANSACTION });
+        } catch (e4) {
+          throw console.error(e4), e4;
+        }
+        const { signedTransaction: n2, error: N2 } = S2;
+        if (N2) throw N2;
+        return n2;
+      })(e2, E2) : Promise.resolve(""), A = (e2, E2) => c ? (async (e3, E3) => {
+        let o2 = { signedBlob: "", error: "" };
+        const _2 = (E3 || {}).accountToSign || "";
+        try {
+          o2 = await T({ blob: e3, accountToSign: _2, type: r.SUBMIT_BLOB });
+        } catch (e4) {
+          throw console.error(e4), e4;
+        }
+        const { signedBlob: t2, error: A2 } = o2;
+        if (A2) throw A2;
+        return t2;
+      })(e2, E2) : Promise.resolve(""), S = (e2, E2) => c ? (async (e3, E3) => {
+        let o2 = { signedAuthEntry: "", error: "" };
+        const _2 = (E3 || {}).accountToSign || "";
+        try {
+          o2 = await T({ entryXdr: e3, accountToSign: _2, type: r.SUBMIT_AUTH_ENTRY });
+        } catch (e4) {
+          console.error(e4);
+        }
+        const { signedAuthEntry: t2, error: A2 } = o2;
+        if (A2) throw A2;
+        return t2;
+      })(e2, E2) : Promise.resolve(""), n = () => c ? window.freighter ? Promise.resolve(window.freighter) : (async () => {
+        let e2 = { isConnected: false };
+        try {
+          e2 = await T({ type: r.REQUEST_CONNECTION_STATUS });
+        } catch (e3) {
+          console.error(e3);
+        }
+        return e2.isConnected;
+      })() : Promise.resolve(false), N = () => c ? (async () => {
+        let e2 = { network: "", error: "" };
+        try {
+          e2 = await T({ type: r.REQUEST_NETWORK });
+        } catch (e3) {
+          console.error(e3);
+        }
+        const { network: E2, error: o2 } = e2;
+        if (o2) throw o2;
+        return E2;
+      })() : Promise.resolve(""), s = () => c ? (async () => {
+        let e2 = { networkDetails: { network: "", networkName: "", networkUrl: "", networkPassphrase: "", sorobanRpcUrl: void 0 }, error: "" };
+        try {
+          e2 = await T({ type: r.REQUEST_NETWORK_DETAILS });
+        } catch (e3) {
+          console.error(e3);
+        }
+        const { networkDetails: E2, error: o2 } = e2, { network: _2, networkUrl: t2, networkPassphrase: A2, sorobanRpcUrl: S2 } = E2;
+        if (o2) throw o2;
+        return { network: _2, networkUrl: t2, networkPassphrase: A2, sorobanRpcUrl: S2 };
+      })() : Promise.resolve({ network: "", networkUrl: "", networkPassphrase: "", sorobanRpcUrl: "" }), C = () => c ? (async () => {
+        let e2 = { isAllowed: false };
+        try {
+          e2 = await T({ type: r.REQUEST_ALLOWED_STATUS });
+        } catch (e3) {
+          console.error(e3);
+        }
+        return e2.isAllowed;
+      })() : Promise.resolve(false), O = () => c ? (async () => {
+        let e2 = { isAllowed: false, error: "" };
+        try {
+          e2 = await T({ type: r.SET_ALLOWED_STATUS });
+        } catch (e3) {
+          console.error(e3);
+        }
+        const { isAllowed: E2, error: o2 } = e2;
+        if (o2) throw o2;
+        return E2;
+      })() : Promise.resolve(false), R = () => c ? (async () => {
+        let e2 = { userInfo: { publicKey: "" }, error: "" };
+        try {
+          e2 = await T({ type: r.REQUEST_USER_INFO });
+        } catch (e3) {
+          console.error(e3);
+        }
+        const { userInfo: E2, error: o2 } = e2;
+        if (o2) throw o2;
+        return E2;
+      })() : Promise.resolve({ publicKey: "" }), i = () => c ? (async () => {
+        let e2 = { publicKey: "", error: "" };
+        try {
+          e2 = await T({ type: r.REQUEST_ACCESS });
+        } catch (e3) {
+          console.error(e3);
+        }
+        const { publicKey: E2, error: o2 } = e2;
+        if (o2) throw o2;
+        return E2;
+      })() : Promise.resolve(""), c = "undefined" != typeof window, I = { getPublicKey: _, signTransaction: t, signBlob: A, signAuthEntry: S, isConnected: n, getNetwork: N, getNetworkDetails: s, isAllowed: C, setAllowed: O, getUserInfo: R, requestAccess: i };
+      return o;
+    })()));
+  }
+});
+
+// ../../node_modules/openapi-fetch/dist/index.mjs
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    pathSerializer: globalPathSerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const globalMiddlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch: fetch2 = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      pathSerializer: requestPathSerializer,
+      body,
+      middleware: requestMiddlewares = [],
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new Request(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (finalMiddlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch: fetch2,
+        parseAs,
+        querySerializer,
+        bodySerializer,
+        pathSerializer
+      });
+      for (const m of finalMiddlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof Request) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch2(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (finalMiddlewares.length) {
+          for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+            const m = finalMiddlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (finalMiddlewares.length) {
+        for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+          const m = finalMiddlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    const contentLength = response.headers.get("Content-Length");
+    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      const getResponseData = async () => {
+        if (parseAs === "stream") {
+          return response.body;
+        }
+        if (parseAs === "json" && !contentLength) {
+          const raw = await response.text();
+          return raw ? JSON.parse(raw) : void 0;
+        }
+        return await response[parseAs]();
+      };
+      return { data: await getResponseData(), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {
+    }
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        globalMiddlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = globalMiddlewares.indexOf(m);
+        if (i !== -1) {
+          globalMiddlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  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}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function 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)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = options.pathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// src/api/client.ts
+function createApiClient(baseUrl) {
+  return createClient({ baseUrl });
+}
+
+// src/types.ts
+var PollarError = class extends Error {
+  constructor(code, message) {
+    super(message ?? code);
+    this.name = "PollarError";
+    this.code = code;
+  }
+};
+var PollarStateVar = {
+  WALLET_ADDRESS: "WALLET_ADDRESS",
+  LOGIN: "LOGIN"
+};
+var STATE_VAR_CODES = {
+  [PollarStateVar.LOGIN]: {
+    NONE: "NONE",
+    LOGOUT: "LOGOUT",
+    CREATE_SESSION_START: "CREATE_SESSION_START",
+    CREATE_SESSION_ERROR: "CREATE_SESSION_ERROR",
+    CREATE_SESSION_SUCCESS: "CREATE_SESSION_SUCCESS",
+    EMAIL_AUTH_START: "EMAIL_AUTH_START",
+    EMAIL_AUTH_START_ERROR: "EMAIL_AUTH_START_ERROR",
+    EMAIL_AUTH_START_SUCCESS: "EMAIL_AUTH_START_SUCCESS",
+    EMAIL_AUTH_CODE_ERROR: "EMAIL_AUTH_CODE_ERROR",
+    EMAIL_AUTH_CODE_SUCCESS: "EMAIL_AUTH_CODE_SUCCESS",
+    WALLET_AUTH_START: "WALLET_AUTH_START",
+    WALLET_AUTH_FREIGHTER_NOT_INSTALLED: "WALLET_AUTH_FREIGHTER_NOT_INSTALLED",
+    WALLET_AUTH_ALBEDO_NOT_INSTALLED: "WALLET_AUTH_ALBEDO_NOT_INSTALLED",
+    WALLET_AUTH_CONNECTED: "WALLET_AUTH_CONNECTED",
+    WALLET_AUTH_LOGIN_START: "WALLET_AUTH_LOGIN_START",
+    WALLET_AUTH_LOGIN_START_SUCCESS: "WALLET_AUTH_LOGIN_START_SUCCESS",
+    WALLET_AUTH_LOGIN_START_ERROR: "WALLET_AUTH_LOGIN_START_ERROR",
+    WALLET_AUTH_ERROR: "WALLET_AUTH_ERROR",
+    STREAM_POLL_START: "STREAM_POLL_START",
+    STREAM_POLL_EVENT: "STREAM_POLL_EVENT",
+    STREAM_POLL_READY: "STREAM_POLL_READY",
+    FETCH_SESSION_START: "FETCH_SESSION_START",
+    FETCH_SESSION_SUCCESS: "FETCH_SESSION_SUCCESS",
+    FETCH_SESSION_ERROR: "FETCH_SESSION_ERROR",
+    ERROR_ABORTED: "ABORTED",
+    ERROR_UNKNOWN: "ERROR_UNKNOWN"
+  },
+  [PollarStateVar.WALLET_ADDRESS]: {
+    NONE: "NONE",
+    REMOVED_ADDRESS: "REMOVED_ADDRESS",
+    UPDATED_ADDRESS: "UPDATED_ADDRESS"
+  }
+};
+var StateStatus = {
+  NONE: "NONE",
+  LOADING: "LOADING",
+  SUCCESS: "SUCCESS",
+  ERROR: "ERROR"
+};
+
+// src/wallets/FreighterAdapter.ts
+var import_freighter_api = __toESM(require_index_min());
+
+// src/wallets/types.ts
+var WalletType = /* @__PURE__ */ ((WalletType2) => {
+  WalletType2["FREIGHTER"] = "freighter";
+  WalletType2["ALBEDO"] = "albedo";
+  return WalletType2;
+})(WalletType || {});
+
+// src/wallets/FreighterAdapter.ts
+var FreighterAdapter = class {
+  constructor() {
+    this.type = "freighter" /* FREIGHTER */;
+  }
+  async isAvailable() {
+    try {
+      return await (0, import_freighter_api.isConnected)();
+    } catch {
+      return false;
+    }
+  }
+  async connect() {
+    const connected = await (0, import_freighter_api.isConnected)();
+    if (!connected) {
+      throw new Error("Freighter wallet is not installed");
+    }
+    const allowed = await (0, import_freighter_api.isAllowed)();
+    if (!allowed) {
+      await (0, import_freighter_api.setAllowed)();
+    }
+    const userInfo = await (0, import_freighter_api.getUserInfo)();
+    if (!userInfo?.publicKey) {
+      throw new Error("Failed to get user information from Freighter");
+    }
+    return { address: userInfo.publicKey, publicKey: userInfo.publicKey };
+  }
+  async disconnect() {
+  }
+  async getPublicKey() {
+    try {
+      const allowed = await (0, import_freighter_api.isAllowed)();
+      if (!allowed) return null;
+      const userInfo = await (0, import_freighter_api.getUserInfo)();
+      return userInfo?.publicKey ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getNetwork() {
+    return (0, import_freighter_api.getNetwork)();
+  }
+  async signTransaction(xdr, options) {
+    const result = await (0, import_freighter_api.signTransaction)(xdr, {
+      network: options?.network,
+      networkPassphrase: options?.networkPassphrase,
+      accountToSign: options?.accountToSign
+    });
+    if (!result || typeof result !== "string") {
+      throw new Error("Invalid response from Freighter");
+    }
+    return { signedTxXdr: result };
+  }
+  async signAuthEntry(entryXdr, options) {
+    const result = await (0, import_freighter_api.signAuthEntry)(entryXdr, { accountToSign: options?.accountToSign });
+    if (!result || typeof result !== "string") {
+      throw new Error("Invalid response from Freighter");
+    }
+    return { signedAuthEntry: result };
+  }
+};
+
+// src/wallets/AlbedoAdapter.ts
+function openAlbedoPopup(url) {
+  const popup = window.open(url, "albedo", "width=420,height=720,resizable=yes,scrollbars=yes");
+  if (!popup) {
+    throw new Error("Failed to open Albedo popup (blocked by browser)");
+  }
+  return popup;
+}
+function waitForAlbedoPopup() {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("Albedo response timeout")), 2 * 60 * 1e3);
+    function handler(event) {
+      if (event.origin !== window.location.origin || event.data?.type !== "ALBEDO_RESULT") return;
+      clearTimeout(timeout);
+      window.removeEventListener("message", handler);
+      resolve(event.data.payload);
+    }
+    window.addEventListener("message", handler);
+  });
+}
+function waitForAlbedoResult() {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("Albedo response timeout")), 2 * 60 * 1e3);
+    const parseResult = () => {
+      const params = new URLSearchParams(window.location.search);
+      if (!params.has("pubkey") && !params.has("signed_envelope_xdr") && !params.has("signed_xdr")) return;
+      clearTimeout(timeout);
+      const result = {};
+      params.forEach((value, key) => {
+        result[key] = value;
+      });
+      window.history.replaceState({}, document.title, window.location.pathname);
+      resolve(result);
+    };
+    parseResult();
+    window.addEventListener("popstate", parseResult);
+  });
+}
+var AlbedoAdapter = class {
+  constructor() {
+    this.type = "albedo" /* ALBEDO */;
+  }
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  async connect() {
+    const url = new URL("https://albedo.link");
+    url.searchParams.set("intent", "public-key");
+    url.searchParams.set("app_name", "Pollar");
+    url.searchParams.set("network", "testnet");
+    url.searchParams.set("callback", `${window.location.origin}/albedo-callback`);
+    url.searchParams.set("origin", window.location.origin);
+    openAlbedoPopup(url.toString());
+    const result = await waitForAlbedoPopup();
+    if (!result.pubkey) {
+      throw new Error("Albedo connection rejected");
+    }
+    return { address: result.pubkey, publicKey: result.pubkey };
+  }
+  async disconnect() {
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async getNetwork() {
+    throw new Error("Albedo does not expose network");
+  }
+  async signTransaction(xdr, _options) {
+    const url = new URL("https://albedo.link");
+    url.searchParams.set("intent", "tx");
+    url.searchParams.set("xdr", xdr);
+    url.searchParams.set("app_name", "Pollar");
+    url.searchParams.set("network", "testnet");
+    url.searchParams.set("callback", window.location.href);
+    url.searchParams.set("origin", window.location.origin);
+    window.location.href = url.toString();
+    const result = await waitForAlbedoResult();
+    if (!result.signed_envelope_xdr) throw new Error("Albedo signing rejected");
+    return { signedTxXdr: result.signed_envelope_xdr };
+  }
+  async signAuthEntry(entryXdr, _options) {
+    const url = new URL("https://albedo.link");
+    url.searchParams.set("intent", "sign-auth-entry");
+    url.searchParams.set("xdr", entryXdr);
+    url.searchParams.set("app_name", "Pollar");
+    url.searchParams.set("network", "testnet");
+    url.searchParams.set("callback", window.location.href);
+    url.searchParams.set("origin", window.location.origin);
+    window.location.href = url.toString();
+    const result = await waitForAlbedoResult();
+    if (!result.signed_xdr) throw new Error("Albedo auth entry signing rejected");
+    return { signedAuthEntry: result.signed_xdr };
+  }
+};
+
+// src/client/session.ts
+var STORAGE_KEY = "pollar:session";
+function isValidSession(value) {
+  if (typeof value !== "object" || value === null) {
+    console.warn("[PollarClient:session] Invalid session \u2014 value is not an object");
+    return false;
+  }
+  const s = value;
+  if (typeof s["clientSessionId"] !== "string" || s["clientSessionId"] === "") {
+    console.warn("[PollarClient:session] Invalid session \u2014 clientSessionId missing or empty");
+    return false;
+  }
+  if (s["userId"] !== null && typeof s["userId"] !== "string") {
+    console.warn("[PollarClient:session] Invalid session \u2014 userId must be string or null, got:", typeof s["userId"]);
+    return false;
+  }
+  if (typeof s["status"] !== "string") {
+    console.warn("[PollarClient:session] Invalid session \u2014 status must be string, got:", typeof s["status"]);
+    return false;
+  }
+  const token = s["token"];
+  if (typeof token !== "object" || token === null) {
+    console.warn("[PollarClient:session] Invalid session \u2014 token missing or not an object");
+    return false;
+  }
+  const t = token;
+  if (typeof t["accessToken"] !== "string" || t["accessToken"] === "") {
+    console.warn("[PollarClient:session] Invalid session \u2014 token.accessToken missing or empty");
+    return false;
+  }
+  if (typeof t["refreshToken"] !== "string" || t["refreshToken"] === "") {
+    console.warn("[PollarClient:session] Invalid session \u2014 token.refreshToken missing or empty");
+    return false;
+  }
+  if (typeof t["expiresAt"] !== "number" || !Number.isFinite(t["expiresAt"])) {
+    console.warn("[PollarClient:session] Invalid session \u2014 token.expiresAt must be a finite number");
+    return false;
+  }
+  const user = s["user"];
+  if (typeof user !== "object" || user === null) {
+    console.warn("[PollarClient:session] Invalid session \u2014 user missing or not an object");
+    return false;
+  }
+  const u = user;
+  if (u["id"] !== void 0 && typeof u["id"] !== "string") {
+    console.warn("[PollarClient:session] Invalid session \u2014 user.id must be string if present, got:", typeof u["id"]);
+    return false;
+  }
+  if (typeof u["ready"] !== "boolean") {
+    console.warn("[PollarClient:session] Invalid session \u2014 user.ready must be boolean, got:", typeof u["ready"]);
+    return false;
+  }
+  const wallet = s["wallet"];
+  if (typeof wallet !== "object" || wallet === null) {
+    console.warn("[PollarClient:session] Invalid session \u2014 wallet missing or not an object");
+    return false;
+  }
+  const w = wallet;
+  if (w["publicKey"] !== null && typeof w["publicKey"] !== "string") {
+    console.warn(
+      "[PollarClient:session] Invalid session \u2014 wallet.publicKey must be string or null, got:",
+      typeof w["publicKey"]
+    );
+    return false;
+  }
+  if (w["existsOnStellar"] !== void 0 && typeof w["existsOnStellar"] !== "boolean") {
+    console.warn("[PollarClient:session] Invalid session \u2014 wallet.existsOnStellar must be boolean if present");
+    return false;
+  }
+  if (w["createdAt"] !== void 0 && (typeof w["createdAt"] !== "number" || !Number.isFinite(w["createdAt"]))) {
+    console.warn("[PollarClient:session] Invalid session \u2014 wallet.createdAt must be a finite number if present");
+    return false;
+  }
+  const data = s["data"];
+  if (typeof data !== "object" || data === null) {
+    console.warn("[PollarClient:session] Invalid session \u2014 data missing or not an object");
+    return false;
+  }
+  const d = data;
+  for (const field of ["mail", "first_name", "last_name", "avatar"]) {
+    if (typeof d[field] !== "string") {
+      console.warn(`[PollarClient:session] Invalid session \u2014 data.${field} must be string, got:`, typeof d[field]);
+      return false;
+    }
+  }
+  const providers = d["providers"];
+  if (typeof providers !== "object" || providers === null) {
+    console.warn("[PollarClient:session] Invalid session \u2014 data.providers missing or not an object");
+    return false;
+  }
+  const p = providers;
+  const providerInnerField = { email: "address", google: "id", github: "id", wallet: "address" };
+  for (const [field, innerField] of Object.entries(providerInnerField)) {
+    const v = p[field];
+    if (v === null) continue;
+    if (typeof v !== "object") {
+      console.warn(`[PollarClient:session] Invalid session \u2014 data.providers.${field} must be object or null, got:`, typeof v);
+      return false;
+    }
+    const vObj = v;
+    if (typeof vObj[innerField] !== "string" || vObj[innerField] === "") {
+      console.warn(`[PollarClient:session] Invalid session \u2014 data.providers.${field}.${innerField} must be a non-empty string`);
+      return false;
+    }
+  }
+  return true;
+}
+function readStorage() {
+  const raw = localStorage.getItem(STORAGE_KEY);
+  if (!raw) {
+    return null;
+  }
+  try {
+    const session = JSON.parse(raw);
+    if (!isValidSession(session)) {
+      localStorage.removeItem(STORAGE_KEY);
+      console.warn("[PollarClient:session] Stored session is invalid \u2014 clearing storage");
+      return null;
+    }
+    if (session.token.expiresAt * 1e3 < Date.now()) {
+      localStorage.removeItem(STORAGE_KEY);
+      console.warn("[PollarClient:session] Session token has expired \u2014 clearing storage");
+      return null;
+    }
+    return session;
+  } catch (error) {
+    console.error("[PollarClient:session] Failed to parse session from storage", error);
+    localStorage.removeItem(STORAGE_KEY);
+    return null;
+  }
+}
+function writeStorage(session) {
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(session));
+  console.info("[PollarClient:session] Session written to storage");
+}
+function removeStorage() {
+  localStorage.removeItem(STORAGE_KEY);
+  console.info("[PollarClient:session] Session removed from storage");
+}
+
+// src/client/stream.ts
+function abortableDelay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+async function streamUntilFound(api, clientSessionId, check, retryDelayMs = 200, signal) {
+  while (true) {
+    signal?.throwIfAborted();
+    let data, error;
+    try {
+      ({ data, error } = await api.GET("/auth/session/status/{clientSessionId}", {
+        params: { path: { clientSessionId } },
+        parseAs: "stream",
+        signal: signal ?? null
+      }));
+    } catch (e) {
+      if (e instanceof Error && e.name === "AbortError") throw e;
+      console.warn(e);
+    }
+    if (error || !data) {
+      if (signal) await abortableDelay(retryDelayMs, signal);
+      else await new Promise((r) => setTimeout(r, retryDelayMs));
+      continue;
+    }
+    const reader = data.getReader();
+    const decoder = new TextDecoder();
+    let streamDone = false;
+    try {
+      while (true) {
+        signal?.throwIfAborted();
+        const { done, value } = await reader.read();
+        if (done) {
+          streamDone = true;
+          break;
+        }
+        const chunk = decoder.decode(value);
+        for (const message of chunk.split("\n\n").filter(Boolean)) {
+          const dataLine = message.split("\n").find((l) => l.startsWith("data:"));
+          if (!dataLine) continue;
+          try {
+            const parsed = JSON.parse(dataLine.slice("data:".length).trim());
+            if (check(parsed)) {
+              return parsed;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (e) {
+      if (e instanceof Error && e.name === "AbortError") throw e;
+      console.warn(e);
+    } finally {
+      reader.releaseLock();
+    }
+    const delay = streamDone ? retryDelayMs : 0;
+    if (delay) {
+      if (signal) await abortableDelay(delay, signal);
+      else await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+}
+
+// src/client/login.ts
+function withSignal(promise, signal) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      if (signal.aborted) {
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true });
+    })
+  ]);
+}
+var emitResponse = (response, successCode, errorCode, emitLog) => {
+  const isSuccess = !!response.data && !response.error;
+  emitLog(
+    PollarStateVar.LOGIN,
+    isSuccess ? successCode : errorCode,
+    isSuccess ? "info" : "error",
+    isSuccess ? StateStatus.LOADING : StateStatus.ERROR,
+    isSuccess ? response.data : response.error
+  );
+  return isSuccess;
+};
+async function login(options, deps) {
+  const { api, basePath, apiKey, signal, emitState, storeSession, clearSession } = deps;
+  emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].CREATE_SESSION_START, "info", StateStatus.LOADING);
+  const createSessionResponse = await api.POST("/auth/session", { signal });
+  if (!emitResponse(
+    createSessionResponse,
+    STATE_VAR_CODES[PollarStateVar.LOGIN].CREATE_SESSION_SUCCESS,
+    STATE_VAR_CODES[PollarStateVar.LOGIN].CREATE_SESSION_ERROR,
+    emitState
+  )) {
+    return;
+  }
+  const clientSessionId = createSessionResponse.data.content.clientSessionId;
+  switch (options.provider) {
+    case "email": {
+      emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].EMAIL_AUTH_START, "info", StateStatus.LOADING, {
+        email: options.email
+      });
+      const emailRes = await api.POST(`/auth/email`, {
+        body: { clientSessionId, email: options.email },
+        signal
+      });
+      if (!emitResponse(
+        emailRes,
+        STATE_VAR_CODES[PollarStateVar.LOGIN].EMAIL_AUTH_START_SUCCESS,
+        STATE_VAR_CODES[PollarStateVar.LOGIN].EMAIL_AUTH_START_ERROR,
+        emitState
+      )) {
+        return;
+      }
+      break;
+    }
+    case "google":
+    case "github": {
+      const url = new URL(`${basePath}/auth/${options.provider}`);
+      url.searchParams.set("api_key", apiKey);
+      url.searchParams.set("client_session_id", clientSessionId);
+      url.searchParams.set("redirect_uri", window.location.origin);
+      window.open(url.toString(), "_blank");
+      break;
+    }
+    case "wallet": {
+      try {
+        emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_START, "info", StateStatus.LOADING, {
+          adapter: options.type
+        });
+        const adapter = options.type === "freighter" /* FREIGHTER */ ? new FreighterAdapter() : new AlbedoAdapter();
+        const available = await withSignal(adapter.isAvailable(), signal);
+        if (!available) {
+          emitState(
+            PollarStateVar.LOGIN,
+            options.type === "freighter" /* FREIGHTER */ ? STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_FREIGHTER_NOT_INSTALLED : STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_ALBEDO_NOT_INSTALLED,
+            "info",
+            StateStatus.LOADING,
+            {
+              type: options.type
+            }
+          );
+        }
+        const { publicKey } = await withSignal(adapter.connect(), signal);
+        emitState(
+          PollarStateVar.LOGIN,
+          STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_CONNECTED,
+          "info",
+          StateStatus.LOADING,
+          {
+            adapter: options.type,
+            publicKey
+          }
+        );
+        emitState(
+          PollarStateVar.LOGIN,
+          STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_LOGIN_START,
+          "info",
+          StateStatus.LOADING,
+          {
+            adapter: options.type,
+            publicKey
+          }
+        );
+        const emailRes = await api.POST(`/auth/wallet`, {
+          body: { clientSessionId, walletAddress: publicKey },
+          signal
+        });
+        if (!emitResponse(
+          emailRes,
+          STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_LOGIN_START_SUCCESS,
+          STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_LOGIN_START_ERROR,
+          emitState
+        )) {
+          return;
+        }
+      } catch (error2) {
+        emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_ERROR, "error", StateStatus.ERROR, {
+          clientSessionId
+        });
+      }
+      break;
+    }
+  }
+  emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].STREAM_POLL_START, "info", StateStatus.LOADING, {
+    clientSessionId
+  });
+  await streamUntilFound(
+    api,
+    clientSessionId,
+    (data2) => {
+      const status = data2?.status;
+      if (status === "READY") {
+        emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].STREAM_POLL_READY, "info", StateStatus.LOADING);
+        return true;
+      }
+      emitState(
+        PollarStateVar.LOGIN,
+        STATE_VAR_CODES[PollarStateVar.LOGIN].STREAM_POLL_EVENT + (status ? `/${status}` : ""),
+        "info",
+        StateStatus.LOADING,
+        data2
+      );
+      return false;
+    },
+    200,
+    signal
+  );
+  emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].FETCH_SESSION_START, "info", StateStatus.LOADING);
+  const { data, error } = await api.POST(`/auth/login`, {
+    body: { clientSessionId },
+    signal
+  });
+  if (data?.code === "SDK_LOGIN_SUCCESS" && isValidSession(data?.content)) {
+    emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].FETCH_SESSION_SUCCESS, "info", StateStatus.SUCCESS);
+    storeSession(data.content);
+  } else {
+    emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].FETCH_SESSION_ERROR, "error", StateStatus.ERROR, {
+      error,
+      data
+    });
+    clearSession();
+  }
+}
+
+// src/client/client.ts
+var isBrowser = typeof window !== "undefined" && typeof localStorage !== "undefined";
+function warnServerSide(method) {
+  console.warn(
+    `[PollarClient] ${method}() called server-side \u2014 browser APIs unavailable. Use PollarClient only in Client Components.`
+  );
+}
+var PollarClient = class {
+  constructor(config) {
+    this._session = null;
+    this._stateListeners = /* @__PURE__ */ new Set();
+    this._state = {
+      [PollarStateVar.LOGIN]: [],
+      [PollarStateVar.WALLET_ADDRESS]: []
+    };
+    this.apiKey = config.apiKey;
+    this.id = crypto.randomUUID();
+    this.basePath = `${config.baseUrl || "https://sdk.api.pollar.xyz"}/v1`;
+    this._api = createApiClient(this.basePath);
+    this._api.use({
+      onRequest({ request }) {
+        request.headers.set("x-pollar-api-key", config.apiKey);
+        return request;
+      }
+    });
+    if (!isBrowser) {
+      warnServerSide("constructor");
+      this._session = null;
+      return;
+    }
+    console.info(`[PollarClient] Initialized \u2014 endpoint: ${this.basePath}`);
+    this._readStore();
+    window.addEventListener("storage", (e) => {
+      if (e.key === STORAGE_KEY) {
+        const prev = this._session;
+        console.info(`[PollarClient] Storage event \u2014 session ${this._session ? "updated" : prev ? "cleared" : "unchanged"}`);
+        this._readStore();
+      }
+    });
+  }
+  isAuthenticated() {
+    return !!this._session?.wallet?.publicKey;
+  }
+  getState() {
+    return { session: this._session };
+  }
+  getApi() {
+    return this._api;
+  }
+  login(options) {
+    if (!isBrowser) {
+      warnServerSide("login");
+      return {
+        cancelLogin: () => {
+        }
+      };
+    }
+    const controller = new AbortController();
+    console.info(`[PollarClient] Login started \u2014 provider: ${options.provider}`);
+    login(options, {
+      api: this._api,
+      basePath: this.basePath,
+      apiKey: this.apiKey,
+      signal: controller.signal,
+      emitState: this._emitState.bind(this),
+      storeSession: this._storeSession.bind(this),
+      clearSession: this._clearSession.bind(this)
+    }).catch((error) => {
+      if (error instanceof Error && error.name === "AbortError") {
+        console.info("[PollarClient] Login aborted by user");
+        this._emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].ERROR_ABORTED, "error", StateStatus.ERROR);
+        return;
+      }
+      console.error("[PollarClient] Login failed with unexpected error", error);
+      this._emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].ERROR_UNKNOWN, "error", StateStatus.ERROR, {
+        error
+      });
+    });
+    return { cancelLogin: () => controller.abort() };
+  }
+  onStateChange(cb) {
+    this._stateListeners.add(cb);
+    for (const [, stateEntry] of Object.entries(this._state)) {
+      if (stateEntry.length >= 1) {
+        cb(stateEntry.at(-1));
+      }
+    }
+    return () => this._stateListeners.delete(cb);
+  }
+  async verifyEmailCode(clientSessionId, code) {
+    if (!isBrowser) {
+      warnServerSide("verifyEmailCode");
+      return;
+    }
+    try {
+      const { error, data } = await this._api.POST("/auth/email/verify-code", {
+        body: { clientSessionId, code }
+      });
+      if (error || !data || data?.code !== "SDK_EMAIL_CODE_VERIFIED") {
+        this._emitState(
+          PollarStateVar.LOGIN,
+          STATE_VAR_CODES[PollarStateVar.LOGIN].EMAIL_AUTH_CODE_ERROR,
+          "error",
+          StateStatus.ERROR,
+          {
+            data,
+            error
+          }
+        );
+        return;
+      }
+      this._emitState(
+        PollarStateVar.LOGIN,
+        STATE_VAR_CODES[PollarStateVar.LOGIN].EMAIL_AUTH_CODE_SUCCESS,
+        "info",
+        StateStatus.SUCCESS,
+        {
+          data,
+          error
+        }
+      );
+    } catch (error) {
+      this._emitState(
+        PollarStateVar.LOGIN,
+        STATE_VAR_CODES[PollarStateVar.LOGIN].WALLET_AUTH_ALBEDO_NOT_INSTALLED,
+        "error",
+        StateStatus.ERROR
+      );
+    }
+  }
+  logout() {
+    if (!isBrowser) {
+      warnServerSide("logout");
+      return;
+    }
+    console.info("[PollarClient] Logout requested");
+    this._clearSession();
+  }
+  _readStore() {
+    this._session = readStorage();
+    if (this._session) {
+      this._emitState(
+        PollarStateVar.WALLET_ADDRESS,
+        STATE_VAR_CODES[PollarStateVar.WALLET_ADDRESS].UPDATED_ADDRESS,
+        "info",
+        StateStatus.SUCCESS,
+        this._session
+      );
+      console.info("[PollarClient] Session restored from storage");
+    } else {
+      this._emitState(
+        PollarStateVar.WALLET_ADDRESS,
+        STATE_VAR_CODES[PollarStateVar.WALLET_ADDRESS].REMOVED_ADDRESS,
+        "info",
+        StateStatus.SUCCESS
+      );
+      console.info("[PollarClient] Session NO restored from storage");
+    }
+  }
+  _storeSession(session) {
+    console.info(`[PollarClient] Session stored \u2014 user: ${session.userId ?? "anonymous"}`);
+    this._session = session;
+    writeStorage(session);
+    this._emitState(
+      PollarStateVar.WALLET_ADDRESS,
+      STATE_VAR_CODES[PollarStateVar.WALLET_ADDRESS].UPDATED_ADDRESS,
+      "info",
+      StateStatus.SUCCESS,
+      this._session
+    );
+  }
+  _clearSession() {
+    console.info("[PollarClient] Session cleared");
+    this._session = null;
+    removeStorage();
+    this._state = {
+      [PollarStateVar.LOGIN]: [],
+      [PollarStateVar.WALLET_ADDRESS]: []
+    };
+    this._emitState(PollarStateVar.LOGIN, STATE_VAR_CODES[PollarStateVar.LOGIN].LOGOUT, "info", StateStatus.NONE);
+    this._emitState(
+      PollarStateVar.WALLET_ADDRESS,
+      STATE_VAR_CODES[PollarStateVar.WALLET_ADDRESS].REMOVED_ADDRESS,
+      "info",
+      StateStatus.NONE
+    );
+  }
+  _emitState(fn, code, level, status, data) {
+    const stateEntry = { var: fn, code, level, data, status, ts: Date.now() };
+    this._state[fn].push(stateEntry);
+    console[level](`[PollarClient] ${fn}:${code} \u2014 ${status}`);
+    for (const cb of this._stateListeners) {
+      cb(stateEntry);
+    }
+  }
+};
+
+// src/stellar/StellarClient.ts
+var HORIZON_URLS = {
+  mainnet: "https://horizon.stellar.org",
+  testnet: "https://horizon-testnet.stellar.org"
+};
+var StellarClient = class {
+  constructor(config) {
+    this.horizonUrl = typeof config === "string" ? HORIZON_URLS[config] : config.horizonUrl;
+  }
+  async getBalances(publicKey) {
+    try {
+      const response = await fetch(`${this.horizonUrl}/accounts/${publicKey}`);
+      if (!response.ok) {
+        if (response.status === 404) {
+          console.warn(`[StellarClient] Account not found: ${publicKey}`);
+          return { success: false, errorCode: "ACCOUNT_NOT_FOUND", balances: [] };
+        }
+        console.warn(`[StellarClient] Horizon API error: ${response.status}`);
+        return { success: false, errorCode: "HORIZON_ERROR", balances: [] };
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        balances: data.balances.filter((b) => b.asset_type !== "liquidity_pool_shares").map((b) => ({
+          asset: b.asset_type === "native" ? "XLM" : b.asset_code ?? "",
+          balance: b.balance,
+          ...b.asset_type !== "native" && { assetIssuer: b.asset_issuer }
+        }))
+      };
+    } catch (error) {
+      console.warn("[StellarClient] Network error fetching balances", error);
+      return { success: false, errorCode: "NETWORK_ERROR", balances: [] };
+    }
+  }
+};
+
+exports.AlbedoAdapter = AlbedoAdapter;
+exports.FreighterAdapter = FreighterAdapter;
+exports.PollarClient = PollarClient;
+exports.PollarError = PollarError;
+exports.PollarStateVar = PollarStateVar;
+exports.STATE_VAR_CODES = STATE_VAR_CODES;
+exports.StateStatus = StateStatus;
+exports.StellarClient = StellarClient;
+exports.WalletType = WalletType;
+exports.isValidSession = isValidSession;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map