@ixo/oracle-runtime-workers 0.29.1 → 0.30.0

package/src/plugins/ixo-chain/kinds/indexed/daos.ts

@@ -0,0 +1,319 @@
+/**
+ * `daos`: the DAO DAO DAOs an account belongs to, through each kind of
+ * membership the index keeps: native-token staking, cw20 staking and cw4
+ * group membership, as one alias holding one sub-field per kind of
+ * membership (Blocksync's `query` field nests the root query type). Each
+ * reaches its DAO through relations, so one document answers it.
+ *
+ * Index (ixo-blocksync main, `20250611142429900_daodao_epochs.sql`):
+ * `idx_dao_native_staker_address`, `idx_dao_cw20_staker_address` and
+ * `idx_dao_cw4_member_address` serve the account; the voting module is a
+ * primary key, `idx_dao_voting_module_staking_contract` serves cw20,
+ * `idx_dao_core_voting_module` the DAO. A cw4 group's voting modules are
+ * found by `dao_voting_module.group_contract_address`, which no index
+ * leads; that table holds one row per DAO, and a member of three groups
+ * answered in 0.27 s on mainnet on Oct 29 2026. cw721 (NFT) staking is not read.
+ * Each list is ordered by its primary key (voting module or contract
+ * address).
+ */
+import { z } from 'zod';
+import { displayCoin } from '../coins';
+import { defineKind, type KindContext, type KindResult } from '../types';
+import { accountArg, firstArg } from '../../queries';
+import { text } from '../../summaries';
+import {
+  PAGE,
+  accountFor,
+  amountText,
+  chainCoin,
+  compact,
+  connection,
+  equalTo,
+  idText,
+  listResult,
+  longText,
+  num,
+  opt,
+  str,
+  unexpected,
+} from './shared';
+
+/** Voting modules read per cw4 group or cw20 staking contract (several DAOs can share one). */
+const MODULES_PER_CONTRACT = 3;
+
+const args = z.strictObject({
+  address: accountArg('Member'),
+  first: firstArg,
+});
+
+/**
+ * The membership sub-fields of `address`, `perList` rows each, with
+ * `core` as the selection set of each DAO core reached.
+ */
+export function membershipFields(
+  address: string,
+  perList: number,
+  core: string,
+): string {
+  const cores = `daoCoresByVotingModule(first: 1) { nodes { ${core} } }`;
+  const staker = equalTo('stakerAddress', address);
+  const member = equalTo('memberAddress', address);
+  const modules = (relation: string, fields: string) =>
+    `${relation}(first: ${MODULES_PER_CONTRACT}) { nodes { ${fields} ${cores} } }`;
+  return [
+    `native: daoNativeStakers(filter: ${staker}, first: ${perList}, orderBy: PRIMARY_KEY_ASC) { ${PAGE} nodes { stakedAmount daoVotingModuleByVotingModuleAddress { address moduleType nativeDenom totalWeight ${cores} } } }`,
+    `cw20: daoCw20Stakers(filter: ${staker}, first: ${perList}, orderBy: PRIMARY_KEY_ASC) { ${PAGE} nodes { stakedAmount daoCw20StakingContractByStakingContract { ${modules('daoVotingModulesByStakingContract', 'address moduleType tokenAddress totalWeight')} } } }`,
+    `cw4: daoCw4Members(filter: ${member}, first: ${perList}, orderBy: PRIMARY_KEY_ASC) { ${PAGE} nodes { weight daoCw4GroupContractByGroupContractAddress { ${modules('daoVotingModulesByGroupContractAddress', 'address moduleType totalWeight')} } } }`,
+  ].join(' ');
+}
+
+const moduleNode = <T extends z.ZodType>(core: T) =>
+  z.looseObject({
+    address: str,
+    moduleType: opt,
+    nativeDenom: opt,
+    tokenAddress: opt,
+    totalWeight: num,
+    daoCoresByVotingModule: z.object({ nodes: z.array(core) }),
+  });
+
+/** The answer of {@link membershipFields} with `core` as each DAO core's shape. */
+export function membershipSchema<T extends z.ZodType>(core: T) {
+  const module = moduleNode(core);
+  const modules = z.object({ nodes: z.array(module) });
+  return z.looseObject({
+    native: connection(
+      z.looseObject({
+        stakedAmount: num,
+        daoVotingModuleByVotingModuleAddress: module.nullish(),
+      }),
+    ),
+    cw20: connection(
+      z.looseObject({
+        stakedAmount: num,
+        daoCw20StakingContractByStakingContract: z
+          .looseObject({ daoVotingModulesByStakingContract: modules })
+          .nullish(),
+      }),
+    ),
+    cw4: connection(
+      z.looseObject({
+        weight: z.number().nullish(),
+        daoCw4GroupContractByGroupContractAddress: z
+          .looseObject({ daoVotingModulesByGroupContractAddress: modules })
+          .nullish(),
+      }),
+    ),
+  });
+}
+
+/** One DAO reached through one membership. */
+interface Membership<C> {
+  core: C;
+  membership: 'native-staked' | 'cw20-staked' | 'cw4-member';
+  votingModule: string;
+  moduleType?: string;
+  /** Staked base units (native or cw20), or the cw4 weight. */
+  weight?: string;
+  nativeDenom?: string;
+  tokenAddress?: string;
+  totalWeight?: string;
+}
+
+type Page = { pageInfo?: { hasNextPage: boolean } };
+type Amount = string | number | null | undefined;
+interface ModuleRow<C> {
+  address: string;
+  moduleType?: string | null;
+  nativeDenom?: string | null;
+  tokenAddress?: string | null;
+  totalWeight?: Amount;
+  daoCoresByVotingModule: { nodes: C[] };
+}
+/** The parsed answer of {@link membershipFields} (see {@link membershipSchema}). */
+export interface MembershipRows<C> {
+  native: Page & {
+    nodes: {
+      stakedAmount?: Amount;
+      daoVotingModuleByVotingModuleAddress?: ModuleRow<C> | null;
+    }[];
+  };
+  cw20: Page & {
+    nodes: {
+      stakedAmount?: Amount;
+      daoCw20StakingContractByStakingContract?: {
+        daoVotingModulesByStakingContract: { nodes: ModuleRow<C>[] };
+      } | null;
+    }[];
+  };
+  cw4: Page & {
+    nodes: {
+      weight?: number | null;
+      daoCw4GroupContractByGroupContractAddress?: {
+        daoVotingModulesByGroupContractAddress: { nodes: ModuleRow<C>[] };
+      } | null;
+    }[];
+  };
+}
+
+/** Every DAO the memberships reach, native stakes first, then cw20 stakes, then cw4 groups. */
+export function membershipsOf<C>(answer: MembershipRows<C>): Membership<C>[] {
+  const out: Membership<C>[] = [];
+  const add = (
+    membership: Membership<C>['membership'],
+    module: ModuleRow<C>,
+    weight: Amount,
+  ) => {
+    for (const core of module.daoCoresByVotingModule.nodes)
+      out.push({
+        core,
+        membership,
+        votingModule: module.address,
+        moduleType: module.moduleType ?? undefined,
+        weight: amountText(weight),
+        nativeDenom: module.nativeDenom ?? undefined,
+        tokenAddress: module.tokenAddress ?? undefined,
+        totalWeight: amountText(module.totalWeight),
+      });
+  };
+  for (const row of answer.native.nodes)
+    if (row.daoVotingModuleByVotingModuleAddress)
+      add(
+        'native-staked',
+        row.daoVotingModuleByVotingModuleAddress,
+        row.stakedAmount,
+      );
+  for (const row of answer.cw20.nodes)
+    for (const module of row.daoCw20StakingContractByStakingContract
+      ?.daoVotingModulesByStakingContract.nodes ?? [])
+      add('cw20-staked', module, row.stakedAmount);
+  for (const row of answer.cw4.nodes)
+    for (const module of row.daoCw4GroupContractByGroupContractAddress
+      ?.daoVotingModulesByGroupContractAddress.nodes ?? [])
+      add('cw4-member', module, row.weight);
+  return out;
+}
+
+/** Whether any membership list holds rows past those read. */
+export function moreMemberships<C>(answer: MembershipRows<C>): boolean {
+  return [answer.native, answer.cw20, answer.cw4].some(
+    (list) => list.pageInfo?.hasNextPage === true,
+  );
+}
+
+const DIGITS = /^\d+$/;
+
+/** `part / whole` as a percentage with two decimals, rounded down; undefined unless both are whole numbers. */
+function shareOf(part?: string, whole?: string): string | undefined {
+  if (!part || !whole || !DIGITS.test(part) || !DIGITS.test(whole))
+    return undefined;
+  const total = BigInt(whole);
+  if (total === 0n) return undefined;
+  const basisPoints = (BigInt(part) * 10_000n) / total;
+  return `${basisPoints / 100n}.${String(basisPoints % 100n).padStart(2, '0')}%`;
+}
+
+const coreNode = z.looseObject({
+  address: str,
+  name: opt,
+  description: opt,
+});
+
+/** What a DAO row shows of its core. */
+type CoreText = {
+  address: string;
+  name?: string | null;
+  description?: string | null;
+};
+
+async function daoOf(ctx: KindContext, entry: Membership<CoreText>) {
+  const native =
+    entry.membership === 'native-staked' && entry.nativeDenom
+      ? chainCoin({ denom: entry.nativeDenom, amount: entry.weight })
+      : undefined;
+  const staked = native
+    ? ((await displayCoin(ctx, native)) ?? undefined)
+    : entry.membership === 'cw20-staked' && entry.weight
+      ? compact({
+          token: idText(entry.tokenAddress),
+          amountBaseUnits: entry.weight,
+        })
+      : undefined;
+  const name = text(entry.core.name);
+  const description = longText(entry.core.description);
+  const cw4 = entry.membership === 'cw4-member';
+  return compact({
+    dao: idText(entry.core.address),
+    name,
+    description,
+    nameIsSelfChosen: name || description ? true : undefined,
+    membership: entry.membership,
+    // A cw4 group's admin adds members without their consent.
+    addedByGroupAdmin: cw4 ? true : undefined,
+    staked,
+    weight: cw4 ? entry.weight : undefined,
+    votingPowerShare: shareOf(entry.weight, entry.totalWeight),
+    votingModule: idText(entry.votingModule),
+    moduleType: text(entry.moduleType, 80),
+  });
+}
+
+/**
+ * The `daos` answer's data from the membership answer: the first `n`
+ * DAOs, and `more` when the index holds further memberships.
+ */
+export async function daosData<C extends CoreText>(
+  ctx: KindContext,
+  answer: MembershipRows<C>,
+  n: number,
+): Promise<Record<string, unknown>> {
+  const all = membershipsOf(answer);
+  return compact({
+    items: await Promise.all(all.slice(0, n).map((entry) => daoOf(ctx, entry))),
+    more: all.length > n || moreMemberships(answer) ? true : undefined,
+  });
+}
+
+const answerSchema = membershipSchema(coreNode);
+
+export const daos = defineKind({
+  name: 'daos',
+  summary:
+    'DAOs an account (default: the user) is a member of, how (staked or group member) and its share of the voting power.',
+  explain: [
+    'A DAO (DAO DAO on the IXO chain) decides by proposals and votes; its voting module sets who votes and with what weight.',
+    '`membership`: `cw4-member` (a group member with a fixed `weight`), `cw20-staked` (voting power from cw20 tokens staked in the DAO, `staked.amountBaseUnits` of the `staked.token` contract) or `native-staked` (from staked bank tokens, e.g. IXO; `staked` is a bank coin, `amount` in display units beside `symbol`).',
+    '`votingPowerShare` is the account’s weight or stake over the voting module’s total, rounded down; staked tokens count only while staked, and unstaking may take a waiting period.',
+    'Each: dao (the DAO core contract address), name, description, membership, staked or weight, votingPowerShare, votingModule.',
+    '`addedByGroupAdmin: true` (every cw4-member row): a cw4 group’s admin can add any address to the group without its consent, so membership alone does not mean the account joined, agreed or knows of the DAO.',
+    '`nameIsSelfChosen: true`: the name and description are whatever the DAO set for itself, never a verified identity or an endorsement; say so before relying on them.',
+    'NFT (cw721) staking is not indexed here. Ask `dao_proposals` for what the DAOs are voting on.',
+  ].join(' '),
+  source: 'blocksync',
+  list: true,
+  args,
+  example: {},
+  plan(input, ctx) {
+    const member = accountFor(input.address, ctx.identity, 'address');
+    if ('invalid' in member) return member;
+    const n = ctx.first;
+    const subfields = membershipFields(
+      member.address,
+      n,
+      'address name description',
+    );
+    return {
+      source: 'blocksync',
+      field: (alias) => `${alias}: query { ${subfields} }`,
+      async shape(raw): Promise<KindResult> {
+        const parsed = answerSchema.safeParse(raw);
+        if (!parsed.success) return { ok: false, ...unexpected };
+        return listResult(
+          await daosData(ctx, parsed.data, n),
+          n,
+          member.subject,
+        );
+      },
+    };
+  },
+});

