@halot/cli 1.0.0

package/dist/features/verifier/verifier-register.command.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifierRegisterCommand = runVerifierRegisterCommand;
+const ethers_1 = require("ethers");
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const agent_id_register_service_1 = require("@halot/cli/shared/integrations/agent-id/agent-id-register.service");
+const space_id_register_service_1 = require("@halot/cli/shared/integrations/space-id/space-id-register.service");
+const verifier_registry_service_1 = require("@halot/cli/shared/integrations/zero-g/verifier-registry.service");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runVerifierRegisterCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const agentIdRegisterService = new agent_id_register_service_1.AgentIdRegisterService();
+    const domainRegistrationService = new space_id_register_service_1.SpaceIdRegisterService();
+    const verifierRegistryService = new verifier_registry_service_1.ZeroGVerifierRegistryService();
+    const config = workspace.readVerifierConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const specializations = workspace.readSpecializations();
+    const verifierWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    const signingPublicKey = (0, authority_util_1.deriveVerifierSigningPublicKey)(wallets, config.authority.actor);
+    const chain = (0, authority_util_1.resolveZeroGAuthorityProfile)(config.authority.actor);
+    const isMainnet = (0, authority_util_1.isMainnetAuthority)(config.authority.actor);
+    if (isMainnet) {
+        const domainResult = await domainRegistrationService.registerZeroGDomain({
+            domain: config.identity.domain,
+            address: verifierWallet.address,
+            privateKey: verifierWallet.privateKey,
+            chainId: chain.chainId,
+            rpcUrl: chain.rpcUrl,
+        });
+        console.log(`Registered ${domainResult.domain}${domainResult.transactionHash ? ` (${domainResult.transactionHash})` : ''}`);
+    }
+    else {
+        console.log('Skipping Space ID domain registration (testnet mode)');
+    }
+    let verifier = await api.post('/verifiers/register', {
+        config: {
+            ...config,
+            identity: {
+                ...config.identity,
+                ownerAddress: verifierWallet.address,
+            },
+        },
+        specializations,
+        ownerAddress: verifierWallet.address,
+        signingPublicKey,
+    });
+    if (isMainnet) {
+        const agentUri = (0, agent_id_register_service_1.createZeroGAgentUri)(verifier.rootHash);
+        const agentResult = await agentIdRegisterService.registerAgent({
+            ownerAddress: verifierWallet.address,
+            privateKey: verifierWallet.privateKey,
+            chainId: chain.chainId,
+            rpcUrl: chain.rpcUrl,
+            agentUri,
+        });
+        const path = `/verifiers/${verifier.verifierId}/identity`;
+        const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(new ethers_1.Wallet(verifierWallet.privateKey), verifier.verifierId, 'verifier', 'POST', path);
+        verifier = await api.post(path, {
+            erc8004TokenId: agentResult.agentId,
+            agentRegistry: agentResult.agentRegistry,
+            agentUri: agentResult.agentUri,
+        }, headers);
+        console.log(`Registered Agent ID ${agentResult.agentId}${agentResult.transactionHash ? ` (${agentResult.transactionHash})` : ''}`);
+    }
+    else {
+        console.log('Skipping Agent ID registration (testnet mode)');
+    }
+    const registryResult = await verifierRegistryService.registerVerifier({
+        privateKey: verifierWallet.privateKey,
+        rpcUrl: chain.rpcUrl,
+        categories: specializations.categories,
+        serviceIds: specializations.serviceIds,
+        stakeAmount: config.stake.amount,
+    });
+    console.log(`Registered verifier stake ${registryResult.transactionHash}`);
+    workspace.writeVerifierConfig({
+        ...config,
+        verifierId: verifier.verifierId,
+        identity: verifier.identity,
+        stake: {
+            ...config.stake,
+            status: 'locked',
+        },
+    });
+    (0, print_util_1.printJson)(verifier);
+}

