Privacy-First Architecture

Two parties need to collaborate on a contract
  |
Content contains sensitive information (PII, terms, financials)
  |
Cloud SaaS platforms require uploading to shared space
  |
BLOCKED: Privacy and security policies prohibit sharing raw content
  |
Result: Manual processes, no automation possible

Upload content to shared cloud -> Privacy breach

Register content hash on blockchain -> Shared immutable identifier
Each party keeps content locally -> Privacy preserved
Coordinate using blockchain identifier -> Automation enabled

Private Information     -> Cryptographic Proof    -> Public Blockchain

Record content          -> Content hash           -> integraHash (on-chain)
User identity           -> Attestation            -> EAS attestation (on-chain)
Payment details         -> Encrypted payload      -> Payment signal (on-chain)

// Private: Actual content
const content = readFile("purchase-agreement.pdf");
const contentBytes = content.bytes;

// Public: Cryptographic proof
const contentHash = keccak256(contentBytes);
// = 0xabc123... (proves content without revealing it)

// On-chain: Just the hash
integraExistenceV1.registerHash(
    contentHash  // Hash only, not content
);

// Private: Content location
const ipfsCID = "QmYwAPJzv5CZsnA..."; // Private IPFS
const encryptionKey = keccak256(sharedSecret);
const encryptedReference = encrypt(ipfsCID, encryptionKey);

// On-chain: Encrypted reference
integraRecordV1.registerRecord(
    contentHash,
    encryptedReference,  // Encrypted, not plaintext
    ...
);

// Not just a hash of content!
integraHash = keccak256(abi.encodePacked(
    contentHash,
    referenceHash,
    msg.sender,
    block.timestamp  // Randomness from timing
));

Without randomness:
  - Same content -> same integraHash
  - Can correlate across registrations
  - Privacy leak

With randomness:
  - Same content -> different integraHash each time
  - Cannot correlate registrations
  - Privacy preserved

// User's primary wallet (known identity)
const primaryWallet = "0x123...";

// Generate ephemeral wallet for each record
const ephemeral1 = deriveEphemeralWallet(primaryWallet, recordIndex: 1);
const ephemeral2 = deriveEphemeralWallet(primaryWallet, recordIndex: 2);
const ephemeral3 = deriveEphemeralWallet(primaryWallet, recordIndex: 3);

// Use ephemeral for record operations
await integraRecordV1.registerRecord(..., { from: ephemeral1 });
await tokenizer.claimToken(..., { from: ephemeral2 });

On-chain view:
  - Address 0xAAA... registered record
  - Address 0xBBB... claimed token
  - Address 0xCCC... received payment
  No visible link between addresses
  Cannot determine these are the same person
  Cannot build complete profile of user's activities

Off-chain (user chooses to prove):
  - All three addresses belong to Alice
  - Alice has 3 contracts
  - Selective disclosure when needed

// Derive ephemeral wallet deterministically
function deriveEphemeralWallet(primaryWallet, recordIndex, secret) {
    const derivationPath = keccak256(
        abi.encode(primaryWallet, recordIndex, secret)
    );
    return ethereumWallet.fromPrivateKey(derivationPath);
}

// User can:
//   Regenerate same ephemeral for record access
//   Prove ownership of ephemeral (via signature)
//   Maintain private correlation (only user knows link)

// Public observers:
//   Cannot link ephemerals to primary
//   Cannot correlate user's activities
//   Cannot build comprehensive profile

// Private: User identity and capabilities
{
    userName: "Alice Johnson",
    email: "alice@example.com",
    capabilities: ["CLAIM", "TRANSFER"],
    recordId: "contract-123",
    role: "Buyer"
}

// Public: Cryptographic attestation
EAS Attestation:
  - schema: 0xSCHEMA...
  - recipient: 0xAAA... (ephemeral)
  - data: abi.encode(capabilityBitmask, integraHash)
  - issuer: 0xISSUER...

function claimToken(
    bytes32 integraHash,
    uint256 tokenId,
    bytes32 attestationUID  // Just a reference
) external {
    // Validates attestation exists and grants capability
    // Never reveals who issued it or why
    // Just proves: msg.sender is authorized
}

// Private: Payment details
{
    amount: "$2,500.00",
    dueDate: "2025-12-01",
    paymentMethod: "Wire to account #12345",
    memo: "Rent for December"
}

// Encrypt for requestor and payer
const encryptedForRequestor = encrypt(details, requestorPublicKey);
const encryptedForPayer = encrypt(details, payerPublicKey);

// Public: Payment signal on-chain
integraSignal.sendPaymentRequest(
    integraHash,
    requestorTokenId,
    payerTokenId,
    payerAddress,
    encryptedForPayer,      // Encrypted payload
    encryptedForRequestor,  // Encrypted payload
    attestationUID,
    invoiceRef,             // Reference hash
    displayAmount,          // Approximate (for UX)
    currency,
    processHash,
    timeoutDays
);

