@profullstack/coinpay 0.5.0 → 0.5.2

package/bin/coinpay.js

@@ -218,6 +218,13 @@ ${colors.cyan}Commands:${colors.reset}
     events <id>           Get escrow audit log
     auth <id>             Authenticate with escrow token
 
+  ${colors.bright}reputation${colors.reset}
+    submit                Submit a task receipt
+    query <agent-did>     Query agent reputation
+    credential <id>       Get credential details
+    verify <id>           Verify a credential
+    revocations           List revoked credentials
+
   ${colors.bright}webhook${colors.reset}
     logs <business-id>    Get webhook logs
     test <business-id>    Send test webhook
@@ -1577,6 +1584,214 @@ async function handleEscrow(subcommand, args, flags) {
   }
 }
 
+/**
+ * Reputation commands
+ */
+async function handleReputation(subcommand, args, flags) {
+  switch (subcommand) {
+    case 'submit': {
+      const receiptArg = flags.receipt;
+      if (!receiptArg) {
+        print.error('Required: --receipt <json-file-or-inline-json>');
+        print.info('Example: coinpay reputation submit --receipt receipt.json');
+        print.info('Example: coinpay reputation submit --receipt \'{"receipt_id":"..."}\'');
+        return;
+      }
+
+      let receipt;
+      try {
+        if (existsSync(receiptArg)) {
+          receipt = JSON.parse(readFileSync(receiptArg, 'utf-8'));
+        } else {
+          receipt = JSON.parse(receiptArg);
+        }
+      } catch {
+        print.error('Could not parse receipt JSON. Provide a valid JSON file path or inline JSON.');
+        return;
+      }
+
+      const client = createClient();
+      const { submitReceipt } = await import('../src/reputation.js');
+      const result = await submitReceipt(client, receipt);
+
+      if (result.success) {
+        print.success('Receipt submitted');
+      } else {
+        print.error(result.error || 'Submission failed');
+      }
+
+      if (flags.json) print.json(result);
+      else if (result.receipt) print.json(result.receipt);
+      break;
+    }
+
+    case 'query': {
+      const agentDid = args[0];
+      if (!agentDid) {
+        print.error('Agent DID required');
+        print.info('Usage: coinpay reputation query <agent-did> [--window 30d|90d|all]');
+        return;
+      }
+
+      const client = createClient();
+      const { getReputation } = await import('../src/reputation.js');
+      const result = await getReputation(client, agentDid);
+
+      if (flags.json) {
+        print.json(result);
+      } else if (result.success && result.reputation) {
+        const rep = result.reputation;
+        const windowKey = flags.window === '90d' ? 'last_90_days'
+          : flags.window === 'all' ? 'all_time'
+          : 'last_30_days';
+        const label = flags.window || '30d';
+        const w = rep.windows[windowKey];
+
+        print.info(`Reputation for ${rep.agent_did} (${label}):`);
+        console.log(`  Tasks: ${w.task_count}`);
+        console.log(`  Accepted: ${w.accepted_count} (${(w.accepted_rate * 100).toFixed(1)}%)`);
+        console.log(`  Disputed: ${w.disputed_count} (${(w.dispute_rate * 100).toFixed(1)}%)`);
+        console.log(`  Volume: ${w.total_volume.toFixed(2)}`);
+        console.log(`  Avg Value: ${w.avg_task_value.toFixed(2)}`);
+        console.log(`  Unique Buyers: ${w.unique_buyers}`);
+
+        if (rep.anti_gaming.flagged) {
+          print.warn(`Anti-gaming flags: ${rep.anti_gaming.flags.join(', ')}`);
+        }
+      } else {
+        print.json(result);
+      }
+      break;
+    }
+
+    case 'credential': {
+      const credentialId = args[0];
+      if (!credentialId) {
+        print.error('Credential ID required');
+        print.info('Usage: coinpay reputation credential <credential-id>');
+        return;
+      }
+
+      const client = createClient();
+      const { getCredential } = await import('../src/reputation.js');
+      const result = await getCredential(client, credentialId);
+
+      if (result.success && result.credential) {
+        print.success(`Credential ${result.credential.id}`);
+        console.log(`  Agent: ${result.credential.agent_did}`);
+        console.log(`  Type: ${result.credential.credential_type}`);
+        console.log(`  Issued: ${result.credential.issued_at}`);
+        console.log(`  Revoked: ${result.credential.revoked ? 'YES' : 'no'}`);
+      }
+
+      if (flags.json) print.json(result);
+      break;
+    }
+
+    case 'verify': {
+      const credentialId = args[0];
+      if (!credentialId) {
+        print.error('Credential ID required');
+        print.info('Usage: coinpay reputation verify <credential-id>');
+        return;
+      }
+
+      const client = createClient();
+      const { verifyCredential } = await import('../src/reputation.js');
+      const result = await verifyCredential(client, { credential_id: credentialId });
+
+      if (result.valid) {
+        print.success('Credential is valid');
+      } else {
+        print.error(`Credential invalid: ${result.reason}`);
+      }
+
+      if (flags.json) print.json(result);
+      break;
+    }
+
+    case 'revocations': {
+      const client = createClient();
+      const { getRevocationList } = await import('../src/reputation.js');
+      const result = await getRevocationList(client);
+
+      if (flags.json) {
+        print.json(result);
+      } else {
+        const revocations = result.revocations || [];
+        print.info(`Revoked credentials: ${revocations.length}`);
+        for (const r of revocations) {
+          console.log(`  ${r.credential_id} — ${r.reason || 'no reason'} (${r.revoked_at})`);
+        }
+      }
+      break;
+    }
+
+    case 'did': {
+      const didSubcommand = args[0];
+      const client = createClient();
+
+      if (didSubcommand === 'claim') {
+        const { claimDid } = await import('../src/reputation.js');
+        const result = await claimDid(client);
+
+        if (result.did) {
+          print.success(`DID claimed: ${result.did}`);
+          console.log(`  Public Key: ${result.public_key}`);
+          console.log(`  Verified: ${result.verified}`);
+        } else {
+          print.error(result.error || 'Failed to claim DID');
+        }
+
+        if (flags.json) print.json(result);
+      } else if (didSubcommand === 'link') {
+        const didValue = flags.did;
+        const publicKey = flags['public-key'];
+        const signature = flags.signature;
+
+        if (!didValue || !publicKey || !signature) {
+          print.error('Required: --did <did> --public-key <key> --signature <sig>');
+          print.info('Usage: coinpay reputation did link --did <did> --public-key <key> --signature <sig>');
+          break;
+        }
+
+        const { linkDid } = await import('../src/reputation.js');
+        const result = await linkDid(client, { did: didValue, publicKey, signature });
+
+        if (result.did) {
+          print.success(`DID linked: ${result.did}`);
+          console.log(`  Verified: ${result.verified}`);
+        } else {
+          print.error(result.error || 'Failed to link DID');
+        }
+
+        if (flags.json) print.json(result);
+      } else {
+        // Default: 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);
+      }
+      break;
+    }
+
+    default:
+      print.error(`Unknown reputation command: ${subcommand}`);
+      print.info('Available: submit, query, credential, verify, revocations, did');
+      process.exit(1);
+  }
+}
+
 /**
  * Main entry point
  */
