@profullstack/coinpay 0.6.7 → 0.6.8

package/bin/coinpay.js

@@ -119,6 +119,13 @@ function createClient() {
   return new CoinPayClient({ apiKey, baseUrl: getBaseUrl() });
 }
 
+/**
+ * Create unauthenticated client for auth operations
+ */
+function createUnauthenticatedClient() {
+  return new CoinPayClient({ baseUrl: getBaseUrl() });
+}
+
 /**
  * Parse command line arguments
  */
@@ -171,6 +178,11 @@ ${colors.cyan}Commands:${colors.reset}
     set-url <base-url>    Set custom API URL
     show                  Show current configuration
 
+  ${colors.bright}auth${colors.reset}
+    register              Register new merchant account
+    login                 Login to merchant account
+    me                    Show current merchant info
+
   ${colors.bright}payment${colors.reset}
     create                Create a new payment
     get <id>              Get payment details
@@ -241,6 +253,8 @@ ${colors.cyan}Commands:${colors.reset}
     badge [did]           Get embeddable reputation badge URL
     verify <id>           Verify a credential
     revocations           List revoked credentials
+    did claim             Claim (auto-generate) a new DID
+    did me                Show your current DID
     issuer register       Register platform issuer (--name, --domain)
     issuer list           List your platform issuers
     issuer rotate         Rotate issuer API key (--id)
@@ -1715,6 +1729,136 @@ async function handleEscrow(subcommand, args, flags) {
   }
 }
 
+/**
+ * Auth commands
+ */
+async function handleAuth(subcommand, args, flags) {
+  const config = loadConfig();
+  
+  switch (subcommand) {
+    case 'register': {
+      const email = flags.email;
+      const password = flags.password;
+      const name = flags.name;
+      
+      if (!email || !password) {
+        print.error('Required: --email <email> --password <password>');
+        print.info('Example: coinpay auth register --email user@example.com --password mysecret --name "My Company"');
+        return;
+      }
+      
+      try {
+        const client = createUnauthenticatedClient();
+        const { registerMerchant } = await import('../src/auth.js');
+        const result = await registerMerchant(client, { email, password, name });
+        
+        if (result.success) {
+          // Store the JWT token in config
+          config.jwtToken = result.token;
+          saveConfig(config);
+          
+          print.success('Registration successful!');
+          print.info(`Merchant ID: ${result.merchant.id}`);
+          print.info(`Email: ${result.merchant.email}`);
+          if (result.merchant.name) {
+            print.info(`Name: ${result.merchant.name}`);
+          }
+          print.success('JWT token saved to config');
+        } else {
+          print.error(result.error || 'Registration failed');
+        }
+        
+        if (flags.json) {
+          print.json(result);
+        }
+      } catch (error) {
+        print.error(error.message);
+      }
+      break;
+    }
+    
+    case 'login': {
+      const email = flags.email;
+      const password = flags.password;
+      
+      if (!email || !password) {
+        print.error('Required: --email <email> --password <password>');
+        print.info('Example: coinpay auth login --email user@example.com --password mysecret');
+        return;
+      }
+      
+      try {
+        const client = createUnauthenticatedClient();
+        const { loginMerchant } = await import('../src/auth.js');
+        const result = await loginMerchant(client, { email, password });
+        
+        if (result.success) {
+          // Store the JWT token in config
+          config.jwtToken = result.token;
+          saveConfig(config);
+          
+          print.success('Login successful!');
+          print.info(`Merchant ID: ${result.merchant.id}`);
+          print.info(`Email: ${result.merchant.email}`);
+          if (result.merchant.name) {
+            print.info(`Name: ${result.merchant.name}`);
+          }
+          print.success('JWT token saved to config');
+        } else {
+          print.error(result.error || 'Login failed');
+        }
+        
+        if (flags.json) {
+          print.json(result);
+        }
+      } catch (error) {
+        print.error(error.message);
+      }
+      break;
+    }
+    
+    case 'me': {
+      try {
+        // Check if we have a JWT token
+        const jwtToken = config.jwtToken;
+        if (!jwtToken) {
+          print.error('Not authenticated. Run: coinpay auth login');
+          return;
+        }
+        
+        // Create client with JWT token instead of API key
+        const client = new CoinPayClient({ apiKey: jwtToken, baseUrl: getBaseUrl() });
+        const { getMe } = await import('../src/auth.js');
+        const result = await getMe(client);
+        
+        print.success('Current merchant:');
+        print.info(`ID: ${result.id}`);
+        print.info(`Email: ${result.email}`);
+        if (result.name) {
+          print.info(`Name: ${result.name}`);
+        }
+        print.info(`Created: ${result.created_at}`);
+        
+        if (flags.json) {
+          print.json(result);
+        }
+      } catch (error) {
+        if (error.message.includes('401') || error.message.includes('403')) {
+          print.error('Authentication failed. Please run: coinpay auth login');
+        } else {
+          print.error(error.message);
+        }
+      }
+      break;
+    }
+    
+    default:
+      print.error(`Unknown auth command: ${subcommand}`);
+      print.info('Available: register, login, me');
+      process.exit(1);
+  }
+}
+
 /**
  * Reputation commands
  */
