neutron-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,824 @@
+// src/client.ts
+import crypto from "crypto";
+
+// src/errors.ts
+var NeutronError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NeutronError";
+  }
+};
+var NeutronApiError = class extends NeutronError {
+  /** HTTP status code */
+  status;
+  /** Neutron error code (e.g. "2005") */
+  code;
+  /** Raw error body from the API */
+  body;
+  constructor(status, body) {
+    const message = body?.error || body?.message || `API error ${status}`;
+    super(message);
+    this.name = "NeutronApiError";
+    this.status = status;
+    this.code = body?.code;
+    this.body = body;
+  }
+  /** True if this is a rate limit error (429) */
+  get isRateLimited() {
+    return this.status === 429;
+  }
+  /** True if this is an auth error (401/403) */
+  get isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  /** True if retrying might help (5xx, 429) */
+  get isRetryable() {
+    return this.status === 429 || this.status >= 500;
+  }
+};
+var NeutronAuthError = class extends NeutronError {
+  constructor(message = "Authentication failed. Check your API key and secret.") {
+    super(message);
+    this.name = "NeutronAuthError";
+  }
+};
+var NeutronTimeoutError = class extends NeutronError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "NeutronTimeoutError";
+  }
+};
+var NeutronValidationError = class extends NeutronError {
+  constructor(message) {
+    super(message);
+    this.name = "NeutronValidationError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://enapi.npay.live";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var TOKEN_REFRESH_BUFFER_MS = 6e4;
+var HttpClient = class {
+  apiKey;
+  apiSecret;
+  baseUrl;
+  timeout;
+  maxRetries;
+  debug;
+  accessToken = null;
+  accountId = null;
+  tokenExpiry = 0;
+  constructor(config) {
+    if (!config.apiKey) throw new NeutronAuthError("apiKey is required");
+    if (!config.apiSecret) throw new NeutronAuthError("apiSecret is required");
+    this.apiKey = config.apiKey;
+    this.apiSecret = config.apiSecret;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.debug = config.debug ?? false;
+  }
+  log(message, data) {
+    if (!this.debug) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const extra = data ? ` ${JSON.stringify(data)}` : "";
+    console.error(`[neutron-sdk ${ts}] ${message}${extra}`);
+  }
+  // ── Auth ──────────────────────────────────────────────
+  generateSignature(payload) {
+    const stringToSign = `${this.apiKey}&payload=${payload}`;
+    return crypto.createHmac("sha256", this.apiSecret).update(stringToSign).digest("hex");
+  }
+  get isTokenValid() {
+    return !!(this.accessToken && this.accountId && Date.now() < this.tokenExpiry - TOKEN_REFRESH_BUFFER_MS);
+  }
+  async authenticate() {
+    const payload = JSON.stringify({ test: "auth" });
+    const signature = this.generateSignature(payload);
+    const response = await this.rawFetch(
+      `${this.baseUrl}/api/v2/authentication/token-signature`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Api-Key": this.apiKey,
+          "X-Api-Signature": signature
+        },
+        body: payload
+      }
+    );
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      throw new NeutronAuthError(
+        body.error || body.message || `Authentication failed (${response.status})`
+      );
+    }
+    const raw = await response.json();
+    const result = raw.data ?? raw;
+    this.accountId = result.accountId;
+    this.accessToken = result.accessToken;
+    this.tokenExpiry = typeof result.expiredAt === "number" ? result.expiredAt : new Date(result.expiredAt).getTime();
+    return result;
+    this.log("Authenticated", { accountId: this.accountId });
+  }
+  async ensureAuth() {
+    if (!this.isTokenValid) {
+      await this.authenticate();
+    }
+  }
+  getAccountId() {
+    if (!this.accountId) {
+      throw new NeutronAuthError("Not authenticated. Call a method first or use neutron.account.get().");
+    }
+    return this.accountId;
+  }
+  async ensureAuthAndGetAccountId() {
+    await this.ensureAuth();
+    return this.accountId;
+  }
+  // ── HTTP ──────────────────────────────────────────────
+  async rawFetch(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        throw new NeutronTimeoutError(this.timeout);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async request(method, path, body) {
+    await this.ensureAuth();
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, Math.pow(2, attempt - 1) * 1e3));
+        if (!this.isTokenValid) await this.authenticate();
+      }
+      const url = `${this.baseUrl}${path}`;
+      this.log(`${method} ${path}`);
+      const headers = {
+        Authorization: `Bearer ${this.accessToken}`
+      };
+      if (body) headers["Content-Type"] = "application/json";
+      const response = await this.rawFetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (response.ok) {
+        return await response.json();
+      }
+      const errorBody = await response.json().catch(() => ({}));
+      const apiError = new NeutronApiError(response.status, errorBody);
+      if (response.status === 401 && attempt < this.maxRetries) {
+        this.accessToken = null;
+        lastError = apiError;
+        continue;
+      }
+      if (apiError.isRetryable && attempt < this.maxRetries) {
+        lastError = apiError;
+        continue;
+      }
+      throw apiError;
+    }
+    throw lastError;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async del(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/sanitize.ts
+function sanitizePathParam(value, name) {
+  if (!value || typeof value !== "string") {
+    throw new NeutronValidationError(`${name} is required and must be a non-empty string.`);
+  }
+  const sanitized = value.replace(/[^a-zA-Z0-9\-_.]/g, "");
+  if (sanitized !== value) {
+    throw new NeutronValidationError(
+      `${name} contains invalid characters. Only alphanumeric, hyphens, underscores, and dots are allowed.`
+    );
+  }
+  if (sanitized.includes("..")) {
+    throw new NeutronValidationError(`${name} cannot contain path traversal sequences.`);
+  }
+  return sanitized;
+}
+
+// src/resources/account.ts
+var AccountResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get account info: display name, status, country, timezone.
+   */
+  async get() {
+    const accountId = await this.client.ensureAuthAndGetAccountId();
+    const res = await this.client.get(`/api/v2/account/${accountId}`);
+    return res.data ?? res;
+  }
+  /**
+   * List all wallets with balances (BTC, USDT, fiat).
+   */
+  async wallets() {
+    const accountId = await this.client.ensureAuthAndGetAccountId();
+    const res = await this.client.get(`/api/v2/account/${accountId}/wallet/`);
+    return res.data ?? res;
+  }
+  /**
+   * Get a specific wallet by ID.
+   */
+  async wallet(walletId) {
+    sanitizePathParam(walletId, "walletId");
+    const accountId = await this.client.ensureAuthAndGetAccountId();
+    const res = await this.client.get(`/api/v2/account/${accountId}/wallet/${walletId}`);
+    return res.data ?? res;
+  }
+  /**
+   * Get your Bitcoin on-chain deposit address (static, reusable).
+   */
+  async btcAddress() {
+    const raw = await this.client.get(`/api/v2/account/onchain-address`);
+    const data = raw?.data ?? raw;
+    return { address: data.staticOnchainAddress };
+  }
+  /**
+   * Get your USDT deposit address.
+   * @param chain "TRON" (default, recommended) or "ETH"
+   */
+  async usdtAddress(chain = "TRON") {
+    const raw = await this.client.get(
+      `/api/v2/account/stablecoin-onchain-address?walletCcy=USDT&chainId=${chain}`
+    );
+    const data = raw?.data ?? raw;
+    return {
+      address: data.staticStablecoinOnchainAddress || data.staticOnchainAddress,
+      chain
+    };
+  }
+};
+
+// src/resources/transactions.ts
+var TransactionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a transaction (returns a quote). Call `.confirm()` to execute.
+   *
+   * @example
+   * // Lightning receive (create invoice)
+   * const txn = await neutron.transactions.create({
+   *   sourceReq: { ccy: "BTC", method: "lightning", reqDetails: {} },
+   *   destReq: { ccy: "BTC", method: "neutronpay", amtRequested: 0.0001, reqDetails: {} },
+   * });
+   *
+   * @example
+   * // Lightning send (pay invoice)
+   * const txn = await neutron.transactions.create({
+   *   sourceReq: { ccy: "BTC", method: "neutronpay" },
+   *   destReq: { ccy: "BTC", method: "lightning", reqDetails: { paymentRequest: "lnbc..." } },
+   * });
+   *
+   * @example
+   * // Internal swap (BTC → USDT)
+   * const txn = await neutron.transactions.create({
+   *   sourceReq: { ccy: "BTC", method: "neutronpay", amtRequested: 0.001, reqDetails: {} },
+   *   destReq: { ccy: "USDT", method: "neutronpay", reqDetails: {} },
+   * });
+   */
+  async create(params) {
+    return this.client.post(`/api/v2/transaction`, params);
+  }
+  /**
+   * Confirm a quoted transaction to execute it.
+   * After confirmation, Lightning invoices become payable and sends are dispatched.
+   */
+  async confirm(txnId) {
+    sanitizePathParam(txnId, "txnId");
+    return this.client.put(`/api/v2/transaction/${txnId}/confirm`);
+  }
+  /**
+   * Get transaction status and details.
+   */
+  async get(txnId) {
+    sanitizePathParam(txnId, "txnId");
+    return this.client.get(`/api/v2/transaction/${txnId}`);
+  }
+  /**
+   * List transactions with optional filters.
+   *
+   * @example
+   * const completed = await neutron.transactions.list({ status: "completed", limit: 10 });
+   */
+  async list(params) {
+    const qs = new URLSearchParams();
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== void 0 && v !== null) qs.append(k, String(v));
+      }
+    }
+    const query = qs.toString();
+    const res = await this.client.get(`/api/v2/transaction${query ? `?${query}` : ""}`);
+    return res.data ?? res;
+  }
+  /**
+   * Cancel a quoted (unconfirmed) transaction.
+   */
+  async cancel(txnId) {
+    sanitizePathParam(txnId, "txnId");
+    return this.client.put(`/api/v2/transaction/${txnId}/cancel`);
+  }
+  /**
+   * Wait for a transaction to reach a final state. Polls at the given interval.
+   *
+   * @param txnId Transaction ID
+   * @param options.intervalMs Polling interval in ms (default: 3000)
+   * @param options.timeoutMs Max wait time in ms (default: 300000 = 5 min)
+   * @param options.onStateChange Callback fired on each state change
+   * @returns The transaction in a final state
+   *
+   * @example
+   * const txn = await neutron.transactions.waitForCompletion(txnId, {
+   *   onStateChange: (state) => console.log("State:", state),
+   * });
+   */
+  async waitForCompletion(txnId, options) {
+    const FINAL_STATES = ["completed", "failed", "expired", "rejected", "error", "usercanceled"];
+    const interval = options?.intervalMs ?? 3e3;
+    const timeout = options?.timeoutMs ?? 3e5;
+    const start = Date.now();
+    let lastState = "";
+    while (Date.now() - start < timeout) {
+      const txn = await this.get(txnId);
+      if (txn.txnState !== lastState) {
+        lastState = txn.txnState;
+        options?.onStateChange?.(txn.txnState, txn);
+      }
+      if (FINAL_STATES.includes(txn.txnState)) {
+        return txn;
+      }
+      await new Promise((r) => setTimeout(r, interval));
+    }
+    throw new Error(`Transaction ${txnId} did not complete within ${timeout}ms`);
+  }
+};
+
+// src/resources/lightning.ts
+var LightningResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a Lightning invoice to receive Bitcoin. Auto-confirms — ready to pay immediately.
+   *
+   * @example
+   * const invoice = await neutron.lightning.createInvoice({ amountSats: 10000 });
+   * console.log(invoice.invoice);   // "lnbc100u1p..."
+   * console.log(invoice.qrPageUrl); // hosted QR code page
+   *
+   * @example
+   * const invoice = await neutron.lightning.createInvoice({
+   *   amountBtc: 0.001,
+   *   memo: "Order #1234",
+   *   extRefId: "order-1234",
+   * });
+   */
+  async createInvoice(params) {
+    let btcAmount;
+    if (params.amountSats !== void 0 && params.amountBtc !== void 0) {
+      throw new NeutronValidationError("Provide either amountSats or amountBtc, not both.");
+    }
+    if (params.amountSats !== void 0) {
+      if (params.amountSats <= 0) throw new NeutronValidationError("amountSats must be positive.");
+      btcAmount = params.amountSats / 1e8;
+    } else if (params.amountBtc !== void 0) {
+      if (params.amountBtc <= 0) throw new NeutronValidationError("amountBtc must be positive.");
+      btcAmount = params.amountBtc;
+    } else {
+      throw new NeutronValidationError("Provide either amountSats or amountBtc.");
+    }
+    const txn = await this.client.post(`/api/v2/transaction`, {
+      extRefId: params.extRefId,
+      sourceReq: { ccy: "BTC", method: "lightning", reqDetails: {} },
+      destReq: {
+        ccy: "BTC",
+        method: "neutronpay",
+        amtRequested: btcAmount,
+        reqDetails: {}
+      }
+    });
+    const confirmed = await this.client.put(
+      `/api/v2/transaction/${txn.txnId}/confirm`
+    );
+    return {
+      txnId: confirmed.txnId,
+      invoice: confirmed.sourceReq?.reqDetails?.paymentRequest ?? "",
+      qrPageUrl: confirmed.sourceReq?.reqDetails?.invoicePageUrl,
+      amountBtc: btcAmount,
+      amountSats: Math.round(btcAmount * 1e8),
+      status: confirmed.txnState
+    };
+  }
+  /**
+   * Pay a Lightning invoice (BOLT11).
+   * Returns a quoted transaction — call `neutron.transactions.confirm()` to send.
+   *
+   * @example
+   * const txn = await neutron.lightning.payInvoice("lnbc100u1p...");
+   * // Review fees: txn.sourceReq.neutronpayFees
+   * await neutron.transactions.confirm(txn.txnId);
+   */
+  async payInvoice(invoice, extRefId) {
+    return this.client.post(`/api/v2/transaction`, {
+      extRefId,
+      sourceReq: { ccy: "BTC", method: "neutronpay" },
+      destReq: {
+        ccy: "BTC",
+        method: "lightning",
+        reqDetails: { paymentRequest: invoice }
+      }
+    });
+  }
+  /**
+   * Send to a Lightning Address (user@domain.com).
+   * Returns a quoted transaction — call `neutron.transactions.confirm()` to send.
+   *
+   * @example
+   * const txn = await neutron.lightning.payAddress("alice@getalby.com", { amountSats: 5000 });
+   * await neutron.transactions.confirm(txn.txnId);
+   */
+  async payAddress(address, params) {
+    let btcAmount;
+    if (params.amountSats !== void 0) {
+      btcAmount = params.amountSats / 1e8;
+    } else if (params.amountBtc !== void 0) {
+      btcAmount = params.amountBtc;
+    } else {
+      throw new NeutronValidationError("Provide either amountSats or amountBtc.");
+    }
+    return this.client.post(`/api/v2/transaction`, {
+      extRefId: params.extRefId,
+      sourceReq: { ccy: "BTC", method: "neutronpay", amtRequested: btcAmount },
+      destReq: {
+        ccy: "BTC",
+        method: "lnurl",
+        reqDetails: { lnurl: address }
+      }
+    });
+  }
+  /**
+   * Decode a BOLT11 invoice to inspect it before paying.
+   * Returns amount, expiry, destination node, description, and payment status.
+   */
+  async decodeInvoice(invoice) {
+    return this.client.get(
+      `/api/v2/lightning/invoice?invoice=${encodeURIComponent(invoice)}`
+    );
+  }
+  /**
+   * Resolve a Lightning Address (user@domain.com) to check if it exists
+   * and get min/max sendable amounts.
+   *
+   * @param amountMsat Optional: get a specific invoice for this amount (in millisatoshis)
+   */
+  async resolveAddress(address, amountMsat) {
+    let path = `/api/v2/lightning/resolve-ln-address?lnAddress=${encodeURIComponent(address)}`;
+    if (amountMsat !== void 0) path += `&amount=${amountMsat}`;
+    return this.client.get(path);
+  }
+  /**
+   * Resolve an LNURL string to see its type (pay/withdraw/channel) and parameters.
+   */
+  async resolveLnurl(lnurl) {
+    return this.client.get(
+      `/api/v2/lightning/resolve-lnurl?lnurl=${encodeURIComponent(lnurl)}`
+    );
+  }
+};
+
+// src/resources/webhooks.ts
+import crypto2 from "crypto";
+var WebhooksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Register a webhook to receive transaction state change notifications.
+   *
+   * @example
+   * const webhook = await neutron.webhooks.create({
+   *   callback: "https://myapp.com/webhooks/neutron",
+   *   secret: "my-webhook-secret",
+   * });
+   */
+  async create(params) {
+    return this.client.post(`/api/v2/webhook`, params);
+  }
+  /**
+   * List all registered webhooks.
+   */
+  async list() {
+    const res = await this.client.get(`/api/v2/webhook`);
+    return res.data ?? res;
+  }
+  /**
+   * Update a webhook's callback URL or secret.
+   */
+  async update(webhookId, params) {
+    sanitizePathParam(webhookId, "webhookId");
+    return this.client.put(`/api/v2/webhook/${webhookId}`, params);
+  }
+  /**
+   * Delete a webhook.
+   */
+  async delete(webhookId) {
+    sanitizePathParam(webhookId, "webhookId");
+    await this.client.del(`/api/v2/webhook/${webhookId}`);
+  }
+  /**
+   * Verify a webhook signature from an incoming request.
+   * Throws if the signature is invalid.
+   *
+   * @param body The raw request body (string or Buffer)
+   * @param signature The `X-Neutronpay-Signature` header value
+   * @param secret Your webhook secret
+   * @returns The parsed event payload
+   *
+   * @example
+   * // Express
+   * app.post("/webhooks/neutron", express.raw({ type: "application/json" }), (req, res) => {
+   *   try {
+   *     const event = Neutron.webhooks.verifySignature(
+   *       req.body,
+   *       req.headers["x-neutronpay-signature"],
+   *       "my-webhook-secret"
+   *     );
+   *     // event is verified and safe to use
+   *     if (event.txnState === "completed") fulfillOrder(event.extRefId);
+   *   } catch (err) {
+   *     return res.status(401).send("Invalid signature");
+   *   }
+   *   res.status(200).send("OK");
+   * });
+   */
+  static verifySignature(body, signature, secret) {
+    if (!signature) {
+      throw new NeutronValidationError("Missing webhook signature header (X-Neutronpay-Signature)");
+    }
+    if (!secret) {
+      throw new NeutronValidationError("Webhook secret is required for verification");
+    }
+    const bodyStr = typeof body === "string" ? body : body.toString("utf8");
+    const expected = crypto2.createHmac("sha256", secret).update(bodyStr).digest("hex");
+    const sigBuf = Buffer.from(signature);
+    const expBuf = Buffer.from(expected);
+    const isValid = sigBuf.length === expBuf.length && crypto2.timingSafeEqual(sigBuf, expBuf);
+    if (!isValid) {
+      throw new NeutronValidationError("Invalid webhook signature");
+    }
+    return JSON.parse(bodyStr);
+  }
+};
+
+// src/resources/rates.ts
+var RatesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get current BTC exchange rates against all supported currencies.
+   *
+   * @example
+   * const rates = await neutron.rates.get();
+   * console.log(rates); // { BTCUSD: 97500, BTCVND: 2437500000, ... }
+   */
+  async get() {
+    const res = await this.client.get(`/api/v2/rate`);
+    return res.data ?? res;
+  }
+};
+
+// src/resources/fiat.ts
+var FiatResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List banks and financial institutions for a country.
+   * Returns institution codes needed for fiat payouts.
+   *
+   * @example
+   * const banks = await neutron.fiat.institutions("VN");
+   * // [{ code: "970422", name: "MB Bank" }, ...]
+   */
+  async institutions(countryCode) {
+    sanitizePathParam(countryCode, "countryCode");
+    const res = await this.client.get(
+      `/api/v2/reference/fiat-institution/by-country/${countryCode}`
+    );
+    return res.data ?? res;
+  }
+  /**
+   * Create a fiat payout transaction. Handles KYC and source of funds automatically.
+   * Returns a quoted transaction — call `neutron.transactions.confirm()` to execute.
+   *
+   * @example
+   * const txn = await neutron.fiat.payout({
+   *   sourceCcy: "BTC",
+   *   sourceAmount: 0.001,
+   *   destCcy: "VND",
+   *   destMethod: "vnd-instant",
+   *   bankAcctNum: "0123456789",
+   *   institutionCode: "970422",
+   *   recipientName: "LE VAN A",
+   *   countryCode: "VN",
+   * });
+   * // Review rate: txn.fxRate
+   * await neutron.transactions.confirm(txn.txnId);
+   */
+  async payout(params) {
+    return this.client.post(`/api/v2/transaction`, {
+      extRefId: params.extRefId,
+      sourceReq: {
+        ccy: params.sourceCcy,
+        method: "neutronpay",
+        amtRequested: params.sourceAmount,
+        reqDetails: {}
+      },
+      destReq: {
+        ccy: params.destCcy,
+        method: params.destMethod,
+        reqDetails: {
+          bankAcctNum: params.bankAcctNum,
+          institutionCode: params.institutionCode
+        },
+        kyc: {
+          type: params.kycType || "individual",
+          details: {
+            legalFullName: params.recipientName,
+            countryCode: params.countryCode
+          }
+        }
+      },
+      sourceOfFunds: params.sourceOfFunds ?? {
+        purpose: 1,
+        source: 5,
+        relationship: 3
+      }
+    });
+  }
+};
+
+// src/utils.ts
+var SATS_PER_BTC = 1e8;
+function satsToBtc(sats) {
+  return sats / SATS_PER_BTC;
+}
+function btcToSats(btc) {
+  return Math.round(btc * SATS_PER_BTC);
+}
+function formatSats(sats) {
+  return `${sats.toLocaleString("en-US")} sats`;
+}
+function formatBtc(btc) {
+  return `${btc.toFixed(8)} BTC`;
+}
+var Currency = {
+  BTC: "BTC",
+  USDT: "USDT",
+  VND: "VND",
+  USD: "USD",
+  CAD: "CAD",
+  NGN: "NGN",
+  KES: "KES",
+  GHS: "GHS"
+};
+var PaymentMethod = {
+  /** Internal Neutron wallet */
+  NEUTRON: "neutronpay",
+  /** Lightning Network (BOLT11 invoices) */
+  LIGHTNING: "lightning",
+  /** Lightning Address / LNURL */
+  LNURL: "lnurl",
+  /** Bitcoin on-chain */
+  ON_CHAIN: "on-chain",
+  /** USDT on TRON (TRC-20) */
+  TRON: "tron",
+  /** USDT on Ethereum (ERC-20) */
+  ETH: "eth",
+  /** Vietnamese Dong instant bank transfer */
+  VND_INSTANT: "vnd-instant"
+};
+var FinalStates = [
+  "completed",
+  "expired",
+  "rejected",
+  "error",
+  "usercanceled"
+];
+var TransactionStates = {
+  QUOTED: "quoted",
+  USER_CONFIRMED: "userconfirmed",
+  SRC_CREATED: "srccreated",
+  SRC_SENT: "srcsent",
+  SRC_INTENT: "srcintent",
+  SRC_PEND_CONFIRM: "srcpendconfirmfill",
+  SRC_CONFIRMED: "srcconfirmfilled",
+  DEST_PEND_SENT: "destpendsent",
+  DEST_SENT: "destsent",
+  COMPLETED: "completed",
+  EXPIRED: "expired",
+  REJECTED: "rejected",
+  ERROR: "error",
+  USER_CANCELED: "usercanceled"
+};
+var Chain = {
+  TRON: "TRON",
+  ETH: "ETH"
+};
+
+// src/index.ts
+var Neutron = class {
+  /** Account info, wallets, and deposit addresses */
+  account;
+  /** Create, confirm, list, and track transactions */
+  transactions;
+  /** Lightning invoices, payments, and utilities */
+  lightning;
+  /** Webhook management */
+  webhooks;
+  /** BTC exchange rates */
+  rates;
+  /** Fiat payouts and bank lookups */
+  fiat;
+  client;
+  constructor(config) {
+    this.client = new HttpClient(config);
+    this.account = new AccountResource(this.client);
+    this.transactions = new TransactionsResource(this.client);
+    this.lightning = new LightningResource(this.client);
+    this.webhooks = new WebhooksResource(this.client);
+    this.rates = new RatesResource(this.client);
+    this.fiat = new FiatResource(this.client);
+  }
+  /**
+   * Explicitly authenticate and verify credentials.
+   * Usually not needed — the SDK auto-authenticates on first request.
+   */
+  async authenticate() {
+    return this.client.authenticate();
+  }
+  /**
+   * Verify a webhook signature. Static method — no client instance needed.
+   *
+   * @example
+   * const event = Neutron.verifyWebhook(req.body, req.headers["x-neutronpay-signature"], secret);
+   */
+  static verifyWebhook(body, signature, secret) {
+    return WebhooksResource.verifySignature(body, signature, secret);
+  }
+};
+export {
+  AccountResource,
+  Chain,
+  Currency,
+  FiatResource,
+  FinalStates,
+  HttpClient,
+  LightningResource,
+  Neutron,
+  NeutronApiError,
+  NeutronAuthError,
+  NeutronError,
+  NeutronTimeoutError,
+  NeutronValidationError,
+  PaymentMethod,
+  RatesResource,
+  TransactionStates,
+  TransactionsResource,
+  WebhooksResource,
+  btcToSats,
+  formatBtc,
+  formatSats,
+  sanitizePathParam,
+  satsToBtc
+};
+//# sourceMappingURL=index.js.map