Build With Tee Agent

# Deploy contracts and write deployments.json
npm run deploy:arbitrumSepolia --workspace=contracts
npm run setup-env --workspace=contracts

# Copy an example oracle or create your own handler
cp apps/oracle/src/examples/prediction-market.ts \
  apps/oracle/src/prod/my-oracle.ts

# Fill root .env and apps/oracle/.env, then deploy it
npm run oracle:image
npm run oracle:deploy -- src/prod/my-oracle.ts

# oracle:deploy prints the HTTPS teeOracle endpoint

const handler = {
  async run(payload, ctx) {
    const skill = ctx.blobs[0];
    const config = ctx.blobs[1];
    return {
      answer: await runModel({
        prompt: skill,
        input: payload.question,
        config,
      }),
    };
  },
};

await startOracle({ handler, deployments });

const network = getNetworkConfig("arbitrumSepolia");

const deployment = deployments[String(network.chainId)];
const contracts = deployment.contracts;
const config = {
  chain: network.chain,
  registryAddress: contracts.agentRegistry,
  teeVerifierAddress: contracts.teeVerifier,
  validationRegistryAddress: contracts.validationRegistry,
  identityRegistryAddress: network.identityRegistryAddress,
  reputationRegistryAddress: network.reputationRegistryAddress,
  rpcUrl,
  pinataJwt,
  privateKey,
  zeroGRpcUrl,
  zeroGIndexerUrl,
} satisfies AgentConfig;

const prepared = await prepareMint(config, {
  name: "Prediction Agent",
  description: "Runs inside my Phala CVM.",
  imageUrl,
  ownerAddress,
  services: [{ name: "teeOracle", endpoint: oracleUrl }],
  privateEntries: [{ name: "skill", data: systemPrompt }],
});

await walletClient.writeContract({
  address: prepared.contractAddress,
  abi: AGENT_REGISTRY_ABI,
  functionName: "mint",
  args: [
    ownerAddress,
    prepared.publicMetadataUri, // ERC-721 metadata
    prepared.agentMetadataUri,  // ERC-8004 services
    prepared.intelligentData,   // ERC-7857 private data
  ],
});

const payload = {
  question: "Will ETH close above $4,000 on May 30, 2026?",
  url:
    "https://api.coingecko.com/api/v3/coins/ethereum/market_chart/range?vs_currency=usd&from=1780099200&to=1780185600",
};
const deadline = Math.floor(Date.now() / 1000) + 300;
const typedData = buildRunTypedData({
  oracleAddress,
  chainId: network.chainId,
  agentId,
  payload,
  deadline,
});

const signature = await walletClient.signTypedData({
  account: ownerAddress,
  ...typedData,
});

const run = await fetch(`${oracleUrl}/run`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    agentId: agentId.toString(),
    registryAddress: contracts.agentRegistry,
    payload,
    signature,
    deadline,
  }),
}).then((res) => res.json());

const verified = await fetch(`${oracleUrl}/verify`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ proof: run.proof }),
}).then((res) => res.json());

const requestURI = toDataUri({
  ...
});
const validation = prepareValidation(config, {
  agentId: erc8004AgentId,
  validatorAddress: contracts.teeVerifier,
  requestURI,
});

await walletClient.writeContract({
  address: contracts.validationRegistry,
  abi: VALIDATION_REGISTRY_ABI,
  functionName: "validationRequest",
  args: [
    validation.validatorAddress,
    BigInt(validation.agentId),
    validation.requestURI,
    validation.requestHash,
  ],
});

// Worker watches ValidationRequest events, signs as PRIVATE_KEY,
// then calls the agent teeOracle. The oracle submits validationResponse.
await fetch(`${oracleUrl}/validate`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(validateRequest),
});

const offer = await createTransferOffer(config, transferParams);
const toSign = getTransferAccessPayloadsToSign(offer);
const signatures = await wallet.signMessages(toSign);
const acceptance = buildTransferAcceptance(offer, signatures);
await walletClient.writeContract(buildTransferTxArgs(acceptance));