package/dist/features/verifier/verifier-run.command.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifierRunCommand = runVerifierRunCommand;
+exports.assertSupportedAssignment = assertSupportedAssignment;
+exports.applyConfidenceThreshold = applyConfidenceThreshold;
+const sdk_1 = require("@halot/sdk");
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const event_stream_1 = require("@halot/cli/shared/http/event-stream");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const actor_headers_service_1 = require("@halot/cli/shared/auth/actor-headers.service");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runVerifierRunCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const api = new api_client_1.ApiClient(options.server);
+    const config = workspace.readVerifierConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const modelConfig = workspace.readModelConfig();
+    const inferenceTemplate = workspace.readInferenceTemplate();
+    const specializations = workspace.readSpecializations();
+    const verifierWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    const chain = (0, authority_util_1.resolveZeroGAuthorityProfile)(config.authority.actor);
+    const compute = new sdk_1.ZeroGComputeService({
+        privateKey: verifierWallet.privateKey,
+        rpcUrl: modelConfig.sdk.rpcUrl ?? chain.rpcUrl,
+        providerAddress: modelConfig.evaluationModel.providerAddress,
+        ledgerContractAddress: modelConfig.sdk.ledgerContractAddress,
+        inferenceContractAddress: modelConfig.sdk.inferenceContractAddress,
+        fineTuningContractAddress: modelConfig.sdk.fineTuningContractAddress,
+    });
+    const intervalMs = Number(options.interval);
+    const workerId = (0, sdk_1.createPrefixedId)('worker');
+    const cursorKey = `verifier:${config.verifierId}`;
+    let lastEventId = workspace.readStreamCursor(cursorKey);
+    if (!modelConfig.evaluationModel.providerAddress) {
+        throw new Error('model.config.json must set evaluationModel.providerAddress for real 0G TeeML verification.');
+    }
+    if (options.once) {
+        const assignmentPath = `/verifiers/${config.verifierId}/jobs/next`;
+        const headers = await (0, actor_headers_service_1.createSignedActorHeaders)(verifierWallet, config.verifierId, 'verifier', 'GET', assignmentPath);
+        const assignment = await api.get(assignmentPath, headers);
+        if (!assignment || !assignment.result) {
+            console.log('No verifier assignments available.');
+            return;
+        }
+        await processVerifierAssignment(api, verifierWallet, config.verifierId, assignment, compute, inferenceTemplate, modelConfig, specializations);
+        return;
+    }
+    do {
+        try {
+            const streamPath = `/verifiers/${config.verifierId}/jobs/stream`;
+            const headers = {
+                ...(await (0, actor_headers_service_1.createSignedActorHeaders)(verifierWallet, config.verifierId, 'verifier', 'GET', streamPath)),
+                'x-halot-worker-id': workerId,
+            };
+            for await (const event of (0, event_stream_1.connectEventStream)(`${options.server}${streamPath}`, headers, lastEventId)) {
+                if (event.event === 'checkpoint') {
+                    if (event.id) {
+                        lastEventId = event.id;
+                        workspace.writeStreamCursor(cursorKey, event.id);
+                    }
+                    continue;
+                }
+                if (event.event !== 'assignment') {
+                    continue;
+                }
+                const assignment = JSON.parse(event.data);
+                if (!assignment.result) {
+                    continue;
+                }
+                await processVerifierAssignment(api, verifierWallet, config.verifierId, assignment, compute, inferenceTemplate, modelConfig, specializations);
+                if (event.id) {
+                    lastEventId = event.id;
+                    workspace.writeStreamCursor(cursorKey, event.id);
+                }
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            await (0, print_util_1.sleep)(intervalMs);
+        }
+    } while (true);
+}
+async function processVerifierAssignment(api, verifierWallet, verifierId, assignment, compute, inferenceTemplate, modelConfig, specializations) {
+    assertSupportedAssignment(assignment.service, specializations);
+    const rawEvaluation = await compute.evaluate({
+        jobHash: assignment.job.jobHash,
+        resultHash: assignment.result.resultHash,
+        input: assignment.job.input,
+        result: assignment.result.output,
+        service: assignment.service,
+        providerAddress: modelConfig.evaluationModel.providerAddress,
+        systemPrompt: inferenceTemplate.systemPrompt,
+        promptTemplate: inferenceTemplate.promptTemplate,
+        outputSchema: inferenceTemplate.outputSchema,
+        maxTokens: inferenceTemplate.maxTokens,
+        temperature: inferenceTemplate.temperature,
+    });
+    const evaluation = applyConfidenceThreshold(rawEvaluation, specializations.minConfidenceThreshold);
+    const verifierSignature = await (0, sdk_1.signAttestationPayload)(verifierWallet, {
+        jobHash: assignment.job.jobHash,
+        resultHash: assignment.result.resultHash,
+        decision: evaluation.decision,
+        teeDigest: evaluation.teeProof.digest,
+    });
+    const attestPath = `/jobs/${assignment.job.jobId}/attest`;
+    const attestHeaders = await (0, actor_headers_service_1.createSignedActorHeaders)(verifierWallet, verifierId, 'verifier', 'POST', attestPath);
+    const job = await api.post(attestPath, {
+        jobHash: assignment.job.jobHash,
+        resultHash: assignment.result.resultHash,
+        verifierId,
+        verifierAddress: verifierWallet.address,
+        decision: evaluation.decision,
+        confidence: evaluation.confidence,
+        reason: evaluation.reason,
+        failedCriteria: evaluation.failedCriteria,
+        teeVerified: evaluation.teeVerified,
+        teeProof: evaluation.teeProof,
+        verifierSignature,
+        modelConfig,
+    }, attestHeaders);
+    (0, print_util_1.printJson)(job);
+}
+function assertSupportedAssignment(service, specializations) {
+    if (!specializations.categories.includes(service.category)) {
+        throw new Error(`Verifier is not specialized for ${service.category} services.`);
+    }
+    if (specializations.serviceIds.length > 0 && !specializations.serviceIds.includes(service.serviceId)) {
+        throw new Error(`Verifier is not specialized for service ${service.serviceId}.`);
+    }
+}
+function applyConfidenceThreshold(evaluation, minConfidenceThreshold) {
+    if (evaluation.decision === 'uncertain' || evaluation.confidence >= minConfidenceThreshold) {
+        return evaluation;
+    }
+    const thresholdMessage = `confidence ${evaluation.confidence.toFixed(2)} is below verifier threshold ${minConfidenceThreshold.toFixed(2)}`;
+    return {
+        ...evaluation,
+        decision: 'uncertain',
+        reason: `${evaluation.reason} ${thresholdMessage}.`.trim(),
+        failedCriteria: [...new Set([...evaluation.failedCriteria, thresholdMessage])],
+    };
+}

