6. Smart Contract Specification

6.1 Exhibition Contract

The Exhibition contract manages the registry of circulating exhibitions. Critically, no transfer function exists—exhibitions are permanently bound to their creating artist.

use cosmwasm_std::{
    entry_point, to_json_binary, Binary, Deps, DepsMut, Env, 
    MessageInfo, Response, StdError, StdResult, Addr, Timestamp, Uint128,
};
use cw_storage_plus::{Item, Map};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

// ============================================================================
// STATE DEFINITIONS
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
    pub admin: Addr,
    pub license_contract: Addr,
    pub governance_contract: Addr,
    pub next_exhibition_id: u64,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Exhibition {
    pub id: u64,
    pub artist: Addr,
    pub curator: Addr,
    pub title: String,
    pub metadata_uri: String,        // IPFS hash
    pub content_hash: String,        // SHA-256 of primary media
    pub created_at: Timestamp,
    pub total_licenses: u64,
    pub active_licenses: u64,
    pub lifetime_revenue: Uint128,
    pub status: ExhibitionStatus,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum ExhibitionStatus {
    Draft,
    Active,
    Paused,      // Artist can pause licensing temporarily
    Archived,    // No new licenses, existing honored
}

pub const CONFIG: Item<Config> = Item::new("config");
pub const EXHIBITIONS: Map<u64, Exhibition> = Map::new("exhibitions");
pub const ARTIST_EXHIBITIONS: Map<&Addr, Vec<u64>> = Map::new("artist_exhibitions");
pub const CURATOR_EXHIBITIONS: Map<&Addr, Vec<u64>> = Map::new("curator_exhibitions");

// ============================================================================
// INSTANTIATE
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
    pub license_contract: String,
    pub governance_contract: String,
}

#[entry_point]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult<Response> {
    let config = Config {
        admin: info.sender.clone(),
        license_contract: deps.api.addr_validate(&msg.license_contract)?,
        governance_contract: deps.api.addr_validate(&msg.governance_contract)?,
        next_exhibition_id: 1,
    };
    CONFIG.save(deps.storage, &config)?;
    
    Ok(Response::new()
        .add_attribute("method", "instantiate")
        .add_attribute("admin", info.sender))
}

// ============================================================================
// EXECUTE MESSAGES
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    // Artist creates new exhibition
    CreateExhibition {
        title: String,
        curator: String,
        metadata_uri: String,
        content_hash: String,
    },
    // Artist updates metadata (not content hash - immutable)
    UpdateMetadata {
        exhibition_id: u64,
        metadata_uri: String,
    },
    // Artist controls availability
    SetStatus {
        exhibition_id: u64,
        status: ExhibitionStatus,
    },
    // Called by License contract to update stats
    RecordLicense {
        exhibition_id: u64,
        fee_amount: Uint128,
    },
    // Called by License contract when license completes
    CompleteLicense {
        exhibition_id: u64,
    },
    // NOTE: No Transfer message - by design
    // NOTE: No Burn message - exhibitions are permanent records
}

#[entry_point]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::CreateExhibition { title, curator, metadata_uri, content_hash } => {
            execute_create_exhibition(deps, env, info, title, curator, metadata_uri, content_hash)
        }
        ExecuteMsg::UpdateMetadata { exhibition_id, metadata_uri } => {
            execute_update_metadata(deps, info, exhibition_id, metadata_uri)
        }
        ExecuteMsg::SetStatus { exhibition_id, status } => {
            execute_set_status(deps, info, exhibition_id, status)
        }
        ExecuteMsg::RecordLicense { exhibition_id, fee_amount } => {
            execute_record_license(deps, info, exhibition_id, fee_amount)
        }
        ExecuteMsg::CompleteLicense { exhibition_id } => {
            execute_complete_license(deps, info, exhibition_id)
        }
    }
}

fn execute_create_exhibition(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    title: String,
    curator: String,
    metadata_uri: String,
    content_hash: String,
) -> Result<Response, ContractError> {
    let mut config = CONFIG.load(deps.storage)?;
    let curator_addr = deps.api.addr_validate(&curator)?;
    
    let exhibition = Exhibition {
        id: config.next_exhibition_id,
        artist: info.sender.clone(),
        curator: curator_addr.clone(),
        title: title.clone(),
        metadata_uri,
        content_hash,
        created_at: env.block.time,
        total_licenses: 0,
        active_licenses: 0,
        lifetime_revenue: Uint128::zero(),
        status: ExhibitionStatus::Draft,
    };
    
    EXHIBITIONS.save(deps.storage, config.next_exhibition_id, &exhibition)?;
    
    // Update artist index
    let mut artist_exh = ARTIST_EXHIBITIONS
        .may_load(deps.storage, &info.sender)?
        .unwrap_or_default();
    artist_exh.push(config.next_exhibition_id);
    ARTIST_EXHIBITIONS.save(deps.storage, &info.sender, &artist_exh)?;
    
    // Update curator index
    let mut curator_exh = CURATOR_EXHIBITIONS
        .may_load(deps.storage, &curator_addr)?
        .unwrap_or_default();
    curator_exh.push(config.next_exhibition_id);
    CURATOR_EXHIBITIONS.save(deps.storage, &curator_addr, &curator_exh)?;
    
    config.next_exhibition_id += 1;
    CONFIG.save(deps.storage, &config)?;
    
    Ok(Response::new()
        .add_attribute("method", "create_exhibition")
        .add_attribute("exhibition_id", exhibition.id.to_string())
        .add_attribute("artist", info.sender)
        .add_attribute("title", title))
}

