Extractable description of assertions

[Quantumplation]

Given that expect is such a prominent part of the language, it would be pretty cool to extract, as part of the blueprint, a description of the constraints enforced by the smart contract, perhaps using some labels / doc comments; This may be pipedream stuff, but I figured I'd document some of my thinking just in case.

i.e. something like:

validator {
  fn spend(d: Data, r: Redeemer, ctx: ScriptContext) {
    /// The owner must sign the transaction
    expect list.has(ctx.transaction.extra_signatories, d.owner)
    /// The transaction must have at least 3 inputs
    expect list.length(ctx.transaction.inputs) >= 3

    /// The first output must be the pool output, with an inline datum
    expect Some(output) = list.head(ctx.transaction.outputs)
    expect InlineDatum(datum) = output.datum
    expect MyDatum { a, b, c } = datum
  }
}

which produces a checklist in the blueprint:

  "conditions": [
    "The owner must sign the transaction",
    "The transaction must have at least 3 inputs",
    ..
  ]

This idea stems from the way I usually write my smart contracts, which look something like this:

validator {
  fn spend(...) {
    let condition_1 = ...;
    let condition_2 = ...;
    
    condition_1 &&
    condition_2 &&
    ...
  }

where condition_1 and condition_2 are english statmenets like token_present_in_output or datum_updated_legally

The formatting around long && chains, and the performance implications, means that I'm rewriting my contract as:

validator {
  fn spend(...) {
    expect ...;
    expect ...;
  }

and each condition that I'm expecting on isn't always as readable as condition_1 and condition_2; I found myself missing the labels, and wondering since this is the central pillar of what your contract is checking, it might make sense to expose this in the blueprint as a form of documentation for auditors, etc.

---

As a non-aiken related aside (that might provide some inspiration we can bring back), it kind of makes me want to write a smart contract language that is really focused on a sort of natural language description, upfront, of what the contract enforces, with the code that computes each condition secondary, plus some built-in constructs for common patterns (like continuing outputs, etc.)

Some hypothetical syntax for this language

protocol DEX {
  validator order {
    Cancel =>
      signed by datum.owner
    Scoop =>
      defers to validator pool
  }
  validator pool {
    Scoop =>
      immutable properties unchanged =>
          {datum.identifier} unchanged
          {datum.fee} unchanged
  }

signed by {owner} =>
    list.has(context.transaction.signatories, datum.owner)

defers to {validator} =>
    ...

{property} unchanged =>
    continuing_output.{property} == {property}

[rvcas]

interesting, very cool