@diviswap/sdk 1.7.6

package/dist/index.js

@@ -0,0 +1,2339 @@
+'use strict';
+
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/errors.ts
+var DiviswapError = class _DiviswapError extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "DiviswapError";
+    Object.setPrototypeOf(this, _DiviswapError.prototype);
+  }
+};
+var AuthenticationError = class extends DiviswapError {
+  constructor(message, details) {
+    super(message, "AUTHENTICATION_ERROR", 401, details);
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends DiviswapError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "ValidationError";
+  }
+};
+var NetworkError = class extends DiviswapError {
+  constructor(message, details) {
+    super(message, "NETWORK_ERROR", void 0, details);
+    this.name = "NetworkError";
+  }
+};
+var ConfigurationError = class extends DiviswapError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", void 0, details);
+    this.name = "ConfigurationError";
+  }
+};
+var LiberExError = DiviswapError;
+
+// src/modules/auth.ts
+var AuthModule = class {
+  constructor(client) {
+    this.client = client;
+    this.client.setRefreshCallback(this.refreshToken.bind(this));
+  }
+  /**
+   * Register a new user
+   * 
+   * @example
+   * ```typescript
+   * const { user, accessToken } = await diviswap.auth.register({
+   *   email: 'user@example.com',
+   *   password: 'secure-password',
+   *   firstName: 'John',
+   *   lastName: 'Doe'
+   * });
+   * ```
+   */
+  async register(data) {
+    const requestData = {
+      email: data.email,
+      password: data.password,
+      first_name: data.firstName || "Test",
+      last_name: data.lastName || "User",
+      // Individual object is REQUIRED by the backend
+      individual: {
+        // Use 'USA' (3-letter code) as seen in working lbx-landing implementation
+        residential_country_code: "USA",
+        residential_address_line_one: "123 Main Street",
+        residential_address_line_two: "",
+        residential_city: "Anytown",
+        residential_state: "CA",
+        residential_postal_code: "12345",
+        id_type: "ssn",
+        // Add id_type field as seen in lbx-landing
+        id_country_code: "USA",
+        dob: "1990-01-01",
+        id_number: "123456789"
+        // Remove dashes from SSN like lbx-landing does
+      }
+    };
+    if (data.individual) {
+      requestData.individual = data.individual;
+    }
+    if (data.phone) requestData.phone = data.phone;
+    if (data.referralCode) requestData.referral_code = data.referralCode;
+    const response = await this.client.post(
+      "/api/v1/register",
+      requestData,
+      { useApiKey: true }
+    );
+    const authResponse = {
+      accessToken: response.access_token || response.accessToken,
+      refreshToken: response.refresh_token || response.refreshToken,
+      user: response.user || { id: response.user_id || response.id, email: data.email }
+    };
+    if (authResponse.accessToken) {
+      this.client.setTokens(authResponse.accessToken, authResponse.refreshToken);
+    }
+    return authResponse;
+  }
+  /**
+   * Login an existing user
+   * 
+   * @example
+   * ```typescript
+   * const { user, accessToken } = await diviswap.auth.login({
+   *   email: 'user@example.com',
+   *   password: 'secure-password'
+   * });
+   * ```
+   */
+  async login(credentials) {
+    const response = await this.client.post(
+      "/api/v1/login",
+      credentials,
+      { useApiKey: true }
+      // useApiKey: true means use API key auth, not JWT
+    );
+    const authResponse = {
+      accessToken: response.access_token || response.accessToken,
+      refreshToken: response.refresh_token || response.refreshToken,
+      user: response.user || { id: response.user_id || response.id, email: credentials.email }
+    };
+    if (authResponse.accessToken) {
+      this.client.setTokens(authResponse.accessToken, authResponse.refreshToken);
+    }
+    return authResponse;
+  }
+  /**
+   * Get current user profile
+   * 
+   * @example
+   * ```typescript
+   * const user = await diviswap.auth.getProfile();
+   * console.log(user.email, user.kycStatus);
+   * ```
+   * 
+   * Note: This endpoint is not yet available in the v1 API
+   */
+  async getProfile() {
+    throw new Error("User profile endpoint not available in v1 API yet");
+  }
+  /**
+   * Update user profile
+   * 
+   * @example
+   * ```typescript
+   * const updatedUser = await diviswap.auth.updateProfile({
+   *   firstName: 'Jane',
+   *   lastName: 'Smith'
+   * });
+   * ```
+   * 
+   * Note: This endpoint is not yet available in the v1 API
+   */
+  async updateProfile(_data) {
+    throw new Error("Update profile endpoint not available in v1 API yet");
+  }
+  /**
+   * Request password reset
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.auth.requestPasswordReset('user@example.com');
+   * ```
+   * 
+   * Note: This endpoint is not yet available in the v1 API
+   */
+  async requestPasswordReset(_email) {
+    throw new Error("Password reset endpoint not available in v1 API yet");
+  }
+  /**
+   * Set new password with reset token
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.auth.setPassword('reset-token', 'new-secure-password');
+   * ```
+   * 
+   * Note: This endpoint is not yet available in the v1 API
+   */
+  async setPassword(_token, _password) {
+    throw new Error("Set password endpoint not available in v1 API yet");
+  }
+  /**
+   * Logout current user
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.auth.logout();
+   * ```
+   */
+  async logout() {
+    this.client.clearTokens();
+  }
+  /**
+   * Get compliance status
+   * @deprecated Use diviswap.kyc.getComplianceStatus() instead
+   */
+  async getComplianceStatus() {
+    console.warn("auth.getComplianceStatus() is deprecated. Use kyc.getComplianceStatus() instead.");
+    throw new Error("Compliance status endpoint not available in v1 API yet");
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.client.tokenManager.getAccessToken();
+  }
+  /**
+   * Refresh access token (internal)
+   * 
+   * Note: This endpoint is not yet available in the v1 API
+   */
+  async refreshToken(_refreshToken) {
+    throw new Error("Token refresh endpoint not available in v1 API yet");
+  }
+};
+
+// src/modules/payees.ts
+var PayeesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new payee (bank account)
+   * 
+   * @example
+   * ```typescript
+   * // Bank account
+   * const bankAccount = await diviswap.payees.create({
+   *   nickname: 'My Checking',
+   *   accountNumber: '123456789',
+   *   routingNumber: '021000021',
+   *   accountType: 'checking',
+   *   setAsDefault: true
+   * });
+   * 
+   * // Debit card
+   * const debitCard = await diviswap.payees.create({
+   *   nickname: 'My Debit Card',
+   *   accountType: 'debit_card',
+   *   debitCard: {
+   *     number: '4111111111111111',
+   *     expirationMonth: '12',
+   *     expirationYear: '2025',
+   *     cvv: '123'
+   *   },
+   *   setAsDefault: false
+   * });
+   * ```
+   */
+  async create(data) {
+    try {
+      if (data.accountType === "debit_card") {
+        if (!data.debitCard) {
+          throw new Error("Debit card information is required for debit_card account type");
+        }
+        return await this.client.post("/api/v1/payees", {
+          name: data.nickname,
+          debit_card: {
+            number: data.debitCard.number,
+            expiration_month: data.debitCard.expirationMonth,
+            expiration_year: data.debitCard.expirationYear,
+            cvv: data.debitCard.cvv
+          },
+          set_as_default: data.setAsDefault || false
+        });
+      } else {
+        if (!data.accountNumber || !data.routingNumber) {
+          throw new Error("Account number and routing number are required for bank accounts");
+        }
+        return await this.client.post("/api/v1/payees", {
+          name: data.nickname,
+          account_number: data.accountNumber,
+          routing_number: data.routingNumber,
+          type: (data.accountType || "checking").toUpperCase(),
+          set_as_default: data.setAsDefault || false
+        });
+      }
+    } catch (error) {
+      throw new Error(`Failed to create payee: ${error.message}`);
+    }
+  }
+  /**
+   * List all payees
+   * 
+   * @example
+   * ```typescript
+   * const payees = await diviswap.payees.list();
+   * const defaultPayee = payees.find(p => p.isDefault);
+   * ```
+   */
+  async list() {
+    const response = await this.client.get("/api/v1/users/payees", { useApiKey: false });
+    return this.parsePayeesResponse(response);
+  }
+  parsePayeesResponse(response) {
+    if (Array.isArray(response)) {
+      return response;
+    }
+    if (response && typeof response === "object") {
+      if (response.data && Array.isArray(response.data)) {
+        return response.data;
+      }
+      if (response.payees && Array.isArray(response.payees)) {
+        return response.payees;
+      }
+      if (response.results && Array.isArray(response.results)) {
+        return response.results;
+      }
+    }
+    return [];
+  }
+  /**
+   * Get a specific payee
+   * 
+   * @example
+   * ```typescript
+   * const payee = await diviswap.payees.get('payee-id');
+   * ```
+   */
+  async get(payeeId) {
+    const payees = await this.list();
+    const payee = payees.find((p) => p.id === payeeId);
+    if (!payee) {
+      throw new Error(`Payee ${payeeId} not found`);
+    }
+    return payee;
+  }
+  /**
+   * Set a payee as default
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.payees.setDefault('payee-id');
+   * ```
+   */
+  async setDefault(payeeId) {
+    return this.client.put("/api/v1/users/payees", {
+      payeeId,
+      setAsDefault: true
+    }, { useApiKey: false });
+  }
+  /**
+   * Delete a payee
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.payees.delete('payee-id');
+   * ```
+   */
+  async delete(payeeId) {
+    return this.client.delete(
+      `/api/v1/users/payees/${payeeId}`,
+      { useApiKey: false }
+    );
+  }
+  /**
+   * Get verification status of a payee
+   * 
+   * @example
+   * ```typescript
+   * const status = await diviswap.payees.getVerificationStatus('payee-id');
+   * console.log(status.verified, status.microDepositsStatus);
+   * ```
+   */
+  async getVerificationStatus(_payeeId) {
+    throw new Error("Payee verification status endpoint not available in v1 API yet");
+  }
+  /**
+   * Verify a payee with micro-deposit amounts
+   * 
+   * @example
+   * ```typescript
+   * const result = await diviswap.payees.verify('payee-id', {
+   *   amount1: 0.32,
+   *   amount2: 0.45
+   * });
+   * ```
+   */
+  async verify(_payeeId, _data) {
+    throw new Error("Payee verification endpoint not available in v1 API yet");
+  }
+  /**
+   * Get the default payee
+   * 
+   * @example
+   * ```typescript
+   * const defaultPayee = await diviswap.payees.getDefault();
+   * if (!defaultPayee) {
+   *   console.log('No default payee set');
+   * }
+   * ```
+   */
+  async getDefault() {
+    const payees = await this.list();
+    return payees.find((p) => p.isDefault) || null;
+  }
+};
+
+// src/constants/addresses.ts
+var PRODUCTION_DEPOSIT_ADDRESSES = {
+  ethereum: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  base: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  polygon: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  solana: "EokHeEoZpGtBNeuJKRPvtxzXqaXz6bM5zsVB5TVPtNee"
+};
+var SANDBOX_DEPOSIT_ADDRESSES = {
+  ethereum: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  // Same address for all environments
+  base: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  polygon: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  solana: "EokHeEoZpGtBNeuJKRPvtxzXqaXz6bM5zsVB5TVPtNee"
+};
+var DEVELOPMENT_DEPOSIT_ADDRESSES = {
+  ethereum: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  // Same unified address
+  base: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  polygon: "0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651",
+  solana: "EokHeEoZpGtBNeuJKRPvtxzXqaXz6bM5zsVB5TVPtNee"
+};
+function getDepositAddresses(environment) {
+  switch (environment) {
+    case "production":
+      return PRODUCTION_DEPOSIT_ADDRESSES;
+    case "sandbox":
+      return SANDBOX_DEPOSIT_ADDRESSES;
+    case "development":
+      return DEVELOPMENT_DEPOSIT_ADDRESSES;
+    default:
+      return SANDBOX_DEPOSIT_ADDRESSES;
+  }
+}
+var CHAIN_ID_TO_NAME = {
+  1: "ethereum",
+  5: "goerli",
+  11155111: "sepolia",
+  137: "polygon",
+  80001: "mumbai",
+  8453: "base",
+  84531: "base-goerli",
+  84532: "base-sepolia"
+};
+var CHAIN_NAME_TO_ID = {
+  "ethereum": 1,
+  "eth": 1,
+  "goerli": 5,
+  "sepolia": 11155111,
+  "polygon": 137,
+  "matic": 137,
+  "mumbai": 80001,
+  "base": 8453,
+  "base-goerli": 84531,
+  "base-sepolia": 84532,
+  "solana": 999999,
+  // Solana mainnet (custom ID for database compatibility)
+  "sol": 999999
+};
+var STABLECOIN_ADDRESSES = {
+  ethereum: {
+    USDT: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    USDC: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    DAI: "0x6b175474e89094c44da98b954eedeac495271d0f"
+  },
+  base: {
+    USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    USDbC: "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca"
+    // Bridged USDC
+  },
+  polygon: {
+    USDT: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+    USDC: "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
+    DAI: "0x8f3cf7ad23cd3cadbd9735aff958023239c6a063"
+  },
+  solana: {
+    USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    // USDC SPL token
+    USDT: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    // USDT SPL token
+    SOL: "So11111111111111111111111111111111111111112"
+    // Wrapped SOL
+  }
+};
+
+// src/modules/transactions.ts
+var TransactionsModule = class {
+  constructor(client, environment = "sandbox") {
+    this.client = client;
+    this.depositAddresses = getDepositAddresses(environment);
+  }
+  /**
+   * Map chain name to chain ID
+   * @private
+   */
+  getChainId(chain) {
+    const chainId = CHAIN_NAME_TO_ID[chain.toLowerCase()];
+    return chainId ? chainId.toString() : chain;
+  }
+  /**
+   * Get deposit address for a given chain
+   * @private
+   */
+  getDepositAddress(chain) {
+    const normalizedChain = chain.toLowerCase();
+    const chainName = normalizedChain === "eth" ? "ethereum" : normalizedChain === "matic" ? "polygon" : normalizedChain;
+    const address = this.depositAddresses[chainName];
+    if (!address || address === "0x..." || address.includes("TODO")) {
+      throw new Error(`Deposit address not configured for chain: ${chain}. Please contact support.`);
+    }
+    return address;
+  }
+  /**
+   * Get all configured deposit addresses
+   * @returns Object mapping chain names to deposit addresses
+   */
+  getDepositAddresses() {
+    return { ...this.depositAddresses };
+  }
+  /**
+   * Get deposit address for a specific chain
+   * @param chain - Chain name (e.g., 'ethereum', 'base', 'polygon')
+   * @returns The deposit address for the specified chain
+   * @throws Error if chain is not supported
+   */
+  getDepositAddressForChain(chain) {
+    return this.getDepositAddress(chain);
+  }
+  /**
+   * Create an onramp transaction (fiat to crypto)
+   * 
+   * @example
+   * ```typescript
+   * const transaction = await diviswap.transactions.onramp({
+   *   amount: 100,
+   *   currency: 'USD',
+   *   payeeId: 'payee-id',
+   *   toAddress: '0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651',
+   *   chain: 'ethereum'
+   * });
+   * ```
+   * 
+   * @throws {Error} If user is not KYC approved
+   */
+  async onramp(_data) {
+    throw new Error("Onramp endpoint not available in v1 API yet");
+  }
+  /**
+   * Create an offramp transaction (crypto to fiat)
+   *
+   * ⚠️ IMPORTANT: Follow the production pattern:
+   * 1. Send crypto transaction on blockchain FIRST
+   * 2. Get the transaction hash
+   * 3. Call this method with the hash
+   *
+   * @example
+   * ```typescript
+   * import { extractTransactionHash } from '@diviswap/sdk';
+   *
+   * // 1. Send crypto transaction first and get tx hash
+   * const txResult = await sendTransactionAsync({
+   *   to: depositAddress,
+   *   value: parseEther('0.5')
+   * });
+   *
+   * // 2. Extract hash (handles different wallet return types)
+   * const txHash = extractTransactionHash(txResult);
+   *
+   * // 3. Record the transaction
+   * const transaction = await diviswap.transactions.offramp({
+   *   amount: 0.5,
+   *   currency: 'ETH',
+   *   fromAddress: '0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651',
+   *   payeeId: 'payee-id',
+   *   chain: 'ethereum',
+   *   txHash: txHash
+   * });
+   * ```
+   *
+   * @throws {Error} If user is not KYC approved
+   */
+  async offramp(data) {
+    if (!data.txHash || data.txHash.trim() === "") {
+      throw new Error(
+        "txHash is required for offramp transactions."
+      );
+    }
+    const payload = {
+      payee_id: data.payeeId,
+      tx_hash: data.txHash,
+      // Required: must send crypto first
+      from_address: data.fromAddress,
+      to_address: data.toAddress || this.getDepositAddress(data.chain || "ethereum"),
+      amount: data.amount,
+      currency: data.currency,
+      chain_id: this.getChainId(data.chain || "ethereum")
+    };
+    if (data.memo) {
+      payload.memo = data.memo;
+    }
+    return this.client.post(
+      `/api/v1/transactions/offramp`,
+      payload,
+      { useApiKey: false }
+    );
+  }
+  /**
+   * Create a test offramp transaction using the same production flow.
+   * Requires a transaction hash - send crypto first, then call this method.
+   *
+   * ⚠️ IMPORTANT: Follow the production pattern:
+   * 1. Send crypto transaction on blockchain FIRST
+   * 2. Get the transaction hash
+   * 3. Call this method with the hash
+   *
+   * @example
+   * ```typescript
+   * // 1. Send crypto transaction first and get tx hash
+   * const txHash = await sendCryptoTransaction({...});
+   *
+   * // 2. Record the transaction using production endpoint
+   * const transaction = await diviswap.transactions.offrampTest({
+   *   amount: 0.1,
+   *   currency: 'USDC',
+   *   fromAddress: '0x...',
+   *   toAddress: '0x...',
+   *   payeeId: 'payee-id',
+   *   chain: 'base',
+   *   txHash: txHash
+   * });
+   * ```
+   */
+  async offrampTest(data) {
+    if (!data.txHash || data.txHash.trim() === "") {
+      throw new Error(
+        "txHash is required for offramp transactions."
+      );
+    }
+    const payload = {
+      payee_id: data.payeeId,
+      tx_hash: data.txHash,
+      from_address: data.fromAddress,
+      to_address: data.toAddress || this.getDepositAddress(data.chain || "ethereum"),
+      amount: data.amount,
+      currency: data.currency,
+      chain_id: this.getChainId(data.chain || "ethereum")
+    };
+    if (data.memo) {
+      payload.memo = data.memo;
+    }
+    return this.client.post(
+      `/api/v1/transactions/offramp`,
+      payload,
+      { useApiKey: false }
+    );
+  }
+  /**
+   * List transactions with optional filters
+   * 
+   * @example
+   * ```typescript
+   * // Get all transactions
+   * const allTransactions = await diviswap.transactions.list();
+   * 
+   * // Get only completed onramp transactions
+   * const completedOnramps = await diviswap.transactions.list({
+   *   type: 'onramp',
+   *   status: 'completed'
+   * });
+   * ```
+   */
+  async list(filters) {
+    const params = new URLSearchParams();
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          params.append(key, value.toString());
+        }
+      });
+    }
+    const queryString = params.toString();
+    const path = `/api/v1/users/transactions${queryString ? `?${queryString}` : ""}`;
+    const response = await this.client.get(path, { useApiKey: false });
+    if (Array.isArray(response)) {
+      return response;
+    }
+    if (response && typeof response === "object") {
+      if (response.data && Array.isArray(response.data)) {
+        return response.data;
+      }
+      if (response.transactions && Array.isArray(response.transactions)) {
+        return response.transactions;
+      }
+      if (response.results && Array.isArray(response.results)) {
+        return response.results;
+      }
+    }
+    return [];
+  }
+  /**
+   * Get a specific transaction by ID
+   * 
+   * @example
+   * ```typescript
+   * const transaction = await diviswap.transactions.get('transaction-id');
+   * console.log(transaction.status, transaction.amount);
+   * ```
+   */
+  async get(transactionId) {
+    const transactions = await this.list();
+    const transaction = transactions.find((t) => t.id === transactionId);
+    if (!transaction) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+    return transaction;
+  }
+  /**
+   * Get fee estimate for a transaction
+   * 
+   * @example
+   * ```typescript
+   * const estimate = await diviswap.transactions.estimateFees({
+   *   amount: 100,
+   *   currency: 'USD',
+   *   type: 'onramp'
+   * });
+   * console.log(`Fee: $${estimate.fee}, Total: $${estimate.total}`);
+   * ```
+   */
+  async estimateFees(params) {
+    return this.client.post("/api/v1/fees", params);
+  }
+  /**
+   * Get recent transactions (convenience method)
+   * 
+   * @example
+   * ```typescript
+   * const recentTransactions = await diviswap.transactions.getRecent(10);
+   * ```
+   */
+  async getRecent(limit = 10) {
+    return this.list({ limit });
+  }
+  /**
+   * Get transaction statistics
+   * 
+   * @example
+   * ```typescript
+   * const stats = await diviswap.transactions.getStats();
+   * console.log(`Total volume: $${stats.totalVolume}`);
+   * ```
+   */
+  async getStats() {
+    const transactions = await this.list();
+    const stats = transactions.reduce((acc, tx) => {
+      acc.totalTransactions++;
+      acc.totalVolume += tx.amount || 0;
+      if (tx.status === "pending" || tx.status === "processing") {
+        acc.pendingTransactions++;
+      } else if (tx.status === "completed") {
+        acc.completedTransactions++;
+      }
+      return acc;
+    }, {
+      totalTransactions: 0,
+      totalVolume: 0,
+      pendingTransactions: 0,
+      completedTransactions: 0
+    });
+    return stats;
+  }
+  /**
+   * Get stablecoin addresses for a specific chain
+   * @param chain - Chain name (e.g., 'ethereum', 'base', 'polygon')
+   * @returns Object mapping stablecoin symbols to contract addresses
+   */
+  getStablecoinAddresses(chain) {
+    const normalizedChain = chain.toLowerCase();
+    const chainName = normalizedChain === "eth" ? "ethereum" : normalizedChain === "matic" ? "polygon" : normalizedChain;
+    return STABLECOIN_ADDRESSES[chainName] || {};
+  }
+};
+
+// src/modules/kyc.ts
+var KycModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get current compliance status including KYC and KYB
+   * 
+   * @example
+   * ```typescript
+   * const status = await diviswap.kyc.getComplianceStatus();
+   * 
+   * if (!status.canTransact) {
+   *   if (status.nextStep === 'COMPLETE_KYC') {
+   *     // Redirect to KYC flow
+   *   }
+   * }
+   * ```
+   */
+  async getComplianceStatus() {
+    try {
+      const profile = await this.client.get("/api/v1/users/profile");
+      const kycData = profile.kyc;
+      const kycStatus = kycData?.status || (profile.is_verified ? "APPROVED" : "PENDING");
+      const canTransact = kycData?.onramp_verified || profile.onramp_verified || false;
+      const isVerified = kycData?.is_verified || profile.is_verified || false;
+      return {
+        kycStatus: kycStatus.toUpperCase(),
+        kybStatus: "NOT_REQUIRED",
+        canTransact,
+        requiresAction: !canTransact,
+        verificationLevel: canTransact ? "full" : isVerified ? "basic" : "none",
+        nextStep: !canTransact ? "COMPLETE_KYC" : void 0,
+        kycMetadata: kycData?.metadata
+      };
+    } catch (error) {
+      throw new Error(`Failed to get compliance status: ${error.message}`);
+    }
+  }
+  /**
+   * Start KYC verification session (opens Sumsub widget)
+   * 
+   * @example
+   * ```typescript
+   * const session = await diviswap.kyc.startKycSession();
+   * 
+   * // Redirect user to session URL
+   * window.location.href = session.sessionUrl;
+   * 
+   * // Or embed in iframe
+   * const iframe = document.createElement('iframe');
+   * iframe.src = session.sessionUrl;
+   * ```
+   */
+  async startKycSession() {
+    throw new Error("KYC session endpoint not available in v1 API yet");
+  }
+  /**
+   * Submit KYC documents programmatically
+   * 
+   * @example
+   * ```typescript
+   * // Convert file to base64
+   * const toBase64 = (file: File) => new Promise<string>((resolve, reject) => {
+   *   const reader = new FileReader();
+   *   reader.readAsDataURL(file);
+   *   reader.onload = () => resolve(reader.result as string);
+   *   reader.onerror = reject;
+   * });
+   * 
+   * const frontImage = await toBase64(frontFile);
+   * const backImage = await toBase64(backFile);
+   * 
+   * await diviswap.kyc.submitDocuments({
+   *   type: 'DRIVERS_LICENSE',
+   *   frontImage,
+   *   backImage
+   * });
+   * ```
+   */
+  async submitDocuments(documents) {
+    if (!documents.frontImage) {
+      throw new ValidationError("Front image is required");
+    }
+    if (["DRIVERS_LICENSE", "ID_CARD"].includes(documents.type) && !documents.backImage) {
+      throw new ValidationError(`Back image is required for ${documents.type}`);
+    }
+    throw new Error("KYC documents endpoint not available in v1 API yet");
+  }
+  /**
+   * Submit personal information for KYC
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.kyc.submitPersonalInfo({
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   dateOfBirth: '1990-01-01',
+   *   ssn: '123-45-6789',
+   *   address: {
+   *     street: '123 Main St',
+   *     city: 'New York',
+   *     state: 'NY',
+   *     postalCode: '10001',
+   *     country: 'US'
+   *   }
+   * });
+   * ```
+   */
+  async submitPersonalInfo(info) {
+    const requiredFields = ["firstName", "lastName", "dateOfBirth"];
+    for (const field of requiredFields) {
+      if (!info[field]) {
+        throw new ValidationError(`${field} is required`);
+      }
+    }
+    if (!info.address || !info.address.street || !info.address.city || !info.address.state || !info.address.postalCode || !info.address.country) {
+      throw new ValidationError("Complete address is required");
+    }
+    try {
+      const response = await this.client.post("/api/v1/kyc/personal-info", {
+        first_name: info.firstName,
+        last_name: info.lastName,
+        dob: info.dateOfBirth,
+        country: info.address.country,
+        ...info.phone && { phone: info.phone },
+        ...info.address.street && { address: info.address.street },
+        ...info.address.city && { city: info.address.city },
+        ...info.address.state && { state: info.address.state },
+        ...info.address.postalCode && { postal_code: info.address.postalCode },
+        ...info.ssn && { ssn: info.ssn }
+      });
+      return response;
+    } catch (error) {
+      throw new Error(`Failed to submit KYC info: ${error.message}`);
+    }
+  }
+  /**
+   * Check if user can transact (convenience method)
+   * 
+   * @example
+   * ```typescript
+   * const canTransact = await diviswap.kyc.canTransact();
+   * if (!canTransact) {
+   *   // Show KYC prompt
+   * }
+   * ```
+   */
+  async canTransact() {
+    const status = await this.getComplianceStatus();
+    return status.canTransact;
+  }
+  /**
+   * Check if KYC is approved
+   * 
+   * @example
+   * ```typescript
+   * const isApproved = await diviswap.kyc.isKycApproved();
+   * ```
+   */
+  async isKycApproved() {
+    const status = await this.getComplianceStatus();
+    return status.kycStatus === "APPROVED";
+  }
+  /**
+   * Check if KYB is approved (for business accounts)
+   * 
+   * @example
+   * ```typescript
+   * const isBusinessApproved = await diviswap.kyc.isKybApproved();
+   * ```
+   */
+  async isKybApproved() {
+    const status = await this.getComplianceStatus();
+    return status.kybStatus === "APPROVED";
+  }
+  /**
+   * Get rejection reasons if KYC/KYB was rejected
+   * 
+   * @example
+   * ```typescript
+   * const reasons = await diviswap.kyc.getRejectionReasons();
+   * if (reasons.length > 0) {
+   *   console.log('Rejected because:', reasons.join(', '));
+   * }
+   * ```
+   */
+  async getRejectionReasons() {
+    const status = await this.getComplianceStatus();
+    const reasons = [];
+    if (status.kycStatus === "REJECTED" && status.kycMetadata?.rejectLabels) {
+      reasons.push(...status.kycMetadata.rejectLabels);
+    }
+    return reasons;
+  }
+  /**
+   * Wait for KYC approval (polling)
+   * 
+   * @example
+   * ```typescript
+   * // Start KYC session
+   * const session = await diviswap.kyc.startKycSession();
+   * window.open(session.sessionUrl);
+   * 
+   * // Wait for approval (polls every 5 seconds for up to 10 minutes)
+   * try {
+   *   await diviswap.kyc.waitForApproval();
+   *   console.log('KYC approved!');
+   * } catch (error) {
+   *   console.log('KYC not approved:', error.message);
+   * }
+   * ```
+   */
+  async waitForApproval(options) {
+    const pollInterval = options?.pollInterval || 5e3;
+    const maxAttempts = options?.maxAttempts || 120;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      const status = await this.getComplianceStatus();
+      if (status.kycStatus === "APPROVED") {
+        return status;
+      }
+      if (status.kycStatus === "REJECTED") {
+        throw new Error(`KYC rejected: ${status.kycMetadata?.rejectLabels?.join(", ") || "Unknown reason"}`);
+      }
+      attempts++;
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("KYC approval timeout");
+  }
+};
+
+// src/modules/fees.ts
+var FeesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Set integrator fee percentage
+   *
+   * @example
+   * ```typescript
+   * // Set global integrator fee to 0.75% (applies to all your users)
+   * await diviswap.fees.setFee({ percentage: 0.75 });
+   *
+   * // Set fee for specific user (overrides global)
+   * await diviswap.fees.setFee({
+   *   percentage: 1.0,
+   *   userId: 123
+   * });
+   * ```
+   */
+  async setFee(data) {
+    if (data.userId) {
+      await this.client.put(`/api/v1/partner/users/${data.userId}/fee`, {
+        percentage: data.percentage
+      });
+      return {
+        integratorFeePercentage: data.percentage,
+        baseFeePercentage: 1.5,
+        totalFeePercentage: 1.5 + data.percentage,
+        userId: data.userId.toString()
+      };
+    }
+    const response = await this.client.put("/api/v1/partner/fee", {
+      percentage: data.percentage
+    });
+    return {
+      integratorFeePercentage: response.integrator_fee_percentage,
+      baseFeePercentage: response.base_fee_percentage,
+      totalFeePercentage: response.total_fee_percentage
+    };
+  }
+  /**
+   * Get current fee settings
+   *
+   * @example
+   * ```typescript
+   * // Get global fee settings (your default)
+   * const fees = await diviswap.fees.getFees();
+   * console.log(`Total fee: ${fees.totalFeePercentage}%`);
+   * ```
+   */
+  async getFees() {
+    const response = await this.client.get("/api/v1/partner/fee");
+    return {
+      integratorFeePercentage: response.integrator_fee_percentage,
+      baseFeePercentage: response.base_fee_percentage,
+      totalFeePercentage: response.total_fee_percentage
+    };
+  }
+  /**
+   * Calculate fees for a transaction amount
+   *
+   * @example
+   * ```typescript
+   * const calc = await diviswap.fees.calculateFees({
+   *   amount: 100,
+   *   userId: 123 // Optional: checks for user-specific override
+   * });
+   *
+   * console.log(`Base fee: $${calc.baseFee}`);
+   * console.log(`Your fee: $${calc.integratorFee}`);
+   * console.log(`Total fee: $${calc.totalFee}`);
+   * console.log(`User receives: $${calc.netAmount}`);
+   * ```
+   */
+  async calculateFees(params) {
+    const response = await this.client.post("/api/v1/partner/fees/calculate", {
+      amount: params.amount,
+      user_id: params.userId
+    });
+    return {
+      amount: response.amount,
+      baseFee: response.base_fee,
+      integratorFee: response.integrator_fee,
+      totalFee: response.total_fee,
+      netAmount: response.net_amount
+    };
+  }
+  /**
+   * Remove custom fee for a user (reverts to partner default)
+   *
+   * @example
+   * ```typescript
+   * // Remove VIP user's custom fee, they'll use your default fee again
+   * await diviswap.fees.removeFee(123);
+   * ```
+   */
+  async removeFee(userId) {
+    await this.client.delete(`/api/v1/partner/users/${userId}/fee`);
+  }
+};
+
+// src/types/addresses.ts
+var CHAIN_IDS = {
+  // Mainnets
+  ethereum: 1,
+  optimism: 10,
+  base: 8453,
+  polygon: 137,
+  arbitrum: 42161,
+  // Testnets
+  sepolia: 11155111,
+  optimism_sepolia: 11155420,
+  base_sepolia: 84532,
+  polygon_mumbai: 80001,
+  arbitrum_sepolia: 421614
+};
+
+// src/modules/addresses.ts
+var AddressesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get all addresses for the authenticated user
+   * 
+   * @example
+   * ```typescript
+   * const addresses = await diviswap.addresses.list();
+   * console.log('User addresses:', addresses);
+   * ```
+   */
+  async list() {
+    const response = await this.client.get("/api/v1/addresses");
+    return Array.isArray(response) ? response : [];
+  }
+  /**
+   * Create a new crypto address for the user
+   * 
+   * @example
+   * ```typescript
+   * const address = await diviswap.addresses.create({
+   *   chain_id: 1, // Ethereum mainnet
+   *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05',
+   *   is_default: true
+   * });
+   * ```
+   */
+  async create(data) {
+    const response = await this.client.post("/api/v1/addresses", data);
+    const addresses = await this.list();
+    const newAddress = addresses.find((addr) => addr.id === response.id);
+    if (!newAddress) {
+      throw new Error("Failed to retrieve created address");
+    }
+    return newAddress;
+  }
+  /**
+   * Set a specific address as the default for its chain
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.addresses.setDefault({
+   *   chain_id: 1,
+   *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05'
+   * });
+   * ```
+   */
+  async setDefault(data) {
+    await this.client.put("/api/v1/addresses/default", data);
+  }
+  /**
+   * Delete a crypto address
+   * 
+   * @example
+   * ```typescript
+   * await diviswap.addresses.delete({
+   *   chain_id: 1,
+   *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05'
+   * });
+   * ```
+   */
+  async delete(data) {
+    await this.client.delete("/api/v1/addresses", { body: data });
+  }
+  /**
+   * Get addresses for a specific chain
+   * 
+   * @example
+   * ```typescript
+   * const ethAddresses = await diviswap.addresses.getByChain(1);
+   * const baseAddresses = await diviswap.addresses.getByChain('base');
+   * ```
+   */
+  async getByChain(chainIdOrName) {
+    const chainId = typeof chainIdOrName === "string" ? CHAIN_IDS[chainIdOrName] : chainIdOrName;
+    const addresses = await this.list();
+    return addresses.filter((addr) => addr.chain_id === chainId);
+  }
+  /**
+   * Get the default address for a specific chain
+   * 
+   * @example
+   * ```typescript
+   * const defaultEthAddress = await diviswap.addresses.getDefault(1);
+   * const defaultBaseAddress = await diviswap.addresses.getDefault('base');
+   * ```
+   */
+  async getDefault(chainIdOrName) {
+    const chainId = typeof chainIdOrName === "string" ? CHAIN_IDS[chainIdOrName] : chainIdOrName;
+    const addresses = await this.list();
+    return addresses.find((addr) => addr.chain_id === chainId && addr.is_default) || null;
+  }
+  /**
+   * Check if an address exists for the user
+   * 
+   * @example
+   * ```typescript
+   * const exists = await diviswap.addresses.exists({
+   *   chain_id: 1,
+   *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05'
+   * });
+   * ```
+   */
+  async exists(data) {
+    const addresses = await this.list();
+    return addresses.some(
+      (addr) => addr.chain_id === data.chain_id && addr.address.toLowerCase() === data.address.toLowerCase()
+    );
+  }
+  /**
+   * Automatically track a wallet connection
+   * This is the main method for automatic address tracking
+   * 
+   * @example
+   * ```typescript
+   * // When user connects wallet
+   * const connection = await diviswap.addresses.trackWallet({
+   *   address: account,
+   *   chainId: chainId,
+   *   chainName: 'ethereum' // optional
+   * });
+   * ```
+   */
+  async trackWallet(connection) {
+    const existsAlready = await this.exists({
+      chain_id: connection.chainId,
+      address: connection.address
+    });
+    if (existsAlready) {
+      const addresses = await this.list();
+      const existingAddress = addresses.find(
+        (addr) => addr.chain_id === connection.chainId && addr.address.toLowerCase() === connection.address.toLowerCase()
+      );
+      if (!existingAddress) {
+        throw new Error("Address exists but could not be retrieved");
+      }
+      return existingAddress;
+    }
+    const existingOnChain = await this.getByChain(connection.chainId);
+    const isDefault = existingOnChain.length === 0;
+    return await this.create({
+      chain_id: connection.chainId,
+      address: connection.address,
+      is_default: isDefault
+    });
+  }
+  /**
+   * Auto-track multiple wallet connections (useful for multi-chain wallets)
+   * 
+   * @example
+   * ```typescript
+   * // When user connects a multi-chain wallet
+   * const addresses = await diviswap.addresses.trackMultipleWallets([
+   *   { address: account, chainId: 1 },      // Ethereum
+   *   { address: account, chainId: 8453 },   // Base
+   *   { address: account, chainId: 10 }      // Optimism
+   * ]);
+   * ```
+   */
+  async trackMultipleWallets(connections) {
+    const results = [];
+    for (const connection of connections) {
+      try {
+        const address = await this.trackWallet(connection);
+        results.push(address);
+      } catch (error) {
+        console.error(`Failed to track wallet for chain ${connection.chainId}:`, error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Helper to get chain name from chain ID
+   */
+  getChainName(chainId) {
+    return Object.entries(CHAIN_IDS).find(([_, id]) => id === chainId)?.[0];
+  }
+  /**
+   * Helper to get chain ID from chain name
+   */
+  getChainId(chainName) {
+    return CHAIN_IDS[chainName];
+  }
+  /**
+   * Get all supported chains
+   */
+  getSupportedChains() {
+    return { ...CHAIN_IDS };
+  }
+};
+
+// src/modules/webhooks.ts
+var WebhooksModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Set webhook URL and secret for your partner account
+   *
+   * @example
+   * ```typescript
+   * await diviswap.webhooks.setConfig({
+   *   webhook_url: 'https://myapp.com/api/webhooks/diviswap',
+   *   webhook_secret: 'whsec_...' // Optional, auto-generated if not provided
+   * });
+   * ```
+   */
+  async setConfig(data) {
+    const response = await this.client.put("/api/v1/partner/webhook", {
+      webhook_url: data.webhook_url,
+      webhook_secret: data.webhook_secret
+    });
+    return response;
+  }
+  /**
+   * Set webhook for a specific partner (user-owned partner)
+   *
+   * @example
+   * ```typescript
+   * await diviswap.webhooks.setConfigForPartner(4, {
+   *   webhook_url: 'https://myapp.com/webhooks'
+   * });
+   * ```
+   */
+  async setConfigForPartner(partnerId, data) {
+    const response = await this.client.put(`/api/v1/partners/${partnerId}/webhook`, {
+      webhook_url: data.webhook_url,
+      webhook_secret: data.webhook_secret
+    });
+    return response;
+  }
+  /**
+   * Get current webhook configuration
+   *
+   * @example
+   * ```typescript
+   * const config = await diviswap.webhooks.getConfig();
+   * console.log(`Webhook enabled: ${config.enabled}`);
+   * console.log(`URL: ${config.webhook_url}`);
+   * ```
+   */
+  async getConfig() {
+    const response = await this.client.get("/api/v1/partner/webhook");
+    return response;
+  }
+  /**
+   * Get webhook config for a specific partner (user-owned)
+   */
+  async getConfigForPartner(partnerId) {
+    const response = await this.client.get(`/api/v1/partners/${partnerId}/webhook`);
+    return response;
+  }
+  /**
+   * List webhook delivery events
+   *
+   * @example
+   * ```typescript
+   * const events = await diviswap.webhooks.listEvents({
+   *   limit: 100,
+   *   status: 'failed'
+   * });
+   *
+   * events.forEach(event => {
+   *   console.log(`${event.event_type}: ${event.status}`);
+   * });
+   * ```
+   */
+  async listEvents(options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.append("limit", options.limit.toString());
+    if (options?.status) params.append("status", options.status);
+    const path = options?.partnerId ? `/api/v1/partners/${options.partnerId}/webhook/events?${params}` : `/api/v1/partner/webhook/events?${params}`;
+    const response = await this.client.get(path);
+    return response;
+  }
+  /**
+   * Send a test webhook to verify your endpoint is working
+   *
+   * @example
+   * ```typescript
+   * const result = await diviswap.webhooks.test();
+   * if (result.success) {
+   *   console.log('Webhook endpoint is working!');
+   * }
+   * ```
+   */
+  async test(partnerId) {
+    const path = partnerId ? `/api/v1/partners/${partnerId}/webhook/test` : "/api/v1/partner/webhook/test";
+    return await this.client.post(path);
+  }
+  /**
+   * Verify a webhook signature (static helper for your webhook endpoint)
+   *
+   * @example
+   * ```typescript
+   * import crypto from 'crypto';
+   *
+   * const isValid = WebhooksModule.verifySignature(
+   *   rawBody,
+   *   request.headers['x-signature'],
+   *   process.env.WEBHOOK_SECRET
+   * );
+   * ```
+   */
+  static verifySignature(payload, signature, secret) {
+    const crypto2 = __require("crypto");
+    const expectedSignature = crypto2.createHmac("sha256", secret).update(payload).digest("hex");
+    return crypto2.timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature)
+    );
+  }
+};
+
+// src/api/token-manager.ts
+var MemoryTokenStorage = class {
+  constructor() {
+    this.data = null;
+  }
+  get() {
+    return this.data;
+  }
+  set(data) {
+    this.data = data;
+  }
+  clear() {
+    this.data = null;
+  }
+};
+var LocalStorageTokenStorage = class {
+  constructor() {
+    this.key = "liberex_tokens";
+  }
+  get() {
+    if (typeof globalThis.window === "undefined") return null;
+    const data = globalThis.localStorage.getItem(this.key);
+    if (!data) return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  set(data) {
+    if (typeof globalThis.window === "undefined") return;
+    globalThis.localStorage.setItem(this.key, JSON.stringify(data));
+  }
+  clear() {
+    if (typeof globalThis.window === "undefined") return;
+    globalThis.localStorage.removeItem(this.key);
+  }
+};
+var TokenManager = class {
+  constructor(useLocalStorage = false) {
+    this.refreshPromise = null;
+    this.storage = useLocalStorage && typeof globalThis.window !== "undefined" ? new LocalStorageTokenStorage() : new MemoryTokenStorage();
+  }
+  /**
+   * Parse JWT token to extract expiration
+   */
+  parseToken(token) {
+    try {
+      const payload = token.split(".")[1];
+      const decoded = atob(payload.replace(/-/g, "+").replace(/_/g, "/"));
+      return JSON.parse(decoded);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Store tokens
+   */
+  setTokens(accessToken, refreshToken) {
+    const parsed = this.parseToken(accessToken);
+    const expiresAt = parsed.exp ? parsed.exp * 1e3 : void 0;
+    this.storage.set({
+      accessToken,
+      refreshToken,
+      expiresAt
+    });
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    const data = this.storage.get();
+    return data?.accessToken || null;
+  }
+  /**
+   * Get refresh token
+   */
+  getRefreshToken() {
+    const data = this.storage.get();
+    return data?.refreshToken || null;
+  }
+  /**
+   * Check if token is expired or about to expire (5 min buffer)
+   */
+  isTokenExpired() {
+    const data = this.storage.get();
+    if (!data?.expiresAt) return true;
+    const bufferTime = 5 * 60 * 1e3;
+    return Date.now() >= data.expiresAt - bufferTime;
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this.storage.clear();
+    this.refreshPromise = null;
+  }
+  /**
+   * Refresh access token
+   */
+  async refreshAccessToken(refreshCallback) {
+    if (this.refreshPromise) {
+      const result = await this.refreshPromise;
+      return result.accessToken;
+    }
+    const refreshToken = this.getRefreshToken();
+    if (!refreshToken) {
+      throw new Error("No refresh token available");
+    }
+    this.refreshPromise = refreshCallback(refreshToken);
+    try {
+      const newTokenData = await this.refreshPromise;
+      this.setTokens(newTokenData.accessToken, newTokenData.refreshToken || refreshToken);
+      return newTokenData.accessToken;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  /**
+   * Get valid access token (refresh if needed)
+   */
+  async getValidAccessToken(refreshCallback) {
+    const token = this.getAccessToken();
+    if (!token) return null;
+    if (this.isTokenExpired() && refreshCallback) {
+      try {
+        return await this.refreshAccessToken(refreshCallback);
+      } catch {
+        this.clearTokens();
+        return null;
+      }
+    }
+    return token;
+  }
+};
+var PartnerAuth = class {
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  /**
+   * Generate HMAC authentication headers for a request
+   */
+  generateHMACHeaders(method, path, queryString = "", body = "") {
+    const timestamp = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+    const nonce = this.generateNonce();
+    const bodyHash = crypto__default.default.createHash("sha256").update(body).digest("hex");
+    const canonical = [
+      method,
+      path,
+      queryString,
+      bodyHash,
+      timestamp,
+      nonce
+    ].join("\n");
+    const signature = crypto__default.default.createHmac("sha256", this.credentials.secretKey).update(canonical).digest("base64");
+    const headers = {
+      "Authorization": `HMAC ${this.credentials.keyId}:${signature}:${timestamp}:${nonce}`,
+      "X-Client-Id": this.credentials.keyId
+    };
+    if (this.credentials.customerId) {
+      headers["X-Customer-Id"] = this.credentials.customerId;
+    }
+    if (this.credentials.customerEmail) {
+      headers["X-Customer-Email"] = this.credentials.customerEmail;
+    }
+    return headers;
+  }
+  /**
+   * Generate a unique nonce for replay protection
+   */
+  generateNonce() {
+    return crypto__default.default.randomBytes(32).toString("base64url");
+  }
+  /**
+   * Generate a JWT token for partner authentication
+   */
+  generateJWT(options = {}) {
+    const {
+      audience = "api.diviswap.io",
+      expiresIn = 300,
+      // 5 minutes max
+      scopes = []
+    } = options;
+    const now = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iss: this.credentials.keyId,
+      // Issuer: partner key ID
+      aud: audience,
+      // Audience: API domain
+      exp: now + Math.min(expiresIn, 300),
+      // Expiration (max 5 minutes)
+      iat: now,
+      // Issued at
+      ...this.credentials.customerId && { sub: this.credentials.customerId },
+      ...this.credentials.customerEmail && { email: this.credentials.customerEmail },
+      ...scopes.length > 0 && { scope: scopes }
+    };
+    const header = { alg: "HS256", typ: "JWT" };
+    const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+    const signature = crypto__default.default.createHmac("sha256", this.credentials.secretKey).update(`${encodedHeader}.${encodedPayload}`).digest("base64url");
+    return `${encodedHeader}.${encodedPayload}.${signature}`;
+  }
+  /**
+   * Set customer context for shadow user linking
+   */
+  setCustomer(customerId, customerEmail) {
+    this.credentials.customerId = customerId;
+    this.credentials.customerEmail = customerEmail;
+  }
+  /**
+   * Clear customer context
+   */
+  clearCustomer() {
+    delete this.credentials.customerId;
+    delete this.credentials.customerEmail;
+  }
+};
+
+// src/api/unified-client.ts
+var UnifiedApiClient = class _UnifiedApiClient {
+  constructor(config, useLocalStorage = true) {
+    this.config = config;
+    this.tokenManager = new TokenManager(useLocalStorage);
+    if (config.mode === "partner" && config.keyId && config.secretKey) {
+      this.partnerAuth = new PartnerAuth({
+        keyId: config.keyId,
+        secretKey: config.secretKey,
+        customerId: config.customerId,
+        customerEmail: config.customerEmail
+      });
+    }
+  }
+  /**
+   * Create client from legacy user config (backward compatibility)
+   */
+  static fromUserConfig(config, useLocalStorage = true) {
+    const baseUrl = config.apiUrl || this.getDefaultApiUrl(config.environment || "production");
+    return new _UnifiedApiClient({
+      baseUrl,
+      timeout: config.timeout || 3e4,
+      debug: config.debug || false,
+      mode: "user",
+      apiKey: config.apiKey,
+      clientId: config.clientId
+    }, useLocalStorage);
+  }
+  /**
+   * Create client from partner config
+   */
+  static fromPartnerConfig(config, useLocalStorage = true) {
+    const baseUrl = config.apiUrl || this.getDefaultApiUrl(config.environment || "production");
+    return new _UnifiedApiClient({
+      baseUrl,
+      timeout: config.timeout || 3e4,
+      debug: config.debug || false,
+      mode: "partner",
+      keyId: config.keyId,
+      secretKey: config.secretKey,
+      authMethod: config.authMethod || "hmac",
+      customerId: config.customerId,
+      customerEmail: config.customerEmail
+    }, useLocalStorage);
+  }
+  /**
+   * Create client from any config (auto-detect mode)
+   */
+  static fromConfig(config, useLocalStorage = true) {
+    if ("mode" in config && config.mode === "partner" || "keyId" in config && "secretKey" in config) {
+      return this.fromPartnerConfig(config, useLocalStorage);
+    } else {
+      return this.fromUserConfig(config, useLocalStorage);
+    }
+  }
+  static getDefaultApiUrl(environment) {
+    switch (environment) {
+      case "production":
+        return "https://api.diviswap.io";
+      case "sandbox":
+        return "https://dev-api.diviswap.io";
+      default:
+        return "https://dev-api.diviswap.io";
+    }
+  }
+  /**
+   * Update customer context for partner auth
+   */
+  setCustomer(customerId, customerEmail) {
+    if (this.partnerAuth) {
+      this.partnerAuth.setCustomer(customerId, customerEmail);
+    }
+    this.config.customerId = customerId;
+    this.config.customerEmail = customerEmail;
+  }
+  /**
+   * Clear customer context
+   */
+  clearCustomer() {
+    if (this.partnerAuth) {
+      this.partnerAuth.clearCustomer();
+    }
+    delete this.config.customerId;
+    delete this.config.customerEmail;
+  }
+  /**
+   * Get authentication mode
+   */
+  getAuthMode() {
+    return this.config.mode || "user";
+  }
+  /**
+   * Get current customer ID (partner mode only)
+   */
+  getCustomerId() {
+    return this.config.customerId;
+  }
+  /**
+   * Set refresh callback for automatic token refresh (user mode only)
+   */
+  setRefreshCallback(callback) {
+    this.refreshCallback = callback;
+  }
+  /**
+   * Set access token directly (user mode only)
+   */
+  setTokens(accessToken, refreshToken) {
+    this.tokenManager.setTokens(accessToken, refreshToken);
+  }
+  /**
+   * Get current access token (user mode only)
+   */
+  async getAccessToken() {
+    if (this.config.mode === "partner") {
+      return null;
+    }
+    return this.tokenManager.getValidAccessToken(this.refreshCallback);
+  }
+  /**
+   * Clear stored tokens (user mode only)
+   */
+  clearTokens() {
+    this.tokenManager.clearTokens();
+  }
+  /**
+   * Make authenticated API request
+   */
+  async request(options) {
+    const { method, path, body, headers = {}, useApiKey = false, skipAuth = false } = options;
+    const url = `${this.config.baseUrl}${path}`;
+    const requestHeaders = {
+      "Content-Type": "application/json",
+      "User-Agent": "Diviswap-SDK/2.0",
+      ...headers
+    };
+    if (!skipAuth) {
+      if (this.config.mode === "partner") {
+        await this.addPartnerAuth(method, path, body, requestHeaders);
+      } else {
+        await this.addUserAuth(useApiKey, requestHeaders);
+      }
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const responseText = await response.text();
+      let responseData;
+      try {
+        responseData = responseText ? JSON.parse(responseText) : null;
+      } catch {
+        responseData = responseText;
+      }
+      if (!response.ok) {
+        await this.handleErrorResponse(response, responseData);
+      }
+      return responseData;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Request timeout");
+      }
+      if (error instanceof DiviswapError) {
+        throw error;
+      }
+      throw new NetworkError(`Network request failed: ${error}`);
+    }
+  }
+  /**
+   * Add partner authentication headers
+   */
+  async addPartnerAuth(method, path, body, headers) {
+    if (!this.partnerAuth) {
+      throw new AuthenticationError("Partner authentication not configured");
+    }
+    const bodyString = body ? JSON.stringify(body) : "";
+    const urlParts = path.split("?");
+    const pathOnly = urlParts[0];
+    const queryString = urlParts.length > 1 ? urlParts[1] : "";
+    if (this.config.authMethod === "jwt") {
+      const jwt = this.partnerAuth.generateJWT({
+        audience: "api.diviswap.io",
+        expiresIn: 300
+      });
+      headers["Authorization"] = `Bearer ${jwt}`;
+    } else {
+      const hmacHeaders = this.partnerAuth.generateHMACHeaders(
+        method,
+        pathOnly,
+        queryString,
+        bodyString
+      );
+      Object.assign(headers, hmacHeaders);
+    }
+  }
+  /**
+   * Add user authentication headers (legacy)
+   */
+  async addUserAuth(useApiKey, headers) {
+    if (!this.config.apiKey || !this.config.clientId) {
+      throw new AuthenticationError("User authentication not configured");
+    }
+    headers["X-CLIENT-ID"] = this.config.clientId;
+    headers["X-TIMESTAMP"] = Math.floor(Date.now() / 1e3).toString();
+    headers["X-API-Key"] = this.config.apiKey;
+    if (!useApiKey) {
+      const accessToken = await this.tokenManager.getValidAccessToken(this.refreshCallback);
+      if (accessToken) {
+        headers["Authorization"] = `Bearer ${accessToken}`;
+      }
+    }
+  }
+  async handleErrorResponse(response, data) {
+    const status = response.status;
+    const message = data?.error || data?.message || `HTTP ${status}`;
+    if (status === 403 && data?.kyc_uri) {
+      const error = new AuthenticationError(message);
+      error.kycUri = data.kyc_uri;
+      error.requiredLevel = data.required_level;
+      throw error;
+    }
+    switch (status) {
+      case 400:
+        throw new ValidationError(message);
+      case 401:
+      case 403:
+        throw new AuthenticationError(message);
+      case 404:
+        throw new DiviswapError(`Resource not found: ${message}`);
+      case 429:
+        throw new DiviswapError(`Rate limit exceeded: ${message}`);
+      case 500:
+      case 502:
+      case 503:
+      case 504:
+        throw new NetworkError(`Server error: ${message}`);
+      default:
+        throw new DiviswapError(`API error: ${message}`);
+    }
+  }
+  // Convenience methods
+  async get(path, options = {}) {
+    return this.request({ method: "GET", path, ...options });
+  }
+  async post(path, body, options = {}) {
+    return this.request({ method: "POST", path, body, ...options });
+  }
+  async put(path, body, options = {}) {
+    return this.request({ method: "PUT", path, body, ...options });
+  }
+  async delete(path, options = {}) {
+    return this.request({ method: "DELETE", path, ...options });
+  }
+};
+
+// src/client.ts
+var _Diviswap = class _Diviswap {
+  constructor(config) {
+    this.config = config;
+    this.validateConfig(config);
+    const useLocalStorage = config.tokenStorage === "localStorage" || !config.tokenStorage;
+    this.apiClient = UnifiedApiClient.fromConfig(config, useLocalStorage);
+    this.auth = new AuthModule(this.apiClient);
+    this.payees = new PayeesModule(this.apiClient);
+    this.transactions = new TransactionsModule(this.apiClient, config.environment || "sandbox");
+    this.kyc = new KycModule(this.apiClient);
+    this.fees = new FeesModule(this.apiClient);
+    this.addresses = new AddressesModule(this.apiClient);
+    this.webhooks = new WebhooksModule(this.apiClient);
+  }
+  /**
+   * Initialize the Diviswap SDK
+   *
+   * @param config - SDK configuration
+   * @returns Diviswap SDK instance
+   *
+   * @example
+   * ```typescript
+   * const diviswap = Diviswap.init({
+   *   apiKey: 'your-api-key',
+   *   clientId: 'your-client-id'
+   * });
+   * ```
+   */
+  static init(config) {
+    if (!_Diviswap.instance) {
+      _Diviswap.instance = new _Diviswap(config);
+    }
+    return _Diviswap.instance;
+  }
+  /**
+   * Get the current SDK instance
+   * @throws {ConfigurationError} If SDK hasn't been initialized
+   */
+  static getInstance() {
+    if (!_Diviswap.instance) {
+      throw new ConfigurationError("Diviswap SDK not initialized. Call Diviswap.init() first.");
+    }
+    return _Diviswap.instance;
+  }
+  /**
+   * Reset the SDK instance (useful for testing)
+   */
+  static reset() {
+    _Diviswap.instance = null;
+  }
+  /**
+   * Update SDK configuration
+   * @deprecated Configuration updates require re-initialization. Call Diviswap.reset() then Diviswap.init() with new config.
+   */
+  updateConfig(_config) {
+    throw new ConfigurationError("Configuration updates require re-initialization. Call Diviswap.reset() then Diviswap.init() with new config.");
+  }
+  /**
+   * Get current configuration (excluding sensitive data)
+   */
+  getConfig() {
+    return {
+      environment: this.config.environment,
+      apiUrl: this.config.apiUrl,
+      debug: this.config.debug,
+      timeout: this.config.timeout
+    };
+  }
+  /**
+   * Get current access token (for developers who need it for custom API calls)
+   * Only available in user authentication mode.
+   *
+   * @example
+   * ```typescript
+   * const token = await diviswap.getAccessToken();
+   * if (token) {
+   *   // Use token for custom API calls
+   *   fetch('https://api.diviswap.io/custom-endpoint', {
+   *     headers: { 'Authorization': `Bearer ${token}` }
+   *   });
+   * }
+   * ```
+   */
+  async getAccessToken() {
+    return this.apiClient.getAccessToken();
+  }
+  /**
+   * Set access token (for server-side usage where tokens are stored externally)
+   * Only available in user authentication mode.
+   *
+   * @example
+   * ```typescript
+   * // In a Next.js API route where token is stored in cookies
+   * const token = cookies().get('diviswap_session')?.value;
+   * if (token) {
+   *   diviswap.setAccessToken(token);
+   * }
+   * ```
+   */
+  setAccessToken(accessToken, refreshToken) {
+    this.apiClient.setTokens(accessToken, refreshToken);
+  }
+  /**
+   * Set customer context for partner authentication mode
+   *
+   * @example
+   * ```typescript
+   * // For partner auth mode - link requests to a specific customer
+   * diviswap.setCustomer('user-123', 'user@example.com');
+   *
+   * // Now all API calls will be made on behalf of this customer
+   * const payees = await diviswap.payees.getAll();
+   * ```
+   */
+  setCustomer(customerId, customerEmail) {
+    this.apiClient.setCustomer(customerId, customerEmail);
+  }
+  /**
+   * Clear customer context for partner authentication mode
+   */
+  clearCustomer() {
+    this.apiClient.clearCustomer();
+  }
+  validateConfig(config) {
+    const isPartnerMode = "mode" in config && config.mode === "partner" || "keyId" in config && "secretKey" in config;
+    if (isPartnerMode) {
+      const partnerConfig = config;
+      if (!partnerConfig.keyId) {
+        throw new ConfigurationError("Partner keyId is required for partner authentication");
+      }
+      if (!partnerConfig.secretKey) {
+        throw new ConfigurationError("Partner secretKey is required for partner authentication");
+      }
+      if (partnerConfig.authMethod && !["hmac", "jwt"].includes(partnerConfig.authMethod)) {
+        throw new ConfigurationError('Invalid authMethod. Must be either "hmac" or "jwt"');
+      }
+    } else {
+      const userConfig = config;
+      if (!userConfig.apiKey) {
+        throw new ConfigurationError("API Key is required for user authentication");
+      }
+      if (!userConfig.clientId) {
+        throw new ConfigurationError("Client ID is required for user authentication");
+      }
+    }
+    if (config.environment && !["production", "sandbox", "development"].includes(config.environment)) {
+      throw new ConfigurationError("Invalid environment. Must be one of: production, sandbox, development");
+    }
+  }
+};
+_Diviswap.instance = null;
+var Diviswap = _Diviswap;
+
+// src/integrations/wallet.ts
+var _WalletTracker = class _WalletTracker {
+  constructor(config = {}) {
+    this.wallet = null;
+    this.diviswap = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.config = {
+      trackAccountChanges: true,
+      trackChainChanges: true,
+      setAsDefault: true,
+      ...config
+    };
+  }
+  /**
+   * Get or create the wallet tracker instance
+   */
+  static getInstance(config) {
+    if (!_WalletTracker.instance) {
+      _WalletTracker.instance = new _WalletTracker(config);
+    }
+    return _WalletTracker.instance;
+  }
+  /**
+   * Initialize wallet tracking with Diviswap SDK instance
+   */
+  init(diviswap, wallet) {
+    this.diviswap = diviswap;
+    if (wallet) {
+      this.wallet = wallet;
+    } else if (typeof window !== "undefined" && window.ethereum) {
+      this.wallet = window.ethereum;
+    }
+    if (this.wallet && this.config.trackAccountChanges) {
+      this.setupAccountChangeListener();
+    }
+    if (this.wallet && this.config.trackChainChanges) {
+      this.setupChainChangeListener();
+    }
+  }
+  /**
+   * Connect and track a wallet
+   */
+  async connect() {
+    if (!this.wallet) {
+      throw new Error("No wallet provider available");
+    }
+    if (!this.diviswap) {
+      throw new Error("Diviswap SDK not initialized. Call init() first.");
+    }
+    try {
+      const accounts = await this.wallet.request({
+        method: "eth_requestAccounts"
+      });
+      const chainId = await this.wallet.request({
+        method: "eth_chainId"
+      });
+      const numericChainId = parseInt(chainId, 16);
+      const connections = [];
+      for (const account of accounts) {
+        const connection = {
+          address: account,
+          chainId: numericChainId,
+          chainName: this.getChainName(numericChainId)
+        };
+        await this.diviswap.addresses.trackWallet(connection);
+        connections.push(connection);
+      }
+      return connections;
+    } catch (error) {
+      console.error("Failed to connect wallet:", error);
+      throw error;
+    }
+  }
+  /**
+   * Track current wallet state without requesting connection
+   */
+  async trackCurrent() {
+    if (!this.wallet) {
+      throw new Error("No wallet provider available");
+    }
+    if (!this.diviswap) {
+      throw new Error("Diviswap SDK not initialized. Call init() first.");
+    }
+    try {
+      const accounts = await this.wallet.request({
+        method: "eth_accounts"
+      });
+      if (accounts.length === 0) {
+        return [];
+      }
+      const chainId = await this.wallet.request({
+        method: "eth_chainId"
+      });
+      const numericChainId = parseInt(chainId, 16);
+      const connections = [];
+      for (const account of accounts) {
+        const connection = {
+          address: account,
+          chainId: numericChainId,
+          chainName: this.getChainName(numericChainId)
+        };
+        await this.diviswap.addresses.trackWallet(connection);
+        connections.push(connection);
+      }
+      return connections;
+    } catch (error) {
+      console.error("Failed to track current wallet state:", error);
+      throw error;
+    }
+  }
+  /**
+   * Setup listener for account changes
+   */
+  setupAccountChangeListener() {
+    if (!this.wallet?.on) return;
+    const handler = async (accounts) => {
+      if (!this.diviswap) return;
+      try {
+        const chainId = await this.wallet.request({
+          method: "eth_chainId"
+        });
+        const numericChainId = parseInt(chainId, 16);
+        for (const account of accounts) {
+          const connection = {
+            address: account,
+            chainId: numericChainId,
+            chainName: this.getChainName(numericChainId)
+          };
+          await this.diviswap.addresses.trackWallet(connection);
+        }
+      } catch (error) {
+        console.error("Failed to handle account change:", error);
+      }
+    };
+    this.wallet.on("accountsChanged", handler);
+    this.listeners.set("accountsChanged", handler);
+  }
+  /**
+   * Setup listener for chain changes
+   */
+  setupChainChangeListener() {
+    if (!this.wallet?.on) return;
+    const handler = async (chainId) => {
+      if (!this.diviswap) return;
+      try {
+        const accounts = await this.wallet.request({
+          method: "eth_accounts"
+        });
+        const numericChainId = parseInt(chainId, 16);
+        for (const account of accounts) {
+          const connection = {
+            address: account,
+            chainId: numericChainId,
+            chainName: this.getChainName(numericChainId)
+          };
+          await this.diviswap.addresses.trackWallet(connection);
+        }
+      } catch (error) {
+        console.error("Failed to handle chain change:", error);
+      }
+    };
+    this.wallet.on("chainChanged", handler);
+    this.listeners.set("chainChanged", handler);
+  }
+  /**
+   * Get chain name from chain ID
+   */
+  getChainName(chainId) {
+    const builtInChain = Object.entries(CHAIN_IDS).find(([_, id]) => id === chainId)?.[0];
+    if (builtInChain) return builtInChain;
+    return this.config.customChains?.[chainId];
+  }
+  /**
+   * Cleanup listeners
+   */
+  cleanup() {
+    if (this.wallet?.removeListener) {
+      for (const [event, handler] of this.listeners) {
+        this.wallet.removeListener(event, handler);
+      }
+    }
+    this.listeners.clear();
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+_WalletTracker.instance = null;
+var WalletTracker = _WalletTracker;
+async function connectWallet(diviswap, wallet, config) {
+  const tracker = WalletTracker.getInstance(config);
+  tracker.init(diviswap, wallet);
+  return tracker.connect();
+}
+async function trackCurrentWallet(diviswap, wallet, config) {
+  const tracker = WalletTracker.getInstance(config);
+  tracker.init(diviswap, wallet);
+  return tracker.trackCurrent();
+}
+function setupWalletTracking(diviswap, wallet, config) {
+  const tracker = WalletTracker.getInstance(config);
+  tracker.init(diviswap, wallet);
+  return tracker;
+}
+
+// src/utils/web3.ts
+function extractTransactionHash(result) {
+  if (typeof result === "string") {
+    return result;
+  }
+  if (typeof result === "object" && result !== null && "hash" in result) {
+    return result.hash;
+  }
+  return result;
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.CHAIN_IDS = CHAIN_IDS;
+exports.CHAIN_ID_TO_NAME = CHAIN_ID_TO_NAME;
+exports.CHAIN_NAME_TO_ID = CHAIN_NAME_TO_ID;
+exports.ConfigurationError = ConfigurationError;
+exports.DEVELOPMENT_DEPOSIT_ADDRESSES = DEVELOPMENT_DEPOSIT_ADDRESSES;
+exports.Diviswap = Diviswap;
+exports.DiviswapError = DiviswapError;
+exports.LiberEx = Diviswap;
+exports.LiberExError = LiberExError;
+exports.NetworkError = NetworkError;
+exports.PRODUCTION_DEPOSIT_ADDRESSES = PRODUCTION_DEPOSIT_ADDRESSES;
+exports.SANDBOX_DEPOSIT_ADDRESSES = SANDBOX_DEPOSIT_ADDRESSES;
+exports.STABLECOIN_ADDRESSES = STABLECOIN_ADDRESSES;
+exports.ValidationError = ValidationError;
+exports.WalletTracker = WalletTracker;
+exports.connectWallet = connectWallet;
+exports.extractTransactionHash = extractTransactionHash;
+exports.getDepositAddresses = getDepositAddresses;
+exports.setupWalletTracking = setupWalletTracking;
+exports.trackCurrentWallet = trackCurrentWallet;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map