Example and Tutorial for end to end signature flow - for intent based applications.

[yellowBirdy]

Feature description

A complete, canonical example of the signature flow.

The goal of this tutorial should be to provide a complete, executable example that can be followed by a third-party developer from start to finish.

Scope

• Message construction.
• Message serialization.
• Message hashing.
• Signature generation:
  • in the frontend / wallet.
  • in rust client
• Signature transport and submission.
• Signature verification
  • in rust client
  • inside the vm.
• Handling invalid signatures.
• Using successful verification to authorize an action.

Requirements

Canonical Message Format

Provide a simple but realistic message structure that can be used throughout the tutorial.

The purpose is not to define a standard intent format, but to establish a reproducible example for demonstrating signing and verification.

The exact fields are less important than ensuring the entire flow is deterministic and reproducible.

Canonical Serialization Format

Explicitly define:

• field ordering
• encoding format
• integer representation
• byte ordering
• array handling
• serialization boundaries

Message Hashing

Demonstrate:

• how the message is transformed into a signing payload
• which hash function is used
• how the digest is represented
• how the digest is passed into signing and verification logic

The exact intermediate values should be shown.

Frontend Signing Example

Provide a complete frontend example showing:

• message construction
• serialization
• hashing
• signature generation
• extraction of the public key
• resulting signature output

The example should be executable with minimal modification.

Contract Verification Example

Provide a complete MASM example showing:

• receiving a message or digest
• receiving a signature
• receiving a public key
• performing signature verification
• handling success and failure cases
• execute a simple action based on message content

The example should compile and execute without modification.

End-to-End Integration Test

Provide a runnable integration example demonstrating:

• Construct message.
• Serialize message.
• Hash message.
• Sign message.
• Submit signature and payload.
• Verify signature inside a contract.
• Execute an authorized action.

The entire flow should be executable by a third-party developer without requiring protocol-level knowledge.

Security Considerations

The tutorial should explain:

• what exactly is being signed
• replay risks
• message uniqueness requirements
• recommended signing patterns
• common implementation mistakes

The tutorial should serve as the canonical reference for signature-based authorization on Miden.

Why is this feature needed?

Currently, there is no end-to-end reference showing such a flow would be implemented in a realistic application.

[Dominik1999]

Can you add an example? Who signs what exactly? And who executes a transaction?

[yellowBirdy]

For example:

1. A user wants to swap 100 USDC for ETH.

2. The frontend constructs a message (assets, amounts, expiration, nonce, etc.).

3. The user signs this intent locally using their wallet.

4. User's PubKey is extracted from the wallet.

5. The signed message + PubKey + userAccountId is serialised (then user sends it via our API to the server).

6. We on the server deserialise the payload and recover:

   • message content
   • signature
   • PubKey
   • UserAccountId

7. We on the server verify the signature and sanity of the signed message with the user's PubKey.

8. We on the server execute a transaction containing:

   • the serialised message,
   • the user's signature,
   • the user's public key (or an identifier from which it can be obtained),
   • deserialised intent (or we recover it from the serialised message, whatever is cheaper in terms of compute).

9. The contract verifies the signature, validates the nonce/expiry.