fn execute_update_metadata(
    deps: DepsMut,
    info: MessageInfo,
    exhibition_id: u64,
    metadata_uri: String,
) -> Result<Response, ContractError> {
    let mut exhibition = EXHIBITIONS.load(deps.storage, exhibition_id)?;
    
    // Only artist can update metadata
    if info.sender != exhibition.artist {
        return Err(ContractError::Unauthorized {});
    }
    
    exhibition.metadata_uri = metadata_uri;
    EXHIBITIONS.save(deps.storage, exhibition_id, &exhibition)?;
    
    Ok(Response::new()
        .add_attribute("method", "update_metadata")
        .add_attribute("exhibition_id", exhibition_id.to_string()))
}

fn execute_set_status(
    deps: DepsMut,
    info: MessageInfo,
    exhibition_id: u64,
    status: ExhibitionStatus,
) -> Result<Response, ContractError> {
    let mut exhibition = EXHIBITIONS.load(deps.storage, exhibition_id)?;
    
    // Only artist can change status
    if info.sender != exhibition.artist {
        return Err(ContractError::Unauthorized {});
    }
    
    exhibition.status = status.clone();
    EXHIBITIONS.save(deps.storage, exhibition_id, &exhibition)?;
    
    Ok(Response::new()
        .add_attribute("method", "set_status")
        .add_attribute("exhibition_id", exhibition_id.to_string())
        .add_attribute("status", format!("{:?}", status)))
}

fn execute_record_license(
    deps: DepsMut,
    info: MessageInfo,
    exhibition_id: u64,
    fee_amount: Uint128,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    
    // Only license contract can record
    if info.sender != config.license_contract {
        return Err(ContractError::Unauthorized {});
    }
    
    let mut exhibition = EXHIBITIONS.load(deps.storage, exhibition_id)?;
    exhibition.total_licenses += 1;
    exhibition.active_licenses += 1;
    exhibition.lifetime_revenue += fee_amount;
    EXHIBITIONS.save(deps.storage, exhibition_id, &exhibition)?;
    
    Ok(Response::new()
        .add_attribute("method", "record_license")
        .add_attribute("exhibition_id", exhibition_id.to_string()))
}

fn execute_complete_license(
    deps: DepsMut,
    info: MessageInfo,
    exhibition_id: u64,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    
    if info.sender != config.license_contract {
        return Err(ContractError::Unauthorized {});
    }
    
    let mut exhibition = EXHIBITIONS.load(deps.storage, exhibition_id)?;
    exhibition.active_licenses = exhibition.active_licenses.saturating_sub(1);
    EXHIBITIONS.save(deps.storage, exhibition_id, &exhibition)?;
    
    Ok(Response::new()
        .add_attribute("method", "complete_license")
        .add_attribute("exhibition_id", exhibition_id.to_string()))
}

// ============================================================================
// QUERY MESSAGES
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    GetExhibition { exhibition_id: u64 },
    GetArtistExhibitions { artist: String },
    GetCuratorExhibitions { curator: String },
    ListActiveExhibitions { start_after: Option<u64>, limit: Option<u32> },
    GetConfig {},
}

#[entry_point]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
    match msg {
        QueryMsg::GetExhibition { exhibition_id } => {
            to_json_binary(&EXHIBITIONS.load(deps.storage, exhibition_id)?)
        }
        QueryMsg::GetArtistExhibitions { artist } => {
            let addr = deps.api.addr_validate(&artist)?;
            let ids = ARTIST_EXHIBITIONS.may_load(deps.storage, &addr)?.unwrap_or_default();
            to_json_binary(&ids)
        }
        QueryMsg::GetCuratorExhibitions { curator } => {
            let addr = deps.api.addr_validate(&curator)?;
            let ids = CURATOR_EXHIBITIONS.may_load(deps.storage, &addr)?.unwrap_or_default();
            to_json_binary(&ids)
        }
        QueryMsg::ListActiveExhibitions { start_after, limit } => {
            let limit = limit.unwrap_or(30).min(100) as usize;
            let start = start_after.unwrap_or(0);
            
            let exhibitions: Vec<Exhibition> = EXHIBITIONS
                .range(deps.storage, None, None, cosmwasm_std::Order::Ascending)
                .filter(|r| {
                    if let Ok((id, exh)) = r {
                        *id > start && exh.status == ExhibitionStatus::Active
                    } else {
                        false
                    }
                })
                .take(limit)
                .filter_map(|r| r.ok().map(|(_, e)| e))
                .collect();
            
            to_json_binary(&exhibitions)
        }
        QueryMsg::GetConfig {} => to_json_binary(&CONFIG.load(deps.storage)?),
    }
}

// ============================================================================
// ERRORS
// ============================================================================

#[derive(Debug)]
pub enum ContractError {
    Std(StdError),
    Unauthorized {},
    ExhibitionNotFound {},
    InvalidStatus {},
}

impl From<StdError> for ContractError {
    fn from(err: StdError) -> Self {
        ContractError::Std(err)
    }
}

6.2 License Contract

The License contract manages time-bound exhibition licenses. Like exhibitions, licenses are non-transferable—bound permanently to the issuing host.

