5.4 Operational Recommendations

Operational rollout should be strategically phased to validate the architecture incrementally while minimizing risk.

Phase 1: Single Chain, Simple Strategy (Weeks 1-4)

Objective

Validate core control loop: Canton → Relayer → Vault

Implementation

• Deploy on one testnet (e.g., Ethereum Sepolia)
• Single vault with one strategy (Flow A only)
• Use Pattern 1 (Signed Intent Relay) for simplicity
• Manual monitoring and intervention

Success Criteria

• [ ] 100 automated rebalances executed successfully
• [ ] Zero policy violations
• [ ] Average latency < 5 seconds
• [ ] No security incidents
• [ ] Complete audit trail verified

Configuration

# phase1-config.yml
canton:
  domain: testnet
  participant: single-node

vaults:
  - id: vault-sepolia-001
    chain: sepolia
    strategy: simple-yield
    maxExposure: 30%

relayer:
  mode: single-instance
  pattern: signed-intent-relay

monitoring:
  alerting: enabled
  dashboard: basic

Phase 2: Multi-Strategy, Approval Workflow (Weeks 5-8)

Objective

Validate governance workflows and Flow B (human-in-the-loop)

Additions

• Implement multi-party approval workflow
• Add 2-3 additional strategies
• Enable Flow B for high-value operations
• Increase exposure limits

Success Criteria

• [ ] 50 approval-based rebalances completed
• [ ] Average approval time < 30 minutes
• [ ] Quorum logic working correctly
• [ ] All approvals logged immutably
• [ ] Stress test with 10+ simultaneous proposals

Configuration

-- Multi-strategy policy
template MultiStrategyPolicy
  with
    controller: Party
    strategies: [Strategy]
    approvers: [Party]
    highValueThreshold: Decimal
  where
    signatory controller

    choice ProposeRebalance : ContractId RebalanceProposal
      with
        allocations: [(Text, Decimal)]
        estimatedValue: Decimal
      controller controller
      do
        -- Require approval if high value
        if estimatedValue > highValueThreshold
          then do
            create RebalanceProposal with
              proposer = controller
              approvers
              proposedAllocations = allocations
              quorumRequired = 2
          else do
            -- Auto-execute if within limits
            create ExecutionIntent with ...

Phase 3: Trustless Verification (Weeks 9-12)

Objective

Migrate to Pattern 2 (Proof Publication) for enhanced security

Additions

• Deploy Canton Key Registry on-chain
• Implement cryptographic proof verification
• Sync Canton topology to registry
• Remove Relayer trust requirement

Success Criteria

• [ ] On-chain signature verification working
• [ ] Key rotation tested successfully
• [ ] Gas cost < 200k per intent
• [ ] No verification failures
• [ ] Registry synchronized automatically

Implementation

// Deploy registry
const KeyRegistry = await ethers.getContractFactory('CantonKeyRegistry');
const registry = await KeyRegistry.deploy();

// Register Canton key
await registry.registerKey(
  AUTHORIZED_PARTY_ID,
  CANTON_PUBLIC_KEY_ADDRESS
);

// Update vault to use registry
const vault = await ethers.getContractAt('CantonDeFiVault', VAULT_ADDRESS);
await vault.updateKeyRegistry(registry.address);

Phase 4: Multi-Chain (Weeks 13-16)

Objective

Enable cross-chain operations and Flow C (atomic coordination)

Additions

• Deploy vaults on 2-3 additional chains
• Implement cross-chain intent groups
• Add compensation logic for partial failures
• Test various failure scenarios

Success Criteria

• [ ] 20 successful multi-chain rebalances
• [ ] Compensation logic triggered and working
• [ ] Average multi-chain latency < 30 seconds
• [ ] All chains reconciled correctly
• [ ] No permanent inconsistencies

Configuration

// Multi-chain intent group
const group = await canton.createIntentGroup({
  groupId: 'group-001',
  intents: [
    {
      chain: 'ethereum',
      vaultId: 'vault-eth-001',
      actions: [
        { protocol: 'Aave', operation: 'withdraw', amount: 100000 }
      ]
    },
    {
      chain: 'polygon',
      vaultId: 'vault-poly-001',
      actions: [
        { protocol: 'Aave', operation: 'supply', amount: 100000 }
      ]
    }
  ],
  deadline: Date.now() + 60000 // 1 minute
});

Phase 5: Production Launch (Week 17+)

Objective

Launch on mainnets with real assets

Implementation Strategy

Week 17-18: Mainnet Deployment

• Deploy contracts to all target mainnets
• Verify contracts on block explorers
• Transfer ownership to multisig
• Disable admin upgradeability (if applicable)

Week 19-20: Limited Launch

• Start with $100k AUM
• Single strategy, single chain
• 24/7 monitoring
• Daily review of all operations

Week 21-24: Gradual Scaling

• Increase AUM to $1M
• Enable multi-strategy
• Add additional chains
• Reduce monitoring frequency to weekly

Week 25+: Full Production

• Scale to target AUM
• Enable all features
• Automated monitoring with alerts
• Monthly operational reviews

