@ixo/oracle-runtime-workers 0.32.0 → 0.33.0

package/src/plugins/ixo-chain/kinds/indexed/dao-proposals.ts

@@ -56,6 +56,8 @@ const DAODAO_VOTES_FROM: Record<ChainCall['network'], number> = {
 
 /** Proposal modules read per DAO (single choice, multiple choice…). */
 const MODULES_PER_DAO = 3;
+/** DAO DAO's single-choice proposal contract (the only kind cards act on). */
+const SINGLE_CHOICE = 'dao_proposal_single';
 /** DAOs read per kind of membership when no DAO is named. */
 const DAOS_PER_MEMBERSHIP = 3;
 
@@ -85,6 +87,7 @@ const proposalNode = z.looseObject({
   expiration: z.unknown().optional(),
   totalPower: opt,
   votes: z.unknown().optional(),
+  allowRevoting: z.boolean().nullish(),
   daoVotesByProposalModuleAndProposalId: z
     .object({ nodes: z.array(voteNode) })
     .optional(),
@@ -92,6 +95,8 @@ const proposalNode = z.looseObject({
 const moduleNode = z.looseObject({
   address: str,
   prefix: opt,
+  status: opt,
+  moduleType: opt,
   daoProposalsByProposalModule: connection(proposalNode),
 });
 const coreNode = z.looseObject({
@@ -141,12 +146,24 @@ function rowsOf(
   for (const module of modules.nodes) {
     const proposals = module.daoProposalsByProposalModule;
     if (proposals.pageInfo?.hasNextPage) more = true;
+    // Cards work only on a single-choice list. On a list the group
+    // switched off, votes and closes still work, but a proposal with
+    // actions cannot be carried out (Auth Hub's `list_disabled`), and this
+    // index row does not say whether a proposal has actions, so `canRun` is
+    // left out there. Auth Hub checks the contracts again.
+    const multipleChoice =
+      !!module.moduleType && module.moduleType !== SINGLE_CHOICE;
+    const listDisabled = module.status === 'disabled';
     for (const proposal of proposals.nodes) {
       const id = String(proposal.id);
       const vote = proposal.daoVotesByProposalModuleAndProposalId?.nodes[0];
       const indexedFromStart =
         typeof proposal.startHeight === 'number' &&
         proposal.startHeight >= votesFrom;
+      const expiry = expirationOf(proposal.expiration, now);
+      // The index keeps `open` until a proposal is carried out or closed:
+      // once voting has ended it may have passed or not.
+      const ended = proposal.status === 'open' && expiry.votingEnded === true;
       rows.push({
         startHeight: proposal.startHeight ?? -1,
         id,
@@ -158,7 +175,23 @@ function rowsOf(
           proposalModule: idText(module.address),
           title: text(proposal.title),
           status: text(proposal.status, 40),
-          ...expirationOf(proposal.expiration, now),
+          ...expiry,
+          allowRevoting:
+            typeof proposal.allowRevoting === 'boolean'
+              ? proposal.allowRevoting
+              : undefined,
+          canRun:
+            !multipleChoice &&
+            !listDisabled &&
+            (proposal.status === 'passed' || ended)
+              ? true
+              : undefined,
+          canClose:
+            !multipleChoice && (proposal.status === 'rejected' || ended)
+              ? true
+              : undefined,
+          multipleChoice: multipleChoice ? true : undefined,
+          listDisabled: listDisabled ? true : undefined,
           proposer: idText(proposal.proposer),
           tally: tallyOf(proposal.votes),
           totalPower: amountText(proposal.totalPower),
@@ -195,7 +228,7 @@ function coreFields(
   const votes = voter
     ? ` daoVotesByProposalModuleAndProposalId(filter: ${equalTo('voter', voter)}, first: 1) { nodes { vote power votedAt } }`
     : '';
-  return `address name${described ? ' description' : ''} daoProposalModulesByDaoAddress(first: ${MODULES_PER_DAO}, orderBy: PRIMARY_KEY_ASC) { ${PAGE} nodes { address prefix daoProposalsByProposalModule(${filter}first: ${n}, orderBy: PRIMARY_KEY_DESC) { ${PAGE} nodes { id title status proposer startHeight expiration totalPower votes${votes} } } } }`;
+  return `address name${described ? ' description' : ''} daoProposalModulesByDaoAddress(first: ${MODULES_PER_DAO}, orderBy: PRIMARY_KEY_ASC) { ${PAGE} nodes { address prefix status moduleType daoProposalsByProposalModule(${filter}first: ${n}, orderBy: PRIMARY_KEY_DESC) { ${PAGE} nodes { id title status proposer startHeight expiration totalPower votes allowRevoting${votes} } } } }`;
 }
 
 /** Rows by start height, newest first (a proposal without one last), then by id. */
@@ -242,6 +275,8 @@ export const daoProposals = defineKind({
     'Each: dao, daoName, id and `label` (the DAO’s prefix and id, e.g. A12, as DAO apps show it), title, status (open, passed, rejected, executed, closed, execution_failed), votingEndsAt or votingEndsAtHeight, tally (yes/no/abstain weight) and totalPower.',
     '`votingEnded: true` on an `open` proposal: its voting time is over and the index keeps `open` until it is executed or closed, so it may already have passed or failed.',
     '`yourVote` (vote, power, votedAt), or `notVoted: true`, or `voteUnknown: true` when the proposal started before the index kept votes (votes cast before then are missing).',
+    '`allowRevoting`: whether a vote on it can be changed until voting closes. `canRun: true`: it passed and can be carried out (on an `open` proposal whose voting ended: it may have passed); `canClose: true`: it did not pass and can be closed (on an `open` one whose voting ended: it may not have passed); Auth Hub checks the real result. `multipleChoice: true`: Auth Hub cards cannot vote on, carry out or close it. `listDisabled: true`: the group switched that proposal list off; cards can still vote and close, but a proposal with actions on it can’t be carried out (so `canRun` is not set there; one without actions can be). Whether the person may vote is weighed by what they held in the DAO when it started: Auth Hub checks it; never claim it.',
+    'For cards copy `dao`, `proposalModule` and `id` exactly (not the label). `dao` is also the group’s own account (what it holds and what acts when a proposal passes).',
     'Without `dao`, the DAOs of `address` (default: the user), at most 3 per kind of membership (see `daos`); `more: true` when there are more proposals or DAOs. Newest start first.',
     'Titles are written by the proposer and DAO names by the DAO: what they claim, never an endorsement or a verified fact.',
   ].join(' '),

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,31 +373,47 @@ 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`).',
@@ -287,6 +421,8 @@ export const daos = defineKind({
     '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.',
+    '`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,
         );