package/src/plugins/ixo-chain/kinds/indexed/disputes.ts

@@ -0,0 +1,159 @@
+/**
+ * `disputes`: x/claims disputes against one claim, or those an account
+ * filed (default: the user), with their resolution.
+ *
+ * Index (ixo-blocksync main): `Dispute_subjectId_idx` ("subjectId") and
+ * `Dispute_disputerAddress_idx` ("disputerAddress"); ordered by the
+ * primary key `id` (filing order), newest first. The resolution is the
+ * 1:1 `DisputeResolution` row (primary key "disputeId"). The filing's and
+ * the resolution's `data` (evidence links and proofs) are not read.
+ */
+import { z } from 'zod';
+import { COINS_NOTE } from '../coins';
+import { defineKind, type KindContext, type KindResult } from '../types';
+import { accountArg, firstArg } from '../../queries';
+import {
+  PAGE,
+  accountFor,
+  bankCoins,
+  claimIdArg,
+  compact,
+  connection,
+  equalTo,
+  idText,
+  listResult,
+  opt,
+  str,
+  unexpected,
+} from './shared';
+
+/** x/claims `DisputeStatus`. */
+const STATUS = ['open', 'awarded', 'dismissed'] as const;
+/** x/claims `DisputeTargetRole`: the party of the claim disputed. */
+const TARGET = ['unspecified', 'submitter', 'evaluator'] as const;
+
+const args = z
+  .strictObject({
+    claimId: claimIdArg('Every dispute against this claim.'),
+    address: accountArg('Disputer (who filed)'),
+    first: firstArg,
+  })
+  .refine(
+    (value) => value.claimId === undefined || value.address === undefined,
+    { message: 'give claimId or address, not both' },
+  );
+
+const RESOLUTION_FIELDS =
+  'resolvedAt adjudicatorDid adjudicatorAddress intendedPenalty actualPenaltyPaid winnerAddress winnerAmount loserAddress adjudicatorAmount';
+const FIELDS = `id subjectId type targetRole status disputerAddress disputerDid disputeDeposit submittedAt resolution { ${RESOLUTION_FIELDS} }`;
+
+const resolutionNode = z.looseObject({
+  resolvedAt: opt,
+  adjudicatorDid: opt,
+  adjudicatorAddress: opt,
+  intendedPenalty: z.unknown().optional(),
+  actualPenaltyPaid: z.unknown().optional(),
+  winnerAddress: opt,
+  winnerAmount: z.unknown().optional(),
+  loserAddress: opt,
+  adjudicatorAmount: z.unknown().optional(),
+});
+const node = z.looseObject({
+  id: z.union([z.string(), z.number()]),
+  subjectId: str,
+  type: z.number().nullish(),
+  targetRole: z.number().nullish(),
+  status: z.number().nullish(),
+  disputerAddress: opt,
+  disputerDid: opt,
+  disputeDeposit: z.unknown().optional(),
+  submittedAt: opt,
+  resolution: resolutionNode.nullish(),
+});
+
+function named<T extends readonly string[]>(
+  names: T,
+  value: number | null | undefined,
+): string | undefined {
+  if (value === null || value === undefined) return undefined;
+  return names[value] ?? `unknown (${value})`;
+}
+
+async function disputeOf(ctx: KindContext, row: z.infer<typeof node>) {
+  const resolution = row.resolution;
+  return compact({
+    id: idText(String(row.id)),
+    claimId: idText(row.subjectId),
+    against: named(TARGET, row.targetRole),
+    status: named(STATUS, row.status),
+    type: row.type ?? undefined,
+    disputer: idText(row.disputerAddress),
+    disputerDid: idText(row.disputerDid),
+    deposit: await bankCoins(ctx, row.disputeDeposit),
+    submittedAt: idText(row.submittedAt),
+    resolution: resolution
+      ? compact({
+          resolvedAt: idText(resolution.resolvedAt),
+          adjudicator: idText(resolution.adjudicatorAddress),
+          adjudicatorDid: idText(resolution.adjudicatorDid),
+          intendedPenalty: await bankCoins(ctx, resolution.intendedPenalty),
+          penaltyPaid: await bankCoins(ctx, resolution.actualPenaltyPaid),
+          winner: idText(resolution.winnerAddress),
+          winnerAmount: await bankCoins(ctx, resolution.winnerAmount),
+          loser: idText(resolution.loserAddress),
+          adjudicatorAmount: await bankCoins(ctx, resolution.adjudicatorAmount),
+        })
+      : undefined,
+  });
+}
+
+export const disputes = defineKind({
+  name: 'disputes',
+  summary:
+    'Disputes against a claim, or those an account filed (default: the user), with how each was resolved.',
+  explain: [
+    'A dispute challenges one party of a claim: `against` is `submitter` (the agent that submitted it) or `evaluator` (the agent that evaluated it). The disputer locks a deposit; an adjudicator the collection names then rules.',
+    'Status: `open` (awaiting a ruling; the disputed agent cannot submit or withdraw its deposit in that collection meanwhile), `awarded` (upheld: the disputed party was in the wrong, its deposit is slashed, the disputer gets its deposit back and most of the penalty) or `dismissed` (the disputed party was vindicated; the disputer’s deposit becomes the penalty).',
+    '`resolution`: when and by whom, the intended and actually paid penalty (capped by what the loser had), the winner, the loser, and the shares paid out.',
+    '`type` is a number the client defines. Newest first. Evidence documents are not shown.',
+    COINS_NOTE,
+  ].join(' '),
+  source: 'blocksync',
+  list: true,
+  args,
+  example: {
+    claimId: 'bafkreibqh2o3cx2bhnvxhoknbashrse3lhxh5rjohyqgy5yoqqc5jhqgpm',
+  },
+  plan(input, ctx) {
+    const n = ctx.first;
+    let filter: string;
+    let subject: 'user' | 'other' | undefined;
+    if (input.claimId !== undefined)
+      filter = equalTo('subjectId', input.claimId);
+    else {
+      const disputer = accountFor(input.address, ctx.identity, 'address');
+      if ('invalid' in disputer) return disputer;
+      filter = equalTo('disputerAddress', disputer.address);
+      subject = disputer.subject;
+    }
+    return {
+      source: 'blocksync',
+      field: (alias) =>
+        `${alias}: disputes(filter: ${filter}, first: ${n}, orderBy: ID_DESC) { ${PAGE} nodes { ${FIELDS} } }`,
+      async shape(raw): Promise<KindResult> {
+        const parsed = connection(node).safeParse(raw);
+        if (!parsed.success) return { ok: false, ...unexpected };
+        return listResult(
+          {
+            items: await Promise.all(
+              parsed.data.nodes.map((row) => disputeOf(ctx, row)),
+            ),
+            more: parsed.data.pageInfo?.hasNextPage ? true : undefined,
+          },
+          n,
+          subject,
+        );
+      },
+    };
+  },
+});

