@profullstack/coinpay 0.6.10 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/coinpay",
-  "version": "0.6.10",
+  "version": "0.8.0",
   "description": "CoinPay SDK & CLI — Accept cryptocurrency payments (BTC, ETH, SOL, POL, BCH, USDC) with wallet and swap support",
   "type": "module",
   "main": "./src/index.js",
@@ -17,6 +17,10 @@
       "import": "./src/payments.js",
       "types": "./src/payments.d.ts"
     },
+    "./tokens": {
+      "import": "./src/tokens.js",
+      "types": "./src/tokens.d.ts"
+    },
     "./card-payments": {
       "import": "./src/card-payments.js",
       "types": "./src/card-payments.d.ts"
@@ -32,6 +36,18 @@
     "./swap": {
       "import": "./src/swap.js",
       "types": "./src/swap.d.ts"
+    },
+    "./x402": {
+      "import": "./src/x402.js"
+    },
+    "./x402-v2": {
+      "import": "./src/x402-v2.js"
+    },
+    "./x402-browser": {
+      "import": "./src/x402-browser.js"
+    },
+    "./x402-pay-server": {
+      "import": "./src/x402-pay-server.js"
     }
   },
   "files": [
@@ -87,7 +103,7 @@
     "node": ">=20.0.0"
   },
   "devDependencies": {
-    "vitest": "^2.1.8",
+    "vitest": "^4.1.0",
     "eslint": "^8.57.0",
     "prettier": "^3.4.1"
   },
@@ -96,6 +112,7 @@
     "@scure/bip39": "^1.4.0",
     "@scure/bip32": "^1.5.0",
     "@noble/curves": "^1.6.0",
-    "@noble/hashes": "^1.5.0"
+    "@noble/hashes": "^1.5.0",
+    "@inquirer/prompts": "^8.3.0"
   }
 }

package/src/auth.js

