@tacitprotocol/sdk 0.1.0

package/src/identity/authenticity.ts

@@ -0,0 +1,260 @@
+/**
+ * Tacit Protocol — Authenticity Vector Engine
+ *
+ * Computes and manages the multi-dimensional trust score that
+ * replaces self-reported profiles with verifiable behavioral signals.
+ */
+
+import type {
+  AuthenticityVector,
+  AuthenticityDimensions,
+  TrustLevel,
+  VerifiableCredential,
+} from '../types/index.js';
+
+// ─── Constants ────────────────────────────────────────────────────
+
+const DIMENSION_WEIGHTS = {
+  tenure: 0.20,
+  consistency: 0.30,
+  attestations: 0.25,
+  networkTrust: 0.25,
+} as const;
+
+const TRUST_LEVEL_THRESHOLDS: [TrustLevel, number][] = [
+  ['exemplary', 90],
+  ['trusted', 70],
+  ['established', 40],
+  ['emerging', 20],
+  ['new', 0],
+];
+
+const CONSISTENCY_WEIGHTS = {
+  intentStability: 0.30,
+  profileConsistency: 0.25,
+  responseReliability: 0.25,
+  interactionQuality: 0.20,
+} as const;
+
+const ATTESTATION_WEIGHTS = {
+  institutional: 0.40,
+  peer: 0.30,
+  transaction: 0.30,
+} as const;
+
+/** Score decays 0.1% per day after 30 days of inactivity */
+const DECAY_RATE_PER_DAY = 0.001;
+const DECAY_GRACE_PERIOD_DAYS = 30;
+
+// ─── Core Engine ──────────────────────────────────────────────────
+
+export class AuthenticityEngine {
+  /**
+   * Compute the tenure dimension score.
+   * Linear growth over 365 days, capped at 1.0.
+   */
+  computeTenure(agentCreatedDate: Date, now: Date = new Date()): number {
+    const daysActive = (now.getTime() - agentCreatedDate.getTime()) / (1000 * 60 * 60 * 24);
+    return Math.min(1.0, Math.max(0, daysActive / 365));
+  }
+
+  /**
+   * Compute the consistency dimension score.
+   * Based on behavioral stability signals over time.
+   */
+  computeConsistency(signals: ConsistencySignals): number {
+    return clamp(
+      signals.intentStability * CONSISTENCY_WEIGHTS.intentStability +
+      signals.profileConsistency * CONSISTENCY_WEIGHTS.profileConsistency +
+      signals.responseReliability * CONSISTENCY_WEIGHTS.responseReliability +
+      signals.interactionQuality * CONSISTENCY_WEIGHTS.interactionQuality
+    );
+  }
+
+  /**
+   * Compute the attestation dimension score.
+   * Based on third-party verifiable credentials.
+   */
+  computeAttestations(credentials: VerifiableCredential[]): number {
+    if (credentials.length === 0) return 0;
+
+    let institutional = 0;
+    let peer = 0;
+    let transaction = 0;
+
+    for (const cred of credentials) {
+      // Categorize credentials
+      if (isInstitutionalCredential(cred)) {
+        institutional += credentialWeight(cred);
+      } else if (isPeerAttestation(cred)) {
+        peer += credentialWeight(cred);
+      } else {
+        transaction += credentialWeight(cred);
+      }
+    }
+
+    // Normalize each category to 0-1
+    institutional = Math.min(1.0, institutional);
+    peer = Math.min(1.0, peer);
+    transaction = Math.min(1.0, transaction);
+
+    return clamp(
+      institutional * ATTESTATION_WEIGHTS.institutional +
+      peer * ATTESTATION_WEIGHTS.peer +
+      transaction * ATTESTATION_WEIGHTS.transaction
+    );
+  }
+
+  /**
+   * Compute the network trust dimension score.
+   * Based on the quality of the agent's network relationships.
+   *
+   * This is a simplified version — production implementations
+   * should use a full PageRank-style algorithm.
+   */
+  computeNetworkTrust(signals: NetworkTrustSignals): number {
+    if (signals.totalInteractions === 0) return 0;
+
+    const successRate = signals.successfulIntros / Math.max(1, signals.totalIntros);
+    const positiveRate = signals.positiveInteractions / signals.totalInteractions;
+    const bidirectionalBonus = Math.min(1.0, signals.bidirectionalTrustEdges * 0.1);
+
+    return clamp(
+      successRate * 0.35 +
+      positiveRate * 0.35 +
+      bidirectionalBonus * 0.30
+    );
+  }
+
+  /**
+   * Compute the full authenticity vector from all dimensions.
+   */
+  computeVector(params: {
+    agentCreatedDate: Date;
+    consistencySignals: ConsistencySignals;
+    credentials: VerifiableCredential[];
+    networkSignals: NetworkTrustSignals;
+    lastActiveDate?: Date;
+  }): AuthenticityVector {
+    const now = new Date();
+
+    const dimensions: AuthenticityDimensions = {
+      tenure: this.computeTenure(params.agentCreatedDate, now),
+      consistency: this.computeConsistency(params.consistencySignals),
+      attestations: this.computeAttestations(params.credentials),
+      networkTrust: this.computeNetworkTrust(params.networkSignals),
+    };
+
+    // Compute raw score
+    let score =
+      dimensions.tenure * DIMENSION_WEIGHTS.tenure +
+      dimensions.consistency * DIMENSION_WEIGHTS.consistency +
+      dimensions.attestations * DIMENSION_WEIGHTS.attestations +
+      dimensions.networkTrust * DIMENSION_WEIGHTS.networkTrust;
+
+    // Apply inactivity decay
+    if (params.lastActiveDate) {
+      const inactiveDays = (now.getTime() - params.lastActiveDate.getTime()) / (1000 * 60 * 60 * 24);
+      if (inactiveDays > DECAY_GRACE_PERIOD_DAYS) {
+        const decayDays = inactiveDays - DECAY_GRACE_PERIOD_DAYS;
+        const decayFactor = Math.max(0, 1 - decayDays * DECAY_RATE_PER_DAY);
+        score *= decayFactor;
+      }
+    }
+
+    // Scale to 0-100
+    score = Math.round(score * 100);
+
+    return {
+      level: this.scoreToLevel(score),
+      score,
+      dimensions,
+      verifiableCredentials: params.credentials,
+    };
+  }
+
+  /**
+   * Convert a numeric score to a trust level.
+   */
+  scoreToLevel(score: number): TrustLevel {
+    for (const [level, threshold] of TRUST_LEVEL_THRESHOLDS) {
+      if (score >= threshold) return level;
+    }
+    return 'new';
+  }
+
+  /**
+   * Check if an agent meets minimum authenticity requirements.
+   */
+  meetsMinimum(vector: AuthenticityVector, minScore: number): boolean {
+    return vector.score >= minScore;
+  }
+}
+
+// ─── Signal Types ─────────────────────────────────────────────────
+
+export interface ConsistencySignals {
+  /** 0-1: How stable the agent's intents have been over time */
+  intentStability: number;
+  /** 0-1: How consistent the profile claims have been */
+  profileConsistency: number;
+  /** 0-1: How reliably the agent responds to proposals */
+  responseReliability: number;
+  /** 0-1: Quality ratings from completed interactions */
+  interactionQuality: number;
+}
+
+export interface NetworkTrustSignals {
+  /** Total number of interactions this agent has had */
+  totalInteractions: number;
+  /** Number of interactions rated positively by the other party */
+  positiveInteractions: number;
+  /** Total introduction proposals that reached completion */
+  totalIntros: number;
+  /** Intros that both parties rated as successful */
+  successfulIntros: number;
+  /** Number of agents that mutually trust this agent */
+  bidirectionalTrustEdges: number;
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+function clamp(value: number, min = 0, max = 1): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+const INSTITUTIONAL_TYPES = new Set([
+  'EmploymentCredential',
+  'EducationCredential',
+  'ProfessionalCertification',
+  'GovernmentId',
+  'LicenseCredential',
+]);
+
+function isInstitutionalCredential(cred: VerifiableCredential): boolean {
+  return INSTITUTIONAL_TYPES.has(cred.type);
+}
+
+const PEER_TYPES = new Set([
+  'PeerEndorsement',
+  'PeerAttestation',
+  'RecommendationCredential',
+]);
+
+function isPeerAttestation(cred: VerifiableCredential): boolean {
+  return PEER_TYPES.has(cred.type);
+}
+
+function credentialWeight(cred: VerifiableCredential): number {
+  // Newer credentials are worth more
+  const issued = new Date(cred.issued);
+  const ageYears = (Date.now() - issued.getTime()) / (1000 * 60 * 60 * 24 * 365);
+
+  // Decay: full weight for first year, then 10% per year
+  const ageFactor = Math.max(0.1, 1 - (ageYears - 1) * 0.1);
+
+  // Base weight by type
+  const baseWeight = INSTITUTIONAL_TYPES.has(cred.type) ? 0.5 : 0.3;
+
+  return baseWeight * ageFactor;
+}

package/src/identity/did.ts

@@ -0,0 +1,192 @@
+/**
+ * Tacit Protocol — DID Identity Management
+ *
+ * Handles creation, resolution, and management of W3C Decentralized Identifiers
+ * for Tacit agents. Uses did:key method for simplicity in v0.1.
+ */
+
+import type { AgentIdentity, DID } from '../types/index.js';
+
+/**
+ * Generate a new Ed25519 keypair for agent identity.
+ * In production, this should use a secure random number generator
+ * and keys should be stored in a secure enclave.
+ */
+export async function generateKeypair(): Promise<{
+  publicKey: Uint8Array;
+  privateKey: Uint8Array;
+}> {
+  // Use Web Crypto API for key generation
+  const keyPair = await crypto.subtle.generateKey(
+    { name: 'Ed25519' },
+    true,
+    ['sign', 'verify']
+  );
+
+  const pair = keyPair as { publicKey: CryptoKey; privateKey: CryptoKey };
+  const publicKeyBuffer = await crypto.subtle.exportKey('raw', pair.publicKey);
+  const privateKeyBuffer = await crypto.subtle.exportKey('pkcs8', pair.privateKey);
+
+  return {
+    publicKey: new Uint8Array(publicKeyBuffer),
+    privateKey: new Uint8Array(privateKeyBuffer),
+  };
+}
+
+/**
+ * Create a did:key identifier from a public key.
+ * did:key encodes the public key directly in the DID string.
+ *
+ * Format: did:key:z{multibase-encoded-multicodec-public-key}
+ * For Ed25519: multicodec prefix is 0xed01
+ */
+export function publicKeyToDid(publicKey: Uint8Array): DID {
+  // Multicodec prefix for Ed25519 public key
+  const ED25519_MULTICODEC = new Uint8Array([0xed, 0x01]);
+  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKey.length);
+  prefixed.set(ED25519_MULTICODEC);
+  prefixed.set(publicKey, ED25519_MULTICODEC.length);
+
+  // Base58btc encode with 'z' prefix (multibase)
+  const encoded = base58btcEncode(prefixed);
+  return `did:key:z${encoded}` as DID;
+}
+
+/**
+ * Create a new agent identity with a fresh keypair and DID.
+ */
+export async function createIdentity(): Promise<AgentIdentity> {
+  const { publicKey, privateKey } = await generateKeypair();
+  const did = publicKeyToDid(publicKey);
+
+  return {
+    did,
+    publicKey,
+    privateKey,
+    created: new Date(),
+  };
+}
+
+/**
+ * Resolve a DID to its public key.
+ * For did:key, the public key is embedded in the DID itself.
+ */
+export function resolveDid(did: DID): { publicKey: Uint8Array } | null {
+  if (!did.startsWith('did:key:z')) {
+    // Only did:key supported in v0.1
+    return null;
+  }
+
+  const encoded = did.slice('did:key:z'.length);
+  const decoded = base58btcDecode(encoded);
+
+  // Strip multicodec prefix (2 bytes for Ed25519)
+  const publicKey = decoded.slice(2);
+
+  return { publicKey };
+}
+
+/**
+ * Sign arbitrary data with the agent's private key.
+ */
+export async function sign(data: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array> {
+  const key = await crypto.subtle.importKey(
+    'pkcs8',
+    privateKey.buffer as ArrayBuffer,
+    { name: 'Ed25519' },
+    false,
+    ['sign']
+  );
+
+  const signature = await crypto.subtle.sign('Ed25519', key, data.buffer as ArrayBuffer);
+  return new Uint8Array(signature);
+}
+
+/**
+ * Verify a signature against a public key.
+ */
+export async function verify(
+  data: Uint8Array,
+  signature: Uint8Array,
+  publicKey: Uint8Array
+): Promise<boolean> {
+  const key = await crypto.subtle.importKey(
+    'raw',
+    publicKey.buffer as ArrayBuffer,
+    { name: 'Ed25519' },
+    false,
+    ['verify']
+  );
+
+  return crypto.subtle.verify('Ed25519', key, signature.buffer as ArrayBuffer, data.buffer as ArrayBuffer);
+}
+
+// ─── Base58btc Encoding (simplified) ──────────────────────────────
+
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+function base58btcEncode(bytes: Uint8Array): string {
+  if (bytes.length === 0) return '';
+
+  // Count leading zeros
+  let zeros = 0;
+  for (const byte of bytes) {
+    if (byte !== 0) break;
+    zeros++;
+  }
+
+  // Convert to base58
+  const digits: number[] = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = (carry / 58) | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = (carry / 58) | 0;
+    }
+  }
+
+  let result = '';
+  for (let i = 0; i < zeros; i++) result += '1';
+  for (let i = digits.length - 1; i >= 0; i--) result += BASE58_ALPHABET[digits[i]];
+
+  return result;
+}
+
+function base58btcDecode(str: string): Uint8Array {
+  if (str.length === 0) return new Uint8Array(0);
+
+  const bytes: number[] = [0];
+  for (const char of str) {
+    const value = BASE58_ALPHABET.indexOf(char);
+    if (value === -1) throw new Error(`Invalid base58 character: ${char}`);
+
+    let carry = value;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 0xff;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 0xff);
+      carry >>= 8;
+    }
+  }
+
+  // Count leading '1's (zeros in base58)
+  let zeros = 0;
+  for (const char of str) {
+    if (char !== '1') break;
+    zeros++;
+  }
+
+  const result = new Uint8Array(zeros + bytes.length);
+  for (let i = 0; i < zeros; i++) result[i] = 0;
+  for (let i = 0; i < bytes.length; i++) result[zeros + i] = bytes[bytes.length - 1 - i];
+
+  return result;
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+/**
+ * Tacit Protocol SDK
+ *
+ * The social layer for the agent era.
+ * Enables AI agents to discover, trust, and introduce the humans they represent.
+ *
+ * @packageDocumentation
+ */
+
+// Core
+export { TacitAgent } from './core/agent.js';
+
+// Identity
+export { createIdentity, publicKeyToDid, resolveDid, sign, verify } from './identity/did.js';
+export { AuthenticityEngine } from './identity/authenticity.js';
+export type { ConsistencySignals, NetworkTrustSignals } from './identity/authenticity.js';
+
+// Discovery
+export { IntentBuilder, IntentStore } from './discovery/intent.js';
+
+// Matching
+export { MatchScorer } from './matching/scorer.js';
+
+// Types
+export type {
+  // Identity
+  DID,
+  AgentIdentity,
+  AnonymityLevel,
+  SessionPersona,
+
+  // Agent Card
+  AgentCard,
+  TransportConfig,
+  Domain,
+  DomainType,
+  AgentPreferences,
+
+  // Authenticity
+  AuthenticityVector,
+  AuthenticityDimensions,
+  TrustLevel,
+  VerifiableCredential,
+
+  // Intents
+  Intent,
+  IntentType,
+  IntentStatus,
+  IntentFilters,
+  PrivacyLevel,
+
+  // Matching
+  MatchResult,
+  MatchScore,
+  MatchAction,
+
+  // Introductions
+  IntroProposal,
+  IntroTerms,
+  RevealStage,
+  ProposalStatus,
+
+  // Commerce
+  ServiceIntent,
+  ServiceAttestation,
+
+  // Events
+  TacitEvent,
+
+  // Config
+  TacitConfig,
+  RelayConfig,
+} from './types/index.js';