Delegate capability: Contract PUT

[sanity]

Parent: #2827

Summary

Allow delegates to create/store contracts via a PUT operation.

Proposed Implementation

1. Add to OutboundDelegateMsg (freenet-stdlib)

PutContractRequest {
    contract: ContractContainer,
    state: WrappedState,
    related_contracts: RelatedContracts,
},

2. Add to InboundDelegateMsg (freenet-stdlib)

PutContractResponse {
    contract_id: ContractInstanceId,
    result: Result<(), PutError>,  // or a custom error type
},

3. Handle in delegate runtime (freenet-core)

In delegate.rs, when processing OutboundDelegateMsg::PutContractRequest:

1. Call executor.perform_contract_put()
2. Package result as InboundDelegateMsg::PutContractResponse
3. Call delegate again with the response

Design Questions

1. Who can PUT?

   • Any delegate can PUT any contract (authorization is contract's responsibility)
   • But should there be any rate limiting or resource controls?

2. Should the delegate be able to specify contract parameters?

   • Parameters are part of ContractContainer
   • Need to ensure the delegate can construct valid contract containers

3. Related contracts handling

   • What if related contracts aren't available?
   • Should the delegate be notified of missing dependencies?

4. Network propagation

   • In network mode, PUT broadcasts to peers
   • Should the delegate be notified when propagation completes, or just when local commit succeeds?

Sender Attestation

When a delegate PUTs a contract, should the contract know who created it? This could be useful for:

• Initial authorization setup
• Audit trails
• Trust relationships

The delegate's key could be recorded as the contract's creator, though this may need design discussion.

Testing

• Unit test for new message types
• Integration test: delegate creates a contract via freenet local
• Test with related contracts
• Test error cases (invalid contract, resource limits)

Acceptance Criteria

• OutboundDelegateMsg::PutContractRequest added to stdlib
• InboundDelegateMsg::PutContractResponse added to stdlib
• Runtime handles the request and stores contract
• Works in both freenet local and freenet network modes
• Example/test delegate demonstrates the capability

[github-actions]

🤖 Auto-labeled

Applied labels:

• T-feature (95% confidence)
• P-medium (90% confidence)
• E-medium (85% confidence)
• A-contracts (98% confidence)
• A-networking (80% confidence)
• A-developer-xp (75% confidence)
• S-needs-design (90% confidence)

Reasoning: This request adds new functionality (message types and runtime handling) to allow delegates to perform contract PUTs, so it is a feature. Priority is medium because it extends delegate capabilities but is not an immediate blocker. The change touches the contract subsystem (message formats and storage/PUT logic) and has implications for network propagation, so A-contracts and A-networking are relevant; it also requires stdlib/API and tests, so A-developer-xp applies. Implementation involves multiple components and design decisions (authorization, propagation, attestation), so effort is medium and the issue should be marked S-needs-design to capture the unresolved design questions.

Previous labels: none

If these labels are incorrect, please update them. This helps improve the auto-labeling system.