use cosmwasm_std::{
    entry_point, to_json_binary, Binary, Deps, DepsMut, Env,
    MessageInfo, Response, StdResult, Addr, Timestamp, Uint128,
    CosmosMsg, BankMsg, WasmMsg, coin,
};
use cw_storage_plus::{Item, Map};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

// ============================================================================
// STATE DEFINITIONS
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
    pub admin: Addr,
    pub exhibition_contract: Addr,
    pub payment_contract: Addr,
    pub governance_contract: Addr,
    pub next_license_id: u64,
    pub denom: String,  // "unt"
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct License {
    pub id: u64,
    pub exhibition_id: u64,
    pub host: Addr,
    pub host_name: String,
    pub venue_type: VenueType,
    pub geographic_zone: String,
    pub start_time: Timestamp,
    pub end_time: Timestamp,
    pub fee_paid: Uint128,
    pub status: LicenseStatus,
    pub created_at: Timestamp,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum VenueType {
    Museum,
    Gallery,
    University,
    Library,
    CommunityCenter,
    Commercial,  // Café, hotel, co-working
    Private,
    Festival,
    PublicSpace,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum LicenseStatus {
    Pending,     // Awaiting payment confirmation
    Active,      // Currently valid
    Completed,   // License period ended
    Cancelled,   // Cancelled before activation
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct PricingTier {
    pub venue_type: VenueType,
    pub base_fee: Uint128,
    pub daily_rate: Uint128,
}

pub const CONFIG: Item<Config> = Item::new("config");
pub const LICENSES: Map<u64, License> = Map::new("licenses");
pub const HOST_LICENSES: Map<&Addr, Vec<u64>> = Map::new("host_licenses");
pub const EXHIBITION_LICENSES: Map<u64, Vec<u64>> = Map::new("exhibition_licenses");
pub const PRICING: Map<String, PricingTier> = Map::new("pricing");  // venue_type string -> tier
pub const GEOGRAPHIC_MULTIPLIERS: Map<String, Uint128> = Map::new("geo_multipliers");

// ============================================================================
// EXECUTE MESSAGES
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    // Host requests license
    RequestLicense {
        exhibition_id: u64,
        host_name: String,
        venue_type: VenueType,
        geographic_zone: String,
        duration_days: u64,
    },
    // Host confirms with payment
    ConfirmLicense {
        license_id: u64,
    },
    // System marks license complete when time expires
    CompleteLicense {
        license_id: u64,
    },
    // Host can cancel pending license
    CancelLicense {
        license_id: u64,
    },
    // Admin functions
    SetPricing {
        venue_type: VenueType,
        base_fee: Uint128,
        daily_rate: Uint128,
    },
    SetGeographicMultiplier {
        zone: String,
        multiplier: Uint128,  // 100 = 1.0x, 50 = 0.5x, 150 = 1.5x
    },
    // NOTE: No Transfer message - licenses are non-transferable
}

#[entry_point]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::RequestLicense { 
            exhibition_id, host_name, venue_type, geographic_zone, duration_days 
        } => execute_request_license(
            deps, env, info, exhibition_id, host_name, venue_type, geographic_zone, duration_days
        ),
        ExecuteMsg::ConfirmLicense { license_id } => {
            execute_confirm_license(deps, env, info, license_id)
        }
        ExecuteMsg::CompleteLicense { license_id } => {
            execute_complete_license(deps, env, info, license_id)
        }
        ExecuteMsg::CancelLicense { license_id } => {
            execute_cancel_license(deps, info, license_id)
        }
        ExecuteMsg::SetPricing { venue_type, base_fee, daily_rate } => {
            execute_set_pricing(deps, info, venue_type, base_fee, daily_rate)
        }
        ExecuteMsg::SetGeographicMultiplier { zone, multiplier } => {
            execute_set_geographic_multiplier(deps, info, zone, multiplier)
        }
    }
}

fn execute_request_license(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    exhibition_id: u64,
    host_name: String,
    venue_type: VenueType,
    geographic_zone: String,
    duration_days: u64,
) -> Result<Response, ContractError> {
    let mut config = CONFIG.load(deps.storage)?;
    
    // Calculate fee
    let venue_key = format!("{:?}", venue_type);
    let pricing = PRICING.load(deps.storage, venue_key)?;
    let geo_multiplier = GEOGRAPHIC_MULTIPLIERS
        .may_load(deps.storage, geographic_zone.clone())?
        .unwrap_or(Uint128::from(100u128));  // Default 1.0x
    
    let base_fee = pricing.base_fee;
    let duration_fee = pricing.daily_rate.checked_mul(Uint128::from(duration_days))?;
    let subtotal = base_fee.checked_add(duration_fee)?;
    let total_fee = subtotal.checked_mul(geo_multiplier)?.checked_div(Uint128::from(100u128))?;
    
    let start_time = env.block.time;
    let end_time = start_time.plus_days(duration_days);
    
    let license = License {
        id: config.next_license_id,
        exhibition_id,
        host: info.sender.clone(),
        host_name,
        venue_type,
        geographic_zone,
        start_time,
        end_time,
        fee_paid: total_fee,
        status: LicenseStatus::Pending,
        created_at: env.block.time,
    };
    
    LICENSES.save(deps.storage, config.next_license_id, &license)?;
    
    // Update indices
    let mut host_lic = HOST_LICENSES
        .may_load(deps.storage, &info.sender)?
        .unwrap_or_default();
    host_lic.push(config.next_license_id);
    HOST_LICENSES.save(deps.storage, &info.sender, &host_lic)?;
    
    let mut exh_lic = EXHIBITION_LICENSES
        .may_load(deps.storage, exhibition_id)?
        .unwrap_or_default();
    exh_lic.push(config.next_license_id);
    EXHIBITION_LICENSES.save(deps.storage, exhibition_id, &exh_lic)?;
    
    config.next_license_id += 1;
    CONFIG.save(deps.storage, &config)?;
    
    Ok(Response::new()
        .add_attribute("method", "request_license")
        .add_attribute("license_id", license.id.to_string())
        .add_attribute("exhibition_id", exhibition_id.to_string())
        .add_attribute("fee_required", total_fee.to_string()))
}