package/dist/features/verifier/verifier-stats.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifierStatsCommand = runVerifierStatsCommand;
+const api_client_1 = require("@halot/cli/shared/http/api-client");
+const print_util_1 = require("@halot/cli/shared/output/print.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runVerifierStatsCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const config = workspace.readVerifierConfig();
+    const api = new api_client_1.ApiClient(options.server);
+    const stats = await api.get(`/verifiers/${config.verifierId}/stats`);
+    (0, print_util_1.printJson)(stats);
+}

package/dist/features/verifier/verifier-unstake.command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifierUnstakeCommand = runVerifierUnstakeCommand;
+const verifier_registry_service_1 = require("@halot/cli/shared/integrations/zero-g/verifier-registry.service");
+const authority_util_1 = require("@halot/cli/shared/wallet/authority.util");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+async function runVerifierUnstakeCommand(options) {
+    const workspace = new workspace_service_1.WorkspaceService();
+    const registryService = new verifier_registry_service_1.ZeroGVerifierRegistryService();
+    const config = workspace.readVerifierConfig();
+    const wallets = workspace.readWallets(config.authority.path);
+    const verifierWallet = (0, authority_util_1.resolveActorWallet)(wallets, config.authority.actor);
+    const chain = (0, authority_util_1.resolveZeroGAuthorityProfile)(config.authority.actor);
+    const result = options.claim
+        ? await registryService.withdrawStake({
+            privateKey: verifierWallet.privateKey,
+            rpcUrl: chain.rpcUrl,
+        })
+        : await registryService.requestUnstake({
+            privateKey: verifierWallet.privateKey,
+            rpcUrl: chain.rpcUrl,
+        });
+    workspace.writeVerifierConfig({
+        ...config,
+        stake: {
+            ...config.stake,
+            status: options.claim ? 'unlocked' : 'unlocking',
+        },
+    });
+    console.log(`${options.claim ? 'Withdrew verifier stake' : 'Requested verifier unstake'} (${result.transactionHash})`);
+}

