import { zkFractalClient } from "zkfractal-sdk";

async function runPrivateInference() {
    // 🎯 Initialize the SDK client
    const client = await zkFractalClient.create({
        network: "solana-mainnet",
        encryptionKey: process.env.ENCRYPTION_KEY,
        solanaRpcUrl: process.env.RPC_ENDPOINT
    });

    // 🔒 Load and encrypt sensitive data
    const sensitiveData = await client.loadTensor("financial_data.json");
    const encryptedData = await client.encryptData(sensitiveData);

    // 🧠 Execute encrypted AI inference
    const inferenceResult = await client.runEncryptedInference(
        encryptedData,
        {
            modelId: "confidential-classifier-v1",
            inputShape: [1, 256],
            outputClasses: 10
        }
    );

    // 📜 Generate zero-knowledge proof
    const zkProof = await client.generateProof(inferenceResult);

    // ⛓ Verify proof on Solana blockchain
    const verification = await client.verifyOnChain(zkProof);

    console.log(`✅ Inference completed and verified on-chain`);
    console.log(`📜 Proof Hash: ${zkProof.proofHash}`);
    console.log(`⛓ Transaction: ${verification.txHash}`);
}

runPrivateInference().catch(console.error);

const advancedClient = await zkFractalClient.create({
    network: "solana-mainnet",
    encryption: {
        algorithm: "aes-256-gcm",
        keyRotation: "auto",
        securityLevel: "enterprise"
    },
    proof: {
        system: "plonk",
        aggregation: true,
        securityBits: 128
    },
    solana: {
        commitment: "confirmed",
        priorityFee: "high",
        maxRetries: 3
    }
});

import { Encryptor, KeyVault } from "zkfractal-sdk/fractal";

const encryptor = new Encryptor();
const keyVault = new KeyVault();

// 🔑 Generate encryption keys
const masterKey = await keyVault.generateMasterKey();
const sessionKey = await keyVault.deriveSessionKey(masterKey);

// 🎯 Encrypt tensor data
const tensorData = await loadTensorData();
const encryptedTensor = await encryptor.encryptTensor(tensorData, sessionKey);
const decryptedTensor = await encryptor.decryptTensor(encryptedTensor, sessionKey);

import { PrivacyBridge, ModelSync } from "zkfractal-sdk/ai";

const privacyBridge = new PrivacyBridge();
const modelSync = new ModelSync();

// 🤖 Load and prepare AI model for encrypted computation
await modelSync.loadEncryptedModel("model-weights.enc");
const modelConfig = await modelSync.getModelConfiguration();

// ⚡ Execute inference on encrypted data
const encryptedResult = await privacyBridge.processEncrypted(
    encryptedTensor,
    modelConfig
);

// 📝 Generate computation trace for proof generation
const computationTrace = await privacyBridge.generateComputationTrace();

import { ProofGenerator, ProofVerifier } from "zkfractal-sdk/proof";

const proofGenerator = new ProofGenerator();
const proofVerifier = new ProofVerifier();

// 🔏 Generate ZK proof for computation
const proof = await proofGenerator.createZKProof({
    computationTrace: computationTrace,
    inputHash: encryptedTensor.hash,
    outputHash: encryptedResult.hash,
    publicInputs: {
        modelId: modelConfig.modelId,
        timestamp: Date.now()
    }
});

// ✅ Verify proof locally before on-chain submission
const isValid = await proofVerifier.verifyProof(proof);
if (!isValid) {
    throw new Error("Proof verification failed");
}

import { SolanaClient } from "zkfractal-sdk/solana";

const solanaClient = new SolanaClient({
    network: "mainnet-beta",
    commitment: "confirmed",
    timeout: 30000
});

// 🚀 Submit proof for on-chain verification
const transactionResult = await solanaClient.verifyProof(proof);

// 👀 Monitor transaction confirmation
const confirmation = await solanaClient.waitForConfirmation(
    transactionResult.txSignature
);

console.log(`✅ Proof verified in block: ${confirmation.slot}`);

class zkFractalClient {
    static create(config: ClientConfig): Promise<zkFractalClient>;
    
    encryptData(data: TensorData): Promise<EncryptedData>;
    runEncryptedInference(data: EncryptedData, config: ModelConfig): Promise<InferenceResult>;
    generateProof(result: InferenceResult): Promise<ZKProof>;
    verifyOnChain(proof: ZKProof): Promise<VerificationResult>;
    
    getComputationMetrics(options: MetricsOptions): Promise<ComputationMetrics>;
    rotateEncryptionKeys(): Promise<void>;
    createSessionManager(): Promise<SessionManager>;
}

// ✅ Always validate proofs before on-chain submission
const isValid = await proofVerifier.verifyProofLocally(proof);
if (!isValid) {
    throw new SecurityError("Local proof verification failed");
}

// 🔑 Use secure key management
const keyVault = new KeyVault();
await keyVault.initializeSecureStorage();
await keyVault.setupKeyRotation(7 * 24 * 60 * 60 * 1000); // Rotate weekly

// 👀 Monitor for suspicious activities
const securityMonitor = new SecurityMonitor();
securityMonitor.on('suspicious_activity', (event) => {
    console.warn(`🚨 Security alert: ${event.type}`);
});