fn execute_confirm_license(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    license_id: u64,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    let mut license = LICENSES.load(deps.storage, license_id)?;
    
    // Verify sender is host
    if info.sender != license.host {
        return Err(ContractError::Unauthorized {});
    }
    
    // Verify pending status
    if license.status != LicenseStatus::Pending {
        return Err(ContractError::InvalidStatus {});
    }
    
    // Verify payment
    let payment = info.funds.iter()
        .find(|c| c.denom == config.denom)
        .map(|c| c.amount)
        .unwrap_or(Uint128::zero());
    
    if payment < license.fee_paid {
        return Err(ContractError::InsufficientPayment {});
    }
    
    // Activate license
    license.status = LicenseStatus::Active;
    license.start_time = env.block.time;
    license.end_time = env.block.time.plus_days(
        (license.end_time.seconds() - license.start_time.seconds()) / 86400
    );
    LICENSES.save(deps.storage, license_id, &license)?;
    
    // Notify exhibition contract
    let update_exhibition_msg = WasmMsg::Execute {
        contract_addr: config.exhibition_contract.to_string(),
        msg: to_json_binary(&ExhibitionExecuteMsg::RecordLicense {
            exhibition_id: license.exhibition_id,
            fee_amount: license.fee_paid,
        })?,
        funds: vec![],
    };
    
    // Trigger payment distribution
    let distribute_msg = WasmMsg::Execute {
        contract_addr: config.payment_contract.to_string(),
        msg: to_json_binary(&PaymentExecuteMsg::Distribute {
            license_id,
            exhibition_id: license.exhibition_id,
            amount: license.fee_paid,
        })?,
        funds: vec![coin(license.fee_paid.u128(), &config.denom)],
    };
    
    Ok(Response::new()
        .add_message(update_exhibition_msg)
        .add_message(distribute_msg)
        .add_attribute("method", "confirm_license")
        .add_attribute("license_id", license_id.to_string())
        .add_attribute("status", "active"))
}

fn execute_complete_license(
    deps: DepsMut,
    env: Env,
    _info: MessageInfo,
    license_id: u64,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    let mut license = LICENSES.load(deps.storage, license_id)?;
    
    // Verify license has expired
    if env.block.time < license.end_time {
        return Err(ContractError::LicenseStillActive {});
    }
    
    license.status = LicenseStatus::Completed;
    LICENSES.save(deps.storage, license_id, &license)?;
    
    // Notify exhibition contract
    let update_msg = WasmMsg::Execute {
        contract_addr: config.exhibition_contract.to_string(),
        msg: to_json_binary(&ExhibitionExecuteMsg::CompleteLicense {
            exhibition_id: license.exhibition_id,
        })?,
        funds: vec![],
    };
    
    Ok(Response::new()
        .add_message(update_msg)
        .add_attribute("method", "complete_license")
        .add_attribute("license_id", license_id.to_string()))
}

fn execute_cancel_license(
    deps: DepsMut,
    info: MessageInfo,
    license_id: u64,
) -> Result<Response, ContractError> {
    let mut license = LICENSES.load(deps.storage, license_id)?;
    
    // Only host can cancel
    if info.sender != license.host {
        return Err(ContractError::Unauthorized {});
    }
    
    // Only pending licenses can be cancelled
    if license.status != LicenseStatus::Pending {
        return Err(ContractError::InvalidStatus {});
    }
    
    license.status = LicenseStatus::Cancelled;
    LICENSES.save(deps.storage, license_id, &license)?;
    
    Ok(Response::new()
        .add_attribute("method", "cancel_license")
        .add_attribute("license_id", license_id.to_string()))
}

// Admin functions omitted for brevity - follow same pattern

6.3 Payment Contract

The Payment contract handles automatic distribution of license fees according to the fixed allocation.

use cosmwasm_std::{
    entry_point, to_json_binary, Binary, Deps, DepsMut, Env,
    MessageInfo, Response, StdResult, Addr, Uint128, Decimal,
    CosmosMsg, BankMsg, coin,
};
use cw_storage_plus::{Item, Map};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