package/dist/index.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const browse_command_1 = require("@halot/cli/features/browse/browse.command");
+const job_create_command_1 = require("@halot/cli/features/jobs/job-create.command");
+const job_result_command_1 = require("@halot/cli/features/jobs/job-result.command");
+const job_watch_command_1 = require("@halot/cli/features/jobs/job-watch.command");
+const provider_init_command_1 = require("@halot/cli/features/provider/provider-init.command");
+const provider_register_command_1 = require("@halot/cli/features/provider/provider-register.command");
+const provider_run_command_1 = require("@halot/cli/features/provider/provider-run.command");
+const provider_stats_command_1 = require("@halot/cli/features/provider/provider-stats.command");
+const provider_update_command_1 = require("@halot/cli/features/provider/provider-update.command");
+const quote_command_1 = require("@halot/cli/features/quotes/quote.command");
+const requester_init_command_1 = require("@halot/cli/features/requester/requester-init.command");
+const service_create_command_1 = require("@halot/cli/features/service/service-create.command");
+const service_init_command_1 = require("@halot/cli/features/service/service-init.command");
+const service_list_command_1 = require("@halot/cli/features/service/service-list.command");
+const service_remove_command_1 = require("@halot/cli/features/service/service-remove.command");
+const service_update_command_1 = require("@halot/cli/features/service/service-update.command");
+const verifier_init_command_1 = require("@halot/cli/features/verifier/verifier-init.command");
+const verifier_register_command_1 = require("@halot/cli/features/verifier/verifier-register.command");
+const verifier_run_command_1 = require("@halot/cli/features/verifier/verifier-run.command");
+const verifier_stats_command_1 = require("@halot/cli/features/verifier/verifier-stats.command");
+const verifier_unstake_command_1 = require("@halot/cli/features/verifier/verifier-unstake.command");
+const env_1 = require("@halot/cli/shared/config/env");
+(0, env_1.loadCliEnv)();
+const defaultServerUrl = (0, env_1.loadCliEnv)().serverUrl ?? 'http://localhost:3001';
+const program = new commander_1.Command();
+program
+    .name('halot')
+    .description('Halot protocol CLI')
+    .version('1.0.0');
+program
+    .command('browse')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .option('--service <id>', 'Show a specific service')
+    .action(browse_command_1.runBrowseCommand);
+program
+    .command('quote')
+    .requiredOption('--service <id>', 'Service id')
+    .requiredOption('--input <json>', 'Input JSON')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(quote_command_1.runQuoteCommand);
+const requester = program.command('requester').description('Requester workspace');
+requester
+    .command('init')
+    .action(requester_init_command_1.runRequesterInitCommand);
+const provider = program.command('provider').description('Provider workspace');
+provider.command('init').action(provider_init_command_1.runProviderInitCommand);
+provider
+    .command('register')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(provider_register_command_1.runProviderRegisterCommand);
+provider
+    .command('update')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(provider_update_command_1.runProviderUpdateCommand);
+provider
+    .command('run')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .option('--once', 'Process a single assignment', false)
+    .option('--interval <ms>', 'Polling interval in milliseconds', '3000')
+    .action(provider_run_command_1.runProviderRunCommand);
+provider
+    .command('stats')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(provider_stats_command_1.runProviderStatsCommand);
+const service = program.command('service').description('Service management');
+service
+    .command('init')
+    .option('--name <name>', 'Service name')
+    .option('--description <text>', 'Service description')
+    .option('--category <category>', 'Service category: text, code, image, audio, video, document, tool, workflow')
+    .option('--trust-level <level>', 'Trust level: standard, thorough, critical, auto')
+    .action(service_init_command_1.runServiceInitCommand);
+service
+    .command('register')
+    .alias('create')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .option('--file <name>', 'Service file name')
+    .action(service_create_command_1.runServiceRegisterCommand);
+service
+    .command('list')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(service_list_command_1.runServiceListCommand);
+service
+    .command('update [serviceId]')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .option('--file <name>', 'Service file name')
+    .action(service_update_command_1.runServiceUpdateCommand);
+service
+    .command('remove <serviceId>')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(service_remove_command_1.runServiceRemoveCommand);
+const verifier = program.command('verifier').description('Verifier workspace');
+verifier.command('init').action(verifier_init_command_1.runVerifierInitCommand);
+verifier
+    .command('register')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(verifier_register_command_1.runVerifierRegisterCommand);
+verifier
+    .command('run')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .option('--once', 'Process a single assignment', false)
+    .option('--interval <ms>', 'Polling interval in milliseconds', '3000')
+    .action(verifier_run_command_1.runVerifierRunCommand);
+verifier
+    .command('stats')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(verifier_stats_command_1.runVerifierStatsCommand);
+verifier
+    .command('unstake')
+    .option('--claim', 'Withdraw after cooldown', false)
+    .action(verifier_unstake_command_1.runVerifierUnstakeCommand);
+const job = program.command('job').description('Job lifecycle');
+job
+    .command('create')
+    .requiredOption('--service <id>', 'Service id')
+    .requiredOption('--input <json>', 'Input JSON')
+    .option('--network <id>', 'Preferred settlement network')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(job_create_command_1.runJobCreateCommand);
+job
+    .command('watch <jobId>')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .option('--interval <ms>', 'Polling interval in milliseconds', '3000')
+    .action(job_watch_command_1.runJobWatchCommand);
+job
+    .command('result <jobId>')
+    .option('--server <url>', 'Halot server url', defaultServerUrl)
+    .action(job_result_command_1.runJobResultCommand);
+program.parseAsync().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

