nuxt-openreceive 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Grygorii Liashenko (frontender-ua)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# nuxt-openreceive
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![CI](https://github.com/aisoul-dev/nuxt-openreceive/actions/workflows/ci.yml/badge.svg)](https://github.com/aisoul-dev/nuxt-openreceive/actions/workflows/ci.yml)
+
+Nuxt module for [OpenReceive](https://openreceive.org): accept Bitcoin over Lightning, plus optional USDT / USDC / ETH / SOL through a swap provider. Payments settle straight into **your own wallet**. You don't need an account or an API key, and no third party ever holds your funds.
+
+OpenReceive doesn't ship a Nuxt package. Its docs have you copy a server route, a lazy singleton, IP wiring and a checkout page by hand. This module does that wiring for you, so all you write is the host file:
+
+- mounts the payment routes at `/openreceive/**` (configurable)
+- builds the OpenReceive stack lazily on the first request (builds and prerendering never touch the wallet) and retries if boot fails
+- reads secrets from Nuxt `runtimeConfig` (`NUXT_OPENRECEIVE_*`), falling back to OpenReceive's own `NWC_URI`, `LSC_URI_*` and `DATABASE_URL`
+- manages a `pg` pool for you, or takes your own handle, Supabase, or a custom repository
+- gives `authorize` a typed `event: H3Event`, so it can read your existing session
+- turns on per-IP rate limiting with `getRequestIP` wired in
+- registers `<OpenReceiveCheckout>` globally with the prefix already filled in, and handles CSS, `build.transpile` and Vite pre-bundling for the raw SFC
+- stops the build on edge presets, since the wallet client and SQL driver need Node
+- closes the wallet connection and the pool when Nitro shuts down
+
+## Install
+
+```sh
+pnpm add nuxt-openreceive pg
+```
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['nuxt-openreceive'],
+})
+```
+
+```sh
+# .env (server only, never NUXT_PUBLIC_*)
+NUXT_OPENRECEIVE_NWC_URI=nostr+walletconnect://...      # receive-only code from your wallet
+NUXT_OPENRECEIVE_DATABASE_URL=postgres://...            # or DATABASE_URL
+# optional, for USDT/USDC/ETH/SOL swaps:
+NUXT_OPENRECEIVE_LSC_URI_PRIMARY=lightning+swapconnect://...
+```
+
+To get a receive-only NWC code, use Rizful (menu → NWC → *Receive-only*) or Alby Hub (Connections → Add Connection → *Read Only*). See the [guide](https://openreceive.org/get_a_nwc_code_to_receive_payments). OpenReceive refuses to boot with a code that can spend.
+
+Create the payment tables once through your own migrations:
+
+```ts
+// e.g. a one-off Nitro task or your migration tool: the DDL is idempotent
+await db.query(openReceiveSchemaSql('postgres')) // auto-imported on the server
+```
+
+`npx openreceive scaffold payments --orm drizzle` (or prisma, knex, ...) emits the same tables as an ORM migration.
+
+Or set `openreceive: { migrate: true }` to run the DDL on boot when the module manages the pool.
+
+## The host file
+
+`server/openreceive.ts` is how OpenReceive talks to your app: three hooks mapped onto **your** existing order and user tables.
+
+```ts
+// server/openreceive.ts
+export default defineOpenReceiveHost({
+  // The trusted price, from YOUR order row. Never from the request.
+  amountFor: async (reference) => {
+    const order = await findOrder(reference)
+    return order?.state === 'awaiting_payment'
+      ? { currency: 'USD', value: order.total, description: order.title } // decimal string
+      : null // → 404
+  },
+
+  // Runs on every payment request. `resource.reference` is a claim, not proof.
+  authorize: async ({ event, resource }) => {
+    const { user } = await getUserSession(event) // nuxt-auth-utils, Supabase, ...
+    const order = resource.reference ? await findOrder(resource.reference) : undefined
+    return Boolean(user && order?.userId === user.id)
+  },
+
+  // Once per order, INSIDE the settlement transaction. Write through `query`.
+  onPaid: async ({ reference, paidAt, query }) => {
+    await query(
+      `UPDATE orders SET state = 'paid', paid_at = to_timestamp($1)
+        WHERE id = $2 AND state = 'awaiting_payment'`,
+      [paidAt, reference],
+    )
+  },
+})
+```
+
+Pass a function instead (`defineOpenReceiveHost(() => ({ ... }))`) to defer work until the first payment request.
+
+### Rules that matter
+
+- **`reference` is your order id.** Create the order before checkout, keep its id across retries, and never reuse it. If you generate a fresh id on every page load, one order can be paid twice.
+- **`onPaid` is for database writes only, and it must be idempotent.** Send emails and webhooks after the commit, from your own worker or an outbox table. Writes made through your ORM's own connection survive a rolled-back settlement; writes made through `query` don't.
+- **Lightning payments can't be refunded by the merchant.** The wallet code is receive-only. The only refunds are swap refunds (see below).
+
+### Bring your own storage
+
+```ts
+export default defineOpenReceiveHost(() => ({
+  amountFor, authorize,
+  // your existing pg Pool (Drizzle: pass the Pool underneath it), mysql2, node:sqlite, better-sqlite3
+  storage: { db: usePgPool(), onPaid },
+  // or Supabase over HTTPS (fulfillment is the SQL function public.openreceive_on_paid):
+  // storage: { supabase: { url: process.env.SUPABASE_URL!, key: process.env.SUPABASE_SECRET_KEY! } },
+}))
+```
+
+## The checkout page
+
+```vue
+<!-- app/pages/checkout/[reference].vue -->
+<script setup lang="ts">
+const route = useRoute()
+// your own route that 404s unless the visitor owns the order
+const { data, refresh } = await useFetch(`/api/checkout/${route.params.reference}`)
+const settledHere = ref(false)
+</script>
+
+<template>
+  <p>{{ data?.state === 'paid' ? 'Paid' : 'Awaiting payment' }}</p>
+  <!-- show it only while unpaid, but keep it mounted once it settles: it is the receipt -->
+  <OpenReceiveCheckout
+    v-if="data && (data.state !== 'paid' || settledHere)"
+    :reference="data.reference"
+    :resumable="true"
+    :onSettled="() => { settledHere = true; refresh() }"
+  />
+</template>
+```
+
+Every `@openreceive/vue` prop passes through. Event handlers (`onSettled`, `onState`, …) are **props** (`:onSettled`), not `@settled`.
+
+**Swaps:** if you set `LSC_URI_PRIMARY`, the checkout must live at a per-order URL the payer can come back to (`/checkout/:reference`), and `authorize` must still recognise them hours later. A deposit that arrives short or late becomes `refund_required` and is claimed on that second visit. See [swap refunds](https://openreceive.org/guides/swap-refunds.md).
+
+## Options
+
+```ts
+openreceive: {
+  prefix: '/openreceive',              // route prefix; the component uses it too
+  host: '~~/server/openreceive',       // host definition file
+  component: true,                     // true → <OpenReceiveCheckout>, string → custom name, false → none
+  css: true,                           // add @openreceive/vue/styles.css
+  rateLimiting: true,                  // or { limitPerHour, limitPerDay, message }
+  trustProxy: false,                   // read x-forwarded-for (only behind YOUR proxy)
+  migrate: false,                      // run the payment-table DDL on boot (managed pool only)
+}
+```
+
+Server auto-imports: `defineOpenReceiveHost`, `useOpenReceive()` (the booted stack, if you need `handler` in a custom route), and `openReceiveSchemaSql(dialect)`.
+
+## Deploying
+
+- Runs on `node-server` and on Node serverless presets (Vercel, Netlify, AWS Lambda). On serverless, use a **pooled** database URL. Edge presets are refused at build time.
+- You don't need a worker or a cron job. Every payment request runs a reconcile pass through a lock in your database, so an abandoned checkout settles on the next request. For push settlement, run OpenReceive's optional `startNotificationWorker` in a separate process.
+- The built server doesn't read `.env`. Set the variables in its environment, or start it with `node --env-file=.env .output/server/index.mjs`.
+
+## Development
+
+```sh
+pnpm install
+pnpm dev:prepare
+DATABASE_URL=postgres://... OPENRECEIVE_TEST_WALLET=1 pnpm dev   # playground on an in-memory test wallet
+DATABASE_URL=postgres://... pnpm test                            # builds the playground and runs a full payment e2e
+```
+
+`OPENRECEIVE_TEST_WALLET=1` swaps in a fake receive-only wallet, so you can run the whole flow without a real NWC code. It is **playground only**. `POST /api/dev/settle/:hash` marks an invoice paid.
+
+Known noise: the Vite build prints `postcss` "Lexical error" warnings for `mod()` / `round()` in OpenReceive's stylesheet. These are harmless: the CSS is valid and works in browsers.
+
+## License
+
+MIT © Grygorii Liashenko ([frontender-ua](https://github.com/frontender-ua)) · [aisoul](https://aisoul.dev). OpenReceive itself is MIT, © its authors.

package/dist/module.d.mts

@@ -0,0 +1,66 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { IpRateLimitConfig } from '@openreceive/http';
+
+interface ModuleOptions {
+    /** Turn the whole module off without removing it. Default `true`. */
+    enabled: boolean;
+    /**
+     * Where the payment routes are mounted. The checkout component talks to the
+     * same prefix by default. Default `/openreceive`.
+     */
+    prefix: string;
+    /**
+     * Your host definition: the file whose default export is
+     * `defineOpenReceiveHost({ amountFor, authorize, onPaid })`.
+     * Resolved like any Nuxt path. Default `~~/server/openreceive`.
+     */
+    host: string;
+    /**
+     * Register the checkout component globally. `true` uses the name
+     * `OpenReceiveCheckout`; a string sets your own name; `false` skips it.
+     */
+    component: boolean | string;
+    /** Add `@openreceive/vue/styles.css` to the app. Default `true`. */
+    css: boolean;
+    /**
+     * Per-IP invoice rate limiting (counted from `openreceive_payments`, so it
+     * survives restarts and spans instances). Default `true`. The module wires
+     * the client IP from the H3 event for you.
+     */
+    rateLimiting: boolean | Omit<IpRateLimitConfig, 'ip'>;
+    /**
+     * Read the client IP from `x-forwarded-for`. Only enable behind YOUR own
+     * reverse proxy that sets the header, otherwise payers can spoof it.
+     */
+    trustProxy: boolean;
+    /**
+     * Create `openreceive_payments` / `openreceive_meta` on boot when the module
+     * manages the Postgres pool. The DDL is idempotent. Default `false`: prefer
+     * running it through your own migrations.
+     */
+    migrate: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+declare module '@nuxt/schema' {
+    interface RuntimeConfig {
+        openreceive: {
+            nwcUri: string;
+            lscUriPrimary: string;
+            lscUriBackup: string;
+            databaseUrl: string;
+            prefix: string;
+            rateLimiting: ModuleOptions['rateLimiting'];
+            trustProxy: boolean;
+            migrate: boolean;
+        };
+    }
+    interface PublicRuntimeConfig {
+        openreceive: {
+            prefix: string;
+        };
+    }
+}
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "nuxt-openreceive",
+  "configKey": "openreceive",
+  "compatibility": {
+    "nuxt": ">=3.13.0"
+  },
+  "version": "0.1.1",
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,113 @@
+import { existsSync } from 'node:fs';
+import { defineNuxtModule, useLogger, createResolver, findPath, addServerHandler, addServerPlugin, addServerImports, addTypeTemplate, addComponent } from '@nuxt/kit';
+import { defu } from 'defu';
+
+const EDGE_PRESETS = /^(cloudflare|vercel-edge|netlify-edge|deno-deploy|deno|bun-edge|winterjs|lagon)/;
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-openreceive",
+    configKey: "openreceive",
+    compatibility: { nuxt: ">=3.13.0" }
+  },
+  defaults: {
+    enabled: true,
+    prefix: "/openreceive",
+    host: "~~/server/openreceive",
+    component: true,
+    css: true,
+    rateLimiting: true,
+    trustProxy: false,
+    migrate: false
+  },
+  async setup(options, nuxt) {
+    const logger = useLogger("openreceive");
+    if (!options.enabled) return;
+    const { resolve } = createResolver(import.meta.url);
+    const prefix = normalizePrefix(options.prefix);
+    nuxt.options.runtimeConfig.openreceive = defu(
+      nuxt.options.runtimeConfig.openreceive,
+      {
+        nwcUri: "",
+        lscUriPrimary: "",
+        lscUriBackup: "",
+        databaseUrl: "",
+        prefix,
+        rateLimiting: options.rateLimiting,
+        trustProxy: options.trustProxy,
+        migrate: options.migrate
+      }
+    );
+    nuxt.options.runtimeConfig.public.openreceive = defu(
+      nuxt.options.runtimeConfig.public.openreceive,
+      { prefix }
+    );
+    const hostPath = await findPath(options.host, { extensions: [".ts", ".mts", ".js", ".mjs"] });
+    if (!hostPath || !existsSync(hostPath)) {
+      logger.warn(
+        `No host definition found at \`${options.host}\`. Payment routes under \`${prefix}\` will answer 503 until you create it (export default defineOpenReceiveHost({ amountFor, authorize, onPaid })).`
+      );
+    }
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.virtual ||= {};
+      nitroConfig.virtual["#openreceive/host"] = hostPath ? `export { default } from ${JSON.stringify(hostPath)}` : "export default undefined";
+      nitroConfig.externals ||= {};
+      nitroConfig.externals.inline ||= [];
+      nitroConfig.externals.inline.push(resolve("./runtime"));
+    });
+    nuxt.hook("nitro:init", (nitro) => {
+      const preset = String(nitro.options.preset || "");
+      if (EDGE_PRESETS.test(preset)) {
+        throw new Error(
+          `[nuxt-openreceive] Nitro preset "${preset}" is an edge runtime. OpenReceive needs Node (NWC wallet client + SQL driver). Use node-server, or a Node serverless preset (vercel, netlify, aws-lambda).`
+        );
+      }
+    });
+    addServerHandler({
+      route: `${prefix}/**`,
+      handler: resolve("./runtime/server/handler")
+    });
+    addServerPlugin(resolve("./runtime/server/plugin"));
+    addServerImports([
+      { name: "defineOpenReceiveHost", from: resolve("./runtime/server/utils/openreceive") },
+      { name: "useOpenReceive", from: resolve("./runtime/server/utils/openreceive") },
+      { name: "openReceiveSchemaSql", from: resolve("./runtime/server/utils/openreceive") }
+    ]);
+    addTypeTemplate({
+      filename: "types/openreceive-host.d.ts",
+      getContents: () => [
+        `declare module '#openreceive/host' {`,
+        `  const host: import(${JSON.stringify(resolve("./runtime/server/utils/openreceive"))}).OpenReceiveHostInput | undefined`,
+        `  export default host`,
+        `}`
+      ].join("\n")
+    }, { nitro: true, nuxt: true });
+    nuxt.options.build.transpile.push("@openreceive/vue");
+    nuxt.options.vite.optimizeDeps = defu(nuxt.options.vite.optimizeDeps, {
+      exclude: ["@openreceive/vue"],
+      // Vite pre-bundles by exact specifier, so list the subpaths the raw SFC
+      // reaches. This also converts the CommonJS `qrcode` dependency for dev.
+      include: [
+        "@openreceive/vue > @openreceive/elements",
+        "@openreceive/vue > @openreceive/elements/wrapper-shared",
+        "@openreceive/vue > @openreceive/browser",
+        "@openreceive/vue > @openreceive/browser/headless"
+      ]
+    });
+    if (options.css) {
+      nuxt.options.css.push("@openreceive/vue/styles.css");
+    }
+    if (options.component) {
+      addComponent({
+        name: typeof options.component === "string" ? options.component : "OpenReceiveCheckout",
+        filePath: resolve("./runtime/components/OpenReceiveCheckout")
+      });
+    }
+    logger.info(`OpenReceive routes mounted at \`${prefix}/**\``);
+  }
+});
+function normalizePrefix(prefix) {
+  const trimmed = `/${prefix.trim().replace(/^\/+|\/+$/g, "")}`;
+  return trimmed === "/" ? "/openreceive" : trimmed;
+}
+
+export { module$1 as default };

