> ## Documentation Index
> Fetch the complete documentation index at: https://www.dynamic.xyz/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Quorum policies

> Require multiple approvals for wallet and business-account actions with quorum policies.

<Note>
  **Coming soon.** Quorum policies shape below may change before release.
</Note>

Today a rule resolves to `allow` or `deny`. Quorum policies add a third outcome: **require approval**. Instead of blocking an action outright, you can require that other members sign off before it proceeds.

Quorum uses the same `requireApprovals` block everywhere. Set how many approvals are needed and which roles can approve.

```js theme={"system"}
requireApprovals: {
  count: 2,                    // approvals needed, besides the initiator
  from: ['owner', 'admin'],    // roles eligible to approve
}
```

What changes is only where you attach it: to a **policy layer** for wallet activity, or to the **business account** for account changes.

## Wallet actions

Attach `requireApprovals` to a rule on any layer you already use. It composes with the other rule fields, so a threshold and an approval requirement can be one rule:

```js theme={"system"}
await createPolicy({
  scope: { businessAccountId },
  chain: 'EVM',
  chainIds: [1],
  rules: {
    maxPerTransaction: { amount: '500000000000000000' }, // 0.5 ETH, in native units
    requireApprovals: { count: 2, from: ['owner', 'admin'] },
  },
});
```

Because layers only ever tighten, the layer you choose decides who the rule covers:

| Layer         | The rule applies to                              |
| ------------- | ------------------------------------------------ |
| Account-Layer | Every wallet in the business account             |
| Wallet-Layer  | One wallet (a treasury wallet, for example)      |
| Signer-Layer  | One signer's activity, whichever wallet they use |

A Signer-Layer requirement is the way to give one member more oversight than another. Layers cannot exempt anyone: a Signer-Layer can raise a requirement above the Account-Layer, but it can never lower it.

<Info>
  You can attach `requireApprovals` to a rule that has no other restrictions if the only requirement is approvals.
</Info>

## Account actions

Attach `requireApprovals` to the business account, keyed by the action it governs:

```js theme={"system"}
await updateBusinessAccountGovernance({
  businessAccountId,
  actions: {
    addMember:         { requireApprovals: { count: 2, from: ['owner', 'admin'] } },
    addSigner:         { requireApprovals: { count: 1, from: ['owner'] } },
    transferOwnership: { requireApprovals: { count: 2, from: ['owner', 'admin'] } },
  },
});
```

Only the business account **owner** can change these settings.

## How approvals work

The flow is the same for wallet and account actions.

1. A member takes an action as they do today (no new call).
2. If a requirement applies, the action returns a **proposal** instead of completing, and eligible approvers are notified.
3. Each approver reviews the proposal and approves it. Approvals are signed by the approver, so they cannot be forged or reassigned to a different action.
4. Once enough approvals are collected, the action completes.

```js theme={"system"}
// 1. The action returns a proposal instead of completing
const result = await signMessage({ walletAccount, message });

if (result.status === 'awaitingApproval') {
  console.log(result.proposalId, result.required, result.satisfied);
}

// 2. An eligible approver approves it
await approveProposal({ proposalId });

// 3. Once satisfied, the original action completes
await executeProposal({ proposalId });
```

An approval is bound to the exact action that was proposed, so nothing about it can change after the fact. The amount, destination, and wallet are all fixed at proposal time.

<Note>
  A member cannot approve their own proposal, and each member can approve a proposal once.
</Note>

<Info>
  The final flow may complete automatically when the last approval is received, or it may require an explicit `executeProposal` call. The example above shows the explicit version.
</Info>

## What can require approval

|                 | Examples                                                                              |
| --------------- | ------------------------------------------------------------------------------------- |
| Wallet actions  | Signing a transaction, exporting a private key                                        |
| Account actions | Adding or removing a member, changing a role, adding a signer, transferring ownership |

Quorum applies to business accounts only. A personal wallet has no second member to approve.