CIP-104 Mode A coupon-reassignment automation

crates/decman/frontend/src/components/GovernanceSection.tsx

@@ -1637,6 +1637,14 @@ export const GovernanceSection = ({
           throw new Error(
             "Paid credential proposal forms are not implemented yet — use the Free direction or call the API directly.",
           );
+        default:
+          // Automation-only proposal types (e.g. setup_coupon_reassignment_delegation,
+          // revoke_coupon_reassignment_delegation) have no UI form by design and are
+          // never offered in the menu; guard the exhaustiveness so `proposal` is
+          // always assigned.
+          throw new Error(
+            `Proposal type "${proposalType}" is automation-only and not available in the UI.`,
+          );
       }
 
       const request: ProposeActionRequest = {

crates/decman/src/cli.rs

@@ -195,5 +195,11 @@ pub enum Commands {
         /// Backoff between attempts of the bounded peer-Noise retry wrapper, in milliseconds
         #[arg(long, env = "DECPM_NOISE_RETRY_BACKOFF_MS")]
         noise_retry_backoff_ms: Option<u64>,
+
+        /// CIP-104 Mode A reward-automation loop tick interval, in seconds.
+        /// Enablement is on-ledger (presence of a CouponReassignmentDelegation);
+        /// this only controls cadence. Defaults to 300.
+        #[arg(long, env = "DECPM_REWARD_AUTOMATION_INTERVAL_SECS")]
+        reward_automation_interval_secs: Option<u64>,
     },
 }

crates/decman/src/config.rs

@@ -247,6 +247,10 @@ pub struct NodeConfig {
     pub canton: CantonConfig,
     pub timeouts: Timeouts,
     pub noise_retry: NoiseRetryConfig,
+    /// Tick interval (seconds) for the CIP-104 Mode A reward-assignment
+    /// automation loop. Enablement is on-ledger (presence of a
+    /// `CouponReassignmentDelegation`), so this only controls cadence. Default 300s.
+    pub reward_automation_interval_secs: u64,
     /// Top-level Keycloak config for frontend website gating
     pub keycloak: Option<KeycloakConfig>,
     /// Top-level Auth0 config for frontend website gating (mutually exclusive
@@ -272,6 +276,7 @@ impl Default for NodeConfig {
             canton: CantonConfig::default(),
             timeouts: Timeouts::default(),
             noise_retry: NoiseRetryConfig::default(),
+            reward_automation_interval_secs: 300,
             keycloak: None,
             auth0: None,
             insecure: false,

crates/decman/src/main.rs

@@ -81,6 +81,7 @@ async fn main() -> Result {
             noise_retry_timeout_sec,
             noise_retry_max_attempts,
             noise_retry_backoff_ms,
+            reward_automation_interval_secs,
             db_encryption_key,
             insecure,
             canton_hmac_secret,
@@ -181,6 +182,9 @@ async fn main() -> Result {
             if let Some(v) = noise_retry_backoff_ms {
                 config.noise_retry.backoff_ms = *v;
             }
+            if let Some(v) = reward_automation_interval_secs {
+                config.reward_automation_interval_secs = *v;
+            }
 
             config.insecure = *insecure;
             // Only ingest the unsafe HMAC settings when insecure mode is on;

crates/decman/src/server/action_serializer.rs

@@ -16,14 +16,14 @@ use crate::{canton_id::CantonId, error::Result};
 
 use super::types::{
     ActionType, AppRewardBeneficiary, BillingParams, Claim, FarConfig, InstrumentAllowance,
-    InstrumentId, InstrumentIdentifier, ProposalType, VaultLimits,
+    InstrumentId, InstrumentIdentifier, ProposalType, RewardBeneficiary, VaultLimits,
 };
 
 // ============================================================================
 // Helper Functions
 // ============================================================================
 
-fn make_party(p: impl std::fmt::Display) -> Value {
+pub(crate) fn make_party(p: impl std::fmt::Display) -> Value {
     Value {
         sum: Some(value::Sum::Party(p.to_string())),
     }
@@ -53,13 +53,13 @@ fn make_bool(b: bool) -> Value {
     }
 }
 
-fn make_contract_id(c: &str) -> Value {
+pub(crate) fn make_contract_id(c: &str) -> Value {
     Value {
         sum: Some(value::Sum::ContractId(c.to_string())),
     }
 }
 
-fn field(label: &str, value: Value) -> RecordField {
+pub(crate) fn field(label: &str, value: Value) -> RecordField {
     RecordField {
         label: label.to_string(),
         value: Some(value),
@@ -85,7 +85,7 @@ fn make_variant(constructor: &str, value: Value) -> Value {
     }
 }
 
-fn make_list(values: Vec<Value>) -> Value {
+pub(crate) fn make_list(values: Vec<Value>) -> Value {
     Value {
         sum: Some(value::Sum::List(List { elements: values })),
     }
@@ -249,6 +249,14 @@ fn make_optional_numeric(opt: &Option<DamlDecimal>) -> Value {
     }
 }
 
+fn make_optional_contract_id(opt: &Option<String>) -> Value {
+    Value {
+        sum: Some(value::Sum::Optional(Box::new(Optional {
+            value: opt.as_ref().map(|c| Box::new(make_contract_id(c))),
+        }))),
+    }
+}
+
 fn make_optional_bool(opt: &Option<bool>) -> Value {
     Value {
         sum: Some(value::Sum::Optional(Box::new(Optional {
@@ -328,6 +336,13 @@ fn serialize_app_reward_beneficiary(b: &AppRewardBeneficiary) -> Value {
     ])
 }
 
+fn serialize_reward_beneficiary(b: &RewardBeneficiary) -> Value {
+    make_record(vec![
+        field("beneficiary", make_party(&b.beneficiary)),
+        field("percentage", make_numeric(&b.percentage.to_string())),
+    ])
+}
+
 fn serialize_instrument_identifier(i: &InstrumentIdentifier) -> Value {
     make_record(vec![
         field("source", make_party(&i.source)),
@@ -1184,6 +1199,52 @@ pub fn build_proposal_create_args(
                 ],
             },
         ),
+        ProposalType::SetupCouponReassignmentDelegation {
+            assigners,
+            new_beneficiaries,
+            prior_delegation,
+        } => (
+            ProposalPackage::GovernanceRewards,
+            "Governance.Rewards.SetupCouponReassignmentDelegation",
+            "SetupCouponReassignmentDelegation",
+            Record {
+                record_id: None,
+                fields: vec![
+                    field("governanceParty", make_party(governance_party)),
+                    field("proposer", make_party(proposer)),
+                    field(
+                        "priorDelegation",
+                        make_optional_contract_id(prior_delegation),
+                    ),
+                    field(
+                        "assigners",
+                        make_list(assigners.iter().map(make_party).collect()),
+                    ),
+                    field(
+                        "beneficiaries",
+                        make_list(
+                            new_beneficiaries
+                                .iter()
+                                .map(serialize_reward_beneficiary)
+                                .collect(),
+                        ),
+                    ),
+                ],
+            },
+        ),
+        ProposalType::RevokeCouponReassignmentDelegation { delegation } => (
+            ProposalPackage::GovernanceRewards,
+            "Governance.Rewards.RevokeCouponReassignmentDelegation",
+            "RevokeCouponReassignmentDelegation",
+            Record {
+                record_id: None,
+                fields: vec![
+                    field("governanceParty", make_party(governance_party)),
+                    field("proposer", make_party(proposer)),
+                    field("delegation", make_contract_id(delegation)),
+                ],
+            },
+        ),
         ProposalType::SetEnableResultContracts {
             registrar_service_cid,
             enable_result_contracts,
@@ -2075,6 +2136,11 @@ mod tests {
         CantonId::new("p".to_string(), Namespace::new([0u8; NAMESPACE_LENGTH]))
     }
 
+    /// Parse a decimal literal in test fixtures, panicking on invalid input.
+    fn dec(s: &str) -> DamlDecimal {
+        DamlDecimal::parse(s).expect("valid decimal literal")
+    }
+
     /// Unwrap a `Variant` value into `(constructor, inner)`.
     fn as_variant(value: &Value) -> (&str, &Value) {
         match &value.sum {
@@ -2466,6 +2532,63 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn build_proposal_setup_delegation_shape() -> Result {
+        let proposal = ProposalType::SetupCouponReassignmentDelegation {
+            assigners: vec![party_id(), party_id()],
+            new_beneficiaries: vec![
+                RewardBeneficiary {
+                    beneficiary: party_id(),
+                    percentage: dec("0.8"),
+                },
+                RewardBeneficiary {
+                    beneficiary: party_id(),
+                    percentage: dec("0.2"),
+                },
+            ],
+            prior_delegation: Some("00old".to_string()),
+        };
+        let (package, module, entity, record) =
+            build_proposal_create_args("gov", "proposer", &proposal, None, None)?;
+        assert_eq!(package, ProposalPackage::GovernanceRewards);
+        assert_eq!(
+            module,
+            "Governance.Rewards.SetupCouponReassignmentDelegation"
+        );
+        assert_eq!(entity, "SetupCouponReassignmentDelegation");
+        assert_eq!(
+            owned_labels(&record),
+            [
+                "governanceParty",
+                "proposer",
+                "priorDelegation",
+                "assigners",
+                "beneficiaries"
+            ]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn build_proposal_revoke_delegation_shape() -> Result {
+        let proposal = ProposalType::RevokeCouponReassignmentDelegation {
+            delegation: "00abc".to_string(),
+        };
+        let (package, module, entity, record) =
+            build_proposal_create_args("gov", "proposer", &proposal, None, None)?;
+        assert_eq!(package, ProposalPackage::GovernanceRewards);
+        assert_eq!(
+            module,
+            "Governance.Rewards.RevokeCouponReassignmentDelegation"
+        );
+        assert_eq!(entity, "RevokeCouponReassignmentDelegation");
+        assert_eq!(
+            owned_labels(&record),
+            ["governanceParty", "proposer", "delegation"]
+        );
+        Ok(())
+    }
+
     #[test]
     fn build_proposal_accept_transfer_shape_and_context_branches() -> Result {
         let proposal = ProposalType::AcceptTransfer {