web.ts

import {
  createPublicClient,
  createWalletClient,
  defineChain,
  http,
  webSocket,
  encodeFunctionData,
  decodeFunctionResult,
  decodeEventLog,
  BaseError,
} from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { config } from './config.js';

const PLATFORM_ADDRESS = '0x037Bb9C718F3f7fe5eCBDB0b600D607b52706776';
const RPC_URL = 'https://dream-rpc.somnia.network/';
const WS_URL = 'wss://dream-rpc.somnia.network/ws';
const PER_AGENT_EXECUTION_COST = 100000000000000000n;
const SUBCOMMITTEE_SIZE = 3n;

const somniaTestnet = defineChain({
  id: 50312,
  name: 'Somnia Testnet',
  nativeCurrency: { decimals: 18, name: 'STT', symbol: 'STT' },
  rpcUrls: {
    default: {
      http: [RPC_URL],
      webSocket: [WS_URL],
    },
  },
});

const ResponseStatus = {
  None: 0,
  Pending: 1,
  Success: 2,
  Failed: 3,
  TimedOut: 4,
} as const;

const platformAbi = [
  {
    type: 'function',
    name: 'createRequest',
    inputs: [
      { type: 'uint256', name: 'agentId' },
      { type: 'address', name: 'callbackAddress' },
      { type: 'bytes4', name: 'callbackSelector' },
      { type: 'bytes', name: 'payload' },
    ],
    outputs: [{ type: 'uint256', name: 'requestId' }],
    stateMutability: 'payable',
  },
  {
    type: 'function',
    name: 'getRequestDeposit',
    inputs: [],
    outputs: [{ type: 'uint256', name: '' }],
    stateMutability: 'view',
  },
  {
    type: 'function',
    name: 'getRequest',
    inputs: [{ type: 'uint256', name: 'requestId' }],
    outputs: [
      {
        type: 'tuple',
        components: [
          { type: 'uint256', name: 'id' },
          { type: 'address', name: 'requester' },
          { type: 'address', name: 'callbackAddress' },
          { type: 'bytes4', name: 'callbackSelector' },
          { type: 'address[]', name: 'subcommittee' },
          {
            type: 'tuple[]',
            name: 'responses',
            components: [
              { type: 'address', name: 'validator' },
              { type: 'bytes', name: 'result' },
              { type: 'uint8', name: 'status' },
              { type: 'uint256', name: 'receipt' },
              { type: 'uint256', name: 'timestamp' },
              { type: 'uint256', name: 'executionCost' },
            ],
          },
          { type: 'uint256', name: 'responseCount' },
          { type: 'uint256', name: 'failureCount' },
          { type: 'uint256', name: 'threshold' },
          { type: 'uint256', name: 'createdAt' },
          { type: 'uint256', name: 'deadline' },
          { type: 'uint8', name: 'status' },
          { type: 'uint8', name: 'consensusType' },
          { type: 'uint256', name: 'remainingBudget' },
          { type: 'uint256', name: 'perAgentBudget' },
        ],
      },
    ],
    stateMutability: 'view',
  },
  {
    type: 'event',
    name: 'RequestCreated',
    inputs: [
      { type: 'uint256', name: 'requestId', indexed: true },
      { type: 'uint256', name: 'agentId', indexed: true },
      { type: 'uint256', name: 'perAgentBudget', indexed: false },
      { type: 'bytes', name: 'payload', indexed: false },
      { type: 'address[]', name: 'subcommittee', indexed: false },
    ],
  },
  {
    type: 'event',
    name: 'RequestFinalized',
    inputs: [
      { type: 'uint256', name: 'requestId', indexed: true },
      { type: 'uint8', name: 'status', indexed: false },
    ],
  },
] as const;

const agentMethodAbi = [
  {
    type: 'function',
    name: 'ExtractString',
    inputs: [
      { type: 'string', name: 'key' },
      { type: 'string', name: 'description' },
      { type: 'string[]', name: 'options' },
      { type: 'string', name: 'prompt' },
      { type: 'string', name: 'url' },
      { type: 'bool', name: 'resolveUrl' },
      { type: 'uint8', name: 'numPages' },
      { type: 'uint8', name: 'confidenceThreshold' },
    ],
    outputs: [{ type: 'string', name: 'output' }],
  },
] as const;