// ============================================================================
// STATE DEFINITIONS  
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
    pub admin: Addr,
    pub license_contract: Addr,
    pub exhibition_contract: Addr,
    pub operations_treasury: Addr,
    pub commission_fund: Addr,
    pub denom: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct PaymentConfig {
    pub artist_share: Decimal,       // 0.40
    pub curator_share: Decimal,      // 0.20
    pub operations_share: Decimal,   // 0.30
    pub commission_share: Decimal,   // 0.10
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct PaymentRecord {
    pub license_id: u64,
    pub exhibition_id: u64,
    pub total_amount: Uint128,
    pub artist: Addr,
    pub artist_amount: Uint128,
    pub curator: Addr,
    pub curator_amount: Uint128,
    pub operations_amount: Uint128,
    pub commission_amount: Uint128,
    pub timestamp: u64,
}

pub const CONFIG: Item<Config> = Item::new("config");
pub const PAYMENT_CONFIG: Item<PaymentConfig> = Item::new("payment_config");
pub const PAYMENTS: Map<u64, PaymentRecord> = Map::new("payments");  // license_id -> record
pub const ARTIST_TOTALS: Map<&Addr, Uint128> = Map::new("artist_totals");
pub const CURATOR_TOTALS: Map<&Addr, Uint128> = Map::new("curator_totals");

// ============================================================================
// INSTANTIATE
// ============================================================================

#[entry_point]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult<Response> {
    let config = Config {
        admin: info.sender,
        license_contract: deps.api.addr_validate(&msg.license_contract)?,
        exhibition_contract: deps.api.addr_validate(&msg.exhibition_contract)?,
        operations_treasury: deps.api.addr_validate(&msg.operations_treasury)?,
        commission_fund: deps.api.addr_validate(&msg.commission_fund)?,
        denom: msg.denom,
    };
    
    // Initialize payment shares - these are constitutional
    let payment_config = PaymentConfig {
        artist_share: Decimal::percent(40),
        curator_share: Decimal::percent(20),
        operations_share: Decimal::percent(30),
        commission_share: Decimal::percent(10),
    };
    
    CONFIG.save(deps.storage, &config)?;
    PAYMENT_CONFIG.save(deps.storage, &payment_config)?;
    
    Ok(Response::new().add_attribute("method", "instantiate"))
}

// ============================================================================
// EXECUTE
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    // Called by License contract with payment
    Distribute {
        license_id: u64,
        exhibition_id: u64,
        amount: Uint128,
    },
    // Governance-controlled share adjustment (requires supermajority)
    UpdateShares {
        artist_share: Decimal,
        curator_share: Decimal,
        operations_share: Decimal,
        commission_share: Decimal,
    },
}

#[entry_point]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::Distribute { license_id, exhibition_id, amount } => {
            execute_distribute(deps, env, info, license_id, exhibition_id, amount)
        }
        ExecuteMsg::UpdateShares { artist_share, curator_share, operations_share, commission_share } => {
            execute_update_shares(deps, info, artist_share, curator_share, operations_share, commission_share)
        }
    }
}

fn execute_distribute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    license_id: u64,
    exhibition_id: u64,
    amount: Uint128,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    let payment_config = PAYMENT_CONFIG.load(deps.storage)?;
    
    // Only license contract can trigger distribution
    if info.sender != config.license_contract {
        return Err(ContractError::Unauthorized {});
    }
    
    // Verify payment received
    let received = info.funds.iter()
        .find(|c| c.denom == config.denom)
        .map(|c| c.amount)
        .unwrap_or(Uint128::zero());
    
    if received < amount {
        return Err(ContractError::InsufficientFunds {});
    }
    
    // Query exhibition for artist and curator addresses
    let exhibition: Exhibition = deps.querier.query_wasm_smart(
        &config.exhibition_contract,
        &ExhibitionQueryMsg::GetExhibition { exhibition_id },
    )?;
    
    // Calculate distributions
    let artist_amount = amount * payment_config.artist_share;
    let curator_amount = amount * payment_config.curator_share;
    let operations_amount = amount * payment_config.operations_share;
    let commission_amount = amount * payment_config.commission_share;
    
    // Create payment record
    let record = PaymentRecord {
        license_id,
        exhibition_id,
        total_amount: amount,
        artist: exhibition.artist.clone(),
        artist_amount,
        curator: exhibition.curator.clone(),
        curator_amount,
        operations_amount,
        commission_amount,
        timestamp: env.block.time.seconds(),
    };
    PAYMENTS.save(deps.storage, license_id, &record)?;
    
    // Update lifetime totals
    let artist_total = ARTIST_TOTALS
        .may_load(deps.storage, &exhibition.artist)?
        .unwrap_or(Uint128::zero());
    ARTIST_TOTALS.save(deps.storage, &exhibition.artist, &(artist_total + artist_amount))?;
    
    let curator_total = CURATOR_TOTALS
        .may_load(deps.storage, &exhibition.curator)?
        .unwrap_or(Uint128::zero());
    CURATOR_TOTALS.save(deps.storage, &exhibition.curator, &(curator_total + curator_amount))?;
    
    // Build distribution messages - instant payments
    let messages: Vec<CosmosMsg> = vec![
        BankMsg::Send {
            to_address: exhibition.artist.to_string(),
            amount: vec![coin(artist_amount.u128(), &config.denom)],
        }.into(),
        BankMsg::Send {
            to_address: exhibition.curator.to_string(),
            amount: vec![coin(curator_amount.u128(), &config.denom)],
        }.into(),
        BankMsg::Send {
            to_address: config.operations_treasury.to_string(),
            amount: vec![coin(operations_amount.u128(), &config.denom)],
        }.into(),
        BankMsg::Send {
            to_address: config.commission_fund.to_string(),
            amount: vec![coin(commission_amount.u128(), &config.denom)],
        }.into(),
    ];
    
    Ok(Response::new()
        .add_messages(messages)
        .add_attribute("method", "distribute")
        .add_attribute("license_id", license_id.to_string())
        .add_attribute("artist_payment", artist_amount.to_string())
        .add_attribute("curator_payment", curator_amount.to_string())
        .add_attribute("operations", operations_amount.to_string())
        .add_attribute("commission", commission_amount.to_string()))
}

