Code Examples

import { ethers } from "ethers";
import { create as createIPFSClient } from "ipfs-http-client";
import fetch from "node-fetch";

// Configuration
const RPC_URL = "https://rpc.nex-t1.ai";
const AGENTS_ADDRESS = "0x..."; // Your deployed Agents contract
const TASKS_ADDRESS = "0x...";   // Your deployed Tasks contract
const PRIVATE_KEY = process.env.PRIVATE_KEY!;

// Initialize providers and contracts
const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

const AGENTS_ABI = [...]; // Import from artifacts
const TASKS_ABI = [...];

const agentsContract = new ethers.Contract(AGENTS_ADDRESS, AGENTS_ABI, wallet);
const tasksContract = new ethers.Contract(TASKS_ADDRESS, TASKS_ABI, wallet);

// IPFS client
const ipfs = createIPFSClient({
  host: "ipfs.infura.io",
  port: 5001,
  protocol: "https",
  headers: {
    authorization: `Basic ${Buffer.from(
      `${process.env.INFURA_PROJECT_ID}:${process.env.INFURA_API_KEY}`
    ).toString("base64")}`
  }
});

// ============================================================================
// Step 1: Register Agent
// ============================================================================

interface AgentMetadata {
  name: string;
  description: string;
  capabilities: string[];
  models: Array<{
    name: string;
    version: string;
    type: string;
  }>;
  pricing: {
    currency: string;
    per_inference: string;
  };
  sla: {
    uptime: string;
    response_time_ms: number;
  };
}

async function registerAgent(
  agentId: bigint,
  metadata: AgentMetadata,
  serviceURI: string
): Promise<string> {
  console.log(`\n[1/5] Registering agent ${agentId}...`);

  try {
    // Upload metadata to IPFS
    const metadataJSON = JSON.stringify(metadata, null, 2);
    const { cid } = await ipfs.add(metadataJSON);
    const metadataURI = `ipfs://${cid}`;
    console.log(`  Metadata uploaded: ${metadataURI}`);

    // Register on-chain
    const tx = await agentsContract.register(agentId, metadataURI, serviceURI, {
      gasLimit: 500000
    });

    console.log(`  Transaction sent: ${tx.hash}`);
    const receipt = await tx.wait();
    console.log(`  ✅ Agent registered (gas used: ${receipt.gasUsed})`);

    return receipt.transactionHash;
  } catch (error: any) {
    if (error.message.includes("AgentAlreadyRegistered")) {
      console.log(`  ℹ️  Agent ${agentId} already registered`);
      return "already-registered";
    }
    throw error;
  }
}

// ============================================================================
// Step 2: Stake for Security
// ============================================================================

async function stakeForAgent(
  agentId: bigint,
  amountETH: string
): Promise<string> {
  console.log(`\n[2/5] Staking ${amountETH} ETH for agent ${agentId}...`);

  const amountWei = ethers.utils.parseEther(amountETH);

  const tx = await agentsContract.stakeETH(agentId, {
    value: amountWei,
    gasLimit: 200000
  });

  console.log(`  Transaction sent: ${tx.hash}`);
  const receipt = await tx.wait();

  // Get updated balance
  const ETH_ADDRESS = ethers.constants.AddressZero;
  const balance = await agentsContract.stakedBalance(agentId, ETH_ADDRESS);

  console.log(`  ✅ Staked (total: ${ethers.utils.formatEther(balance)} ETH)`);
  return receipt.transactionHash;
}

// ============================================================================
// Step 3: Set Up Delegation (Optional)
// ============================================================================

async function setupDelegation(
  agentId: bigint,
  operatorAddress: string
): Promise<void> {
  console.log(`\n[3/5] Setting up delegation for agent ${agentId}...`);

  const PERMISSION_INFERENCE = ethers.utils.id("PERMISSION_INFERENCE");
  const PERMISSION_METADATA = ethers.utils.id("PERMISSION_METADATA");

  // Grant inference permission to operator
  const tx1 = await agentsContract.setDelegate(
    agentId,
    operatorAddress,
    PERMISSION_INFERENCE,
    true,
    { gasLimit: 100000 }
  );
  await tx1.wait();
  console.log(`  ✅ Granted inference permission to ${operatorAddress}`);

  // Grant metadata permission
  const tx2 = await agentsContract.setDelegate(
    agentId,
    operatorAddress,
    PERMISSION_METADATA,
    true,
    { gasLimit: 100000 }
  );
  await tx2.wait();
  console.log(`  ✅ Granted metadata permission to ${operatorAddress}`);
}

// ============================================================================
// Step 4: Execute Inference
// ============================================================================

interface InferenceInput {
  prompt: string;
  parameters?: {
    width?: number;
    height?: number;
    steps?: number;
    guidance_scale?: number;
  };
}

