Build on Mekar.

ts
// 1. Register your model once — it becomes an ERC-7857 INFT.
const agentId = await agentINFT.mintGenesis(
  weightsPointer,   // 0G Storage rootHash of your weights
  trainingMerkle,   // Merkle root of your training data
  teeProof,         // TEE attestation hash
  royaltySchema,    // your split — 50/25/15/7/3 by default
);

// 2. Anyone who uses the agent pays through the vault:
await royaltyVault.payInference(agentId, { value: fee });

// 3. A registered compute provider calls settleInference —
//    the fee then cascades on-chain in one atomic tx:
//      50% → you (direct owner)
//      25% → gen-1 parents you forked from
//      15% → gen-2 ancestors
//       7% → gen-3+ (capped at depth 10)
//       3% → training-data contributors
//    Dust + any unpayable share sweeps to the protocol treasury.

bash
RPC=https://evmrpc.0g.ai
VAULT=0x55107dB2CB8399fbA7Fdd913fd5a0FBACd7134f6

# Read the live price for agent #4 (Carol's compose)
PRICE=$(cast call $VAULT \
  "getInferencePrice(uint256)(uint256)" 4 \
  --rpc-url $RPC | awk '{print $1}')

# Pay — escrow opens, requestId emitted as first indexed topic
cast send $VAULT "payInference(uint256)" 4 \
  --value $PRICE \
  --rpc-url $RPC \
  --private-key $PK \
  --legacy --async

ts
import { createWalletClient, createPublicClient, http, parseAbiItem } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const VAULT = "0x55107dB2CB8399fbA7Fdd913fd5a0FBACd7134f6" as const;
const account = privateKeyToAccount(process.env.PK as `0x${string}`);

const wallet = createWalletClient({ account, chain: zg, transport: http() });
const pub = createPublicClient({ chain: zg, transport: http() });

app.post("/inference/:agentId", async (req, res) => {
  const id = BigInt(req.params.agentId);
  const price = await pub.readContract({
    address: VAULT,
    abi: [parseAbiItem("function getInferencePrice(uint256) view returns (uint256)")],
    functionName: "getInferencePrice",
    args: [id],
  });
  const hash = await wallet.writeContract({
    address: VAULT,
    abi: [parseAbiItem("function payInference(uint256) payable returns (bytes32)")],
    functionName: "payInference",
    args: [id],
    value: price,
  });
  res.json({ ok: true, txHash: hash, paid: price.toString() });
});

ts
const event = parseAbiItem(
  "event RoyaltyPaid(uint256 indexed agentId, address indexed recipient, uint16 generation, uint256 amount)"
);

const CHUNK = 50_000n;
const ranges: { from: bigint; to: bigint }[] = [];
for (let f = DEPLOY_BLOCK; f <= latest; f += CHUNK) {
  ranges.push({ from: f, to: f + CHUNK > latest ? latest : f + CHUNK });
}

// 5 concurrent at a time — same trick as the frontend hook
const results = await Promise.all(
  ranges.map(r => client.getLogs({
    address: VAULT, event, fromBlock: r.from, toBlock: r.to
  }))
);

// Group by recipient → leaderboard
const byRecipient = new Map<string, bigint>();
for (const logs of results)
  for (const log of logs)
    byRecipient.set(
      log.args.recipient!,
      (byRecipient.get(log.args.recipient!) ?? 0n) + log.args.amount!
    );

ts
const aesKey = new Uint8Array(32);
crypto.getRandomValues(aesKey);

const [result, err] = await indexer.upload(
  new MemData(Array.from(buf)),
  "https://evmrpc.0g.ai",
  signer,
  { encryption: { type: "aes256", key: aesKey } }
);
// result.rootHash is what you anchor on chain.
// Persist aesKey separately — only key-holders can decrypt.

bash
TX=$(cast send $VAULT ... --async)
for i in 2 3 4 5 6; do
    sleep $i
    status=$(cast receipt $TX --rpc-url $RPC 2>/dev/null | grep ^status | awk '{print $2}')
    [ "$status" = "1" ] && break
done

ts
for (let from = startBlock; from <= latest; from += 50_000n) {
  const to = from + 50_000n > latest ? latest : from + 50_000n;
  const chunk = await client.getLogs({ address, event, fromBlock: from, toBlock: to });
}

ts
await client.writeContract({
  address: VAULT,
  abi: [parseAbiItem("function refundIfTimeout(bytes32 requestId)")],
  functionName: "refundIfTimeout",
  args: [requestId],
});