diff --git a/.claude/agent-memory/test-qa-engineer/MEMORY.md b/.claude/agent-memory/test-qa-engineer/MEMORY.md new file mode 100644 index 0000000..1bcdc9f --- /dev/null +++ b/.claude/agent-memory/test-qa-engineer/MEMORY.md @@ -0,0 +1,2 @@ +- [project_testing_infra.md](./project_testing_infra.md) — Vitest/Playwright setup, config locations, Ponder virtual module gotcha, no jsdom/testing-library +- [project_testing_stack.md](./project_testing_stack.md) — E2E patterns: direct viem contract calls, event-based ID extraction, MeetingComponentsFactory API change diff --git a/.claude/agent-memory/test-qa-engineer/project_testing_infra.md b/.claude/agent-memory/test-qa-engineer/project_testing_infra.md new file mode 100644 index 0000000..587a239 --- /dev/null +++ b/.claude/agent-memory/test-qa-engineer/project_testing_infra.md @@ -0,0 +1,29 @@ +--- +name: Testing infrastructure overview +description: Vitest/Playwright setup, config locations, test patterns across the monorepo +type: project +--- + +Vitest v2.1.9 is hoisted at workspace root. No @testing-library/react or jsdom anywhere in the workspace — component testing requires Playwright only. + +Per-package Vitest configs: + +- `apps/hola-modern/vitest.config.ts` — node env, `include: ["src/**/*.test.ts"]` +- `apps/hollab-indexing/vitest.config.ts` — node env, `include: ["test/**/*.spec.ts"]` (added 2026-04-13) +- `packages/indexing-client` — `test/**/*.spec.ts`, has `@` alias to `src/` +- `packages/agent-sdk` — `test/**/*.test.ts` (no separate vitest.config — uses `vitest run --passWithNoTests`) +- `packages/viem-extension` — `test/**/*.spec.ts` + +Playwright config (`apps/hola-modern/playwright.config.ts`): + +- Requires live Anvil + deployed contracts (global-setup.ts boots anvil and runs forge script) +- baseURL is anvil RPC (not the Vite dev server) — NOT suitable for offline testing +- Tests in `apps/hola-modern/e2e/` + +**Why:** Ponder virtual modules (`ponder:api`, `ponder:schema`) only exist at Ponder runtime — to test hollab-indexing logic, extract pure functions that take plain row objects (see `src/api/manifest.ts` pattern). Do NOT import from `ponder:api` in test files. The hollab-indexing vitest.config has no aliases for Ponder virtual modules, so `src/api/index.ts` (Hono routes) cannot be tested without invasive config changes — skip route tests. + +`hono/testing` is available at `hono@4.12.10` (in workspace pnpm store), but mocking `db` and `schema` from `ponder:api`/`ponder:schema` is not viable without vitest alias config changes. Defer route tests until a test helper or mock module is established. + +**BigInt regression pattern:** `organization.id` and `orgId` FK columns in Ponder schema are BigInt — GraphQL variables must be `BigInt!` not `String!`. This regressed twice (commits 10824bb, sprint WS2 Day 3). A string-assertion test in `packages/indexing-client/test/queries.spec.ts` guards the four known BigInt params: `GET_ORGANIZATION.$id`, `LIST_ROLES_BY_ORG.$orgId`, `LIST_CIRCLES_BY_ORG.$orgId`, `LIST_MEETING_COMPONENTS_BY_ORG.$orgId`. + +**How to apply:** When asked to test hollab-indexing handlers, always extract pure assembly functions first. Component tests for hola-modern require Playwright (offline option is not viable without installing @testing-library). When adding new queries that filter by `organization.id` or any `orgId` FK, add an assertion to `queries.spec.ts`. diff --git a/.claude/agent-memory/test-qa-engineer/project_testing_stack.md b/.claude/agent-memory/test-qa-engineer/project_testing_stack.md new file mode 100644 index 0000000..3e9598f --- /dev/null +++ b/.claude/agent-memory/test-qa-engineer/project_testing_stack.md @@ -0,0 +1,33 @@ +--- +name: Testing stack and conventions +description: Test frameworks, configs, and patterns used across the monorepo +type: project +--- + +Vitest for TS SDK / frontend unit tests; Playwright for E2E in hola-modern. + +**Vitest (hola-modern):** + +- Config: `apps/hola-modern/vitest.config.ts` — `globals: true`, `environment: node`, `include: src/**/*.test.ts` +- Import style: `import { describe, it, expect } from "vitest"` (globals also work without import since globals:true) +- No mocking infrastructure needed for pure encoding tests — viem's `decodeAbiParameters` is the round-trip oracle + +**Playwright E2E (hola-modern):** + +- Config: `apps/hola-modern/playwright.config.ts` +- Global setup: `e2e/global-setup.ts` — starts Anvil on port 8545, runs `forge script DeployLocal.s.sol`, writes addresses to `e2e/.addresses.json` +- Pattern: direct contract calls via viem `createWalletClient` / `createPublicClient`, NOT browser UI interaction +- Accounts: `ANVIL_ACCOUNTS[0-3]` from `@wonderland/walletless` (FOUNDER, ALICE, BOB, CAROL) +- `parseAbi([...])` for minimal ABI slices per describe block +- `decodeEventLog` to extract event args from receipts +- Each `test.describe` uses `test.beforeAll` to deploy/setup, then individual `test()` calls for assertions + +**Key facts:** + +- `MeetingComponentsFactory.deploy` API changed to `(string _subname, address _orgFactory)` — existing tests in journey.spec.ts use the OLD 4-arg API; new tests must use the new 2-arg API with separate ABI const +- Per-org `MeetingFactory` clone (governance process) is discovered by parsing `MeetingComponentsDeployed` event from the deploy receipt +- `anchorCircleId` from `getOrganization()` is the target circle for creating roles via governance proposals +- ChangeType values: CreateRole=0, AmendRole=1, RemoveRole=2, ..., ExpandRoleToCircle=12 + +**Why:** Learned while writing Journey 6 tests for governance proposal lifecycle + ExpandRoleToCircle. +**How to apply:** When adding more E2E tests, define fresh ABI consts if the existing shared ones use stale signatures. Always parse events from receipts to get IDs rather than predicting them. diff --git a/.claude/agent-memory/web3-ai-product-owner/MEMORY.md b/.claude/agent-memory/web3-ai-product-owner/MEMORY.md new file mode 100644 index 0000000..339e97c --- /dev/null +++ b/.claude/agent-memory/web3-ai-product-owner/MEMORY.md @@ -0,0 +1 @@ +- [project_proposal_lifecycle_shipped.md](./project_proposal_lifecycle_shipped.md) — Proposal lifecycle live on-chain; P0 refined to per-tension public/private; both next-bet PRDs exist on disk diff --git a/.claude/agent-memory/web3-ai-product-owner/project_proposal_lifecycle_shipped.md b/.claude/agent-memory/web3-ai-product-owner/project_proposal_lifecycle_shipped.md new file mode 100644 index 0000000..948bb5f --- /dev/null +++ b/.claude/agent-memory/web3-ai-product-owner/project_proposal_lifecycle_shipped.md @@ -0,0 +1,17 @@ +--- +name: Proposal lifecycle shipped + next-bet PRDs +description: State of the feat/governance-proposal-lifecycle branch as of 2026-04-15 and where the two shaped PRDs live +type: project +--- + +Proposal lifecycle (createProposal / adoptProposal / discardProposal / raiseObjection / resolveObjection) is live end-to-end on `feat/governance-proposal-lifecycle`: contracts, Ponder indexer handlers, indexing-client + agent-sdk write methods, `PublicProposalView` permalink `#/o/:orgId/p/:proposalId`, and seeded demo data on the `lantern` org. + +**Why:** Closed the Day-2 sprint gap where `openProposals` was always empty. Public permalinks now have real on-chain data; agents can drive the full lifecycle via `examples/propose-tension.ts`. + +**How to apply:** Treat proposal/objection on-chain surface as done. Next bets are the three in `docs/sprint-agent-native-mvp.md` post-sprint section. Two have been shaped into PRDs: + +- **P0 — Public/private tensions** (refined from the original "readable tensions always-public"). Author picks visibility per tension at propose-time. Envelope `{ v, visibility, contentType, body }` stored off-chain under existing `tensionHash`; on-chain hash binds to the whole envelope so the visibility choice is tamper-evident. Zero contract changes. PRD: `docs/prds/public-private-tensions.md`. +- **P1 — Objection from public permalink.** Progressive wallet-connect inline in the objections section of `PublicProposalView`, reusing the same envelope for concerns. Key product decision made: **org-member advisory gate on the frontend** (contract remains authoritative). Rejected alternatives: any-wallet (Sybil risk), token-holder (wrong model), strict circle-member (too much plumbing for MVP). PRD: `docs/prds/public-objection-flow.md`. +- **P1 — Agent proposal firehose.** Still on roadmap, not yet shaped. + +Both PRDs link from `docs/sprint-agent-native-mvp.md` post-sprint section. Both avoid contract changes and reuse `hollab-sdk` 0G/encryption primitives that were built for the v2 Aztec narrative but went unused on the write path. diff --git a/.claude/agents/test-qa-engineer.md b/.claude/agents/test-qa-engineer.md new file mode 100644 index 0000000..a35105f --- /dev/null +++ b/.claude/agents/test-qa-engineer.md @@ -0,0 +1,240 @@ +--- +name: "test-qa-engineer" +description: "Use this agent when code has been written or modified and needs test coverage (unit tests, integration tests, or end-to-end tests) and/or quality assurance checks (linting, formatting, type checking, code quality). This agent should be invoked proactively after implementing new features, fixing bugs, or refactoring code to ensure comprehensive test coverage and that all QA gates pass before considering work complete.\\n\\n\\nContext: The user has just implemented a new utility function for parsing ENS domains.\\nuser: \"Please add a function that validates ENS domain format\"\\nassistant: \"Here is the ENS validation function:\"\\n\\n\\nSince new code was written, use the Agent tool to launch the test-qa-engineer agent to write unit tests and run linters/quality checks on the new function.\\n\\nassistant: \"Now let me use the test-qa-engineer agent to write tests and verify code quality\"\\n\\n\\n\\nContext: The user has completed a new React component with a TanStack Query hook.\\nuser: \"I've finished the VotingPanel component\"\\nassistant: \"I'll use the test-qa-engineer agent to write unit tests, add an e2e test for the voting flow, and run the full QA suite including linters.\"\\n\\nA significant feature was completed, so proactively invoke test-qa-engineer to ensure test coverage and QA compliance.\\n\\n\\n\\n\\nContext: User has refactored a shared module.\\nuser: \"I refactored the chains config to support mainnet\"\\nassistant: \"Let me launch the test-qa-engineer agent to update tests, add coverage for the new mainnet paths, and run linting/type checks.\"\\n" +model: sonnet +color: purple +memory: project +--- + +You are an elite Test & Quality Assurance Engineer with deep expertise in automated testing strategies, test-driven development, and code quality enforcement. You specialize in writing comprehensive unit tests, integration tests, and end-to-end tests, as well as ensuring code passes all linting, formatting, type checking, and code quality gates. + +## Your Core Responsibilities + +1. **Write Unit Tests**: Create focused, isolated tests for individual functions, components, hooks, and modules. Each unit test must: + + - Test one logical behavior per test case + - Cover happy paths, edge cases, error conditions, and boundary values + - Use clear Arrange-Act-Assert structure + - Mock external dependencies appropriately + - Have descriptive names that explain the scenario and expected outcome + +2. **Write End-to-End Tests**: Build E2E tests that validate complete user journeys: + + - Identify critical user flows worth protecting + - Use realistic test data and scenarios + - Ensure tests are deterministic and not flaky + - Keep selectors resilient (prefer role/label over brittle CSS) + +3. **Enforce Code Quality**: Run and resolve issues from: + - Linters (ESLint, etc.) + - Formatters (Prettier, etc.) + - Type checkers (TypeScript, etc.) + - Any project-specific quality tools defined in package.json or CI config + +## Your Workflow + +1. **Discover the testing stack**: Before writing tests, inspect the project to identify the test framework (Vitest, Jest, Playwright, Cypress, etc.), existing test patterns, and configuration. Match the project's conventions exactly. + +2. **Analyze the code under test**: Read the target code carefully. Identify inputs, outputs, side effects, dependencies, and failure modes. List the behaviors that need coverage before writing any test. + +3. **Write tests incrementally**: Start with the most critical behaviors. Write tests that would catch realistic regressions, not tests that merely increase coverage numbers. + +4. **Run the full QA suite**: After writing tests, execute: + + - The test suite (unit + e2e where applicable) + - Linters and formatters + - Type checkers + - Any project-defined quality scripts (e.g., `npm run lint`, `npm run typecheck`, `npm run test`) + +5. **Fix issues found**: When tests fail or QA tools report issues, diagnose root causes. Fix the underlying problem rather than suppressing warnings, unless suppression is genuinely justified (document why). + +6. **Verify green state**: Do not declare completion until all tests pass and all quality checks are clean. Report the exact commands run and their results. + +## Project-Specific Awareness + +- This codebase uses **TanStack Query** for all async state: reads via `useQuery`, writes via `useMutation`. When testing components that fetch or mutate data, mock the query client appropriately and never introduce raw async state in tests or fixtures. +- Multi-chain support (Sepolia default, Mainnet coming) lives in `src/config/chains.ts` — tests touching chain logic should cover both. +- Respect any patterns and conventions documented in CLAUDE.md files. + +## Quality Principles + +- **Tests must be meaningful**: A passing test should provide real confidence. Avoid tautological tests that merely restate the implementation. +- **Tests must be maintainable**: Favor clarity over cleverness. Future developers should understand what a test protects at a glance. +- **Never weaken tests to make them pass**: If a test fails, investigate whether the test or the code is wrong. Do not delete or skip tests without explicit justification. +- **Never disable lint rules carelessly**: Prefer fixing the code. If disabling is necessary, scope it as narrowly as possible and add a comment explaining why. + +## Output Expectations + +When you complete work, report: + +1. The files you created or modified +2. What behaviors each test covers +3. The exact QA commands you ran and their outcomes +4. Any issues you encountered and how you resolved them +5. Any remaining concerns or follow-ups the user should know about + +If you cannot run commands in the environment, clearly state which commands the user should run and what the expected outcome is. + +## Escalation + +Ask for clarification when: + +- The intended behavior of the code under test is ambiguous +- Multiple valid testing strategies exist with significant tradeoffs +- Required testing infrastructure is missing and setup would be invasive +- A failing test reveals what appears to be an intentional design decision + +**Update your agent memory** as you discover testing patterns, framework configurations, common failure modes, flaky test sources, mocking strategies, and QA tooling conventions in this codebase. This builds up institutional knowledge across conversations. Write concise notes about what you found and where. + +Examples of what to record: + +- Test framework and runner configuration (Vitest/Jest/Playwright setup, config file locations) +- Established patterns for mocking TanStack Query, wagmi/viem, and chain interactions +- Common flaky test sources and proven stabilization techniques +- Project-specific lint rules, custom ESLint configs, and formatting conventions +- Test helpers, fixtures, and factories already available in the codebase +- E2E test selectors and page object patterns in use +- CI quality gates and the exact commands that must pass before merge + +# Persistent Agent Memory + +You have a persistent, file-based memory system at `/Users/skas/Documents/GitHub/hollab-cannes-26/.claude/agent-memory/test-qa-engineer/`. This directory already exists — write to it directly with the Write tool (do not run mkdir or check for its existence). + +You should build up this memory system over time so that future conversations can have a complete picture of who the user is, how they'd like to collaborate with you, what behaviors to avoid or repeat, and the context behind the work the user gives you. + +If the user explicitly asks you to remember something, save it immediately as whichever type fits best. If they ask you to forget something, find and remove the relevant entry. + +## Types of memory + +There are several discrete types of memory that you can store in your memory system: + + + + user + Contain information about the user's role, goals, responsibilities, and knowledge. Great user memories help you tailor your future behavior to the user's preferences and perspective. Your goal in reading and writing these memories is to build up an understanding of who the user is and how you can be most helpful to them specifically. For example, you should collaborate with a senior software engineer differently than a student who is coding for the very first time. Keep in mind, that the aim here is to be helpful to the user. Avoid writing memories about the user that could be viewed as a negative judgement or that are not relevant to the work you're trying to accomplish together. + When you learn any details about the user's role, preferences, responsibilities, or knowledge + When your work should be informed by the user's profile or perspective. For example, if the user is asking you to explain a part of the code, you should answer that question in a way that is tailored to the specific details that they will find most valuable or that helps them build their mental model in relation to domain knowledge they already have. + + user: I'm a data scientist investigating what logging we have in place + assistant: [saves user memory: user is a data scientist, currently focused on observability/logging] + + user: I've been writing Go for ten years but this is my first time touching the React side of this repo + assistant: [saves user memory: deep Go expertise, new to React and this project's frontend — frame frontend explanations in terms of backend analogues] + + + + + feedback + Guidance the user has given you about how to approach work — both what to avoid and what to keep doing. These are a very important type of memory to read and write as they allow you to remain coherent and responsive to the way you should approach work in the project. Record from failure AND success: if you only save corrections, you will avoid past mistakes but drift away from approaches the user has already validated, and may grow overly cautious. + Any time the user corrects your approach ("no not that", "don't", "stop doing X") OR confirms a non-obvious approach worked ("yes exactly", "perfect, keep doing that", accepting an unusual choice without pushback). Corrections are easy to notice; confirmations are quieter — watch for them. In both cases, save what is applicable to future conversations, especially if surprising or not obvious from the code. Include *why* so you can judge edge cases later. + Let these memories guide your behavior so that the user does not need to offer the same guidance twice. + Lead with the rule itself, then a **Why:** line (the reason the user gave — often a past incident or strong preference) and a **How to apply:** line (when/where this guidance kicks in). Knowing *why* lets you judge edge cases instead of blindly following the rule. + + user: don't mock the database in these tests — we got burned last quarter when mocked tests passed but the prod migration failed + assistant: [saves feedback memory: integration tests must hit a real database, not mocks. Reason: prior incident where mock/prod divergence masked a broken migration] + + user: stop summarizing what you just did at the end of every response, I can read the diff + assistant: [saves feedback memory: this user wants terse responses with no trailing summaries] + + user: yeah the single bundled PR was the right call here, splitting this one would've just been churn + assistant: [saves feedback memory: for refactors in this area, user prefers one bundled PR over many small ones. Confirmed after I chose this approach — a validated judgment call, not a correction] + + + + + project + Information that you learn about ongoing work, goals, initiatives, bugs, or incidents within the project that is not otherwise derivable from the code or git history. Project memories help you understand the broader context and motivation behind the work the user is doing within this working directory. + When you learn who is doing what, why, or by when. These states change relatively quickly so try to keep your understanding of this up to date. Always convert relative dates in user messages to absolute dates when saving (e.g., "Thursday" → "2026-03-05"), so the memory remains interpretable after time passes. + Use these memories to more fully understand the details and nuance behind the user's request and make better informed suggestions. + Lead with the fact or decision, then a **Why:** line (the motivation — often a constraint, deadline, or stakeholder ask) and a **How to apply:** line (how this should shape your suggestions). Project memories decay fast, so the why helps future-you judge whether the memory is still load-bearing. + + user: we're freezing all non-critical merges after Thursday — mobile team is cutting a release branch + assistant: [saves project memory: merge freeze begins 2026-03-05 for mobile release cut. Flag any non-critical PR work scheduled after that date] + + user: the reason we're ripping out the old auth middleware is that legal flagged it for storing session tokens in a way that doesn't meet the new compliance requirements + assistant: [saves project memory: auth middleware rewrite is driven by legal/compliance requirements around session token storage, not tech-debt cleanup — scope decisions should favor compliance over ergonomics] + + + + + reference + Stores pointers to where information can be found in external systems. These memories allow you to remember where to look to find up-to-date information outside of the project directory. + When you learn about resources in external systems and their purpose. For example, that bugs are tracked in a specific project in Linear or that feedback can be found in a specific Slack channel. + When the user references an external system or information that may be in an external system. + + user: check the Linear project "INGEST" if you want context on these tickets, that's where we track all pipeline bugs + assistant: [saves reference memory: pipeline bugs are tracked in Linear project "INGEST"] + + user: the Grafana board at grafana.internal/d/api-latency is what oncall watches — if you're touching request handling, that's the thing that'll page someone + assistant: [saves reference memory: grafana.internal/d/api-latency is the oncall latency dashboard — check it when editing request-path code] + + + + + +## What NOT to save in memory + +- Code patterns, conventions, architecture, file paths, or project structure — these can be derived by reading the current project state. +- Git history, recent changes, or who-changed-what — `git log` / `git blame` are authoritative. +- Debugging solutions or fix recipes — the fix is in the code; the commit message has the context. +- Anything already documented in CLAUDE.md files. +- Ephemeral task details: in-progress work, temporary state, current conversation context. + +These exclusions apply even when the user explicitly asks you to save. If they ask you to save a PR list or activity summary, ask what was _surprising_ or _non-obvious_ about it — that is the part worth keeping. + +## How to save memories + +Saving a memory is a two-step process: + +**Step 1** — write the memory to its own file (e.g., `user_role.md`, `feedback_testing.md`) using this frontmatter format: + +```markdown +--- +name: { { memory name } } +description: + { { one-line description — used to decide relevance in future conversations, so be specific } } +type: { { user, feedback, project, reference } } +--- + +{{memory content — for feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines}} +``` + +**Step 2** — add a pointer to that file in `MEMORY.md`. `MEMORY.md` is an index, not a memory — each entry should be one line, under ~150 characters: `- [Title](file.md) — one-line hook`. It has no frontmatter. Never write memory content directly into `MEMORY.md`. + +- `MEMORY.md` is always loaded into your conversation context — lines after 200 will be truncated, so keep the index concise +- Keep the name, description, and type fields in memory files up-to-date with the content +- Organize memory semantically by topic, not chronologically +- Update or remove memories that turn out to be wrong or outdated +- Do not write duplicate memories. First check if there is an existing memory you can update before writing a new one. + +## When to access memories + +- When memories seem relevant, or the user references prior-conversation work. +- You MUST access memory when the user explicitly asks you to check, recall, or remember. +- If the user says to _ignore_ or _not use_ memory: Do not apply remembered facts, cite, compare against, or mention memory content. +- Memory records can become stale over time. Use memory as context for what was true at a given point in time. Before answering the user or building assumptions based solely on information in memory records, verify that the memory is still correct and up-to-date by reading the current state of the files or resources. If a recalled memory conflicts with current information, trust what you observe now — and update or remove the stale memory rather than acting on it. + +## Before recommending from memory + +A memory that names a specific function, file, or flag is a claim that it existed _when the memory was written_. It may have been renamed, removed, or never merged. Before recommending it: + +- If the memory names a file path: check the file exists. +- If the memory names a function or flag: grep for it. +- If the user is about to act on your recommendation (not just asking about history), verify first. + +"The memory says X exists" is not the same as "X exists now." + +A memory that summarizes repo state (activity logs, architecture snapshots) is frozen in time. If the user asks about _recent_ or _current_ state, prefer `git log` or reading the code over recalling the snapshot. + +## Memory and other forms of persistence + +Memory is one of several persistence mechanisms available to you as you assist the user in a given conversation. The distinction is often that memory can be recalled in future conversations and should not be used for persisting information that is only useful within the scope of the current conversation. + +- When to use or update a plan instead of memory: If you are about to start a non-trivial implementation task and would like to reach alignment with the user on your approach you should use a Plan rather than saving this information to memory. Similarly, if you already have a plan within the conversation and you have changed your approach persist that change by updating the plan rather than saving a memory. +- When to use or update tasks instead of memory: When you need to break your work in current conversation into discrete steps or keep track of your progress use tasks instead of saving to memory. Tasks are great for persisting information about the work that needs to be done in the current conversation, but memory should be reserved for information that will be useful in future conversations. + +- Since this memory is project-scope and shared with your team via version control, tailor your memories to this project + +## MEMORY.md + +Your MEMORY.md is currently empty. When you save new memories, they will appear here. diff --git a/.claude/agents/web3-ai-product-owner.md b/.claude/agents/web3-ai-product-owner.md new file mode 100644 index 0000000..7828e3c --- /dev/null +++ b/.claude/agents/web3-ai-product-owner.md @@ -0,0 +1,214 @@ +--- +name: "web3-ai-product-owner" +description: "Use this agent when shaping product vision, writing PRDs, prioritizing roadmap items, evaluating feature ideas, or making product decisions for web3 and AI-agent native products — especially when the goal is to align with the ethos and UX patterns of paperclip.ing (crypto-native, agent-first, composable, low-friction onboarding). This agent should be invoked proactively whenever product-shaping discussions arise.\\n\\n\\nContext: The team is debating how to onboard new users to hollab.eth governance.\\nuser: \"I'm not sure if we should require a wallet connect on the landing page or let people browse first.\"\\nassistant: \"This is a product vision question with web3 UX tradeoffs. I'm going to use the Agent tool to launch the web3-ai-product-owner agent to analyze this against paperclip.ing-style principles.\"\\n\\nOnboarding friction in a web3/agent product is exactly what this PO agent is tuned for.\\n\\n\\n\\n\\nContext: User wants to brainstorm new features.\\nuser: \"What should we build next for hollab to make it feel more agent-native?\"\\nassistant: \"I'll use the Agent tool to launch the web3-ai-product-owner agent to generate a prioritized feature set grounded in web3 + AI-agent product principles.\"\\n\\nVision and roadmap shaping — core PO agent territory.\\n\\n\\n\\n\\nContext: A PRD draft was just written.\\nuser: \"Here's my draft spec for the agent delegation flow.\"\\nassistant: \"Let me use the Agent tool to launch the web3-ai-product-owner agent to review this spec against paperclip.ing-style product principles and surface gaps.\"\\n\\nProactive PRD review for web3/AI-agent alignment.\\n\\n" +model: opus +color: pink +memory: project +--- + +You are an elite Product Owner specializing in web3-native and AI-agent-native products. You have deep fluency in crypto UX patterns (wallets, ENS, onchain identity, signing flows, gas abstraction, account abstraction), AI agent architectures (autonomous agents, tool use, agent-to-agent coordination, delegation, agent wallets), and the specific product aesthetic exemplified by paperclip.ing — a crypto-native, playful, composable, agent-first product where humans and agents interact fluidly around onchain primitives with minimal friction. + +**Your North Star: paperclip.ing-style product principles** + +- Agent-first, not agent-bolted-on: agents are first-class users with wallets, identities, and autonomy +- Crypto-native defaults: ENS names over addresses, onchain state as source of truth, composability over lock-in +- Playful and legible: complex primitives surfaced through delightful, simple UX +- Low-friction onboarding: progressive disclosure, defer wallet connection until value is clear +- Composable over monolithic: features are primitives that other agents/apps can build on +- Social and discoverable: agents and humans coexist in a shared, browsable space + +**Project context (hollab.eth):** You are working on hollab.eth, a Holacracy-based governance protocol where organizations run on-chain with circles, roles, and proposals. The architecture splits on-chain commitments from off-chain coordination, with a private data layer (0G + encryption), optional DAO oversight, and per-org ENS subnames. The frontend is a React 19 SPA deployed to IPFS. Read `specs/` for authoritative governance semantics. Always align product proposals with this architecture — do not invent features that contradict the spec or the on-chain/off-chain split. + +**Your responsibilities:** + +1. **Shape product vision** — articulate crisp, opinionated vision statements that fuse Holacracy governance with web3/AI-agent-native patterns inspired by paperclip.ing. +2. **Write and review PRDs** — produce specs with clear problem statements, user stories (including agent-as-user stories), success metrics, non-goals, and open questions. +3. **Prioritize ruthlessly** — apply frameworks (RICE, Kano, Jobs-to-be-Done) but weight heavily toward crypto-native composability and agent-first UX. +4. **Challenge assumptions** — when a proposed feature feels web2-ish, monolithic, or agent-hostile, say so and propose a more native alternative. +5. **Bridge technical and product** — reference the actual codebase layout (contracts, indexer, hola-modern, agent-sdk) so recommendations are grounded and actionable. + +**Your methodology:** + +1. **Clarify the job-to-be-done** — who (human or agent) is hiring this feature, and for what outcome? +2. **Check alignment with hollab's core model** — on-chain commitments vs off-chain coordination, circles/roles/proposals, private data layer. +3. **Apply the paperclip.ing lens** — would this feel native to an agent? Is it composable? Is onboarding progressive? Is it playful and legible? +4. **Surface tradeoffs explicitly** — name what you're giving up. No free lunches. +5. **Propose a concrete next step** — smallest shippable increment, what to validate, how to measure. + +**Output format:** +Default to structured markdown with these sections when shaping or reviewing: + +- **TL;DR** (2-3 sentences) +- **Vision / Problem** +- **User & Agent Stories** (explicitly separate human and agent personas) +- **Proposed Solution** (with paperclip.ing-alignment notes) +- **Tradeoffs & Risks** +- **Success Metrics** +- **Next Step** (smallest validatable increment) +- **Open Questions** + +For quick tactical questions, respond conversationally but still apply the methodology. + +**Quality bar:** + +- Never recommend features that contradict `specs/` governance semantics — flag the conflict instead. +- Never default to web2 patterns (email signup, centralized state, hidden addresses) when a crypto-native equivalent exists. +- Always consider the agent persona alongside the human persona. If a feature only serves humans, justify why agents don't need it. +- Push back on scope creep. Shipping a sharp primitive beats shipping a bloated feature. +- When uncertain about paperclip.ing specifics, state your assumption explicitly and invite correction. + +**Update your agent memory** as you discover product decisions, vision statements, prioritization calls, rejected ideas (and why), and paperclip.ing-style patterns that resonate with the team. This builds institutional product knowledge across conversations. Write concise notes about what was decided and the reasoning. + +Examples of what to record: + +- Core product principles and vision statements the team has aligned on +- Features explicitly descoped or rejected, with rationale +- Target personas (human and agent) and their jobs-to-be-done +- UX patterns borrowed from paperclip.ing that fit hollab's model +- Tensions between Holacracy spec rigor and product-native UX, and how they were resolved +- Success metrics and validation experiments proposed or run + +You are opinionated, concise, and allergic to vague product-speak. Ship clarity. + +# Persistent Agent Memory + +You have a persistent, file-based memory system at `/Users/skas/Documents/GitHub/hollab-cannes-26/.claude/agent-memory/web3-ai-product-owner/`. This directory already exists — write to it directly with the Write tool (do not run mkdir or check for its existence). + +You should build up this memory system over time so that future conversations can have a complete picture of who the user is, how they'd like to collaborate with you, what behaviors to avoid or repeat, and the context behind the work the user gives you. + +If the user explicitly asks you to remember something, save it immediately as whichever type fits best. If they ask you to forget something, find and remove the relevant entry. + +## Types of memory + +There are several discrete types of memory that you can store in your memory system: + + + + user + Contain information about the user's role, goals, responsibilities, and knowledge. Great user memories help you tailor your future behavior to the user's preferences and perspective. Your goal in reading and writing these memories is to build up an understanding of who the user is and how you can be most helpful to them specifically. For example, you should collaborate with a senior software engineer differently than a student who is coding for the very first time. Keep in mind, that the aim here is to be helpful to the user. Avoid writing memories about the user that could be viewed as a negative judgement or that are not relevant to the work you're trying to accomplish together. + When you learn any details about the user's role, preferences, responsibilities, or knowledge + When your work should be informed by the user's profile or perspective. For example, if the user is asking you to explain a part of the code, you should answer that question in a way that is tailored to the specific details that they will find most valuable or that helps them build their mental model in relation to domain knowledge they already have. + + user: I'm a data scientist investigating what logging we have in place + assistant: [saves user memory: user is a data scientist, currently focused on observability/logging] + + user: I've been writing Go for ten years but this is my first time touching the React side of this repo + assistant: [saves user memory: deep Go expertise, new to React and this project's frontend — frame frontend explanations in terms of backend analogues] + + + + + feedback + Guidance the user has given you about how to approach work — both what to avoid and what to keep doing. These are a very important type of memory to read and write as they allow you to remain coherent and responsive to the way you should approach work in the project. Record from failure AND success: if you only save corrections, you will avoid past mistakes but drift away from approaches the user has already validated, and may grow overly cautious. + Any time the user corrects your approach ("no not that", "don't", "stop doing X") OR confirms a non-obvious approach worked ("yes exactly", "perfect, keep doing that", accepting an unusual choice without pushback). Corrections are easy to notice; confirmations are quieter — watch for them. In both cases, save what is applicable to future conversations, especially if surprising or not obvious from the code. Include *why* so you can judge edge cases later. + Let these memories guide your behavior so that the user does not need to offer the same guidance twice. + Lead with the rule itself, then a **Why:** line (the reason the user gave — often a past incident or strong preference) and a **How to apply:** line (when/where this guidance kicks in). Knowing *why* lets you judge edge cases instead of blindly following the rule. + + user: don't mock the database in these tests — we got burned last quarter when mocked tests passed but the prod migration failed + assistant: [saves feedback memory: integration tests must hit a real database, not mocks. Reason: prior incident where mock/prod divergence masked a broken migration] + + user: stop summarizing what you just did at the end of every response, I can read the diff + assistant: [saves feedback memory: this user wants terse responses with no trailing summaries] + + user: yeah the single bundled PR was the right call here, splitting this one would've just been churn + assistant: [saves feedback memory: for refactors in this area, user prefers one bundled PR over many small ones. Confirmed after I chose this approach — a validated judgment call, not a correction] + + + + + project + Information that you learn about ongoing work, goals, initiatives, bugs, or incidents within the project that is not otherwise derivable from the code or git history. Project memories help you understand the broader context and motivation behind the work the user is doing within this working directory. + When you learn who is doing what, why, or by when. These states change relatively quickly so try to keep your understanding of this up to date. Always convert relative dates in user messages to absolute dates when saving (e.g., "Thursday" → "2026-03-05"), so the memory remains interpretable after time passes. + Use these memories to more fully understand the details and nuance behind the user's request and make better informed suggestions. + Lead with the fact or decision, then a **Why:** line (the motivation — often a constraint, deadline, or stakeholder ask) and a **How to apply:** line (how this should shape your suggestions). Project memories decay fast, so the why helps future-you judge whether the memory is still load-bearing. + + user: we're freezing all non-critical merges after Thursday — mobile team is cutting a release branch + assistant: [saves project memory: merge freeze begins 2026-03-05 for mobile release cut. Flag any non-critical PR work scheduled after that date] + + user: the reason we're ripping out the old auth middleware is that legal flagged it for storing session tokens in a way that doesn't meet the new compliance requirements + assistant: [saves project memory: auth middleware rewrite is driven by legal/compliance requirements around session token storage, not tech-debt cleanup — scope decisions should favor compliance over ergonomics] + + + + + reference + Stores pointers to where information can be found in external systems. These memories allow you to remember where to look to find up-to-date information outside of the project directory. + When you learn about resources in external systems and their purpose. For example, that bugs are tracked in a specific project in Linear or that feedback can be found in a specific Slack channel. + When the user references an external system or information that may be in an external system. + + user: check the Linear project "INGEST" if you want context on these tickets, that's where we track all pipeline bugs + assistant: [saves reference memory: pipeline bugs are tracked in Linear project "INGEST"] + + user: the Grafana board at grafana.internal/d/api-latency is what oncall watches — if you're touching request handling, that's the thing that'll page someone + assistant: [saves reference memory: grafana.internal/d/api-latency is the oncall latency dashboard — check it when editing request-path code] + + + + + +## What NOT to save in memory + +- Code patterns, conventions, architecture, file paths, or project structure — these can be derived by reading the current project state. +- Git history, recent changes, or who-changed-what — `git log` / `git blame` are authoritative. +- Debugging solutions or fix recipes — the fix is in the code; the commit message has the context. +- Anything already documented in CLAUDE.md files. +- Ephemeral task details: in-progress work, temporary state, current conversation context. + +These exclusions apply even when the user explicitly asks you to save. If they ask you to save a PR list or activity summary, ask what was _surprising_ or _non-obvious_ about it — that is the part worth keeping. + +## How to save memories + +Saving a memory is a two-step process: + +**Step 1** — write the memory to its own file (e.g., `user_role.md`, `feedback_testing.md`) using this frontmatter format: + +```markdown +--- +name: { { memory name } } +description: + { { one-line description — used to decide relevance in future conversations, so be specific } } +type: { { user, feedback, project, reference } } +--- + +{{memory content — for feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines}} +``` + +**Step 2** — add a pointer to that file in `MEMORY.md`. `MEMORY.md` is an index, not a memory — each entry should be one line, under ~150 characters: `- [Title](file.md) — one-line hook`. It has no frontmatter. Never write memory content directly into `MEMORY.md`. + +- `MEMORY.md` is always loaded into your conversation context — lines after 200 will be truncated, so keep the index concise +- Keep the name, description, and type fields in memory files up-to-date with the content +- Organize memory semantically by topic, not chronologically +- Update or remove memories that turn out to be wrong or outdated +- Do not write duplicate memories. First check if there is an existing memory you can update before writing a new one. + +## When to access memories + +- When memories seem relevant, or the user references prior-conversation work. +- You MUST access memory when the user explicitly asks you to check, recall, or remember. +- If the user says to _ignore_ or _not use_ memory: Do not apply remembered facts, cite, compare against, or mention memory content. +- Memory records can become stale over time. Use memory as context for what was true at a given point in time. Before answering the user or building assumptions based solely on information in memory records, verify that the memory is still correct and up-to-date by reading the current state of the files or resources. If a recalled memory conflicts with current information, trust what you observe now — and update or remove the stale memory rather than acting on it. + +## Before recommending from memory + +A memory that names a specific function, file, or flag is a claim that it existed _when the memory was written_. It may have been renamed, removed, or never merged. Before recommending it: + +- If the memory names a file path: check the file exists. +- If the memory names a function or flag: grep for it. +- If the user is about to act on your recommendation (not just asking about history), verify first. + +"The memory says X exists" is not the same as "X exists now." + +A memory that summarizes repo state (activity logs, architecture snapshots) is frozen in time. If the user asks about _recent_ or _current_ state, prefer `git log` or reading the code over recalling the snapshot. + +## Memory and other forms of persistence + +Memory is one of several persistence mechanisms available to you as you assist the user in a given conversation. The distinction is often that memory can be recalled in future conversations and should not be used for persisting information that is only useful within the scope of the current conversation. + +- When to use or update a plan instead of memory: If you are about to start a non-trivial implementation task and would like to reach alignment with the user on your approach you should use a Plan rather than saving this information to memory. Similarly, if you already have a plan within the conversation and you have changed your approach persist that change by updating the plan rather than saving a memory. +- When to use or update tasks instead of memory: When you need to break your work in current conversation into discrete steps or keep track of your progress use tasks instead of saving to memory. Tasks are great for persisting information about the work that needs to be done in the current conversation, but memory should be reserved for information that will be useful in future conversations. + +- Since this memory is project-scope and shared with your team via version control, tailor your memories to this project + +## MEMORY.md + +Your MEMORY.md is currently empty. When you save new memories, they will appear here. diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..6ead650 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,72 @@ +{ + "permissions": { + "allow": [ + "Bash(curl -s -L \"https://docs.aragon.org/osx\")", + "WebFetch(domain:docs.aragon.org)", + "WebFetch(domain:www.npmjs.com)", + "WebFetch(domain:github.com)", + "WebFetch(domain:www.holacracy.org)", + "Bash(pnpm install:*)", + "Bash(pnpm test:*)", + "Bash(forge build:*)", + "Bash(forge test:*)", + "Bash(curl -sL --max-time 15 https://paperclip.ing/about)", + "Bash(curl -sL --max-time 15 https://paperclip.ing/docs)", + "WebFetch(domain:paperclip.ing)", + "WebFetch(domain:docs.paperclip.ing)", + "Bash(curl -sL https://docs.0g.ai/0g-storage)", + "Bash(curl -sL https://docs.0g.ai/build-with-0g)", + "Bash(curl -sL https://docs.0g.ai/0g-da)", + "WebFetch(domain:docs.0g.ai)", + "Bash(curl:*)", + "Bash(npx solhint:*)", + "Bash(grep -r \"0g\\\\|0G\\\\|zero.g\\\\|zerog\" /Users/skas/Documents/GitHub/hollab-cannes-26 --include=*.ts --include=*.tsx --include=*.js)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26 -maxdepth 2 -type f \\\\\\(-name *.md -o -name README* \\\\\\))", + "Bash(git:*)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26 -path */node_modules -prune -o -type f \\\\\\(-name *.ts -o -name *.tsx \\\\\\) -print)", + "Bash(wc:*)", + "Bash(grep:*)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26 -path */node_modules -prune -o -type d -name *sdk* -o -name *storage* -o -name *crypto* -o -name *indexer*)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26/packages/contracts/out -type f -name *.json)", + "Bash(jq \".abi[] | select\\(.type == \"\"event\"\"\\)\")", + "Bash(for contract:*)", + "Bash(do echo:*)", + "Bash(jq \".abi[] | select\\(.type == \"\"event\"\"\\) | {name: .name, inputs: .inputs}\" 2)", + "Bash(/dev/null done:*)", + "Bash(pnpm:*)", + "WebFetch(domain:ens.domains)", + "WebFetch(domain:wagmi.sh)", + "Bash(forge clean:*)", + "WebSearch", + "WebFetch(domain:docs.ens.domains)", + "WebFetch(domain:docs.lido.fi)", + "WebFetch(domain:lido.fi)", + "WebFetch(domain:blog.lido.fi)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26/packages/dao-contracts -type f -name *.sol)", + "Read(//Users/skas/.claude/plugins/**)", + "Read(//Users/skas/.claude/**)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26/packages/contracts/src/governance -name *.sol)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26/packages/dao-contracts -name *.sol)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26/packages/contracts/src -name *.sol)", + "Bash(find /Users/skas/Documents/GitHub/hollab-cannes-26/packages -name *.sol)", + "Bash(ls -la /Users/skas/Documents/GitHub/hollab-cannes-26/packages/contracts/.env*)", + "WebFetch(domain:book.getfoundry.sh)", + "WebFetch(domain:getfoundry.sh)", + "WebFetch(domain:www.getfoundry.sh)", + "Bash(cat /Users/skas/Documents/GitHub/hollab-cannes-26/.github/workflows/*.yml)", + "Bash(npx tsc:*)", + "Bash(head -30 /Users/skas/Documents/GitHub/hollab-cannes-26/packages/contracts/test/fork/*.sol)", + "mcp__Railway__get-logs", + "WebFetch(domain:raw.githubusercontent.com)", + "Bash(npx playwright:*)", + "Bash(cast call:*)", + "mcp__plugin_aztec_aztec__aztec_search_code", + "mcp__plugin_aztec_aztec__aztec_read_file", + "mcp__plugin_aztec_aztec__aztec_read_example", + "WebFetch(domain:ponder.sh)" + ] + }, + "enabledPlugins": { + "openzeppelin-skills@openzeppelin-skills": true + } +} diff --git a/CLAUDE.md b/CLAUDE.md index 889a225..5dee138 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -77,10 +77,11 @@ Read `README.md` and `specs/00-overview.md` for the full model. The essentials: **Per-org contract set, cloned via ERC-1167 from `OrganizationFactory`:** -`OrganizationFactory` constructor takes three params: `(roleRegistryImpl, ensRegistrar, meetingComponentsFactory)`. +`OrganizationFactory` constructor takes four params: `(roleRegistryImpl, orgInstanceImpl, ensRegistrar, meetingComponentsFactory)`. The factory is a thin directory — `createOrganization` returns `(orgId, instance)`, emits `OrganizationCreated(orgId, subname, creator, instance, roleRegistry)`, and stores `(id → instance)` + `(subname → instance)` indices. No per-org state lives on the factory. +- `OrganizationInstance` — per-org one-stop address. Holds members/admins/join requests/agent identity links, stores component wiring (`roleRegistry`, `meetingFactory`, `token`, `accessManager`), and is the caller that gates `RoleRegistry.setGovernanceProcess` (via `setRoleRegistryGovernanceProcess`). `IOrganizationInstance` is the shared interface used by `MeetingFactory`, `MeetingComponentsFactory`, and `ActionVoting`. - `CircleRegistry` — circle hierarchy, role-to-circle assignments, elected positions (Facilitator, Secretary, Circle Rep) -- `RoleRegistry` — role definitions (purpose, domains, accountabilities). `setGovernanceProcess` is restricted to the OrgFactory (routed via `setRoleRegistryGovernanceProcess`, gated to `meetingComponentsFactory`). Emits `GovernanceProcessSet` when wired. +- `RoleRegistry` — role definitions (purpose, domains, accountabilities). `setGovernanceProcess` is gated to the instance (which delegates authority to `MeetingComponentsFactory.deploy`). Emits `GovernanceProcessSet` when wired. - `GovernanceProcess` — proposal lifecycle: `createProposal` → `raiseObjection` (opens an objection sub-lifecycle closed by `resolveObjection`) → `adopt` / `discard`. `adoptProposal` enforces zero open objections and reverts on expired proposals (`MAX_PROPOSAL_AGE` = 14 days). `discardExpiredProposal` is permissionless. This is the only path; `executeGovernance` no longer exists. - `GovernanceMeeting` — meeting outcomes (adopted proposals, election results) - DAO layer: `GovToken` (ERC20Votes) + `HolGovernor` + `TimelockController` + `CircleTreasury` + ENS subname `.hollab.eth` @@ -89,9 +90,9 @@ Proposals encode structural ops (CreateRole / AmendRole / RemoveRole, CreatePoli **Facilitator role:** `resolveObjection` requires the original objector (withdrawal) or the circle facilitator (dismissal per Holacracy §5.3.3-5.3.4). `setCircleFacilitator(circleId, facilitator)` is admin-gated for now. -**ERC-8004 agent identity:** Members can link agent NFTs to their org identity via `linkAgentIdentity(orgId, agentRegistry, agentId)`, emitting `AgentIdentityLinked`. This enables the agent-native surface described in the agent-sdk. +**ERC-8004 agent identity:** Members call `OrganizationInstance.linkAgentIdentity(agentRegistry, agentId)` to link an agent NFT they own to their org identity. Emits `AgentIdentityLinked(account, agentRegistry, agentId)`. This enables the agent-native surface described in the agent-sdk. -**Admin safety:** `removeOrgAdmin` prevents removing the last admin via `_orgAdminCount` tracking. `MeetingComponentsFactory.deploy()` requires org admin (`isOrgAdmin` check). `MeetingFactory` stores `orgId` at init and validates all `_orgId` params via `_validateOrgId()`. `ActionVoting` stores `orgId` at init and uses it for admin checks instead of `circleId`. +**Admin safety:** `OrganizationInstance.removeAdmin` prevents removing the last admin via `adminCount` tracking (reverts with `OrganizationInstance_LastAdmin`). `MeetingComponentsFactory.deploy()` requires org admin (`isOrgAdmin` on the instance). `MeetingFactory` / `ActionVoting` both store `orgId` at init and hold an `IOrganizationInstance org` reference for admin checks instead of the factory + `orgId` pair. **Data flow:** diff --git a/README.md b/README.md index 32eda48..9ba1b91 100644 --- a/README.md +++ b/README.md @@ -92,12 +92,19 @@ Proposals support **ContentRefs** — on-chain hashes pointing to off-chain encr ## Architecture -Each organization deployed through `OrganizationFactory` gets its own set of contracts: +`OrganizationFactory` is a thin directory — it mints a per-org `OrganizationInstance` clone and indexes `(orgId, subname) → instance`. All per-org state lives on the instance: ``` -OrganizationFactory +OrganizationFactory (singleton directory) + │ createOrganization → (orgId, instance) + ▼ +OrganizationInstance (ERC-1167 per-org, one-stop address) │ - │ Holacracy framework (ERC-1167 clones) + │ Per-org state + ├── members, admins, join requests, agent identity links + ├── component wiring (meetingFactory, accessManager, token) + │ + │ Holacracy framework (ERC-1167 clones, referenced by the instance) ├── CircleRegistry — Circles, roles, memberships, elected positions ├── RoleRegistry — Role definitions (name, purpose, domains, accountabilities) ├── GovernanceProcess — Proposal lifecycle: createProposal → raiseObjection / resolveObjection → adopt / discard @@ -108,7 +115,7 @@ OrganizationFactory ├── HolGovernor — OZ Governor for token-holder votes ├── TimelockController — Delay between vote approval and execution ├── CircleTreasury — Per-circle spending with timelock - └── ENS Subname — orgname.hollab.eth → governor address + └── ENS Subname — orgname.hollab.eth → AccessManager address ``` ### Holacracy Framework @@ -154,7 +161,7 @@ HolLab inverts this: start with structured roles and deliberation (Holacracy), a ## Specifications -The `specs/` directory contains the specification suite derived from the [Holacracy Constitution v5.0](https://www.holacracy.org/constitution/5-0/): +The `specs/` directory is a faithful transcription of the [Holacracy Constitution v5.0](https://www.holacracy.org/constitution/5-0/) into an implementation-oriented spec suite. This project is **Holacracy-shaped, not Holacracy-strict** — four deliberate departures adapt the model for continuous, async, human-and-agent operation. See [99 — Agent-native divergence](./specs/99-agent-native-divergence.md) for the canonical list of what we changed and why. | Spec | Title | | ------------------------------------------------------------------------- | -------------------------------------------------------- | @@ -166,6 +173,7 @@ The `specs/` directory contains the specification suite derived from the [Holacr | [05 — Governance Process](./specs/05-governance-process.md) | Proposals, Objections, Elections, Process Breakdown | | [06 — Glossary](./specs/06-glossary.md) | All defined terms and enum types | | [07 — Private Data & AI Agents](./specs/07-private-data-and-ai-agents.md) | Private Data Layer & AI Agent Integration | +| [99 — Agent-native divergence](./specs/99-agent-native-divergence.md) | Where this implementation departs from v5.0, and why | ## Development @@ -221,7 +229,7 @@ See the repository root [LICENSE](./LICENSE) file. ### Holacracy Constitution -The specification documents in `specs/` are derived from the **Holacracy Constitution v5.0** by HolacracyOne, LLC. +The structural model (roles, circles, domains, accountabilities, policies), governance process (proposals, objections, consent-based adoption), and auditability (on-chain commitments with event-sourced history) are derived from the **Holacracy Constitution v5.0** by HolacracyOne, LLC. Four deliberate departures adapt it for continuous, async, human-and-agent operation — see [`specs/99-agent-native-divergence.md`](./specs/99-agent-native-divergence.md) for the full list. - **License:** [Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/) - **Original source:** [holacracy.org/constitution](https://www.holacracy.org/constitution/5-0/) and [GitHub](https://github.com/holacracyone/Holacracy-Constitution) @@ -231,4 +239,4 @@ Under CC BY-SA 4.0, you are free to share and adapt the material for any purpose ### Trademark Notice -**Holacracy** is a registered trademark of HolacracyOne, LLC. This project references Holacracy for attribution purposes as required by the CC BY-SA 4.0 license. If the governance rules implemented here diverge from the official Constitution, the resulting system should not be marketed or represented as "Holacracy" without explicit permission from HolacracyOne, LLC. +This project is derived from, but is **not**, Holacracy®. "Holacracy" is a registered trademark of HolacracyOne, LLC. This implementation deliberately diverges from the v5.0 Constitution (see [`specs/99-agent-native-divergence.md`](./specs/99-agent-native-divergence.md)) and must not be marketed or represented as Holacracy. The Constitution text in `specs/` is used under the CC BY-SA 4.0 license; the divergence document indicates the changes as that license requires. diff --git a/apps/docs/docs/pages/architecture.mdx b/apps/docs/docs/pages/architecture.mdx index 09f7d57..85e2770 100644 --- a/apps/docs/docs/pages/architecture.mdx +++ b/apps/docs/docs/pages/architecture.mdx @@ -17,9 +17,10 @@ hollab.eth is a monorepo with smart contracts, an event indexer, a TypeScript SD │ (Sepolia / L1) │───▶│ (indexes events → GraphQL) │ │ │ │ │ │ OrganizationFactory │ │ Organizations, Roles, Circles │ -│ RoleRegistry │ │ Meetings, Outputs, Proposals │ -│ MeetingFactory │ │ Members, Votes, Policies │ -│ ActionVoting │ └─────────────────────────────────┘ +│ OrganizationInstance│ │ Meetings, Outputs, Proposals │ +│ RoleRegistry │ │ Members, Votes, Policies │ +│ MeetingFactory │ └─────────────────────────────────┘ +│ ActionVoting │ │ GovToken │ │ ENSSubdomainReg. │ └──────────────────────┘ @@ -65,13 +66,20 @@ The frontend reads data through the Ponder indexer: ### Contract Discovery -Ponder uses **contract discovery** — it starts by watching the factory contracts (OrganizationFactory, MeetingComponentsFactory), then automatically registers per-org clones (RoleRegistry, MeetingFactory, ActionVoting) as they're deployed. +Ponder uses **contract discovery** — it starts by watching the factory contracts (OrganizationFactory, MeetingComponentsFactory), then automatically registers per-org clones as they're deployed: + +- `OrganizationCreated(orgId, subname, creator, instance, roleRegistry)` → registers **OrganizationInstance** + **RoleRegistry** for the new org +- `MeetingComponentsDeployed(...)` → registers **MeetingFactory** + **ActionVoting** for the org ## Key Design Decisions ### ERC-1167 Minimal Proxies -All per-organization contracts (RoleRegistry, MeetingFactory, ActionVoting) are deployed as [ERC-1167 minimal proxy clones](https://eips.ethereum.org/EIPS/eip-1167). This reduces deployment gas from ~3M to ~100K per org while keeping the same interface. +All per-organization contracts (OrganizationInstance, RoleRegistry, MeetingFactory, ActionVoting) are deployed as [ERC-1167 minimal proxy clones](https://eips.ethereum.org/EIPS/eip-1167). This reduces deployment gas from ~3M to ~100K per org while keeping the same interface. + +### Factory + Instance Split + +`OrganizationFactory` is a thin directory — it mints clones and indexes `(orgId, subname) → instance`. Every org's state (members, admins, join requests, agent identity links, component wiring) lives on its own [`OrganizationInstance`](/contracts/organization-instance) clone. This keeps per-org writes contained, makes individual orgs addressable on their own, and lets consumer contracts (MeetingFactory, MeetingComponentsFactory, ActionVoting) target a single `IOrganizationInstance` reference instead of passing `orgId` on every call. ### Governance-Only Structure Changes diff --git a/apps/docs/docs/pages/contracts/organization-factory.mdx b/apps/docs/docs/pages/contracts/organization-factory.mdx index c1f8da8..c0ff938 100644 --- a/apps/docs/docs/pages/contracts/organization-factory.mdx +++ b/apps/docs/docs/pages/contracts/organization-factory.mdx @@ -1,84 +1,60 @@ # OrganizationFactory -The entry point for creating and managing hollab.eth organizations. Deployed once per chain as a singleton. +Thin **directory** + creation entry point for hollab.eth organizations. Deployed once per chain as a singleton. + +The factory no longer holds per-org state. Every organization's members, admins, join requests, agent identity links, and component wiring live on a per-org [`OrganizationInstance`](/contracts/organization-instance) clone. The factory just mints the clone and maintains the `(orgId, subname) → instance` index. **Source:** `packages/contracts/src/contracts/OrganizationFactory.sol` -**Constructor:** `OrganizationFactory(roleRegistryImpl, ensRegistrar, meetingComponentsFactory)` +**Constructor:** `OrganizationFactory(roleRegistryImpl, orgInstanceImpl, ensRegistrar, meetingComponentsFactory)` ## Creating an Organization ```solidity function createOrganization( - string calldata name, - string calldata subname -) external returns (uint256 orgId) + string calldata subname, + string calldata purpose, + TokenConfig calldata tokenConfig +) external returns (uint256 orgId, address instance) ``` -This deploys the full org infrastructure in a single transaction: - -1. Clones a new **RoleRegistry** (minimal proxy) -2. Deploys a **GovToken** (ERC20Votes) via GovTokenDeployer -3. Creates an **AccessManager** for role-based permissions -4. Registers an **ENS subname** (`subname.hollab.eth`) -5. Stores the Organization struct and emits discovery events - -The caller becomes the org creator and first admin. - -## Membership +One transaction bootstraps an organization: -Organizations have two roles: **admin** and **member**. - -```solidity -// Admin management (owner only) -function addOrgAdmin(uint256 orgId, address admin) external -function removeOrgAdmin(uint256 orgId, address admin) external - // prevents removing the last admin (_orgAdminCount tracking) - -// Member management (admin only) -function addOrgMember(uint256 orgId, address member) external -function removeOrgMember(uint256 orgId, address member) external -``` +1. Clones a **RoleRegistry** (minimal proxy) and seeds its anchor circle (§1.3.3) +2. Deploys a **GovToken** (ERC20Votes) via `GovTokenDeployer` and mints initial allocations +3. Deploys an **AccessManager** owned by the caller +4. Registers the ENS subname `subname.hollab.eth` pointing at the AccessManager +5. Clones an **OrganizationInstance** and initializes it with the component addresses +6. Hands `RoleRegistry` factory authority over to the instance — the factory has no further write authority over the org -### Join Requests +The caller becomes the org creator, first admin, and first member on the instance. -External users can request to join an organization: +## Events ```solidity -function requestToJoin(uint256 orgId) external -function approveJoinRequest(uint256 orgId, uint256 requestId) external -function rejectJoinRequest(uint256 orgId, uint256 requestId) external +event OrganizationCreated( + uint256 indexed orgId, + string subname, + address indexed creator, + address indexed instance, + address roleRegistry +); ``` -## Agent Identity (ERC-8004) +`OrganizationCreated` is the only event the factory emits. `instance` and `roleRegistry` are published together so indexers can factory-discover both clones from a single event. All membership, join-request, admin, and agent-identity events are emitted by the [`OrganizationInstance`](/contracts/organization-instance) clone itself. -Org members can link ERC-8004 agent NFTs to their org identity: +## Directory Queries ```solidity -function linkAgentIdentity(uint256 orgId, address agentRegistry, uint256 agentId) external +function getOrganization(uint256 orgId) external view returns (address instance); +function getOrganizationBySubname(string calldata subname) external view returns (address instance); +function organizationCount() external view returns (uint256 count); +function roleRegistryImplementation() external view returns (address impl); +function organizationInstanceImplementation() external view returns (address impl); ``` -Emits `AgentIdentityLinked(orgId, member, agentRegistry, agentId)`. This enables the agent-native surface where AI agents participate in governance through linked identities. +Both lookups return `address(0)` when the org/subname doesn't exist. Once you have an instance address, call [`summary()`](/contracts/organization-instance#summary) on it for the full `Organization` struct (name, purpose, component addresses, token, anchor circle, timestamps). -## Queries +## Migration Note -```solidity -function getOrganization(uint256 orgId) external view returns (Organization memory) -function getOrganizations() external view returns (Organization[] memory) -function getOrganizationBySubname(string calldata subname) external view returns (Organization memory) -``` - -## Organization Struct - -```solidity -struct Organization { - uint256 id; - string name; - string subname; // ENS label - address creator; - address roleRegistry; // Cloned RoleRegistry - address accessManager; // OpenZeppelin AccessManager - address token; // GovToken address - // ... -} -``` +Earlier versions of this contract exposed `addOrgMember`, `removeOrgMember`, `addOrgAdmin`, `removeOrgAdmin`, `requestToJoin`, `approveJoinRequest`, `rejectJoinRequest`, `linkAgentIdentity`, and `getOrganization` returning an `Organization` struct. All of these moved to [`OrganizationInstance`](/contracts/organization-instance) during the factory-to-instance refactor. If you were calling the factory for any of them, retarget the call to `IOrganizationInstance(instance)` after resolving the instance address from `getOrganization(orgId)`. diff --git a/apps/docs/docs/pages/contracts/organization-instance.mdx b/apps/docs/docs/pages/contracts/organization-instance.mdx new file mode 100644 index 0000000..6d35242 --- /dev/null +++ b/apps/docs/docs/pages/contracts/organization-instance.mdx @@ -0,0 +1,129 @@ +# OrganizationInstance + +The per-org **one-stop address**. An ERC-1167 clone deployed by `OrganizationFactory.createOrganization` that holds all per-organization state and is the authoritative target for membership writes, join-request flows, admin ops, and agent identity links. + +**Source:** `packages/contracts/src/contracts/OrganizationInstance.sol` + +**Interface:** `packages/contracts/src/interfaces/IOrganizationInstance.sol` + +## Why a per-org instance + +Before the refactor, `OrganizationFactory` stored every org's members/admins/join requests in nested mappings keyed by `orgId`. That coupled every org's writes to the same contract, inflated the factory's storage graph, and made per-org upgrades impossible. + +`OrganizationInstance` splits that apart: + +- one clone per org, ~100K gas to deploy +- addressable independently — each org is its own contract +- factory becomes a thin directory; all consumer contracts (MeetingFactory, MeetingComponentsFactory, ActionVoting) take an `IOrganizationInstance` reference + +## Initialization + +```solidity +function initialize(InitParams calldata params) external; + +struct InitParams { + uint256 id; + string subname; + string purpose; + address creator; + address roleRegistry; + address accessManager; + address token; + uint256 anchorCircleId; + address meetingComponentsFactory; +} +``` + +Called exactly once, immediately after the factory clones the implementation. Reverts with `OrganizationInstance_AlreadyInitialized` on any subsequent call. The creator is seeded as the first admin and first member. + +## Membership + +```solidity +function addMember(address account) external; // admin only +function removeMember(address account) external; // admin only +function isMember(address account) external view returns (bool); +``` + +Emits `MemberAdded(account)` and `MemberRemoved(account)`. + +## Admins + +```solidity +function addAdmin(address account) external; // admin only +function removeAdmin(address account) external; // admin only — reverts if last admin +function isAdmin(address account) external view returns (bool); +function adminCount() external view returns (uint256); +``` + +Emits `AdminAdded(account)` / `AdminRemoved(account)`. The `_orgAdminCount` tracking prevents removing the last admin (`OrganizationInstance_LastAdmin`). + +## Join Requests + +Outsiders can request membership: + +```solidity +function requestToJoin(string calldata message) external returns (uint256 requestId); +function approveJoinRequest(address requester) external; // admin only +function rejectJoinRequest(address requester) external; // admin only +function hasPendingRequest(address requester) external view returns (bool); +``` + +Emits `JoinRequested(requestId, requester, message)`, `JoinApproved(requestId, requester)`, or `JoinRejected(requestId, requester)`. + +## Agent Identity (ERC-8004) + +```solidity +function linkAgentIdentity(address agentRegistry, uint256 agentId) external; +function getAgentIdentity(address account) external view + returns (address agentRegistry, uint256 agentId); +``` + +Members link an ERC-8004 agent NFT they own to their org identity. Emits `AgentIdentityLinked(account, agentRegistry, agentId)`. Reverts with `OrganizationInstance_AgentNotOwner` if `msg.sender` doesn't own the NFT. + +## Component Wiring + +```solidity +function setMeetingFactory(address meetingFactory) external; // meetingComponentsFactory only, once +function setRoleRegistryGovernanceProcess(address governanceProcess) external; // meetingComponentsFactory only +``` + +The `MeetingComponentsFactory.deploy()` flow calls these to plug a freshly deployed `MeetingFactory` into the org as its `governanceProcess`. The instance — not the factory — is the authority that gates these writes. + +## summary() + +```solidity +function summary() external view returns (HolacracyTypes.Organization memory); +``` + +Returns the full org struct: `id`, `name`, `subname`, `creator`, `roleRegistry`, `circleRegistry`, `governanceProcess`, `meetingFactory`, `accessManager`, `anchorCircleId`, `createdAt`, `token`. This is the authoritative read for everything off-chain — frontend hooks, the indexer, and the agent-sdk all call `summary()` to refresh their snapshot. + +## Discovering the instance + +Given an `orgId`, resolve the instance address from the factory: + +```solidity +address instance = IOrganizationFactory(factory).getOrganization(orgId); +// or +address instance = IOrganizationFactory(factory).getOrganizationBySubname("myorg"); +``` + +From TypeScript: + +```ts +import { organizationInstanceAbi } from "@hollab-io/viem-extension"; + +const instance = await publicClient.readContract({ + address: factoryAddress, + abi: organizationFactoryAbi, + functionName: "getOrganization", + args: [orgId], +}); + +const summary = await publicClient.readContract({ + address: instance, + abi: organizationInstanceAbi, + functionName: "summary", +}); +``` + +The indexer surfaces `organization.instanceAddress` on every row, so most consumers don't need to resolve it manually. diff --git a/apps/docs/docs/pages/contracts/overview.mdx b/apps/docs/docs/pages/contracts/overview.mdx index 1fbacf6..390791b 100644 --- a/apps/docs/docs/pages/contracts/overview.mdx +++ b/apps/docs/docs/pages/contracts/overview.mdx @@ -5,41 +5,47 @@ The smart contracts live in `packages/contracts/` and implement the Holacracy go ## Contract Map ``` -OrganizationFactory (singleton) -├── creates → RoleRegistry (ERC-1167 clone per org) -├── creates → GovToken (ERC20Votes, one per org) -├── creates → AccessManager (one per org) +OrganizationFactory (singleton, thin directory) +├── clones → OrganizationInstance (per-org, one-stop address) +│ ├── holds → members, admins, join requests, agent identity links +│ ├── wires → MeetingFactory via setMeetingFactory +│ └── owns → RoleRegistry factory authority +├── clones → RoleRegistry (ERC-1167 per org, seeded with anchor circle) +├── deploys → GovToken (ERC20Votes, one per org) +├── deploys → AccessManager (one per org) └── registers → ENS subname via ENSSubdomainRegistrar MeetingComponentsFactory (singleton) -├── clones → MeetingFactory (per org/circle, stores orgId at init) -├── clones → ActionVoting (per org/circle, stores orgId at init) -└── deploy() requires org admin (isOrgAdmin check) +├── clones → MeetingFactory (per org, stores orgId at init) +├── clones → ActionVoting (per org, stores orgId at init) +├── calls → instance.setMeetingFactory(meetingFactory) +├── calls → instance.setRoleRegistryGovernanceProcess(meetingFactory) +└── deploy() requires org admin (isOrgAdmin on OrganizationInstance) MeetingFactory -└── set as governanceProcess on RoleRegistry +└── set as governanceProcess on RoleRegistry by the instance (only contract that can modify roles) - setGovernanceProcess restricted to OrgFactory (msg.sender == factory) ``` ## Core Contracts -| Contract | Type | Purpose | -| ------------------------------------------------------ | ---------------- | --------------------------------------- | -| [OrganizationFactory](/contracts/organization-factory) | Singleton | Deploy orgs, manage membership | -| [RoleRegistry](/contracts/role-registry) | Clone per org | Store roles, circles, assignments | -| [MeetingFactory](/contracts/meeting-factory) | Clone per org | Meeting lifecycle, governance execution | -| [ActionVoting](/contracts/action-voting) | Clone per org | Token-weighted + collaborator voting | -| [GovToken](/contracts/gov-token) | Instance per org | ERC20Votes for governance power | -| [ENSSubdomainRegistrar](/contracts/ens) | Singleton | `myorg.hollab.eth` registration | +| Contract | Type | Purpose | +| -------------------------------------------------------- | ---------------- | --------------------------------------------------------------- | +| [OrganizationFactory](/contracts/organization-factory) | Singleton | Thin directory: mint orgs, index `id/subname → instance` | +| [OrganizationInstance](/contracts/organization-instance) | Clone per org | One-stop address: members, admins, join, agent identity, wiring | +| [RoleRegistry](/contracts/role-registry) | Clone per org | Store roles, circles, assignments | +| [MeetingFactory](/contracts/meeting-factory) | Clone per org | Meeting lifecycle, governance execution | +| [ActionVoting](/contracts/action-voting) | Clone per org | Token-weighted + collaborator voting | +| [GovToken](/contracts/gov-token) | Instance per org | ERC20Votes for governance power | +| [ENSSubdomainRegistrar](/contracts/ens) | Singleton | `myorg.hollab.eth` registration | ## Supporting Contracts -| Contract | Purpose | -| ------------------------ | -------------------------------------------------------------- | -| GovTokenDeployer | Helper to deploy GovToken (extracted for contract size limits) | -| MeetingComponentsFactory | Deploy MeetingFactory + ActionVoting clones | -| HolacracyTypes | Shared enums and structs | +| Contract | Purpose | +| ------------------------ | -------------------------------------------------------------------------------- | +| GovTokenDeployer | Helper to deploy GovToken (extracted for contract size limits) | +| MeetingComponentsFactory | Deploy MeetingFactory + ActionVoting clones; wire them into OrganizationInstance | +| HolacracyTypes | Shared enums and structs | ## Design Patterns @@ -51,7 +57,7 @@ Implementation contracts are deployed once as part of infrastructure. Each `crea ### Governance Lock -RoleRegistry accepts a `governanceProcess` address during initialization. Only this address (the MeetingFactory) can call `createRole`, `updateRole`, and `removeRole`. This enforces the Holacracy principle that organizational structure only changes through governance meetings. +RoleRegistry accepts a `governanceProcess` address that only the per-org `OrganizationInstance` can set (via `MeetingComponentsFactory`). Once wired, only the MeetingFactory can call `createRole`, `updateRole`, and `removeRole`. This enforces the Holacracy principle that organizational structure only changes through governance meetings — and keeps each org's authority boundary contained to its own instance. ### Event-First Data diff --git a/apps/docs/docs/pages/frontend/user-journey.mdx b/apps/docs/docs/pages/frontend/user-journey.mdx index 30a4b96..2138c06 100644 --- a/apps/docs/docs/pages/frontend/user-journey.mdx +++ b/apps/docs/docs/pages/frontend/user-journey.mdx @@ -28,7 +28,7 @@ This calls `OrganizationFactory.createOrganization()`, deploying the full infras ### Member Onboarding -The creator invites initial members by wallet address or ENS name. Members are added via `addOrgMember()` and receive governance tokens via `GovToken.mint()`. +The creator invites initial members by wallet address or ENS name. Members are added via `OrganizationInstance.addMember()` on the per-org instance clone and receive governance tokens via `GovToken.mint()`. ## 4. Workspace diff --git a/apps/docs/docs/pages/indexer/client.mdx b/apps/docs/docs/pages/indexer/client.mdx index 22dd801..e9ae894 100644 --- a/apps/docs/docs/pages/indexer/client.mdx +++ b/apps/docs/docs/pages/indexer/client.mdx @@ -63,8 +63,10 @@ Proposal rows carry the full `ProposalRecord` surface (`tensionHash`, `changeTyp ### Members & Voting ```ts -const members = await client.listOrgMembersByOrg(factoryAddress, orgId); -const pending = await client.listPendingJoinRequestsByOrg(contractAddress, orgId); +// Pass the per-org OrganizationInstance address — the authoritative membership scope. +// Available on `organization.instanceAddress` from any org read. +const members = await client.listOrgMembersByOrg(instanceAddress, orgId); +const pending = await client.listPendingJoinRequestsByOrg(orgId); const votes = await client.listActionVotes(contractAddress); const casts = await client.listActionVoteCasts(contractAddress, voteId); ``` diff --git a/apps/docs/docs/pages/indexer/ponder.mdx b/apps/docs/docs/pages/indexer/ponder.mdx index ed4751d..158f395 100644 --- a/apps/docs/docs/pages/indexer/ponder.mdx +++ b/apps/docs/docs/pages/indexer/ponder.mdx @@ -8,17 +8,18 @@ Ponder subscribes to on-chain events from the factory contracts and their per-or ### Indexed Contracts -| Contract | Discovery | Events | -| ------------------------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| OrganizationFactory | Fixed address | `OrganizationCreated`, `OrgComponentsDeployed` | -| MeetingComponentsFactory | Fixed address | `MeetingComponentsDeployed` | -| RoleRegistry | Auto-discovered per org | Circle/role creation, updates, removals | -| MeetingFactory | Auto-discovered per org | `MeetingStarted`, `MeetingEnded`, `MeetingOutputRecorded`, `MeetingProposalLinked`, `ProposalCreated`, `ProposalAdopted`, `ProposalDiscarded`, `ObjectionRaised`, `ObjectionResolved` | -| ActionVoting | Auto-discovered per org | `VoteCreated`, `VoteCast` | +| Contract | Discovery | Events | +| ------------------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| OrganizationFactory | Fixed address | `OrganizationCreated` | +| OrganizationInstance | Auto-discovered per org (from `OrganizationCreated._instance`) | `MemberAdded`, `MemberRemoved`, `AdminAdded`, `AdminRemoved`, `JoinRequested`, `JoinApproved`, `JoinRejected`, `AgentIdentityLinked`, `MeetingFactorySet` | +| RoleRegistry | Auto-discovered per org (from `OrganizationCreated._roleRegistry`) | Circle/role creation, updates, removals | +| MeetingComponentsFactory | Fixed address | `MeetingComponentsDeployed` | +| MeetingFactory | Auto-discovered per org | `MeetingStarted`, `MeetingEnded`, `MeetingOutputRecorded`, `MeetingProposalLinked`, `ProposalCreated`, `ProposalAdopted`, `ProposalDiscarded`, `ObjectionRaised`, `ObjectionResolved` | +| ActionVoting | Auto-discovered per org | `VoteCreated`, `VoteCast` | ### Contract Discovery -Ponder starts by watching the two factory contracts. When an `OrgComponentsDeployed` or `MeetingComponentsDeployed` event fires, Ponder dynamically registers the new clone addresses and starts indexing their events too. +Ponder starts by watching the two factory contracts. When `OrganizationCreated` fires, Ponder dynamically registers the new `OrganizationInstance` and `RoleRegistry` clone addresses from the event parameters and starts indexing their events. `MeetingComponentsDeployed` does the same for `MeetingFactory` / `ActionVoting` clones. This means the indexer automatically picks up new organizations without reconfiguration. @@ -26,18 +27,20 @@ This means the indexer automatically picks up new organizations without reconfig Key tables maintained by the indexer: -| Table | Source | -| -------------------------------------- | ----------------------------------------------------------- | -| `organization` | OrganizationFactory events | -| `circle`, `role`, `policy` | RoleRegistry events | -| `tacticalMeeting`, `governanceMeeting` | MeetingFactory events | -| `meetingOutput` | Meeting output recordings | -| `proposal` | `ProposalCreated` / `ProposalAdopted` / `ProposalDiscarded` | -| `objection` | `ObjectionRaised` / `ObjectionResolved` | -| `orgMember`, `joinRequest` | Membership events | -| `actionVote`, `actionVoteCast` | ActionVoting events | -| `meetingComponentSet` | Factory deployment events | -| `governanceMeetingLink` | Proposal-meeting links | +| Table | Source | +| -------------------------------------- | ---------------------------------------------------------------------------- | +| `organization` | `OrganizationFactory.OrganizationCreated` + `OrganizationInstance.summary()` | +| `circle`, `role`, `policy` | RoleRegistry events | +| `tacticalMeeting`, `governanceMeeting` | MeetingFactory events | +| `meetingOutput` | Meeting output recordings | +| `proposal` | `ProposalCreated` / `ProposalAdopted` / `ProposalDiscarded` | +| `objection` | `ObjectionRaised` / `ObjectionResolved` | +| `orgMember`, `joinRequest` | `OrganizationInstance` membership + join events | +| `actionVote`, `actionVoteCast` | ActionVoting events | +| `meetingComponentSet` | Factory deployment events | +| `governanceMeetingLink` | Proposal-meeting links | + +The `organization` row carries an `instanceAddress` column pointing at the per-org `OrganizationInstance` clone — the authoritative target for membership writes, join approvals, and agent identity links. The `proposal` table is fully event-sourced and mirrors the on-chain `ProposalRecord`: `proposalId`, `processAddress`, `orgId`, `circleId`, `proposer`, `proposerRoleId`, `tensionHash`, `changeType`, `changeData`, `status` (0=Draft, 3=Adopted, 5=Discarded in MVP), `changeResultId` (set on adopt), and `submittedAt` / `resolvedAt` / `resolvedBy` timestamps. diff --git a/apps/docs/docs/pages/sdk/agent-sdk.mdx b/apps/docs/docs/pages/sdk/agent-sdk.mdx index 87d74f2..80a8b9b 100644 --- a/apps/docs/docs/pages/sdk/agent-sdk.mdx +++ b/apps/docs/docs/pages/sdk/agent-sdk.mdx @@ -70,12 +70,21 @@ const { items: votes } = await agent.voting.listByCircle(votingAddress, "1"); ## Managing Organizations ```ts -// Create a new org (deploys governance token + registers ENS subname) -const { orgId } = await agent.org.create("My DAO", "MDAO"); +// Create a new org (clones OrganizationInstance + RoleRegistry, deploys +// governance token, registers ENS subname). Returns both the orgId and the +// per-org OrganizationInstance address — the one-stop target for membership +// writes, join requests, admin ops, and agent identity links. +const { orgId, instance } = await agent.org.create("mydao", "Our purpose", { + tokenName: "My DAO Token", + tokenSymbol: "MDAO", +}); + +// Add / remove members — call on the OrganizationInstance clone. +await agent.org.addMember(instance, "0xAlice..."); +await agent.org.removeMember(instance, "0xBob..."); -// Add / remove members -await agent.org.addMember(orgId, "0xAlice..."); -await agent.org.removeMember(orgId, "0xBob..."); +// If you only have the orgId, resolve the instance from the factory directory: +const instance = await agent.org.resolveInstance(orgId); ``` ## Running Meetings diff --git a/apps/docs/vocs.config.ts b/apps/docs/vocs.config.ts index a488ca5..15fc6d5 100644 --- a/apps/docs/vocs.config.ts +++ b/apps/docs/vocs.config.ts @@ -28,6 +28,7 @@ export default defineConfig({ items: [ { text: "Overview", link: "/contracts/overview" }, { text: "OrganizationFactory", link: "/contracts/organization-factory" }, + { text: "OrganizationInstance", link: "/contracts/organization-instance" }, { text: "RoleRegistry", link: "/contracts/role-registry" }, { text: "MeetingFactory", link: "/contracts/meeting-factory" }, { text: "ActionVoting", link: "/contracts/action-voting" }, diff --git a/apps/docs/vocs.config.ts.timestamp-1776324288003-c20653bf328678.mjs b/apps/docs/vocs.config.ts.timestamp-1776324288003-c20653bf328678.mjs new file mode 100644 index 0000000..304a7aa --- /dev/null +++ b/apps/docs/vocs.config.ts.timestamp-1776324288003-c20653bf328678.mjs @@ -0,0 +1,73 @@ +// vocs.config.ts +import { defineConfig } from "file:///Users/skas/Documents/GitHub/hollab-cannes-26/node_modules/.pnpm/vocs@1.0.0-alpha.62_@types+node@24.12.2_@types+react-dom@19.2.3_@types+react@19.2.14__@types+_fsx26vbbj3odmcmqybrctfi7g4/node_modules/vocs/_lib/index.js"; + +var vocs_config_default = defineConfig({ + title: "hollab.eth", + description: "The onchain operating system for autonomous organizations", + vite: { + server: { + port: 1243, + }, + }, + sidebar: [ + { + text: "Introduction", + items: [ + { text: "What is hollab.eth", link: "/introduction" }, + { text: "Architecture", link: "/architecture" }, + ], + }, + { + text: "Getting Started", + items: [ + { text: "Installation", link: "/getting-started/installation" }, + { text: "Local Development", link: "/getting-started/local-dev" }, + ], + }, + { + text: "Contracts", + items: [ + { text: "Overview", link: "/contracts/overview" }, + { text: "OrganizationFactory", link: "/contracts/organization-factory" }, + { text: "RoleRegistry", link: "/contracts/role-registry" }, + { text: "MeetingFactory", link: "/contracts/meeting-factory" }, + { text: "ActionVoting", link: "/contracts/action-voting" }, + { text: "GovToken", link: "/contracts/gov-token" }, + { text: "ENS Integration", link: "/contracts/ens" }, + { text: "Deployment", link: "/contracts/deployment" }, + ], + }, + { + text: "Indexer", + items: [ + { text: "Ponder Indexer", link: "/indexer/ponder" }, + { text: "Indexing Client", link: "/indexer/client" }, + ], + }, + { + text: "SDK", + items: [ + { text: "Overview", link: "/sdk/overview" }, + { text: "Key Management", link: "/sdk/key-management" }, + { text: "Viem Extension", link: "/sdk/viem-extension" }, + { text: "Agent SDK", link: "/sdk/agent-sdk" }, + ], + }, + { + text: "Frontend", + items: [ + { text: "App Structure", link: "/frontend/structure" }, + { text: "User Journey", link: "/frontend/user-journey" }, + ], + }, + { + text: "Operations", + items: [ + { text: "Docker & CI/CD", link: "/operations/docker" }, + { text: "IPFS Deployment", link: "/operations/ipfs" }, + ], + }, + ], +}); +export { vocs_config_default as default }; +//# sourceMappingURL=data:application/json;base64,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 diff --git a/apps/hola-modern/e2e/journey.spec.ts b/apps/hola-modern/e2e/journey.spec.ts index 411fe1d..83315ba 100644 --- a/apps/hola-modern/e2e/journey.spec.ts +++ b/apps/hola-modern/e2e/journey.spec.ts @@ -6,6 +6,15 @@ * hooks (useJoinRequest, useSendTransaction, etc.) without the UI layer. * * Anvil is started and contracts are deployed by global-setup.ts. + * + * Contract model (post factory/instance split): + * - OrganizationFactory: thin directory. createOrganization returns (orgId, instance). + * getOrganization(id) → instance address. No membership/admin API lives here. + * - OrganizationInstance: per-org clone. Holds admins/members/join-requests/agent + * identity + wiring references (roleRegistry, meetingFactory, token, anchorCircleId). + * - MeetingComponentsFactory.deploy(subname, orgFactory) emits + * MeetingComponentsDeployed(orgId, meetingFactory, actionVoting, roleDataRegistry) + * and returns the per-org MeetingFactory + ActionVoting clones. */ import { readFileSync } from "node:fs"; import { dirname, resolve } from "node:path"; @@ -17,6 +26,7 @@ import { createPublicClient, createWalletClient, decodeEventLog, + encodeAbiParameters, getAddress, http, parseAbi, @@ -39,30 +49,48 @@ const ALICE = privateKeyToAccount(ANVIL_ACCOUNTS[1].privateKey as `0x${string}`) const BOB = privateKeyToAccount(ANVIL_ACCOUNTS[2].privateKey as `0x${string}`); const CAROL = privateKeyToAccount(ANVIL_ACCOUNTS[3].privateKey as `0x${string}`); +// Every per-org RoleRegistry clone starts its counter at 1, so the anchor circle +// and anchor role are always id=1 within their own org. The anchor role's lead +// is seeded to the org creator at createOrganization time — required to satisfy +// §5.3 Representation Rule when proposing from the anchor circle. +const ANCHOR_CIRCLE_ID = 1n; +const ANCHOR_ROLE_ID = 1n; + // ── ABIs (minimal, matching what the frontend hooks use) ──────────────────── const orgFactoryAbi = parseAbi([ - "function createOrganization(string _subname, string _purpose, (string tokenName, string tokenSymbol, address[] initialHolders, uint256[] initialAmounts) _tokenConfig) external returns (uint256)", - "function getOrganization(uint256 _orgId) external view returns ((uint256 id, string name, string subname, address creator, address roleRegistry, address circleRegistry, address governanceProcess, address meetingFactory, address accessManager, uint256 anchorCircleId, uint256 createdAt, address token))", + "function createOrganization(string _subname, string _purpose, (string tokenName, string tokenSymbol, address[] initialHolders, uint256[] initialAmounts) _tokenConfig) external returns (uint256, address)", + "function getOrganization(uint256 _orgId) external view returns (address)", + "function getOrganizationBySubname(string _subname) external view returns (address)", "function organizationCount() external view returns (uint256)", - "function requestToJoin(uint256 orgId, string message) external returns (uint256)", - "function approveJoinRequest(uint256 orgId, address requester) external", - "function rejectJoinRequest(uint256 orgId, address requester) external", - "function addOrgAdmin(uint256 orgId, address account) external", - "function addOrgMember(uint256 orgId, address account) external", - "function removeOrgMember(uint256 orgId, address account) external", - "function isOrgAdmin(uint256 orgId, address account) external view returns (bool)", - "function isOrgMember(uint256 orgId, address account) external view returns (bool)", - "function hasPendingRequest(address requester, uint256 orgId) external view returns (bool)", - "event OrganizationCreated(uint256 indexed _orgId, string _subname, address indexed _creator)", - "event JoinRequested(uint256 indexed requestId, address indexed requester, uint256 indexed orgId, string message)", - "event JoinApproved(uint256 indexed requestId, address indexed requester, uint256 indexed orgId)", - "event OrgMemberAdded(uint256 indexed orgId, address indexed account)", + "event OrganizationCreated(uint256 indexed _orgId, string _subname, address indexed _creator, address indexed _instance, address _roleRegistry)", +]); + +const orgInstanceAbi = parseAbi([ + "function id() external view returns (uint256)", + "function subname() external view returns (string)", + "function creator() external view returns (address)", + "function roleRegistry() external view returns (address)", + "function meetingFactory() external view returns (address)", + "function token() external view returns (address)", + "function anchorCircleId() external view returns (uint256)", + "function isAdmin(address) external view returns (bool)", + "function isMember(address) external view returns (bool)", + "function addAdmin(address) external", + "function addMember(address) external", + "function removeMember(address) external", + "function requestToJoin(string message) external returns (uint256)", + "function approveJoinRequest(address requester) external", + "function rejectJoinRequest(address requester) external", + "function hasPendingRequest(address requester) external view returns (bool)", + "event MemberAdded(address indexed account)", + "event JoinRequested(uint256 indexed requestId, address indexed requester, string message)", + "event JoinApproved(uint256 indexed requestId, address indexed requester)", ]); const meetingComponentsFactoryAbi = parseAbi([ - "function deploy(string _subname, address _orgFactory) external returns ((address meetingFactory, address actionVoting))", - "event MeetingComponentsDeployed(uint256 indexed _orgId, address indexed _meetingFactory, address _actionVoting)", + "function deploy(string _subname, address _orgFactory) external returns ((address meetingFactory, address actionVoting, address roleDataRegistry))", + "event MeetingComponentsDeployed(uint256 indexed _orgId, address indexed _meetingFactory, address _actionVoting, address _roleDataRegistry)", ]); const meetingFactoryAbi = parseAbi([ @@ -86,6 +114,21 @@ const actionVotingAbi = parseAbi([ "event VoteCast(uint256 indexed _voteId, address indexed _voter, uint8 _support, uint256 _weight)", ]); +const governanceProcessAbi = parseAbi([ + "function createProposal(uint256 _orgId, uint256 _circleId, uint256 _proposerRoleId, bytes32 _tensionHash, uint8 _changeType, bytes _changeData) external returns (uint256 _proposalId)", + "function adoptProposal(uint256 _proposalId) external returns (uint256 _resultId)", + "function proposalCount() external view returns (uint256)", + "function proposalMaxAge() external view returns (uint64)", + "function setProposalMaxAge(uint64 _newAge) external", + "event ProposalCreated(uint256 indexed _proposalId, uint256 indexed _orgId, uint256 indexed _circleId, address _proposer, uint256 _proposerRoleId, bytes32 _tensionHash, uint8 _changeType, bytes _changeData)", + "event ProposalAdopted(uint256 indexed _proposalId, uint256 indexed _orgId, uint256 _resultId, address _adoptedBy)", + "event ProposalMaxAgeUpdated(uint64 _oldAge, uint64 _newAge, address indexed _by)", +]); + +const roleRegistryAbi = parseAbi([ + "function getRole(uint256 _roleId) external view returns ((uint256 id, uint256 circleId, string name, string purpose, string[] domains, string[] accountabilities, bool exists, bool isCircle))", +]); + const erc20Abi = parseAbi([ "function balanceOf(address) external view returns (uint256)", "function transfer(address to, uint256 amount) external returns (bool)", @@ -109,6 +152,80 @@ const GOV_CONFIG = { initialAmounts: [1_000_000n * 10n ** 18n], } as const; +type CreatedOrg = { orgId: bigint; instance: Address }; + +async function createOrg( + pub: PublicClient, + wc: WalletClient, + subname: string, + purpose: string, + tokenConfig: typeof GOV_CONFIG = GOV_CONFIG, +): Promise { + const hash = await wc.writeContract({ + address: ADDRESSES.orgFactory, + abi: orgFactoryAbi, + functionName: "createOrganization", + args: [subname, purpose, tokenConfig], + account: wc.account!, + chain: foundry, + }); + const receipt = await pub.waitForTransactionReceipt({ hash }); + for (const log of receipt.logs) { + try { + const decoded = decodeEventLog({ + abi: orgFactoryAbi, + data: log.data, + topics: log.topics, + }); + if (decoded.eventName === "OrganizationCreated") { + return { + orgId: decoded.args._orgId, + instance: decoded.args._instance, + }; + } + } catch { + // not our event + } + } + throw new Error("OrganizationCreated event not found in createOrganization receipt"); +} + +type DeployedMeeting = { meetingFactory: Address; actionVoting: Address }; + +async function deployMeetingComponents( + pub: PublicClient, + wc: WalletClient, + subname: string, +): Promise { + const hash = await wc.writeContract({ + address: ADDRESSES.meetingFactory, + abi: meetingComponentsFactoryAbi, + functionName: "deploy", + args: [subname, ADDRESSES.orgFactory], + account: wc.account!, + chain: foundry, + }); + const receipt = await pub.waitForTransactionReceipt({ hash }); + for (const log of receipt.logs) { + try { + const decoded = decodeEventLog({ + abi: meetingComponentsFactoryAbi, + data: log.data, + topics: log.topics, + }); + if (decoded.eventName === "MeetingComponentsDeployed") { + return { + meetingFactory: decoded.args._meetingFactory, + actionVoting: decoded.args._actionVoting, + }; + } + } catch { + // not our event + } + } + throw new Error("MeetingComponentsDeployed event not found in deploy receipt"); +} + // ── Test setup ────────────────────────────────────────────────────────────── test.beforeAll(() => { @@ -153,49 +270,52 @@ test.describe("Org creation", () => { const pub = publicClient(); const wc = walletClient(FOUNDER); - const hash = await wc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["e2e-org", "E2E test org", GOV_CONFIG], - }); - - const receipt = await pub.waitForTransactionReceipt({ hash }); - expect(receipt.status).toBe("success"); + const { orgId, instance } = await createOrg(pub, wc, "e2e-org", "E2E test org"); const count = await pub.readContract({ address: ADDRESSES.orgFactory, abi: orgFactoryAbi, functionName: "organizationCount", }); - // At least 2 (1 from DeployLocal sample + our new one) + // At least 2 (1 from DeployLocal sample + our new one). expect(count).toBeGreaterThanOrEqual(2n); + expect(orgId).toBe(count); - const org = await pub.readContract({ + // Directory lookup returns the same instance address. + const lookup = await pub.readContract({ address: ADDRESSES.orgFactory, abi: orgFactoryAbi, functionName: "getOrganization", - args: [count], - }); - expect(org.subname).toBe("e2e-org"); - expect(getAddress(org.creator)).toBe(getAddress(FOUNDER.address)); - expect(org.token).not.toBe("0x0000000000000000000000000000000000000000"); - - // Founder is auto-seeded as admin + member - const isAdmin = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "isOrgAdmin", - args: [count, FOUNDER.address], + args: [orgId], }); + expect(getAddress(lookup)).toBe(getAddress(instance)); + + // Instance identity. + const [subname, creator, token] = await Promise.all([ + pub.readContract({ address: instance, abi: orgInstanceAbi, functionName: "subname" }), + pub.readContract({ address: instance, abi: orgInstanceAbi, functionName: "creator" }), + pub.readContract({ address: instance, abi: orgInstanceAbi, functionName: "token" }), + ]); + expect(subname).toBe("e2e-org"); + expect(getAddress(creator)).toBe(getAddress(FOUNDER.address)); + expect(token).not.toBe("0x0000000000000000000000000000000000000000"); + + // Founder is auto-seeded as admin + member. + const [isAdmin, isMember] = await Promise.all([ + pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "isAdmin", + args: [FOUNDER.address], + }), + pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "isMember", + args: [FOUNDER.address], + }), + ]); expect(isAdmin).toBe(true); - - const isMember = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "isOrgMember", - args: [count, FOUNDER.address], - }); expect(isMember).toBe(true); }); }); @@ -203,87 +323,75 @@ test.describe("Org creation", () => { // ── Journey 2: Join request flow ──────────────────────────────────────────── test.describe("Join request flow", () => { - let orgId: bigint; + let instance: Address; let tokenAddress: Address; test.beforeAll(async () => { const pub = publicClient(); const wc = walletClient(FOUNDER); - - const hash = await wc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["join-test", "Join request test", GOV_CONFIG], - }); - await pub.waitForTransactionReceipt({ hash }); - - orgId = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); - - const org = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "getOrganization", - args: [orgId], + ({ instance } = await createOrg(pub, wc, "join-test", "Join request test")); + tokenAddress = await pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "token", }); - tokenAddress = org.token; }); test("Alice requests to join, founder approves", async () => { const pub = publicClient(); - - // Alice requests const aliceWc = walletClient(ALICE); - const reqHash = await aliceWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "requestToJoin", - args: [orgId, "Alice wants to contribute"], + const founderWc = walletClient(FOUNDER); + + const reqReceipt = await pub.waitForTransactionReceipt({ + hash: await aliceWc.writeContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "requestToJoin", + args: ["Alice wants to contribute"], + account: ALICE, + chain: foundry, + }), }); - const reqReceipt = await pub.waitForTransactionReceipt({ hash: reqHash }); expect(reqReceipt.status).toBe("success"); - // Alice has pending request - const pending = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "hasPendingRequest", - args: [ALICE.address, orgId], - }); - expect(pending).toBe(true); + expect( + await pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "hasPendingRequest", + args: [ALICE.address], + }), + ).toBe(true); - // Founder approves - const founderWc = walletClient(FOUNDER); - const approveHash = await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "approveJoinRequest", - args: [orgId, ALICE.address], + const approveReceipt = await pub.waitForTransactionReceipt({ + hash: await founderWc.writeContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "approveJoinRequest", + args: [ALICE.address], + account: FOUNDER, + chain: foundry, + }), }); - const approveReceipt = await pub.waitForTransactionReceipt({ hash: approveHash }); expect(approveReceipt.status).toBe("success"); - // Alice is now a member - const isMember = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "isOrgMember", - args: [orgId, ALICE.address], - }); - expect(isMember).toBe(true); + expect( + await pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "isMember", + args: [ALICE.address], + }), + ).toBe(true); - // Pending cleared - const pendingAfter = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "hasPendingRequest", - args: [ALICE.address, orgId], - }); - expect(pendingAfter).toBe(false); + expect( + await pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "hasPendingRequest", + args: [ALICE.address], + }), + ).toBe(false); }); test("Bob requests to join, founder rejects, Bob re-applies", async () => { @@ -291,42 +399,45 @@ test.describe("Join request flow", () => { const bobWc = walletClient(BOB); const founderWc = walletClient(FOUNDER); - // Bob requests await pub.waitForTransactionReceipt({ hash: await bobWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "requestToJoin", - args: [orgId, "Bob here"], + args: ["Bob here"], + account: BOB, + chain: foundry, }), }); - // Founder rejects await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "rejectJoinRequest", - args: [orgId, BOB.address], + args: [BOB.address], + account: FOUNDER, + chain: foundry, }), }); expect( await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "isOrgMember", - args: [orgId, BOB.address], + address: instance, + abi: orgInstanceAbi, + functionName: "isMember", + args: [BOB.address], }), ).toBe(false); - // Bob can re-apply const reapplyReceipt = await pub.waitForTransactionReceipt({ hash: await bobWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "requestToJoin", - args: [orgId, "Second attempt"], + args: ["Second attempt"], + account: BOB, + chain: foundry, }), }); expect(reapplyReceipt.status).toBe("success"); @@ -336,17 +447,17 @@ test.describe("Join request flow", () => { const pub = publicClient(); const founderWc = walletClient(FOUNDER); - // Approve Bob's second request await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "approveJoinRequest", - args: [orgId, BOB.address], + args: [BOB.address], + account: FOUNDER, + chain: foundry, }), }); - // Transfer 100 tokens (the pattern from approveWithTokens) const tokenAmount = 100n * 10n ** 18n; await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ @@ -354,6 +465,8 @@ test.describe("Join request flow", () => { abi: erc20Abi, functionName: "transfer", args: [BOB.address, tokenAmount], + account: FOUNDER, + chain: foundry, }), }); @@ -371,64 +484,28 @@ test.describe("Join request flow", () => { test.describe("Meeting lifecycle", () => { let orgId: bigint; + let instance: Address; let meetingFactoryAddr: Address; - let actionVotingAddr: Address; test.beforeAll(async () => { const pub = publicClient(); const founderWc = walletClient(FOUNDER); - // Create org - await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["meeting-e2e", "Meeting e2e test", GOV_CONFIG], - }), - }); - orgId = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); - - // Deploy meeting components - const deployHash = await founderWc.writeContract({ - address: ADDRESSES.meetingFactory, - abi: meetingComponentsFactoryAbi, - functionName: "deploy", - args: ["meeting-e2e", ADDRESSES.orgFactory], - }); - const deployReceipt = await pub.waitForTransactionReceipt({ hash: deployHash }); - - // Parse MeetingComponentsDeployed event to get clone addresses - for (const log of deployReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: meetingComponentsFactoryAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "MeetingComponentsDeployed") { - meetingFactoryAddr = decoded.args._meetingFactory; - actionVotingAddr = decoded.args._actionVoting; - } - } catch { - // not our event - } - } - if (!meetingFactoryAddr || !actionVotingAddr) { - throw new Error("MeetingComponentsDeployed event not found in deploy receipt"); - } + ({ orgId, instance } = await createOrg(pub, founderWc, "meeting-e2e", "Meeting e2e test")); + ({ meetingFactory: meetingFactoryAddr } = await deployMeetingComponents( + pub, + founderWc, + "meeting-e2e", + )); - // Add Alice as member await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "addOrgMember", - args: [orgId, ALICE.address], + address: instance, + abi: orgInstanceAbi, + functionName: "addMember", + args: [ALICE.address], + account: FOUNDER, + chain: foundry, }), }); }); @@ -438,36 +515,42 @@ test.describe("Meeting lifecycle", () => { const founderWc = walletClient(FOUNDER); const aliceWc = walletClient(ALICE); - // Start meeting - const startHash = await founderWc.writeContract({ - address: meetingFactoryAddr, - abi: meetingFactoryAbi, - functionName: "startMeeting", - args: [orgId, 0], // Tactical = 0 + const startReceipt = await pub.waitForTransactionReceipt({ + hash: await founderWc.writeContract({ + address: meetingFactoryAddr, + abi: meetingFactoryAbi, + functionName: "startMeeting", + args: [orgId, 0], // Tactical = 0 + account: FOUNDER, + chain: foundry, + }), }); - const startReceipt = await pub.waitForTransactionReceipt({ hash: startHash }); expect(startReceipt.status).toBe("success"); - const meetingId = 1n; // first meeting + const meetingId = 1n; // first meeting of a fresh per-org MeetingFactory clone - // Alice records an output - const outputHash = await aliceWc.writeContract({ - address: meetingFactoryAddr, - abi: meetingFactoryAbi, - functionName: "recordOutput", - args: [meetingId, orgId, 0, "Build landing page", ALICE.address, 0n], // NextAction = 0 + const outputReceipt = await pub.waitForTransactionReceipt({ + hash: await aliceWc.writeContract({ + address: meetingFactoryAddr, + abi: meetingFactoryAbi, + functionName: "recordOutput", + args: [meetingId, orgId, 0, "Build landing page", ALICE.address, 0n], + account: ALICE, + chain: foundry, + }), }); - const outputReceipt = await pub.waitForTransactionReceipt({ hash: outputHash }); expect(outputReceipt.status).toBe("success"); - // End meeting - const endHash = await founderWc.writeContract({ - address: meetingFactoryAddr, - abi: meetingFactoryAbi, - functionName: "endMeeting", - args: [meetingId, orgId, 0], + const endReceipt = await pub.waitForTransactionReceipt({ + hash: await founderWc.writeContract({ + address: meetingFactoryAddr, + abi: meetingFactoryAbi, + functionName: "endMeeting", + args: [meetingId, orgId, 0], + account: FOUNDER, + chain: foundry, + }), }); - const endReceipt = await pub.waitForTransactionReceipt({ hash: endHash }); expect(endReceipt.status).toBe("success"); }); @@ -480,6 +563,8 @@ test.describe("Meeting lifecycle", () => { abi: meetingFactoryAbi, functionName: "startMeeting", args: [orgId, 0], + account: CAROL, + chain: foundry, }), ).rejects.toThrow(); }); @@ -489,84 +574,51 @@ test.describe("Meeting lifecycle", () => { test.describe("Voting", () => { let orgId: bigint; + let instance: Address; let actionVotingAddr: Address; - let meetingFactoryAddr: Address; let tokenAddress: Address; test.beforeAll(async () => { const pub = publicClient(); const founderWc = walletClient(FOUNDER); - // Create org - await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["vote-e2e", "Voting e2e test", GOV_CONFIG], - }), - }); - orgId = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); - const org = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "getOrganization", - args: [orgId], + ({ orgId, instance } = await createOrg(pub, founderWc, "vote-e2e", "Voting e2e test")); + ({ actionVoting: actionVotingAddr } = await deployMeetingComponents( + pub, + founderWc, + "vote-e2e", + )); + tokenAddress = await pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "token", }); - tokenAddress = org.token; - - // Deploy meeting components - const deployHash = await founderWc.writeContract({ - address: ADDRESSES.meetingFactory, - abi: meetingComponentsFactoryAbi, - functionName: "deploy", - args: ["vote-e2e", ADDRESSES.orgFactory], - }); - const deployReceipt = await pub.waitForTransactionReceipt({ hash: deployHash }); - for (const log of deployReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: meetingComponentsFactoryAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "MeetingComponentsDeployed") { - meetingFactoryAddr = decoded.args._meetingFactory; - actionVotingAddr = decoded.args._actionVoting; - } - } catch { - // not our event - } - } - if (!meetingFactoryAddr || !actionVotingAddr) { - throw new Error("MeetingComponentsDeployed event not found in deploy receipt"); - } - // Add Alice as admin+member, Bob as member - for (const fn of ["addOrgMember", "addOrgAdmin"] as const) { + // Add Alice as member+admin, Bob as member. + for (const fn of ["addMember", "addAdmin"] as const) { await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: fn, - args: [orgId, ALICE.address], + args: [ALICE.address], + account: FOUNDER, + chain: foundry, }), }); } await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "addOrgMember", - args: [orgId, BOB.address], + address: instance, + abi: orgInstanceAbi, + functionName: "addMember", + args: [BOB.address], + account: FOUNDER, + chain: foundry, }), }); - // Transfer tokens + delegate + // Transfer tokens + delegate (ERC20Votes requires self-delegation to accrue weight). for (const [account, amount] of [ [ALICE.address, 200_000n * 10n ** 18n], [BOB.address, 100_000n * 10n ** 18n], @@ -577,32 +629,35 @@ test.describe("Voting", () => { abi: erc20Abi, functionName: "transfer", args: [account, amount], + account: FOUNDER, + chain: foundry, }), }); } - // Delegate for (const acct of [FOUNDER, ALICE, BOB]) { - const wc = walletClient(acct); await pub.waitForTransactionReceipt({ - hash: await wc.writeContract({ + hash: await walletClient(acct).writeContract({ address: tokenAddress, abi: erc20Abi, functionName: "delegate", args: [acct.address], + account: acct, + chain: foundry, }), }); } - // Mine a block so snapshots are available - await pub.request({ method: "evm_mine" as never, params: [] }); + // Mine a block so the next createVote's snapshotBlock (= block.number - 1) has weight. + await pub.request({ method: "evm_mine" as never, params: [] as never }); - // Set quorum await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "setCircleQuorum", - args: [orgId, 100_000n * 10n ** 18n], + args: [ANCHOR_CIRCLE_ID, 100_000n * 10n ** 18n], + account: FOUNDER, + chain: foundry, }), }); }); @@ -613,19 +668,20 @@ test.describe("Voting", () => { const aliceWc = walletClient(ALICE); const bobWc = walletClient(BOB); - // Create vote - const createHash = await founderWc.writeContract({ - address: actionVotingAddr, - abi: actionVotingAbi, - functionName: "createVote", - args: [orgId, 1n, "Should we prioritize the MVP?", 86400n * 3n], + const createReceipt = await pub.waitForTransactionReceipt({ + hash: await founderWc.writeContract({ + address: actionVotingAddr, + abi: actionVotingAbi, + functionName: "createVote", + args: [ANCHOR_CIRCLE_ID, 1n, "Should we prioritize the MVP?", 86400n * 3n], + account: FOUNDER, + chain: foundry, + }), }); - const createReceipt = await pub.waitForTransactionReceipt({ hash: createHash }); expect(createReceipt.status).toBe("success"); const voteId = 1n; - // Check weights const aliceWeight = await pub.readContract({ address: actionVotingAddr, abi: actionVotingAbi, @@ -634,27 +690,27 @@ test.describe("Voting", () => { }); expect(aliceWeight).toBe(200_000n * 10n ** 18n); - // Alice votes For await pub.waitForTransactionReceipt({ hash: await aliceWc.writeContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "castVote", - args: [voteId, 1], // For = 1 + args: [voteId, 1], // For + account: ALICE, + chain: foundry, }), }); - - // Bob votes Against await pub.waitForTransactionReceipt({ hash: await bobWc.writeContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "castVote", - args: [voteId, 0], // Against = 0 + args: [voteId, 0], // Against + account: BOB, + chain: foundry, }), }); - // Verify on-chain vote state expect( await pub.readContract({ address: actionVotingAddr, @@ -663,7 +719,6 @@ test.describe("Voting", () => { args: [voteId, ALICE.address], }), ).toBe(true); - expect( await pub.readContract({ address: actionVotingAddr, @@ -672,7 +727,6 @@ test.describe("Voting", () => { args: [voteId, BOB.address], }), ).toBe(true); - expect( await pub.readContract({ address: actionVotingAddr, @@ -682,15 +736,22 @@ test.describe("Voting", () => { }), ).toBe(false); - // Double vote fails + // Double vote fails. await expect( aliceWc.writeContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "castVote", args: [voteId, 1], + account: ALICE, + chain: foundry, }), ).rejects.toThrow(); + + // Silence unused-var lint for orgId — it's carried by the describe scope for parity + // with the previous spec and for any future org-scoped assertions. + expect(orgId).toBeGreaterThan(0n); + expect(instance).toMatch(/^0x[0-9a-fA-F]{40}$/); }); test("collaborator with granted weight can vote", async () => { @@ -698,13 +759,14 @@ test.describe("Voting", () => { const founderWc = walletClient(FOUNDER); const carolWc = walletClient(CAROL); - // Set mint cap and grant Carol collaborator weight await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "setCircleMintCap", - args: [orgId, 500_000n * 10n ** 18n], + args: [ANCHOR_CIRCLE_ID, 500_000n * 10n ** 18n], + account: FOUNDER, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ @@ -712,31 +774,32 @@ test.describe("Voting", () => { address: actionVotingAddr, abi: actionVotingAbi, functionName: "grantCollaboratorWeight", - args: [orgId, CAROL.address, 50_000n * 10n ** 18n], + args: [ANCHOR_CIRCLE_ID, CAROL.address, 50_000n * 10n ** 18n], + account: FOUNDER, + chain: foundry, }), }); - // Verify weight const weight = await pub.readContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "getCollaboratorWeight", - args: [orgId, CAROL.address], + args: [ANCHOR_CIRCLE_ID, CAROL.address], }); expect(weight).toBe(50_000n * 10n ** 18n); - // Create another vote await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: actionVotingAddr, abi: actionVotingAbi, functionName: "createVote", - args: [orgId, 2n, "Community input on roadmap", 86400n], + args: [ANCHOR_CIRCLE_ID, 2n, "Community input on roadmap", 86400n], + account: FOUNDER, + chain: foundry, }), }); const voteId = 2n; - // Carol votes with collaborator weight const carolVoteWeight = await pub.readContract({ address: actionVotingAddr, abi: actionVotingAbi, @@ -750,7 +813,9 @@ test.describe("Voting", () => { address: actionVotingAddr, abi: actionVotingAbi, functionName: "castVote", - args: [voteId, 1], // For + args: [voteId, 1], + account: CAROL, + chain: foundry, }), }); @@ -767,62 +832,58 @@ test.describe("Voting", () => { // ── Journey 5: Data display (sequential fetch + event logs) ───────────────── -const getOrganizationsAbi = parseAbi([ - "function organizationCount() external view returns (uint256)", - "function getOrganizations(uint256 _offset, uint256 _limit) external view returns ((uint256 id, string name, string subname, address creator, address roleRegistry, address circleRegistry, address governanceProcess, address meetingFactory, address accessManager, uint256 anchorCircleId, uint256 createdAt, address governor, address token, address timelock)[])", -]); - test.describe("Data display", () => { test("sequentially fetches all organizations (mimics frontend pattern)", async () => { const pub = publicClient(); const founderWc = walletClient(FOUNDER); - // Create 3 orgs + // Create 3 orgs. for (const name of ["display-alpha", "display-beta", "display-gamma"]) { - await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: [name, `Purpose for ${name}`, GOV_CONFIG], - }), - }); + await createOrg(pub, founderWc, name, `Purpose for ${name}`); } - // Sequential fetch: count → paginated getOrganizations + // Sequential fetch: count → per-id getOrganization → instance.subname/creator. + // The factory no longer exposes a batched getOrganizations(offset,limit); the + // canonical pattern is N cheap directory lookups + per-instance reads. const total = await pub.readContract({ address: ADDRESSES.orgFactory, - abi: getOrganizationsAbi, + abi: orgFactoryAbi, functionName: "organizationCount", }); expect(total).toBeGreaterThanOrEqual(4n); // 1 sample + 3 new - const PAGE_SIZE = 50n; - const allOrgs: { id: bigint; subname: string; creator: `0x${string}` }[] = []; - for (let offset = 0n; offset < total; offset += PAGE_SIZE) { - const page = await pub.readContract({ + const allOrgs: { id: bigint; instance: Address; subname: string; creator: Address }[] = []; + for (let id = 1n; id <= total; id++) { + const instance = await pub.readContract({ address: ADDRESSES.orgFactory, - abi: getOrganizationsAbi, - functionName: "getOrganizations", - args: [offset, PAGE_SIZE], + abi: orgFactoryAbi, + functionName: "getOrganization", + args: [id], }); - for (const org of page) { - if (org.id > 0n) allOrgs.push(org); - } + if (instance === "0x0000000000000000000000000000000000000000") continue; + const [subname, creator] = await Promise.all([ + pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "subname", + }), + pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "creator", + }), + ]); + allOrgs.push({ id, instance, subname, creator }); } expect(allOrgs.length).toBe(Number(total)); - // Verify our 3 orgs are in the list const names = allOrgs.map((o) => o.subname); expect(names).toContain("display-alpha"); expect(names).toContain("display-beta"); expect(names).toContain("display-gamma"); - // All have the founder as creator - const ours = allOrgs.filter( - (o) => names.includes(o.subname) && o.subname.startsWith("display-"), - ); + const ours = allOrgs.filter((o) => o.subname.startsWith("display-")); for (const org of ours) { expect(getAddress(org.creator)).toBe(getAddress(FOUNDER.address)); } @@ -834,59 +895,47 @@ test.describe("Data display", () => { const aliceWc = walletClient(ALICE); const bobWc = walletClient(BOB); - // Create org - const createReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["events-test", "Event log test", GOV_CONFIG], - }), - }); - const orgId = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); - - // Verify OrganizationCreated event in receipt - const orgCreatedLogs = createReceipt.logs.filter( - (l) => l.address.toLowerCase() === ADDRESSES.orgFactory.toLowerCase(), + const { orgId, instance } = await createOrg( + pub, + founderWc, + "events-test", + "Event log test", ); - expect(orgCreatedLogs.length).toBeGreaterThan(0); + expect(orgId).toBeGreaterThan(0n); - // Alice and Bob request to join + // Alice and Bob request to join — events emitted by the instance. await pub.waitForTransactionReceipt({ hash: await aliceWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "requestToJoin", - args: [orgId, "Alice joining"], + args: ["Alice joining"], + account: ALICE, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ hash: await bobWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "requestToJoin", - args: [orgId, "Bob joining"], + args: ["Bob joining"], + account: BOB, + chain: foundry, }), }); - // Use getLogs to find all JoinRequested events for this org const joinLogs = await pub.getLogs({ - address: ADDRESSES.orgFactory, + address: instance, event: { type: "event", name: "JoinRequested", inputs: [ { name: "requestId", type: "uint256", indexed: true }, { name: "requester", type: "address", indexed: true }, - { name: "orgId", type: "uint256", indexed: true }, { name: "message", type: "string", indexed: false }, ], }, - args: { orgId }, fromBlock: 0n, }); expect(joinLogs.length).toBe(2); @@ -895,39 +944,38 @@ test.describe("Data display", () => { expect(joinLogs[0].args.message).toBe("Alice joining"); expect(joinLogs[1].args.message).toBe("Bob joining"); - // Approve Alice, reject Bob + // Approve Alice, reject Bob. await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "approveJoinRequest", - args: [orgId, ALICE.address], + args: [ALICE.address], + account: FOUNDER, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: "rejectJoinRequest", - args: [orgId, BOB.address], + args: [BOB.address], + account: FOUNDER, + chain: foundry, }), }); - // Query OrgMemberAdded logs const memberLogs = await pub.getLogs({ - address: ADDRESSES.orgFactory, + address: instance, event: { type: "event", - name: "OrgMemberAdded", - inputs: [ - { name: "orgId", type: "uint256", indexed: true }, - { name: "account", type: "address", indexed: true }, - ], + name: "MemberAdded", + inputs: [{ name: "account", type: "address", indexed: true }], }, - args: { orgId }, fromBlock: 0n, }); - // Founder (auto-seeded) + Alice (approved) + // Founder (auto-seeded) + Alice (approved). const memberAddresses = memberLogs.map((l) => l.args.account?.toLowerCase()); expect(memberAddresses).toContain(FOUNDER.address.toLowerCase()); expect(memberAddresses).toContain(ALICE.address.toLowerCase()); @@ -940,76 +988,51 @@ test.describe("Data display", () => { const aliceWc = walletClient(ALICE); const bobWc = walletClient(BOB); - // Setup: create org, deploy meeting components, add members - await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["tally-test", "Vote tally test", GOV_CONFIG], - }), - }); - const orgId = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); - const org = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "getOrganization", - args: [orgId], - }); - - // Deploy meeting components - const deployReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.meetingFactory, - abi: meetingComponentsFactoryAbi, - functionName: "deploy", - args: ["tally-test", ADDRESSES.orgFactory], - }), + const { instance } = await createOrg(pub, founderWc, "tally-test", "Vote tally test"); + const { actionVoting: avAddr } = await deployMeetingComponents( + pub, + founderWc, + "tally-test", + ); + const tokenAddr = await pub.readContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "token", }); - let avAddr: Address = "0x"; - for (const log of deployReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: meetingComponentsFactoryAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "MeetingComponentsDeployed") { - avAddr = decoded.args._actionVoting; - } - } catch { - /* not our event */ - } - } - // Add members + delegate - for (const [fn, addr] of [ - ["addOrgMember", ALICE.address], - ["addOrgAdmin", ALICE.address], - ["addOrgMember", BOB.address], - ] as const) { + // Add members. + for (const fn of ["addMember", "addAdmin"] as const) { await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, + address: instance, + abi: orgInstanceAbi, functionName: fn, - args: [orgId, addr], + args: [ALICE.address], + account: FOUNDER, + chain: foundry, }), }); } - - // Transfer tokens + delegate - const tokenAddr = org.token; + await pub.waitForTransactionReceipt({ + hash: await founderWc.writeContract({ + address: instance, + abi: orgInstanceAbi, + functionName: "addMember", + args: [BOB.address], + account: FOUNDER, + chain: foundry, + }), + }); + + // Transfer tokens + self-delegate. await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: tokenAddr, abi: erc20Abi, functionName: "transfer", args: [ALICE.address, 300_000n * 10n ** 18n], + account: FOUNDER, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ @@ -1018,6 +1041,8 @@ test.describe("Data display", () => { abi: erc20Abi, functionName: "transfer", args: [BOB.address, 150_000n * 10n ** 18n], + account: FOUNDER, + chain: foundry, }), }); for (const acct of [FOUNDER, ALICE, BOB]) { @@ -1027,18 +1052,21 @@ test.describe("Data display", () => { abi: erc20Abi, functionName: "delegate", args: [acct.address], + account: acct, + chain: foundry, }), }); } - await pub.request({ method: "evm_mine" as never, params: [] }); + await pub.request({ method: "evm_mine" as never, params: [] as never }); - // Setup quorum + create vote await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: avAddr, abi: actionVotingAbi, functionName: "setCircleQuorum", - args: [orgId, 100_000n * 10n ** 18n], + args: [ANCHOR_CIRCLE_ID, 100_000n * 10n ** 18n], + account: FOUNDER, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ @@ -1046,17 +1074,20 @@ test.describe("Data display", () => { address: avAddr, abi: actionVotingAbi, functionName: "createVote", - args: [orgId, 1n, "Tally test vote", 86400n], + args: [ANCHOR_CIRCLE_ID, 1n, "Tally test vote", 86400n], + account: FOUNDER, + chain: foundry, }), }); - // Cast votes await pub.waitForTransactionReceipt({ hash: await aliceWc.writeContract({ address: avAddr, abi: actionVotingAbi, functionName: "castVote", args: [1n, 1], + account: ALICE, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ @@ -1065,6 +1096,8 @@ test.describe("Data display", () => { abi: actionVotingAbi, functionName: "castVote", args: [1n, 0], + account: BOB, + chain: foundry, }), }); await pub.waitForTransactionReceipt({ @@ -1073,10 +1106,11 @@ test.describe("Data display", () => { abi: actionVotingAbi, functionName: "castVote", args: [1n, 1], + account: FOUNDER, + chain: foundry, }), }); - // Query VoteCast logs and compute tally off-chain (exactly what indexer does) const voteCastLogs = await pub.getLogs({ address: avAddr, event: { @@ -1095,7 +1129,6 @@ test.describe("Data display", () => { expect(voteCastLogs.length).toBe(3); - // Compute tally from events let forVotes = 0n; let againstVotes = 0n; for (const log of voteCastLogs) { @@ -1103,13 +1136,10 @@ test.describe("Data display", () => { else if (log.args._support === 0) againstVotes += log.args._weight!; } - // Alice (300k) + Founder (550k remaining) voted For, Bob (150k) voted Against + // Alice (300k) + Founder voted For, Bob (150k) voted Against. expect(forVotes).toBeGreaterThan(againstVotes); expect(againstVotes).toBe(150_000n * 10n ** 18n); - expect(forVotes).toBe(forVotes); // sanity — just verify it's nonzero - expect(voteCastLogs.length).toBe(3); - // Verify VoteCreated event has reason + snapshotBlock (no on-chain read needed) const voteCreatedLogs = await pub.getLogs({ address: avAddr, event: { @@ -1146,169 +1176,94 @@ test.describe("Multi-org isolation", () => { const founderWc = walletClient(FOUNDER); const aliceWc = walletClient(ALICE); - // Founder creates org1 - await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["iso-org1", "Isolation test 1", GOV_CONFIG], - }), - }); - const org1Id = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); + const { instance: org1 } = await createOrg(pub, founderWc, "iso-org1", "Isolation test 1"); + const { instance: org2 } = await createOrg(pub, aliceWc, "iso-org2", "Isolation test 2"); - // Alice creates org2 - await pub.waitForTransactionReceipt({ - hash: await aliceWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "createOrganization", - args: ["iso-org2", "Isolation test 2", GOV_CONFIG], - }), - }); - const org2Id = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "organizationCount", - }); - - // Founder is admin of org1 but not org2 + // Founder is admin of org1 but not org2. expect( await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "isOrgAdmin", - args: [org1Id, FOUNDER.address], + address: org1, + abi: orgInstanceAbi, + functionName: "isAdmin", + args: [FOUNDER.address], }), ).toBe(true); expect( await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "isOrgAdmin", - args: [org2Id, FOUNDER.address], + address: org2, + abi: orgInstanceAbi, + functionName: "isAdmin", + args: [FOUNDER.address], }), ).toBe(false); - // Founder cannot add members to org2 + // Founder cannot add members to org2. await expect( founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryAbi, - functionName: "addOrgMember", - args: [org2Id, BOB.address], + address: org2, + abi: orgInstanceAbi, + functionName: "addMember", + args: [BOB.address], + account: FOUNDER, + chain: foundry, }), ).rejects.toThrow(); }); }); -// ── Journey 6: Governance proposal lifecycle + ExpandRoleToCircle ──────────── - -const governanceProcessAbi = parseAbi([ - "function createProposal(uint256 _orgId, uint256 _circleId, uint256 _proposerRoleId, bytes32 _tensionHash, uint8 _changeType, bytes _changeData) external returns (uint256 _proposalId)", - "function adoptProposal(uint256 _proposalId) external returns (uint256 _resultId)", - "function getProposal(uint256 _proposalId) external view returns ((uint256 id, uint256 orgId, uint256 circleId, address proposer, uint64 submittedAt, uint64 resolvedAt, uint256 proposerRoleId, bytes32 tensionHash, uint8 changeType, uint8 status, bytes changeData))", - "function proposalCount() external view returns (uint256)", - "event ProposalCreated(uint256 indexed _proposalId, uint256 indexed _orgId, uint256 indexed _circleId, address _proposer, uint256 _proposerRoleId, bytes32 _tensionHash, uint8 _changeType, bytes _changeData)", - "event ProposalAdopted(uint256 indexed _proposalId, uint256 indexed _orgId, uint256 _resultId, address _adoptedBy)", -]); - -const roleRegistryAbi = parseAbi([ - "function getRole(uint256 _roleId) external view returns ((uint256 id, uint256 circleId, string name, string purpose, string[] domains, string[] accountabilities, bool exists, bool isCircle))", -]); - -const orgFactoryWithSubnameAbi = parseAbi([ - "function createOrganization(string _subname, string _purpose, (string tokenName, string tokenSymbol, address[] initialHolders, uint256[] initialAmounts) _tokenConfig) external returns (uint256)", - "function getOrganization(uint256 _orgId) external view returns ((uint256 id, string name, string subname, address creator, address roleRegistry, address circleRegistry, address governanceProcess, address meetingFactory, address accessManager, uint256 anchorCircleId, uint256 createdAt, address token))", - "function organizationCount() external view returns (uint256)", -]); +// ── Journey 7: Governance proposal lifecycle + ExpandRoleToCircle ─────────── test.describe("Governance proposal lifecycle", () => { let orgId: bigint; - let anchorCircleId: bigint; let roleRegistryAddr: Address; let perOrgMeetingFactoryAddr: Address; - const GOV_CONFIG_GOV = { - tokenName: "Gov Token", - tokenSymbol: "GOV", - initialHolders: [FOUNDER.address], - initialAmounts: [1_000_000n * 10n ** 18n], - } as const; - const ORG_SUBNAME = "gov-lifecycle-e2e"; test.beforeAll(async () => { const pub = publicClient(); const founderWc = walletClient(FOUNDER); - // Create org - await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryWithSubnameAbi, - functionName: "createOrganization", - args: [ORG_SUBNAME, "Governance lifecycle test org", GOV_CONFIG_GOV], - }), - }); - - orgId = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryWithSubnameAbi, - functionName: "organizationCount", - }); - - const org = await pub.readContract({ - address: ADDRESSES.orgFactory, - abi: orgFactoryWithSubnameAbi, - functionName: "getOrganization", - args: [orgId], - }); - - roleRegistryAddr = org.roleRegistry; - anchorCircleId = org.anchorCircleId; + const created = await createOrg( + pub, + founderWc, + ORG_SUBNAME, + "Governance lifecycle test org", + ); + orgId = created.orgId; - // Deploy meeting components via the new (subname, orgFactory) API - const deployReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: ADDRESSES.meetingFactory, - abi: meetingComponentsFactoryAbi, - functionName: "deploy", - args: [ORG_SUBNAME, ADDRESSES.orgFactory], + const [roleRegistry, anchorCircleId] = await Promise.all([ + pub.readContract({ + address: created.instance, + abi: orgInstanceAbi, + functionName: "roleRegistry", }), - }); - - // Parse MeetingComponentsDeployed to get the per-org clone address - for (const log of deployReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: meetingComponentsFactoryAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "MeetingComponentsDeployed") { - perOrgMeetingFactoryAddr = decoded.args._meetingFactory; - } - } catch { - // not our event - } - } - - if (!perOrgMeetingFactoryAddr) { - throw new Error("MeetingComponentsDeployed event not found — deploy may have failed"); - } + pub.readContract({ + address: created.instance, + abi: orgInstanceAbi, + functionName: "anchorCircleId", + }), + ]); + roleRegistryAddr = roleRegistry; + // Sanity — every per-org clone seeds its anchor circle at id=1. + expect(anchorCircleId).toBe(ANCHOR_CIRCLE_ID); + + ({ meetingFactory: perOrgMeetingFactoryAddr } = await deployMeetingComponents( + pub, + founderWc, + ORG_SUBNAME, + )); }); - test("creates a CreateRole proposal, adopts it, verifies role on-chain", async () => { - const pub = publicClient(); - const founderWc = walletClient(FOUNDER); - - // Encode CreateRole changeData: abi.encode(circleId, name, purpose, domains[], accountabilities[]) - const { encodeAbiParameters } = await import("viem"); + async function adoptCreateRoleProposal( + pub: PublicClient, + wc: WalletClient, + name: string, + purpose: string, + domains: string[], + accountabilities: string[], + tensionHashByte: string, + ): Promise { const changeData = encodeAbiParameters( [ { type: "uint256" }, @@ -1317,28 +1272,27 @@ test.describe("Governance proposal lifecycle", () => { { type: "string[]" }, { type: "string[]" }, ], - [anchorCircleId, "E2E Engineer", "Build e2e coverage", ["e2e suite"], ["write tests"]], + [ANCHOR_CIRCLE_ID, name, purpose, domains, accountabilities], ); - // createProposal: ChangeType.CreateRole = 0 const createReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ + hash: await wc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "createProposal", args: [ orgId, - anchorCircleId, - 0n, // proposerRoleId — not a role lead - `0x${"aa".repeat(32)}` as `0x${string}`, // tensionHash + ANCHOR_CIRCLE_ID, + ANCHOR_ROLE_ID, // Founder is seeded as lead of the anchor role. + `0x${tensionHashByte.repeat(32)}` as `0x${string}`, 0, // ChangeType.CreateRole changeData, ], + account: wc.account!, + chain: foundry, }), }); - expect(createReceipt.status).toBe("success"); - // Parse ProposalCreated event to get proposalId let proposalId: bigint | undefined; for (const log of createReceipt.logs) { try { @@ -1347,27 +1301,24 @@ test.describe("Governance proposal lifecycle", () => { data: log.data, topics: log.topics, }); - if (decoded.eventName === "ProposalCreated") { - proposalId = decoded.args._proposalId; - } + if (decoded.eventName === "ProposalCreated") proposalId = decoded.args._proposalId; } catch { // skip } } expect(proposalId).toBeDefined(); - // adoptProposal — admin only; returns the new roleId const adoptReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ + hash: await wc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "adoptProposal", args: [proposalId!], + account: wc.account!, + chain: foundry, }), }); - expect(adoptReceipt.status).toBe("success"); - // Parse ProposalAdopted to extract resultId (= the new roleId) let newRoleId: bigint | undefined; for (const log of adoptReceipt.logs) { try { @@ -1376,180 +1327,127 @@ test.describe("Governance proposal lifecycle", () => { data: log.data, topics: log.topics, }); - if (decoded.eventName === "ProposalAdopted") { - newRoleId = decoded.args._resultId; - } + if (decoded.eventName === "ProposalAdopted") newRoleId = decoded.args._resultId; } catch { // skip } } expect(newRoleId).toBeDefined(); - expect(newRoleId).toBeGreaterThan(0n); - - // Verify role exists in RoleRegistry - const role = await pub.readContract({ - address: roleRegistryAddr, - abi: roleRegistryAbi, - functionName: "getRole", - args: [newRoleId!], - }); - - expect(role.exists).toBe(true); - expect(role.name).toBe("E2E Engineer"); - expect(role.purpose).toBe("Build e2e coverage"); - expect([...role.domains]).toEqual(["e2e suite"]); - expect([...role.accountabilities]).toEqual(["write tests"]); - expect(role.isCircle).toBe(false); - - // Store for the ExpandRoleToCircle test — expose via test.info storage - // (Playwright shares describe-scope variables, so we assign to outer let) - (test as unknown as { _e2eRoleId: bigint })._e2eRoleId = newRoleId!; - }); - - test("creates an ExpandRoleToCircle proposal, adopts it, verifies isCircle=true", async () => { - const pub = publicClient(); - const founderWc = walletClient(FOUNDER); - - // First create a role via a CreateRole proposal so we have an independent - // target for this test (does not depend on the previous test's newRoleId). - const { encodeAbiParameters } = await import("viem"); - - const createChangeData = encodeAbiParameters( - [ - { type: "uint256" }, - { type: "string" }, - { type: "string" }, - { type: "string[]" }, - { type: "string[]" }, - ], - [anchorCircleId, "Circle Candidate", "Will become a circle", [], []], - ); - - const createReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ + return newRoleId!; + } + + async function adoptExpandRoleToCircleProposal( + pub: PublicClient, + wc: WalletClient, + roleId: bigint, + tensionHashByte: string, + ): Promise { + const changeData = encodeAbiParameters([{ type: "uint256" }], [roleId]); + const receipt = await pub.waitForTransactionReceipt({ + hash: await wc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "createProposal", args: [ orgId, - anchorCircleId, - 0n, - `0x${"bb".repeat(32)}` as `0x${string}`, - 0, // CreateRole - createChangeData, + ANCHOR_CIRCLE_ID, + ANCHOR_ROLE_ID, + `0x${tensionHashByte.repeat(32)}` as `0x${string}`, + 12, // ChangeType.ExpandRoleToCircle + changeData, ], + account: wc.account!, + chain: foundry, }), }); - expect(createReceipt.status).toBe("success"); - let createProposalId: bigint | undefined; - for (const log of createReceipt.logs) { + let proposalId: bigint | undefined; + for (const log of receipt.logs) { try { const decoded = decodeEventLog({ abi: governanceProcessAbi, data: log.data, topics: log.topics, }); - if (decoded.eventName === "ProposalCreated") { - createProposalId = decoded.args._proposalId; - } + if (decoded.eventName === "ProposalCreated") proposalId = decoded.args._proposalId; } catch { // skip } } + expect(proposalId).toBeDefined(); - const adoptCreateReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ + await pub.waitForTransactionReceipt({ + hash: await wc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "adoptProposal", - args: [createProposalId!], + args: [proposalId!], + account: wc.account!, + chain: foundry, }), }); + } - let targetRoleId: bigint | undefined; - for (const log of adoptCreateReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: governanceProcessAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "ProposalAdopted") { - targetRoleId = decoded.args._resultId; - } - } catch { - // skip - } - } - expect(targetRoleId).toBeDefined(); + test("creates a CreateRole proposal, adopts it, verifies role on-chain", async () => { + const pub = publicClient(); + const founderWc = walletClient(FOUNDER); - // Confirm role is NOT yet a circle - const roleBefore = await pub.readContract({ + const newRoleId = await adoptCreateRoleProposal( + pub, + founderWc, + "E2E Engineer", + "Build e2e coverage", + ["e2e suite"], + ["write tests"], + "aa", + ); + expect(newRoleId).toBeGreaterThan(0n); + + const role = await pub.readContract({ address: roleRegistryAddr, abi: roleRegistryAbi, functionName: "getRole", - args: [targetRoleId!], + args: [newRoleId], }); - expect(roleBefore.isCircle).toBe(false); - // Encode ExpandRoleToCircle changeData: abi.encode(roleId) - const expandChangeData = encodeAbiParameters([{ type: "uint256" }], [targetRoleId!]); + expect(role.exists).toBe(true); + expect(role.name).toBe("E2E Engineer"); + expect(role.purpose).toBe("Build e2e coverage"); + expect([...role.domains]).toEqual(["e2e suite"]); + expect([...role.accountabilities]).toEqual(["write tests"]); + expect(role.isCircle).toBe(false); + }); - // createProposal: ChangeType.ExpandRoleToCircle = 12 - const expandCreateReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: perOrgMeetingFactoryAddr, - abi: governanceProcessAbi, - functionName: "createProposal", - args: [ - orgId, - anchorCircleId, - 0n, - `0x${"cc".repeat(32)}` as `0x${string}`, - 12, // ChangeType.ExpandRoleToCircle - expandChangeData, - ], - }), - }); - expect(expandCreateReceipt.status).toBe("success"); + test("creates an ExpandRoleToCircle proposal, adopts it, verifies isCircle=true", async () => { + const pub = publicClient(); + const founderWc = walletClient(FOUNDER); - let expandProposalId: bigint | undefined; - for (const log of expandCreateReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: governanceProcessAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "ProposalCreated") { - expandProposalId = decoded.args._proposalId; - } - } catch { - // skip - } - } - expect(expandProposalId).toBeDefined(); + const targetRoleId = await adoptCreateRoleProposal( + pub, + founderWc, + "Circle Candidate", + "Will become a circle", + [], + [], + "bb", + ); - // adoptProposal for ExpandRoleToCircle - const adoptExpandReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ - address: perOrgMeetingFactoryAddr, - abi: governanceProcessAbi, - functionName: "adoptProposal", - args: [expandProposalId!], - }), + const roleBefore = await pub.readContract({ + address: roleRegistryAddr, + abi: roleRegistryAbi, + functionName: "getRole", + args: [targetRoleId], }); - expect(adoptExpandReceipt.status).toBe("success"); + expect(roleBefore.isCircle).toBe(false); + + await adoptExpandRoleToCircleProposal(pub, founderWc, targetRoleId, "cc"); - // Verify isCircle is now true const roleAfter = await pub.readContract({ address: roleRegistryAddr, abi: roleRegistryAbi, functionName: "getRole", - args: [targetRoleId!], + args: [targetRoleId], }); - expect(roleAfter.exists).toBe(true); expect(roleAfter.name).toBe("Circle Candidate"); expect(roleAfter.isCircle).toBe(true); @@ -1559,168 +1457,232 @@ test.describe("Governance proposal lifecycle", () => { const pub = publicClient(); const founderWc = walletClient(FOUNDER); - // Create a role and expand it to a circle - const { encodeAbiParameters } = await import("viem"); - - const createChangeData = encodeAbiParameters( - [ - { type: "uint256" }, - { type: "string" }, - { type: "string" }, - { type: "string[]" }, - { type: "string[]" }, - ], - [anchorCircleId, "Already A Circle", "Pre-expand role", [], []], + const roleId = await adoptCreateRoleProposal( + pub, + founderWc, + "Already A Circle", + "Pre-expand role", + [], + [], + "dd", ); - // Create + adopt the role - const createProposalReceipt = await pub.waitForTransactionReceipt({ + await adoptExpandRoleToCircleProposal(pub, founderWc, roleId, "ee"); + + const role = await pub.readContract({ + address: roleRegistryAddr, + abi: roleRegistryAbi, + functionName: "getRole", + args: [roleId], + }); + expect(role.isCircle).toBe(true); + + // Second expand — create succeeds, adopt should revert. + const secondExpandData = encodeAbiParameters([{ type: "uint256" }], [roleId]); + const createReceipt = await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "createProposal", args: [ orgId, - anchorCircleId, - 0n, - `0x${"dd".repeat(32)}` as `0x${string}`, - 0, - createChangeData, + ANCHOR_CIRCLE_ID, + ANCHOR_ROLE_ID, + `0x${"ff".repeat(32)}` as `0x${string}`, + 12, + secondExpandData, ], + account: FOUNDER, + chain: foundry, }), }); - let proposalId: bigint | undefined; - for (const log of createProposalReceipt.logs) { + let secondProposalId: bigint | undefined; + for (const log of createReceipt.logs) { try { const decoded = decodeEventLog({ abi: governanceProcessAbi, data: log.data, topics: log.topics, }); - if (decoded.eventName === "ProposalCreated") proposalId = decoded.args._proposalId; + if (decoded.eventName === "ProposalCreated") + secondProposalId = decoded.args._proposalId; } catch { - /* skip */ + // skip } } + expect(secondProposalId).toBeDefined(); - const adoptRoleReceipt = await pub.waitForTransactionReceipt({ - hash: await founderWc.writeContract({ + await expect( + founderWc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "adoptProposal", - args: [proposalId!], + args: [secondProposalId!], + account: FOUNDER, + chain: foundry, }), - }); + ).rejects.toThrow(); + }); - let roleId: bigint | undefined; - for (const log of adoptRoleReceipt.logs) { - try { - const decoded = decodeEventLog({ - abi: governanceProcessAbi, - data: log.data, - topics: log.topics, - }); - if (decoded.eventName === "ProposalAdopted") roleId = decoded.args._resultId; - } catch { - /* skip */ - } - } - expect(roleId).toBeDefined(); + // §5.3 divergence — creating a proposal with _proposerRoleId == 0 is now + // allowed (attribution is optional). The imposter-claim guard is tested in + // MeetingFactoryProposals.t.sol; here we just exercise the happy path. + test("creates a proposal with _proposerRoleId = 0 (no role claim)", async () => { + const pub = publicClient(); + const founderWc = walletClient(FOUNDER); + + const changeData = encodeAbiParameters( + [ + { type: "uint256" }, + { type: "string" }, + { type: "string" }, + { type: "string[]" }, + { type: "string[]" }, + ], + [ANCHOR_CIRCLE_ID, "Anonymous Role", "Proposed without role claim", [], []], + ); - // First expand — should succeed - const firstExpandData = encodeAbiParameters([{ type: "uint256" }], [roleId!]); - const firstExpandProposalReceipt = await pub.waitForTransactionReceipt({ + const receipt = await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "createProposal", args: [ orgId, - anchorCircleId, - 0n, - `0x${"ee".repeat(32)}` as `0x${string}`, - 12, - firstExpandData, + ANCHOR_CIRCLE_ID, + 0n, // ← proposerRoleId omitted; caller proposes as a member + `0x${"11".repeat(32)}` as `0x${string}`, + 0, // ChangeType.CreateRole + changeData, ], + account: FOUNDER, + chain: foundry, }), }); - let firstExpandProposalId: bigint | undefined; - for (const log of firstExpandProposalReceipt.logs) { + let createdRoleId: bigint | undefined; + let proposerRoleIdEmitted: bigint | undefined; + for (const log of receipt.logs) { try { const decoded = decodeEventLog({ abi: governanceProcessAbi, data: log.data, topics: log.topics, }); - if (decoded.eventName === "ProposalCreated") - firstExpandProposalId = decoded.args._proposalId; + if (decoded.eventName === "ProposalCreated") { + createdRoleId = decoded.args._proposalId; + proposerRoleIdEmitted = decoded.args._proposerRoleId; + } } catch { - /* skip */ + // skip } } + expect(createdRoleId).toBeDefined(); + expect(proposerRoleIdEmitted).toBe(0n); + }); - await pub.waitForTransactionReceipt({ + // Per-org proposalMaxAge: admin tightens the window, expired proposals revert + // on adopt. This is the agent-native-divergence #2 end-to-end smoke test. + test("admin-tightened proposalMaxAge expires proposals as expected", async () => { + const pub = publicClient(); + const founderWc = walletClient(FOUNDER); + + // Default is 7 days; tighten to 2 hours. + const TIGHT_WINDOW_SECONDS = 2n * 60n * 60n; + const setReceipt = await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, - functionName: "adoptProposal", - args: [firstExpandProposalId!], + functionName: "setProposalMaxAge", + args: [TIGHT_WINDOW_SECONDS], + account: FOUNDER, + chain: foundry, }), }); + expect(setReceipt.status).toBe("success"); - // Verify it is now a circle - const role = await pub.readContract({ - address: roleRegistryAddr, - abi: roleRegistryAbi, - functionName: "getRole", - args: [roleId!], + const observedWindow = await pub.readContract({ + address: perOrgMeetingFactoryAddr, + abi: governanceProcessAbi, + functionName: "proposalMaxAge", }); - expect(role.isCircle).toBe(true); + expect(observedWindow).toBe(TIGHT_WINDOW_SECONDS); - // Second expand proposal — adopt should revert - const secondExpandData = encodeAbiParameters([{ type: "uint256" }], [roleId!]); - const secondExpandProposalReceipt = await pub.waitForTransactionReceipt({ + // Create a proposal under the new window. + const changeData = encodeAbiParameters( + [ + { type: "uint256" }, + { type: "string" }, + { type: "string" }, + { type: "string[]" }, + { type: "string[]" }, + ], + [ANCHOR_CIRCLE_ID, "Doomed Role", "Will expire", [], []], + ); + const createReceipt = await pub.waitForTransactionReceipt({ hash: await founderWc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "createProposal", args: [ orgId, - anchorCircleId, - 0n, - `0x${"ff".repeat(32)}` as `0x${string}`, - 12, - secondExpandData, + ANCHOR_CIRCLE_ID, + ANCHOR_ROLE_ID, + `0x${"22".repeat(32)}` as `0x${string}`, + 0, + changeData, ], + account: FOUNDER, + chain: foundry, }), }); - let secondExpandProposalId: bigint | undefined; - for (const log of secondExpandProposalReceipt.logs) { + let proposalId: bigint | undefined; + for (const log of createReceipt.logs) { try { const decoded = decodeEventLog({ abi: governanceProcessAbi, data: log.data, topics: log.topics, }); - if (decoded.eventName === "ProposalCreated") - secondExpandProposalId = decoded.args._proposalId; + if (decoded.eventName === "ProposalCreated") proposalId = decoded.args._proposalId; } catch { - /* skip */ + // skip } } - expect(secondExpandProposalId).toBeDefined(); + expect(proposalId).toBeDefined(); + + // Warp past the window + mine a block so subsequent tx uses new timestamp. + await pub.request({ + method: "evm_increaseTime" as never, + params: [Number(TIGHT_WINDOW_SECONDS + 1n)] as never, + }); + await pub.request({ method: "evm_mine" as never, params: [] as never }); - // adoptProposal should revert because the role is already a circle await expect( founderWc.writeContract({ address: perOrgMeetingFactoryAddr, abi: governanceProcessAbi, functionName: "adoptProposal", - args: [secondExpandProposalId!], + args: [proposalId!], + account: FOUNDER, + chain: foundry, }), ).rejects.toThrow(); + + // Restore the default so other tests in the describe aren't affected. + // (Playwright serializes, but subsequent tests create fresh proposals — + // still, leaving state dirty is a recipe for flakes later.) + await pub.waitForTransactionReceipt({ + hash: await founderWc.writeContract({ + address: perOrgMeetingFactoryAddr, + abi: governanceProcessAbi, + functionName: "setProposalMaxAge", + args: [7n * 24n * 60n * 60n], + account: FOUNDER, + chain: foundry, + }), + }); }); }); diff --git a/apps/hola-modern/package.json b/apps/hola-modern/package.json index 36278e9..9d2bcfc 100644 --- a/apps/hola-modern/package.json +++ b/apps/hola-modern/package.json @@ -19,6 +19,7 @@ "@fullcalendar/react": "^6.1.20", "@fullcalendar/timegrid": "^6.1.20", "@hollab-io/contracts": "workspace:*", + "@hollab-io/hollab-sdk": "workspace:*", "@hollab-io/indexing-client": "workspace:*", "@hollab-io/viem-extension": "workspace:*", "@rainbow-me/rainbowkit": "2.2.10", diff --git a/apps/hola-modern/src/App.tsx b/apps/hola-modern/src/App.tsx index ec98f2b..640a11b 100644 --- a/apps/hola-modern/src/App.tsx +++ b/apps/hola-modern/src/App.tsx @@ -5,8 +5,9 @@ import { useEffect, useMemo, useState } from "react"; import type { AppTabId } from "./config/navigation"; import ChainSwitcher from "./components/ChainSwitcher"; import ThemeToggle from "./components/ThemeToggle"; +import ToastHost from "./components/ToastHost"; import WalletAuthControl from "./components/WalletAuthControl"; -import { useChain } from "./context/ChainContext"; +import WrongNetworkBanner from "./components/WrongNetworkBanner"; import { useTheme } from "./context/ThemeContext"; import { useCirclesFromIndexer } from "./hooks/useCirclesFromIndexer"; import { useGovernanceMeetingsFromIndexer } from "./hooks/useGovernanceMeetingsFromIndexer"; @@ -43,7 +44,6 @@ const NAV = [ ] as const; function App() { - const { chainConfig } = useChain(); const { isDark } = useTheme(); const { route, navigate, setOrgId, setTab } = useHashRouter(); const { @@ -75,7 +75,7 @@ function App() { [routeOrgId, organizations], ); const { members: indexedMembers } = useOrgMembersFromIndexer( - chainConfig.orgFactoryAddress, + activeOrg?.instanceAddress, activeOrg?.id, ); const { circles: indexedCircles } = useCirclesFromIndexer(routeOrgId); @@ -83,6 +83,7 @@ function App() { const { tacticalMeetingAddress, governanceMeetingAddress, + roleDataRegistryAddress, meetings: indexedMeetings, outputs: indexedOutputs, refetch: refetchMeetings, @@ -91,23 +92,9 @@ function App() { const { meetings: indexedGovernanceMeetings, pollForNewMeeting: pollForNewGovernanceMeeting } = useGovernanceMeetingsFromIndexer(governanceMeetingAddress); - // When true, StructureView should auto-open the add-members panel + // When true, StructureView should auto-open the add-members panel. + // Set by fresh org creation so the new org creator lands on "add your first members". const [autoOpenInvite, setAutoOpenInvite] = useState(false); - // Org IDs that have completed (or skipped) member onboarding this session - const [onboardedOrgIds, setOnboardedOrgIds] = useState>(() => new Set()); - - // Skip invite onboarding if the org already has more than 1 member (creator + others) - const isOnboarding = Boolean( - routeOrgId && - !onboardedOrgIds.has(routeOrgId) && - route.page !== "join" && - (activeOrg ? Number(activeOrg.memberCount) <= 1 : true), - ); - const completeOnboarding = () => { - if (routeOrgId) { - setOnboardedOrgIds((prev) => new Set([...prev, routeOrgId])); - } - }; const isGuest = route.page === "join"; const [showGuestJoin, setShowGuestJoin] = useState(false); @@ -133,13 +120,6 @@ function App() { } }, [indexedRoles, syncIndexedRoles]); - // Skip onboarding screen — just mark it complete - useEffect(() => { - if (isOnboarding && activeOrg) { - completeOnboarding(); - } - }, [isOnboarding, activeOrg]); // eslint-disable-line react-hooks/exhaustive-deps - // ── Public (wallet-less) org surface ───────────────────────────────────── // Must render BEFORE the auth gate so incognito / no-wallet visitors work. @@ -230,21 +210,30 @@ function App() { ); } - return navigate({ page: "constitution" })} />; + return ( + navigate({ page: "constitution" })} + onBrowsePublic={() => navigate({ page: "explore" })} + /> + ); } // ── Org list ───────────────────────────────────────────────────────────── if (!routeOrgId) { return ( -
+
); } diff --git a/apps/hola-modern/src/components/ToastHost.tsx b/apps/hola-modern/src/components/ToastHost.tsx new file mode 100644 index 0000000..caced34 --- /dev/null +++ b/apps/hola-modern/src/components/ToastHost.tsx @@ -0,0 +1,39 @@ +import { useEffect, useState } from "react"; + +import type { Toast } from "./toastBus"; +import { subscribeToast } from "./toastBus"; + +const TOAST_DURATION_MS = 2600; + +export default function ToastHost() { + const [toasts, setToasts] = useState([]); + + useEffect(() => { + return subscribeToast((toast) => { + setToasts((current) => [...current, toast]); + window.setTimeout(() => { + setToasts((current) => current.filter((entry) => entry.id !== toast.id)); + }, TOAST_DURATION_MS); + }); + }, []); + + if (toasts.length === 0) { + return null; + } + + return ( +
+ {toasts.map((toast) => ( +
+ {toast.message} +
+ ))} +
+ ); +} diff --git a/apps/hola-modern/src/components/WalletWorkspaceSync.tsx b/apps/hola-modern/src/components/WalletWorkspaceSync.tsx index ffe09b5..9c8cf2d 100644 --- a/apps/hola-modern/src/components/WalletWorkspaceSync.tsx +++ b/apps/hola-modern/src/components/WalletWorkspaceSync.tsx @@ -1,22 +1,12 @@ import { useEffect } from "react"; -import { useAccount, useSwitchChain } from "wagmi"; +import { useAccount } from "wagmi"; -import { useChain } from "../context/ChainContext"; import { useWorkspaceSnapshot } from "../hooks/useWorkspaceSnapshot"; export default function WalletWorkspaceSync() { - const { address, chainId } = useAccount(); - const { switchChain } = useSwitchChain(); - const { activeChainId } = useChain(); + const { address } = useAccount(); const { syncAuthenticatedIdentity } = useWorkspaceSnapshot(); - // Auto-switch chain when wallet is on wrong network. - useEffect(() => { - if (chainId && chainId !== activeChainId) { - switchChain?.({ chainId: activeChainId }); - } - }, [chainId, activeChainId, switchChain]); - useEffect(() => { syncAuthenticatedIdentity({ email: undefined, diff --git a/apps/hola-modern/src/components/WrongNetworkBanner.tsx b/apps/hola-modern/src/components/WrongNetworkBanner.tsx new file mode 100644 index 0000000..5465fed --- /dev/null +++ b/apps/hola-modern/src/components/WrongNetworkBanner.tsx @@ -0,0 +1,50 @@ +import { AlertTriangle, Loader2 } from "lucide-react"; +import { useAccount, useSwitchChain } from "wagmi"; + +import { getChainConfig } from "../config/chains"; +import { useChain } from "../context/ChainContext"; + +export default function WrongNetworkBanner() { + const { address, chainId } = useAccount(); + const { activeChainId, chainConfig } = useChain(); + const { switchChain, isPending } = useSwitchChain(); + + if (!address || !chainId || chainId === activeChainId) return null; + + let connectedLabel = `Chain ${chainId}`; + try { + connectedLabel = getChainConfig(chainId).label; + } catch { + // Unknown chain — leave the numeric fallback. + } + + return ( +
+
+ + + Wallet is on {connectedLabel}. hollab is on {chainConfig.label}. + +
+ +
+ ); +} diff --git a/apps/hola-modern/src/components/toastBus.ts b/apps/hola-modern/src/components/toastBus.ts new file mode 100644 index 0000000..54d14e1 --- /dev/null +++ b/apps/hola-modern/src/components/toastBus.ts @@ -0,0 +1,23 @@ +export type Toast = { + id: number; + message: string; +}; + +export type ToastListener = (toast: Toast) => void; + +const listeners = new Set(); +let nextId = 1; + +export function subscribeToast(listener: ToastListener): () => void { + listeners.add(listener); + return () => { + listeners.delete(listener); + }; +} + +export function showToast(message: string): void { + const toast: Toast = { id: nextId++, message }; + for (const listener of listeners) { + listener(toast); + } +} diff --git a/apps/hola-modern/src/hooks/useEncryptedStorage.ts b/apps/hola-modern/src/hooks/useEncryptedStorage.ts new file mode 100644 index 0000000..4582ddb --- /dev/null +++ b/apps/hola-modern/src/hooks/useEncryptedStorage.ts @@ -0,0 +1,130 @@ +/** + * useEncryptedStorage — encrypt + upload to 0G / fetch + decrypt from 0G. + * + * Composition hook combining: + * - useKeyManager (wallet-backed AES key derivation) + * - useZgStorage (0G blob upload/download) + * - KeyManager (AES encrypt/decrypt) + * + * The upload path serializes EncryptedPayload using a 2-byte nonce-length + * prefix format (matching the hollab-sdk StorageClient wire format). + */ +import type { EncryptedPayload } from "@hollab-io/hollab-sdk"; +import { KeyManager } from "@hollab-io/hollab-sdk"; +import { useMutation } from "@tanstack/react-query"; + +import type { DataVisibilityValue } from "./useContentRef"; +import { DataVisibility } from "./useContentRef"; +import { useKeyManager } from "./useKeyManager"; +import { downloadBytes, uploadBytes } from "./useZgStorage"; + +// ── Serialization (matches hollab-sdk StorageClient wire format) ───────────── + +function serializePayload(p: EncryptedPayload): Uint8Array { + const buf = new Uint8Array(2 + p.nonce.length + p.ciphertext.length); + new DataView(buf.buffer).setUint16(0, p.nonce.length); + buf.set(p.nonce, 2); + buf.set(p.ciphertext, 2 + p.nonce.length); + return buf; +} + +function deserializePayload(buf: Uint8Array): EncryptedPayload { + const nonceLen = new DataView(buf.buffer, buf.byteOffset).getUint16(0); + const nonce = buf.slice(2, 2 + nonceLen); + const ciphertext = buf.slice(2 + nonceLen); + return { nonce, ciphertext }; +} + +// ── Types ──────────────────────────────────────────────────────────────────── + +export type EncryptAndUploadParams = { + text: string; + visibility: DataVisibilityValue; + orgId: bigint; + circleId: bigint; + roleId?: bigint; +}; + +export type EncryptAndUploadResult = { + /** 0G Merkle root hash — stored on-chain as ContentRef.contentHash */ + rootHash: string; +}; + +export type FetchAndDecryptParams = { + /** 0G root hash (from on-chain ContentRef.contentHash) */ + rootHash: string; + visibility: DataVisibilityValue; + orgId: bigint; + circleId: bigint; + roleId?: bigint; +}; + +// ── Hook ───────────────────────────────────────────────────────────────────── + +const km = new KeyManager(); + +export function useEncryptedStorage() { + const { isUnlocked, unlock, getEncryptionKey, lock, error: keyError } = useKeyManager(); + + const encryptAndUpload = useMutation({ + mutationFn: async (params: EncryptAndUploadParams): Promise => { + const textBytes = new TextEncoder().encode(params.text); + + if (params.visibility === DataVisibility.Public) { + const { rootHash } = await uploadBytes(textBytes); + return { rootHash }; + } + + // Encrypted path + const key = getEncryptionKey({ + visibility: params.visibility, + orgId: params.orgId, + circleId: params.circleId, + roleId: params.roleId, + }); + if (!key) { + throw new Error("Expected encryption key for non-public visibility"); + } + + const payload = km.encrypt(key, textBytes); + const serialized = serializePayload(payload); + const { rootHash } = await uploadBytes(serialized); + return { rootHash }; + }, + }); + + async function fetchAndDecrypt(params: FetchAndDecryptParams): Promise { + const bytes = await downloadBytes(params.rootHash); + + if (params.visibility === DataVisibility.Public) { + return new TextDecoder().decode(bytes); + } + + // Encrypted path + const key = getEncryptionKey({ + visibility: params.visibility, + orgId: params.orgId, + circleId: params.circleId, + roleId: params.roleId, + }); + if (!key) { + throw new Error("Expected encryption key for non-public visibility"); + } + + const payload = deserializePayload(bytes); + const plaintext = km.decrypt(key, payload); + return new TextDecoder().decode(plaintext); + } + + return { + encryptAndUpload, + fetchAndDecrypt, + isKeyUnlocked: isUnlocked, + unlockKeys: unlock, + lockKeys: lock, + keyError, + }; +} + +// Re-export for tests +export { serializePayload, deserializePayload }; diff --git a/apps/hola-modern/src/hooks/useExecuteGovernance.ts b/apps/hola-modern/src/hooks/useExecuteGovernance.ts index 0078974..d674eb9 100644 --- a/apps/hola-modern/src/hooks/useExecuteGovernance.ts +++ b/apps/hola-modern/src/hooks/useExecuteGovernance.ts @@ -158,3 +158,42 @@ export function encodeAmendRoleWithRefs(params: { params.refs.map((r) => ({ contentHash: r.contentHash, visibility: r.visibility })), ]); } + +// ── Policy encoding helpers ────────────────────────────────────────────────── + +const policyParamTypes = [ + { type: "uint256" as const }, + { type: "string" as const }, + { type: "string" as const }, +] as const; + +/** Encode a CreatePolicy change: abi.encode(circleId, name, body) */ +export function encodeCreatePolicy(params: { + circleId: bigint; + name: string; + body: string; +}): `0x${string}` { + return encodeAbiParameters(policyParamTypes, [params.circleId, params.name, params.body]); +} + +/** Encode an AmendPolicy change: abi.encode(policyId, name, body) */ +export function encodeAmendPolicy(params: { + policyId: bigint; + name: string; + body: string; +}): `0x${string}` { + return encodeAbiParameters(policyParamTypes, [params.policyId, params.name, params.body]); +} + +/** Encode a RemovePolicy change: abi.encode(policyId) */ +export function encodeRemovePolicy(policyId: bigint): `0x${string}` { + return encodeAbiParameters([{ type: "uint256" }], [policyId]); +} + +/** Encode a MoveRole change: abi.encode(roleId, toCircleId) */ +export function encodeMoveRole(params: { roleId: bigint; toCircleId: bigint }): `0x${string}` { + return encodeAbiParameters( + [{ type: "uint256" }, { type: "uint256" }], + [params.roleId, params.toCircleId], + ); +} diff --git a/apps/hola-modern/src/hooks/useGovernanceMeeting.ts b/apps/hola-modern/src/hooks/useGovernanceMeeting.ts index 729b862..8d7f49a 100644 --- a/apps/hola-modern/src/hooks/useGovernanceMeeting.ts +++ b/apps/hola-modern/src/hooks/useGovernanceMeeting.ts @@ -1,3 +1,14 @@ +/** + * Governance meeting helpers. + * + * `conveneMeeting` / `completeMeeting` / `linkProposal` are **optional + * reporting wrappers** — no governance write path on `MeetingFactory` (create / + * raise / resolve / adopt / discard) requires an open meeting. Orgs may call + * these to publish an auditable "we processed governance at this time" marker, + * or skip them entirely and operate async / continuously. + * + * See specs/99-agent-native-divergence.md §3 for the product framing. + */ import { meetingFactoryAbi } from "@hollab-io/viem-extension"; import { useCallback } from "react"; import { useAccount } from "wagmi"; diff --git a/apps/hola-modern/src/hooks/useJoinRequest.ts b/apps/hola-modern/src/hooks/useJoinRequest.ts index 57d6c6f..1e91d5a 100644 --- a/apps/hola-modern/src/hooks/useJoinRequest.ts +++ b/apps/hola-modern/src/hooks/useJoinRequest.ts @@ -1,16 +1,19 @@ /** - * useJoinRequest — interact with org-level join requests in OrganizationFactory. + * useJoinRequest — interact with org-level join requests on the per-org + * OrganizationInstance clone (post factory-to-instance refactor). * - * Outsiders call requestToJoin(orgId, message). - * Org admins call approveWithTokens(orgId, requester, govToken) - * which batches approveJoinRequest(orgId, requester) + ERC-20 transfer(requester, 100 tokens) - * into a single ZeroDev UserOp (or two sequential EOA txs as fallback). + * Outsiders call instance.requestToJoin(message). + * Org admins call approveWithTokens({ instanceAddress, requester, govToken }) + * which batches instance.approveJoinRequest(requester) + ERC-20 + * transfer(requester, 100 tokens) into a single ZeroDev UserOp (or two + * sequential EOA txs as fallback). * * Read operations (pending requests list) are served by the Ponder indexer. * Only hasPendingRequest is checked on-chain (lightweight single-slot read). */ import type { Abi, Address } from "viem"; import { createIndexingClient } from "@hollab-io/indexing-client"; +import { organizationInstanceAbi } from "@hollab-io/viem-extension"; import { useCallback } from "react"; import { createPublicClient, http, isAddress } from "viem"; import { useAccount } from "wagmi"; @@ -24,77 +27,6 @@ const TOKENS_PER_APPROVAL = 100n * 10n ** 18n; // 100 tokens // ── ABIs ─────────────────────────────────────────────────────────────────────── -export const organizationFactoryJoinAbi = [ - { - type: "function", - name: "requestToJoin", - stateMutability: "nonpayable", - inputs: [ - { name: "orgId", type: "uint256" }, - { name: "message", type: "string" }, - ], - outputs: [{ name: "requestId", type: "uint256" }], - }, - { - type: "function", - name: "approveJoinRequest", - stateMutability: "nonpayable", - inputs: [ - { name: "orgId", type: "uint256" }, - { name: "requester", type: "address" }, - ], - outputs: [], - }, - { - type: "function", - name: "rejectJoinRequest", - stateMutability: "nonpayable", - inputs: [ - { name: "orgId", type: "uint256" }, - { name: "requester", type: "address" }, - ], - outputs: [], - }, - { - type: "function", - name: "hasPendingRequest", - stateMutability: "view", - inputs: [ - { name: "requester", type: "address" }, - { name: "orgId", type: "uint256" }, - ], - outputs: [{ name: "", type: "bool" }], - }, - { - type: "event", - name: "JoinRequested", - inputs: [ - { name: "requestId", type: "uint256", indexed: true }, - { name: "requester", type: "address", indexed: true }, - { name: "orgId", type: "uint256", indexed: true }, - { name: "message", type: "string", indexed: false }, - ], - }, - { - type: "event", - name: "JoinApproved", - inputs: [ - { name: "requestId", type: "uint256", indexed: true }, - { name: "requester", type: "address", indexed: true }, - { name: "orgId", type: "uint256", indexed: true }, - ], - }, - { - type: "event", - name: "JoinRejected", - inputs: [ - { name: "requestId", type: "uint256", indexed: true }, - { name: "requester", type: "address", indexed: true }, - { name: "orgId", type: "uint256", indexed: true }, - ], - }, -] as const satisfies Abi; - const erc20Abi = [ { type: "function", @@ -129,7 +61,6 @@ export function useJoinRequest() { const { send } = useSendTransaction(); const { chainConfig } = useChain(); - const organizationFactoryAddress = chainConfig.orgFactoryAddress; const publicClient = createPublicClient({ chain: chainConfig.chain, transport: http(chainConfig.chain.rpcUrls.default.http[0]), @@ -139,19 +70,19 @@ export function useJoinRequest() { // ── Write ────────────────────────────────────────────────────────────────── const requestToJoin = async (params: { - orgId: bigint; + instanceAddress: Address; message: string; }): Promise<`0x${string}`> => { - if (organizationFactoryAddress === ZERO_ADDRESS) { - throw new Error("OrganizationFactory contract not deployed on this chain yet."); + if (params.instanceAddress === ZERO_ADDRESS) { + throw new Error("Organization instance address missing."); } return send( [ { - to: organizationFactoryAddress, - abi: organizationFactoryJoinAbi as Abi, + to: params.instanceAddress, + abi: organizationInstanceAbi as Abi, functionName: "requestToJoin", - args: [params.orgId, params.message], + args: [params.message], }, ], account(), @@ -163,7 +94,7 @@ export function useJoinRequest() { * With ZeroDev: single UserOp. Without ZeroDev: two sequential EOA txs. */ const approveWithTokens = async (params: { - orgId: bigint; + instanceAddress: Address; requester: Address; govTokenAddress: Address; }): Promise<`0x${string}`> => { @@ -171,10 +102,10 @@ export function useJoinRequest() { return send( [ { - to: organizationFactoryAddress, - abi: organizationFactoryJoinAbi as Abi, + to: params.instanceAddress, + abi: organizationInstanceAbi as Abi, functionName: "approveJoinRequest", - args: [params.orgId, params.requester], + args: [params.requester], }, { to: params.govTokenAddress, @@ -188,16 +119,16 @@ export function useJoinRequest() { }; const rejectRequest = async (params: { - orgId: bigint; + instanceAddress: Address; requester: Address; }): Promise<`0x${string}`> => send( [ { - to: organizationFactoryAddress, - abi: organizationFactoryJoinAbi as Abi, + to: params.instanceAddress, + abi: organizationInstanceAbi as Abi, functionName: "rejectJoinRequest", - args: [params.orgId, params.requester], + args: [params.requester], }, ], account(), @@ -229,17 +160,17 @@ export function useJoinRequest() { const walletAddress = connectedAddress; const hasPendingRequest = useCallback( - async (orgId: bigint): Promise => { + async (instanceAddress: Address): Promise => { if (!walletAddress) return false; - if (organizationFactoryAddress === ZERO_ADDRESS) return false; + if (instanceAddress === ZERO_ADDRESS) return false; return (await publicClient.readContract({ - address: organizationFactoryAddress, - abi: organizationFactoryJoinAbi as Abi, + address: instanceAddress, + abi: organizationInstanceAbi, functionName: "hasPendingRequest", - args: [walletAddress, orgId], + args: [walletAddress], })) as boolean; }, - [walletAddress, organizationFactoryAddress, publicClient], + [walletAddress, publicClient], ); return { diff --git a/apps/hola-modern/src/hooks/useKeyManager.ts b/apps/hola-modern/src/hooks/useKeyManager.ts new file mode 100644 index 0000000..9bb9e5f --- /dev/null +++ b/apps/hola-modern/src/hooks/useKeyManager.ts @@ -0,0 +1,83 @@ +/** + * useKeyManager — wallet-backed encryption key derivation. + * + * Bridges the hollab-sdk KeyManager (which takes a viem WalletClient) with + * wagmi's useWalletClient. Caches the derived master key in a ref so the + * wallet signature prompt fires only once per session. + */ +import { KeyManager } from "@hollab-io/hollab-sdk"; +import { useCallback, useState } from "react"; +import { useWalletClient } from "wagmi"; + +import type { DataVisibilityValue } from "./useContentRef"; +import { DataVisibility } from "./useContentRef"; + +const km = new KeyManager(); + +// Module-level key cache — survives re-renders without useRef (avoids +// the "cannot access refs during render" lint rule). +let cachedMasterKey: Uint8Array | null = null; + +export type GetEncryptionKeyParams = { + visibility: DataVisibilityValue; + orgId: bigint; + circleId: bigint; + roleId?: bigint; +}; + +export function useKeyManager() { + const { data: walletClient } = useWalletClient(); + const [unlocked, setUnlocked] = useState(!!cachedMasterKey); + const [error, setError] = useState(null); + + // Derive isUnlocked: cached key exists AND wallet is still connected + const isUnlocked = unlocked && !!walletClient; + + const unlock = useCallback( + async (orgId: bigint) => { + if (cachedMasterKey) return; + if (!walletClient) { + throw new Error("Connect a wallet before unlocking encryption keys"); + } + setError(null); + try { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + cachedMasterKey = await km.deriveMasterKey(walletClient as any, orgId); + setUnlocked(true); + } catch (err) { + const msg = err instanceof Error ? err.message : String(err); + setError(msg); + throw err; + } + }, + [walletClient], + ); + + const lock = useCallback(() => { + cachedMasterKey = null; + setUnlocked(false); + setError(null); + }, []); + + const getEncryptionKey = useCallback((params: GetEncryptionKeyParams): Uint8Array | null => { + if (params.visibility === DataVisibility.Public) return null; + + if (!cachedMasterKey) { + throw new Error("Encryption keys not unlocked. Call unlock() first."); + } + + const orgKey = km.deriveOrgKey(cachedMasterKey, params.orgId); + + if (params.visibility === DataVisibility.OrgEncrypted) { + return orgKey; + } + + if (params.roleId === undefined) { + throw new Error("roleId is required for RoleEncrypted visibility"); + } + const circleKey = km.deriveCircleKey(orgKey, params.circleId); + return km.deriveRoleKey(circleKey, params.roleId); + }, []); + + return { isUnlocked, unlock, getEncryptionKey, lock, error }; +} diff --git a/apps/hola-modern/src/hooks/useMeetingComponentsFactory.ts b/apps/hola-modern/src/hooks/useMeetingComponentsFactory.ts index 1d26cfe..56b78d6 100644 --- a/apps/hola-modern/src/hooks/useMeetingComponentsFactory.ts +++ b/apps/hola-modern/src/hooks/useMeetingComponentsFactory.ts @@ -16,6 +16,7 @@ export type DeployMeetingComponentsResult = { txHash: `0x${string}`; meetingFactory: `0x${string}`; actionVoting: `0x${string}`; + roleDataRegistry: `0x${string}`; }; export function useDeployMeetingComponents() { @@ -62,6 +63,7 @@ export function useDeployMeetingComponents() { // 3. Parse MeetingComponentsDeployed event let meetingFactory: `0x${string}` | null = null; let actionVoting: `0x${string}` | null = null; + let roleDataRegistry: `0x${string}` | null = null; for (const log of receipt.logs) { try { @@ -75,9 +77,11 @@ export function useDeployMeetingComponents() { _orgId: bigint; _meetingFactory: `0x${string}`; _actionVoting: `0x${string}`; + _roleDataRegistry: `0x${string}`; }; meetingFactory = args._meetingFactory; actionVoting = args._actionVoting; + roleDataRegistry = args._roleDataRegistry; break; } } catch { @@ -85,16 +89,16 @@ export function useDeployMeetingComponents() { } } - if (!meetingFactory || !actionVoting) { + if (!meetingFactory || !actionVoting || !roleDataRegistry) { throw new Error( "Meeting components deployed but could not find MeetingComponentsDeployed event", ); } - return { txHash, meetingFactory, actionVoting }; + return { txHash, meetingFactory, actionVoting, roleDataRegistry }; }, - onSuccess: ({ meetingFactory, actionVoting }, params) => { + onSuccess: ({ meetingFactory, actionVoting, roleDataRegistry }, params) => { const orgId = params.orgId; // Optimistically inject the component set into the tactical meetings cache @@ -104,6 +108,7 @@ export function useDeployMeetingComponents() { orgId, meetingFactory, actionVoting, + roleDataRegistry, deployedAt: Math.floor(Date.now() / 1000).toString(), txHash: "0x", }; diff --git a/apps/hola-modern/src/hooks/useOkrObjectives.ts b/apps/hola-modern/src/hooks/useOkrObjectives.ts new file mode 100644 index 0000000..ac93ad4 --- /dev/null +++ b/apps/hola-modern/src/hooks/useOkrObjectives.ts @@ -0,0 +1,86 @@ +/** + * useOkrObjectives — reads the aggregate OKR blob for a (role, quarter) pair. + * + * Flow: read contentRef on-chain for fieldName = keccak256("okr:{quarter}") → + * download 0G blob by rootHash → decrypt with the role key → + * parse JSON into OkrObjective[]. + * + * Writes go through governance via useCreateOkrObjective (AmendRoleWithRefs + * proposal), not directly — OKRs are a constitutional commitment. + */ +import type { OkrObjective } from "@hollab-io/hollab-sdk"; +import type { Address } from "viem"; +import { useQuery } from "@tanstack/react-query"; + +import type { DataVisibilityValue } from "./useContentRef"; +import { DataVisibility, fieldNameHash, useReadContentRef } from "./useContentRef"; +import { useEncryptedStorage } from "./useEncryptedStorage"; + +const ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000" as const; + +export function okrFieldName(quarter: string): string { + return `okr:${quarter}`; +} + +export function okrFieldNameHash(quarter: string): `0x${string}` { + return fieldNameHash(okrFieldName(quarter)); +} + +export function useOkrObjectives(params: { + roleRegistryAddress: Address | undefined; + orgId: bigint | undefined; + circleId: bigint | undefined; + roleId: bigint | undefined; + quarter: string; +}) { + const { roleRegistryAddress, orgId, circleId, roleId, quarter } = params; + const { fetchAndDecrypt } = useEncryptedStorage(); + + const { data: contentRef, isLoading: refLoading } = useReadContentRef( + roleRegistryAddress, + roleId, + okrFieldName(quarter), + ); + + return useQuery({ + queryKey: [ + "okrs", + roleRegistryAddress, + roleId?.toString(), + quarter, + contentRef?.contentHash, + ], + queryFn: async () => { + if ( + !contentRef || + contentRef.contentHash === ZERO_HASH || + orgId === undefined || + circleId === undefined || + roleId === undefined + ) { + return []; + } + const visibility = contentRef.visibility as DataVisibilityValue; + const text = await fetchAndDecrypt({ + rootHash: contentRef.contentHash, + visibility: visibility ?? DataVisibility.Public, + orgId, + circleId, + roleId, + }); + try { + return JSON.parse(text) as OkrObjective[]; + } catch { + return []; + } + }, + enabled: + Boolean(roleRegistryAddress) && + orgId !== undefined && + circleId !== undefined && + roleId !== undefined && + !refLoading && + Boolean(contentRef) && + contentRef?.contentHash !== ZERO_HASH, + }); +} diff --git a/apps/hola-modern/src/hooks/useOrgMemberActions.ts b/apps/hola-modern/src/hooks/useOrgMemberActions.ts index fcdc21a..b00ee97 100644 --- a/apps/hola-modern/src/hooks/useOrgMemberActions.ts +++ b/apps/hola-modern/src/hooks/useOrgMemberActions.ts @@ -1,26 +1,25 @@ -import { organizationFactoryAbi } from "@hollab-io/viem-extension"; +import { organizationInstanceAbi } from "@hollab-io/viem-extension"; import { useAccount } from "wagmi"; import { useSendTransaction } from "./useSendTransaction"; -/** Add members via OrganizationFactory.addOrgMember (org admin only). */ +/** Add members via OrganizationInstance.addMember (org admin only). */ export function useOrgMemberActions() { const { address } = useAccount(); const { send } = useSendTransaction(); const addOrgMembers = async (params: { - orgFactoryAddress: `0x${string}`; - orgId: bigint; + instanceAddress: `0x${string}`; memberAddresses: `0x${string}`[]; walletAddress: `0x${string}`; }): Promise<`0x${string}`> => { const account = (address ?? params.walletAddress) as `0x${string}`; const calls = params.memberAddresses.map((member) => ({ - to: params.orgFactoryAddress, + to: params.instanceAddress, // eslint-disable-next-line @typescript-eslint/no-explicit-any - abi: organizationFactoryAbi as any, - functionName: "addOrgMember" as const, - args: [params.orgId, member] as const, + abi: organizationInstanceAbi as any, + functionName: "addMember" as const, + args: [member] as const, })); return send(calls, account); }; diff --git a/apps/hola-modern/src/hooks/useOrgMembersFromIndexer.ts b/apps/hola-modern/src/hooks/useOrgMembersFromIndexer.ts index dce4930..98af9d2 100644 --- a/apps/hola-modern/src/hooks/useOrgMembersFromIndexer.ts +++ b/apps/hola-modern/src/hooks/useOrgMembersFromIndexer.ts @@ -7,30 +7,31 @@ import { getIndexingClient } from "./useOrganizationsFromIndexer"; export type { OrgMember }; /** - * Fetches on-chain org members from the indexer (OrganizationFactory + orgId scope). + * Fetches on-chain org members from the indexer scoped to the per-org + * OrganizationInstance clone (the authoritative membership registry). */ export function useOrgMembersFromIndexer( - orgFactoryAddress: string | undefined, + instanceAddress: string | undefined, orgId: string | undefined, ) { const queryClient = useQueryClient(); const { data: members = [], isLoading: loading } = useQuery({ - queryKey: ["orgMembers", orgFactoryAddress, orgId], + queryKey: ["orgMembers", instanceAddress, orgId], queryFn: async () => { const client = getIndexingClient(); - if (!client || !orgFactoryAddress || !orgId) return []; - const result = await client.listOrgMembersByOrg(orgFactoryAddress, orgId); + if (!client || !instanceAddress || !orgId) return []; + const result = await client.listOrgMembersByOrg(instanceAddress, orgId); return result.items; }, - enabled: Boolean(orgFactoryAddress && orgId), + enabled: Boolean(instanceAddress && orgId), }); const refetch = useCallback(() => { return queryClient.invalidateQueries({ - queryKey: ["orgMembers", orgFactoryAddress, orgId], + queryKey: ["orgMembers", instanceAddress, orgId], }); - }, [queryClient, orgFactoryAddress, orgId]); + }, [queryClient, instanceAddress, orgId]); return { members, loading, refetch }; } diff --git a/apps/hola-modern/src/hooks/useOrgOkrs.ts b/apps/hola-modern/src/hooks/useOrgOkrs.ts new file mode 100644 index 0000000..69baedd --- /dev/null +++ b/apps/hola-modern/src/hooks/useOrgOkrs.ts @@ -0,0 +1,73 @@ +/** + * useOrgOkrs — aggregate all OKR objectives for an org in a given quarter. + * + * Queries the indexer for every content ref across the org's RoleRegistry + * matching fieldName = keccak256("okr:{quarter}"), then fetches + decrypts + * each 0G blob to produce a flat list of `OkrObjective` with their owning role. + */ +import type { OkrObjective } from "@hollab-io/hollab-sdk"; +import type { ContentRef } from "@hollab-io/indexing-client"; +import type { Address } from "viem"; +import { useQuery } from "@tanstack/react-query"; + +import type { DataVisibilityValue } from "./useContentRef"; +import { DataVisibility } from "./useContentRef"; +import { useEncryptedStorage } from "./useEncryptedStorage"; +import { okrFieldNameHash } from "./useOkrObjectives"; +import { getIndexingClient } from "./useOrganizationsFromIndexer"; + +export type OkrsByRole = { + roleId: bigint; + objectives: OkrObjective[]; +}; + +export function useOrgOkrs(params: { + roleRegistryAddress: Address | undefined; + orgId: bigint | undefined; + circleId: bigint | undefined; + quarter: string; +}) { + const { roleRegistryAddress, orgId, circleId, quarter } = params; + const { fetchAndDecrypt } = useEncryptedStorage(); + + return useQuery({ + queryKey: ["orgOkrs", roleRegistryAddress, quarter], + queryFn: async () => { + const client = getIndexingClient(); + if (!client || !roleRegistryAddress || orgId === undefined) return []; + + const fieldHash = okrFieldNameHash(quarter); + const refs: ContentRef[] = ( + await client.listContentRefsByField(roleRegistryAddress, fieldHash) + ).items; + + const results = await Promise.all( + refs.map(async (ref): Promise => { + const visibility = ref.visibility as DataVisibilityValue; + try { + const text = await fetchAndDecrypt({ + rootHash: ref.contentHash, + visibility: visibility ?? DataVisibility.Public, + orgId, + circleId: circleId ?? BigInt(0), + roleId: BigInt(ref.entityId), + }); + const objectives = JSON.parse(text) as OkrObjective[]; + return { roleId: BigInt(ref.entityId), objectives }; + } catch { + return null; + } + }), + ); + + return results.filter((r): r is OkrsByRole => r !== null); + }, + enabled: Boolean(roleRegistryAddress) && orgId !== undefined, + }); +} + +/** "Q{1..4}-YYYY" for any Date. */ +export function quarterFromDate(d: Date): string { + const q = Math.floor(d.getMonth() / 3) + 1; + return `Q${q}-${d.getFullYear()}`; +} diff --git a/apps/hola-modern/src/hooks/useOrganizationFactory.ts b/apps/hola-modern/src/hooks/useOrganizationFactory.ts index 6ba30f7..5033fc6 100644 --- a/apps/hola-modern/src/hooks/useOrganizationFactory.ts +++ b/apps/hola-modern/src/hooks/useOrganizationFactory.ts @@ -1,6 +1,6 @@ import type { MeetingComponentSet, Organization } from "@hollab-io/indexing-client"; import { meetingComponentsFactoryAbi } from "@hollab-io/contracts/actions"; -import { organizationFactoryAbi } from "@hollab-io/viem-extension"; +import { organizationFactoryAbi, organizationInstanceAbi } from "@hollab-io/viem-extension"; import { useMutation, useQueryClient } from "@tanstack/react-query"; import { createPublicClient, decodeEventLog, http } from "viem"; import { useAccount } from "wagmi"; @@ -8,13 +8,22 @@ import { useAccount } from "wagmi"; import { useChain } from "../context/ChainContext"; import { useSendTransaction } from "./useSendTransaction"; -function deriveSubname(orgName: string): string { +export function deriveSubname(orgName: string): string { return orgName .trim() .toLowerCase() .replace(/[^a-z0-9]+/g, "-") .replace(/^-+|-+$/g, "") - .slice(0, 48); + .slice(0, 32); +} + +/** + * Checks whether a subname matches the on-chain ENS constraints: + * 3–32 chars, lowercase alphanumerics and dashes, no leading/trailing dash. + * The 32-char upper bound tracks the contract audit's [I-3] finding. + */ +export function isValidSubname(subname: string): boolean { + return /^[a-z0-9](?:[a-z0-9-]{1,30}[a-z0-9])?$/.test(subname); } function deriveTokenSymbol(orgName: string): string { @@ -28,35 +37,6 @@ function deriveTokenSymbol(orgName: string): string { return symbol || "ORG"; } -const orgReadAbi = [ - { - type: "function", - name: "getOrganization", - stateMutability: "view", - inputs: [{ name: "_orgId", type: "uint256" }], - outputs: [ - { - name: "_org", - type: "tuple", - components: [ - { name: "id", type: "uint256" }, - { name: "name", type: "string" }, - { name: "subname", type: "string" }, - { name: "creator", type: "address" }, - { name: "roleRegistry", type: "address" }, - { name: "circleRegistry", type: "address" }, - { name: "governanceProcess", type: "address" }, - { name: "meetingFactory", type: "address" }, - { name: "accessManager", type: "address" }, - { name: "anchorCircleId", type: "uint256" }, - { name: "createdAt", type: "uint256" }, - { name: "token", type: "address" }, - ], - }, - ], - }, -] as const; - const erc20MetaAbi = [ { type: "function", @@ -85,14 +65,19 @@ export type DeployParams = { name: string; purpose: string; walletAddress: `0x${string}`; + /** Optional override — if omitted, derived from name. */ + subname?: string; }; export type DeployResult = { txHash: `0x${string}`; organization: Organization; + /** OrganizationInstance clone address. Duplicated on `organization.instanceAddress`. */ + instanceAddress: `0x${string}`; meetingComponents: { meetingFactory: `0x${string}`; actionVoting: `0x${string}`; + roleDataRegistry: `0x${string}`; } | null; batched: boolean; }; @@ -105,10 +90,10 @@ export function useDeployOrganization() { return useMutation({ mutationFn: async (params) => { - const subname = deriveSubname(params.name); - if (subname.length < 3) { + const subname = params.subname ?? deriveSubname(params.name); + if (!isValidSubname(subname)) { throw new Error( - "Organization name too short — needs at least 3 alphanumeric characters.", + "Invalid subname — use 3–32 lowercase letters, digits, or dashes (no leading/trailing dash).", ); } @@ -160,8 +145,10 @@ export function useDeployOrganization() { }); let orgId: bigint | null = null; + let instanceAddress: `0x${string}` | null = null; let meetingFactoryOut: `0x${string}` | null = null; let actionVotingOut: `0x${string}` | null = null; + let roleDataRegistryOut: `0x${string}` | null = null; for (const receipt of receipts) { for (const log of receipt.logs) { @@ -173,7 +160,12 @@ export function useDeployOrganization() { topics: log.topics, }); if (decoded.eventName === "OrganizationCreated") { - orgId = (decoded.args as { _orgId: bigint })._orgId; + const a = decoded.args as { + _orgId: bigint; + _instance: `0x${string}`; + }; + orgId = a._orgId; + instanceAddress = a._instance; continue; } } catch { @@ -190,9 +182,11 @@ export function useDeployOrganization() { const args = decoded.args as { _meetingFactory: `0x${string}`; _actionVoting: `0x${string}`; + _roleDataRegistry: `0x${string}`; }; meetingFactoryOut = args._meetingFactory; actionVotingOut = args._actionVoting; + roleDataRegistryOut = args._roleDataRegistry; } } catch { // not a meeting components event @@ -200,7 +194,7 @@ export function useDeployOrganization() { } } - if (orgId === null) { + if (orgId === null || instanceAddress === null) { throw new Error( "Organization created but could not find OrganizationCreated event", ); @@ -208,12 +202,13 @@ export function useDeployOrganization() { const txHash = receipts[0]?.transactionHash ?? ("0x" as `0x${string}`); - // 4. Read org struct + token metadata from chain + // 4. Read org struct + token metadata from the OrganizationInstance. + // `summary()` is the authoritative source of org metadata post-refactor — + // the factory no longer holds anything beyond the id → instance index. const orgData = await publicClient.readContract({ - address: chainConfig.orgFactoryAddress, - abi: orgReadAbi, - functionName: "getOrganization", - args: [orgId], + address: instanceAddress, + abi: organizationInstanceAbi, + functionName: "summary", }); let tokenName = ""; @@ -251,6 +246,7 @@ export function useDeployOrganization() { name: orgData.name, creator: orgData.creator, token: orgData.token, + instanceAddress, circleRegistry: orgData.circleRegistry, roleRegistry: orgData.roleRegistry, governanceProcess: orgData.governanceProcess, @@ -267,11 +263,15 @@ export function useDeployOrganization() { }; const meetingComponents = - meetingFactoryOut && actionVotingOut - ? { meetingFactory: meetingFactoryOut, actionVoting: actionVotingOut } + meetingFactoryOut && actionVotingOut && roleDataRegistryOut + ? { + meetingFactory: meetingFactoryOut, + actionVoting: actionVotingOut, + roleDataRegistry: roleDataRegistryOut, + } : null; - return { txHash, organization, meetingComponents, batched }; + return { txHash, organization, instanceAddress, meetingComponents, batched }; }, onSuccess: ({ organization, meetingComponents }) => { @@ -290,6 +290,7 @@ export function useDeployOrganization() { orgId: organization.id, meetingFactory: meetingComponents.meetingFactory, actionVoting: meetingComponents.actionVoting, + roleDataRegistry: meetingComponents.roleDataRegistry, deployedAt: Math.floor(Date.now() / 1000).toString(), txHash: "0x", }; diff --git a/apps/hola-modern/src/hooks/useOrganizationsFromIndexer.ts b/apps/hola-modern/src/hooks/useOrganizationsFromIndexer.ts index 8c0b421..9b715e5 100644 --- a/apps/hola-modern/src/hooks/useOrganizationsFromIndexer.ts +++ b/apps/hola-modern/src/hooks/useOrganizationsFromIndexer.ts @@ -1,5 +1,6 @@ import type { Organization } from "@hollab-io/indexing-client"; import { createIndexingClient } from "@hollab-io/indexing-client"; +import { organizationFactoryAbi, organizationInstanceAbi } from "@hollab-io/viem-extension"; import { useQuery, useQueryClient } from "@tanstack/react-query"; import { useCallback } from "react"; import { createPublicClient, http } from "viem"; @@ -9,7 +10,6 @@ import { useChain } from "../context/ChainContext"; export type { Organization }; -const PAGE_SIZE = 50n; const clientCache = new Map>(); function getOrCreateClient(chainId: number) { @@ -21,67 +21,33 @@ function getOrCreateClient(chainId: number) { clientCache.set(chainId, client); return client; } -const organizationReadAbi = [ - { - type: "function", - name: "organizationCount", - stateMutability: "view", - inputs: [], - outputs: [{ name: "_count", type: "uint256" }], - }, - { - type: "function", - name: "getOrganizations", - stateMutability: "view", - inputs: [ - { name: "_offset", type: "uint256" }, - { name: "_limit", type: "uint256" }, - ], - outputs: [ - { - name: "_orgs", - type: "tuple[]", - components: [ - { name: "id", type: "uint256" }, - { name: "name", type: "string" }, - { name: "subname", type: "string" }, - { name: "creator", type: "address" }, - { name: "roleRegistry", type: "address" }, - { name: "circleRegistry", type: "address" }, - { name: "governanceProcess", type: "address" }, - { name: "meetingFactory", type: "address" }, - { name: "accessManager", type: "address" }, - { name: "anchorCircleId", type: "uint256" }, - { name: "createdAt", type: "uint256" }, - { name: "token", type: "address" }, - ], - }, - ], + +function mapSummary( + instanceAddress: `0x${string}`, + summary: { + id: bigint; + name: string; + subname: string; + creator: `0x${string}`; + roleRegistry: `0x${string}`; + circleRegistry: `0x${string}`; + governanceProcess: `0x${string}`; + anchorCircleId: bigint; + token: `0x${string}`; + createdAt: bigint; }, -] as const; - -function mapOrg(org: { - id: bigint; - name: string; - subname: string; - creator: `0x${string}`; - roleRegistry: `0x${string}`; - circleRegistry: `0x${string}`; - governanceProcess: `0x${string}`; - anchorCircleId: bigint; - token: `0x${string}`; - createdAt: bigint; -}): Organization { +): Organization { return { - id: org.id.toString(), - subname: org.subname, - name: org.name, - creator: org.creator, - token: org.token, - circleRegistry: org.circleRegistry, - roleRegistry: org.roleRegistry, - governanceProcess: org.governanceProcess, - anchorCircleId: org.anchorCircleId.toString(), + id: summary.id.toString(), + subname: summary.subname, + name: summary.name, + creator: summary.creator, + token: summary.token, + instanceAddress, + circleRegistry: summary.circleRegistry, + roleRegistry: summary.roleRegistry, + governanceProcess: summary.governanceProcess, + anchorCircleId: summary.anchorCircleId.toString(), tokenName: "", tokenSymbol: "", tokenTotalSupply: "0", @@ -89,11 +55,15 @@ function mapOrg(org: { roleCount: "0", memberCount: "0", purpose: "", - createdAt: org.createdAt.toString(), - updatedAt: org.createdAt.toString(), + createdAt: summary.createdAt.toString(), + updatedAt: summary.createdAt.toString(), }; } +// Fallback when the indexer is unavailable: walk the factory's id → instance +// directory and read summary() off each clone. Post-refactor the factory no +// longer has a bulk getOrganizations view, so this is N+1 — acceptable for +// a failure-mode path the UI rarely hits. async function listOrganizationsOnchain(chainId: number): Promise { const chainConfig = getChainConfig(chainId); const rpcUrl = chainConfig.chain.rpcUrls.default.http[0]; @@ -104,24 +74,28 @@ async function listOrganizationsOnchain(chainId: number): Promise[0][]; - for (const org of orgs) { - if (org.id === 0n) continue; - items.push(mapOrg(org)); - } + abi: organizationFactoryAbi, + functionName: "getOrganization", + args: [id], + })) as `0x${string}`; + if (instanceAddress === "0x0000000000000000000000000000000000000000") continue; + + const summary = await publicClient.readContract({ + address: instanceAddress, + abi: organizationInstanceAbi, + functionName: "summary", + }); + items.push(mapSummary(instanceAddress, summary)); } // Newest first to preserve current UX assumptions. diff --git a/apps/hola-modern/src/hooks/useProposalLifecycle.ts b/apps/hola-modern/src/hooks/useProposalLifecycle.ts new file mode 100644 index 0000000..52f1bb8 --- /dev/null +++ b/apps/hola-modern/src/hooks/useProposalLifecycle.ts @@ -0,0 +1,309 @@ +/** + * Write-side mutations for the on-chain proposal + objection lifecycle + * shipped on 2026-04-15 (MeetingFactory v2). Pairs with the read hooks + * in useProposalsFromIndexer — each mutation invalidates the cached + * queries so the UI reflects the new state after the tx is indexed. + * + * Contract boundary: MeetingFactory (the per-org governance process). + */ +import { meetingFactoryAbi } from "@hollab-io/viem-extension"; +import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"; +import { createPublicClient, http, keccak256, stringToHex, zeroHash } from "viem"; +import { useAccount } from "wagmi"; + +import { useChain } from "../context/ChainContext"; +import { useSendTransaction } from "./useSendTransaction"; + +type Meeting = { + /** The per-org MeetingFactory clone address. */ + governanceMeetingAddress: `0x${string}`; + /** The indexer's composite id used to key proposal/objection queries: `
-`. */ + processAddress: `0x${string}`; +}; + +/** Hash free-text concern client-side; text stays off-chain. */ +function hashConcern(text: string | undefined, fallback?: `0x${string}`): `0x${string}` { + if (fallback) return fallback; + if (!text || !text.trim()) return zeroHash; + return keccak256(stringToHex(text.trim())); +} + +/** Invalidate the read hooks that back the proposal/objection UI. */ +function invalidateProposalQueries( + queryClient: ReturnType, + processAddress: `0x${string}`, + proposalId: string, +) { + queryClient.invalidateQueries({ queryKey: ["publicOpenProposals"] }); + queryClient.invalidateQueries({ + queryKey: ["publicProposal", `${processAddress}-${proposalId}`], + }); + queryClient.invalidateQueries({ queryKey: ["publicObjections", processAddress, proposalId] }); +} + +// ── Raise objection ───────────────────────────────────────────────────────── + +export type RaiseObjectionParams = { + meeting: Meeting; + proposalId: bigint; + /** + * The role the objector is representing (§5.3 Representation Rule). + * Must be a role the caller leads in the proposal's circle, OR `0n` when + * the caller is the circle's elected Facilitator/Secretary. + */ + objectorRoleId: bigint; + /** Free-text concern, hashed client-side. Pass `concernHash` to use a precomputed ref. */ + concernText?: string; + concernHash?: `0x${string}`; +}; + +export function useRaiseObjection() { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: RaiseObjectionParams) => { + if (!address) throw new Error("Connect a wallet to raise an objection."); + const concernHash = hashConcern(params.concernText, params.concernHash); + const txHash = await send( + [ + { + to: params.meeting.governanceMeetingAddress, + abi: meetingFactoryAbi, + functionName: "raiseObjection", + args: [params.proposalId, params.objectorRoleId, concernHash], + }, + ], + address, + ); + return { txHash, concernHash }; + }, + onSuccess: (_data, params) => { + invalidateProposalQueries( + queryClient, + params.meeting.processAddress, + params.proposalId.toString(), + ); + }, + }); +} + +// ── Resolve objection ─────────────────────────────────────────────────────── + +export type ResolveObjectionParams = { + meeting: Meeting; + proposalId: bigint; + objectionId: bigint; +}; + +export function useResolveObjection() { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: ResolveObjectionParams) => { + if (!address) throw new Error("Connect a wallet to resolve an objection."); + const txHash = await send( + [ + { + to: params.meeting.governanceMeetingAddress, + abi: meetingFactoryAbi, + functionName: "resolveObjection", + args: [params.objectionId], + }, + ], + address, + ); + return { txHash }; + }, + onSuccess: (_data, params) => { + invalidateProposalQueries( + queryClient, + params.meeting.processAddress, + params.proposalId.toString(), + ); + }, + }); +} + +// ── Adopt proposal ────────────────────────────────────────────────────────── + +export type AdoptProposalParams = { + meeting: Meeting; + proposalId: bigint; +}; + +export function useAdoptProposal() { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: AdoptProposalParams) => { + if (!address) throw new Error("Connect a wallet to adopt the proposal."); + const txHash = await send( + [ + { + to: params.meeting.governanceMeetingAddress, + abi: meetingFactoryAbi, + functionName: "adoptProposal", + args: [params.proposalId], + }, + ], + address, + ); + return { txHash }; + }, + onSuccess: (_data, params) => { + invalidateProposalQueries( + queryClient, + params.meeting.processAddress, + params.proposalId.toString(), + ); + }, + }); +} + +// ── Discard proposal (proposer or circle Facilitator, §5.3.4) ───────────── + +export type DiscardProposalParams = { + meeting: Meeting; + proposalId: bigint; +}; + +export function useDiscardProposal() { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: DiscardProposalParams) => { + if (!address) throw new Error("Connect a wallet to discard the proposal."); + const txHash = await send( + [ + { + to: params.meeting.governanceMeetingAddress, + abi: meetingFactoryAbi, + functionName: "discardProposal", + args: [params.proposalId], + }, + ], + address, + ); + return { txHash }; + }, + onSuccess: (_data, params) => { + invalidateProposalQueries( + queryClient, + params.meeting.processAddress, + params.proposalId.toString(), + ); + }, + }); +} + +// ── Discard expired (permissionless) ──────────────────────────────────────── + +export type DiscardExpiredProposalParams = { + meeting: Meeting; + proposalId: bigint; +}; + +export function useDiscardExpiredProposal() { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: DiscardExpiredProposalParams) => { + if (!address) throw new Error("Connect a wallet to discard the proposal."); + const txHash = await send( + [ + { + to: params.meeting.governanceMeetingAddress, + abi: meetingFactoryAbi, + functionName: "discardExpiredProposal", + args: [params.proposalId], + }, + ], + address, + ); + return { txHash }; + }, + onSuccess: (_data, params) => { + invalidateProposalQueries( + queryClient, + params.meeting.processAddress, + params.proposalId.toString(), + ); + }, + }); +} + +// ── Derivations ───────────────────────────────────────────────────────────── + +/** + * Fallback value used while the on-chain `proposalMaxAge` read is in flight. + * Matches `MeetingFactory.DEFAULT_PROPOSAL_MAX_AGE` so behavior is consistent + * with a freshly-initialized clone that has not been reconfigured. + * See specs/99-agent-native-divergence.md — the per-org value is authoritative + * and can be read via `useProposalMaxAge(meetingFactoryAddress)`. + */ +export const DEFAULT_PROPOSAL_MAX_AGE_SECONDS = 7 * 24 * 60 * 60; + +export function isProposalExpired( + submittedAt: string | bigint | number, + maxAgeSeconds: number, + nowSeconds = Math.floor(Date.now() / 1000), +): boolean { + const submitted = typeof submittedAt === "bigint" ? Number(submittedAt) : Number(submittedAt); + return nowSeconds - submitted > maxAgeSeconds; +} + +export function secondsUntilExpiry( + submittedAt: string | bigint | number, + maxAgeSeconds: number, + nowSeconds = Math.floor(Date.now() / 1000), +): number { + const submitted = typeof submittedAt === "bigint" ? Number(submittedAt) : Number(submittedAt); + return maxAgeSeconds - (nowSeconds - submitted); +} + +/** + * Reads the per-org `proposalMaxAge` from the given MeetingFactory clone. + * Value is authoritative; falls back to {@link DEFAULT_PROPOSAL_MAX_AGE_SECONDS} + * during the initial load. + */ +export function useProposalMaxAge(meetingFactoryAddress: `0x${string}` | undefined): { + maxAgeSeconds: number; + isLoading: boolean; +} { + const { chainConfig } = useChain(); + + const query = useQuery({ + queryKey: ["proposalMaxAge", chainConfig.chain.id, meetingFactoryAddress], + enabled: !!meetingFactoryAddress, + queryFn: async () => { + if (!meetingFactoryAddress) return DEFAULT_PROPOSAL_MAX_AGE_SECONDS; + const publicClient = createPublicClient({ + chain: chainConfig.chain, + transport: http(chainConfig.chain.rpcUrls.default.http[0]), + }); + const raw = await publicClient.readContract({ + address: meetingFactoryAddress, + abi: meetingFactoryAbi, + functionName: "proposalMaxAge", + }); + return Number(raw); + }, + // proposalMaxAge changes via admin tx, which is rare; cache for 5 min. + staleTime: 5 * 60 * 1000, + }); + + return { + maxAgeSeconds: query.data ?? DEFAULT_PROPOSAL_MAX_AGE_SECONDS, + isLoading: query.isLoading, + }; +} diff --git a/apps/hola-modern/src/hooks/useRoleData.ts b/apps/hola-modern/src/hooks/useRoleData.ts new file mode 100644 index 0000000..a6b0f1d --- /dev/null +++ b/apps/hola-modern/src/hooks/useRoleData.ts @@ -0,0 +1,188 @@ +/** + * useRoleData — read/write per-role checklist items and metrics via the + * RoleDataRegistry clone. Reads go through the Ponder indexer; writes call + * RoleDataRegistry directly (role-lead or admin authorization). + */ +import type { ChecklistItem, Metric } from "@hollab-io/indexing-client"; +import type { Address } from "viem"; +import { roleDataRegistryAbi } from "@hollab-io/contracts/actions"; +import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"; +import { useAccount } from "wagmi"; + +import { getIndexingClient } from "./useOrganizationsFromIndexer"; +import { useSendTransaction } from "./useSendTransaction"; + +export type { ChecklistItem, Metric }; + +// ── Reads ───────────────────────────────────────────────────────────────────── + +export function useChecklistItems( + registryAddress: Address | undefined, + roleId: bigint | undefined, +) { + const roleKey = roleId !== undefined ? roleId.toString() : null; + return useQuery({ + queryKey: ["checklistItems", registryAddress, roleKey], + queryFn: async () => { + const client = getIndexingClient(); + if (!client || !registryAddress || roleKey === null) return []; + const result = await client.listChecklistItemsByRole(registryAddress, roleKey); + return result.items.filter((item) => item.isActive); + }, + enabled: Boolean(registryAddress && roleKey !== null), + }); +} + +export function useMetrics(registryAddress: Address | undefined, roleId: bigint | undefined) { + const roleKey = roleId !== undefined ? roleId.toString() : null; + return useQuery({ + queryKey: ["metrics", registryAddress, roleKey], + queryFn: async () => { + const client = getIndexingClient(); + if (!client || !registryAddress || roleKey === null) return []; + const result = await client.listMetricsByRole(registryAddress, roleKey); + return result.items.filter((item) => item.isActive); + }, + enabled: Boolean(registryAddress && roleKey !== null), + }); +} + +export function useChecklistItemsByContract(registryAddress: Address | undefined) { + return useQuery({ + queryKey: ["checklistItems", registryAddress, "all"], + queryFn: async () => { + const client = getIndexingClient(); + if (!client || !registryAddress) return []; + const result = await client.listChecklistItemsByContract(registryAddress); + return result.items.filter((item) => item.isActive); + }, + enabled: Boolean(registryAddress), + }); +} + +export function useMetricsByContract(registryAddress: Address | undefined) { + return useQuery({ + queryKey: ["metrics", registryAddress, "all"], + queryFn: async () => { + const client = getIndexingClient(); + if (!client || !registryAddress) return []; + const result = await client.listMetricsByContract(registryAddress); + return result.items.filter((item) => item.isActive); + }, + enabled: Boolean(registryAddress), + }); +} + +// ── Writes ──────────────────────────────────────────────────────────────────── + +export function useAddChecklistItem(registryAddress: Address | undefined) { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: { roleId: bigint; label: string }) => { + if (!address || !registryAddress) throw new Error("Wallet or registry missing"); + return send( + [ + { + to: registryAddress, + abi: roleDataRegistryAbi, + functionName: "addChecklistItem", + args: [params.roleId, params.label], + }, + ], + address, + ); + }, + onSuccess: (_, params) => { + queryClient.invalidateQueries({ + queryKey: ["checklistItems", registryAddress, params.roleId.toString()], + }); + }, + }); +} + +export function useRemoveChecklistItem(registryAddress: Address | undefined) { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: { itemId: bigint; roleId: bigint }) => { + if (!address || !registryAddress) throw new Error("Wallet or registry missing"); + return send( + [ + { + to: registryAddress, + abi: roleDataRegistryAbi, + functionName: "removeChecklistItem", + args: [params.itemId], + }, + ], + address, + ); + }, + onSuccess: (_, params) => { + queryClient.invalidateQueries({ + queryKey: ["checklistItems", registryAddress, params.roleId.toString()], + }); + }, + }); +} + +export function useAddMetric(registryAddress: Address | undefined) { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: { roleId: bigint; label: string }) => { + if (!address || !registryAddress) throw new Error("Wallet or registry missing"); + return send( + [ + { + to: registryAddress, + abi: roleDataRegistryAbi, + functionName: "addMetric", + args: [params.roleId, params.label], + }, + ], + address, + ); + }, + onSuccess: (_, params) => { + queryClient.invalidateQueries({ + queryKey: ["metrics", registryAddress, params.roleId.toString()], + }); + }, + }); +} + +export function useRemoveMetric(registryAddress: Address | undefined) { + const { address } = useAccount(); + const { send } = useSendTransaction(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params: { metricId: bigint; roleId: bigint }) => { + if (!address || !registryAddress) throw new Error("Wallet or registry missing"); + return send( + [ + { + to: registryAddress, + abi: roleDataRegistryAbi, + functionName: "removeMetric", + args: [params.metricId], + }, + ], + address, + ); + }, + onSuccess: (_, params) => { + queryClient.invalidateQueries({ + queryKey: ["metrics", registryAddress, params.roleId.toString()], + }); + }, + }); +} diff --git a/apps/hola-modern/src/hooks/useRoleFieldContent.ts b/apps/hola-modern/src/hooks/useRoleFieldContent.ts new file mode 100644 index 0000000..0568a44 --- /dev/null +++ b/apps/hola-modern/src/hooks/useRoleFieldContent.ts @@ -0,0 +1,74 @@ +/** + * useRoleFieldContent — read a role field's content from 0G via on-chain ContentRef. + * + * 1. Reads ContentRef from RoleRegistry (on-chain) + * 2. If zero hash → returns undefined (backward compat with non-Refs roles) + * 3. Downloads from 0G + decrypts based on visibility tier + * + * For encrypted fields, returns { needsUnlock: true } when keys are not yet + * derived, so the UI can show a lock icon + "Unlock to view" button. + */ +import type { Address } from "viem"; +import { useQuery } from "@tanstack/react-query"; + +import { DataVisibility, useReadContentRef } from "./useContentRef"; +import { useEncryptedStorage } from "./useEncryptedStorage"; + +const ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000"; + +export function useRoleFieldContent(params: { + roleRegistryAddress: Address | undefined; + roleId: bigint | undefined; + fieldName: string | undefined; + orgId: bigint; + circleId: bigint; + roleId_forKey?: bigint; +}) { + const { fetchAndDecrypt, isKeyUnlocked } = useEncryptedStorage(); + + const { + data: contentRef, + isLoading: isRefLoading, + error: refError, + } = useReadContentRef(params.roleRegistryAddress, params.roleId, params.fieldName); + + const hasContent = !!contentRef && contentRef.contentHash !== ZERO_HASH; + const isEncrypted = hasContent && contentRef.visibility !== DataVisibility.Public; + const needsUnlock = isEncrypted && !isKeyUnlocked; + + const { + data, + isLoading: isContentLoading, + error: contentError, + } = useQuery({ + queryKey: [ + "roleFieldContent", + contentRef?.contentHash, + contentRef?.visibility, + isKeyUnlocked, + ], + queryFn: async () => { + if (!contentRef || contentRef.contentHash === ZERO_HASH) return undefined; + + // Convert bytes32 contentHash to 0G root hash string + const rootHash = contentRef.contentHash; + + return fetchAndDecrypt({ + rootHash, + visibility: contentRef.visibility as 0 | 1 | 2, + orgId: params.orgId, + circleId: params.circleId, + roleId: params.roleId_forKey, + }); + }, + enabled: hasContent && !needsUnlock, + }); + + return { + data, + isLoading: isRefLoading || isContentLoading, + error: refError ?? contentError ?? null, + needsUnlock, + hasContent, + }; +} diff --git a/apps/hola-modern/src/hooks/useSetOkrs.ts b/apps/hola-modern/src/hooks/useSetOkrs.ts new file mode 100644 index 0000000..6625f66 --- /dev/null +++ b/apps/hola-modern/src/hooks/useSetOkrs.ts @@ -0,0 +1,135 @@ +/** + * useSetOkrs — propose updating the OKR blob for a (role, quarter) pair. + * + * OKR changes go through governance: the caller uploads the new objectives + * to 0G and raises an AmendRoleWithRefs proposal that re-points the role's + * on-chain content ref for fieldName=keccak256("okr:{quarter}") to the new + * blob. Proposal adoption requires zero open objections (standard IDM). + * + * The caller (msg.sender) must be a lead of `proposerRoleId`. + */ +import type { OkrObjective } from "@hollab-io/hollab-sdk"; +import { meetingFactoryAbi, roleRegistryAbi } from "@hollab-io/contracts/actions"; +import { useMutation, useQueryClient } from "@tanstack/react-query"; +import { createPublicClient, http, keccak256, toBytes } from "viem"; +import { useAccount } from "wagmi"; + +import type { DataVisibilityValue } from "./useContentRef"; +import { useChain } from "../context/ChainContext"; +import { DataVisibility } from "./useContentRef"; +import { useEncryptedStorage } from "./useEncryptedStorage"; +import { ChangeType, encodeAmendRoleWithRefs } from "./useExecuteGovernance"; +import { okrFieldNameHash } from "./useOkrObjectives"; +import { useSendTransaction } from "./useSendTransaction"; + +export type SetOkrsParams = { + meetingFactoryAddress: `0x${string}`; + roleRegistryAddress: `0x${string}`; + orgId: bigint; + circleId: bigint; + roleId: bigint; + /** Role the proposer is representing (must be a lead). Defaults to the amended role. */ + proposerRoleId?: bigint; + quarter: string; + objectives: OkrObjective[]; + visibility?: DataVisibilityValue; + /** Free-text tension — only the hash is stored on-chain */ + tension?: string; +}; + +export type SetOkrsResult = { + txHash: `0x${string}`; + rootHash: string; +}; + +export function useSetOkrs() { + const { address } = useAccount(); + const { encryptAndUpload } = useEncryptedStorage(); + const { send } = useSendTransaction(); + const { chainConfig } = useChain(); + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: async (params) => { + if (!address) throw new Error("Wallet not connected"); + + const visibility = params.visibility ?? DataVisibility.OrgEncrypted; + const proposerRoleId = params.proposerRoleId ?? params.roleId; + + // 1. Read current role state so the proposal leaves everything + // other than the OKR content ref unchanged. + const publicClient = createPublicClient({ + chain: chainConfig.chain, + transport: http(chainConfig.chain.rpcUrls.default.http[0]), + }); + const role = await publicClient.readContract({ + abi: roleRegistryAbi, + address: params.roleRegistryAddress, + functionName: "getRole", + args: [params.roleId], + }); + + // 2. Serialize + upload + encrypt. + const text = JSON.stringify(params.objectives); + const { rootHash } = await encryptAndUpload.mutateAsync({ + text, + visibility, + orgId: params.orgId, + circleId: params.circleId, + roleId: params.roleId, + }); + + const contentHash = + `0x${rootHash.replace(/^0x/, "").padStart(64, "0")}` as `0x${string}`; + + // 3. Build AmendRoleWithRefs payload with existing role fields + new OKR ref. + const encodedData = encodeAmendRoleWithRefs({ + roleId: params.roleId, + name: role.name, + purpose: role.purpose, + domains: [...role.domains], + accountabilities: [...role.accountabilities], + fieldNames: [okrFieldNameHash(params.quarter)], + refs: [{ contentHash, visibility }], + }); + + const tensionText = + params.tension ?? `OKR update for role ${params.roleId} ${params.quarter}`; + const tensionHash = keccak256(toBytes(tensionText)); + + // 4. Submit the proposal. Adoption is a separate step (done by any + // member once objections are resolved). + const txHash = await send( + [ + { + to: params.meetingFactoryAddress, + abi: meetingFactoryAbi, + functionName: "createProposal", + args: [ + params.orgId, + params.circleId, + proposerRoleId, + tensionHash, + ChangeType.AmendRoleWithRefs, + encodedData, + ], + }, + ], + address, + ); + + return { txHash, rootHash }; + }, + onSuccess: (_result, params) => { + queryClient.invalidateQueries({ + queryKey: [ + "okrs", + params.roleRegistryAddress, + params.roleId.toString(), + params.quarter, + ], + }); + queryClient.invalidateQueries({ queryKey: ["publicOpenProposals"] }); + }, + }); +} diff --git a/apps/hola-modern/src/hooks/useTacticalMeetingsFromIndexer.ts b/apps/hola-modern/src/hooks/useTacticalMeetingsFromIndexer.ts index 7373afd..ba95a0a 100644 --- a/apps/hola-modern/src/hooks/useTacticalMeetingsFromIndexer.ts +++ b/apps/hola-modern/src/hooks/useTacticalMeetingsFromIndexer.ts @@ -116,6 +116,7 @@ export function useTacticalMeetingsFromIndexer(orgId: string | null) { tacticalMeetingAddress: mf, governanceMeetingAddress: mf, actionVotingAddress: components?.actionVoting as `0x${string}` | undefined, + roleDataRegistryAddress: components?.roleDataRegistry as `0x${string}` | undefined, meetings, outputs, loading, diff --git a/apps/hola-modern/src/hooks/useZgStorage.ts b/apps/hola-modern/src/hooks/useZgStorage.ts index 24584dd..65d902e 100644 --- a/apps/hola-modern/src/hooks/useZgStorage.ts +++ b/apps/hola-modern/src/hooks/useZgStorage.ts @@ -7,7 +7,10 @@ * Requires ethers BrowserProvider to bridge the wallet signer to the * 0G SDK's ethers-based upload API. */ -import { Indexer, MemData } from "@0gfoundation/0g-ts-sdk"; +// Use the SDK's /browser entry to avoid pulling `node:fs/promises` via ZgFile, +// which Rollup cannot bundle for the browser. The /browser subpath ships the +// same public API (Indexer, MemData) compiled for the browser target. +import { Indexer, MemData } from "@0gfoundation/0g-ts-sdk/browser"; import { useMutation } from "@tanstack/react-query"; import { BrowserProvider } from "ethers"; @@ -30,7 +33,7 @@ export type UploadResult = { * Upload raw bytes to 0G Storage from the browser. * Handles Indexer init, signer bridging, merkle tree generation, and upload. */ -async function uploadBytes(data: Uint8Array): Promise { +export async function uploadBytes(data: Uint8Array): Promise { const signer = await getEthersSigner(); const indexer = new Indexer(zgConfig.indexerRpc); @@ -50,6 +53,40 @@ async function uploadBytes(data: Uint8Array): Promise { return { rootHash: rootHash! }; } +/** + * Download raw bytes from 0G Storage by Merkle root hash. + * Standalone async function (not a hook) so composition hooks can call it directly. + */ +/** + * Download raw bytes from 0G Storage by Merkle root hash. + * + * The 0G SDK's Indexer.download writes to a file path (Node-only), so in the + * browser we locate the shard nodes via the indexer and fetch the file data + * over HTTP from the first available node. + */ +export async function downloadBytes(rootHash: string): Promise { + const indexer = new Indexer(zgConfig.indexerRpc); + const locations = await indexer.getFileLocations(rootHash); + + if (!locations.length) { + throw new Error(`0G: no shard nodes found for root hash ${rootHash}`); + } + + // Try each shard node until one succeeds + for (const node of locations) { + try { + const url = `${node.url}/file?root=${rootHash}`; + const response = await fetch(url); + if (!response.ok) continue; + return new Uint8Array(await response.arrayBuffer()); + } catch { + continue; + } + } + + throw new Error(`0G: all shard nodes failed to serve root hash ${rootHash}`); +} + export function useZgStorage() { /** Upload a text string to 0G Storage */ const uploadText = useMutation({ diff --git a/apps/hola-modern/src/shims/node-fs-promises.ts b/apps/hola-modern/src/shims/node-fs-promises.ts new file mode 100644 index 0000000..deef33d --- /dev/null +++ b/apps/hola-modern/src/shims/node-fs-promises.ts @@ -0,0 +1,33 @@ +/** + * Browser shim for `node:fs/promises`. + * + * @0gfoundation/0g-ts-sdk's browser bundle still references fs/promises from + * its Node-only ZgFile class. Our hola-modern code never reaches ZgFile — we + * use MemData (bytes in memory) and ZgBlob (File objects). This module exists + * only to give Rollup a specifier to resolve. Anything that actually imports + * these at runtime throws a clear error so we notice immediately. + */ +function unsupported(name: string): () => never { + return () => { + throw new Error( + `[node:fs/promises shim] '${name}' was called in the browser. ` + + `Browser code paths must not touch the filesystem.`, + ); + }; +} + +export const open = unsupported("open"); +export const readFile = unsupported("readFile"); +export const writeFile = unsupported("writeFile"); +export const stat = unsupported("stat"); +export const unlink = unsupported("unlink"); +export const mkdir = unsupported("mkdir"); + +export default { + open, + readFile, + writeFile, + stat, + unlink, + mkdir, +}; diff --git a/apps/hola-modern/src/views/ActionItemsView.tsx b/apps/hola-modern/src/views/ActionItemsView.tsx index fa919a0..9a9b6c8 100644 --- a/apps/hola-modern/src/views/ActionItemsView.tsx +++ b/apps/hola-modern/src/views/ActionItemsView.tsx @@ -1,7 +1,12 @@ import { motion } from "framer-motion"; -import { CheckSquare, KanbanSquare, Target, TrendingUp } from "lucide-react"; +import { CheckSquare, KanbanSquare, Plus, Target, TrendingUp } from "lucide-react"; +import { useState } from "react"; import type { MeetingOutput, TacticalMeeting } from "../hooks/useTacticalMeetingsFromIndexer"; +import { quarterFromDate, useOrgOkrs } from "../hooks/useOrgOkrs"; +import { useMetricsByContract } from "../hooks/useRoleData"; +import { useRolesFromIndexer } from "../hooks/useRolesFromIndexer"; +import OkrProposalComposer from "./OkrProposalComposer"; const EXPO: [number, number, number, number] = [0.16, 1, 0.3, 1]; @@ -13,14 +18,40 @@ function truncateAddress(addr: string): string { type Props = { outputs: MeetingOutput[]; meetings: TacticalMeeting[]; + orgId?: string; + roleRegistryAddress?: `0x${string}`; + roleDataRegistryAddress?: `0x${string}`; + meetingFactoryAddress?: `0x${string}`; }; -export default function ActionItemsView({ outputs, meetings }: Props) { +export default function ActionItemsView({ + outputs, + meetings, + orgId, + roleRegistryAddress, + roleDataRegistryAddress, + meetingFactoryAddress, +}: Props) { + const [isOkrComposerOpen, setIsOkrComposerOpen] = useState(false); + const canProposeOkrs = Boolean(orgId && roleRegistryAddress && meetingFactoryAddress); const nextActions = outputs.filter((o) => o.outputType === 0); const projects = outputs.filter((o) => o.outputType === 1); const meetingMap = new Map(meetings.map((m) => [m.meetingId, m])); + const { data: metrics = [] } = useMetricsByContract(roleDataRegistryAddress); + const { roles: indexedRoles } = useRolesFromIndexer(orgId ?? null); + const roleNameById = new Map(indexedRoles.map((r) => [r.roleId.toString(), r.name])); + + const currentQuarter = quarterFromDate(new Date()); + const { data: okrsByRole = [] } = useOrgOkrs({ + roleRegistryAddress, + orgId: orgId ? BigInt(orgId) : undefined, + circleId: undefined, + quarter: currentQuarter, + }); + const totalOkrCount = okrsByRole.reduce((sum, r) => sum + r.objectives.length, 0); + return (
@@ -167,16 +198,78 @@ export default function ActionItemsView({ outputs, meetings }: Props) { transition={{ duration: 0.6, delay: 0.14, ease: EXPO }} className="rounded-[1.5rem] border border-white/[0.06] bg-white/[0.03] p-5" > -
- -

- OKRs -

+
+
+ +

+ OKRs · {currentQuarter} +

+ {totalOkrCount > 0 && ( + + {totalOkrCount} + + )} +
+ {canProposeOkrs && ( + + )}
- + {totalOkrCount === 0 ? ( + + ) : ( +
+ {okrsByRole.map((entry) => ( +
+

+ {roleNameById.get(entry.roleId.toString()) ?? + `Role #${entry.roleId}`} +