@@ -1626,6 +1841,10 @@ async function main() {
       case 'webhook':
         await handleWebhook(subcommand, args, flags);
         break;
+
+      case 'reputation':
+        await handleReputation(subcommand, args, flags);
+        break;
         
       default:
         print.error(`Unknown command: ${command}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/coinpay",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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/index.d.ts

@@ -105,11 +105,10 @@ export {
   getRevocationList,
 } from './reputation.js';
 export type {
-  TaskReceipt,
-  ReputationSummary,
-  MultiWindowReputation,
-  CredentialVerification,
-  RevocationList,
+  ReceiptInput,
+  ReputationWindow,
+  ReputationResult,
+  Credential,
 } from './reputation.js';
 
 import { CoinPayClient } from './client.js';

package/src/index.js

@@ -78,6 +78,7 @@ import {
 } from './wallet.js';
 
 // Swap exports
+// Reputation exports
 import {
   submitReceipt,
   getReputation,

package/src/reputation.d.ts

@@ -1,69 +1,82 @@
 import { CoinPayClient } from './client';
 
-export interface TaskReceipt {
+export interface ReceiptInput {
   receipt_id: string;
   task_id: string;
   agent_did: string;
   buyer_did: string;
-  platform_did: string;
+  platform_did?: string;
   escrow_tx?: string;
-  amount: number;
-  currency: string;
+  amount?: number;
+  currency?: string;
   category?: string;
   sla?: Record<string, unknown>;
-  outcome: 'completed' | 'failed' | 'disputed' | 'cancelled';
+  outcome: 'accepted' | 'rejected' | 'disputed';
   dispute?: boolean;
   artifact_hash?: string;
   signatures: {
-    agent?: string;
-    buyer?: string;
-    platform?: string;
+    escrow_sig: string;
+    agent_sig?: string;
+    buyer_sig?: string;
+    arbitration_sig?: string;
   };
   finalized_at?: string;
 }
 
-export interface ReputationSummary {
-  agent_did: string;
-  total_tasks: number;
-  completed: number;
-  failed: number;
-  disputed: number;
-  cancelled: number;
-  completion_rate: number;
-  dispute_rate: number;
+export interface ReputationWindow {
+  task_count: number;
+  accepted_count: number;
+  disputed_count: number;
   total_volume: number;
-  avg_task_value: number;
   unique_buyers: number;
+  avg_task_value: number;
+  accepted_rate: number;
+  dispute_rate: number;
   categories: Record<string, { count: number; volume: number }>;
+}
+
+export interface ReputationResult {
+  agent_did: string;
+  windows: {
+    last_30_days: ReputationWindow;
+    last_90_days: ReputationWindow;
+    all_time: ReputationWindow;
+  };
   anti_gaming: {
-    circular_payment: boolean;
-    burst_detected: boolean;
-    below_economic_threshold: boolean;
-    insufficient_unique_buyers: boolean;
     flagged: boolean;
-    details: string[];
+    flags: string[];
+    adjusted_weight: number;
   };
 }
 
-export interface MultiWindowReputation {
-  '30d': ReputationSummary;
-  '90d': ReputationSummary;
-  all: ReputationSummary;
+export interface Credential {
+  id: string;
+  agent_did: string;
+  credential_type: string;
+  category?: string;
+  data: Record<string, unknown>;
+  window_start: string;
+  window_end: string;
+  issued_at: string;
+  issuer_did: string;
+  signature: string;
+  revoked: boolean;
+  revoked_at?: string;
 }
 
-export interface CredentialVerification {
-  valid: boolean;
-  reason: string;
-  credential?: Record<string, unknown>;
-}
+export function submitReceipt(client: CoinPayClient, receipt: ReceiptInput): Promise<{ success: boolean; receipt?: Record<string, unknown>; error?: string }>;
+export function getReputation(client: CoinPayClient, agentDid: string): Promise<{ success: boolean; reputation: ReputationResult }>;
+export function getCredential(client: CoinPayClient, credentialId: string): Promise<{ success: boolean; credential: Credential }>;
+export function verifyCredential(client: CoinPayClient, credential: { credential_id: string }): Promise<{ valid: boolean; reason?: string }>;
+export function getRevocationList(client: CoinPayClient): Promise<{ success: boolean; revoked_credentials: string[]; revocations: Array<Record<string, unknown>> }>;
 
-export interface RevocationList {
-  revoked: string[];
-  details: Array<{ credential_id: string; reason: string; revoked_at: string }>;
+export interface DidInfo {
+  did: string;
+  public_key: string;
+  verified: boolean;
+  created_at: string;
 }
 
-export function submitReceipt(client: CoinPayClient, receipt: TaskReceipt): Promise<{ id: string; verified_signatures: string[] }>;
-export function getReputation(client: CoinPayClient, agentDid: string): Promise<MultiWindowReputation>;
-export function getCredential(client: CoinPayClient, credentialId: string): Promise<Record<string, unknown>>;
-export function verifyCredential(client: CoinPayClient, credentialId: string): Promise<CredentialVerification>;
-export function getRevocationList(client: CoinPayClient): Promise<RevocationList>;
+export function getMyDid(client: CoinPayClient): Promise<DidInfo>;
+export function claimDid(client: CoinPayClient): Promise<DidInfo>;
+export function linkDid(client: CoinPayClient, params: { did: string; publicKey: string; signature: string }): Promise<DidInfo>;

package/src/reputation.js

@@ -1,51 +1,104 @@
 /**
  * Reputation SDK Module
  *
- * Submit receipts, query reputation, verify credentials.
+ * Query and submit reputation data for the CoinPayPortal Reputation Protocol (CPR).
  *
  * @example
  * import { CoinPayClient } from '@profullstack/coinpay';
- * const client = new CoinPayClient({ apiKey: 'your-key' });
- *
- * // Submit a task receipt
- * const result = await client.submitReceipt({ ... });
- *
- * // Get agent reputation
- * const rep = await client.getReputation('did:web:agent.example.com');
+ * import { submitReceipt, getReputation } from '@profullstack/coinpay/reputation';
  */
 
 /**
  * Submit a task receipt
+ * @param {import('./client.js').CoinPayClient} client
+ * @param {Object} receipt - Receipt data
+ * @returns {Promise<Object>}
  */
 export async function submitReceipt(client, receipt) {
-  return client._request('POST', '/api/reputation/receipt', receipt);
+  return client.request('/reputation/receipt', {
+    method: 'POST',
+    body: JSON.stringify(receipt),
+  });
 }
 
 /**
- * Get aggregated reputation for an agent DID
+ * Get reputation for an agent DID
+ * @param {import('./client.js').CoinPayClient} client
+ * @param {string} agentDid
+ * @returns {Promise<Object>}
  */
 export async function getReputation(client, agentDid) {
-  const encoded = encodeURIComponent(agentDid);
-  return client._request('GET', `/api/reputation/agent/${encoded}/reputation`);
+  return client.request(`/reputation/agent/${encodeURIComponent(agentDid)}/reputation`);
 }
 
 /**
- * Get a specific credential by ID
+ * Get a specific credential
+ * @param {import('./client.js').CoinPayClient} client
+ * @param {string} credentialId
+ * @returns {Promise<Object>}
  */
 export async function getCredential(client, credentialId) {
-  return client._request('GET', `/api/reputation/credential/${credentialId}`);
+  return client.request(`/reputation/credential/${credentialId}`);
 }
 
 /**
  * Verify a credential
+ * @param {import('./client.js').CoinPayClient} client
+ * @param {Object} credential - { credential_id: string }
+ * @returns {Promise<{valid: boolean, reason?: string}>}
  */
-export async function verifyCredential(client, credentialId) {
-  return client._request('POST', '/api/reputation/verify', { credential_id: credentialId });
+export async function verifyCredential(client, credential) {
+  return client.request('/reputation/verify', {
+    method: 'POST',
+    body: JSON.stringify(credential),
+  });
 }
 
 /**
  * Get the revocation list
+ * @param {import('./client.js').CoinPayClient} client
+ * @returns {Promise<Object>}
  */
 export async function getRevocationList(client) {
-  return client._request('GET', '/api/reputation/revocation-list');
+  return client.request('/reputation/revocation-list');
+}
+
+/**
+ * Get the authenticated merchant's DID
+ * @param {import('./client.js').CoinPayClient} client
+ * @returns {Promise<Object>}
+ */
+export async function getMyDid(client) {
+  return client.request('/reputation/did/me');
+}
+
+/**
+ * Claim (auto-generate) a new DID for the authenticated merchant
+ * @param {import('./client.js').CoinPayClient} client
+ * @returns {Promise<Object>}
+ */
+export async function claimDid(client) {
+  return client.request('/reputation/did/claim', {
+    method: 'POST',
+  });
+}
+
+/**
+ * Link an existing DID to the authenticated merchant
+ * @param {import('./client.js').CoinPayClient} client
+ * @param {Object} params
+ * @param {string} params.did - The DID to link
+ * @param {string} params.publicKey - Base64url-encoded public key
+ * @param {string} params.signature - Base64url-encoded signature
+ * @returns {Promise<Object>}
+ */
+export async function linkDid(client, { did, publicKey, signature }) {
+  return client.request('/reputation/did/claim', {
+    method: 'POST',
+    body: JSON.stringify({
+      did,
+      public_key: publicKey,
+      signature,
+    }),
+  });
 }