@@ -1896,6 +2040,21 @@ async function handleReputation(subcommand, args, flags) {
           print.error(result.error || 'Failed to link DID');
         }
 
+        if (flags.json) print.json(result);
+      } else if (didSubcommand === 'me') {
+        // Show current DID
+        const { getMyDid } = await import('../src/reputation.js');
+        const result = await getMyDid(client);
+
+        if (result.did) {
+          print.success(`Your DID: ${result.did}`);
+          console.log(`  Public Key: ${result.public_key}`);
+          console.log(`  Verified: ${result.verified}`);
+          console.log(`  Created: ${result.created_at}`);
+        } else {
+          print.info('No DID found. Run: coinpay reputation did claim');
+        }
+
         if (flags.json) print.json(result);
       } else {
         // Default: show current DID
@@ -2449,6 +2608,10 @@ async function main() {
         await handleCard(subcommand, args, flags);
         break;
 
+      case 'auth':
+        await handleAuth(subcommand, args, flags);
+        break;
+        
       case 'reputation':
         await handleReputation(subcommand, args, flags);
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/coinpay",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "CoinPay SDK & CLI — Accept cryptocurrency payments (BTC, ETH, SOL, POL, BCH, USDC) with wallet and swap support",
   "type": "module",
   "main": "./src/index.js",

package/src/auth.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Auth SDK Module Types
+ */
+
+import { CoinPayClient } from './client.js';
+
+/**
+ * Merchant object returned from auth operations
+ */
+export interface Merchant {
+  id: string;
+  email: string;
+  name?: string;
+  created_at: string;
+  updated_at?: string;
+  [key: string]: any;
+}
+
+/**
+ * Auth response for register/login
+ */
+export interface AuthResponse {
+  success: boolean;
+  merchant: Merchant;
+  token: string;
+}
+
+/**
+ * Register params
+ */
+export interface RegisterParams {
+  email: string;
+  password: string;
+  name?: string;
+}
+
+/**
+ * Login params
+ */
+export interface LoginParams {
+  email: string;
+  password: string;
+}
+
+/**
+ * Register a new merchant account
+ * @param client - CoinPay client (can be unauthenticated)
+ * @param params - Registration parameters
+ * @returns Promise with registration response
+ */
+export function registerMerchant(
+  client: CoinPayClient,
+  params: RegisterParams
+): Promise<AuthResponse>;
+
+/**
+ * Login to merchant account
+ * @param client - CoinPay client (can be unauthenticated)
+ * @param params - Login parameters
+ * @returns Promise with login response
+ */
+export function loginMerchant(
+  client: CoinPayClient,
+  params: LoginParams
+): Promise<AuthResponse>;
+
+/**
+ * Get current authenticated merchant info
+ * @param client - Authenticated CoinPay client
+ * @returns Promise with merchant information
+ */
+export function getMe(client: CoinPayClient): Promise<Merchant>;

package/src/auth.js

@@ -0,0 +1,58 @@
+/**
+ * Auth SDK Module
+ *
+ * Authentication functions for registration, login, and merchant management.
+ *
+ * @example
+ * import { CoinPayClient } from '@profullstack/coinpay';
+ * import { registerMerchant, loginMerchant, getMe } from '@profullstack/coinpay/auth';
+ */
+
+/**
+ * Register a new merchant account
+ * @param {import('./client.js').CoinPayClient} client - CoinPay client (can be unauthenticated)
+ * @param {Object} params
+ * @param {string} params.email - Merchant email
+ * @param {string} params.password - Account password
+ * @param {string} [params.name] - Optional merchant name
+ * @returns {Promise<Object>} { success: boolean, merchant: Object, token: string }
+ */
+export async function registerMerchant(client, { email, password, name }) {
+  return client.requestUnauthenticated('/auth/register', {
+    method: 'POST',
+    body: JSON.stringify({
+      email,
+      password,
+      name,
+    }),
+  });
+}
+
+/**
+ * Login to merchant account
+ * @param {import('./client.js').CoinPayClient} client - CoinPay client (can be unauthenticated)
+ * @param {Object} params
+ * @param {string} params.email - Merchant email
+ * @param {string} params.password - Account password
+ * @returns {Promise<Object>} { success: boolean, merchant: Object, token: string }
+ */
+export async function loginMerchant(client, { email, password }) {
+  return client.requestUnauthenticated('/auth/login', {
+    method: 'POST',
+    body: JSON.stringify({
+      email,
+      password,
+    }),
+  });
+}
+
+/**
+ * Get current authenticated merchant info
+ * @param {import('./client.js').CoinPayClient} client - Authenticated CoinPay client
+ * @returns {Promise<Object>} Merchant information
+ */
+export async function getMe(client) {
+  return client.request('/auth/me', {
+    method: 'POST',
+  });
+}

package/src/client.js

@@ -16,15 +16,11 @@ export class CoinPayClient {
   /**
    * Create a new CoinPay client
    * @param {Object} options - Client options
-   * @param {string} options.apiKey - Your CoinPay API key
+   * @param {string} [options.apiKey] - Your CoinPay API key (optional for auth operations)
    * @param {string} [options.baseUrl] - API base URL (default: https://coinpayportal.com/api)
    * @param {number} [options.timeout] - Request timeout in ms (default: 30000)
    */
-  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL, timeout = 30000 }) {
-    if (!apiKey) {
-      throw new Error('API key is required');
-    }
-
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL, timeout = 30000 } = {}) {
     this.#apiKey = apiKey;
     this.#baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
     this.#timeout = timeout;
@@ -37,6 +33,10 @@ export class CoinPayClient {
    * @returns {Promise<Object>} API response
    */
   async request(endpoint, options = {}) {
+    if (!this.#apiKey) {
+      throw new Error('API key is required for authenticated requests. Use requestUnauthenticated() for registration/login.');
+    }
+
     const url = `${this.#baseUrl}${endpoint}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.#timeout);
@@ -72,6 +72,47 @@ export class CoinPayClient {
     }
   }
 
+  /**
+   * Make an unauthenticated API request (for registration/login)
+   * @param {string} endpoint - API endpoint
+   * @param {Object} [options] - Fetch options
+   * @returns {Promise<Object>} API response
+   */
+  async requestUnauthenticated(endpoint, options = {}) {
+    const url = `${this.#baseUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.#timeout);
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+        headers: {
+          'Content-Type': 'application/json',
+          ...options.headers,
+        },
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        const error = new Error(data.error || `HTTP ${response.status}`);
+        error.status = response.status;
+        error.response = data;
+        throw error;
+      }
+
+      return data;
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${this.#timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
   /**
    * Create a new payment
    *

package/src/index.js

@@ -88,8 +88,18 @@ import {
   getBadgeUrl,
   verifyCredential,
   getRevocationList,
+  claimDid,
+  linkDid,
+  getMyDid,
 } from './reputation.js';
 
+// Auth exports
+import {
+  registerMerchant,
+  loginMerchant,
+  getMe,
+} from './auth.js';
+
 import {
   SwapClient,
   SwapCoins,
@@ -216,8 +226,19 @@ export {
   submitReceipt,
   getReputation,
   getCredential,
+  getCredentials,
+  getReceipts,
+  getBadgeUrl,
   verifyCredential,
   getRevocationList,
+  claimDid,
+  linkDid,
+  getMyDid,
+  
+  // Auth
+  registerMerchant,
+  loginMerchant,
+  getMe,
   
   // Webhook utilities
   verifyWebhookSignature,