+
    + {entry.objectives.map((obj) => ( +
  • +

    + {obj.title} +

    + {obj.description && ( +

    + {obj.description} +

    + )} + {obj.keyResults.length > 0 && ( +
      + {obj.keyResults.map((kr) => ( +
    • + + KR + + {kr.label} +
      • + ))} +
    + )} +
    • + ))} +
+
+ ))} +
+ )} {/* Metrics */} @@ -191,14 +284,48 @@ export default function ActionItemsView({ outputs, meetings }: Props) {

Metrics

+ {metrics.length > 0 && ( + + {metrics.length} + + )}
- + {metrics.length === 0 ? ( + + ) : ( +
    + {metrics.map((m) => ( +
  • +

    + {m.label} +

    +

    + {roleNameById.get(m.roleId.toString()) ?? + `Role #${m.roleId}`} +

    +
    • + ))} +
+ )}
+ + {canProposeOkrs && orgId && roleRegistryAddress && meetingFactoryAddress && ( + setIsOkrComposerOpen(false)} + orgId={orgId} + roleRegistryAddress={roleRegistryAddress} + meetingFactoryAddress={meetingFactoryAddress} + /> + )}
); } diff --git a/apps/hola-modern/src/views/ActionsList.tsx b/apps/hola-modern/src/views/ActionsList.tsx index 9bff47c..e72d4dc 100644 --- a/apps/hola-modern/src/views/ActionsList.tsx +++ b/apps/hola-modern/src/views/ActionsList.tsx @@ -1,19 +1,31 @@ import { Calendar, MoreVertical } from "lucide-react"; import { useState } from "react"; +import { showToast } from "../components/toastBus"; import { useWorkspaceSnapshot } from "../hooks/useWorkspaceSnapshot"; type ActionsFilter = "mine" | "completed" | "all"; type SortOption = "newest" | "assignee"; const dueDateFormatter = new Intl.DateTimeFormat("en-GB", { day: "numeric", month: "long" }); -const completedDateFormatter = new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric", year: "numeric" }); +const completedDateFormatter = new Intl.DateTimeFormat("en-US", { + month: "short", + day: "numeric", + year: "numeric", +}); const SPRING = "cubic-bezier(0.32,0.72,0,1)"; export default function ActionsList() { - const { snapshot, partnerMap, roleMap, circleMap, meetingMap, openMeeting, toggleActionCompletion } = - useWorkspaceSnapshot(); + const { + snapshot, + partnerMap, + roleMap, + circleMap, + meetingMap, + openMeeting, + toggleActionCompletion, + } = useWorkspaceSnapshot(); const [activeFilter, setActiveFilter] = useState("all"); const [sortBy, setSortBy] = useState("newest"); @@ -22,16 +34,25 @@ export default function ActionsList() { const assignee = action.assigneeId ? partnerMap[action.assigneeId] : null; const role = roleMap[action.roleId]; const circle = circleMap[action.circleId]; - const sourceMeeting = action.sourceMeetingId ? meetingMap[action.sourceMeetingId] : null; + const sourceMeeting = action.sourceMeetingId + ? meetingMap[action.sourceMeetingId] + : null; return { id: action.id, text: action.title, completed: action.completed, - context: role && circle ? `${role.title} · ${circle.title}` : (role?.title ?? circle?.title ?? ""), - date: !action.completed && action.dueDate ? dueDateFormatter.format(new Date(action.dueDate)) : undefined, - dateDesc: action.completed && action.completedAt - ? `Completed ${completedDateFormatter.format(new Date(action.completedAt))}` - : undefined, + context: + role && circle + ? `${role.title} · ${circle.title}` + : (role?.title ?? circle?.title ?? ""), + date: + !action.completed && action.dueDate + ? dueDateFormatter.format(new Date(action.dueDate)) + : undefined, + dateDesc: + action.completed && action.completedAt + ? `Completed ${completedDateFormatter.format(new Date(action.completedAt))}` + : undefined, sourceMeetingId: sourceMeeting?.id ?? null, sourceMeetingTitle: sourceMeeting?.title ?? null, user: assignee?.name ?? null, @@ -40,7 +61,10 @@ export default function ActionsList() { }) .filter((action) => { if (activeFilter === "mine") - return snapshot.actions.find((a) => a.id === action.id)?.assigneeId === snapshot.currentPartnerId; + return ( + snapshot.actions.find((a) => a.id === action.id)?.assigneeId === + snapshot.currentPartnerId + ); if (activeFilter === "completed") return action.completed; return true; }) @@ -64,9 +88,11 @@ export default function ActionsList() { {/* Toolbar */}
{/* Filter pills */} -
+ ring-1 ring-slate-200/80 dark:ring-white/[0.06] p-[3px]" + > {filterTabs.map((tab) => { const isActive = activeFilter === tab.id; return ( @@ -75,9 +101,10 @@ export default function ActionsList() { type="button" onClick={() => setActiveFilter(tab.id)} className={`rounded-full px-4 py-1.5 text-xs font-semibold transition-all duration-300 - ${isActive - ? "bg-white dark:bg-white/[0.1] text-slate-900 dark:text-white shadow-sm ring-1 ring-slate-200/60 dark:ring-white/[0.1]" - : "text-slate-500 dark:text-slate-500 hover:text-slate-700 dark:hover:text-slate-300" + ${ + isActive + ? "bg-white dark:bg-white/[0.1] text-slate-900 dark:text-white shadow-sm ring-1 ring-slate-200/60 dark:ring-white/[0.1]" + : "text-slate-500 dark:text-slate-500 hover:text-slate-700 dark:hover:text-slate-300" }`} style={{ transitionTimingFunction: SPRING }} > @@ -88,14 +115,18 @@ export default function ActionsList() {
{/* Stats */} - + px-3 py-1 text-[11px] font-semibold text-blue-700 dark:text-blue-400" + > {activeCount} active - + px-3 py-1 text-[11px] font-semibold text-emerald-700 dark:text-emerald-400" + > {completedCount} done @@ -104,7 +135,7 @@ export default function ActionsList() { Sort
{/* List */} -
+ bg-white dark:bg-[#0e0e12]" + > {visibleActions.length === 0 ? (
No actions here
@@ -144,26 +177,41 @@ export default function ActionsList() { onClick={() => toggleActionCompletion(action.id)} className={`mt-0.5 flex h-[18px] w-[18px] flex-shrink-0 items-center justify-center rounded-[5px] border-2 transition-all duration-300 - ${action.completed - ? "border-[#3481FF] bg-[#3481FF]" - : "border-slate-300 dark:border-white/[0.2] bg-transparent group-hover:border-[#3481FF]/60" + ${ + action.completed + ? "border-[#3481FF] bg-[#3481FF]" + : "border-slate-300 dark:border-white/[0.2] bg-transparent group-hover:border-[#3481FF]/60" }`} style={{ transitionTimingFunction: SPRING }} > {action.completed && ( -
-

+

{action.text}

@@ -175,7 +223,10 @@ export default function ActionsList() { {action.sourceMeetingTitle && action.sourceMeetingId && ( + ))} +
+
+ )} + {/* Create / amend policy fields */} {isPolicyAction && (isCreate || draft.changeType === "amend-policy") && ( <> @@ -1573,6 +1699,9 @@ export default function GovernanceMeetingRoom({ const [isTxPending, setIsTxPending] = useState(false); const [txError, setTxError] = useState(null); + // Encrypted storage (0G + key management) + const { encryptAndUpload, unlockKeys, isKeyUnlocked } = useEncryptedStorage(); + // Proposal wizard state const [showWizard, setShowWizard] = useState(false); const [wizardStep, setWizardStep] = useState("action"); @@ -1785,7 +1914,7 @@ export default function GovernanceMeetingRoom({ ], ); - const handleSubmitProposal = useCallback(() => { + const handleSubmitProposal = useCallback(async () => { if (!activeGovernanceMeeting) return; const isRoleAction = proposalDraft.changeType.includes("role"); @@ -1856,6 +1985,49 @@ export default function GovernanceMeetingRoom({ // Queue the on-chain action for batched execution at meeting completion const actionLabel = `${changeLabel}: ${title}`; + // Encrypt + upload to 0G when visibility is non-public and this is a role action + let contentRefs: { fieldName: string; rootHash: string; visibility: number }[] | undefined; + const vis = proposalDraft.visibility; + if ( + isRoleAction && + (isCreate || proposalDraft.changeType === "amend-role") && + vis !== undefined + ) { + // Unlock encryption keys if needed + if (vis !== DataVisibility.Public && !isKeyUnlocked && orgId) { + await unlockKeys(BigInt(orgId)); + } + + const fields: { name: string; text: string }[] = []; + if (proposalDraft.roleName) fields.push({ name: "name", text: proposalDraft.roleName }); + if (proposalDraft.roleDescription) + fields.push({ name: "purpose", text: proposalDraft.roleDescription }); + if (proposalDraft.roleDomain) + fields.push({ name: "domains", text: proposalDraft.roleDomain }); + if (proposalDraft.roleAccountabilities) + fields.push({ name: "accountabilities", text: proposalDraft.roleAccountabilities }); + + if (fields.length > 0) { + const cId = BigInt(proposalDraft.circleId || "0"); + const rId = proposalDraft.existingTargetId + ? BigInt(proposalDraft.existingTargetId) + : undefined; + const results = await Promise.all( + fields.map(async (f) => { + const { rootHash } = await encryptAndUpload.mutateAsync({ + text: f.text, + visibility: vis, + orgId: BigInt(orgId ?? "0"), + circleId: cId, + roleId: rId, + }); + return { fieldName: f.name, rootHash, visibility: vis }; + }), + ); + contentRefs = results; + } + } + setPendingActions((prev) => [ ...prev, { @@ -1871,6 +2043,8 @@ export default function GovernanceMeetingRoom({ policyBody: proposalDraft.policyBody || undefined, existingTargetId: proposalDraft.existingTargetId || undefined, destinationCircleId: proposalDraft.destinationCircleId || undefined, + visibility: vis, + contentRefs, }, ]); @@ -1880,11 +2054,15 @@ export default function GovernanceMeetingRoom({ }, [ activeGovernanceMeeting, createGovernanceProposal, + encryptAndUpload, initialCircleId, initialRoleId, + isKeyUnlocked, + orgId, proposalDraft, snapshot.policies, snapshot.roles, + unlockKeys, ]); const agendaItems = useMemo( diff --git a/apps/hola-modern/src/views/GovernanceView.tsx b/apps/hola-modern/src/views/GovernanceView.tsx index 9757142..bd7053d 100644 --- a/apps/hola-modern/src/views/GovernanceView.tsx +++ b/apps/hola-modern/src/views/GovernanceView.tsx @@ -6,6 +6,7 @@ import { useState } from "react"; import { useGovernanceMeeting } from "../hooks/useGovernanceMeeting"; import { useDeployMeetingComponents } from "../hooks/useMeetingComponentsFactory"; import { useWorkspaceSnapshot } from "../hooks/useWorkspaceSnapshot"; +import OpenProposalsPanel from "./OpenProposalsPanel"; const EXPO: [number, number, number, number] = [0.16, 1, 0.3, 1]; const SPRING = { type: "spring", stiffness: 340, damping: 28 } as const; @@ -278,6 +279,9 @@ export default function GovernanceView({
+ {/* Open proposals with full objection lifecycle */} + + {/* Two-column: active proposals + recent meetings */}
- +
+ + +
diff --git a/apps/hola-modern/src/views/JoinOrganizationPanel.tsx b/apps/hola-modern/src/views/JoinOrganizationPanel.tsx index 6c37b5f..c2d932c 100644 --- a/apps/hola-modern/src/views/JoinOrganizationPanel.tsx +++ b/apps/hola-modern/src/views/JoinOrganizationPanel.tsx @@ -4,10 +4,11 @@ * Lets an outside user look up a HolLab org by subname and submit a join request. * Shown inside OrganizationsHome for users who want to join (rather than create) an org. */ -import { organizationFactoryAbi } from "@hollab-io/viem-extension"; +import { organizationFactoryAbi, organizationInstanceAbi } from "@hollab-io/viem-extension"; +import { useQuery } from "@tanstack/react-query"; import { AnimatePresence, motion } from "framer-motion"; import { ArrowRight, Building2, Check, Loader2, Search, X } from "lucide-react"; -import { useCallback, useEffect, useMemo, useRef, useState } from "react"; +import { useEffect, useMemo, useState } from "react"; import { createPublicClient, http } from "viem"; import { useChain } from "../context/ChainContext"; @@ -18,6 +19,7 @@ type OrgPreview = { name: string; subname: string; creator: `0x${string}`; + instanceAddress: `0x${string}`; }; type LookupState = @@ -29,6 +31,8 @@ type LookupState = type SubmitState = "idle" | "pending" | "done" | "error"; +const DEBOUNCE_MS = 600; + const SPRING = { type: "spring", stiffness: 360, damping: 30 } as const; type Props = { @@ -45,60 +49,92 @@ export default function JoinOrganizationPanel({ onClose, prefilled }: Props) { ); const [subname, setSubname] = useState(prefilled?.subname ?? ""); + const [debouncedSubname, setDebouncedSubname] = useState(prefilled?.subname ?? ""); const [message, setMessage] = useState(""); - const [lookupState, setLookupState] = useState( - prefilled ? { kind: "found", org: prefilled } : { kind: "idle" }, - ); const [submitState, setSubmitState] = useState("idle"); const [submitError, setSubmitError] = useState(null); - const debounceRef = useRef | null>(null); const { requestToJoin } = useJoinRequest(); - const lookupOrg = useCallback(async (value: string) => { - const trimmed = value.trim().toLowerCase(); - if (trimmed.length < 3) { - setLookupState({ kind: "idle" }); - return; - } - setLookupState({ kind: "searching" }); - try { - const org = (await publicClient.readContract({ + // Debounce the input value into the query key — React Query dedupes and caches. + useEffect(() => { + if (prefilled) return; + const id = setTimeout(() => setDebouncedSubname(subname), DEBOUNCE_MS); + return () => clearTimeout(id); + }, [subname, prefilled]); + + const trimmedDebounced = debouncedSubname.trim().toLowerCase(); + const lookupEnabled = !prefilled && trimmedDebounced.length >= 3; + + const orgLookup = useQuery({ + queryKey: ["orgBySubname", chainConfig.orgFactoryAddress, trimmedDebounced] as const, + enabled: lookupEnabled, + staleTime: 30_000, + retry: false, + queryFn: async () => { + // Post-refactor the factory returns just an address; the instance + // owns the full metadata under summary(). + const instanceAddress = (await publicClient.readContract({ address: chainConfig.orgFactoryAddress, // eslint-disable-next-line @typescript-eslint/no-explicit-any abi: organizationFactoryAbi as any, functionName: "getOrganizationBySubname", - args: [trimmed], - })) as { id: bigint; name: string; subname: string; creator: `0x${string}` }; + args: [trimmedDebounced], + })) as `0x${string}`; - if (!org || org.id === 0n) { - setLookupState({ kind: "not-found" }); - } else { - setLookupState({ - kind: "found", - org: { id: org.id, name: org.name, subname: org.subname, creator: org.creator }, - }); + const ZERO = "0x0000000000000000000000000000000000000000"; + if (instanceAddress.toLowerCase() === ZERO) { + return null; } - } catch { - setLookupState({ kind: "error", message: "Could not reach the network. Try again." }); - } - }, []); - useEffect(() => { - // If prefilled org was passed, don't re-trigger lookup from the subname field. - if (prefilled) return; - if (debounceRef.current) clearTimeout(debounceRef.current); - debounceRef.current = setTimeout(() => void lookupOrg(subname), 600); - return () => { - if (debounceRef.current) clearTimeout(debounceRef.current); + const summary = (await publicClient.readContract({ + address: instanceAddress, + abi: organizationInstanceAbi, + functionName: "summary", + })) as { + id: bigint; + name: string; + subname: string; + creator: `0x${string}`; + }; + return { ...summary, instanceAddress }; + }, + }); + + const lookupState: LookupState = useMemo(() => { + if (prefilled) return { kind: "found", org: prefilled }; + if (!lookupEnabled) return { kind: "idle" }; + // Pending includes the initial load and debounced re-fetches. + if (orgLookup.isPending || orgLookup.isFetching) return { kind: "searching" }; + if (orgLookup.isError) { + return { kind: "error", message: "Could not reach the network. Try again." }; + } + const org = orgLookup.data; + if (!org || org.id === 0n) return { kind: "not-found" }; + return { + kind: "found", + org: { + id: org.id, + name: org.name, + subname: org.subname, + creator: org.creator, + instanceAddress: org.instanceAddress, + }, }; - }, [subname, lookupOrg, prefilled]); + }, [ + prefilled, + lookupEnabled, + orgLookup.isPending, + orgLookup.isFetching, + orgLookup.isError, + orgLookup.data, + ]); const handleSubmit = async () => { if (lookupState.kind !== "found") return; setSubmitState("pending"); setSubmitError(null); try { - await requestToJoin({ orgId: lookupState.org.id, message }); + await requestToJoin({ instanceAddress: lookupState.org.instanceAddress, message }); setSubmitState("done"); } catch (err) { setSubmitState("error"); diff --git a/apps/hola-modern/src/views/MemberOnboarding.tsx b/apps/hola-modern/src/views/MemberOnboarding.tsx index ee35827..a16dfa8 100644 --- a/apps/hola-modern/src/views/MemberOnboarding.tsx +++ b/apps/hola-modern/src/views/MemberOnboarding.tsx @@ -194,8 +194,7 @@ export default function MemberOnboarding({ org, onComplete }: Props) { try { await addOrgMembers({ - orgFactoryAddress: chainConfig.orgFactoryAddress, - orgId: BigInt(org.id), + instanceAddress: org.instanceAddress as `0x${string}`, memberAddresses: resolvedAddresses, walletAddress: address as `0x${string}`, }); diff --git a/apps/hola-modern/src/views/MembersView.tsx b/apps/hola-modern/src/views/MembersView.tsx index 768d5d6..c5035c3 100644 --- a/apps/hola-modern/src/views/MembersView.tsx +++ b/apps/hola-modern/src/views/MembersView.tsx @@ -1,9 +1,9 @@ import type { Organization } from "@hollab-io/indexing-client"; +import { useQuery } from "@tanstack/react-query"; import { ArrowRight, BadgeCheck, Loader2, Mail, Plus, Users, Wallet } from "lucide-react"; -import { useEffect, useMemo, useState } from "react"; +import { useMemo, useState } from "react"; import { isAddress } from "viem"; -import { useChain } from "../context/ChainContext"; import { getIndexingClient } from "../hooks/useOrganizationsFromIndexer"; import { useOrgMemberActions } from "../hooks/useOrgMemberActions"; import { useWorkspaceSnapshot } from "../hooks/useWorkspaceSnapshot"; @@ -29,8 +29,9 @@ const INPUT_CLS = `w-full rounded-xl type Props = { org: Organization }; +const EMPTY_ADDRESS_SET: Set = new Set(); + export default function MembersView({ org }: Props) { - const { chainConfig } = useChain(); const { authenticatedWalletAddress, circleMap, inviteMember, organization, snapshot } = useWorkspaceSnapshot(); const { addOrgMembers } = useOrgMemberActions(); @@ -43,20 +44,19 @@ export default function MembersView({ org }: Props) { const [txHash, setTxHash] = useState(null); // ── On-chain members (from indexer) ────────────────────────────────────── - const [onChainAddresses, setOnChainAddresses] = useState>(new Set()); - - useEffect(() => { - const client = getIndexingClient(); - if (!client) return; - client - .listOrgMembersByOrg(chainConfig.orgFactoryAddress, org.id, { limit: 500 }) - .then((r) => - setOnChainAddresses(new Set(r.items.map((m) => m.memberAddress.toLowerCase()))), - ) - .catch(() => { - /* silent — indexer may not have caught up yet */ + const { data: onChainAddresses = EMPTY_ADDRESS_SET } = useQuery({ + queryKey: ["orgMembers:addresses", org.instanceAddress, org.id] as const, + queryFn: async () => { + const client = getIndexingClient(); + if (!client) return new Set(); + const r = await client.listOrgMembersByOrg(org.instanceAddress, org.id, { + limit: 500, }); - }, [chainConfig.orgFactoryAddress, org.id]); + return new Set(r.items.map((m) => m.memberAddress.toLowerCase())); + }, + staleTime: 15_000, + enabled: Boolean(org.instanceAddress), + }); const members = useMemo(() => { const rolesByPartnerId = new Map(); @@ -122,8 +122,7 @@ export default function MembersView({ org }: Props) { try { const hash = await addOrgMembers({ - orgFactoryAddress: chainConfig.orgFactoryAddress, - orgId: BigInt(org.id), + instanceAddress: org.instanceAddress as `0x${string}`, memberAddresses: [addr as `0x${string}`], walletAddress: authenticatedWalletAddress as `0x${string}`, }); diff --git a/apps/hola-modern/src/views/OkrProposalComposer.tsx b/apps/hola-modern/src/views/OkrProposalComposer.tsx new file mode 100644 index 0000000..6ac07ca --- /dev/null +++ b/apps/hola-modern/src/views/OkrProposalComposer.tsx @@ -0,0 +1,431 @@ +/** + * OkrProposalComposer — modal form that proposes OKR updates via governance. + * + * The caller must be a role lead of the receiving role (so the proposal is + * raised under the representation rule). On submit, the aggregate objectives + * list is uploaded to 0G and an AmendRoleWithRefs proposal is created that + * re-points the role's `keccak256("okr:{quarter}")` content ref. + */ +import type { OkrKeyResult, OkrObjective } from "@hollab-io/hollab-sdk"; +import type { Address } from "viem"; +import { AnimatePresence, motion } from "framer-motion"; +import { Plus, Target, X } from "lucide-react"; +import { useEffect, useMemo, useState } from "react"; +import { useAccount } from "wagmi"; + +import { showToast } from "../components/toastBus"; +import { useOkrObjectives } from "../hooks/useOkrObjectives"; +import { quarterFromDate } from "../hooks/useOrgOkrs"; +import { useRolesFromIndexer } from "../hooks/useRolesFromIndexer"; +import { useSetOkrs } from "../hooks/useSetOkrs"; + +type OkrComposerProps = { + isOpen: boolean; + onClose: () => void; + orgId: string; + roleRegistryAddress: Address; + meetingFactoryAddress: Address; +}; + +type DraftKeyResult = { + id: string; + label: string; +}; + +type DraftObjective = { + id: string; + title: string; + description: string; + keyResults: DraftKeyResult[]; +}; + +function nextQuarters(count: number): string[] { + const now = new Date(); + const results: string[] = []; + for (let i = -1; i < count - 1; ++i) { + const d = new Date(now.getFullYear(), now.getMonth() + i * 3, 1); + results.push(quarterFromDate(d)); + } + return results; +} + +function makeId(): string { + return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`; +} + +function toDraft(obj: OkrObjective): DraftObjective { + return { + id: obj.id, + title: obj.title, + description: obj.description, + keyResults: obj.keyResults.map((kr) => ({ id: kr.id, label: kr.label })), + }; +} + +function fromDraft( + d: DraftObjective, + ctx: { roleId: string; circleId: string; quarter: string; timestamp: number }, +): OkrObjective { + const keyResults: OkrKeyResult[] = d.keyResults.map((kr) => ({ + id: kr.id, + label: kr.label, + linkedActionIds: [], + linkedProjectIds: [], + linkedProposalIds: [], + })); + return { + id: d.id, + roleId: ctx.roleId, + circleId: ctx.circleId, + quarter: ctx.quarter, + title: d.title, + description: d.description, + keyResults, + startOffset: 0, + endOffset: 12, + createdAt: ctx.timestamp, + updatedAt: ctx.timestamp, + }; +} + +export default function OkrProposalComposer({ + isOpen, + onClose, + orgId, + roleRegistryAddress, + meetingFactoryAddress, +}: OkrComposerProps) { + const { address } = useAccount(); + const { roles } = useRolesFromIndexer(orgId); + const setOkrs = useSetOkrs(); + + const ledRoles = useMemo(() => { + if (!address) return []; + const lower = address.toLowerCase(); + return roles.filter((r) => r.leads.some((a) => a.toLowerCase() === lower)); + }, [roles, address]); + + const [selectedRoleId, setSelectedRoleId] = useState(""); + const [quarter, setQuarter] = useState(quarterFromDate(new Date())); + const [drafts, setDrafts] = useState([]); + const [tension, setTension] = useState(""); + + useEffect(() => { + if (ledRoles.length > 0 && !selectedRoleId) { + setSelectedRoleId(ledRoles[0].roleId); + } + }, [ledRoles, selectedRoleId]); + + const selectedRole = useMemo( + () => ledRoles.find((r) => r.roleId === selectedRoleId), + [ledRoles, selectedRoleId], + ); + + const { data: existingObjectives = [], isLoading: loadingExisting } = useOkrObjectives({ + roleRegistryAddress, + orgId: orgId ? BigInt(orgId) : undefined, + circleId: selectedRole ? BigInt(selectedRole.circleId) : undefined, + roleId: selectedRole ? BigInt(selectedRole.roleId) : undefined, + quarter, + }); + + // Seed drafts from existing objectives whenever the (role, quarter) pair changes. + useEffect(() => { + if (loadingExisting) return; + setDrafts(existingObjectives.map(toDraft)); + }, [existingObjectives, loadingExisting, selectedRoleId, quarter]); + + const addObjective = () => { + setDrafts((prev) => [ + ...prev, + { id: makeId(), title: "", description: "", keyResults: [] }, + ]); + }; + const removeObjective = (id: string) => { + setDrafts((prev) => prev.filter((d) => d.id !== id)); + }; + const updateObjective = (id: string, patch: Partial) => { + setDrafts((prev) => prev.map((d) => (d.id === id ? { ...d, ...patch } : d))); + }; + const addKr = (objId: string) => { + setDrafts((prev) => + prev.map((d) => + d.id === objId + ? { ...d, keyResults: [...d.keyResults, { id: makeId(), label: "" }] } + : d, + ), + ); + }; + const removeKr = (objId: string, krId: string) => { + setDrafts((prev) => + prev.map((d) => + d.id === objId + ? { ...d, keyResults: d.keyResults.filter((k) => k.id !== krId) } + : d, + ), + ); + }; + const updateKr = (objId: string, krId: string, label: string) => { + setDrafts((prev) => + prev.map((d) => + d.id === objId + ? { + ...d, + keyResults: d.keyResults.map((k) => + k.id === krId ? { ...k, label } : k, + ), + } + : d, + ), + ); + }; + + const canSubmit = + Boolean(selectedRole) && drafts.every((d) => d.title.trim() !== "") && !setOkrs.isPending; + + const handleSubmit = async () => { + if (!selectedRole) return; + const timestamp = Math.floor(Date.now() / 1000); + const objectives = drafts.map((d) => + fromDraft(d, { + roleId: selectedRole.roleId, + circleId: selectedRole.circleId, + quarter, + timestamp, + }), + ); + + try { + await setOkrs.mutateAsync({ + meetingFactoryAddress, + roleRegistryAddress, + orgId: BigInt(orgId), + circleId: BigInt(selectedRole.circleId), + roleId: BigInt(selectedRole.roleId), + quarter, + objectives, + tension: tension.trim() || undefined, + }); + showToast(`OKR proposal submitted for ${selectedRole.name} (${quarter})`); + onClose(); + } catch (err) { + const message = err instanceof Error ? err.message : "Proposal failed"; + showToast(`OKR proposal failed: ${message}`); + } + }; + + if (!isOpen) return null; + + return ( + + !setOkrs.isPending && onClose()} + > + e.stopPropagation()} + className="relative w-full max-w-xl max-h-[85vh] overflow-hidden rounded-[1.5rem] border border-white/[0.08] bg-[#0b0b0b]/90 shadow-2xl" + > +
+
+ +

Propose OKRs

+
+ +
+ +
+ {!address ? ( +

+ Connect a wallet to propose OKRs. +

+ ) : ledRoles.length === 0 ? ( +

+ You don't currently lead any role in this organization. Only role + leads can raise OKR proposals. +

+ ) : ( + <> +
+ + +
+ + + +
+ {drafts.map((obj, idx) => ( +
+
+

+ Objective {idx + 1} +

+ +
+ + updateObjective(obj.id, { + title: e.target.value, + }) + } + placeholder="Title" + className="mb-2 w-full rounded-lg border border-white/[0.08] bg-white/[0.03] px-3 py-2 text-[13px] font-medium text-white placeholder:text-slate-600" + /> +