Production Checklist

Pre-Launch

• [ ] All Phase 1-4 success criteria met
• [ ] Security audit completed (2+ firms)
• [ ] Penetration testing performed
• [ ] Bug bounty program launched
• [ ] Insurance coverage secured
• [ ] Legal/regulatory approval obtained
• [ ] Incident response plan documented
• [ ] On-call rotation established
• [ ] Backup and recovery tested

Launch Day

• [ ] Final smoke tests passed
• [ ] All team members briefed
• [ ] Monitoring dashboards live
• [ ] Alert channels tested
• [ ] Communication plan ready
• [ ] Rollback plan prepared

Post-Launch (First 48 Hours)

• [ ] Continuous monitoring
• [ ] Hourly health checks
• [ ] No automated scaling
• [ ] All operations reviewed manually
• [ ] Team on standby

Operational Best Practices

1. Start Simple, Add Complexity Gradually

Phase 1: Single Chain, Single Strategy
  ↓
Phase 2: Single Chain, Multi-Strategy
  ↓
Phase 3: Enhanced Security (Pattern 2)
  ↓
Phase 4: Multi-Chain
  ↓
Phase 5: Full Production

2. Reserve Human Approval for High-Risk Ops

function requiresApproval(intent: ExecutionIntent): boolean {
  return (
    intent.estimatedValue > HIGH_VALUE_THRESHOLD ||
    intent.newProtocol ||  // First time using protocol
    intent.actions.length > 5 ||  // Complex operation
    isHighVolatility()  // Market conditions
  );
}

3. Continuous Adapter Iteration

Adapter Development Cycle:
1. Research protocol (docs, audits, exploits)
2. Implement minimal adapter
3. Comprehensive unit tests
4. Testnet deployment and testing
5. Security audit of adapter
6. Mainnet deployment
7. Monitor for 2 weeks
8. Enable for production

Keep adapters:

• Small: 100-200 lines of code
• Audited: External security review
• Isolated: Failures don't affect other adapters
• Minimal: Only essential functionality

4. Regular Policy Reviews

// Quarterly policy review
cron.schedule('0 0 1 */3 *', async () => {  // Every quarter
  const review = {
    currentPolicy: await canton.fetchPolicy(POLICY_ID),
    utilization: await analyzeUtilization(),
    performance: await analyzePerformance(),
    risks: await assessRisks(),
    recommendations: await generateRecommendations()
  };

  await notifyRiskCommittee(review);
});

5. Incident Response Playbooks

Document procedures for common incidents:

Playbook: Relayer Compromise

1. Immediate: Pause all vaults (emergency multisig)
2. Within 1 hour: Rotate Relayer credentials
3. Within 4 hours: Audit all recent transactions
4. Within 24 hours: Re-verify all Canton signatures
5. Recovery: Resume operations with new Relayer
6. Post-mortem: Document incident and improve detection

Playbook: Smart Contract Exploit

1. Immediate: Pause affected vault
2. Within 30 min: Assess damage and freeze assets if possible
3. Within 2 hours: Deploy patched contract
4. Within 4 hours: Migrate assets to new contract
5. Within 24 hours: Compensate affected users (if applicable)
6. Post-mortem: Security audit and bug bounty payout

6. Performance Optimization Targets

Metric	Target	Acceptable	Action Required
End-to-End Latency	< 5s	< 15s	> 30s
Success Rate	> 99%	> 95%	< 90%
Gas Efficiency	< 150k	< 250k	> 350k
Relayer Uptime	> 99.9%	> 99%	< 98%
Canton Uptime	> 99.99%	> 99.5%	< 99%

7. Cost Optimization

// Optimize gas usage
class GasOptimizer {
  async optimizeIntent(intent: ExecutionIntent): Promise<void> {
    // Batch compatible operations
    intent.actions = this.batchActions(intent.actions);

    // Use gas-efficient patterns
    intent.actions = this.optimizeCalldata(intent.actions);

    // Choose optimal gas price
    intent.gasPrice = await this.estimateOptimalGasPrice();
  }

  private batchActions(actions: Action[]): Action[] {
    // Combine multiple swaps on same DEX
    // Batch multiple supplies to same protocol
    // Group withdrawals
    return batched;
  }
}

Long-Term Maintenance

Monthly Tasks

• [ ] Review all operational metrics
• [ ] Analyze gas costs and optimize
• [ ] Review and update policies
• [ ] Check for adapter updates
• [ ] Security patch management
• [ ] Backup verification

Quarterly Tasks

• [ ] Comprehensive security review
• [ ] Disaster recovery drill
• [ ] Policy effectiveness analysis
• [ ] Adapter security re-audit
• [ ] Infrastructure capacity planning
• [ ] Team training and knowledge sharing

Annual Tasks

• [ ] Full system security audit
• [ ] Architecture review and optimization
• [ ] Regulatory compliance review
• [ ] Insurance coverage review
• [ ] Major version upgrades (Canton, adapters)
• [ ] Business continuity plan update