package/dist/shared/auth/actor-headers.service.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignedActorHeaders = createSignedActorHeaders;
+const sdk_1 = require("@halot/sdk");
+async function createSignedActorHeaders(wallet, actorId, role, method, path) {
+    return (0, sdk_1.createActorAuthHeaders)(wallet, {
+        actorId,
+        role,
+        method,
+        path,
+        timestamp: (0, sdk_1.nowIso)(),
+    });
+}

package/dist/shared/config/env.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCliEnv = loadCliEnv;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+let cachedEnv = null;
+function loadCliEnv() {
+    if (cachedEnv) {
+        return cachedEnv;
+    }
+    hydrateEnvFile(node_path_1.default.join(process.cwd(), '.env'));
+    const mode = (readStringEnv('HALOT_NETWORK_MODE') || 'testnet');
+    const isTestnet = mode === 'testnet';
+    const suffix = isTestnet ? '_TEST' : '_MAIN';
+    cachedEnv = {
+        networkMode: mode,
+        serverUrl: readStringEnv('HALOT_SERVER_URL')?.replace(/\/+$/u, ''),
+        spaceIdIdentifier: readStringEnv('HALOT_SPACE_ID_IDENTIFIER'),
+        spaceIdControllerAddress: readAddressEnv(`HALOT_SPACE_ID_CONTROLLER_ADDRESS${suffix}`) || readAddressEnv('HALOT_SPACE_ID_CONTROLLER_ADDRESS'),
+        spaceIdResolverAddress: readAddressEnv(`HALOT_SPACE_ID_RESOLVER_ADDRESS${suffix}`) || readAddressEnv('HALOT_SPACE_ID_RESOLVER_ADDRESS'),
+        spaceIdSimulateAccount: readAddressEnv('HALOT_SPACE_ID_SIMULATE_ACCOUNT'),
+        spaceIdSimulateValue: readStringEnv('HALOT_SPACE_ID_SIMULATE_VALUE'),
+        spaceIdGraphUrl: readStringEnv('HALOT_SPACE_ID_GRAPH_URL'),
+        spaceIdVerifiedTldHubAddress: readAddressEnv(`HALOT_SPACE_ID_VERIFIED_TLD_HUB_ADDRESS${suffix}`) || readAddressEnv('HALOT_SPACE_ID_VERIFIED_TLD_HUB_ADDRESS'),
+        spaceIdVerifiedTldHubRpcUrl: readStringEnv(`HALOT_SPACE_ID_VERIFIED_TLD_HUB_RPC_URL${suffix}`) || readStringEnv('HALOT_SPACE_ID_VERIFIED_TLD_HUB_RPC_URL'),
+        zeroGStorageGateway: readStringEnv(`HALOT_ZERO_G_STORAGE_GATEWAY${suffix}`)?.replace(/\/+$/u, '') || readStringEnv('HALOT_ZERO_G_STORAGE_GATEWAY')?.replace(/\/+$/u, ''),
+        agentIdRegistryAddress: readAddressEnv(`HALOT_AGENT_ID_REGISTRY_ADDRESS${suffix}`) || readAddressEnv('HALOT_AGENT_ID_REGISTRY_ADDRESS'),
+        zeroGVerifierRegistryAddress: readAddressEnv(`HALOT_ZERO_G_VERIFIER_REGISTRY_ADDRESS${suffix}`) || readAddressEnv('HALOT_ZERO_G_VERIFIER_REGISTRY_ADDRESS'),
+        defaultStellarRpcUrl: readStringEnv(`HALOT_DEFAULT_STELLAR_RPC_URL${suffix}`) || readStringEnv('HALOT_DEFAULT_STELLAR_RPC_URL'),
+        defaultStellarNetworkPassphrase: readStringEnv(`HALOT_DEFAULT_STELLAR_NETWORK_PASSPHRASE${suffix}`) || readStringEnv('HALOT_DEFAULT_STELLAR_NETWORK_PASSPHRASE'),
+    };
+    return cachedEnv;
+}
+function hydrateEnvFile(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return;
+    }
+    const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+    for (const rawLine of content.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const rawValue = line.slice(separatorIndex + 1).trim();
+        if (!key || process.env[key] !== undefined) {
+            continue;
+        }
+        const value = stripWrappingQuotes(rawValue);
+        process.env[key] = value;
+    }
+}
+function stripWrappingQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function readStringEnv(key) {
+    const value = process.env[key]?.trim();
+    return value ? value : undefined;
+}
+function readAddressEnv(key) {
+    const value = readStringEnv(key);
+    return value;
+}
+function readNumberEnv(key) {
+    const value = readStringEnv(key);
+    return value ? Number(value) : undefined;
+}

