@xpr-agents/sdk 0.1.0

package/dist/utils.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTrustScore = calculateTrustScore;
+exports.getTrustRating = getTrustRating;
+exports.validationResultFromNumber = validationResultFromNumber;
+exports.validationResultToNumber = validationResultToNumber;
+exports.disputeStatusFromNumber = disputeStatusFromNumber;
+exports.safeJsonParse = safeJsonParse;
+exports.parseCapabilities = parseCapabilities;
+exports.parseSpecializations = parseSpecializations;
+exports.parseTags = parseTags;
+exports.formatXpr = formatXpr;
+exports.parseXpr = parseXpr;
+exports.safeParseInt = safeParseInt;
+exports.formatTimestamp = formatTimestamp;
+exports.calculateWeightedAverage = calculateWeightedAverage;
+exports.isValidAccountName = isValidAccountName;
+exports.isValidUrl = isValidUrl;
+exports.getKycWeight = getKycWeight;
+/**
+ * Calculate trust score for an agent
+ * Combines KYC level, stake, reputation, and longevity
+ * @param agent - Agent data
+ * @param agentScore - Aggregated score from feedback
+ * @param kycLevel - KYC verification level (0-4)
+ * @param stakeAmount - Staked XPR in smallest units (optional, fetched from system staking)
+ */
+function calculateTrustScore(agent, agentScore, kycLevel, stakeAmount = 0) {
+    const breakdown = {
+        kyc: 0,
+        stake: 0,
+        reputation: 0,
+        longevity: 0,
+    };
+    // KYC score (0-30 points)
+    // Level 0 = 0, Level 1 = 10, Level 2 = 20, Level 3 = 30
+    breakdown.kyc = Math.min(kycLevel * 10, 30);
+    // Stake score (0-20 points, caps at 10000 XPR)
+    // Every 500 XPR = 1 point, max 20 points
+    const stakeXpr = stakeAmount / 10000; // Convert from smallest unit
+    breakdown.stake = Math.min(Math.floor(stakeXpr / 500), 20);
+    // Reputation score (0-40 points)
+    if (agentScore && agentScore.total_weight > 0) {
+        // avg_score is 0-10000 (representing 0-100.00%)
+        // We need to convert to 0-40 points
+        // If avg_score is 10000 (100%), that means perfect 5/5 rating
+        breakdown.reputation = Math.floor((agentScore.avg_score / 10000) * 40);
+    }
+    // Longevity score (0-10 points, 1 point per month)
+    const now = Math.floor(Date.now() / 1000);
+    const monthsActive = Math.floor((now - agent.registered_at) / (30 * 24 * 60 * 60));
+    breakdown.longevity = Math.min(monthsActive, 10);
+    // Total score (0-100)
+    const total = breakdown.kyc + breakdown.stake + breakdown.reputation + breakdown.longevity;
+    return {
+        agent: agent.account,
+        total,
+        breakdown,
+        rating: getTrustRating(total),
+    };
+}
+/**
+ * Get trust rating label from numeric score
+ */
+function getTrustRating(score) {
+    if (score >= 80)
+        return 'verified';
+    if (score >= 60)
+        return 'high';
+    if (score >= 40)
+        return 'medium';
+    if (score >= 20)
+        return 'low';
+    return 'untrusted';
+}
+/**
+ * Convert validation result number to string
+ */
+function validationResultFromNumber(result) {
+    switch (result) {
+        case 0:
+            return 'fail';
+        case 1:
+            return 'pass';
+        case 2:
+            return 'partial';
+        default:
+            return 'fail';
+    }
+}
+/**
+ * Convert validation result string to number
+ */
+function validationResultToNumber(result) {
+    switch (result) {
+        case 'fail':
+            return 0;
+        case 'pass':
+            return 1;
+        case 'partial':
+            return 2;
+        default:
+            return 0;
+    }
+}
+/**
+ * Convert dispute status number to string
+ */
+function disputeStatusFromNumber(status) {
+    switch (status) {
+        case 0:
+            return 'pending';
+        case 1:
+            return 'upheld';
+        case 2:
+            return 'rejected';
+        case 3:
+            return 'cancelled';
+        default:
+            return 'pending';
+    }
+}
+/**
+ * Parse JSON safely with fallback
+ */
+function safeJsonParse(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Parse capabilities string to array
+ */
+function parseCapabilities(capabilities) {
+    if (!capabilities)
+        return [];
+    return safeJsonParse(capabilities, []);
+}
+/**
+ * Parse specializations string to array
+ */
+function parseSpecializations(specializations) {
+    if (!specializations)
+        return [];
+    return safeJsonParse(specializations, []);
+}
+/**
+ * Parse tags string to array (comma-separated)
+ */
+function parseTags(tags) {
+    if (!tags)
+        return [];
+    return tags.split(',').map((t) => t.trim()).filter((t) => t.length > 0);
+}
+/**
+ * Format XPR amount from smallest unit
+ */
+function formatXpr(amount) {
+    return (amount / 10000).toFixed(4) + ' XPR';
+}
+/**
+ * Parse XPR amount string to smallest unit (integer math to avoid float precision issues)
+ * "100.5000 XPR" → 1005000, "0.7000 XPR" → 7000
+ */
+function parseXpr(amount) {
+    const match = amount.match(/^(\d+)(?:\.(\d{1,4}))?/);
+    if (!match)
+        return 0;
+    const whole = parseInt(match[1], 10) || 0;
+    const fracStr = (match[2] || '').padEnd(4, '0').slice(0, 4);
+    const frac = parseInt(fracStr, 10) || 0;
+    return whole * 10000 + frac;
+}
+/**
+ * Safe parseInt with fallback - returns fallback on NaN
+ */
+function safeParseInt(value, fallback = 0) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? fallback : parsed;
+}
+/**
+ * Format timestamp to ISO string
+ */
+function formatTimestamp(timestamp) {
+    return new Date(timestamp * 1000).toISOString();
+}
+/**
+ * Calculate weighted average score
+ */
+function calculateWeightedAverage(scores) {
+    if (scores.length === 0)
+        return 0;
+    let totalScore = 0;
+    let totalWeight = 0;
+    for (const { score, weight } of scores) {
+        totalScore += score * weight;
+        totalWeight += weight;
+    }
+    if (totalWeight === 0)
+        return 0;
+    return totalScore / totalWeight;
+}
+/**
+ * Validate XPR account name
+ * Must be 1-12 characters, a-z, 1-5, and .
+ */
+function isValidAccountName(name) {
+    if (!name || name.length > 12)
+        return false;
+    return /^[a-z1-5.]+$/.test(name);
+}
+/**
+ * Validate URL format
+ */
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get KYC level weight for feedback scoring
+ */
+function getKycWeight(kycLevel) {
+    return 1 + kycLevel;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Agent,\n  AgentScore,\n  TrustScore,\n  TrustScoreBreakdown,\n  TrustRating,\n  ValidationResult,\n  DisputeStatus,\n} from './types';\n\n/**\n * Calculate trust score for an agent\n * Combines KYC level, stake, reputation, and longevity\n * @param agent - Agent data\n * @param agentScore - Aggregated score from feedback\n * @param kycLevel - KYC verification level (0-4)\n * @param stakeAmount - Staked XPR in smallest units (optional, fetched from system staking)\n */\nexport function calculateTrustScore(\n  agent: Agent,\n  agentScore: AgentScore | null,\n  kycLevel: number,\n  stakeAmount: number = 0\n): TrustScore {\n  const breakdown: TrustScoreBreakdown = {\n    kyc: 0,\n    stake: 0,\n    reputation: 0,\n    longevity: 0,\n  };\n\n  // KYC score (0-30 points)\n  // Level 0 = 0, Level 1 = 10, Level 2 = 20, Level 3 = 30\n  breakdown.kyc = Math.min(kycLevel * 10, 30);\n\n  // Stake score (0-20 points, caps at 10000 XPR)\n  // Every 500 XPR = 1 point, max 20 points\n  const stakeXpr = stakeAmount / 10000; // Convert from smallest unit\n  breakdown.stake = Math.min(Math.floor(stakeXpr / 500), 20);\n\n  // Reputation score (0-40 points)\n  if (agentScore && agentScore.total_weight > 0) {\n    // avg_score is 0-10000 (representing 0-100.00%)\n    // We need to convert to 0-40 points\n    // If avg_score is 10000 (100%), that means perfect 5/5 rating\n    breakdown.reputation = Math.floor((agentScore.avg_score / 10000) * 40);\n  }\n\n  // Longevity score (0-10 points, 1 point per month)\n  const now = Math.floor(Date.now() / 1000);\n  const monthsActive = Math.floor((now - agent.registered_at) / (30 * 24 * 60 * 60));\n  breakdown.longevity = Math.min(monthsActive, 10);\n\n  // Total score (0-100)\n  const total = breakdown.kyc + breakdown.stake + breakdown.reputation + breakdown.longevity;\n\n  return {\n    agent: agent.account,\n    total,\n    breakdown,\n    rating: getTrustRating(total),\n  };\n}\n\n/**\n * Get trust rating label from numeric score\n */\nexport function getTrustRating(score: number): TrustRating {\n  if (score >= 80) return 'verified';\n  if (score >= 60) return 'high';\n  if (score >= 40) return 'medium';\n  if (score >= 20) return 'low';\n  return 'untrusted';\n}\n\n/**\n * Convert validation result number to string\n */\nexport function validationResultFromNumber(result: number): ValidationResult {\n  switch (result) {\n    case 0:\n      return 'fail';\n    case 1:\n      return 'pass';\n    case 2:\n      return 'partial';\n    default:\n      return 'fail';\n  }\n}\n\n/**\n * Convert validation result string to number\n */\nexport function validationResultToNumber(result: ValidationResult): number {\n  switch (result) {\n    case 'fail':\n      return 0;\n    case 'pass':\n      return 1;\n    case 'partial':\n      return 2;\n    default:\n      return 0;\n  }\n}\n\n/**\n * Convert dispute status number to string\n */\nexport function disputeStatusFromNumber(status: number): DisputeStatus {\n  switch (status) {\n    case 0:\n      return 'pending';\n    case 1:\n      return 'upheld';\n    case 2:\n      return 'rejected';\n    case 3:\n      return 'cancelled';\n    default:\n      return 'pending';\n  }\n}\n\n/**\n * Parse JSON safely with fallback\n */\nexport function safeJsonParse<T>(json: string, fallback: T): T {\n  try {\n    return JSON.parse(json) as T;\n  } catch {\n    return fallback;\n  }\n}\n\n/**\n * Parse capabilities string to array\n */\nexport function parseCapabilities(capabilities: string): string[] {\n  if (!capabilities) return [];\n  return safeJsonParse<string[]>(capabilities, []);\n}\n\n/**\n * Parse specializations string to array\n */\nexport function parseSpecializations(specializations: string): string[] {\n  if (!specializations) return [];\n  return safeJsonParse<string[]>(specializations, []);\n}\n\n/**\n * Parse tags string to array (comma-separated)\n */\nexport function parseTags(tags: string): string[] {\n  if (!tags) return [];\n  return tags.split(',').map((t) => t.trim()).filter((t) => t.length > 0);\n}\n\n/**\n * Format XPR amount from smallest unit\n */\nexport function formatXpr(amount: number): string {\n  return (amount / 10000).toFixed(4) + ' XPR';\n}\n\n/**\n * Parse XPR amount string to smallest unit (integer math to avoid float precision issues)\n * \"100.5000 XPR\" → 1005000, \"0.7000 XPR\" → 7000\n */\nexport function parseXpr(amount: string): number {\n  const match = amount.match(/^(\\d+)(?:\\.(\\d{1,4}))?/);\n  if (!match) return 0;\n  const whole = parseInt(match[1], 10) || 0;\n  const fracStr = (match[2] || '').padEnd(4, '0').slice(0, 4);\n  const frac = parseInt(fracStr, 10) || 0;\n  return whole * 10000 + frac;\n}\n\n/**\n * Safe parseInt with fallback - returns fallback on NaN\n */\nexport function safeParseInt(value: string | undefined | null, fallback: number = 0): number {\n  if (value === undefined || value === null || value === '') return fallback;\n  const parsed = parseInt(value, 10);\n  return isNaN(parsed) ? fallback : parsed;\n}\n\n/**\n * Format timestamp to ISO string\n */\nexport function formatTimestamp(timestamp: number): string {\n  return new Date(timestamp * 1000).toISOString();\n}\n\n/**\n * Calculate weighted average score\n */\nexport function calculateWeightedAverage(\n  scores: Array<{ score: number; weight: number }>\n): number {\n  if (scores.length === 0) return 0;\n\n  let totalScore = 0;\n  let totalWeight = 0;\n\n  for (const { score, weight } of scores) {\n    totalScore += score * weight;\n    totalWeight += weight;\n  }\n\n  if (totalWeight === 0) return 0;\n  return totalScore / totalWeight;\n}\n\n/**\n * Validate XPR account name\n * Must be 1-12 characters, a-z, 1-5, and .\n */\nexport function isValidAccountName(name: string): boolean {\n  if (!name || name.length > 12) return false;\n  return /^[a-z1-5.]+$/.test(name);\n}\n\n/**\n * Validate URL format\n */\nexport function isValidUrl(url: string): boolean {\n  try {\n    new URL(url);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Get KYC level weight for feedback scoring\n */\nexport function getKycWeight(kycLevel: number): number {\n  return 1 + kycLevel;\n}\n"]}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@xpr-agents/sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for XPR Network Trustless Agent Registry - register agents, submit feedback, validate outputs, and manage escrow jobs",
+  "author": "XPR Network",
+  "license": "MIT",
+  "homepage": "https://github.com/XPRNetwork/xpr-agents#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XPRNetwork/xpr-agents.git",
+    "directory": "sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/XPRNetwork/xpr-agents/issues"
+  },
+  "keywords": [
+    "xpr",
+    "xpr-network",
+    "proton",
+    "blockchain",
+    "agents",
+    "ai-agents",
+    "registry",
+    "reputation",
+    "validation",
+    "escrow",
+    "trustless"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts"
+  },
+  "dependencies": {
+    "@proton/js": "^28.1.2"
+  },
+  "peerDependencies": {
+    "@proton/web-sdk": "^4.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@proton/web-sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@proton/web-sdk": "^4.4.1",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  }
+}