@profullstack/coinpay 0.4.16 → 0.5.1

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,156 @@ 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;
+    }
+
+    default:
+      print.error(`Unknown reputation command: ${subcommand}`);
+      print.info('Available: submit, query, credential, verify, revocations');
+      process.exit(1);
+  }
+}
+
 /**
  * Main entry point
  */
@@ -1626,6 +1783,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.4.16",
+  "version": "0.5.1",
   "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

@@ -96,5 +96,20 @@ export type {
   SwapHistoryResult,
 } from './swap.js';
 
+// Reputation exports
+export {
+  submitReceipt,
+  getReputation,
+  getCredential,
+  verifyCredential,
+  getRevocationList,
+} from './reputation.js';
+export type {
+  ReceiptInput,
+  ReputationWindow,
+  ReputationResult,
+  Credential,
+} from './reputation.js';
+
 import { CoinPayClient } from './client.js';
 export default CoinPayClient;

package/src/index.js

@@ -78,6 +78,15 @@ import {
 } from './wallet.js';
 
 // Swap exports
+// Reputation exports
+import {
+  submitReceipt,
+  getReputation,
+  getCredential,
+  verifyCredential,
+  getRevocationList,
+} from './reputation.js';
+
 import {
   SwapClient,
   SwapCoins,
@@ -134,6 +143,13 @@ export {
   PaymentStatus,
   FiatCurrency,
   
+  // Reputation
+  submitReceipt,
+  getReputation,
+  getCredential,
+  verifyCredential,
+  getRevocationList,
+  
   // Webhook utilities
   verifyWebhookSignature,
   generateWebhookSignature,

package/src/reputation.d.ts

@@ -0,0 +1,71 @@
+import { CoinPayClient } from './client';
+
+export interface ReceiptInput {
+  receipt_id: string;
+  task_id: string;
+  agent_did: string;
+  buyer_did: string;
+  platform_did?: string;
+  escrow_tx?: string;
+  amount?: number;
+  currency?: string;
+  category?: string;
+  sla?: Record<string, unknown>;
+  outcome: 'accepted' | 'rejected' | 'disputed';
+  dispute?: boolean;
+  artifact_hash?: string;
+  signatures: {
+    escrow_sig: string;
+    agent_sig?: string;
+    buyer_sig?: string;
+    arbitration_sig?: string;
+  };
+  finalized_at?: string;
+}
+
+export interface ReputationWindow {
+  task_count: number;
+  accepted_count: number;
+  disputed_count: number;
+  total_volume: 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: {
+    flagged: boolean;
+    flags: string[];
+    adjusted_weight: number;
+  };
+}
+
+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 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>> }>;

package/src/reputation.js

@@ -0,0 +1,64 @@
+/**
+ * Reputation SDK Module
+ *
+ * Query and submit reputation data for the CoinPayPortal Reputation Protocol (CPR).
+ *
+ * @example
+ * import { CoinPayClient } from '@profullstack/coinpay';
+ * 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('/reputation/receipt', {
+    method: 'POST',
+    body: JSON.stringify(receipt),
+  });
+}
+
+/**
+ * Get reputation for an agent DID
+ * @param {import('./client.js').CoinPayClient} client
+ * @param {string} agentDid
+ * @returns {Promise<Object>}
+ */
+export async function getReputation(client, agentDid) {
+  return client.request(`/reputation/agent/${encodeURIComponent(agentDid)}/reputation`);
+}
+
+/**
+ * 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(`/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, 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('/reputation/revocation-list');
+}