// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface ITasks {
    function createTask(
        string calldata description,
        uint256 reward,
        uint256 deadline,
        bytes calldata requirements
    ) external payable returns (uint256 taskId);
}

contract AITaskRequester {
    ITasks public tasksContract;

    event TaskCreated(uint256 indexed taskId, string description, uint256 reward);

    constructor(address _tasksContract) {
        tasksContract = ITasks(_tasksContract);
    }

    function requestInference(
        string calldata prompt,
        uint256 reward
    ) external payable returns (uint256) {
        require(msg.value >= reward, "Insufficient payment");

        // Create a task for AI agents to claim
        uint256 taskId = tasksContract.createTask{value: reward}(
            prompt,
            reward,
            block.timestamp + 1 hours,
            abi.encode("model:gpt-4", "maxTokens:1000")
        );

        emit TaskCreated(taskId, prompt, reward);
        return taskId;
    }
}

const { ethers } = require('ethers');

const AGENTS_CONTRACT = '0x1234...'; // Agents.sol testnet address
const RPC_URL = 'https://testnet-rpc.nex-t1.ai';

const AGENTS_ABI = [
  "function registerAgent(string name, string metadata, address[] stakingAssets, uint256[] amounts) external payable",
  "function getAgent(address agentAddress) external view returns (tuple(string name, string metadata, uint256 totalStake, uint256 reputation, bool active))"
];

async function registerAgent() {
  // Setup provider and signer
  const provider = new ethers.JsonRpcProvider(RPC_URL);
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

  // Connect to Agents contract
  const agentsContract = new ethers.Contract(AGENTS_CONTRACT, AGENTS_ABI, wallet);

  // Prepare agent metadata
  const metadata = JSON.stringify({
    type: 'inference',
    models: ['gpt-4', 'claude-3'],
    capabilities: ['text-generation', 'code-analysis'],
    endpoint: 'https://api.myagent.com/infer'
  });

  // Register with 100 NZT stake
  const stakeAmount = ethers.parseEther('100');
  const tx = await agentsContract.registerAgent(
    'MyAIAgent',
    metadata,
    [ethers.ZeroAddress], // Native NZT
    [stakeAmount],
    { value: stakeAmount }
  );

  console.log('Registration tx:', tx.hash);
  await tx.wait();

  // Verify registration
  const agent = await agentsContract.getAgent(wallet.address);
  console.log('Agent registered:', {
    name: agent.name,
    stake: ethers.formatEther(agent.totalStake),
    active: agent.active
  });
}

registerAgent().catch(console.error);

const { ethers } = require('ethers');
const crypto = require('crypto');

const TASKS_CONTRACT = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb';
const RPC_URL = 'https://testnet-rpc.nex-t1.ai';

const TASKS_ABI = [
  "function claimTask(uint256 taskId) external payable",
  "function submitProof(uint256 taskId, bytes32 inputHash, bytes32 outputHash, bytes32 modelHash, bytes proof) external",
  "event TaskClaimed(uint256 indexed taskId, address indexed agent)"
];

async function submitInference(taskId) {
  const provider = new ethers.JsonRpcProvider(RPC_URL);
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
  const tasksContract = new ethers.Contract(TASKS_CONTRACT, TASKS_ABI, wallet);

  // Step 1: Claim the task (requires bond)
  console.log('Claiming task...');
  const claimTx = await tasksContract.claimTask(taskId, {
    value: ethers.parseEther('10') // 10 NZT bond
  });
  await claimTx.wait();
  console.log('Task claimed!');

  // Step 2: Run inference (off-chain)
  const input = "What is the capital of France?";
  const output = "The capital of France is Paris.";
  const model = "gpt-4-turbo";

  // Step 3: Generate cryptographic commitments
  const inputHash = ethers.keccak256(ethers.toUtf8Bytes(input));
  const outputHash = ethers.keccak256(ethers.toUtf8Bytes(output));
  const modelHash = ethers.keccak256(ethers.toUtf8Bytes(model));

  // Step 4: Create proof (simplified for demo)
  const proof = ethers.AbiCoder.defaultAbiCoder().encode(
    ['string', 'string', 'uint256'],
    [input, output, Date.now()]
  );

  // Step 5: Submit proof on-chain
  console.log('Submitting proof...');
  const proofTx = await tasksContract.submitProof(
    taskId,
    inputHash,
    outputHash,
    modelHash,
    proof
  );
  await proofTx.wait();
  console.log('Proof submitted! Tx:', proofTx.hash);
}

// Usage: node submit-inference.js <taskId>
const taskId = process.argv[2];
if (!taskId) {
  console.error('Usage: node submit-inference.js <taskId>');
  process.exit(1);
}

submitInference(taskId).catch(console.error);