@pollar/core 0.4.5 → 0.5.0

package/dist/index.mjs

@@ -650,31 +650,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" };
+    }
   }
 };
 
@@ -931,8 +998,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 });
@@ -943,9 +1010,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;
@@ -1008,25 +1082,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;
@@ -1226,18 +1285,8 @@ 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;
   try {
     setAuthState({ step: "connecting_wallet", walletType: type });
     const adapter = type === "freighter" /* FREIGHTER */ ? new FreighterAdapter() : new AlbedoAdapter();
@@ -1247,6 +1296,7 @@ async function loginWallet(type, deps) {
       return;
     }
     const { publicKey } = await withSignal(adapter.connect(), signal);
+    deps.storeWalletAdapter(adapter);
     setAuthState({ step: "authenticating_wallet" });
     const { data: walletData, error: walletError } = await api.POST("/auth/wallet", {
       body: { clientSessionId, walletAddress: publicKey },
@@ -1273,19 +1323,6 @@ async function loginWallet(type, deps) {
   await authenticate(clientSessionId, deps);
 }
 
-// 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) {
@@ -1296,46 +1333,48 @@ 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._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;
   }
@@ -1350,17 +1389,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);
     }
@@ -1403,19 +1448,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) {
@@ -1440,24 +1472,70 @@ 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);
   }
-  onStateChange(cb) {
-    this._stateListeners.add(cb);
-    for (const [, stateEntry] of Object.entries(this._state)) {
-      if (stateEntry.length >= 1) cb(stateEntry.at(-1));
+  // ─── 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 ──────────────────────────────────────────────────────────
+  _setTxHistoryState(next) {
+    this._txHistoryState = next;
+    for (const cb of this._txHistoryStateListeners) cb(next);
+  }
+  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" });
     }
-    return () => this._stateListeners.delete(cb);
+  }
+  // ─── Wallet balance ───────────────────────────────────────────────────────
+  async getWalletBalance(publicKey) {
+    const pk = publicKey ?? this._session?.wallet?.publicKey;
+    if (!pk) return null;
+    const network = this.getNetwork();
+    const { data, error } = await this._api.GET("/wallet/balance", { params: { query: { publicKey: pk, network } } });
+    if (!error && data?.success && data.content) return data.content;
+    return null;
   }
   // ─── 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 = {
@@ -1465,42 +1543,104 @@ 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)
+      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 signAndSubmitTx(unsignedXdr) {
+    if (this._transactionState?.step !== "built") {
+      throw new PollarFlowError(
+        `signAndSubmitTx() requires step 'built', current step is '${this._transactionState?.step ?? "none"}'`
       );
-    } catch (error) {
-      this._emitState("transaction", STATE_VAR_CODES.transaction.BUILD_TRANSACTION_ERROR, "error", StateStatus.ERROR, {
-        error
-      });
+    }
+    const buildData = this._transactionState.buildData;
+    this._setTransactionState({ step: "signing", buildData });
+    if (this._walletAdapter) {
+      try {
+        const signOpts = this._session?.wallet?.publicKey ? { networkPassphrase: this._networkPassphrase(), accountToSign: this._session.wallet.publicKey } : { 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", buildData, hash: result.hash });
+        } else {
+          this._setTransactionState({ step: "error", ...buildData && { buildData }, details: result.errorCode });
+        }
+      } catch {
+        this._setTransactionState({ step: "error", ...buildData && { buildData } });
+      }
+      return;
+    }
+    const body = {
+      network: this.getNetwork(),
+      publicKey: this._session?.wallet?.publicKey ?? "",
+      unsignedXdr
+    };
+    try {
+      const { data, error } = await this._api.POST("/tx/sign-and-send", { body });
+      if (!error && data?.success && data.content?.hash) {
+        this._setTransactionState({ step: "success", buildData, hash: data.content.hash });
+      } else {
+        const details = error?.details;
+        this._setTransactionState({ step: "error", ...buildData && { buildData }, ...details && { details } });
+      }
+    } catch {
+      this._setTransactionState({ step: "error", ...buildData && { buildData } });
     }
   }
-  async submitTx(signedXdr) {
-    const body = { network: this.getNetwork(), signedXdr };
+  // ─── App config ───────────────────────────────────────────────────────────
+  async getAppConfig() {
     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.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);
+  }
   // ─── Private ──────────────────────────────────────────────────────────────
   /** Creates a new AbortController, cancelling any existing flow first. */
   _newController() {
@@ -1515,7 +1655,10 @@ 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) => {
+        this._walletAdapter = adapter;
+      }
     };
   }
   _handleFlowError(error) {
@@ -1532,7 +1675,7 @@ var PollarClient = class {
       errorCode: AUTH_ERROR_CODES.UNEXPECTED_ERROR
     });
   }
-  _readStore() {
+  _restoreSession() {
     this._session = readStorage();
     if (this._session) {
       this._authState = { step: "authenticated", session: this._session };
@@ -1550,59 +1693,32 @@ 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);
   }
 };
 
-export { AUTH_ERROR_CODES, AlbedoAdapter, FreighterAdapter, PollarClient, PollarStateVar, STATE_VAR_CODES, StateStatus, StellarClient, WalletType, isValidSession };
+export { AUTH_ERROR_CODES, AlbedoAdapter, FreighterAdapter, PollarClient, StellarClient, WalletType, createOffRamp, createOnRamp, getKycProviders, getKycStatus, getRampTransaction, getRampsQuote, isValidSession, pollKycStatus, pollRampTransaction, resolveKyc, startKyc };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map