package/dist/runtime/components/OpenReceiveCheckout.d.ts

@@ -0,0 +1,4 @@
+import { type DefineComponent } from 'vue';
+import { type VueCheckoutProps } from '@openreceive/vue/checkout.vue';
+declare const _default: DefineComponent<VueCheckoutProps>;
+export default _default;

package/dist/runtime/components/OpenReceiveCheckout.js

@@ -0,0 +1,12 @@
+import { defineComponent, h } from "vue";
+import Checkout from "@openreceive/vue/checkout.vue";
+import { useRuntimeConfig } from "#imports";
+const OpenReceiveCheckout = defineComponent({
+  name: "OpenReceiveCheckout",
+  inheritAttrs: false,
+  setup(_, { attrs, slots }) {
+    const { prefix } = useRuntimeConfig().public.openreceive;
+    return () => h(Checkout, { prefix, ...attrs }, slots);
+  }
+});
+export default OpenReceiveCheckout;

package/dist/runtime/server/handler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/handler.js

@@ -0,0 +1,23 @@
+import { createRequestId, errorResponse, HttpError } from "@openreceive/http";
+import { defineEventHandler, toWebRequest } from "h3";
+import { useOpenReceive } from "./utils/openreceive.js";
+let warned = false;
+export default defineEventHandler(async (event) => {
+  let stack;
+  try {
+    stack = await useOpenReceive();
+  } catch (error) {
+    if (!warned || import.meta.dev) {
+      warned = true;
+      console.error(`[openreceive] ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return errorResponse(
+      new HttpError(503, "WALLET_UNAVAILABLE", "The payment service is not available. Please try again shortly.", {
+        retryable: true,
+        retryAfterSeconds: 5
+      }),
+      createRequestId()
+    );
+  }
+  return stack.handler(toWebRequest(event), { native: event });
+});

package/dist/runtime/server/plugin.d.ts

@@ -0,0 +1,7 @@
+interface NitroAppLike {
+    hooks: {
+        hook: (name: 'close', fn: () => Promise<void>) => unknown;
+    };
+}
+export default function openReceiveNitroPlugin(nitroApp: NitroAppLike): void;
+export {};

package/dist/runtime/server/plugin.js

@@ -0,0 +1,4 @@
+import { closeOpenReceive } from "./utils/openreceive.js";
+export default function openReceiveNitroPlugin(nitroApp) {
+  nitroApp.hooks.hook("close", closeOpenReceive);
+}

package/dist/runtime/server/utils/openreceive.d.ts

@@ -0,0 +1,60 @@
+import { paymentsSchemaSql, type AuthorizeContext, type CreateStackOptions, type IpRateLimitConfig, type PaymentSettlementHook, type Stack, type StackStorage, type StackWallet } from '@openreceive/http';
+import { type H3Event } from 'h3';
+/** `authorize` context with the request's H3 event, typed. */
+export interface OpenReceiveAuthorizeContext extends AuthorizeContext {
+    /** The H3 event of this request: read your session/cookies from it. */
+    readonly event: H3Event;
+}
+type PassThroughOptions = Omit<CreateStackOptions, 'wallet' | 'storage' | 'authorize' | 'prefix' | 'amountFor' | 'rateLimiting'>;
+export interface OpenReceiveHost extends PassThroughOptions {
+    /**
+     * The trusted price for an order id (`reference`), read from YOUR data.
+     * Return `null` when there is nothing to pay (answered 404). Never trust an
+     * amount the payer sends.
+     */
+    amountFor: CreateStackOptions['amountFor'];
+    /**
+     * Runs on every payment request. `resource.reference` is a claim the payer
+     * made, not proof: check ownership against the session on `event`.
+     */
+    authorize: (context: OpenReceiveAuthorizeContext) => boolean | Promise<boolean>;
+    /**
+     * Fulfillment, when the module manages the Postgres pool (DATABASE_URL).
+     * Runs once per reference INSIDE the settlement transaction: do your writes
+     * through the supplied `query` (`$1` placeholders), keep it idempotent, and
+     * send emails/webhooks only after commit, from your own worker.
+     */
+    onPaid?: PaymentSettlementHook;
+    /**
+     * Bring your own storage instead of the managed pool: `{ db, onPaid }` with
+     * an existing pg Pool / mysql2 / sqlite handle, `{ supabase: { url, key } }`
+     * for Supabase over HTTPS, or `{ payments, onPaid }` for a custom repository.
+     */
+    storage?: StackStorage;
+    /**
+     * Override the wallet (tests, a pre-built service). By default the module
+     * builds it from `NUXT_OPENRECEIVE_NWC_URI` / `NWC_URI`.
+     */
+    wallet?: StackWallet;
+    /** Override the module-level `rateLimiting` option for this host. */
+    rateLimiting?: boolean | Omit<IpRateLimitConfig, 'ip'> | IpRateLimitConfig;
+}
+export type OpenReceiveHostFactory = () => OpenReceiveHost | Promise<OpenReceiveHost>;
+export type OpenReceiveHostInput = OpenReceiveHost | OpenReceiveHostFactory;
+/**
+ * Define how OpenReceive talks to your app. Put it in `server/openreceive.ts`
+ * as the default export. Pass a function to defer work (opening your DB,
+ * reading config) until the first payment request.
+ */
+export declare function defineOpenReceiveHost<T extends OpenReceiveHostInput>(host: T): T;
+/** The OpenReceive payment tables DDL for your own migrations. Idempotent. */
+export declare function openReceiveSchemaSql(dialect?: Parameters<typeof paymentsSchemaSql>[0]): string;
+/**
+ * The booted OpenReceive stack for this server process. Built on first use,
+ * never at import, so `nuxi build` and prerendering never touch the wallet.
+ * A failed boot is retried after a short pause instead of sticking forever.
+ */
+export declare function useOpenReceive(): Promise<Stack>;
+/** Close the wallet connection and the managed pool (called on Nitro close). */
+export declare function closeOpenReceive(): Promise<void>;
+export {};

package/dist/runtime/server/utils/openreceive.js

@@ -0,0 +1,134 @@
+import {
+  createStack,
+  paymentsSchemaSql
+} from "@openreceive/http";
+import { createOpenReceive } from "@openreceive/node";
+import { getRequestIP } from "h3";
+import { useRuntimeConfig } from "#imports";
+import hostInput from "#openreceive/host";
+export function defineOpenReceiveHost(host) {
+  return host;
+}
+export function openReceiveSchemaSql(dialect = "postgres") {
+  return paymentsSchemaSql(dialect);
+}
+const RETRY_AFTER_MS = 5e3;
+let booting;
+let failedAt = 0;
+let lastError;
+export async function useOpenReceive() {
+  if (!booting) {
+    if (failedAt && Date.now() - failedAt < RETRY_AFTER_MS) throw lastError;
+    booting = boot().catch((error) => {
+      booting = void 0;
+      failedAt = Date.now();
+      lastError = error;
+      throw error;
+    });
+  }
+  return (await booting).stack;
+}
+export async function closeOpenReceive() {
+  const current = booting;
+  booting = void 0;
+  if (!current) return;
+  try {
+    await (await current).close();
+  } catch {
+  }
+}
+async function boot() {
+  if (!hostInput) {
+    throw new Error(
+      "nuxt-openreceive: no host definition. Create server/openreceive.ts with `export default defineOpenReceiveHost({ amountFor, authorize, onPaid })`."
+    );
+  }
+  const config = useRuntimeConfig().openreceive;
+  const host = typeof hostInput === "function" ? await hostInput() : hostInput;
+  const { authorize, onPaid, storage, wallet, rateLimiting, ...rest } = host;
+  const cleanups = [];
+  let resolvedStorage;
+  if (storage) {
+    if (onPaid) {
+      console.warn("[openreceive] `onPaid` is ignored when `storage` is set: put it inside `storage`.");
+    }
+    resolvedStorage = storage;
+  } else {
+    if (!onPaid) {
+      throw new Error("nuxt-openreceive: define `onPaid` (managed pool) or `storage` in your host.");
+    }
+    const url = config.databaseUrl || process.env.DATABASE_URL;
+    if (!url) {
+      throw new Error(
+        "nuxt-openreceive: no database. Set NUXT_OPENRECEIVE_DATABASE_URL (or DATABASE_URL), or pass `storage: { db, onPaid }` in your host."
+      );
+    }
+    const { default: pg } = await import("pg");
+    const pool = new pg.Pool({ connectionString: url });
+    cleanups.push(() => pool.end());
+    if (config.migrate) {
+      await pool.query(paymentsSchemaSql("postgres"));
+    }
+    resolvedStorage = { db: pool, onPaid };
+  }
+  let resolvedWallet;
+  if (wallet) {
+    resolvedWallet = wallet;
+  } else {
+    const env = withoutEmpty({
+      ...process.env,
+      NWC_URI: config.nwcUri || process.env.NWC_URI,
+      LSC_URI_PRIMARY: config.lscUriPrimary || process.env.LSC_URI_PRIMARY,
+      LSC_URI_BACKUP: config.lscUriBackup || process.env.LSC_URI_BACKUP
+    });
+    if (!env.NWC_URI) {
+      await runAll(cleanups);
+      throw new Error(
+        "nuxt-openreceive: no wallet. Set NUXT_OPENRECEIVE_NWC_URI (or NWC_URI) to a receive-only NWC code. See https://openreceive.org/get_a_nwc_code_to_receive_payments"
+      );
+    }
+    const service = createOpenReceive({ env });
+    cleanups.push(async () => (await service).close());
+    resolvedWallet = { service };
+  }
+  const stack = createStack({
+    ...rest,
+    prefix: config.prefix,
+    wallet: resolvedWallet,
+    storage: resolvedStorage,
+    authorize: (context) => authorize({ ...context, event: context.native }),
+    rateLimiting: resolveRateLimiting(rateLimiting ?? config.rateLimiting, config.trustProxy)
+  });
+  cleanups.unshift(() => stack.close());
+  try {
+    await stack.ready;
+  } catch (error) {
+    await runAll(cleanups);
+    throw error;
+  }
+  return { stack, close: () => runAll(cleanups) };
+}
+function resolveRateLimiting(option, trustProxy) {
+  if (!option) return false;
+  const base = option === true ? {} : option;
+  if (base.ip) return base;
+  return {
+    ...base,
+    ip: ({ native }) => getRequestIP(native, { xForwardedFor: trustProxy })
+  };
+}
+function withoutEmpty(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value) out[key] = value;
+  }
+  return out;
+}
+async function runAll(tasks) {
+  for (const task of tasks) {
+    try {
+      await task();
+    } catch {
+    }
+  }
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,80 @@
 {
   "name": "nuxt-openreceive",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Nuxt module for OpenReceive: Bitcoin Lightning (and optional USDT/USDC/ETH/SOL swap) checkout that settles straight into your own wallet.",
+  "license": "MIT",
+  "author": "Grygorii Liashenko (https://github.com/frontender-ua)",
+  "homepage": "https://github.com/aisoul-dev/nuxt-openreceive#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aisoul-dev/nuxt-openreceive.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aisoul-dev/nuxt-openreceive/issues"
+  },
+  "type": "module",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "openreceive",
+    "bitcoin",
+    "lightning",
+    "nwc",
+    "payments",
+    "checkout"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.2.0",
+    "@openreceive/http": "^0.4.31",
+    "@openreceive/node": "^0.4.31",
+    "@openreceive/vue": "^0.4.31",
+    "defu": "^6.1.4",
+    "h3": "^1.15.0"
+  },
+  "peerDependencies": {
+    "pg": "^8.11.0"
+  },
+  "peerDependenciesMeta": {
+    "pg": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.6.4",
+    "@types/node": "^22.10.0",
+    "@types/pg": "^8.11.10",
+    "nuxt": "^4.6.4",
+    "pg": "^8.23.1",
+    "typescript": "~5.9.3",
+    "vue-tsc": "^3.3.14"
+  },
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "typecheck": "vue-tsc --noEmit -p playground/.nuxt/tsconfig.app.json && vue-tsc --noEmit -p playground/.nuxt/tsconfig.server.json",
+    "test": "node --test test/*.test.mjs"
+  }
 }