On-chain:
  Payment request exists
  Links to record (integraHash)
  Links to payer/requestor tokens
  Amount hidden (encrypted)
  Payment instructions hidden (encrypted)
  Account details hidden (encrypted)

Off-chain:
  Requestor decrypts with their key
  Payer decrypts with their key
  No one else can read payment details

Record A (integraHash: 0xAAA...):
  - Parties: Alice (ephemeral: 0xA1), Bob (ephemeral: 0xB1)
  - Content hash: 0xDOC_A
  - Reference: encrypted_ref_A

Record B (integraHash: 0xBBB...):
  - Parties: Alice (ephemeral: 0xA2), Carol (ephemeral: 0xC1)
  - Content hash: 0xDOC_B
  - Reference: encrypted_ref_B

On-chain observer cannot determine:
  - Alice participated in both contracts
  - Records are related
  - What records contain
  - Where content is stored

// Alice and Bob negotiate contract off-chain
// Each has the full content privately

// Alice: "I'll register our agreement"
const contentHash = keccak256(agreementPDF);
const integraHash = await integraRecordV1.registerRecord(
    contentHash,
    encryptedIPFSReference,
    ...
);

// Alice tells Bob off-chain: "integraHash is 0xAAA..."

// Bob verifies he has the same content
const bobsHash = keccak256(hisCopyOfAgreementPDF);
const onChainHash = await integraRecordV1.getContentHash(integraHash);

if (bobsHash === onChainHash) {
    // Confirmed: Same content
    // Both can now coordinate using integraHash
    // No content shared on-chain
}

// Bob claims his token
await tokenizer.claimToken(integraHash, bobTokenId, attestation, processHash);

Scenario: Two companies create joint venture agreement
Privacy requirements:
  - Terms must remain confidential
  - Counter-party relationship must be private
  - Each company has strict data governance policies

Integra solution:
  1. Each party keeps content in their own secure storage
  2. Compute content hash independently
  3. One party registers hash on-chain (integraHash created)
  4. Both verify hashes match
  5. Use integraHash to coordinate automation
  6. Use ephemeral wallets (no public link to corporations)
  7. Payment signals encrypted
Result:
  Record coordination enabled
  No content on-chain
  No public link to corporate identities
  Full automation possible
  Audit trail via processHash

Scenario: Patient authorizes provider access to medical records
Privacy requirements:
  - HIPAA compliance (no PHI on public blockchain)
  - Patient controls access
  - Provider needs verifiable authorization

Integra solution:
  1. Patient registers consent record hash
  2. Medical record stays in patient's encrypted storage
  3. Patient creates claim attestation for provider's ephemeral
  4. Provider claims token (proves authorization)
  5. Provider uses integraHash to request content off-chain
  6. Patient's system verifies provider has token
  7. Content shared privately, peer-to-peer

On-chain:
  Consent exists (integraHash)
  Provider authorized (has token)
  No medical records
  No patient identity
  No provider identity
  No correlation between patients

Scenario: Property sale with title company
Privacy requirements:
  - Property details private
  - Purchase price confidential
  - Buyer/seller identities protected

Integra solution:
  1. Title company registers deed hash (not deed)
  2. Reference encrypted (only parties can access)
  3. Buyer and seller use ephemeral wallets
  4. Payment signal with encrypted amount
  5. Token transfer represents ownership transfer
On-chain:
  Property deed verified (hash)
  Ownership transferred
  Property address not visible
  Purchase price not visible
  Real identities not linked
  Cannot correlate to other properties

Option 1: Cloud collaboration (Dropbox, Google Drive)
  - Upload content to shared space
  - Both parties access same file
  - Problem: Content in third-party hands
  - Blocked: Security policies prohibit

Option 2: Email back and forth
  - Send content via email
  - Version confusion (which is current?)
  - Problem: No shared state
  - Result: Manual, error-prone

Blockchain as coordination layer:

Party A's Environment:
  - Content in secure storage (encrypted)
  - Generates: contentHash
  - Registers: integraHash on-chain

Party B's Environment:
  - Content in secure storage (encrypted)
  - Generates: contentHash (same!)
  - Verifies: Matches on-chain hash

Shared coordination:
  - Both use integraHash to coordinate
  - Automate workflows using identifier
  - Neither party shares actual content
  - Privacy policies satisfied

bytes32 contentHash = keccak256(content);

// Private: IPFS CID or content URL
const reference = "QmYwAPJzv5CZsnA...";

// Encrypt with shared secret
const key = keccak256(abi.encode(contentHash, sharedSecret));
const encryptedReference = encrypt(reference, key);

// On-chain: Encrypted blob
integraRecordV1.registerRecord(
    contentHash,
    encryptedReference,  // Cannot be read publicly
    ...
);

integraHash = keccak256(abi.encodePacked(
    contentHash,
    referenceHash,
    msg.sender,
    block.timestamp  // Random element
));

Deterministic approach (BAD):
  integraHash = keccak256(contentHash)
  Problem: Same content -> same integraHash
  Privacy leak: Can correlate registrations
  Example: "This is the 5th registration of this template"

