@ixo/oracle-runtime-workers 0.32.0 → 0.33.1

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

@@ -14,13 +14,15 @@
  * 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).
+ * address). The `daos` kind also reads each DAO's first three proposal
+ * lists (`idx_dao_proposal_module_dao`) with their intake (a primary key),
+ * for new proposals.
  */
 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 { isRecord, text } from '../../summaries';
 import {
   PAGE,
   accountFor,
@@ -32,6 +34,7 @@ import {
   idText,
   listResult,
   longText,
+  nonEmpty,
   num,
   opt,
   str,
@@ -219,6 +222,117 @@ const coreNode = z.looseObject({
   description: opt,
 });
 
+/** Proposal lists read per DAO (single choice, multiple choice…). */
+const LISTS_PER_DAO = 3;
+
+/**
+ * A DAO's proposal lists: what a new proposal needs (who may propose, the
+ * deposit, the voting time) and what cards can do with the list. The
+ * `config`, `proposalCreationPolicy` and `depositInfo` columns hold the
+ * contracts' own query answers (DAO DAO v2: `{ allow_revoting,
+ * only_members_execute, max_voting_period, … }`, `{ anyone: {} }` or
+ * `{ module: { addr } }`, `{ denom: { native } | { cw20 }, amount,
+ * refund_policy }`).
+ */
+const LIST_FIELDS = `daoProposalModulesByDaoAddress(first: ${LISTS_PER_DAO}, orderBy: PRIMARY_KEY_ASC) { ${PAGE} nodes { address prefix status moduleType proposalCreationPolicy config daoPreProposeModuleByPreProposeModule { depositInfo openProposalSubmission } } }`;
+const listNode = z.looseObject({
+  address: str,
+  prefix: opt,
+  status: opt,
+  moduleType: opt,
+  proposalCreationPolicy: z.unknown().optional(),
+  config: z.unknown().optional(),
+  daoPreProposeModuleByPreProposeModule: z
+    .looseObject({
+      depositInfo: z.unknown().optional(),
+      openProposalSubmission: z.boolean().nullish(),
+    })
+    .nullish(),
+});
+const coreWithLists = coreNode.extend({
+  daoProposalModulesByDaoAddress: connection(listNode),
+});
+type CoreWithLists = z.infer<typeof coreWithLists>;
+
+/** DAO DAO's single-choice proposal contract (the only kind cards vote on). */
+const SINGLE_CHOICE = 'dao_proposal_single';
+const REFUND_POLICIES = ['always', 'only_passed', 'never'] as const;
+
+/** cw-utils `Duration` as words: `{ time: s }` or `{ height: n }`. */
+function durationText(value: unknown): string | undefined {
+  if (!isRecord(value)) return undefined;
+  const count = (n: number, unit: string) =>
+    `${n} ${unit}${n === 1 ? '' : 's'}`;
+  if (typeof value.time === 'number' && Number.isSafeInteger(value.time)) {
+    const s = value.time;
+    if (s > 0 && s % 86_400 === 0) return count(s / 86_400, 'day');
+    if (s > 0 && s % 3_600 === 0) return count(s / 3_600, 'hour');
+    if (s > 0 && s % 60 === 0) return count(s / 60, 'minute');
+    return count(s, 'second');
+  }
+  if (typeof value.height === 'number' && Number.isSafeInteger(value.height))
+    return count(value.height, 'block');
+  return undefined;
+}
+
+/**
+ * A proposal deposit (`CheckedDepositInfo`): a bank coin as shown, or a
+ * cw20 amount with `cardCannotPay` (cards pay bank coins only), each with
+ * its refund rule; undefined when there is none or it is unreadable.
+ */
+async function depositOf(ctx: KindContext, value: unknown) {
+  if (!isRecord(value) || !isRecord(value.denom)) return undefined;
+  const refundPolicy = REFUND_POLICIES.find(
+    (policy) => policy === value.refund_policy,
+  );
+  if (typeof value.denom.native === 'string') {
+    const coin = chainCoin({ denom: value.denom.native, amount: value.amount });
+    const shown = coin ? await displayCoin(ctx, coin) : null;
+    return shown ? compact({ ...shown, refundPolicy }) : undefined;
+  }
+  const amountBaseUnits = amountText(value.amount);
+  return typeof value.denom.cw20 === 'string' && amountBaseUnits
+    ? compact({
+        token: idText(value.denom.cw20),
+        amountBaseUnits,
+        refundPolicy,
+        cardCannotPay: true,
+      })
+    : undefined;
+}
+
+/** One proposal list of a DAO as the `daos` answer shows it. */
+async function proposalListOf(
+  ctx: KindContext,
+  list: z.infer<typeof listNode>,
+) {
+  const config = isRecord(list.config) ? list.config : {};
+  const policy = isRecord(list.proposalCreationPolicy)
+    ? list.proposalCreationPolicy
+    : {};
+  const intake = list.daoPreProposeModuleByPreProposeModule;
+  // `anyone`: proposals go straight to the list, from anyone, without a
+  // deposit; `module`: through the list's intake, which holds both rules.
+  const viaIntake = isRecord(policy.module);
+  return compact({
+    proposalModule: idText(list.address),
+    prefix: text(list.prefix, 20),
+    disabled: list.status === 'disabled' ? true : undefined,
+    multipleChoice:
+      list.moduleType && list.moduleType !== SINGLE_CHOICE ? true : undefined,
+    membersOnly:
+      viaIntake && intake?.openProposalSubmission === false ? true : undefined,
+    deposit: viaIntake ? await depositOf(ctx, intake?.depositInfo) : undefined,
+    votingTime: durationText(config.max_voting_period),
+    allowRevoting:
+      typeof config.allow_revoting === 'boolean'
+        ? config.allow_revoting
+        : undefined,
+    membersOnlyCarryOut:
+      config.only_members_execute === true ? true : undefined,
+  });
+}
+
 /** What a DAO row shows of its core. */
 type CoreText = {
   address: string;
@@ -226,7 +340,11 @@ type CoreText = {
   description?: string | null;
 };
 
-async function daoOf(ctx: KindContext, entry: Membership<CoreText>) {
+async function daoOf<C extends CoreText>(
+  ctx: KindContext,
+  entry: Membership<C>,
+  extra?: (core: C) => Promise<Record<string, unknown>>,
+) {
   const native =
     entry.membership === 'native-staked' && entry.nativeDenom
       ? chainCoin({ denom: entry.nativeDenom, amount: entry.weight })
@@ -255,38 +373,56 @@ async function daoOf(ctx: KindContext, entry: Membership<CoreText>) {
     votingPowerShare: shareOf(entry.weight, entry.totalWeight),
     votingModule: idText(entry.votingModule),
     moduleType: text(entry.moduleType, 80),
+    ...(extra ? await extra(entry.core) : {}),
   });
 }
 
 /**
  * The `daos` answer's data from the membership answer: the first `n`
- * DAOs, and `more` when the index holds further memberships.
+ * DAOs, and `more` when the index holds further memberships. `extra` adds
+ * fields read with each DAO core (the `daos` kind's proposal lists).
  */
 export async function daosData<C extends CoreText>(
   ctx: KindContext,
   answer: MembershipRows<C>,
   n: number,
+  extra?: (core: C) => Promise<Record<string, unknown>>,
 ): Promise<Record<string, unknown>> {
   const all = membershipsOf(answer);
   return compact({
-    items: await Promise.all(all.slice(0, n).map((entry) => daoOf(ctx, entry))),
+    items: await Promise.all(
+      all.slice(0, n).map((entry) => daoOf(ctx, entry, extra)),
+    ),
     more: all.length > n || moreMemberships(answer) ? true : undefined,
   });
 }
 
-const answerSchema = membershipSchema(coreNode);
+/** A DAO core's proposal lists, and `moreProposalLists` past those read. */
+async function listsOf(ctx: KindContext, core: CoreWithLists) {
+  const lists = core.daoProposalModulesByDaoAddress;
+  return {
+    proposalLists: nonEmpty(
+      await Promise.all(lists.nodes.map((list) => proposalListOf(ctx, list))),
+    ),
+    moreProposalLists: lists.pageInfo?.hasNextPage ? true : undefined,
+  };
+}
+
+const answerSchema = membershipSchema(coreWithLists);
 
 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.',
+    'DAOs an account (default: the user) is a member of, how, its share of the voting power, and where each takes new proposals.',
   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.',
+    '`addedByGroupAdmin: true` (every cw4-member row): members of this kind of group are added by its admin. That is normal: leave it out of an ordinary answer and never suggest the person did not join; mention it briefly only when it matters, for example when they do not recognise a group (“Members of this group are added by its admin.”).',
+    '`nameIsSelfChosen: true`: the group chose its own name and description. Mention it only when it matters (for example when they rely on the name to tell who runs the group), in one short, calm note such as “Group names are chosen by the group itself.”',
+    '`dao` is also the group’s own account: what the group holds (chain_lookup balances with that address) and what acts when one of its proposals passes.',
+    '`proposalLists` (at most 3; `moreProposalLists: true` past them): where the DAO takes proposals, each `proposalModule` (its address), `prefix` (the letter before proposal numbers, A in A3), `votingTime`, `allowRevoting` (whether a vote can be changed until voting closes), `membersOnly: true` (only members may propose), `membersOnlyCarryOut: true` (only members may carry out a passed proposal), and `deposit` when proposing takes one: a bank coin (`amount` beside `symbol`) or a cw20 amount with `cardCannotPay: true`, with `refundPolicy` (`only_passed`: back only if it passes and is carried out, `always`: back when carried out or closed, `never`: not back). `multipleChoice: true`: Auth Hub cards cannot use that list. `disabled: true`: the group switched it off: no new proposals through it, and its proposals with actions can’t be carried out (votes and closes still work).',
     'NFT (cw721) staking is not indexed here. Ask `dao_proposals` for what the DAOs are voting on.',
   ].join(' '),
   source: 'blocksync',
@@ -300,7 +436,7 @@ export const daos = defineKind({
     const subfields = membershipFields(
       member.address,
       n,
-      'address name description',
+      `address name description ${LIST_FIELDS}`,
     );
     return {
       source: 'blocksync',
@@ -309,7 +445,7 @@ export const daos = defineKind({
         const parsed = answerSchema.safeParse(raw);
         if (!parsed.success) return { ok: false, ...unexpected };
         return listResult(
-          await daosData(ctx, parsed.data, n),
+          await daosData(ctx, parsed.data, n, (core) => listsOf(ctx, core)),
           n,
           member.subject,
         );