fn execute_update_shares(
    deps: DepsMut,
    info: MessageInfo,
    artist_share: Decimal,
    curator_share: Decimal,
    operations_share: Decimal,
    commission_share: Decimal,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    
    // Only governance contract can update shares
    // This would be called after successful supermajority vote
    if info.sender != config.admin {  // Replace with governance_contract in production
        return Err(ContractError::Unauthorized {});
    }
    
    // Constitutional protection: artist share cannot fall below 35%
    if artist_share < Decimal::percent(35) {
        return Err(ContractError::ConstitutionalViolation {
            reason: "Artist share cannot fall below 35%".to_string(),
        });
    }
    
    // Verify shares sum to 100%
    let total = artist_share + curator_share + operations_share + commission_share;
    if total != Decimal::one() {
        return Err(ContractError::InvalidShares {});
    }
    
    let payment_config = PaymentConfig {
        artist_share,
        curator_share,
        operations_share,
        commission_share,
    };
    PAYMENT_CONFIG.save(deps.storage, &payment_config)?;
    
    Ok(Response::new()
        .add_attribute("method", "update_shares")
        .add_attribute("artist_share", artist_share.to_string())
        .add_attribute("curator_share", curator_share.to_string()))
}

6.4 Governance Contract

The Governance contract implements multi-stakeholder voting with constitutional protections.

use cosmwasm_std::{
    entry_point, to_json_binary, Binary, Deps, DepsMut, Env,
    MessageInfo, Response, StdResult, Addr, Uint128, Decimal,
    CosmosMsg, WasmMsg, Timestamp,
};
use cw_storage_plus::{Item, Map};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

