# Base Mainnet Bonds-only Pre-deployment Manifest

This directory contains an **offline, unsigned, non-broadcast** pre-deployment
artifact for Base mainnet (`8453`). It is not a deployment plan authorization,
does not access a wallet, and cannot create a transaction.

## Mission boundary

This pilot treats morals over metrics, privacy over surveillance, and freedom
over control as release constraints. Its economic objective is to make human
thriving more profitable than extraction.

Flourishing measurements are optional and privacy-minimized. They cannot
determine eligibility, change principal, trigger or increase slashing, decide a
breach, or become a condition of withdrawal. The bonds-only package does not
deploy validation, reputation, reward, surveillance, Solana, or cross-chain
modules, and the manifest validator rejects any change to these mission
constraints.

## Enabled scope

Only these components are represented:

- `MultisigGovernanceV3` (3-of-5; 24-hour timelock)
- `BasePilotAccessControllerV3`
- `ThresholdConsensusV3`
- `DisputeRegistryV3`
- `SafeBondFactoryV3`
- separately deployed `PartnershipBondFactoryV3` and
  `AccountabilityBondFactoryV3`, bound once through a confirmed and timelocked
  `configureFactories(address,address)` governance proposal after their
  immutable-patched runtime hashes have been pinned in the coordinator
  constructor
- `PartnershipBondV3Safe` and `AccountabilityBondV3Safe` as factory-created
  child types
- no identity, evidence, or mandate adapter: none is required by the enabled
  contracts in this manifest

`RewardProgramV3`, `TaskEscrowV3`, `MutualAidPoolV3`, `VaultfireBIPVaultV3`,
validation/reputation, identity, evidence, and mandate modules, Solana, and cross-chain are explicitly disabled
and are not deployment entries.

## Safety properties

- Controller ceilings are hard-bounded at `0.40 ETH` global and `0.20 ETH` per
  position by constructor-pinned `maxGlobalCap` and `maxPerPositionCap`
  immutables. Governance may lower configured caps and later restore them only
  up to those fresh-deployment maxima. Bond aggregate caps do not exceed the
  per-position ceiling.
- The checked-in source/evidence commits, Git trees, archive SHA-256 hashes,
  and external audit/Sepolia/x402 references are deliberately null. Run
  `finalize_bonds_only_manifest.py` against the reviewed integration repository
  to derive and bind them deterministically; historical review/validation
  hashes are not final-release inputs.
- Compiler settings, manifest payload hash, deployment order, constructor
  arguments, CREATE nonce derivation, approval state, and post-deployment
  assertions are bound in `base_v3_deployment_manifest.json`.
- Checked-in human/owner fields are null or empty. The checked-in intake is
  public-address-only and refuses secret/signing-material fields.
- Bytecode hashes and expected addresses are deliberately `null` in the review
  manifest because no compiler artifact, public deployer, or nonce has been
  approved. The package generator calculates and binds those values from clean
  Foundry artifacts and a supplied public address/nonce; it never invents them.
  The generated package derives the specialized-factory and child runtime
  hashes after patching every Solidity immutable reference, passes all four
  hashes to the fresh `SafeBondFactoryV3` constructor, and verifies each child
  hash before controller registration. `EIP712BaseV3` derives its
  verifying-contract domain separator at call time, preserving its EIP-712
  output while avoiding an address-specific cached immutable in child runtime
  bytecode. Its inherited `_VERSION_HASH=keccak256(bytes("3.0.0"))` immutable
  is also patched into the child code identity; one reviewed immutable-patched
  child hash therefore remains valid
  for every fresh child of the same type and reviewed constructor bindings.
- ABI/storage impact: `BasePilotAccessControllerV3` adds two immutable
  maximum-cap constructor arguments and public getters. Relative to the prior
  V3 coordinator constructor, `SafeBondFactoryV3` adds four `bytes32`
  expected-runtime-hash arguments and
  the one-time `configureFactories(address,address)` entry point/event. Its
  specialized-factory references are storage rather than constructor-created
  immutables so they can be bound once after code-hash verification.
  `EIP712BaseV3.DOMAIN_SEPARATOR()` keeps the same ABI and domain semantics.
  These are fresh-deployment-only changes: no proxy upgrade, storage-layout
  migration, or in-place alteration of V2 is assumed.
- The seven deployment transactions are followed by an unsigned governed
  configuration payload. Factory deployment cannot be enabled until governance
  has confirmed, timelocked, executed, and independently verified that binding.

## Guardian pause-target dependency

`MultisigGovernanceV3` rejects targets without code, while child bond addresses
do not exist at governance construction. The manifest therefore uses an empty
constructor target list—not a placeholder—and requires the reviewed post-deploy
flow for each actual child bond:

1. Verify the child is a `PartnershipBondV3Safe` or `AccountabilityBondV3Safe`,
   has code, is owned by governance, and exposes `pause()`.
2. Submit and confirm a governance self-call to
   `addGuardianPauseTarget(actualChildAddress)`.
3. Wait the 24-hour timelock, execute it, and independently verify the target
   is allowlisted before treating the bond as pause-protected.

The actual target is only allowed after code exists. No zero, example, or
symbolic address is executable. BOND-03 remains a fail-closed
post-deployment assertion, not an on-chain atomic enforcement claim: the
current governance contract accepts one target call per proposal rather than
an atomic batch.

## BOND-02 reward exclusion

`RewardProgramV3` is not a bootstrap/deployment entry and has no address, cap,
constructor argument, or dependency in this path. The child-bond policy binds
the partnership `rewardProgram` argument to `address(0)` and rejects reward
terms; each bond is capped at exactly `0.02 ETH`.

## Offline validation

```bash
python3 pr8/pilot/deployment_manifest.py
python3 -m unittest pr8/pilot/test_deployment_manifest.py -v
```

Finalize provenance only after integration with:

```bash
python3 pr8/pilot/finalize_bonds_only_manifest.py \
  --repository /reviewed/repository \
  --source-commit <reviewed-source-commit> \
  --evidence-commit <reviewed-evidence-commit> \
  --out /reviewed/finalization-candidate.json
```

For an owner-supplied, public-address-only intake and clean Foundry `out/`
artifacts, `generate_bonds_only_package.py` creates an unsigned data package.
It requires an explicit approval record, validates 3-of-5 public signers,
separate guardian, exactly one partner, attesters/adjudicators, clean constructor
ABIs, and the deployer nonce assumption. It does not sign or broadcast.

## Remaining blockers

The checked-in manifest intentionally remains non-deployable: no owner public
addresses, no explicit approval evidence, no clean `solc 0.8.24` artifacts,
no reviewed deployer/nonce, and no actual post-deployment runtime/constructor
assertions are available. Audit, Sepolia, and x402 records are path/hash-bound
but marked unsatisfied; they cannot be promoted by this tooling.
