289 lines
11 KiB
JavaScript
289 lines
11 KiB
JavaScript
#!/usr/bin/env node
|
|
import { parseArgs } from "util";
|
|
import { parseAbiParameters, createWalletClient, http, publicActions } from "viem";
|
|
import { privateKeyToAccount } from "viem/accounts";
|
|
import { foundry } from "viem/chains";
|
|
import { makeLLMClient } from "../..";
|
|
import { existsSync, readFileSync } from "fs";
|
|
import { resolve } from "path";
|
|
import { makeClient } from "alkahest-ts";
|
|
import { fixtures } from "alkahest-ts";
|
|
import { ProviderName } from "../../nla";
|
|
|
|
// Helper function to display usage
|
|
function displayHelp() {
|
|
console.log(`
|
|
Natural Language Agreement Oracle CLI
|
|
|
|
Usage:
|
|
bun oracle.ts [options]
|
|
|
|
Options:
|
|
--rpc-url <url> RPC URL for the blockchain network (required)
|
|
--private-key <key> Private key of the oracle operator (required)
|
|
--openai-api-key <key> OpenAI API key (optional)
|
|
--anthropic-api-key <key> Anthropic API key (optional)
|
|
--openrouter-api-key <key> OpenRouter API key (optional)
|
|
--perplexity-api-key <key> Perplexity API key for search tools (optional)
|
|
--eas-contract <address> EAS contract address (optional)
|
|
--deployment <file> Load addresses from deployment file (optional)
|
|
--polling-interval <ms> Polling interval in milliseconds (default: 5000)
|
|
--help, -h Display this help message
|
|
|
|
Environment Variables (alternative to CLI options):
|
|
RPC_URL RPC URL for the blockchain network
|
|
ORACLE_PRIVATE_KEY Private key of the oracle operator
|
|
OPENAI_API_KEY OpenAI API key
|
|
ANTHROPIC_API_KEY Anthropic API key
|
|
OPENROUTER_API_KEY OpenRouter API key
|
|
PERPLEXITY_API_KEY Perplexity API key for search tools
|
|
EAS_CONTRACT_ADDRESS EAS contract address
|
|
|
|
Examples:
|
|
# Using command line options
|
|
bun oracle.ts --rpc-url http://localhost:8545 --private-key 0x... --openai-api-key sk-...
|
|
|
|
# Using deployment file
|
|
bun oracle.ts --deployment ./deployments/localhost.json --private-key 0x... --openai-api-key sk-...
|
|
|
|
# Using environment variables
|
|
export OPENAI_API_KEY=sk-...
|
|
export RPC_URL=http://localhost:8545
|
|
export ORACLE_PRIVATE_KEY=0x...
|
|
bun oracle.ts
|
|
`);
|
|
}
|
|
|
|
// Parse command line arguments
|
|
function parseCliArgs() {
|
|
const { values } = parseArgs({
|
|
args: process.argv.slice(2),
|
|
options: {
|
|
"rpc-url": { type: "string" },
|
|
"private-key": { type: "string" },
|
|
"openai-api-key": { type: "string" },
|
|
"anthropic-api-key": { type: "string" },
|
|
"openrouter-api-key": { type: "string" },
|
|
"perplexity-api-key": { type: "string" },
|
|
"eas-contract": { type: "string" },
|
|
"deployment": { type: "string" },
|
|
"polling-interval": { type: "string" },
|
|
"help": { type: "boolean", short: "h" },
|
|
},
|
|
strict: true,
|
|
});
|
|
|
|
return values;
|
|
}
|
|
|
|
// Load deployment file
|
|
function loadDeployment(filePath: string) {
|
|
if (!existsSync(filePath)) {
|
|
throw new Error(`Deployment file not found: ${filePath}`);
|
|
}
|
|
|
|
const content = readFileSync(filePath, "utf-8");
|
|
return JSON.parse(content);
|
|
}
|
|
|
|
// Main function
|
|
async function main() {
|
|
try {
|
|
const args = parseCliArgs();
|
|
|
|
// Display help if requested
|
|
if (args.help) {
|
|
displayHelp();
|
|
process.exit(0);
|
|
}
|
|
|
|
let rpcUrl = args["rpc-url"] || process.env.RPC_URL;
|
|
let easContract = args["eas-contract"] || process.env.EAS_CONTRACT_ADDRESS;
|
|
let deploymentAddresses = null;
|
|
|
|
// Load deployment file if provided
|
|
if (args.deployment) {
|
|
console.log(`📄 Loading deployment from: ${args.deployment}\n`);
|
|
const deployment = loadDeployment(args.deployment);
|
|
deploymentAddresses = deployment.addresses;
|
|
|
|
if (!rpcUrl) {
|
|
rpcUrl = deployment.rpcUrl;
|
|
}
|
|
if (!easContract) {
|
|
easContract = deployment.addresses.eas;
|
|
}
|
|
|
|
console.log(`✅ Loaded deployment (${deployment.network})\n`);
|
|
}
|
|
|
|
const privateKey = args["private-key"] || process.env.ORACLE_PRIVATE_KEY;
|
|
const openaiApiKey = args["openai-api-key"] || process.env.OPENAI_API_KEY;
|
|
const anthropicApiKey = args["anthropic-api-key"] || process.env.ANTHROPIC_API_KEY;
|
|
const openrouterApiKey = args["openrouter-api-key"] || process.env.OPENROUTER_API_KEY;
|
|
const perplexityApiKey = args["perplexity-api-key"] || process.env.PERPLEXITY_API_KEY;
|
|
const pollingInterval = parseInt(args["polling-interval"] || "5000");
|
|
|
|
// Validate required parameters
|
|
if (!rpcUrl) {
|
|
console.error("❌ Error: RPC URL is required. Use --rpc-url or set RPC_URL environment variable.");
|
|
console.error("Run with --help for usage information.");
|
|
process.exit(1);
|
|
}
|
|
|
|
if (!privateKey) {
|
|
console.error("❌ Error: Private key is required. Use --private-key or set ORACLE_PRIVATE_KEY environment variable.");
|
|
console.error("Run with --help for usage information.");
|
|
process.exit(1);
|
|
}
|
|
|
|
// Check if at least one API key is provided
|
|
if (!openaiApiKey && !anthropicApiKey && !openrouterApiKey) {
|
|
console.error("❌ Error: At least one LLM provider API key is required.");
|
|
console.error(" Set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, or OPENROUTER_API_KEY");
|
|
console.error("Run with --help for usage information.");
|
|
process.exit(1);
|
|
}
|
|
|
|
console.log("🚀 Starting Natural Language Agreement Oracle...\n");
|
|
console.log("Configuration:");
|
|
console.log(` 📡 RPC URL: ${rpcUrl}`);
|
|
console.log(` 🔑 Oracle Key: ${privateKey.slice(0, 6)}...${privateKey.slice(-4)}`);
|
|
|
|
// Show available providers
|
|
const availableProviders = [];
|
|
if (openaiApiKey) availableProviders.push("OpenAI");
|
|
if (anthropicApiKey) availableProviders.push("Anthropic");
|
|
if (openrouterApiKey) availableProviders.push("OpenRouter");
|
|
console.log(` 🤖 AI Providers: ${availableProviders.join(", ")}`);
|
|
|
|
if (perplexityApiKey) {
|
|
console.log(` 🔍 Perplexity Search: Enabled`);
|
|
}
|
|
|
|
if (easContract) {
|
|
console.log(` 📝 EAS Contract: ${easContract}`);
|
|
}
|
|
console.log(` ⏱️ Polling Interval: ${pollingInterval}ms\n`);
|
|
|
|
// Create wallet client
|
|
const account = privateKeyToAccount(privateKey as `0x${string}`);
|
|
const walletClient = createWalletClient({
|
|
account,
|
|
chain: foundry,
|
|
transport: http(rpcUrl),
|
|
}).extend(publicActions) as any;
|
|
|
|
// Create alkahest client
|
|
const client = makeClient(walletClient, deploymentAddresses || { eas: easContract });
|
|
|
|
console.log(`✅ Oracle initialized with address: ${account.address}\n`);
|
|
|
|
// Create LLM client
|
|
const llmClient = client.extend(() => ({
|
|
llm: makeLLMClient([]),
|
|
}));
|
|
|
|
// Add all available providers
|
|
if (openaiApiKey) {
|
|
llmClient.llm.addProvider({
|
|
providerName: ProviderName.OpenAI,
|
|
apiKey: openaiApiKey,
|
|
perplexityApiKey: perplexityApiKey,
|
|
});
|
|
console.log("✅ OpenAI provider configured");
|
|
}
|
|
|
|
if (anthropicApiKey) {
|
|
llmClient.llm.addProvider({
|
|
providerName: ProviderName.Anthropic,
|
|
apiKey: anthropicApiKey,
|
|
perplexityApiKey: perplexityApiKey,
|
|
});
|
|
console.log("✅ Anthropic provider configured");
|
|
}
|
|
|
|
if (openrouterApiKey) {
|
|
llmClient.llm.addProvider({
|
|
providerName: ProviderName.OpenRouter,
|
|
apiKey: openrouterApiKey,
|
|
perplexityApiKey: perplexityApiKey,
|
|
});
|
|
console.log("✅ OpenRouter provider configured");
|
|
}
|
|
|
|
console.log("\n🎯 LLM Arbitrator configured and ready\n");
|
|
console.log("👂 Listening for arbitration requests...\n");
|
|
|
|
// Define the obligation ABI
|
|
const obligationAbi = parseAbiParameters("(string item)");
|
|
|
|
// Start listening and arbitrating
|
|
const { unwatch } = await client.arbiters.general.trustedOracle.arbitrateMany(
|
|
async ({ attestation, demand }) => {
|
|
console.log(`\n📨 New arbitration request received!`);
|
|
console.log(` Attestation UID: ${attestation.uid}`);
|
|
|
|
try {
|
|
// Extract obligation data
|
|
const obligation = client.extractObligationData(
|
|
obligationAbi,
|
|
attestation,
|
|
);
|
|
const obligationItem = obligation[0].item;
|
|
console.log(` Obligation: "${obligationItem}"`);
|
|
|
|
const trustedOracleDemandData = client.arbiters.general.trustedOracle.decodeDemand(demand);
|
|
const nlaDemandData = llmClient.llm.decodeDemand(trustedOracleDemandData.data);
|
|
console.log(` Demand: "${nlaDemandData.demand}"`);
|
|
console.log(` Model: ${nlaDemandData.arbitrationModel}`);
|
|
|
|
// Perform arbitration using LLM
|
|
console.log(` 🤔 Arbitrating with AI...`);
|
|
const result = await llmClient.llm.arbitrate(
|
|
nlaDemandData,
|
|
obligationItem
|
|
);
|
|
|
|
console.log(` ✨ Arbitration result: ${result ? "✅ APPROVED" : "❌ REJECTED"}`);
|
|
return result;
|
|
} catch (error) {
|
|
console.error(` ❌ Error during arbitration:`, error);
|
|
throw error;
|
|
}
|
|
},
|
|
{
|
|
onAfterArbitrate: async (decision: any) => {
|
|
console.log(` 📝 Arbitration decision recorded on-chain`);
|
|
console.log(` Decision UID: ${decision.attestation.uid}`);
|
|
console.log(` Result: ${decision.decision ? "✅ Fulfilled" : "❌ Not Fulfilled"}\n`);
|
|
},
|
|
pollingInterval,
|
|
},
|
|
);
|
|
|
|
console.log("✨ Oracle is now running. Press Ctrl+C to stop.\n");
|
|
|
|
// Handle graceful shutdown
|
|
const shutdown = async () => {
|
|
console.log("\n\n🛑 Shutting down oracle...");
|
|
unwatch();
|
|
console.log("👋 Oracle stopped gracefully");
|
|
process.exit(0);
|
|
};
|
|
|
|
process.on("SIGINT", shutdown);
|
|
process.on("SIGTERM", shutdown);
|
|
|
|
// Keep the process alive
|
|
await new Promise(() => { });
|
|
|
|
} catch (error) {
|
|
console.error("❌ Fatal error:", error);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
// Run the CLI
|
|
main();
|