@@ -18,6 +18,9 @@
  * @returns {Promise<Object>} { success: boolean, merchant: Object, token: string }
  */
 export async function registerMerchant(client, { email, password, name }) {
+  if (!email) throw new Error('Email is required');
+  if (!password) throw new Error('Password is required');
+
   return client.requestUnauthenticated('/auth/register', {
     method: 'POST',
     body: JSON.stringify({
@@ -37,6 +40,9 @@ export async function registerMerchant(client, { email, password, name }) {
  * @returns {Promise<Object>} { success: boolean, merchant: Object, token: string }
  */
 export async function loginMerchant(client, { email, password }) {
+  if (!email) throw new Error('Email is required');
+  if (!password) throw new Error('Password is required');
+
   return client.requestUnauthenticated('/auth/login', {
     method: 'POST',
     body: JSON.stringify({
@@ -52,7 +58,8 @@ export async function loginMerchant(client, { email, password }) {
  * @returns {Promise<Object>} Merchant information
  */
 export async function getMe(client) {
+  // GET — the /auth/me endpoint is GET-only (a POST returns 405).
   return client.request('/auth/me', {
-    method: 'POST',
+    method: 'GET',
   });
 }

package/src/client.d.ts

@@ -41,6 +41,14 @@ export interface ListPaymentsParams {
   offset?: number;
 }
 
+/** Parameters for supported coin/token discovery */
+export interface SupportedCoinsParams {
+  /** Business ID. Required for merchant JWTs; optional with business API keys if it matches key scope. */
+  businessId?: string;
+  /** If true, only active wallets are returned. */
+  activeOnly?: boolean;
+}
+
 /** Options for the `waitForPayment` polling method */
 export interface WaitForPaymentOptions {
   /** Polling interval in milliseconds (default: `5000`) */
@@ -109,6 +117,36 @@ export interface ListPaymentsResponse {
   payments: Payment[];
 }
 
+/** Supported payment coin record */
+export interface SupportedCoin {
+  symbol: string;
+  name: string;
+  is_active: boolean;
+  has_wallet: boolean;
+  wallet_source: 'business' | 'merchant_global';
+}
+
+/** Checkout token record with lower-case code accepted by createPayment currency */
+export interface SupportedToken extends SupportedCoin {
+  code: string;
+  ticker: string;
+  chain?: string;
+}
+
+/** Response from supported coin discovery */
+export interface SupportedCoinsResponse {
+  success: boolean;
+  coins: SupportedCoin[];
+  business_id: string;
+  merchant_id?: string;
+  total: number;
+}
+
+/** Response from token discovery */
+export interface TokensResponse extends SupportedCoinsResponse {
+  tokens: SupportedToken[];
+}
+
 /**
  * CoinPay API Client
  *
@@ -186,6 +224,20 @@ export class CoinPayClient {
    */
   listPayments(params: ListPaymentsParams): Promise<ListPaymentsResponse>;
 
+  /**
+   * List supported payment coins for a business.
+   *
+   * Business wallets win; merchant global wallets are used as fallback.
+   */
+  getSupportedCoins(params?: SupportedCoinsParams): Promise<SupportedCoinsResponse>;
+
+  /**
+   * List checkout-friendly tokens for a business.
+   *
+   * Returns lower-case `code` values accepted by `createPayment({ currency })`.
+   */
+  getTokens(params?: SupportedCoinsParams): Promise<TokensResponse>;
+
   /**
    * Get a URL pointing to the QR code image for a payment.
    *

package/src/client.js

@@ -279,6 +279,45 @@ export class CoinPayClient {
     return this.request(`/payments?${params.toString()}`);
   }
 
+  /**
+   * Get supported payment coins for a business.
+   *
+   * Business API keys derive the business from the key. Passing businessId is
+   * still allowed and must match the key scope. Merchant JWTs require
+   * businessId.
+   *
+   * @param {Object} [params]
+   * @param {string} [params.businessId] - Business ID
+   * @param {boolean} [params.activeOnly] - Only return active wallets
+   * @returns {Promise<Object>} Supported coins response
+   */
+  async getSupportedCoins({ businessId, activeOnly } = {}) {
+    const params = new URLSearchParams();
+    if (businessId) params.set('business_id', businessId);
+    if (activeOnly) params.set('active_only', 'true');
+    const query = params.toString();
+    return this.request(`/supported-coins${query ? `?${query}` : ''}`);
+  }
+
+  /**
+   * Get payment-option tokens for a business.
+   *
+   * Returns lower-case `code` values accepted by /payments/create, plus
+   * display fields for checkout coin pickers.
+   *
+   * @param {Object} [params]
+   * @param {string} [params.businessId] - Business ID
+   * @param {boolean} [params.activeOnly] - Only return active wallets
+   * @returns {Promise<Object>} Tokens response
+   */
+  async getTokens({ businessId, activeOnly } = {}) {
+    const params = new URLSearchParams();
+    if (businessId) params.set('business_id', businessId);
+    if (activeOnly) params.set('active_only', 'true');
+    const query = params.toString();
+    return this.request(`/tokens${query ? `?${query}` : ''}`);
+  }
+
   /**
    * Get payment QR code URL
    *
@@ -685,22 +724,29 @@ export class CoinPayClient {
 
   /**
    * Create Stripe Connect onboarding link
-   * 
+   *
    * Generates a Stripe Express onboarding link for a merchant.
    * The merchant must complete this onboarding before they can accept card payments.
-   * 
+   *
+   * Country is required on the first onboarding call and is locked at Stripe
+   * account creation — it cannot be changed afterward. Subsequent calls (e.g.
+   * to finish remaining requirements) may omit it; the server reuses the
+   * country stored on the business. All Stripe Connect supported countries are
+   * accepted (US, CA, GB, AU, DE, FR, JP, SG, ...). See
+   * https://stripe.com/global for the full list.
+   *
    * @param {string} businessId - Business ID
    * @param {Object} [params] - Optional parameters
    * @param {string} [params.email] - Merchant email (pre-fills onboarding form)
-   * @param {string} [params.country='US'] - Country code (US, CA, GB, etc.)
+   * @param {string} [params.country] - ISO-3166-1 alpha-2 country code (e.g. 'US', 'CA', 'GB'). Required on first onboarding.
    * @returns {Promise<Object>} Onboarding link and account ID
-   * 
+   *
    * @example
    * const onboarding = await client.createStripeOnboardingLink('business-id', {
    *   email: 'merchant@example.com',
-   *   country: 'US'
+   *   country: 'CA'
    * });
-   * 
+   *
    * // Redirect merchant to onboarding.onboarding_url
    */
   async createStripeOnboardingLink(businessId, params = {}) {
@@ -826,6 +872,91 @@ export class CoinPayClient {
       method: 'DELETE',
     });
   }
+
+  // ── OAuth Client Methods ─────────────────────────────────
+
+  /**
+   * List OAuth clients
+   *
+   * Returns all OAuth clients registered under your account.
+   *
+   * @returns {Promise<Object>} List of OAuth clients
+   *
+   * @example
+   * const result = await client.listOAuthClients();
+   * for (const app of result.clients) {
+   *   console.log(app.client_id, app.name);
+   * }
+   */
+  async listOAuthClients() {
+    return this.request('/oauth/clients');
+  }
+
+  /**
+   * Create a new OAuth client
+   *
+   * Registers a new OAuth application. Returns the client_id and client_secret.
+   * Store the client_secret securely — it is only shown once.
+   *
+   * @param {Object} params - OAuth client parameters
+   * @param {string} params.name - Application name
+   * @param {string[]} params.redirectUris - Authorized redirect URIs
+   * @param {string[]} [params.scopes] - Requested scopes (e.g., ['openid', 'profile'])
+   * @param {string} [params.description] - Application description
+   * @returns {Promise<Object>} Created OAuth client with client_id and client_secret
+   *
+   * @example
+   * const app = await client.createOAuthClient({
+   *   name: 'My App',
+   *   redirectUris: ['https://myapp.com/callback'],
+   *   scopes: ['openid', 'profile'],
+   *   description: 'My awesome application',
+   * });
+   * console.log('Client ID:', app.client_id);
+   * console.log('Client Secret:', app.client_secret);
+   */
+  async createOAuthClient({ name, redirectUris, scopes, description }) {
+    return this.request('/oauth/clients', {
+      method: 'POST',
+      body: JSON.stringify({
+        name,
+        redirect_uris: redirectUris,
+        scopes,
+        description,
+      }),
+    });
+  }
+
+  /**
+   * Get an OAuth client by ID
+   *
+   * @param {string} id - OAuth client ID
+   * @returns {Promise<Object>} OAuth client details
+   *
+   * @example
+   * const app = await client.getOAuthClient('oac_abc123');
+   * console.log(app.name, app.redirect_uris);
+   */
+  async getOAuthClient(id) {
+    return this.request(`/oauth/clients/${id}`);
+  }
+
+  /**
+   * Delete an OAuth client
+   *
+   * Permanently removes an OAuth client and revokes all associated tokens.
+   *
+   * @param {string} id - OAuth client ID
+   * @returns {Promise<Object>} Deletion confirmation
+   *
+   * @example
+   * await client.deleteOAuthClient('oac_abc123');
+   */
+  async deleteOAuthClient(id) {
+    return this.request(`/oauth/clients/${id}`, {
+      method: 'DELETE',
+    });
+  }
 }
 
-export default CoinPayClient;
+export default CoinPayClient;

package/src/index.d.ts

@@ -12,9 +12,22 @@ export type {
   PaymentParams, 
   ListPaymentsParams, 
   WaitForPaymentOptions, 
-  CreateBusinessParams 
+  CreateBusinessParams,
+  SupportedCoinsParams,
+  SupportedCoin,
+  SupportedToken,
+  SupportedCoinsResponse,
+  TokensResponse,
 } from './client.js';
 
+export {
+  getTokens,
+  getSupportedCoins,
+} from './tokens.js';
+export type {
+  TokenDiscoveryParams,
+} from './tokens.js';
+
 // Payment exports
 export {
   createPayment,
@@ -31,6 +44,26 @@ export type {
   ListPaymentsFnParams 
 } from './payments.js';
 
+// Invoice exports
+export {
+  createInvoice,
+  getInvoice,
+  listInvoices,
+  updateInvoice,
+  deleteInvoice,
+  sendInvoice,
+  getInvoicePaymentData,
+  InvoiceStatus,
+} from './invoices.js';
+export type {
+  Invoice,
+  InvoiceStatusType,
+  CreateInvoiceParams,
+  ListInvoicesParams,
+  UpdateInvoiceParams,
+  ListInvoicesResult,
+} from './invoices.js';
+
 // Webhook exports
 export {
   verifyWebhookSignature,

package/src/index.js

@@ -46,6 +46,11 @@ import {
   PaymentStatus,
   FiatCurrency,
 } from './payments.js';
+import {
+  getTokens,
+  getSupportedCoins,
+  getSupportedCoins as getSupportedPaymentCoins,
+} from './tokens.js';
 import {
   verifyWebhookSignature,
   generateWebhookSignature,
@@ -66,6 +71,18 @@ import {
   authenticateEscrow,
 } from './escrow.js';
 
+// Invoice exports
+import {
+  createInvoice,
+  getInvoice,
+  listInvoices,
+  updateInvoice,
+  deleteInvoice,
+  sendInvoice,
+  getInvoicePaymentData,
+  InvoiceStatus,
+} from './invoices.js';
+
 // Wallet exports
 import {
   WalletClient,
@@ -156,6 +173,7 @@ import {
   verifyX402Payment,
   settleX402Payment,
   buildPaymentRequired,
+  expectedForProof,
   convertUsdToAssetAmount,
   PAYMENT_METHODS,
   USDC_CONTRACTS,
@@ -170,6 +188,9 @@ export {
   createPayment,
   getPayment,
   listPayments,
+  getTokens,
+  getSupportedCoins,
+  getSupportedPaymentCoins,
   
   // Escrow functions
   createEscrow,
@@ -182,6 +203,16 @@ export {
   waitForEscrow,
   authenticateEscrow,
   
+  // Invoice functions
+  createInvoice,
+  getInvoice,
+  listInvoices,
+  updateInvoice,
+  deleteInvoice,
+  sendInvoice,
+  getInvoicePaymentData,
+  InvoiceStatus,
+  
   // Wallet
   WalletClient,
   WalletChain,
@@ -263,6 +294,7 @@ export {
   verifyX402Payment,
   settleX402Payment,
   buildPaymentRequired,
+  expectedForProof,
   convertUsdToAssetAmount,
   PAYMENT_METHODS,
   USDC_CONTRACTS,

package/src/invoices.d.ts

@@ -0,0 +1,77 @@
+import type { CoinPayClient } from './client.js';
+
+export const InvoiceStatus: {
+  readonly DRAFT: 'draft';
+  readonly SENT: 'sent';
+  readonly PAID: 'paid';
+  readonly OVERDUE: 'overdue';
+  readonly CANCELLED: 'cancelled';
+};
+
+export type InvoiceStatusType = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
+
+export interface Invoice {
+  id: string;
+  invoiceNumber?: string;
+  businessId?: string;
+  clientId?: string;
+  currency?: string;
+  amount?: number;
+  cryptoCurrency?: string;
+  cryptoAmount?: string | number;
+  status?: InvoiceStatusType;
+  dueDate?: string;
+  notes?: string;
+  walletId?: string;
+  merchantWalletAddress?: string;
+  paymentAddress?: string;
+  stripeCheckoutUrl?: string;
+  paidAt?: string;
+  sentAt?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface CreateInvoiceParams {
+  businessId?: string;
+  clientId?: string;
+  currency: string;
+  amount: number;
+  cryptoCurrency?: string;
+  dueDate?: string;
+  notes?: string;
+  walletId?: string;
+  merchantWalletAddress?: string;
+}
+
+export interface ListInvoicesParams {
+  businessId?: string;
+  status?: InvoiceStatusType;
+  clientId?: string;
+  dateFrom?: string;
+  dateTo?: string;
+}
+
+export interface UpdateInvoiceParams {
+  amount?: number;
+  currency?: string;
+  cryptoCurrency?: string;
+  dueDate?: string;
+  notes?: string;
+  clientId?: string;
+  walletId?: string;
+  merchantWalletAddress?: string;
+}
+
+export interface ListInvoicesResult {
+  invoices: Invoice[];
+  total?: number;
+}
+
+export function createInvoice(client: CoinPayClient, options: CreateInvoiceParams): Promise<Invoice>;
+export function listInvoices(client: CoinPayClient, filters?: ListInvoicesParams): Promise<ListInvoicesResult>;
+export function getInvoice(client: CoinPayClient, id: string): Promise<Invoice>;
+export function updateInvoice(client: CoinPayClient, id: string, updates: UpdateInvoiceParams): Promise<Invoice>;
+export function deleteInvoice(client: CoinPayClient, id: string): Promise<Record<string, unknown>>;
+export function sendInvoice(client: CoinPayClient, id: string): Promise<Record<string, unknown>>;
+export function getInvoicePaymentData(client: CoinPayClient, id: string): Promise<Record<string, unknown>>;