// ============================================================================
// STATE DEFINITIONS
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
    pub admin: Addr,
    pub voting_period: u64,           // seconds (14 days = 1_209_600)
    pub quorum: Decimal,              // 0.33 (33%)
    pub threshold: Decimal,           // 0.50 (50% for standard)
    pub supermajority: Decimal,       // 0.75 (75% for constitutional)
    pub next_proposal_id: u64,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Proposal {
    pub id: u64,
    pub proposer: Addr,
    pub title: String,
    pub description: String,
    pub proposal_type: ProposalType,
    pub messages: Vec<CosmosMsg>,
    pub start_time: Timestamp,
    pub end_time: Timestamp,
    pub status: ProposalStatus,
    pub votes_for: Uint128,
    pub votes_against: Uint128,
    pub votes_abstain: Uint128,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum ProposalType {
    Standard,           // 50% threshold
    Constitutional,     // 75% threshold, artist council veto
    Emergency,          // Fast-track for security issues
    Parameter,          // Chain parameter updates
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum ProposalStatus {
    Voting,
    Passed,
    Rejected,
    Executed,
    Vetoed,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Vote {
    pub voter: Addr,
    pub council: Council,
    pub choice: VoteChoice,
    pub weight: Uint128,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum Council {
    Artist,     // 30% weight
    Curator,    // 20% weight
    Host,       // 25% weight
    Investor,   // 25% weight
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum VoteChoice {
    For,
    Against,
    Abstain,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct CouncilMember {
    pub address: Addr,
    pub council: Council,
    pub voting_power: Uint128,
    pub joined_at: Timestamp,
}

pub const CONFIG: Item<Config> = Item::new("config");
pub const PROPOSALS: Map<u64, Proposal> = Map::new("proposals");
pub const VOTES: Map<(u64, &Addr), Vote> = Map::new("votes");  // (proposal_id, voter)
pub const COUNCIL_MEMBERS: Map<&Addr, CouncilMember> = Map::new("council_members");
pub const COUNCIL_TOTALS: Map<String, Uint128> = Map::new("council_totals");

// Constitutional protections - cannot be modified
pub const CONSTITUTIONAL: Item<ConstitutionalProtections> = Item::new("constitutional");

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct ConstitutionalProtections {
    pub min_artist_share: Decimal,           // Cannot fall below 35%
    pub anti_speculation_immutable: bool,    // Cannot enable transfers
    pub geographic_access_required: bool,    // Must maintain accessibility tiers
}

// ============================================================================
// EXECUTE MESSAGES
// ============================================================================

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    // Create new proposal
    CreateProposal {
        title: String,
        description: String,
        proposal_type: ProposalType,
        messages: Vec<CosmosMsg>,
    },
    // Cast vote
    Vote {
        proposal_id: u64,
        choice: VoteChoice,
    },
    // Execute passed proposal
    Execute {
        proposal_id: u64,
    },
    // Artist council veto (constitutional proposals only)
    Veto {
        proposal_id: u64,
    },
    // Council membership management
    AddCouncilMember {
        address: String,
        council: Council,
        voting_power: Uint128,
    },
    RemoveCouncilMember {
        address: String,
    },
}

fn execute_create_proposal(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    title: String,
    description: String,
    proposal_type: ProposalType,
    messages: Vec<CosmosMsg>,
) -> Result<Response, ContractError> {
    // Verify proposer is council member
    let member = COUNCIL_MEMBERS.may_load(deps.storage, &info.sender)?;
    if member.is_none() {
        return Err(ContractError::NotCouncilMember {});
    }
    
    let mut config = CONFIG.load(deps.storage)?;
    
    let proposal = Proposal {
        id: config.next_proposal_id,
        proposer: info.sender,
        title,
        description,
        proposal_type,
        messages,
        start_time: env.block.time,
        end_time: env.block.time.plus_seconds(config.voting_period),
        status: ProposalStatus::Voting,
        votes_for: Uint128::zero(),
        votes_against: Uint128::zero(),
        votes_abstain: Uint128::zero(),
    };
    
    PROPOSALS.save(deps.storage, config.next_proposal_id, &proposal)?;
    config.next_proposal_id += 1;
    CONFIG.save(deps.storage, &config)?;
    
    Ok(Response::new()
        .add_attribute("method", "create_proposal")
        .add_attribute("proposal_id", proposal.id.to_string()))
}

fn execute_vote(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    proposal_id: u64,
    choice: VoteChoice,
) -> Result<Response, ContractError> {
    let mut proposal = PROPOSALS.load(deps.storage, proposal_id)?;
    
    // Verify voting period
    if env.block.time > proposal.end_time {
        return Err(ContractError::VotingEnded {});
    }
    
    // Verify voter is council member
    let member = COUNCIL_MEMBERS.load(deps.storage, &info.sender)?;
    
    // Check if already voted
    if VOTES.may_load(deps.storage, (proposal_id, &info.sender))?.is_some() {
        return Err(ContractError::AlreadyVoted {});
    }
    
    // Calculate weighted vote based on council
    let council_weight = match member.council {
        Council::Artist => Decimal::percent(30),
        Council::Curator => Decimal::percent(20),
        Council::Host => Decimal::percent(25),
        Council::Investor => Decimal::percent(25),
    };
    
    let weighted_vote = member.voting_power * council_weight;
    
    // Record vote
    let vote = Vote {
        voter: info.sender.clone(),
        council: member.council,
        choice: choice.clone(),
        weight: weighted_vote,
    };
    VOTES.save(deps.storage, (proposal_id, &info.sender), &vote)?;
    
    // Update totals
    match choice {
        VoteChoice::For => proposal.votes_for += weighted_vote,
        VoteChoice::Against => proposal.votes_against += weighted_vote,
        VoteChoice::Abstain => proposal.votes_abstain += weighted_vote,
    }
    PROPOSALS.save(deps.storage, proposal_id, &proposal)?;
    
    Ok(Response::new()
        .add_attribute("method", "vote")
        .add_attribute("proposal_id", proposal_id.to_string())
        .add_attribute("choice", format!("{:?}", choice)))
}

fn execute_execute(
    deps: DepsMut,
    env: Env,
    _info: MessageInfo,
    proposal_id: u64,
) -> Result<Response, ContractError> {
    let config = CONFIG.load(deps.storage)?;
    let constitutional = CONSTITUTIONAL.load(deps.storage)?;
    let mut proposal = PROPOSALS.load(deps.storage, proposal_id)?;
    
    // Verify voting ended
    if env.block.time < proposal.end_time {
        return Err(ContractError::VotingNotEnded {});
    }
    
    // Verify not already executed
    if proposal.status != ProposalStatus::Voting {
        return Err(ContractError::InvalidStatus {});
    }
    
    // Calculate totals
    let total_votes = proposal.votes_for + proposal.votes_against + proposal.votes_abstain;
    let total_supply = get_total_voting_power(deps.as_ref())?;
    
    // Check quorum
    let quorum_reached = Decimal::from_ratio(total_votes, total_supply) >= config.quorum;
    if !quorum_reached {
        proposal.status = ProposalStatus::Rejected;
        PROPOSALS.save(deps.storage, proposal_id, &proposal)?;
        return Err(ContractError::QuorumNotReached {});
    }
    
    // Determine threshold based on proposal type
    let required_threshold = match proposal.proposal_type {
        ProposalType::Constitutional => config.supermajority,
        _ => config.threshold,
    };
    
    // Check threshold
    let votes_counted = proposal.votes_for + proposal.votes_against;
    let approval_rate = Decimal::from_ratio(proposal.votes_for, votes_counted);
    
    if approval_rate >= required_threshold {
        // Validate constitutional protections for constitutional proposals
        if proposal.proposal_type == ProposalType::Constitutional {
            validate_constitutional_compliance(&proposal, &constitutional)?;
        }
        
        proposal.status = ProposalStatus::Passed;
        PROPOSALS.save(deps.storage, proposal_id, &proposal)?;
        
        // Execute messages
        Ok(Response::new()
            .add_messages(proposal.messages)
            .add_attribute("method", "execute")
            .add_attribute("proposal_id", proposal_id.to_string())
            .add_attribute("status", "passed"))
    } else {
        proposal.status = ProposalStatus::Rejected;
        PROPOSALS.save(deps.storage, proposal_id, &proposal)?;
        
        Ok(Response::new()
            .add_attribute("method", "execute")
            .add_attribute("proposal_id", proposal_id.to_string())
            .add_attribute("status", "rejected"))
    }
}

fn execute_veto(
    deps: DepsMut,
    info: MessageInfo,
    proposal_id: u64,
) -> Result<Response, ContractError> {
    let member = COUNCIL_MEMBERS.load(deps.storage, &info.sender)?;
    
    // Only artist council can veto
    if member.council != Council::Artist {
        return Err(ContractError::Unauthorized {});
    }
    
    let mut proposal = PROPOSALS.load(deps.storage, proposal_id)?;
    
    // Only constitutional proposals can be vetoed
    if proposal.proposal_type != ProposalType::Constitutional {
        return Err(ContractError::CannotVeto {});
    }
    
    // Check if artist council has sufficient representation for veto
    // Requires 66% of artist council voting to veto
    let artist_veto_threshold = Decimal::percent(66);
    // Implementation would check artist council vote distribution
    
    proposal.status = ProposalStatus::Vetoed;
    PROPOSALS.save(deps.storage, proposal_id, &proposal)?;
    
    Ok(Response::new()
        .add_attribute("method", "veto")
        .add_attribute("proposal_id", proposal_id.to_string()))
}

fn validate_constitutional_compliance(
    proposal: &Proposal,
    protections: &ConstitutionalProtections,
) -> Result<(), ContractError> {
    // Parse proposal messages and verify they don't violate constitutional protections
    // This is a simplified check - production would parse each message type
    
    for msg in &proposal.messages {
        // Check for attempts to modify protected parameters
        // In production: deserialize and inspect each message
    }
    
    Ok(())
}

fn get_total_voting_power(deps: Deps) -> StdResult<Uint128> {
    let artist_total = COUNCIL_TOTALS.may_load(deps.storage, "Artist".to_string())?
        .unwrap_or(Uint128::zero());
    let curator_total = COUNCIL_TOTALS.may_load(deps.storage, "Curator".to_string())?
        .unwrap_or(Uint128::zero());
    let host_total = COUNCIL_TOTALS.may_load(deps.storage, "Host".to_string())?
        .unwrap_or(Uint128::zero());
    let investor_total = COUNCIL_TOTALS.may_load(deps.storage, "Investor".to_string())?
        .unwrap_or(Uint128::zero());
    
    Ok(artist_total + curator_total + host_total + investor_total)
}

6.5 Provenance Contract

The Provenance contract maintains immutable circulation history for each exhibition.

use cosmwasm_std::{
    entry_point, to_json_binary, Binary, Deps, DepsMut, Env,
    MessageInfo, Response, StdResult, Addr, Timestamp,
};
use cw_storage_plus::{Item, Map};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct ProvenanceEntry {
    pub exhibition_id: u64,
    pub entry_type: ProvenanceType,
    pub actor: Addr,
    pub details: String,
    pub timestamp: Timestamp,
    pub block_height: u64,
    pub tx_hash: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub enum ProvenanceType {
    Created,        // Exhibition created
    Licensed,       // License issued
    Exhibited,      // Exhibition hosted
    Completed,      // License completed
    MetadataUpdate, // Metadata changed
    StatusChange,   // Status changed
    Curated,        // Added to curated collection
}

pub const PROVENANCE: Map<(u64, u64), ProvenanceEntry> = Map::new("provenance");  // (exhibition_id, entry_index)
pub const PROVENANCE_COUNT: Map<u64, u64> = Map::new("provenance_count");
pub const AUTHORIZED_CONTRACTS: Map<&Addr, bool> = Map::new("authorized");

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    RecordEvent {
        exhibition_id: u64,
        entry_type: ProvenanceType,
        actor: String,
        details: String,
    },
    AuthorizeContract {
        contract: String,
    },
}

fn execute_record_event(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    exhibition_id: u64,
    entry_type: ProvenanceType,
    actor: String,
    details: String,
) -> Result<Response, ContractError> {
    // Verify caller is authorized contract
    let is_authorized = AUTHORIZED_CONTRACTS
        .may_load(deps.storage, &info.sender)?
        .unwrap_or(false);
    
    if !is_authorized {
        return Err(ContractError::Unauthorized {});
    }
    
    // Get next entry index
    let count = PROVENANCE_COUNT
        .may_load(deps.storage, exhibition_id)?
        .unwrap_or(0);
    
    let entry = ProvenanceEntry {
        exhibition_id,
        entry_type,
        actor: deps.api.addr_validate(&actor)?,
        details,
        timestamp: env.block.time,
        block_height: env.block.height,
        tx_hash: None,  // Would be populated by indexer
    };
    
    PROVENANCE.save(deps.storage, (exhibition_id, count), &entry)?;
    PROVENANCE_COUNT.save(deps.storage, exhibition_id, &(count + 1))?;
    
    Ok(Response::new()
        .add_attribute("method", "record_event")
        .add_attribute("exhibition_id", exhibition_id.to_string())
        .add_attribute("entry_index", count.to_string()))
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    GetProvenance {
        exhibition_id: u64,
        start_after: Option<u64>,
        limit: Option<u32>,
    },
    GetFullHistory {
        exhibition_id: u64,
    },
    VerifyProvenance {
        exhibition_id: u64,
        content_hash: String,
    },
}

fn query_full_history(deps: Deps, exhibition_id: u64) -> StdResult<Vec<ProvenanceEntry>> {
    let count = PROVENANCE_COUNT
        .may_load(deps.storage, exhibition_id)?
        .unwrap_or(0);
    
    let mut entries = Vec::new();
    for i in 0..count {
        if let Some(entry) = PROVENANCE.may_load(deps.storage, (exhibition_id, i))? {
            entries.push(entry);
        }
    }
    
    Ok(entries)
}