interface InferenceOutput {
  image_url?: string;
  text?: string;
  metadata: {
    model: string;
    execution_time_ms: number;
    timestamp: number;
  };
}

async function executeInference(
  input: InferenceInput
): Promise<InferenceOutput> {
  console.log(`\n[4/5] Executing inference...`);

  // In production, this would call your actual AI model
  // For this example, we'll simulate it
  const startTime = Date.now();

  // Simulate model execution
  await new Promise(resolve => setTimeout(resolve, 2000));

  const output: InferenceOutput = {
    text: `Generated response for: ${input.prompt}`,
    metadata: {
      model: "gpt-4",
      execution_time_ms: Date.now() - startTime,
      timestamp: Date.now()
    }
  };

  console.log(`  ✅ Inference completed in ${output.metadata.execution_time_ms}ms`);
  return output;
}

// ============================================================================
// Step 5: Record Inference On-Chain
// ============================================================================

async function recordInference(
  agentId: bigint,
  input: InferenceInput,
  output: InferenceOutput,
  taskId: bigint = 0n
): Promise<string> {
  console.log(`\n[5/5] Recording inference on-chain...`);

  // Compute hashes
  const inputHash = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes(JSON.stringify(input, Object.keys(input).sort()))
  );

  const outputHash = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes(JSON.stringify(output, Object.keys(output).sort()))
  );

  const modelHash = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes(`${output.metadata.model}:v1.0`)
  );

  console.log(`  Input hash: ${inputHash}`);
  console.log(`  Output hash: ${outputHash}`);
  console.log(`  Model hash: ${modelHash}`);

  // Prepare proof artifact
  const proofArtifact = {
    version: "1.0",
    inference: {
      agentId: agentId.toString(),
      timestamp: Date.now()
    },
    input,
    output,
    model: {
      name: output.metadata.model,
      version: "v1.0"
    },
    execution: {
      duration_ms: output.metadata.execution_time_ms,
      timestamp: output.metadata.timestamp
    }
  };

  // Upload proof to IPFS
  const { cid } = await ipfs.add(JSON.stringify(proofArtifact, null, 2));
  const proofURI = `ipfs://${cid}`;
  console.log(`  Proof uploaded: ${proofURI}`);

  // Record on-chain
  const tx = await agentsContract.recordInference(
    agentId,
    inputHash,
    outputHash,
    modelHash,
    taskId,
    proofURI,
    { gasLimit: 300000 }
  );

  console.log(`  Transaction sent: ${tx.hash}`);
  const receipt = await tx.wait();

  // Extract inference ID from event
  const event = receipt.events?.find(
    (e: any) => e.event === "InferenceRecorded"
  );
  const inferenceId = event?.args?.inferenceId;

  console.log(`  ✅ Inference recorded: ${inferenceId}`);
  return inferenceId;
}

// ============================================================================
// Complete Flow
// ============================================================================

async function completeAgentLifecycle() {
  try {
    const agentId = BigInt(Date.now()); // Use timestamp as unique ID

    // Define agent metadata
    const metadata: AgentMetadata = {
      name: "GPT-4 Agent",
      description: "Advanced language model for text generation",
      capabilities: ["text-generation", "summarization", "translation"],
      models: [
        {
          name: "gpt-4",
          version: "v1.0",
          type: "language-model"
        }
      ],
      pricing: {
        currency: "NEXIS",
        per_inference: "0.01"
      },
      sla: {
        uptime: "99.9%",
        response_time_ms: 5000
      }
    };

    // Step 1: Register agent
    await registerAgent(
      agentId,
      metadata,
      "https://my-agent-service.com/api"
    );

    // Step 2: Stake ETH
    await stakeForAgent(agentId, "1.0");

    // Step 3: Setup delegation (optional)
    const operatorAddress = "0x..."; // Your operator address
    await setupDelegation(agentId, operatorAddress);

    // Step 4: Execute inference
    const input: InferenceInput = {
      prompt: "Explain quantum computing in simple terms",
      parameters: {
        steps: 50
      }
    };

    const output = await executeInference(input);

    // Step 5: Record inference
    const inferenceId = await recordInference(agentId, input, output);

    console.log(`\n✅ Complete agent lifecycle finished!`);
    console.log(`   Agent ID: ${agentId}`);
    console.log(`   Inference ID: ${inferenceId}`);

    return { agentId, inferenceId };
  } catch (error) {
    console.error(`\n❌ Error in agent lifecycle:`, error);
    throw error;
  }
}

// Run the complete flow
completeAgentLifecycle()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

import { ethers } from "ethers";

// ============================================================================
// Task Creator: Post a Task
// ============================================================================