Random approach (GOOD):
  integraHash = keccak256(contentHash + timestamp + ...)
  Benefit: Same content -> different integraHash each time
  Privacy win: Cannot correlate registrations

// User's primary wallet (long-term identity)
const primaryWallet = "0x123...";

// Generate unique ephemeral for each record
const ephemeral1 = deriveWallet(primary, seed, index: 1);
const ephemeral2 = deriveWallet(primary, seed, index: 2);
const ephemeral3 = deriveWallet(primary, seed, index: 3);

// Use ephemeral for all record operations
await registerRecord({ from: ephemeral1 });
await claimToken({ from: ephemeral2 });
await sendPayment({ from: ephemeral3 });

On-chain analysis:
  - Address 0xAAA... has 1 record
  - Address 0xBBB... has 1 record
  - Address 0xCCC... has 1 record
  Cannot determine these are same person
  Cannot build user's complete record history
  Cannot track user across contracts

User knows:
  All ephemerals are mine
  Can prove ownership when needed
  Can correlate privately (off-chain)

// Private: User identity information
const userIdentity = {
    name: "Alice Johnson",
    email: "alice@example.com",
    accreditation: "Verified by SEC",
    kycProvider: "IdentityProvider Inc"
};

// Off-chain: KYC provider verifies

// On-chain: Just the attestation
const attestationUID = await eas.attest({
    schema: kycSchemaUID,
    data: {
        recipient: aliceEphemeralWallet,
        data: abi.encode(
            keccak256(abi.encode(userIdentity)),  // Hash only
            expirationDate,
            verificationType
        )
    }
});

// Smart contract checks
function requireKYC(address user) internal view {
    // Just verifies attestation exists
    require(hasValidKYCAttestation(user), "KYC required");
    // Does not know WHO the user is
    // Just knows they are KYC verified
}

// Private: Full payment details
const paymentDetails = {
    amount: "$2,500.00 USD",
    bankAccount: "Account #123-456-789",
    routingNumber: "987654321",
    memo: "November rent payment",
    instructions: "Wire transfer by 1st of month"
};

// Encrypt for each party
const encryptedForRequestor = encrypt(details, requestorKey);
const encryptedForPayer = encrypt(details, payerKey);

// On-chain: Encrypted payloads only
integraSignal.sendPaymentRequest(
    integraHash,
    requestorTokenId,
    payerTokenId,
    payerAddress,
    encryptedForPayer,      // Only payer can decrypt
    encryptedForRequestor,  // Only requestor can decrypt
    attestationUID,
    keccak256("invoice-123"), // Reference hash
    2500,                   // Display amount (for UX)
    "USD",
    processHash,
    30  // 30 days to pay
);

On-chain:
  Payment request exists
  Linked to record and parties
  Approximate amount (for UX)
  Exact amount hidden
  Account numbers hidden
  Payment instructions hidden

Only requestor and payer can:
  Decrypt full payment details
  See account information
  Read payment instructions

Public view:
  - Address 0xAAA... has attestation
  - Nothing else

User reveals: Nothing

User reveals:
  - "I have 5 completed contracts"
  - "I have 3 rental agreements as tenant"

Proof: Show attestation count, not details

User reveals:
  - "I completed rental at 123 Main St"
  - Proves: integraHash corresponds to property
  - Off-chain proof linking ephemeral to claim

Privacy preserved: Other contracts still private

User reveals:
  - All content hashes
  - Links between ephemerals and primary
  - Complete contract history

Use case: Court order, audit, verification
Proof: Cryptographic proof of ownership

Approach: Cryptographic proof of computation
Privacy: Maximum (prove without revealing anything)
Complexity: High (requires circuit design)
Gas cost: Very high (proof verification)

Integra: Selective approach
  - Use ZK where critical
  - Use encryption for most cases (simpler, cheaper)
  - Use hashing for content proofs (efficient)

Approach: Entire blockchain state encrypted
Privacy: Strong (all data private)
Complexity: Different execution environment
Interoperability: Limited (not standard EVM)

Integra: Public blockchain with privacy layers
  - Standard EVM (works everywhere)
  - Selective encryption (only what needs privacy)
  - Interoperable (standard ERCs, standard attestations)

Approach: Private blockchain network
Privacy: Strong (controlled participants)
Complexity: Infrastructure overhead
Decentralization: None (controlled network)

Integra: Public blockchain with privacy techniques
  - Fully decentralized
  - No infrastructure needed
  - Privacy via cryptography, not access control

// Generate new ephemeral for each record
const ephemeral = deriveEphemeralWallet(primary, recordIndex);

// Never store plaintext IPFS CIDs
const encrypted = encrypt(ipfsCID, sharedSecret);

// Good
processHash = keccak256("workflow-12345");

// Bad
processHash = keccak256("patient-ssn-123-45-6789");  // PII!

// Store only what is needed for coordination
// Keep everything else off-chain

// Reveal only what is necessary
// Default: Reveal nothing

// Always use encrypted payment signals
// Never post account numbers publicly