Presentation Submission

A Presentation Submission is the act of a credential holder sending a Verifiable Presentation (VP) to a verifier in response to a Presentation Request. This structured data packet contains one or more Verifiable Credentials, along with cryptographic proofs and optional holder-generated data, packaged according to a specific format like the W3C Verifiable Credentials Data Model. The submission is the critical handover that allows the verifier to cryptographically verify the authenticity, integrity, and validity of the presented claims.

The process is governed by a Presentation Definition, a machine-readable schema issued by the verifier that specifies the exact credentials and constraints required. A compliant submission, or Presentation Submission Descriptor, must satisfy these constraints—such as credential type, issuer, or specific claim values. In decentralized identity systems, this exchange often occurs over secure, peer-to-peer protocols like DIDComm, ensuring the holder maintains control over their data and what is disclosed.

Upon receipt, the verifier performs Presentation Verification. This involves checking the digital signatures on the VP and its embedded VCs, confirming they were issued by trusted entities and haven't been tampered with. It also validates that all requirements from the Presentation Definition are met. Successful verification results in access being granted, a transaction being approved, or a claim being accepted, completing the trust triangle between issuer, holder, and verifier.

The process begins when an off-chain reporting (OCR) network, composed of independent node operators, reaches consensus on the state of a reserve. This data, which includes metrics like total token supply and verified collateral balances, is aggregated and signed by a quorum of nodes to produce a cryptographic attestation. This signed data package is the presentation, which is then submitted as a transaction to a verifier contract on the destination blockchain, such as Ethereum or another EVM-compatible chain.

Upon receiving the transaction, the on-chain verifier contract performs a signature verification against the known public keys of the authorized node operators. If the signatures are valid and meet the predefined quorum threshold, the contract accepts the data and updates its internal state. This state update typically involves writing the new attestation values—like the latest totalSupply and timestamp—to the contract's public storage, making them immutable and publicly verifiable for any other on-chain application.

This mechanism provides a secure bridge from off-chain data to on-chain logic. The decentralized oracle network ensures data integrity during collection, while the on-chain verification guarantees that only properly authorized data is accepted. This two-layer security model is critical for applications like cross-chain bridges and algorithmic stablecoins that rely on real-time, tamper-proof reserve proofs to maintain system solvency and user trust.

A practical example is the wBTC Proof of Reserve system. Regularly, a network of Chainlink nodes audits the custodian's Bitcoin holdings, creates a signed attestation of the BTC balance, and submits it to the wBTC verifier contract on Ethereum. DeFi protocols like Aave or Compound can then programmatically read this verified reserve data from the contract to ensure the wBTC in their markets is fully backed before allowing it as collateral.

A Presentation Submission Flow is a process model that maps the journey of a data presentation from initial creation through to final verification and inclusion on-chain. It serves as a critical reference for developers and analysts to understand the sequence of operations, key decision points, and the responsibilities of different network participants, such as the presenter, verifiers, and the underlying smart contract system. Visualizing this flow clarifies the handoffs between off-chain computation and on-chain state updates.

The flow typically begins with a presenter generating a cryptographic proof or attestation for a specific data claim off-chain. This involves querying source data, executing the required computations defined by the protocol's rules, and producing a verifiable output. The presenter then constructs a transaction containing this proof and submits it to the network. This transaction targets a specific presentation smart contract, which defines the valid format and logic for acceptance.

Upon receiving the submission, the network enters a verification phase. Verifiers or the smart contract logic itself validate the proof's correctness and the presenter's authorization. This may involve checking digital signatures, verifying the proof against a trusted verification key, and ensuring all required data fields are present and formatted correctly. The flow diagram highlights conditional paths for successful validation versus rejection due to errors or invalid data.

Following successful verification, the flow proceeds to finalization. The smart contract executes its state transition logic, which often includes recording the presentation in an on-chain registry, emitting an event log, and potentially triggering downstream actions or payments. This update creates a permanent, tamper-proof record of the submission. The visualization concludes with the updated state being reflected on the blockchain, accessible for querying by other applications or users.

Understanding this submission flow is essential for debugging integration issues, designing compliant data providers, and auditing protocol activity. It demystifies abstract concepts like proof verification and state commitment by anchoring them in a concrete sequence of technical steps. For complex protocols, these diagrams are often decomposed into sub-flows for specific presentation types or verification mechanisms.