@ghostspeak/sdk 2.0.6 → 2.0.7

package/dist/browser.js

@@ -1,846 +1,19 @@
-export { WorkOrderModule } from './chunk-ZWOYNHVK.js';
-import { BaseModule } from './chunk-TVVGXYCI.js';
-export { AgentModule, ChannelModule, EscrowModule, GHOSTSPEAK_PROGRAM_ID, GovernanceModule, MarketplaceModule, NETWORK_CONFIG, Token2022Module } from './chunk-TVVGXYCI.js';
-import { REPUTATION_CONSTANTS } from './chunk-OWYHJG6H.js';
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BadgeType, NATIVE_MINT_ADDRESS, REPUTATION_CONSTANTS, ReputationTier, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS } from './chunk-OWYHJG6H.js';
-import { getInitializeStakingConfigInstructionAsync, getCreateStakingAccountInstructionAsync, getClaimStakingRewardsInstructionAsync } from './chunk-COGZFWOT.js';
-import './chunk-GMHIUK2R.js';
-export { deriveAgentPda, deriveAgentPdaOriginal, deriveChannelPda, deriveEscrowPda, deriveJobPostingPda, deriveMessagePda, deriveServiceListingPda, deriveUserRegistryPda } from './chunk-ASQXX4IT.js';
-import './chunk-RERCHKZP.js';
-import './chunk-RDDPOFR5.js';
+export { GHOSTSPEAK_PROGRAM_ID, NETWORK_CONFIG } from './chunk-TTB4OS2D.js';
+import { init_MultiSourceAggregator } from './chunk-SZGFSCNU.js';
+export { AgentModule, CredentialModule as CredentialsModule, GovernanceModule, MultisigModule, PayAIClient, ReputationModule, StakingModule } from './chunk-SZGFSCNU.js';
+export { deriveAgentPda, deriveUserRegistryPda } from './chunk-BF3IQ35I.js';
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BadgeType, NATIVE_MINT_ADDRESS, REPUTATION_CONSTANTS, ReputationTier, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS } from './chunk-C5CDA3WX.js';
+import './chunk-S74EH3KD.js';
+import './chunk-IHVDQ4YI.js';
+import './chunk-SFTSZ3LC.js';
+import './chunk-JV2SWONF.js';
+import './chunk-KB6CKIUK.js';
+import './chunk-AL3HQN73.js';
 import './chunk-SRS2SKFS.js';
-import './chunk-NSBPE2FW.js';
-import { getProgramDerivedAddress, getBytesEncoder, getAddressEncoder, getUtf8Encoder } from '@solana/kit';
+import './chunk-UP2VWCW5.js';
+import 'crypto';
 
