# Policy Manager Quick Start
Source: https://docs.chain.link/ace/getting-started/policy-manager
Last Updated: 2026-05-26

> For the complete documentation index, see [llms.txt](/llms.txt).

<AceCallout callout="privateBeta" />

This guide walks you through the **Policy Manager** — the ACE component for attaching and configuring compliance policies on smart contracts. By the end you will have a policy-protected contract running on a supported network.

### 1. Prerequisites

- Solidity basics
- **Must-read before proceeding:** [Signing & Ownership Model](/ace/concepts/signing-ownership) — understand how ACE manages keys, who owns what, and how the delegated trust model works

### 2. Account setup

Complete the [Account Setup](/ace/getting-started/account-setup) steps — organization creation, API key generation, and CRE Connect Wallet deployment — before proceeding.

### 3. Create a PolicyEngine

A **PolicyEngine** is the onchain contract that evaluates compliance rules on your smart contract. When you create a PolicyEngine, you also attach **extractors** — modules that decode transaction calldata so the PolicyEngine can evaluate policies against function arguments (sender, recipient, amount, etc.).

#### Verify deployment

The PolicyEngine and its extractors start with `"creation_pending"` / `"inactive"` status while the onchain transactions are processed. Poll until everything is ready:

```bash
curl https://ace.api.chain.link/v1/policy-engines/<POLICY_ENGINE_ID> \
  -H "Authorization: Apikey <API_KEY>"
```

Check two things in the response:

1. **PolicyEngine deployed** — Every entry in `onchain_policy_engines` shows `"status": "created"`.
2. **Extractors active** — Every entry in `extractor_registrations[].onchain_extractor_registrations` shows `"status": "active"`.

In the Platform UI, confirm the engine status is **Active** and extractors appear in the engine settings page.

> **CAUTION: Deployment failure**
>
> If any chain shows `"status": "creation_failed"`, the onchain deployment did not succeed. Create a new PolicyEngine
> and retry. Contact your Chainlink representative if the issue persists.

#### Save the PolicyEngine addresses

Copy the `address` value from each entry in `onchain_policy_engines` — or from the engine settings page in the UI — you need these addresses to deploy or upgrade your smart contract in the next step. Each chain has a different PolicyEngine contract address.

### 4. Integrate your contract

See [Making Your Contract ACE-Compatible](/ace/guides/policy-manager/contracts/ace-compatible) for a full overview of what your contract needs. In short:

- Inherit from `PolicyProtected` (or `PolicyProtectedUpgradeable` for upgradeable contracts)
- Add the `runPolicy` modifier to the functions you want to protect
- Pass the PolicyEngine address during deployment or initialization

**Choose your path:**

#### New contract

If you are building a new token or contract from scratch, ACE provides reference implementations you can use as a starting point:

- **ERC-20** — see [Building an ERC-20 Compliance Token](/ace/guides/policy-manager/contracts/erc20-token) for the full guide
- **ERC-3643** — see [Building an ERC-3643 Compliance Token](/ace/guides/policy-manager/contracts/erc3643-token) for the full guide

#### Existing contract

If you have an already-deployed contract you want to add ACE compliance to, this involves modifying your implementation contract, testing, and executing a proxy upgrade. This is typically the longest step in the onboarding process.

- See [Upgrading Existing Contracts](/ace/guides/policy-manager/contracts/upgrade-existing) for the step-by-step guide
- Non-upgradeable contracts require alternative approaches — contact your Chainlink representative for guidance

### 5. Register your contract as a target

After deploying your contract, register it as a target under your PolicyEngine. Provide the contract name, type, protected methods, and on-chain addresses for each chain where the contract is deployed.

```bash
curl -X POST https://ace.api.chain.link/v1/targets \
  -H "Content-Type: application/json" \
  -H "Authorization: Apikey <API_KEY>" \
  -d '{
    "title": "My ERC-20 Token",
    "description": "Production ERC-20 token with compliance enforcement",
    "policy_engine_id": "<POLICY_ENGINE_ID>",
    "protected_methods": [
      "transfer(address,uint256)",
      "transferFrom(address,address,uint256)",
      #[any other methods you want to protect]
    ],
    "desired_default_allow": true,
    "metadata": {"contract_type": "ERC-20"},
    "onchain_targets": [
      {
        "chain_selector": "16015286601757825753",
        "address": "0xYourContractAddressOnSepolia"
      },
      {
        "chain_selector": "3478487238524512106",
        "address": "0xYourContractAddressOnArbitrumSepolia"
      },
      #[any other chains where your contract is deployed]
    ]
  }'
```

Include an entry in `onchain_targets` for every chain where you deployed the contract. Once registered, your target appears in the ACE Platform dashboard under your policy engine.

For a full description of all fields and options, see [Managing Targets](/ace/guides/policy-manager/manage-targets#register-a-target).

### 6. Post-setup checklist

Before creating policies, confirm that every component is in the expected state. You can verify each of these with a single API call.

| Check                        | What to look for                                                                                         |
| ---------------------------- | -------------------------------------------------------------------------------------------------------- |
| CRE Connect Wallets created  | `GET /wallets` — every wallet shows `"status": "created"`                                                |
| PolicyEngine deployed        | `GET /policy-engines/<ID>` — every `onchain_policy_engines[].status` is `"created"`                      |
| Extractors active            | Same response — every `extractor_registrations[].onchain_extractor_registrations[].status` is `"active"` |
| Contract visible in platform | Your target contract appears in the ACE Platform dashboard                                               |

### 7. Create and configure policies

From the UI or API, create policy instances and attach them to your contract's protected functions. See [Managing Policies](/ace/guides/policy-manager/manage-policies) for creating and configuring policies, then [Protecting Target Functions](/ace/guides/policy-manager/manage-protections) for attaching them to specific functions on your contracts.

### 8. Test it

Make a transaction against your protected contract, verify the policy enforces correctly, and check the results in the [Reporting Manager](/ace/concepts/reporting).