package/dist/shared/http/api-client.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+class ApiClient {
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async get(path, headers) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            headers,
+        });
+        return this.handleResponse(response);
+    }
+    async post(path, body, headers) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(headers ?? {}),
+            },
+            body: JSON.stringify(body),
+        });
+        return this.handleResponse(response);
+    }
+    async put(path, body, headers) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'PUT',
+            headers: {
+                'content-type': 'application/json',
+                ...(headers ?? {}),
+            },
+            body: JSON.stringify(body),
+        });
+        return this.handleResponse(response);
+    }
+    async delete(path, headers) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'DELETE',
+            headers,
+        });
+        if (!response.ok) {
+            const data = await response.json().catch(() => ({}));
+            throw new Error(typeof data?.error === 'string' ? data.error : `Request failed with status ${response.status}`);
+        }
+    }
+    async postRaw(path, body, headers) {
+        return fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(headers ?? {}),
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    async handleResponse(response) {
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            throw new Error(typeof data?.error === 'string' ? data.error : `Request failed with status ${response.status}`);
+        }
+        return data;
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/shared/http/event-stream.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectEventStream = connectEventStream;
+async function* connectEventStream(url, headers, lastEventId) {
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            ...(headers ?? {}),
+            ...(lastEventId ? { 'Last-Event-ID': lastEventId } : {}),
+        },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Event stream request failed (${response.status}): ${body}`);
+    }
+    if (!response.body) {
+        throw new Error('Event stream response did not include a body');
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        buffer = buffer.replace(/\r\n/g, '\n');
+        while (true) {
+            const boundary = buffer.indexOf('\n\n');
+            if (boundary === -1) {
+                break;
+            }
+            const rawEvent = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const parsed = parseServerSentEvent(rawEvent);
+            if (parsed) {
+                yield parsed;
+            }
+        }
+    }
+}
+function parseServerSentEvent(rawEvent) {
+    let id;
+    let event = 'message';
+    const dataLines = [];
+    for (const line of rawEvent.split('\n')) {
+        if (!line || line.startsWith(':')) {
+            continue;
+        }
+        const separator = line.indexOf(':');
+        const field = separator === -1 ? line : line.slice(0, separator);
+        let value = separator === -1 ? '' : line.slice(separator + 1);
+        if (value.startsWith(' ')) {
+            value = value.slice(1);
+        }
+        if (field === 'id') {
+            id = value || undefined;
+        }
+        else if (field === 'event') {
+            event = value || 'message';
+        }
+        else if (field === 'data') {
+            dataLines.push(value);
+        }
+    }
+    if (dataLines.length === 0) {
+        return null;
+    }
+    return {
+        id,
+        event,
+        data: dataLines.join('\n'),
+    };
+}