async function invokeAgent(
  key: string,
  description: string,
  options: string[],
  prompt: string,
  url: string,
  resolveUrl: boolean,
  numPages: number,
  confidenceThreshold: number,
) {
  const account = privateKeyToAccount(config.PRIVATE_KEY! as `0x${string}`);

  const walletClient = createWalletClient({
    account,
    chain: somniaTestnet,
    transport: http(RPC_URL),
  });

  const readClient = createPublicClient({
    chain: somniaTestnet,
    transport: http(RPC_URL),
  });

  const eventClient = createPublicClient({
    chain: somniaTestnet,
    transport: webSocket(WS_URL),
  });

  // 1. Encode payload
  const payload = encodeFunctionData({
    abi: agentMethodAbi,
    functionName: 'ExtractString',
    args: [
      key,
      description,
      options,
      prompt,
      url,
      resolveUrl,
      numPages,
      confidenceThreshold,
    ],
  });

  // 2. Calculate deposit
  const reserve = await readClient.readContract({
    address: PLATFORM_ADDRESS,
    abi: platformAbi,
    functionName: 'getRequestDeposit',
  });
  const deposit = reserve + PER_AGENT_EXECUTION_COST * SUBCOMMITTEE_SIZE;

  // 3. Submit request
  const hash = await walletClient.writeContract({
    address: PLATFORM_ADDRESS,
    abi: platformAbi,
    functionName: 'createRequest',
    args: [
      12875401142070969085n,
      '0x0000000000000000000000000000000000000000',
      '0x00000000',
      payload,
    ],
    value: deposit,
  });

  console.log('Transaction submitted:', hash);

  // 4. Extract requestId from receipt
  const receipt = await readClient.waitForTransactionReceipt({
    hash,
    confirmations: 2,
  });

  const createdEvent = receipt.logs
    .map((log) => {
      try {
        return decodeEventLog({
          abi: platformAbi,
          data: log.data,
          topics: log.topics,
        });
      } catch {
        return null;
      }
    })
    .find((e) => e?.eventName === 'RequestCreated');

  const requestId = createdEvent?.args?.requestId;
  if (requestId == null)
    throw new Error('RequestCreated event not found in transaction logs');
  console.log('Request ID:', requestId);

  // 5. Wait for RequestFinalized — capture the block number it landed in
  const { finalizedStatus, finalizedBlockNumber } = await new Promise<{
    finalizedStatus: number;
    finalizedBlockNumber: bigint;
  }>((resolve, reject) => {
    let settled = false;

    const timeout = setTimeout(() => {
      if (settled) return;
      settled = true;
      unwatch();
      reject(
        new Error(
          `Timed out waiting for RequestFinalized for request ${requestId}`,
        ),
      );
    }, 120_000);

    const unwatch = eventClient.watchContractEvent({
      address: PLATFORM_ADDRESS,
      abi: platformAbi,
      eventName: 'RequestFinalized',
      onLogs: (logs) => {
        for (const log of logs) {
          if (log.args.requestId === requestId) {
            if (settled) return;
            settled = true;
            clearTimeout(timeout);
            unwatch();
            resolve({
              finalizedStatus: Number(log.args.status),
              finalizedBlockNumber: log.blockNumber,
            });
            return;
          }
        }
      },
      onError: (error) => {
        if (settled) return;
        settled = true;
        clearTimeout(timeout);
        unwatch();
        reject(error);
      },
    });
  });

  if (finalizedStatus !== ResponseStatus.Success) {
    throw new Error(
      finalizedStatus === ResponseStatus.Failed
        ? `Agent execution failed for request ${requestId}`
        : `Request ${requestId} finalized with status ${finalizedStatus}`,
    );
  }

  // 6. Read request at the block BEFORE finalization — still exists in that state
  console.log(`Reading request state at block ${finalizedBlockNumber - 1n}...`);

  let request;
  try {
    request = await readClient.readContract({
      account,
      address: PLATFORM_ADDRESS,
      abi: platformAbi,
      functionName: 'getRequest',
      args: [requestId],
      blockNumber: finalizedBlockNumber - 1n, // request not yet deleted here
    });
  } catch (error) {
    const details =
      error instanceof BaseError
        ? error.shortMessage
        : error instanceof Error
          ? error.message
          : String(error);
    throw new Error(
      `Failed to read request ${requestId} at pre-finalization block: ${details}`,
    );
  }

  console.log('Responses:', request.responses);

  // 7. Find the first successful response (not just index 0)
  const successfulResponse = request.responses.find(
    (r) => r.status === ResponseStatus.Success,
  );

  if (!successfulResponse) {
    throw new Error(`No successful response found for request ${requestId}`);
  }

  const result = decodeFunctionResult({
    abi: agentMethodAbi,
    functionName: 'ExtractString',
    data: successfulResponse.result,
  });

  console.log('Result:', result);
  return result;
}

export default invokeAgent;