@pollar/core 0.4.5 → 0.5.2

package/dist/index.js

@@ -652,31 +652,98 @@ function createApiClient(baseUrl) {
   return createClient({ baseUrl });
 }
 
-// src/constants.ts
-var StateStatus = {
-  NONE: "NONE",
-  LOADING: "LOADING",
-  SUCCESS: "SUCCESS",
-  ERROR: "ERROR"
-};
-var PollarStateVar = {
-  NETWORK: "network",
-  TRANSACTION: "transaction"
+// src/api/endpoints/kyc.ts
+async function getKycStatus(api, providerId) {
+  const { data, error } = await api.GET("/kyc/status", {
+    params: { query: providerId ? { providerId } : {} }
+  });
+  if (!data?.content || error) {
+    throw new Error(error?.error ?? "Failed to get KYC status");
+  }
+  return data.content;
+}
+async function getKycProviders(api, country) {
+  const { data, error } = await api.GET("/kyc/providers", { params: { query: { country } } });
+  if (!data?.content || error) throw new Error(error?.error ?? "Failed to get KYC providers");
+  return data.content;
+}
+async function startKyc(api, body) {
+  const { data, error } = await api.POST("/kyc/start", { body });
+  if (!data?.content || error) throw new Error(error?.error ?? "Failed to start KYC");
+  return data.content;
+}
+async function resolveKyc(api, providerId, level = "basic") {
+  const { status } = await getKycStatus(api, providerId);
+  if (status === "approved") return { alreadyApproved: true };
+  const started = await startKyc(api, { providerId, level });
+  return { alreadyApproved: false, ...started };
+}
+async function pollKycStatus(api, providerId, { intervalMs = 3e3, timeoutMs = 3e5 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const { status } = await getKycStatus(api, providerId);
+    if (status === "approved" || status === "rejected") return status;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error("KYC polling timed out");
+}
+
+// src/api/endpoints/ramps.ts
+async function getRampsQuote(api, query) {
+  const { data, error } = await api.GET("/ramps/quote", { params: { query } });
+  if (!data?.content || error) throw new Error(error?.error ?? "Failed to get ramp quotes");
+  return data.content;
+}
+async function createOnRamp(api, body) {
+  const { data, error } = await api.POST("/ramps/onramp", { body });
+  if (!data?.content || error) throw new Error(error?.error ?? "Failed to create onramp");
+  return data.content;
+}
+async function createOffRamp(api, body) {
+  const { data, error } = await api.POST("/ramps/offramp", { body });
+  if (!data?.content || error) throw new Error(error?.error ?? "Failed to create offramp");
+  return data.content;
+}
+async function getRampTransaction(api, txId) {
+  const { data, error } = await api.GET("/ramps/transaction/{txId}", { params: { path: { txId } } });
+  if (!data?.content || error) throw new Error(error?.error ?? "Failed to get transaction");
+  return data.content;
+}
+async function pollRampTransaction(api, txId, { intervalMs = 5e3, timeoutMs = 6e5 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const { status } = await getRampTransaction(api, txId);
+    if (status === "completed" || status === "failed") return status;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error("Ramp transaction polling timed out");
+}
+
+// src/stellar/StellarClient.ts
+var HORIZON_URLS = {
+  mainnet: "https://horizon.stellar.org",
+  testnet: "https://horizon-testnet.stellar.org"
 };
-var STATE_VAR_CODES = {
-  transaction: {
-    NONE: "NONE",
-    BUILD_TRANSACTION_ERROR_NO_WALLET: "BUILD_TRANSACTION_ERROR_NO_WALLET",
-    BUILD_TRANSACTION_START: "BUILD_TRANSACTION_START",
-    BUILD_TRANSACTION_SUCCESS: "BUILD_TRANSACTION_SUCCESS",
-    BUILD_TRANSACTION_ERROR: "BUILD_TRANSACTION_ERROR",
-    SIGN_SEND_TRANSACTION_START: "SIGN_SEND_TRANSACTION_START",
-    SIGN_SEND_TRANSACTION_SUCCESS: "SIGN_SEND_TRANSACTION_SUCCESS",
-    SIGN_SEND_TRANSACTION_ERROR: "SIGN_SEND_TRANSACTION_ERROR"
-  },
-  network: {
-    NONE: "NONE",
-    NETWORK_UPDATED: "NETWORK_UPDATED"
+var StellarClient = class {
+  constructor(config) {
+    this.horizonUrl = typeof config === "string" ? HORIZON_URLS[config] : config.horizonUrl;
+  }
+  async submitTransaction(signedXdr) {
+    try {
+      const response = await fetch(`${this.horizonUrl}/transactions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ tx: signedXdr })
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({}));
+        return { success: false, errorCode: body.extras?.result_codes?.transaction ?? "HORIZON_ERROR" };
+      }
+      const data = await response.json();
+      return { success: true, hash: data.hash };
+    } catch {
+      return { success: false, errorCode: "NETWORK_ERROR" };
+    }
   }
 };
 
@@ -700,8 +767,176 @@ var PollarFlowError = class extends 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";
+var WALLET_TYPE_KEY = "pollar:walletType";
 function isValidSession(value) {
   if (typeof value !== "object" || value === null) {
     console.warn("[PollarClient:session] Invalid session \u2014 value is not an object");
@@ -837,8 +1072,15 @@ function writeStorage(session) {
 }
 function removeStorage() {
   localStorage.removeItem(STORAGE_KEY);
+  localStorage.removeItem(WALLET_TYPE_KEY);
   console.info("[PollarClient:session] Session removed from storage");
 }
+function writeWalletType(type) {
+  localStorage.setItem(WALLET_TYPE_KEY, type);
+}
+function readWalletType() {
+  return localStorage.getItem(WALLET_TYPE_KEY);
+}
 
 // src/client/stream.ts
 function abortableDelay(ms, signal) {
@@ -912,7 +1154,7 @@ async function streamUntilFound(api, clientSessionId, check, retryDelayMs = 200,
 }
 
 // src/client/auth/authenticate.ts
-async function authenticate(clientSessionId, deps) {
+async function authenticate(clientSessionId, deps, expectedWallet) {
   const { api, signal, setAuthState, storeSession, clearSession } = deps;
   setAuthState({ step: "authenticating" });
   await streamUntilFound(api, clientSessionId, (data2) => data2?.status === "READY", 200, signal);
@@ -921,6 +1163,16 @@ async function authenticate(clientSessionId, deps) {
     signal
   });
   if (data?.code === "SDK_LOGIN_SUCCESS" && isValidSession(data?.content)) {
+    if (expectedWallet && data.content.data.providers.wallet?.address !== expectedWallet) {
+      setAuthState({
+        step: "error",
+        previousStep: "authenticating",
+        message: "Wallet mismatch: session wallet does not match connected wallet",
+        errorCode: AUTH_ERROR_CODES.WALLET_AUTH_FAILED
+      });
+      clearSession();
+      return;
+    }
     storeSession(data.content);
   } else {
     setAuthState({
@@ -933,8 +1185,8 @@ async function authenticate(clientSessionId, deps) {
   }
 }
 
-// src/client/auth/emailFlow.ts
-async function initEmailSession(deps) {
+// src/client/auth/deps.ts
+async function createAuthSession(deps) {
   const { api, signal, setAuthState } = deps;
   setAuthState({ step: "creating_session" });
   const { data, error } = await api.POST("/auth/session", { signal });
@@ -945,9 +1197,16 @@ async function initEmailSession(deps) {
       message: "Failed to create session",
       errorCode: AUTH_ERROR_CODES.SESSION_CREATE_FAILED
     });
-    return;
+    return null;
   }
-  setAuthState({ step: "entering_email", clientSessionId: data.content.clientSessionId });
+  return data.content.clientSessionId;
+}
+
+// src/client/auth/emailFlow.ts
+async function initEmailSession(deps) {
+  const clientSessionId = await createAuthSession(deps);
+  if (!clientSessionId) return;
+  deps.setAuthState({ step: "entering_email", clientSessionId });
 }
 async function sendEmailCode(email, clientSessionId, deps) {
   const { api, signal, setAuthState } = deps;
@@ -1010,25 +1269,10 @@ async function verifyAndAuthenticate(code, clientSessionId, email, deps) {
 }
 
 // src/client/auth/oauthFlow.ts
-async function initOAuthSession(deps) {
-  const { api, signal, setAuthState } = deps;
-  setAuthState({ step: "creating_session" });
-  const { data, error } = await api.POST("/auth/session", { signal });
-  if (error || !data?.success) {
-    setAuthState({
-      step: "error",
-      previousStep: "creating_session",
-      message: "Failed to create session",
-      errorCode: AUTH_ERROR_CODES.SESSION_CREATE_FAILED
-    });
-    return null;
-  }
-  return data.content.clientSessionId;
-}
 async function loginOAuth(provider, deps) {
   const { setAuthState, basePath, apiKey } = deps;
   const popup = window.open("about:blank", "_blank");
-  const clientSessionId = await initOAuthSession(deps);
+  const clientSessionId = await createAuthSession(deps);
   if (!clientSessionId) {
     popup?.close();
     return;
@@ -1046,173 +1290,6 @@ async function loginOAuth(provider, deps) {
   await authenticate(clientSessionId, deps);
 }
 
-// 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/auth/walletFlow.ts
 function withSignal(promise, signal) {
   return Promise.race([
@@ -1228,18 +1305,9 @@ function withSignal(promise, signal) {
 }
 async function loginWallet(type, deps) {
   const { api, signal, setAuthState } = deps;
-  setAuthState({ step: "creating_session" });
-  const { data, error } = await api.POST("/auth/session", { signal });
-  if (error || !data?.success) {
-    setAuthState({
-      step: "error",
-      previousStep: "creating_session",
-      message: "Failed to create session",
-      errorCode: AUTH_ERROR_CODES.SESSION_CREATE_FAILED
-    });
-    return;
-  }
-  const clientSessionId = data.content.clientSessionId;
+  const clientSessionId = await createAuthSession(deps);
+  if (!clientSessionId) return;
+  let connectedWallet;
   try {
     setAuthState({ step: "connecting_wallet", walletType: type });
     const adapter = type === "freighter" /* FREIGHTER */ ? new FreighterAdapter() : new AlbedoAdapter();
@@ -1249,6 +1317,8 @@ async function loginWallet(type, deps) {
       return;
     }
     const { publicKey } = await withSignal(adapter.connect(), signal);
+    connectedWallet = publicKey;
+    deps.storeWalletAdapter(adapter, type);
     setAuthState({ step: "authenticating_wallet" });
     const { data: walletData, error: walletError } = await api.POST("/auth/wallet", {
       body: { clientSessionId, walletAddress: publicKey },
@@ -1272,22 +1342,9 @@ async function loginWallet(type, deps) {
     });
     return;
   }
-  await authenticate(clientSessionId, deps);
+  await authenticate(clientSessionId, deps, connectedWallet);
 }
 
-// src/client/helpers.ts
-var emitResponse = (state, response, success, errorCode, emitLog) => {
-  const isSuccess = !response.error && !!response.data && !!response.data?.success;
-  emitLog(
-    state,
-    isSuccess ? success.code : errorCode,
-    isSuccess ? "info" : "error",
-    isSuccess ? success.status || StateStatus.LOADING : StateStatus.ERROR,
-    isSuccess ? response.data : response.error
-  );
-  return isSuccess;
-};
-
 // src/client/client.ts
 var isBrowser = typeof window !== "undefined" && typeof localStorage !== "undefined";
 function warnServerSide(method) {
@@ -1298,46 +1355,50 @@ function warnServerSide(method) {
 var PollarClient = class {
   constructor(config) {
     this._session = null;
-    this._stateListeners = /* @__PURE__ */ new Set();
-    this._state = {
-      network: [],
-      transaction: []
-    };
+    this._transactionState = null;
+    this._transactionStateListeners = /* @__PURE__ */ new Set();
+    this._txHistoryState = { step: "idle" };
+    this._txHistoryStateListeners = /* @__PURE__ */ new Set();
+    this._walletBalanceState = { step: "idle" };
+    this._walletBalanceStateListeners = /* @__PURE__ */ new Set();
     this._authState = { step: "idle" };
     this._authStateListeners = /* @__PURE__ */ new Set();
+    this._networkState = { step: "idle" };
+    this._networkStateListeners = /* @__PURE__ */ new Set();
+    this._walletAdapter = null;
     this._loginController = null;
     this.apiKey = config.apiKey;
     this.id = crypto.randomUUID();
     this.basePath = `${config.baseUrl || "https://sdk.api.pollar.xyz"}/v1`;
     this._api = createApiClient(this.basePath);
+    const self = this;
     this._api.use({
       onRequest({ request }) {
         request.headers.set("x-pollar-api-key", config.apiKey);
+        const accessToken = self._session?.token?.accessToken;
+        if (accessToken) {
+          request.headers.set("Authorization", `Bearer ${accessToken}`);
+        }
         return request;
       }
     });
+    this._networkState = { step: "connected", network: config.stellarNetwork ?? "testnet" };
     if (!isBrowser) {
       warnServerSide("constructor");
       this._session = null;
       return;
     }
-    console.info(`[PollarClient] Initialized \u2014 endpoint: ${this.basePath}`);
-    this._readStore();
+    console.info(`[PollarClient] Initialized \u2014 endpoint: ${this.basePath}, network: ${this._networkState.network}`);
+    this._restoreSession();
     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();
+        this._restoreSession();
       }
     });
-    this._emitState("network", STATE_VAR_CODES.network.NETWORK_UPDATED, "info", StateStatus.SUCCESS, {
-      network: "testnet"
-    });
   }
   // ─── Auth state ──────────────────────────────────────────────────────────────
-  isAuthenticated() {
-    return !!this._session?.wallet?.publicKey;
-  }
   getAuthState() {
     return this._authState;
   }
@@ -1352,17 +1413,23 @@ var PollarClient = class {
       warnServerSide("login");
       return;
     }
-    if (options.provider === "google" || options.provider === "github") {
-      this.loginOAuth(options.provider);
-    } else if (options.provider === "email") {
-      const { email } = options;
+    if (options.provider === "google" || options.provider === "github" || options.provider === "email") {
       const controller = this._newController();
       const deps = this._flowDeps(controller.signal);
-      initEmailSession(deps).then(() => {
-        if (this._authState.step === "entering_email") {
-          return sendEmailCode(email, this._authState.clientSessionId, deps);
-        }
-      }).catch((err) => this._handleFlowError(err));
+      if (options.provider === "google" || options.provider === "github") {
+        loginOAuth(options.provider, {
+          ...deps,
+          basePath: this.basePath,
+          apiKey: this.apiKey
+        }).catch((err) => this._handleFlowError(err));
+      } else if (options.provider === "email") {
+        const { email } = options;
+        initEmailSession(deps).then(() => {
+          if (this._authState.step === "entering_email") {
+            return sendEmailCode(email, this._authState.clientSessionId, deps);
+          }
+        }).catch((err) => this._handleFlowError(err));
+      }
     } else if (options.provider === "wallet") {
       this.loginWallet(options.type);
     }
@@ -1405,19 +1472,6 @@ var PollarClient = class {
       (err) => this._handleFlowError(err)
     );
   }
-  // ─── OAuth flow (single call) ─────────────────────────────────────────────
-  loginOAuth(provider) {
-    if (!isBrowser) {
-      warnServerSide("loginOAuth");
-      return;
-    }
-    const controller = this._newController();
-    loginOAuth(provider, {
-      ...this._flowDeps(controller.signal),
-      basePath: this.basePath,
-      apiKey: this.apiKey
-    }).catch((err) => this._handleFlowError(err));
-  }
   // ─── Wallet flow (single call) ────────────────────────────────────────────
   loginWallet(type) {
     if (!isBrowser) {
@@ -1442,24 +1496,85 @@ var PollarClient = class {
     console.info("[PollarClient] Logout requested");
     this._clearSession();
   }
-  // ─── General state (network / transaction) ────────────────────────────────
-  getApi() {
-    return this._api;
-  }
+  // ─── Network ──────────────────────────────────────────────────────────────
   getNetwork() {
-    return this._state.network.at(-1)?.data?.network === "public" ? "public" : "testnet";
+    return this._networkState.step === "connected" ? this._networkState.network : "testnet";
+  }
+  getNetworkState() {
+    return this._networkState;
+  }
+  setNetwork(network) {
+    this._setNetworkState({ step: "connected", network });
+  }
+  onNetworkStateChange(cb) {
+    this._networkStateListeners.add(cb);
+    cb(this._networkState);
+    return () => this._networkStateListeners.delete(cb);
+  }
+  // ─── Transaction state ────────────────────────────────────────────────────
+  getTransactionState() {
+    return this._transactionState;
+  }
+  onTransactionStateChange(cb) {
+    this._transactionStateListeners.add(cb);
+    if (this._transactionState) cb(this._transactionState);
+    return () => this._transactionStateListeners.delete(cb);
+  }
+  // ─── Tx history ──────────────────────────────────────────────────────────
+  getTxHistoryState() {
+    return this._txHistoryState;
+  }
+  onTxHistoryStateChange(cb) {
+    this._txHistoryStateListeners.add(cb);
+    cb(this._txHistoryState);
+    return () => this._txHistoryStateListeners.delete(cb);
+  }
+  async fetchTxHistory(params = {}) {
+    this._setTxHistoryState({ step: "loading", params });
+    try {
+      const { data, error } = await this._api.GET("/tx/history", { params: { query: params } });
+      if (!error && data?.success && data.content) {
+        this._setTxHistoryState({ step: "loaded", params, data: data.content });
+      } else {
+        const message = error?.message ?? "Failed to load history";
+        this._setTxHistoryState({ step: "error", params, message });
+      }
+    } catch {
+      this._setTxHistoryState({ step: "error", params, message: "Failed to load history" });
+    }
   }
-  onStateChange(cb) {
-    this._stateListeners.add(cb);
-    for (const [, stateEntry] of Object.entries(this._state)) {
-      if (stateEntry.length >= 1) cb(stateEntry.at(-1));
+  // ─── Wallet balance ───────────────────────────────────────────────────────
+  getWalletBalanceState() {
+    return this._walletBalanceState;
+  }
+  onWalletBalanceStateChange(cb) {
+    this._walletBalanceStateListeners.add(cb);
+    cb(this._walletBalanceState);
+    return () => this._walletBalanceStateListeners.delete(cb);
+  }
+  async refreshBalance(publicKey) {
+    const pk = publicKey ?? this._session?.wallet?.publicKey;
+    if (!pk) {
+      this._setWalletBalanceState({ step: "error", message: "No wallet connected" });
+      return;
+    }
+    this._setWalletBalanceState({ step: "loading" });
+    try {
+      const network = this.getNetwork();
+      const { data, error } = await this._api.GET("/wallet/balance", { params: { query: { publicKey: pk, network } } });
+      if (!error && data?.success && data.content) {
+        this._setWalletBalanceState({ step: "loaded", data: data.content });
+      } else {
+        this._setWalletBalanceState({ step: "error", message: "Failed to load balance" });
+      }
+    } catch {
+      this._setWalletBalanceState({ step: "error", message: "Failed to load balance" });
     }
-    return () => this._stateListeners.delete(cb);
   }
   // ─── Transactions ─────────────────────────────────────────────────────────
   async buildTx(operation, params, options) {
     if (!this._session?.wallet?.publicKey) {
-      this._emitState("transaction", STATE_VAR_CODES.transaction.BUILD_TRANSACTION_ERROR_NO_WALLET, "error", StateStatus.ERROR);
+      this._setTransactionState({ step: "error", details: "No wallet connected" });
       return;
     }
     const body = {
@@ -1467,42 +1582,114 @@ var PollarClient = class {
       publicKey: this._session.wallet.publicKey,
       operation,
       params,
-      options: options || {}
+      options: options ?? {}
     };
     try {
-      this._emitState("transaction", STATE_VAR_CODES.transaction.BUILD_TRANSACTION_START, "info", StateStatus.LOADING);
-      const response = await this._api.POST("/tx/build", { body });
-      emitResponse(
-        PollarStateVar.TRANSACTION,
-        response,
-        { code: STATE_VAR_CODES.transaction.BUILD_TRANSACTION_SUCCESS, status: StateStatus.SUCCESS },
-        STATE_VAR_CODES.transaction.BUILD_TRANSACTION_ERROR,
-        this._emitState.bind(this)
-      );
-    } catch (error) {
-      this._emitState("transaction", STATE_VAR_CODES.transaction.BUILD_TRANSACTION_ERROR, "error", StateStatus.ERROR, {
-        error
-      });
+      this._setTransactionState({ step: "building" });
+      const { data, error } = await this._api.POST("/tx/build", { body });
+      if (!error && data?.success && data.content) {
+        this._setTransactionState({ step: "built", buildData: data.content });
+      } else {
+        const details = error?.details;
+        this._setTransactionState({ step: "error", ...details && { details } });
+      }
+    } catch {
+      this._setTransactionState({ step: "error" });
     }
   }
-  async submitTx(signedXdr) {
-    const body = { network: this.getNetwork(), signedXdr };
+  getWalletType() {
+    return this._walletAdapter?.type ?? null;
+  }
+  async signAndSubmitTx(unsignedXdr) {
+    const state = this._transactionState;
+    const buildData = state?.step === "built" ? state.buildData : state?.step === "error" ? state.buildData : void 0;
+    const isBuiltFlow = !!buildData;
+    const stateExtra = buildData ? { buildData } : { external: true };
+    this._setTransactionState({ step: "signing", ...stateExtra });
+    const accountToSign = isBuiltFlow ? this._session?.wallet?.publicKey : this._session?.data?.providers?.wallet?.address ?? this._session?.wallet?.publicKey;
+    if (this._walletAdapter) {
+      try {
+        const signOpts = accountToSign ? { networkPassphrase: this._networkPassphrase(), accountToSign } : { networkPassphrase: this._networkPassphrase() };
+        const { signedTxXdr } = await this._walletAdapter.signTransaction(unsignedXdr, signOpts);
+        const stellarClient = new StellarClient(this.getNetwork());
+        const result = await stellarClient.submitTransaction(signedTxXdr);
+        if (result.success) {
+          this._setTransactionState({ step: "success", ...stateExtra, hash: result.hash });
+        } else {
+          this._setTransactionState({ step: "error", ...stateExtra, details: result.errorCode });
+        }
+      } catch {
+        this._setTransactionState({ step: "error", ...stateExtra });
+      }
+      return;
+    }
+    const body = {
+      network: this.getNetwork(),
+      publicKey: this._session?.wallet?.publicKey ?? "",
+      unsignedXdr
+    };
     try {
-      this._emitState("transaction", STATE_VAR_CODES.transaction.SIGN_SEND_TRANSACTION_START, "info", StateStatus.LOADING);
-      const response = await this._api.POST("/tx/sign-and-send", { body });
-      emitResponse(
-        PollarStateVar.TRANSACTION,
-        response,
-        { code: STATE_VAR_CODES.transaction.SIGN_SEND_TRANSACTION_SUCCESS, status: StateStatus.SUCCESS },
-        STATE_VAR_CODES.transaction.SIGN_SEND_TRANSACTION_ERROR,
-        this._emitState.bind(this)
-      );
-    } catch (error) {
-      this._emitState("transaction", STATE_VAR_CODES.transaction.SIGN_SEND_TRANSACTION_ERROR, "error", StateStatus.ERROR, {
-        error
-      });
+      const { data, error } = await this._api.POST("/tx/sign-and-send", { body });
+      if (!error && data?.success && data.content?.hash) {
+        this._setTransactionState({ step: "success", ...stateExtra, hash: data.content.hash });
+      } else {
+        const details = error?.details;
+        this._setTransactionState({ step: "error", ...stateExtra, ...details && { details } });
+      }
+    } catch {
+      this._setTransactionState({ step: "error", ...stateExtra });
     }
   }
+  // ─── App config ───────────────────────────────────────────────────────────
+  async getAppConfig() {
+    try {
+      const { data, error } = await this._api.GET("/applications/config");
+      if (!data || error) return null;
+      return data.content;
+    } catch {
+      return null;
+    }
+  }
+  // ─── KYC ──────────────────────────────────────────────────────────────────
+  getKycStatus(providerId) {
+    return getKycStatus(this._api, providerId);
+  }
+  getKycProviders(country) {
+    return getKycProviders(this._api, country);
+  }
+  startKyc(body) {
+    return startKyc(this._api, body);
+  }
+  resolveKyc(providerId, level) {
+    return resolveKyc(this._api, providerId, level);
+  }
+  pollKycStatus(providerId, opts) {
+    return pollKycStatus(this._api, providerId, opts);
+  }
+  // ─── Ramps ────────────────────────────────────────────────────────────────
+  getRampsQuote(query) {
+    return getRampsQuote(this._api, query);
+  }
+  createOnRamp(body) {
+    return createOnRamp(this._api, body);
+  }
+  createOffRamp(body) {
+    return createOffRamp(this._api, body);
+  }
+  getRampTransaction(txId) {
+    return getRampTransaction(this._api, txId);
+  }
+  pollRampTransaction(txId, opts) {
+    return pollRampTransaction(this._api, txId, opts);
+  }
+  _setTxHistoryState(next) {
+    this._txHistoryState = next;
+    for (const cb of this._txHistoryStateListeners) cb(next);
+  }
+  _setWalletBalanceState(next) {
+    this._walletBalanceState = next;
+    for (const cb of this._walletBalanceStateListeners) cb(next);
+  }
   // ─── Private ──────────────────────────────────────────────────────────────
   /** Creates a new AbortController, cancelling any existing flow first. */
   _newController() {
@@ -1517,7 +1704,11 @@ var PollarClient = class {
       signal,
       setAuthState: this._setAuthState.bind(this),
       storeSession: this._storeSession.bind(this),
-      clearSession: this._clearSession.bind(this)
+      clearSession: this._clearSession.bind(this),
+      storeWalletAdapter: (adapter, type) => {
+        this._walletAdapter = adapter;
+        writeWalletType(type);
+      }
     };
   }
   _handleFlowError(error) {
@@ -1534,10 +1725,18 @@ var PollarClient = class {
       errorCode: AUTH_ERROR_CODES.UNEXPECTED_ERROR
     });
   }
-  _readStore() {
+  _restoreSession() {
     this._session = readStorage();
     if (this._session) {
       this._authState = { step: "authenticated", session: this._session };
+      if (this._session.data?.providers?.wallet?.address) {
+        const storedType = readWalletType();
+        if (storedType === "freighter" /* FREIGHTER */) {
+          this._walletAdapter = new FreighterAdapter();
+        } else if (storedType === "albedo" /* ALBEDO */) {
+          this._walletAdapter = new AlbedoAdapter();
+        }
+      }
       console.info("[PollarClient] Session restored from storage");
     } else {
       console.info("[PollarClient] No session in storage");
@@ -1552,56 +1751,29 @@ var PollarClient = class {
   _clearSession() {
     console.info("[PollarClient] Session cleared");
     this._session = null;
+    this._walletAdapter = null;
     removeStorage();
-    this._state = { network: [], transaction: [] };
+    this._transactionState = null;
     this._setAuthState({ step: "idle" });
   }
+  _networkPassphrase() {
+    return this.getNetwork() === "mainnet" ? "Public Global Stellar Network ; September 2015" : "Test SDF Network ; September 2015";
+  }
+  _setNetworkState(next) {
+    this._networkState = next;
+    const label = next.step === "connected" ? next.network : next.step;
+    console.info(`[PollarClient] network:${label}`);
+    for (const cb of this._networkStateListeners) cb(next);
+  }
   _setAuthState(next) {
     this._authState = next;
     console.info(`[PollarClient] auth:${next.step}`);
     for (const cb of this._authStateListeners) cb(next);
   }
-  _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: [] };
-    }
+  _setTransactionState(next) {
+    this._transactionState = next;
+    console.info(`[PollarClient] transaction:${next.step}`);
+    for (const cb of this._transactionStateListeners) cb(next);
   }
 };
 
@@ -1609,11 +1781,18 @@ exports.AUTH_ERROR_CODES = AUTH_ERROR_CODES;
 exports.AlbedoAdapter = AlbedoAdapter;
 exports.FreighterAdapter = FreighterAdapter;
 exports.PollarClient = PollarClient;
-exports.PollarStateVar = PollarStateVar;
-exports.STATE_VAR_CODES = STATE_VAR_CODES;
-exports.StateStatus = StateStatus;
 exports.StellarClient = StellarClient;
 exports.WalletType = WalletType;
+exports.createOffRamp = createOffRamp;
+exports.createOnRamp = createOnRamp;
+exports.getKycProviders = getKycProviders;
+exports.getKycStatus = getKycStatus;
+exports.getRampTransaction = getRampTransaction;
+exports.getRampsQuote = getRampsQuote;
 exports.isValidSession = isValidSession;
+exports.pollKycStatus = pollKycStatus;
+exports.pollRampTransaction = pollRampTransaction;
+exports.resolveKyc = resolveKyc;
+exports.startKyc = startKyc;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map