async function postTask(
  reward: string,
  bond: string,
  claimWindow: number,
  completionWindow: number,
  taskDescription: string
): Promise<bigint> {
  console.log(`\n[Creator] Posting task...`);

  // Prepare task metadata
  const metadata = {
    title: "Image Generation Task",
    description: taskDescription,
    requirements: {
      model: "stable-diffusion",
      quality: "high",
      format: "png"
    },
    deliverables: ["generated_image", "proof_of_work"]
  };

  // Upload to IPFS
  const { cid: metadataCID } = await ipfs.add(JSON.stringify(metadata));
  const metadataURI = `ipfs://${metadataCID}`;

  // Upload input data
  const inputData = {
    prompt: "A serene mountain landscape at sunset",
    parameters: {
      width: 1024,
      height: 768,
      steps: 50
    }
  };

  const { cid: inputCID } = await ipfs.add(JSON.stringify(inputData));
  const inputURI = `ipfs://${inputCID}`;

  // Post task
  const rewardWei = ethers.utils.parseEther(reward);
  const bondWei = ethers.utils.parseEther(bond);

  const tx = await tasksContract.postTask(
    ethers.constants.AddressZero, // ETH
    rewardWei,
    bondWei,
    claimWindow,
    completionWindow,
    metadataURI,
    inputURI,
    { value: rewardWei, gasLimit: 400000 }
  );

  const receipt = await tx.wait();
  const event = receipt.events?.find((e: any) => e.event === "TaskCreated");
  const taskId = event?.args?.taskId;

  console.log(`  ✅ Task posted: ${taskId}`);
  console.log(`     Reward: ${reward} ETH`);
  console.log(`     Bond: ${bond} ETH`);

  return taskId;
}

// ============================================================================
// Agent: Claim Task
// ============================================================================

async function claimTask(
  taskId: bigint,
  agentId: bigint
): Promise<void> {
  console.log(`\n[Agent] Claiming task ${taskId} with agent ${agentId}...`);

  // Check agent has sufficient stake
  const ETH_ADDRESS = ethers.constants.AddressZero;
  const stakeView = await agentsContract.stakeBalances(agentId, ETH_ADDRESS);

  console.log(`  Agent stake:`);
  console.log(`    Total: ${ethers.utils.formatEther(stakeView.total)} ETH`);
  console.log(`    Locked: ${ethers.utils.formatEther(stakeView.locked)} ETH`);
  console.log(`    Available: ${ethers.utils.formatEther(stakeView.available)} ETH`);

  // Claim task
  const tx = await tasksContract.claimTask(taskId, agentId, {
    gasLimit: 300000
  });

  await tx.wait();
  console.log(`  ✅ Task claimed`);
}

// ============================================================================
// Agent: Execute Task
// ============================================================================

async function executeTask(taskId: bigint): Promise<{
  output: any;
  inferenceId: string;
}> {
  console.log(`\n[Agent] Executing task ${taskId}...`);

  // Get task details
  const task = await tasksContract.getTask(taskId);

  // Download input from IPFS
  const inputCID = task.inputURI.replace("ipfs://", "");
  const inputResponse = await fetch(`https://ipfs.io/ipfs/${inputCID}`);
  const inputData = await inputResponse.json();

  console.log(`  Task input: ${JSON.stringify(inputData, null, 2)}`);

  // Execute AI inference
  console.log(`  Running AI model...`);
  const output = await executeInference(inputData);

  console.log(`  ✅ Inference completed`);
  return { output, inferenceId: "" };
}

// ============================================================================
// Agent: Submit Work
// ============================================================================

async function submitWork(
  taskId: bigint,
  agentId: bigint,
  output: any
): Promise<string> {
  console.log(`\n[Agent] Submitting work for task ${taskId}...`);

  // Get task details
  const task = await tasksContract.getTask(taskId);

  // Download input
  const inputResponse = await fetch(
    `https://ipfs.io/ipfs/${task.inputURI.replace("ipfs://", "")}`
  );
  const inputData = await inputResponse.json();

  // Record inference
  const inputHash = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes(JSON.stringify(inputData, Object.keys(inputData).sort()))
  );

  const outputHash = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes(JSON.stringify(output, Object.keys(output).sort()))
  );

  const modelHash = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes("stable-diffusion:v2.1")
  );

  // Upload proof
  const proofArtifact = {
    version: "1.0",
    taskId: taskId.toString(),
    agentId: agentId.toString(),
    input: inputData,
    output,
    model: {
      name: "stable-diffusion",
      version: "v2.1"
    }
  };

  const { cid: proofCID } = await ipfs.add(JSON.stringify(proofArtifact));
  const proofURI = `ipfs://${proofCID}`;

  // Record inference
  console.log(`  Recording inference...`);
  const recordTx = await agentsContract.recordInference(
    agentId,
    inputHash,
    outputHash,
    modelHash,
    taskId,
    proofURI,
    { gasLimit: 300000 }
  );

  const recordReceipt = await recordTx.wait();
  const inferenceEvent = recordReceipt.events?.find(
    (e: any) => e.event === "InferenceRecorded"
  );
  const inferenceId = inferenceEvent?.args?.inferenceId;

  console.log(`  Inference recorded: ${inferenceId}`);

  // Submit work to task contract
  console.log(`  Submitting to task contract...`);
  const submitTx = await tasksContract.submitWork(taskId, inferenceId, {
    gasLimit: 200000
  });

  await submitTx.wait();
  console.log(`  ✅ Work submitted`);

  return inferenceId;
}