-var LockupTier = /* @__PURE__ */ ((LockupTier2) => {
-  LockupTier2[LockupTier2["None"] = 0] = "None";
-  LockupTier2[LockupTier2["OneMonth"] = 1] = "OneMonth";
-  LockupTier2[LockupTier2["ThreeMonths"] = 2] = "ThreeMonths";
-  LockupTier2[LockupTier2["SixMonths"] = 3] = "SixMonths";
-  LockupTier2[LockupTier2["OneYear"] = 4] = "OneYear";
-  LockupTier2[LockupTier2["TwoYears"] = 5] = "TwoYears";
-  return LockupTier2;
-})(LockupTier || {});
-var StakingModule = class extends BaseModule {
-  /**
-   * Derive staking account PDA for a user
-   * Seeds: ["staking", owner]
-   */
-  async deriveStakingAccountPda(owner) {
-    const [pda] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new TextEncoder().encode("staking")),
-        getAddressEncoder().encode(owner)
-      ]
-    });
-    return pda;
-  }
-  /**
-   * Derive staking config PDA
-   * Seeds: ["staking_config"]
-   */
-  async deriveStakingConfigPda() {
-    const [pda] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new TextEncoder().encode("staking_config"))
-      ]
-    });
-    return pda;
-  }
-  /**
-   * Initialize staking configuration (admin only)
-   */
-  async initializeConfig(params) {
-    const instructionGetter = async () => {
-      return getInitializeStakingConfigInstructionAsync({
-        authority: params.signer,
-        ghostTokenMint: params.ghostTokenMint,
-        rewardsTreasury: params.rewardsTreasury,
-        baseApy: params.baseApy,
-        minStakeAmount: params.minStakeAmount,
-        maxStakeAmount: params.maxStakeAmount
-      });
-    };
-    return this.execute("initializeStakingConfig", instructionGetter, [params.signer]);
-  }
-  /**
-   * Create a staking account for a user
-   */
-  async createStakingAccount(params) {
-    const instructionGetter = async () => {
-      return getCreateStakingAccountInstructionAsync({
-        owner: params.signer
-      });
-    };
-    return this.execute("createStakingAccount", instructionGetter, [params.signer]);
-  }
-  /**
-   * Claim staking rewards
-   */
-  async claimRewards(params) {
-    const instructionGetter = async () => {
-      return getClaimStakingRewardsInstructionAsync({
-        owner: params.signer,
-        ghostMint: params.ghostMint,
-        userTokenAccount: params.userTokenAccount,
-        rewardsTreasury: params.rewardsTreasury
-      });
-    };
-    return this.execute("claimStakingRewards", instructionGetter, [params.signer]);
-  }
-  /**
-   * Get staking account for a user
-   */
-  async getStakingAccount(owner) {
-    const stakingAccountAddress = await this.deriveStakingAccountPda(owner);
-    return this.getAccount(stakingAccountAddress, "StakingAccount");
-  }
-  /**
-   * Get staking account by address
-   */
-  async getStakingAccountByAddress(address) {
-    return this.getAccount(address, "StakingAccount");
-  }
-  /**
-   * Get all staking accounts
-   */
-  async getAllStakingAccounts() {
-    return this.getProgramAccounts("StakingAccount");
-  }
-  /**
-   * Get staking config
-   */
-  async getStakingConfig() {
-    const configAddress = await this.deriveStakingConfigPda();
-    return this.getAccount(configAddress, "StakingConfig");
-  }
-  /**
-   * Calculate pending rewards for a staking account
-   */
-  calculatePendingRewards(stakingAccount, config) {
-    const now = BigInt(Math.floor(Date.now() / 1e3));
-    const timeSinceLastClaim = now - stakingAccount.lastClaimAt;
-    const baseReward = stakingAccount.stakedAmount * BigInt(config.baseApy) * timeSinceLastClaim / BigInt(365 * 24 * 60 * 60 * 1e4);
-    const tierBonus = this.getTierBonusApy(stakingAccount.lockupTier, config);
-    const bonusReward = stakingAccount.stakedAmount * BigInt(tierBonus) * timeSinceLastClaim / BigInt(365 * 24 * 60 * 60 * 1e4);
-    return baseReward + bonusReward + stakingAccount.pendingRewards;
-  }
-  /**
-   * Get tier bonus APY in basis points
-   */
-  getTierBonusApy(tier, config) {
-    if (config.tierBonusApy && tier < config.tierBonusApy.length) {
-      return config.tierBonusApy[tier];
-    }
-    return 0;
-  }
-  /**
-   * Get lockup duration in seconds for a tier
-   */
-  getLockupDuration(tier) {
-    const durations = {
-      [0 /* None */]: 0,
-      [1 /* OneMonth */]: 30 * 24 * 60 * 60,
-      [2 /* ThreeMonths */]: 90 * 24 * 60 * 60,
-      [3 /* SixMonths */]: 180 * 24 * 60 * 60,
-      [4 /* OneYear */]: 365 * 24 * 60 * 60,
-      [5 /* TwoYears */]: 730 * 24 * 60 * 60
-    };
-    return durations[tier] || 0;
-  }
-  /**
-   * Check if a staking account is locked
-   */
-  isLocked(stakingAccount) {
-    const now = BigInt(Math.floor(Date.now() / 1e3));
-    return stakingAccount.lockupEndsAt > now;
-  }
-  /**
-   * Get time remaining on lockup in seconds
-   */
-  getLockupTimeRemaining(stakingAccount) {
-    const now = BigInt(Math.floor(Date.now() / 1e3));
-    if (stakingAccount.lockupEndsAt <= now) {
-      return 0;
-    }
-    return Number(stakingAccount.lockupEndsAt - now);
-  }
-};
-var DisputeResolution = /* @__PURE__ */ ((DisputeResolution2) => {
-  DisputeResolution2[DisputeResolution2["FavorComplainant"] = 0] = "FavorComplainant";
-  DisputeResolution2[DisputeResolution2["FavorRespondent"] = 1] = "FavorRespondent";
-  DisputeResolution2[DisputeResolution2["Split"] = 2] = "Split";
-  DisputeResolution2[DisputeResolution2["Dismissed"] = 3] = "Dismissed";
-  return DisputeResolution2;
-})(DisputeResolution || {});
-var DisputeModule = class extends BaseModule {
-  /**
-   * Derive dispute case PDA
-   * Seeds: ["dispute", transaction_address, complainant, reason]
-   */
-  async deriveDisputePda(transactionAddress, complainant, reason) {
-    const [pda] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new TextEncoder().encode("dispute")),
-        getAddressEncoder().encode(transactionAddress),
-        getAddressEncoder().encode(complainant),
-        getUtf8Encoder().encode(reason)
-      ]
-    });
-    return pda;
-  }
-  /**
-   * Get dispute case by address
-   */
-  async getDisputeCase(address) {
-    return this.getAccount(address, "DisputeCase");
-  }
-  /**
-   * Get all disputes
-   */
-  async getAllDisputes() {
-    return this.getProgramAccounts("DisputeCase");
-  }
-  /**
-   * Get disputes by complainant
-   */
-  async getDisputesByComplainant(complainant) {
-    const allDisputes = await this.getAllDisputes();
-    return allDisputes.filter((d) => d.data.complainant === complainant);
-  }
-  /**
-   * Get disputes by respondent
-   */
-  async getDisputesByRespondent(respondent) {
-    const allDisputes = await this.getAllDisputes();
-    return allDisputes.filter((d) => d.data.respondent === respondent);
-  }
-  /**
-   * Get pending disputes (awaiting resolution)
-   */
-  async getPendingDisputes() {
-    const allDisputes = await this.getAllDisputes();
-    return allDisputes.filter(
-      (d) => !d.data.resolvedAt || d.data.resolvedAt.__option === "None"
-    );
-  }
-  /**
-   * Check if a dispute is resolved
-   */
-  isResolved(dispute) {
-    return dispute.resolvedAt !== null && dispute.resolvedAt.__option !== "None";
-  }
-  /**
-   * Get evidence count for a dispute
-   */
-  getEvidenceCount(dispute) {
-    return dispute.evidence?.length ?? 0;
-  }
-  /**
-   * Get AI confidence score (0-100)
-   */
-  getAiConfidence(dispute) {
-    return Math.round(dispute.aiScore * 100);
-  }
-  /**
-   * Check if dispute requires human review
-   */
-  requiresHumanReview(dispute) {
-    return dispute.humanReview || dispute.aiScore < 0.7;
-  }
-};
-
-// src/utils/reputation-calculator.ts
-var ReputationCalculator = class {
-  fraudPatterns = [];
-  constructor() {
-    this.initializeFraudPatterns();
-  }
-  /**
-   * Initialize fraud detection patterns
-   */
-  initializeFraudPatterns() {
-    this.fraudPatterns = [
-      {
-        patternId: "sudden_spike",
-        description: "Sudden spike in reputation without corresponding activity",
-        riskScore: 80,
-        detect: (data) => {
-          if (data.performanceHistory.length < 2) return false;
-          const recent = data.performanceHistory[data.performanceHistory.length - 1];
-          const previous = data.performanceHistory[data.performanceHistory.length - 2];
-          const spike = recent.score - previous.score;
-          return spike > 2e3 && recent.jobsCompleted === previous.jobsCompleted;
-        }
-      },
-      {
-        patternId: "perfect_scores_only",
-        description: "All jobs have perfect scores (potential manipulation)",
-        riskScore: 60,
-        detect: (data) => {
-          const recentJobs = data.performanceHistory.slice(-10);
-          return recentJobs.length >= 5 && recentJobs.every((job) => job.avgQuality === 100);
-        }
-      },
-      {
-        patternId: "rapid_category_switching",
-        description: "Rapid switching between unrelated categories",
-        riskScore: 40,
-        detect: (data) => {
-          if (data.categoryReputations.length < 5) return false;
-          const recentCategories = data.categoryReputations.sort((a, b) => b.lastActivity - a.lastActivity).slice(0, 5);
-          const daysSinceOldest = (Date.now() - recentCategories[4].lastActivity) / (1e3 * 60 * 60 * 24);
-          return daysSinceOldest < 7;
-        }
-      },
-      {
-        patternId: "dispute_pattern",
-        description: "High dispute rate with suspicious resolution pattern",
-        riskScore: 70,
-        detect: (data) => {
-          if (data.totalJobsCompleted < 10) return false;
-          const disputeRate = data.disputesAgainst / data.totalJobsCompleted;
-          const resolutionRate = data.disputesResolved / Math.max(1, data.disputesAgainst);
-          return disputeRate > 0.3 && resolutionRate > 0.9;
-        }
-      },
-      {
-        patternId: "time_manipulation",
-        description: "Completion times significantly below expected",
-        riskScore: 50,
-        detect: (data, job) => {
-          return job.actualDuration < job.expectedDuration * 0.1;
-        }
-      }
-    ];
-  }
-  /**
-   * Calculate reputation update based on job performance
-   */
-  calculateReputation(currentData, jobPerformance) {
-    const decayedData = this.applyTimeDecay(currentData);
-    const jobScore = this.calculateWeightedScore(decayedData.factors, jobPerformance);
-    const categoryUpdate = this.updateCategoryReputation(
-      decayedData.categoryReputations,
-      jobPerformance,
-      jobScore
-    );
-    const overallScore = this.calculateOverallScore(categoryUpdate.categories);
-    const tier = this.getTierFromScore(overallScore);
-    const newBadges = this.checkBadgeAchievements(
-      decayedData,
-      jobPerformance,
-      overallScore
-    );
-    const fraudAnalysis = this.detectFraud(decayedData, jobPerformance);
-    return {
-      overallScore,
-      jobScore,
-      categoryScore: categoryUpdate.categoryScore,
-      tier,
-      newBadges,
-      fraudDetected: fraudAnalysis.detected,
-      fraudRiskScore: fraudAnalysis.riskScore
-    };
-  }
-  /**
-   * Apply time-based reputation decay
-   */
-  applyTimeDecay(data) {
-    const currentTime = Date.now() / 1e3;
-    const daysSinceUpdate = (currentTime - data.lastUpdated) / 86400;
-    if (daysSinceUpdate <= 0) return data;
-    const decayFactor = REPUTATION_CONSTANTS.REPUTATION_DECAY_RATE_BPS * daysSinceUpdate;
-    const decayMultiplier = Math.max(0, 1e4 - decayFactor) / 1e4;
-    const decayedOverallScore = Math.floor(data.overallScore * decayMultiplier);
-    const decayedCategories = data.categoryReputations.map((category) => {
-      const categoryDaysInactive = (currentTime - category.lastActivity) / 86400;
-      const categoryDecay = REPUTATION_CONSTANTS.REPUTATION_DECAY_RATE_BPS * categoryDaysInactive;
-      const categoryMultiplier = Math.max(0, 1e4 - categoryDecay) / 1e4;
-      return {
-        ...category,
-        score: Math.floor(category.score * categoryMultiplier)
-      };
-    });
-    return {
-      ...data,
-      overallScore: decayedOverallScore,
-      categoryReputations: decayedCategories
-    };
-  }
-  /**
-   * Calculate weighted score based on job performance
-   */
-  calculateWeightedScore(factors, jobPerformance) {
-    const totalWeight = factors.completionWeight + factors.qualityWeight + factors.timelinessWeight + factors.satisfactionWeight + factors.disputeWeight;
-    if (totalWeight !== 100) {
-      throw new Error("Reputation factors must sum to 100");
-    }
-    const completionScore = jobPerformance.completed ? REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE : 0;
-    const qualityScore = jobPerformance.qualityRating * REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE / 100;
-    const timelinessScore = this.calculateTimelinessScore(
-      jobPerformance.expectedDuration,
-      jobPerformance.actualDuration
-    );
-    const satisfactionScore = jobPerformance.clientSatisfaction * REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE / 100;
-    const disputeScore = this.calculateDisputeScore(jobPerformance);
-    const weightedScore = (completionScore * factors.completionWeight + qualityScore * factors.qualityWeight + timelinessScore * factors.timelinessWeight + satisfactionScore * factors.satisfactionWeight + disputeScore * factors.disputeWeight) / 100;
-    return Math.min(weightedScore, REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE);
-  }
-  /**
-   * Calculate timeliness score based on expected vs actual duration
-   */
-  calculateTimelinessScore(expectedDuration, actualDuration) {
-    if (actualDuration <= expectedDuration) {
-      return REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE;
-    }
-    const delayRatio = (actualDuration - expectedDuration) * 1e4 / expectedDuration;
-    if (delayRatio > 5e3) {
-      return 0;
-    }
-    return REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE - REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE * delayRatio / 1e4;
-  }
-  /**
-   * Calculate dispute score
-   */
-  calculateDisputeScore(jobPerformance) {
-    if (!jobPerformance.hadDispute) {
-      return REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE;
-    }
-    if (jobPerformance.disputeResolvedFavorably) {
-      return REPUTATION_CONSTANTS.MAX_REPUTATION_SCORE / 2;
-    }
-    return 0;
-  }
-  /**
-   * Update category-specific reputation
-   */
-  updateCategoryReputation(categories, jobPerformance, jobScore) {
-    const existingCategoryIndex = categories.findIndex(
-      (c) => c.category === jobPerformance.category
-    );
-    if (existingCategoryIndex !== -1) {
-      const category = categories[existingCategoryIndex];
-      const updatedCategory = {
-        ...category,
-        completedJobs: category.completedJobs + 1,
-        qualitySum: category.qualitySum + jobPerformance.qualityRating,
-        qualityCount: category.qualityCount + 1,
-        totalEarnings: category.totalEarnings + jobPerformance.paymentAmount,
-        lastActivity: Date.now() / 1e3,
-        score: Math.floor((category.score * 7 + jobScore * 3) / 10),
-        // 70% existing, 30% new
-        avgCompletionTime: Math.floor(
-          (category.avgCompletionTime * category.completedJobs + jobPerformance.actualDuration) / (category.completedJobs + 1)
-        )
-      };
-      const newCategories = [...categories];
-      newCategories[existingCategoryIndex] = updatedCategory;
-      return { categories: newCategories, categoryScore: updatedCategory.score };
-    } else {
-      if (categories.length >= REPUTATION_CONSTANTS.MAX_REPUTATION_CATEGORIES) {
-        throw new Error("Maximum reputation categories reached");
-      }
-      const newCategory = {
-        category: jobPerformance.category,
-        score: jobScore,
-        completedJobs: 1,
-        avgCompletionTime: jobPerformance.actualDuration,
-        qualitySum: jobPerformance.qualityRating,
-        qualityCount: 1,
-        lastActivity: Date.now() / 1e3,
-        totalEarnings: jobPerformance.paymentAmount
-      };
-      return {
-        categories: [...categories, newCategory],
-        categoryScore: jobScore
-      };
-    }
-  }
-  /**
-   * Calculate overall score from category reputations
-   */
-  calculateOverallScore(categories) {
-    if (categories.length === 0) return 5e3;
-    let weightedSum = 0;
-    let totalWeight = 0;
-    for (const category of categories) {
-      const weight = category.completedJobs;
-      weightedSum += category.score * weight;
-      totalWeight += weight;
-    }
-    return totalWeight > 0 ? Math.floor(weightedSum / totalWeight) : 5e3;
-  }
-  /**
-   * Get reputation tier from score
-   */
-  getTierFromScore(score) {
-    if (score >= REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD) {
-      return "Platinum" /* Platinum */;
-    } else if (score >= REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD) {
-      return "Gold" /* Gold */;
-    } else if (score >= REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD) {
-      return "Silver" /* Silver */;
-    } else if (score >= REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD) {
-      return "Bronze" /* Bronze */;
-    } else {
-      return "None" /* None */;
-    }
-  }
-  /**
-   * Check for badge achievements
-   */
-  checkBadgeAchievements(data, jobPerformance, newScore) {
-    const newBadges = [];
-    const existingBadges = new Set(data.badges.map((b) => b.badgeType));
-    const newTotalJobs = data.totalJobsCompleted + (jobPerformance.completed ? 1 : 0);
-    if (!existingBadges.has("FirstJob" /* FirstJob */) && newTotalJobs >= 1) {
-      newBadges.push("FirstJob" /* FirstJob */);
-    }
-    if (!existingBadges.has("TenJobs" /* TenJobs */) && newTotalJobs >= 10) {
-      newBadges.push("TenJobs" /* TenJobs */);
-    }
-    if (!existingBadges.has("HundredJobs" /* HundredJobs */) && newTotalJobs >= 100) {
-      newBadges.push("HundredJobs" /* HundredJobs */);
-    }
-    if (!existingBadges.has("ThousandJobs" /* ThousandJobs */) && newTotalJobs >= 1e3) {
-      newBadges.push("ThousandJobs" /* ThousandJobs */);
-    }
-    if (!existingBadges.has("PerfectRating" /* PerfectRating */) && newScore >= 9500) {
-      newBadges.push("PerfectRating" /* PerfectRating */);
-    }
-    if (!existingBadges.has("QuickResponder" /* QuickResponder */) && data.avgResponseTime > 0 && data.avgResponseTime < 3600) {
-      newBadges.push("QuickResponder" /* QuickResponder */);
-    }
-    if (!existingBadges.has("DisputeResolver" /* DisputeResolver */) && data.disputesResolved >= 5) {
-      newBadges.push("DisputeResolver" /* DisputeResolver */);
-    }
-    if (!existingBadges.has("CategoryExpert" /* CategoryExpert */)) {
-      const hasExpertCategory = data.categoryReputations.some((c) => c.score >= 9e3);
-      if (hasExpertCategory) {
-        newBadges.push("CategoryExpert" /* CategoryExpert */);
-      }
-    }
-    if (!existingBadges.has("CrossCategoryMaster" /* CrossCategoryMaster */) && data.categoryReputations.length >= 5) {
-      newBadges.push("CrossCategoryMaster" /* CrossCategoryMaster */);
-    }
-    return newBadges;
-  }
-  /**
-   * Detect potential fraud patterns
-   */
-  detectFraud(data, jobPerformance) {
-    let totalRiskScore = 0;
-    const detectedPatterns = [];
-    for (const pattern of this.fraudPatterns) {
-      if (pattern.detect(data, jobPerformance)) {
-        totalRiskScore += pattern.riskScore;
-        detectedPatterns.push(pattern.patternId);
-      }
-    }
-    const normalizedRiskScore = Math.min(100, totalRiskScore);
-    return {
-      detected: normalizedRiskScore >= 50,
-      // Threshold for fraud detection
-      riskScore: normalizedRiskScore,
-      patterns: detectedPatterns
-    };
-  }
-  /**
-   * Create performance snapshot
-   */
-  createPerformanceSnapshot(data, newScore) {
-    const avgQuality = data.categoryReputations.length > 0 ? data.categoryReputations.reduce((sum, cat) => {
-      return sum + (cat.qualityCount > 0 ? cat.qualitySum / cat.qualityCount : 0);
-    }, 0) / data.categoryReputations.length : 0;
-    return {
-      timestamp: Date.now() / 1e3,
-      score: newScore,
-      jobsCompleted: data.totalJobsCompleted,
-      avgQuality: Math.floor(avgQuality)
-    };
-  }
-  /**
-   * Calculate reputation slash amount
-   */
-  calculateSlashAmount(currentScore, slashPercentage) {
-    if (slashPercentage > 5e3) {
-      throw new Error("Slash percentage cannot exceed 50%");
-    }
-    if (currentScore < REPUTATION_CONSTANTS.MIN_REPUTATION_FOR_SLASH) {
-      throw new Error("Reputation too low to slash");
-    }
-    const slashAmount = Math.floor(currentScore * slashPercentage / 1e4);
-    const newScore = Math.max(0, currentScore - slashAmount);
-    return { newScore, slashAmount };
-  }
-  /**
-   * Calculate staking bonus
-   */
-  calculateStakingBonus(stakeAmount) {
-    return Math.min(500, Math.floor(stakeAmount / 1e3));
-  }
-};
-
-// src/modules/reputation/ReputationModule.ts
-var ReputationModule = class extends BaseModule {
-  calculator;
-  constructor(config) {
-    super(config);
-    this.calculator = new ReputationCalculator();
-  }
-  /**
-   * Calculate reputation change for a job
-   */
-  calculateReputationChange(currentData, jobPerformance) {
-    return this.calculator.calculateReputation(currentData, jobPerformance);
-  }
-  /**
-   * Get tier name from tier enum
-   */
-  getTierName(tier) {
-    switch (tier) {
-      case "None" /* None */:
-        return "Unranked";
-      case "Bronze" /* Bronze */:
-        return "Bronze";
-      case "Silver" /* Silver */:
-        return "Silver";
-      case "Gold" /* Gold */:
-        return "Gold";
-      case "Platinum" /* Platinum */:
-        return "Platinum";
-      default:
-        return "Unknown";
-    }
-  }
-  /**
-   * Get tier from score
-   */
-  getTierFromScore(score) {
-    if (score >= REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD) {
-      return "Platinum" /* Platinum */;
-    } else if (score >= REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD) {
-      return "Gold" /* Gold */;
-    } else if (score >= REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD) {
-      return "Silver" /* Silver */;
-    } else if (score >= REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD) {
-      return "Bronze" /* Bronze */;
-    }
-    return "None" /* None */;
-  }
-  /**
-   * Get badge display name
-   */
-  getBadgeName(badge) {
-    switch (badge) {
-      case "FirstJob" /* FirstJob */:
-        return "First Job";
-      case "TenJobs" /* TenJobs */:
-        return "10 Jobs";
-      case "HundredJobs" /* HundredJobs */:
-        return "100 Jobs";
-      case "ThousandJobs" /* ThousandJobs */:
-        return "1000 Jobs";
-      case "PerfectRating" /* PerfectRating */:
-        return "Perfect Rating";
-      case "QuickResponder" /* QuickResponder */:
-        return "Quick Responder";
-      case "DisputeResolver" /* DisputeResolver */:
-        return "Dispute Resolver";
-      case "CategoryExpert" /* CategoryExpert */:
-        return "Category Expert";
-      case "CrossCategoryMaster" /* CrossCategoryMaster */:
-        return "Cross-Category Master";
-      default:
-        return "Unknown Badge";
-    }
-  }
-  /**
-   * Calculate estimated APY boost from reputation
-   */
-  calculateApyBoost(score) {
-    return Math.floor(score / 1e3) * 50;
-  }
-  /**
-   * Get reputation tier color for UI
-   */
-  getTierColor(tier) {
-    switch (tier) {
-      case "Platinum" /* Platinum */:
-        return "#E5E4E2";
-      // Platinum gray
-      case "Gold" /* Gold */:
-        return "#FFD700";
-      // Gold
-      case "Silver" /* Silver */:
-        return "#C0C0C0";
-      // Silver
-      case "Bronze" /* Bronze */:
-        return "#CD7F32";
-      // Bronze
-      default:
-        return "#808080";
-    }
-  }
-  /**
-   * Create default reputation data for new agents
-   */
-  createDefaultReputationData(agentAddress) {
-    return {
-      agent: agentAddress,
-      overallScore: 5e3,
-      // Start at 50%
-      totalJobsCompleted: 0,
-      totalJobsFailed: 0,
-      avgResponseTime: 0,
-      disputesAgainst: 0,
-      disputesResolved: 0,
-      lastUpdated: Math.floor(Date.now() / 1e3),
-      categoryReputations: [],
-      badges: [],
-      performanceHistory: [],
-      factors: {
-        completionWeight: 25,
-        qualityWeight: 25,
-        timelinessWeight: 20,
-        satisfactionWeight: 20,
-        disputeWeight: 10
-      }
-    };
-  }
-  /**
-   * Check if agent qualifies for a specific tier
-   */
-  qualifiesForTier(score, tier) {
-    switch (tier) {
-      case "Platinum" /* Platinum */:
-        return score >= REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD;
-      case "Gold" /* Gold */:
-        return score >= REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD;
-      case "Silver" /* Silver */:
-        return score >= REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD;
-      case "Bronze" /* Bronze */:
-        return score >= REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD;
-      default:
-        return true;
-    }
-  }
-  /**
-   * Calculate points needed for next tier
-   */
-  pointsToNextTier(score) {
-    const currentTier = this.getTierFromScore(score);
-    switch (currentTier) {
-      case "None" /* None */:
-        return { nextTier: "Bronze" /* Bronze */, pointsNeeded: REPUTATION_CONSTANTS.BRONZE_TIER_THRESHOLD - score };
-      case "Bronze" /* Bronze */:
-        return { nextTier: "Silver" /* Silver */, pointsNeeded: REPUTATION_CONSTANTS.SILVER_TIER_THRESHOLD - score };
-      case "Silver" /* Silver */:
-        return { nextTier: "Gold" /* Gold */, pointsNeeded: REPUTATION_CONSTANTS.GOLD_TIER_THRESHOLD - score };
-      case "Gold" /* Gold */:
-        return { nextTier: "Platinum" /* Platinum */, pointsNeeded: REPUTATION_CONSTANTS.PLATINUM_TIER_THRESHOLD - score };
-      case "Platinum" /* Platinum */:
-        return null;
-      // Already at max tier
-      default:
-        return null;
-    }
-  }
-};
-var AuctionType = /* @__PURE__ */ ((AuctionType2) => {
-  AuctionType2[AuctionType2["English"] = 0] = "English";
-  AuctionType2[AuctionType2["Dutch"] = 1] = "Dutch";
-  AuctionType2[AuctionType2["SealedBid"] = 2] = "SealedBid";
-  return AuctionType2;
-})(AuctionType || {});
-var AuctionModule = class extends BaseModule {
-  /**
-   * Derive auction PDA
-   * Seeds: ["auction", creator, auction_id]
-   */
-  async deriveAuctionPda(creator, auctionId) {
-    const [pda] = await getProgramDerivedAddress({
-      programAddress: this.programId,
-      seeds: [
-        getBytesEncoder().encode(new TextEncoder().encode("auction")),
-        getAddressEncoder().encode(creator),
-        getBytesEncoder().encode(new TextEncoder().encode(auctionId))
-      ]
-    });
-    return pda;
-  }
-  /**
-   * Get auction marketplace account
-   */
-  async getAuctionMarketplace(address) {
-    return this.getAccount(address, "AuctionMarketplace");
-  }
-  /**
-   * Get all auction marketplaces
-   */
-  async getAllAuctions() {
-    return this.getProgramAccounts("AuctionMarketplace");
-  }
-  /**
-   * Get auction by creator and ID
-   */
-  async getAuctionByCreatorAndId(creator, auctionId) {
-    const auctionAddress = await this.deriveAuctionPda(creator, auctionId);
-    return this.getAuctionMarketplace(auctionAddress);
-  }
-  /**
-   * Calculate time remaining in auction
-   */
-  getTimeRemaining(auction) {
-    const now = BigInt(Math.floor(Date.now() / 1e3));
-    if (auction.auctionEndTime <= now) {
-      return 0;
-    }
-    return Number(auction.auctionEndTime - now);
-  }
-  /**
-   * Check if auction has ended
-   */
-  hasEnded(auction) {
-    return this.getTimeRemaining(auction) === 0;
-  }
-  /**
-   * Get total bid count for an auction
-   */
-  getTotalBids(auction) {
-    return auction.totalBids;
-  }
-  /**
-   * Get auction metadata URI
-   */
-  getMetadataUri(auction) {
-    return auction.metadataUri;
-  }
-  /**
-   * Check if reserve price was met
-   */
-  isReserveMet(auction) {
-    return auction.reserveMet;
-  }
-  /**
-   * Get current winning price
-   */
-  getCurrentPrice(auction) {
-    return auction.currentPrice;
-  }
-  /**
-   * Get auctions by creator
-   */
-  async getAuctionsByCreator(creator) {
-    const allAuctions = await this.getAllAuctions();
-    return allAuctions.filter((a) => a.data.creator === creator);
-  }
-};
-
-export { AuctionModule, AuctionType, DisputeModule, DisputeResolution, LockupTier, ReputationModule, StakingModule };
+// src/modules/reputation/index.ts
+init_MultiSourceAggregator();
 //# sourceMappingURL=browser.js.map
 //# sourceMappingURL=browser.js.map