xTitle.io Technical Architecture

class PhoneLockProtocol {
  private verificationWindow = 5 * 60 * 1000; // 5 minutes
  private smsTimeout = 60 * 1000; // 1 minute for SMS
  
  // Create phone-locked attestation
  async createPhoneLockedAttestation(
    wireDetails: WireInstructions,
    buyerInfo: BuyerInfo
  ): Promise<AttestationId> {
    // Validate and hash phone number
    const phoneHash = this.hashPhoneNumber(buyerInfo.phone);
    
    // Create attestation with phone binding
    const attestation = {
      wireDetails,
      phoneNumberHash: phoneHash,
      requiresPhoneLock: true,
      verificationWindow: this.verificationWindow,
      fieldHashes: this.createFieldHashes(wireDetails)
    };
    
    // Store on blockchain with phone lock
    return await this.storeOnBlockchain(attestation);
  }
  
  // Request verification (ONLY works from registered phone)
  async requestVerification(
    attestationId: string,
    phoneNumber: string
  ): Promise<SessionId> {
    // Verify phone matches attestation
    if (!this.verifyPhoneMatch(attestationId, phoneNumber)) {
      throw new Error('Phone not authorized for this wire');
    }
    
    // Send SMS with time-locked link
    const session = await this.createSecureSession();
    await this.sendSMS(phoneNumber, {
      message: `xTitle Wire Verification\nCode: ${session.code}\nLink: verify.xtitle.io/s/${session.id}\nExpires in 60 seconds`
    });
    
    return session.id;
  }
}

interface WireInstructions {
  bank: string;
  account: string;
  routing: string;
  amount: number;
}

class StructuredHashingService {
  // Create individual field hashes for granular detection
  private createFieldHashes(wire: WireInstructions): FieldHashes {
    return {
      bank: this.hashField(wire.bank, 'BANK'),
      account: this.hashField(wire.account, 'ACCOUNT'),
      routing: this.hashField(wire.routing, 'ROUTING'),
      amount: this.hashField(wire.amount.toString(), 'AMOUNT')
    };
  }

  // Verify with specific field detection
  public async verifyWire(
    attestationId: string,
    wire: WireInstructions
  ): VerificationResult {
    const stored = await this.getStoredHashes(attestationId);
    const current = this.createFieldHashes(wire);
    
    const mismatches = [];
    for (const field in current) {
      if (stored[field] !== current[field]) {
        mismatches.push({
          field,
          severity: this.calculateSeverity(field),
          message: `${field} has been modified`
        });
      }
    }
    
    return {
      valid: mismatches.length === 0,
      mismatches,
      fraudScore: this.calculateFraudScore(mismatches)
    };
  }
}