// ============================================================================
// Verifier: Attest Inference
// ============================================================================

async function attestInference(
  inferenceId: string,
  isValid: boolean
): Promise<void> {
  console.log(`\n[Verifier] Attesting inference ${inferenceId}...`);

  // Get inference details
  const [commitment, _] = await agentsContract.getInference(inferenceId);

  // Download proof from IPFS
  const proofCID = commitment.proofURI.replace("ipfs://", "");
  const proofResponse = await fetch(`https://ipfs.io/ipfs/${proofCID}`);
  const proofData = await proofResponse.json();

  console.log(`  Proof data retrieved`);

  // Perform verification (simplified)
  console.log(`  Verifying proof...`);
  const verified = isValid; // In production, implement actual verification

  // Prepare reputation deltas
  const REPUTATION_DIMENSIONS = {
    ACCURACY: ethers.utils.id("accuracy"),
    RELIABILITY: ethers.utils.id("reliability")
  };

  const deltas = verified
    ? [
        {
          dimension: REPUTATION_DIMENSIONS.ACCURACY,
          delta: 10,
          reason: "Successful verification"
        },
        {
          dimension: REPUTATION_DIMENSIONS.RELIABILITY,
          delta: 5,
          reason: "Timely submission"
        }
      ]
    : [
        {
          dimension: REPUTATION_DIMENSIONS.ACCURACY,
          delta: -20,
          reason: "Failed verification"
        }
      ];

  // Upload attestation to IPFS
  const attestation = {
    inferenceId,
    verified,
    timestamp: Date.now(),
    verifier: await wallet.getAddress()
  };

  const { cid: attestationCID } = await ipfs.add(JSON.stringify(attestation));
  const attestationURI = `ipfs://${attestationCID}`;

  // Submit attestation
  const tx = await agentsContract.attestInference(
    inferenceId,
    verified,
    attestationURI,
    deltas,
    { gasLimit: 400000 }
  );

  await tx.wait();
  console.log(`  ✅ Attestation submitted: ${verified ? "PASSED" : "FAILED"}`);
}

// ============================================================================
// Complete Task Flow
// ============================================================================

async function completeTaskFlow() {
  console.log(`\n${"=".repeat(80)}`);
  console.log(`  COMPLETE TASK EXECUTION FLOW`);
  console.log(`${"=".repeat(80)}`);

  try {
    const agentId = BigInt(Date.now());

    // Setup: Register and stake agent
    console.log(`\n[Setup] Preparing agent ${agentId}...`);
    await registerAgent(
      agentId,
      {
        name: "Image Generation Agent",
        description: "Stable Diffusion image generation service",
        capabilities: ["text-to-image"],
        models: [{ name: "stable-diffusion", version: "v2.1", type: "text-to-image" }],
        pricing: { currency: "NEXIS", per_inference: "0.05" },
        sla: { uptime: "99.9%", response_time_ms: 10000 }
      },
      "https://my-agent.com/api"
    );

    await stakeForAgent(agentId, "2.0");

    // Step 1: Creator posts task
    const taskId = await postTask(
      "0.1",  // 0.1 ETH reward
      "0.5",  // 0.5 ETH bond required
      3600,   // 1 hour claim window
      7200,   // 2 hour completion window
      "Generate a high-quality image of a mountain landscape"
    );

    // Step 2: Agent claims task
    await claimTask(taskId, agentId);

    // Step 3: Agent executes task
    const { output } = await executeTask(taskId);

    // Step 4: Agent submits work
    const inferenceId = await submitWork(taskId, agentId, output);

    // Step 5: Verifier attests
    await attestInference(inferenceId, true);

    console.log(`\n${"=".repeat(80)}`);
    console.log(`  ✅ TASK FLOW COMPLETED SUCCESSFULLY`);
    console.log(`${"=".repeat(80)}`);
    console.log(`     Task ID: ${taskId}`);
    console.log(`     Agent ID: ${agentId}`);
    console.log(`     Inference ID: ${inferenceId}`);

  } catch (error) {
    console.error(`\n❌ Error in task flow:`, error);
    throw error;
  }
}

// Run complete flow
completeTaskFlow()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });