synkrokonn-dev/dist/index.js

Plugin-based cross-chain orchestration middleware for Web3 enterprise automation.

import { fileURLToPath } from 'url';
import path from 'path';
import dotenv from 'dotenv';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
// Load fallback .env in case cli.ts didn't already load from process.cwd()
dotenv.config({ path: path.resolve(__dirname, '..', '.env') });
import { EthereumAdapter } from './adapters/EthereumAdapter.js';
import { FabricAdapter } from './adapters/fabric/FabricAdapter.js';
import { PluginManager } from './core/PluginManager.js';
import { AuditLoggerPlugin } from './plugins/auditLogger.js';
import { HTLCPlugin } from './plugins/htlc.js';
import { RollbackPlugin } from './plugins/rollback.js';
import { OrchestratorEngine } from './core/OrchestratorEngine.js';
export async function runOrchestration(workflowFile) {
    console.log("synkrokonn-dev started");
    const rpcA = process.env.CHAIN_RPC_ETHEREUM;
    const rpcB = process.env.CHAIN_RPC_GANACHE_B;
    const privateKey = process.env.PRIVATE_KEY;
    if (!rpcA || !rpcB || !privateKey) {
        console.error("Missing CHAIN_RPC_ETHEREUM, CHAIN_RPC_GANACHE_B or PRIVATE_KEY in .env");
        process.exit(1);
    }
    console.log("Chain A RPC:", rpcA);
    console.log("Chain B RPC:", rpcB);
    console.log("PRIVATE_KEY (first 10 chars):", privateKey.slice(0, 10), "...");
    let ethAdapterA;
    let ethAdapterB;
    try {
        ethAdapterA = new EthereumAdapter(rpcA, privateKey);
        ethAdapterB = new EthereumAdapter(rpcB, privateKey);
    }
    catch (err) {
        console.error("Failed to initialize EthereumAdapters:", err);
        process.exit(1);
    }
    try {
        const addressA = await ethAdapterA.getAccountAddress();
        const addressB = await ethAdapterB.getAccountAddress();
        console.log("Chain A Account:", addressA);
        console.log("Chain B Account:", addressB);
    }
    catch (err) {
        console.error("Unable to fetch one or more account addresses:", err);
        process.exit(1);
    }
    const plugins = [AuditLoggerPlugin, HTLCPlugin, RollbackPlugin];
    const pluginManager = new PluginManager(plugins);
    const adapters = {
        ethereum: ethAdapterA,
        ganache_b: ethAdapterB,
        fabric_chain: new FabricAdapter(),
    };
    const engine = new OrchestratorEngine(workflowFile, adapters, pluginManager);
    try {
        await engine.start();
        console.log("Orchestration complete");
    }
    catch (err) {
        console.error("Orchestration failed:", err);
    }
    // Simulated domain events every 5s (including Service)
    setInterval(async () => {
        const types = ["Vehicle", "Loan", "Insurance", "Service"];
        const chosen = types[Math.floor(Math.random() * types.length)];
        const simulatedObject = {
            type: chosen,
            id: `${chosen.toLowerCase()}-1001`,
            payload: {
                ...(chosen === "Vehicle" && { vehicleId: 1001, model: "ModelX", status: "Delivered" }),
                ...(chosen === "Loan" && { loanId: 2001, borrower: "Alice", amount: 50000, status: "Approved" }),
                ...(chosen === "Insurance" && { policyId: 3001, policyHolder: "Bob", coverage: "Full", premium: 1200 }),
                ...(chosen === "Service" && { assetId: "asset6", serviceStatus: "Inspected" }),
            },
            metadata: {},
        };
        await pluginManager.onEvent("ChainEvent", {
            message: `Simulated chain event for ${chosen}`,
            object: simulatedObject,
        });
    }, 5000);
    // Simulated orchestrator error after 15s
    setTimeout(async () => {
        const context = {
            id: "simulated-context",
            timestamp: new Date().toISOString(),
            metadata: {},
        };
        await pluginManager.onError(new Error("Simulated error triggered"), context);
    }, 15000);
}