diff --git a/Cargo.lock b/Cargo.lock
index eaac99e..614650d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1279,6 +1279,18 @@ dependencies = [
  "sp-runtime",
 ]
 
+[[package]]
+name = "fc-pallet-pitch"
+version = "0.1.0"
+dependencies = [
+ "pallet-balances",
+ "parity-scale-codec",
+ "polkadot-sdk-frame",
+ "scale-info",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "fc-pallet-referenda-tracks"
 version = "1.0.0"
diff --git a/pallets/pitch/Cargo.toml b/pallets/pitch/Cargo.toml
new file mode 100644
index 0000000..58c01c9
--- /dev/null
+++ b/pallets/pitch/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+authors.workspace = true
+description = "Ephemeral, consent-gated economic cells keyed by H3 cell references"
+edition.workspace = true
+license.workspace = true
+name = "fc-pallet-pitch"
+repository.workspace = true
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec.workspace = true
+frame.workspace = true
+scale-info.workspace = true
+sp-runtime.workspace = true
+
+[dev-dependencies]
+pallet-balances.workspace = true
+sp-io.workspace = true
+
+[features]
+default = ["std"]
+runtime-benchmarks = [
+	"frame/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
+try-runtime = [
+	"frame/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/pallets/pitch/README.md b/pallets/pitch/README.md
new file mode 100644
index 0000000..491fb38
--- /dev/null
+++ b/pallets/pitch/README.md
@@ -0,0 +1,21 @@
+# Pitch Pallet
+
+`fc-pallet-pitch` records time-boxed economic authority over H3 cells.
+
+A pitch is a short-lived claim over the economic membrane of a place: it can be
+publicly indexed by raw H3 cell, hidden behind a commitment, gated by a
+membership proof, or sealed with only an opaque on-chain residue. The pallet
+does not perform H3 geometry. Clients compute H3 cells off-chain and submit
+either the raw `u64` cell or a commitment.
+
+This first implementation focuses on the minimal consensus surface:
+
+- claim, amend, join, dissolve, and reap a pitch;
+- index public raw-cell pitches for cheap lookup;
+- keep private pitches out of the raw-cell index;
+- record selective disclosure grants without putting the disclosed secret
+  on-chain;
+- derive a deterministic sovereign account for each pitch.
+
+Fee routing, VOS/Noir verification, and off-chain residue transport are intended
+as runtime integrations layered on top of this base.
diff --git a/pallets/pitch/src/lib.rs b/pallets/pitch/src/lib.rs
new file mode 100644
index 0000000..68ef46a
--- /dev/null
+++ b/pallets/pitch/src/lib.rs
@@ -0,0 +1,462 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! # Pitch Pallet
+//!
+//! Time-boxed economic authority over H3 cells, private by default.
+//!
+//! The pallet stores sparse pitch records keyed by raw H3 cell ids or opaque
+//! commitments. H3 geometry remains off-chain; the runtime only stores and
+//! indexes claims.
+
+use frame::prelude::*;
+use sp_runtime::{traits::AccountIdConversion, Permill};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+pub use pallet::*;
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Decode,
+    DecodeWithMemTracking,
+    Encode,
+    MaxEncodedLen,
+    PartialEq,
+    Eq,
+    TypeInfo,
+)]
+pub enum Disclosure {
+    Public,
+    Unlisted,
+    Gated,
+    Sealed,
+}
+
+#[derive(
+    Clone, Debug, Decode, DecodeWithMemTracking, Encode, MaxEncodedLen, PartialEq, Eq, TypeInfo,
+)]
+pub enum CellRef<Hash> {
+    Raw(u64),
+    Commitment(Hash),
+}
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Decode,
+    DecodeWithMemTracking,
+    Encode,
+    MaxEncodedLen,
+    PartialEq,
+    Eq,
+    TypeInfo,
+)]
+pub enum SettlementPolicy<CommunityId> {
+    Holder,
+    Licensor,
+    Members,
+    Community(CommunityId),
+}
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Decode,
+    DecodeWithMemTracking,
+    Encode,
+    MaxEncodedLen,
+    PartialEq,
+    Eq,
+    TypeInfo,
+)]
+pub enum DisclosureScope {
+    Location,
+    Membership,
+    Activity,
+    All,
+}
+
+#[derive(
+    Clone, Debug, Decode, DecodeWithMemTracking, Encode, MaxEncodedLen, PartialEq, Eq, TypeInfo,
+)]
+#[scale_info(skip_type_params(T))]
+#[codec(mel_bound(T: Config))]
+pub struct Pitch<T: Config> {
+    pub disclosure: Disclosure,
+    pub cell: CellRef<T::Hash>,
+    pub resolution: Option<u8>,
+    pub start: BlockNumberFor<T>,
+    pub end: BlockNumberFor<T>,
+    pub holder: T::AccountId,
+    pub licensor: Option<T::CommunityId>,
+    pub local_tax: Permill,
+    pub membership_root: Option<T::Hash>,
+    pub on_dissolve: SettlementPolicy<T::CommunityId>,
+    pub residue: Option<BoundedVec<u8, T::MaxResidueLen>>,
+}
+
+pub type PitchId = u64;
+pub type MembershipProofOf<T> = BoundedVec<u8, <T as pallet::Config>::MaxProofLen>;
+pub type ResidueOf<T> = BoundedVec<u8, <T as pallet::Config>::MaxResidueLen>;
+
+pub trait MembershipVerifier<AccountId, Hash> {
+    fn verify(who: &AccountId, root: &Hash, proof: &[u8]) -> bool;
+}
+
+impl<AccountId, Hash> MembershipVerifier<AccountId, Hash> for () {
+    fn verify(_: &AccountId, _: &Hash, _: &[u8]) -> bool {
+        false
+    }
+}
+
+#[frame::pallet]
+pub mod pallet {
+    use super::*;
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config<RuntimeEvent: From<Event<Self>>> {
+        type WeightInfo: WeightInfo;
+
+        type CommunityId: Parameter + MaxEncodedLen + Copy;
+
+        type Verifier: MembershipVerifier<Self::AccountId, Self::Hash>;
+
+        #[pallet::constant]
+        type PalletId: Get<PalletId>;
+
+        #[pallet::constant]
+        type MaxPitchesPerCell: Get<u32>;
+
+        #[pallet::constant]
+        type MaxProofLen: Get<u32>;
+
+        #[pallet::constant]
+        type MaxResidueLen: Get<u32>;
+
+        #[pallet::constant]
+        type GracePeriod: Get<BlockNumberFor<Self>>;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    pub type NextPitchId<T> = StorageValue<_, PitchId, ValueQuery>;
+
+    #[pallet::storage]
+    pub type Pitches<T: Config> = StorageMap<_, Blake2_128Concat, PitchId, Pitch<T>>;
+
+    #[pallet::storage]
+    pub type ByCell<T: Config> =
+        StorageMap<_, Twox64Concat, u64, BoundedVec<PitchId, T::MaxPitchesPerCell>, ValueQuery>;
+
+    #[pallet::storage]
+    pub type Expiring<T: Config> = StorageMap<
+        _,
+        Twox64Concat,
+        BlockNumberFor<T>,
+        BoundedVec<PitchId, T::MaxPitchesPerCell>,
+        ValueQuery,
+    >;
+
+    #[pallet::storage]
+    pub type Joined<T: Config> = StorageDoubleMap<
+        _,
+        Blake2_128Concat,
+        PitchId,
+        Blake2_128Concat,
+        T::AccountId,
+        (),
+        OptionQuery,
+    >;
+
+    #[pallet::storage]
+    pub type DisclosureGrants<T: Config> = StorageDoubleMap<
+        _,
+        Blake2_128Concat,
+        PitchId,
+        Blake2_128Concat,
+        T::AccountId,
+        DisclosureScope,
+        OptionQuery,
+    >;
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        Claimed {
+            pitch: PitchId,
+            disclosure: Disclosure,
+            holder: T::AccountId,
+        },
+        Joined {
+            pitch: PitchId,
+            who: T::AccountId,
+        },
+        Amended {
+            pitch: PitchId,
+        },
+        Dissolved {
+            pitch: PitchId,
+        },
+        DisclosureGranted {
+            pitch: PitchId,
+            to: T::AccountId,
+            scope: DisclosureScope,
+        },
+        Reaped {
+            pitch: PitchId,
+        },
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        BadCellRef,
+        BadResolution,
+        BadWindow,
+        ExpiryScheduleFull,
+        IndexFull,
+        NotHolder,
+        NotLive,
+        PitchMissing,
+        ProofInvalid,
+        WindowInPast,
+    }
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        #[pallet::weight(T::WeightInfo::claim())]
+        pub fn claim(
+            origin: OriginFor<T>,
+            cell: CellRef<T::Hash>,
+            resolution: Option<u8>,
+            start: BlockNumberFor<T>,
+            end: BlockNumberFor<T>,
+            disclosure: Disclosure,
+            local_tax: Permill,
+            membership_root: Option<T::Hash>,
+            on_dissolve: SettlementPolicy<T::CommunityId>,
+            licensor: Option<T::CommunityId>,
+            residue: Option<ResidueOf<T>>,
+        ) -> DispatchResult {
+            let holder = ensure_signed(origin)?;
+            Self::ensure_cell_matches_disclosure(&cell, disclosure)?;
+            Self::ensure_resolution(&cell, resolution)?;
+            Self::ensure_window(start, end)?;
+
+            let pitch = NextPitchId::<T>::get();
+            let record = Pitch::<T> {
+                disclosure,
+                cell: cell.clone(),
+                resolution,
+                start,
+                end,
+                holder: holder.clone(),
+                licensor,
+                local_tax,
+                membership_root,
+                on_dissolve,
+                residue,
+            };
+
+            Pitches::<T>::insert(pitch, record);
+            NextPitchId::<T>::put(pitch.checked_add(1).ok_or(ArithmeticError::Overflow)?);
+            Self::index_pitch(pitch, &cell)?;
+            Expiring::<T>::try_mutate(end.saturating_add(T::GracePeriod::get()), |ids| {
+                ids.try_push(pitch)
+                    .map_err(|_| Error::<T>::ExpiryScheduleFull)
+            })?;
+
+            Self::deposit_event(Event::Claimed {
+                pitch,
+                disclosure,
+                holder,
+            });
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(T::WeightInfo::join())]
+        pub fn join(
+            origin: OriginFor<T>,
+            pitch: PitchId,
+            proof: MembershipProofOf<T>,
+        ) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+            let record = Pitches::<T>::get(pitch).ok_or(Error::<T>::PitchMissing)?;
+            ensure!(Self::is_live(&record), Error::<T>::NotLive);
+
+            if let Some(root) = record.membership_root {
+                ensure!(
+                    T::Verifier::verify(&who, &root, proof.as_slice()),
+                    Error::<T>::ProofInvalid
+                );
+            }
+
+            Joined::<T>::insert(pitch, &who, ());
+            Self::deposit_event(Event::Joined { pitch, who });
+            Ok(())
+        }
+
+        #[pallet::call_index(2)]
+        #[pallet::weight(T::WeightInfo::amend())]
+        pub fn amend(
+            origin: OriginFor<T>,
+            pitch: PitchId,
+            local_tax: Option<Permill>,
+            membership_root: Option<Option<T::Hash>>,
+            end: Option<BlockNumberFor<T>>,
+            residue: Option<Option<ResidueOf<T>>>,
+        ) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+            Pitches::<T>::try_mutate(pitch, |maybe_record| {
+                let record = maybe_record.as_mut().ok_or(Error::<T>::PitchMissing)?;
+                ensure!(record.holder == who, Error::<T>::NotHolder);
+                ensure!(Self::is_live(record), Error::<T>::NotLive);
+
+                if let Some(local_tax) = local_tax {
+                    record.local_tax = local_tax;
+                }
+                if let Some(membership_root) = membership_root {
+                    record.membership_root = membership_root;
+                }
+                if let Some(new_end) = end {
+                    ensure!(record.start < new_end, Error::<T>::BadWindow);
+                    record.end = new_end;
+                    Expiring::<T>::try_mutate(
+                        new_end.saturating_add(T::GracePeriod::get()),
+                        |ids| {
+                            if !ids.contains(&pitch) {
+                                ids.try_push(pitch)
+                                    .map_err(|_| Error::<T>::ExpiryScheduleFull)?;
+                            }
+                            Ok::<_, DispatchError>(())
+                        },
+                    )?;
+                }
+                if let Some(residue) = residue {
+                    record.residue = residue;
+                }
+
+                Ok::<_, DispatchError>(())
+            })?;
+
+            Self::deposit_event(Event::Amended { pitch });
+            Ok(())
+        }
+
+        #[pallet::call_index(3)]
+        #[pallet::weight(T::WeightInfo::dissolve())]
+        pub fn dissolve(origin: OriginFor<T>, pitch: PitchId) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+            let record = Pitches::<T>::get(pitch).ok_or(Error::<T>::PitchMissing)?;
+            ensure!(record.holder == who, Error::<T>::NotHolder);
+            Self::remove_pitch(pitch, &record);
+            Self::deposit_event(Event::Dissolved { pitch });
+            Ok(())
+        }
+
+        #[pallet::call_index(4)]
+        #[pallet::weight(T::WeightInfo::grant_disclosure())]
+        pub fn grant_disclosure(
+            origin: OriginFor<T>,
+            pitch: PitchId,
+            to: T::AccountId,
+            scope: DisclosureScope,
+        ) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+            let record = Pitches::<T>::get(pitch).ok_or(Error::<T>::PitchMissing)?;
+            ensure!(record.holder == who, Error::<T>::NotHolder);
+
+            DisclosureGrants::<T>::insert(pitch, &to, scope);
+            Self::deposit_event(Event::DisclosureGranted { pitch, to, scope });
+            Ok(())
+        }
+
+        #[pallet::call_index(5)]
+        #[pallet::weight(T::WeightInfo::reap())]
+        pub fn reap(origin: OriginFor<T>, pitch: PitchId) -> DispatchResult {
+            ensure_signed(origin)?;
+            let record = Pitches::<T>::get(pitch).ok_or(Error::<T>::PitchMissing)?;
+            let now = frame_system::Pallet::<T>::block_number();
+            ensure!(
+                now >= record.end.saturating_add(T::GracePeriod::get()),
+                Error::<T>::NotLive
+            );
+            Self::remove_pitch(pitch, &record);
+            Self::deposit_event(Event::Reaped { pitch });
+            Ok(())
+        }
+    }
+
+    impl<T: Config> Pallet<T> {
+        pub fn pitch_account(pitch: PitchId) -> T::AccountId {
+            T::PalletId::get().into_sub_account_truncating((pitch, b"pitch"))
+        }
+
+        fn ensure_cell_matches_disclosure(
+            cell: &CellRef<T::Hash>,
+            disclosure: Disclosure,
+        ) -> DispatchResult {
+            match (disclosure, cell) {
+                (Disclosure::Public, CellRef::Raw(_)) => Ok(()),
+                (Disclosure::Unlisted | Disclosure::Sealed, CellRef::Commitment(_)) => Ok(()),
+                (Disclosure::Gated, CellRef::Raw(_) | CellRef::Commitment(_)) => Ok(()),
+                _ => Err(Error::<T>::BadCellRef.into()),
+            }
+        }
+
+        fn ensure_resolution(cell: &CellRef<T::Hash>, resolution: Option<u8>) -> DispatchResult {
+            match (cell, resolution) {
+                (CellRef::Raw(_), Some(resolution)) if resolution <= 15 => Ok(()),
+                (CellRef::Commitment(_), None) => Ok(()),
+                _ => Err(Error::<T>::BadResolution.into()),
+            }
+        }
+
+        fn ensure_window(start: BlockNumberFor<T>, end: BlockNumberFor<T>) -> DispatchResult {
+            let now = frame_system::Pallet::<T>::block_number();
+            ensure!(start >= now, Error::<T>::WindowInPast);
+            ensure!(start < end, Error::<T>::BadWindow);
+            Ok(())
+        }
+
+        fn is_live(record: &Pitch<T>) -> bool {
+            let now = frame_system::Pallet::<T>::block_number();
+            record.start <= now && now < record.end
+        }
+
+        fn index_pitch(pitch: PitchId, cell: &CellRef<T::Hash>) -> DispatchResult {
+            if let CellRef::Raw(cell) = cell {
+                ByCell::<T>::try_mutate(cell, |ids| {
+                    ids.try_push(pitch).map_err(|_| Error::<T>::IndexFull)
+                })?;
+            }
+            Ok(())
+        }
+
+        fn remove_pitch(pitch: PitchId, record: &Pitch<T>) {
+            if let CellRef::Raw(cell) = record.cell {
+                ByCell::<T>::mutate(cell, |ids| {
+                    if let Some(pos) = ids.iter().position(|id| *id == pitch) {
+                        ids.remove(pos);
+                    }
+                });
+            }
+            Pitches::<T>::remove(pitch);
+            let _ = Joined::<T>::clear_prefix(pitch, u32::MAX, None);
+            let _ = DisclosureGrants::<T>::clear_prefix(pitch, u32::MAX, None);
+        }
+    }
+}
diff --git a/pallets/pitch/src/mock.rs b/pallets/pitch/src/mock.rs
new file mode 100644
index 0000000..cf89e3f
--- /dev/null
+++ b/pallets/pitch/src/mock.rs
@@ -0,0 +1,83 @@
+pub use crate::{self as fc_pallet_pitch, *};
+use frame::{
+    deps::{frame_support::parameter_types, sp_core::H256, sp_runtime::BuildStorage},
+    testing_prelude::*,
+};
+
+pub type AccountId = u64;
+pub type BlockNumber = u64;
+pub type CommunityId = u32;
+
+pub const HOLDER: AccountId = 1;
+pub const MEMBER: AccountId = 2;
+pub const OUTSIDER: AccountId = 3;
+pub const CELL: u64 = 0x87283082bffffff;
+pub const ROOT: H256 = H256::repeat_byte(42);
+
+#[frame_construct_runtime]
+pub mod runtime {
+    #[runtime::runtime]
+    #[runtime::derive(
+        RuntimeCall,
+        RuntimeEvent,
+        RuntimeError,
+        RuntimeOrigin,
+        RuntimeTask,
+        RuntimeHoldReason,
+        RuntimeFreezeReason
+    )]
+    pub struct Test;
+
+    #[runtime::pallet_index(0)]
+    pub type System = frame_system;
+    #[runtime::pallet_index(10)]
+    pub type Balances = pallet_balances;
+    #[runtime::pallet_index(20)]
+    pub type Pitch = fc_pallet_pitch;
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type Block = MockBlock<Test>;
+    type AccountData = pallet_balances::AccountData<u64>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+pub struct TestVerifier;
+impl MembershipVerifier<AccountId, H256> for TestVerifier {
+    fn verify(who: &AccountId, root: &H256, proof: &[u8]) -> bool {
+        *who == MEMBER && *root == ROOT && proof == b"member"
+    }
+}
+
+parameter_types! {
+    pub PitchPalletId: PalletId = PalletId(*b"pitch___");
+    pub const MaxPitchesPerCell: u32 = 4;
+    pub const MaxProofLen: u32 = 32;
+    pub const MaxResidueLen: u32 = 128;
+    pub const GracePeriod: BlockNumber = 2;
+}
+
+impl Config for Test {
+    type WeightInfo = ();
+    type CommunityId = CommunityId;
+    type Verifier = TestVerifier;
+    type PalletId = PitchPalletId;
+    type MaxPitchesPerCell = MaxPitchesPerCell;
+    type MaxProofLen = MaxProofLen;
+    type MaxResidueLen = MaxResidueLen;
+    type GracePeriod = GracePeriod;
+}
+
+pub fn new_test_ext() -> TestExternalities {
+    let storage = frame_system::GenesisConfig::<Test>::default()
+        .build_storage()
+        .unwrap();
+    let mut ext = TestExternalities::new(storage);
+    ext.execute_with(|| System::set_block_number(1));
+    ext
+}
diff --git a/pallets/pitch/src/tests.rs b/pallets/pitch/src/tests.rs
new file mode 100644
index 0000000..c0511bb
--- /dev/null
+++ b/pallets/pitch/src/tests.rs
@@ -0,0 +1,210 @@
+use crate::{
+    mock::*, ByCell, CellRef, Disclosure, DisclosureGrants, Error, Event, Joined, Pitches,
+    SettlementPolicy,
+};
+use frame::deps::frame_support::{assert_noop, assert_ok};
+use frame::deps::sp_core::H256;
+use sp_runtime::{BoundedVec, Permill};
+
+fn claim_public() {
+    assert_ok!(Pitch::claim(
+        RuntimeOrigin::signed(HOLDER),
+        CellRef::Raw(CELL),
+        Some(7),
+        1,
+        10,
+        Disclosure::Public,
+        Permill::from_percent(2),
+        None,
+        SettlementPolicy::Holder,
+        None,
+        None,
+    ));
+}
+
+#[test]
+fn public_pitch_is_claimed_and_indexed_by_cell() {
+    new_test_ext().execute_with(|| {
+        claim_public();
+
+        let pitch = Pitches::<Test>::get(0).unwrap();
+        assert_eq!(pitch.holder, HOLDER);
+        assert_eq!(pitch.cell, CellRef::Raw(CELL));
+        assert_eq!(ByCell::<Test>::get(CELL).as_slice(), &[0]);
+
+        System::assert_last_event(
+            Event::Claimed {
+                pitch: 0,
+                disclosure: Disclosure::Public,
+                holder: HOLDER,
+            }
+            .into(),
+        );
+    });
+}
+
+#[test]
+fn committed_pitch_is_not_indexed_by_raw_cell() {
+    new_test_ext().execute_with(|| {
+        assert_ok!(Pitch::claim(
+            RuntimeOrigin::signed(HOLDER),
+            CellRef::Commitment(H256::repeat_byte(7)),
+            None,
+            1,
+            10,
+            Disclosure::Sealed,
+            Permill::zero(),
+            None,
+            SettlementPolicy::Holder,
+            None,
+            Some(BoundedVec::try_from(b"sealed-residue".to_vec()).unwrap()),
+        ));
+
+        assert_eq!(ByCell::<Test>::get(CELL).len(), 0);
+        assert_eq!(
+            Pitches::<Test>::get(0).unwrap().cell,
+            CellRef::Commitment(H256::repeat_byte(7))
+        );
+    });
+}
+
+#[test]
+fn validates_disclosure_and_resolution() {
+    new_test_ext().execute_with(|| {
+        assert_noop!(
+            Pitch::claim(
+                RuntimeOrigin::signed(HOLDER),
+                CellRef::Commitment(H256::repeat_byte(1)),
+                None,
+                1,
+                10,
+                Disclosure::Public,
+                Permill::zero(),
+                None,
+                SettlementPolicy::Holder,
+                None,
+                None,
+            ),
+            Error::<Test>::BadCellRef,
+        );
+
+        assert_noop!(
+            Pitch::claim(
+                RuntimeOrigin::signed(HOLDER),
+                CellRef::Raw(CELL),
+                Some(16),
+                1,
+                10,
+                Disclosure::Public,
+                Permill::zero(),
+                None,
+                SettlementPolicy::Holder,
+                None,
+                None,
+            ),
+            Error::<Test>::BadResolution,
+        );
+    });
+}
+
+#[test]
+fn gated_pitch_requires_valid_membership_proof() {
+    new_test_ext().execute_with(|| {
+        assert_ok!(Pitch::claim(
+            RuntimeOrigin::signed(HOLDER),
+            CellRef::Raw(CELL),
+            Some(7),
+            1,
+            10,
+            Disclosure::Gated,
+            Permill::zero(),
+            Some(ROOT),
+            SettlementPolicy::Holder,
+            None,
+            None,
+        ));
+
+        assert_noop!(
+            Pitch::join(
+                RuntimeOrigin::signed(OUTSIDER),
+                0,
+                BoundedVec::try_from(b"member".to_vec()).unwrap(),
+            ),
+            Error::<Test>::ProofInvalid,
+        );
+
+        assert_ok!(Pitch::join(
+            RuntimeOrigin::signed(MEMBER),
+            0,
+            BoundedVec::try_from(b"member".to_vec()).unwrap(),
+        ));
+        assert!(Joined::<Test>::contains_key(0, MEMBER));
+    });
+}
+
+#[test]
+fn holder_can_amend_and_grant_disclosure() {
+    new_test_ext().execute_with(|| {
+        claim_public();
+
+        assert_ok!(Pitch::amend(
+            RuntimeOrigin::signed(HOLDER),
+            0,
+            Some(Permill::from_percent(5)),
+            Some(Some(ROOT)),
+            Some(12),
+            None,
+        ));
+        assert_eq!(
+            Pitches::<Test>::get(0).unwrap().local_tax,
+            Permill::from_percent(5)
+        );
+        assert_eq!(Pitches::<Test>::get(0).unwrap().end, 12);
+
+        assert_ok!(Pitch::grant_disclosure(
+            RuntimeOrigin::signed(HOLDER),
+            0,
+            MEMBER,
+            crate::DisclosureScope::Location,
+        ));
+        assert_eq!(
+            DisclosureGrants::<Test>::get(0, MEMBER),
+            Some(crate::DisclosureScope::Location)
+        );
+    });
+}
+
+#[test]
+fn dissolve_removes_pitch_and_public_index() {
+    new_test_ext().execute_with(|| {
+        claim_public();
+        assert_ok!(Pitch::dissolve(RuntimeOrigin::signed(HOLDER), 0));
+
+        assert!(Pitches::<Test>::get(0).is_none());
+        assert_eq!(ByCell::<Test>::get(CELL).len(), 0);
+    });
+}
+
+#[test]
+fn reap_only_after_grace_period() {
+    new_test_ext().execute_with(|| {
+        claim_public();
+
+        System::set_block_number(11);
+        assert_noop!(
+            Pitch::reap(RuntimeOrigin::signed(OUTSIDER), 0),
+            Error::<Test>::NotLive,
+        );
+
+        System::set_block_number(12);
+        assert_ok!(Pitch::reap(RuntimeOrigin::signed(OUTSIDER), 0));
+        assert!(Pitches::<Test>::get(0).is_none());
+    });
+}
+
+#[test]
+fn derives_stable_pitch_account() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(Pitch::pitch_account(0), Pitch::pitch_account(0));
+    });
+}
diff --git a/pallets/pitch/src/weights.rs b/pallets/pitch/src/weights.rs
new file mode 100644
index 0000000..bcd07a1
--- /dev/null
+++ b/pallets/pitch/src/weights.rs
@@ -0,0 +1,58 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use core::marker::PhantomData;
+use frame::deps::{frame_support::weights::Weight, frame_system};
+
+pub trait WeightInfo {
+	fn claim() -> Weight;
+	fn join() -> Weight;
+	fn amend() -> Weight;
+	fn dissolve() -> Weight;
+	fn grant_disclosure() -> Weight;
+	fn reap() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn claim() -> Weight {
+		Weight::from_parts(20_000_000, 0)
+	}
+	fn join() -> Weight {
+		Weight::from_parts(10_000_000, 0)
+	}
+	fn amend() -> Weight {
+		Weight::from_parts(15_000_000, 0)
+	}
+	fn dissolve() -> Weight {
+		Weight::from_parts(15_000_000, 0)
+	}
+	fn grant_disclosure() -> Weight {
+		Weight::from_parts(10_000_000, 0)
+	}
+	fn reap() -> Weight {
+		Weight::from_parts(15_000_000, 0)
+	}
+}
+
+impl WeightInfo for () {
+	fn claim() -> Weight {
+		Weight::from_parts(20_000_000, 0)
+	}
+	fn join() -> Weight {
+		Weight::from_parts(10_000_000, 0)
+	}
+	fn amend() -> Weight {
+		Weight::from_parts(15_000_000, 0)
+	}
+	fn dissolve() -> Weight {
+		Weight::from_parts(15_000_000, 0)
+	}
+	fn grant_disclosure() -> Weight {
+		Weight::from_parts(10_000_000, 0)
+	}
+	fn reap() -> Weight {
+		Weight::from_parts(15_000_000, 0)
+	}
+}