package/src/plugins/ixo-chain/kinds/indexed/evaluations.ts

@@ -0,0 +1,172 @@
+/**
+ * `evaluations`: x/claims evaluations, by claim, by collection or by the
+ * agent that evaluated (default: the user).
+ *
+ * Index (ixo-blocksync main): `Evaluation_claimId_evaluationDate_idx`
+ * ("claimId", "evaluationDate" DESC) and
+ * `Evaluation_collectionId_evaluationDate_id_idx` ("collectionId",
+ * "evaluationDate", "id") serve the claim and collection reads in
+ * `EVALUATION_DATE_DESC` order; `Evaluation_agentAddress_idx`
+ * ("agentAddress") serves the evaluator read, ordered by the primary key
+ * `id` (indexing order).
+ */
+import { z } from 'zod';
+import { COINS_NOTE } from '../coins';
+import { defineKind, type KindContext, type KindResult } from '../types';
+import { accountArg, firstArg } from '../../queries';
+import {
+  PAGE,
+  accountFor,
+  bankCoins,
+  claimIdArg,
+  collectionIdArg,
+  compact,
+  connection,
+  cw1155Amounts,
+  cw20Amounts,
+  equalTo,
+  idText,
+  listResult,
+  nonEmpty,
+  num,
+  opt,
+  str,
+  unexpected,
+} from './shared';
+
+/** x/claims `EvaluationStatus`. */
+const STATUS = [
+  'pending',
+  'approved',
+  'rejected',
+  'disputed',
+  'invalidated',
+  'flagged',
+] as const;
+
+const args = z
+  .strictObject({
+    claimId: claimIdArg('Every evaluation of this claim (its history).'),
+    collectionId: collectionIdArg(
+      'Every evaluation in this collection, e.g. "8250".',
+    ),
+    evaluator: accountArg('The agent that evaluated'),
+    first: firstArg,
+  })
+  .refine(
+    (value) =>
+      [value.claimId, value.collectionId, value.evaluator].filter(
+        (given) => given !== undefined,
+      ).length <= 1,
+    { message: 'give at most one of claimId, collectionId and evaluator' },
+  );
+
+// `cw1155Payment` is on the mainnet index's `Evaluation` (introspected on
+// Oct 29 2026), as the chain's `[{ address, token_id, amount }]`.
+const FIELDS =
+  'claimId collectionId oracle agentDid agentAddress status reason verificationProof amount cw20Payment cw1155Payment evaluationDate';
+
+const node = z.looseObject({
+  claimId: str,
+  collectionId: str,
+  oracle: opt,
+  agentDid: opt,
+  agentAddress: opt,
+  status: z.number().nullish(),
+  reason: num,
+  verificationProof: opt,
+  amount: z.unknown().optional(),
+  cw20Payment: z.unknown().optional(),
+  cw1155Payment: z.unknown().optional(),
+  evaluationDate: opt,
+});
+
+function statusOf(value: number | null | undefined): string | undefined {
+  if (value === null || value === undefined) return undefined;
+  return STATUS[value] ?? `unknown (${value})`;
+}
+
+async function evaluationOf(ctx: KindContext, row: z.infer<typeof node>) {
+  const coins = await bankCoins(ctx, row.amount);
+  const cw20 = nonEmpty(cw20Amounts(row.cw20Payment));
+  const cw1155 = nonEmpty(cw1155Amounts(row.cw1155Payment));
+  return compact({
+    claimId: idText(row.claimId),
+    collectionId: idText(row.collectionId),
+    status: statusOf(row.status),
+    evaluationDate: idText(row.evaluationDate),
+    evaluatorAddress: idText(row.agentAddress),
+    evaluatorDid: idText(row.agentDid),
+    oracle: idText(row.oracle),
+    reasonCode:
+      row.reason === null || row.reason === undefined
+        ? undefined
+        : idText(String(row.reason)),
+    verificationProof: idText(row.verificationProof),
+    coins,
+    cw20,
+    cw1155,
+    // x/claims pays the collection's default approval payment only when an
+    // evaluation sets none of the three; any one set replaces all of it.
+    defaultPayment: !coins && !cw20 && !cw1155 ? true : undefined,
+  });
+}
+
+export const evaluations = defineKind({
+  name: 'evaluations',
+  summary:
+    'Claim evaluations: the history of one claim, a collection, or what an agent evaluated (default: the user).',
+  explain: [
+    'An evaluation is the verdict an evaluation agent, acting for an oracle, gives a claim: approved claims get paid from the collection, rejected ones do not.',
+    'Status: pending, approved, rejected, disputed, invalidated, or flagged (the evaluator declined to decide yet; the claim can be evaluated again, and only a later approved/rejected/invalidated is final).',
+    'A claim can have several evaluations (flagged, then decided); with claimId they are newest first.',
+    'Each: claimId, collectionId, status, evaluationDate, evaluatorAddress/evaluatorDid (the agent that evaluated), oracle (the oracle entity it evaluated for), reasonCode (a number the evaluator defines), verificationProof (the CID of the evaluation credential).',
+    '`coins` (bank coins), `cw20` (base units per token contract) and `cw1155` (whole units of the listed token ids per contract) are the approval payment the evaluation set: together they replace the collection’s default, so one absent beside another pays nothing of its kind.',
+    '`defaultPayment: true`: it set none of them, so an approval pays the collection’s default approval payment (see claim_collection payments). A claim with an intent is paid its intent amounts, which the evaluation then carries.',
+    COINS_NOTE,
+    'For the evaluations of claims an account submitted, ask `claims` (each carries its current evaluation) or this kind with a claimId.',
+    'Give at most one of claimId, collectionId, evaluator; with none, the user’s own evaluations.',
+  ].join(' '),
+  source: 'blocksync',
+  list: true,
+  args,
+  example: { collectionId: '8250', first: 5 },
+  plan(input, ctx) {
+    const n = ctx.first;
+    let filter: string;
+    let orderBy: string;
+    let subject: 'user' | 'other' | undefined;
+    if (input.claimId !== undefined) {
+      filter = equalTo('claimId', input.claimId);
+      orderBy = 'EVALUATION_DATE_DESC';
+    } else if (input.collectionId !== undefined) {
+      filter = equalTo('collectionId', input.collectionId);
+      orderBy = 'EVALUATION_DATE_DESC';
+    } else {
+      const evaluator = accountFor(input.evaluator, ctx.identity, 'evaluator');
+      if ('invalid' in evaluator) return evaluator;
+      filter = equalTo('agentAddress', evaluator.address);
+      orderBy = 'ID_DESC';
+      subject = evaluator.subject;
+    }
+    return {
+      source: 'blocksync',
+      field: (alias) =>
+        `${alias}: evaluations(filter: ${filter}, first: ${n}, orderBy: ${orderBy}) { ${PAGE} nodes { ${FIELDS} } }`,
+      async shape(raw): Promise<KindResult> {
+        const parsed = connection(node).safeParse(raw);
+        if (!parsed.success) return { ok: false, ...unexpected };
+        return listResult(
+          {
+            items: await Promise.all(
+              parsed.data.nodes.map((row) => evaluationOf(ctx, row)),
+            ),
+            more: parsed.data.pageInfo?.hasNextPage ? true : undefined,
+          },
+          n,
+          subject,
+        );
+      },
+    };
+  },
+});

package/src/plugins/ixo-chain/kinds/indexed/index.ts

@@ -0,0 +1,21 @@
+import type { KindDef } from '../types';
+import { agentDeposits } from './agent-deposits';
+import { daoProposals } from './dao-proposals';
+import { daos } from './daos';
+import { disputes } from './disputes';
+import { evaluations } from './evaluations';
+import { liquidStakeHistory } from './liquid-stake-history';
+import { memberBudgets } from './member-budgets';
+import { tokenHistory } from './token-history';
+
+/** Kinds answered by the Blocksync index, in catalogue order. */
+export const INDEXED_KINDS: readonly KindDef[] = [
+  tokenHistory,
+  evaluations,
+  memberBudgets,
+  agentDeposits,
+  disputes,
+  daos,
+  daoProposals,
+  liquidStakeHistory,
+];