@midnight-ntwrk/credential-compact 0.1.0-rc2

package/dist/managed/same-holder/contract/index.js.map

@@ -0,0 +1,8 @@
+{
+  "version": 3,
+  "file": "index.js",
+  "sourceRoot": "../../../../",
+  "sources": ["src/holder-binding/same-holder.compact", "src/holder-binding/.././credentials/./types.compact", "src/holder-binding/.././credentials/./proofs.compact", "src/holder-binding/.././credentials/./holder-bindings.compact", "src/holder-binding/.././credentials/./protocols.compact", "src/holder-binding/.././credentials/./status-bindings.compact", "compiler/standard-library.compact"],
+  "names": [],
+  "mappings": "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"
+}

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@midnight-ntwrk/credential-compact",
+  "version": "0.1.0-rc2",
+  "description": "Private candidate library of family-neutral Compact VC and VP semantics",
+  "license": "Apache-2.0",
+  "private": false,
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/midnightntwrk/midnight-verifiable-credentials.git",
+    "directory": "packages/core/compact"
+  },
+  "keywords": [
+    "midnight",
+    "verifiable-credentials",
+    "compact",
+    "vc",
+    "vp"
+  ],
+  "sideEffects": [],
+  "engines": {
+    "node": ">=24",
+    "pnpm": ">=10"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "import": "./dist/contract.js",
+      "default": "./dist/contract.js"
+    },
+    "./jubjub": {
+      "types": "./dist/jubjub.d.ts",
+      "import": "./dist/jubjub.js",
+      "default": "./dist/jubjub.js"
+    },
+    "./holder-binding/same-holder": {
+      "types": "./dist/holder-binding/same-holder.d.ts",
+      "import": "./dist/holder-binding/same-holder.js",
+      "default": "./dist/holder-binding/same-holder.js"
+    },
+    "./credentials.compact": "./dist/credentials.compact",
+    "./holder-binding/same-holder.compact": "./dist/holder-binding/same-holder.compact",
+    "./holder-binding/same-holder/composable.compact": "./dist/holder-binding/same-holder/composable.compact"
+  },
+  "dependencies": {
+    "@midnight-ntwrk/compact-runtime": "0.15.0"
+  },
+  "files": [
+    "dist/**",
+    "src/**/*.compact",
+    "README.md",
+    "CHANGELOG.md",
+    "package.json"
+  ],
+  "midnight": {
+    "maturity": "core",
+    "packageClass": "dist",
+    "releaseStage": "supported",
+    "compactCompilerVersion": "0.30.0",
+    "compactRuntimeVersion": "0.15.0",
+    "compactSources": [
+      "src/credentials.compact",
+      "src/credentials/bindings.compact",
+      "src/credentials/composable.compact",
+      "src/credentials/holder-bindings.compact",
+      "src/credentials/issue.compact",
+      "src/credentials/present.compact",
+      "src/credentials/proofs.compact",
+      "src/credentials/protocol-support.compact",
+      "src/credentials/protocols.compact",
+      "src/credentials/relations.compact",
+      "src/credentials/status-bindings.compact",
+      "src/credentials/types.compact",
+      "src/credentials/vc-support.compact",
+      "src/credentials/vc.compact",
+      "src/credentials/vp.compact",
+      "src/holder-binding/same-holder.compact",
+      "src/holder-binding/same-holder/composable.compact"
+    ],
+    "compactEntrypoints": {
+      "standalone": [
+        "./credentials.compact",
+        "./holder-binding/same-holder.compact"
+      ],
+      "composition": [
+        "./holder-binding/same-holder/composable.compact"
+      ]
+    }
+  },
+  "scripts": {
+    "check-toolchain": "node scripts/check-toolchain.mjs",
+    "compact": "pnpm run check-toolchain && rm -rf src/managed && compact compile src/credentials.compact src/managed/credentials && compact compile src/holder-binding/same-holder.compact src/managed/same-holder && rm -rf src/managed/credentials/compiler src/managed/same-holder/compiler",
+    "build": "pnpm run compact && rm -rf dist && mkdir -p dist && tsc -b tsconfig.build.json --force && cp -Rf src/managed dist/ && cp src/credentials.compact dist/ && cp -Rf src/credentials dist/ && mkdir -p dist/holder-binding && cp src/holder-binding/same-holder.compact dist/holder-binding/ && cp -Rf src/holder-binding/same-holder dist/holder-binding/ && node scripts/write-build-manifest.mjs",
+    "typecheck": "pnpm run compact && tsc -p tsconfig.json --noEmit",
+    "lint": "eslint src --ignore-pattern 'src/managed/**'",
+    "test": "vitest run",
+    "test:ci": "pnpm run compact && vitest run",
+    "clean": "rm -rf dist src/managed coverage reports *.tsbuildinfo"
+  }
+}

package/src/credentials/bindings.compact

@@ -0,0 +1,5 @@
+// Shared binding surface for capability packages that only need holder-binding
+// types and witness-validation helpers.
+
+include "./types";
+include "./holder-bindings";

package/src/credentials/composable.compact

@@ -0,0 +1,14 @@
+// Composition-safe shared root for Layer 3 contracts and credential-family
+// entrypoints. This file includes the leaf modules directly because Compact
+// does not deduplicate repeated includes across intermediate entry points.
+
+include "./types";
+include "./proofs";
+include "./vc";
+include "./vp";
+include "./relations";
+include "./holder-bindings";
+include "./protocols";
+include "./issue";
+include "./present";
+include "./status-bindings";

package/src/credentials/holder-bindings.compact

@@ -0,0 +1,320 @@
+// Holder-binding and holder-witness primitives.
+// This file groups the reusable binding checks for explicit DID, Jubjub,
+// offchain DID, secret-holder, and blinded-secret-holder profiles.
+// =====================
+// Explicit and Jubjub-backed holder bindings
+// =====================
+export pure circuit assertValidExplicitHolderBinding(
+  binding: ExplicitHolderBinding
+): [] {
+  assert(
+    binding.holderVerificationMethodRef.didContractAddress.bytes != pad(32, ""),
+    "Explicit holder binding DID contract address must be set"
+  );
+  assert(
+    binding.holderVerificationMethodRef.methodId != pad(32, ""),
+    "Explicit holder binding method reference must be set"
+  );
+}
+
+export pure circuit assertMatchingExplicitHolderBindings(
+  credentialBinding: ExplicitHolderBinding,
+  presentationBinding: ExplicitHolderBinding
+): [] {
+  assert(
+    presentationBinding.holderVerificationMethodRef.didContractAddress
+      == credentialBinding.holderVerificationMethodRef.didContractAddress,
+    "Presentation holder contract does not match credential holder binding"
+  );
+  assert(
+    presentationBinding.holderVerificationMethodRef.methodId
+      == credentialBinding.holderVerificationMethodRef.methodId,
+    "Presentation holder method reference does not match credential holder binding"
+  );
+}
+
+export pure circuit assertProofMatchesExplicitHolderBinding(
+  binding: ExplicitHolderBinding,
+  presentationProof: Proof
+): [] {
+  assert(
+    binding.holderVerificationMethodRef.didContractAddress
+      == presentationProof.signerVerificationMethodRef.didContractAddress,
+    "Presentation proof signer must match holder binding"
+  );
+  assert(
+    binding.holderVerificationMethodRef.methodId
+      == presentationProof.signerVerificationMethodRef.methodId,
+    "Presentation proof signer method reference must match holder binding"
+  );
+}
+
+export pure circuit assertValidJubjubHolderBinding(
+  binding: JubjubHolderBinding
+): [] {
+  // This is only a sentinel check that the binding is populated.
+  // The helper remains useful for the legacy compatibility profile and as a
+  // building block inside richer DID-shaped bindings.
+  // Callers still need assertValidPresentationContextProof(...) or an
+  // equivalent proof verification path to establish proof-of-possession.
+  assert(
+    jubjubPointX(binding.holderPublicKey) != 0 as Field ||
+      jubjubPointY(binding.holderPublicKey) != 0 as Field,
+    "Jubjub holder binding public key must be set"
+  );
+}
+
+export pure circuit assertMatchingJubjubHolderBindings(
+  credentialBinding: JubjubHolderBinding,
+  presentationBinding: JubjubHolderBinding
+): [] {
+  assert(
+    jubjubPointX(presentationBinding.holderPublicKey)
+      == jubjubPointX(credentialBinding.holderPublicKey) &&
+      jubjubPointY(presentationBinding.holderPublicKey)
+        == jubjubPointY(credentialBinding.holderPublicKey),
+    "Presentation Jubjub holder key does not match the credential holder binding"
+  );
+}
+
+export pure circuit assertProofMatchesJubjubHolderBinding(
+  binding: JubjubHolderBinding,
+  presentationProof: Proof
+): [] {
+  assert(
+    jubjubPointX(binding.holderPublicKey)
+      == jubjubPointX(presentationProof.publicKey) &&
+      jubjubPointY(binding.holderPublicKey)
+        == jubjubPointY(presentationProof.publicKey),
+    "Presentation proof public key must match the Jubjub holder binding"
+  );
+}
+
+export pure circuit assertValidOffchainMidnightHolderBinding(
+  binding: OffchainMidnightHolderBinding
+): [] {
+  // This validates presence and consistency only for the preferred lightweight
+  // DID-shaped offchain profile.
+  // It does not prove that holderPublicKey is the verification method
+  // published under holderMethodId in the referenced offchain DID state.
+  assert(
+    binding.holderDidStateHash != pad(32, ""),
+    "Offchain Midnight holder state hash must be set"
+  );
+  assert(
+    binding.holderMethodId != pad(32, ""),
+    "Offchain Midnight holder method id must be set"
+  );
+  const jubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
+    holderPublicKey: binding.holderPublicKey
+  };
+  assertValidJubjubHolderBinding(jubjubBinding);
+}
+
+export pure circuit assertMatchingOffchainMidnightHolderBindings(
+  credentialBinding: OffchainMidnightHolderBinding,
+  presentationBinding: OffchainMidnightHolderBinding
+): [] {
+  assert(
+    presentationBinding.holderDidStateHash
+      == credentialBinding.holderDidStateHash,
+    "Offchain Midnight holder state hash does not match the credential holder binding"
+  );
+  assert(
+    presentationBinding.holderMethodId
+      == credentialBinding.holderMethodId,
+    "Offchain Midnight holder method id does not match the credential holder binding"
+  );
+  const credentialJubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
+    holderPublicKey: credentialBinding.holderPublicKey
+  };
+  const presentationJubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
+    holderPublicKey: presentationBinding.holderPublicKey
+  };
+  assertMatchingJubjubHolderBindings(
+    credentialJubjubBinding,
+    presentationJubjubBinding
+  );
+}
+
+export pure circuit assertProofMatchesOffchainMidnightHolderBinding(
+  binding: OffchainMidnightHolderBinding,
+  presentationProof: Proof
+): [] {
+  const jubjubBinding: JubjubHolderBinding = JubjubHolderBinding {
+    holderPublicKey: binding.holderPublicKey
+  };
+  assertProofMatchesJubjubHolderBinding(jubjubBinding, presentationProof);
+}
+
+// =====================
+// Secret-holder bindings and derived pseudonyms
+// =====================
+export pure circuit noSecretHolderChallengeResponse(): Bytes<32> {
+  return pad(32, "midnight:vc:no-holder-response");
+}
+
+export pure circuit secretHolderBindingCommitment(
+  holderSecret: Bytes<32>,
+  opening: Bytes<32>
+): Bytes<32> {
+  return persistentCommit<Bytes<32>>(holderSecret, opening);
+}
+
+export pure circuit secretHolderBindingChallengeResponse(
+  holderSecret: Bytes<32>,
+  verifierChallengeHash: Bytes<32>
+): Bytes<32> {
+  return persistentHash<Vector<3, Bytes<32>>>([
+    pad(32, "midnight:vc:holder-chall"),
+    holderSecret,
+    verifierChallengeHash
+  ]);
+}
+
+export pure circuit verifierScopedPseudonym(
+  holderSecret: Bytes<32>,
+  verifierDomainHash: Bytes<32>
+): Bytes<32> {
+  return persistentHash<Vector<3, Bytes<32>>>([
+    pad(32, "midnight:vc:holder-pseudonym"),
+    holderSecret,
+    verifierDomainHash
+  ]);
+}
+
+export pure circuit assertVerifierScopedPseudonym(
+  pseudonym: Bytes<32>,
+  holderSecret: Bytes<32>,
+  verifierDomainHash: Bytes<32>
+): [] {
+  assert(
+    pseudonym == verifierScopedPseudonym(holderSecret, verifierDomainHash),
+    "Verifier-scoped pseudonym does not match the holder secret and verifier domain"
+  );
+}
+
+export pure circuit blindedSecretHolderCommitment(
+  holderSecretCommitment: Bytes<32>,
+  issuerNonce: Bytes<32>,
+  blindingFactor: Bytes<32>
+): Bytes<32> {
+  // NOTE: This remains a hash-based compatibility commitment today. The
+  // breaking `persistentCommit` migration is tracked separately and should not
+  // be rolled in silently with source-style or purity cleanups.
+  return persistentHash<Vector<4, Bytes<32>>>([
+    pad(32, "midnight:vc:blind-holder"),
+    holderSecretCommitment,
+    issuerNonce,
+    blindingFactor
+  ]);
+}
+
+export pure circuit assertValidSecretHolderCredentialBinding(
+  binding: SecretHolderBinding
+): [] {
+  assert(
+    binding.requestChallengeResponse == noSecretHolderChallengeResponse(),
+    "Credential secret holder binding must not embed a request challenge response"
+  );
+}
+
+export pure circuit assertValidSecretHolderPresentationBinding(
+  binding: SecretHolderBinding
+): [] {
+  assert(
+    binding.requestChallengeResponse != noSecretHolderChallengeResponse(),
+    "Presentation secret holder binding must include a request challenge response"
+  );
+}
+
+export pure circuit assertMatchingSecretHolderBindings(
+  credentialBinding: SecretHolderBinding,
+  presentationBinding: SecretHolderBinding
+): [] {
+  assert(
+    credentialBinding.holderSecretCommitment == presentationBinding.holderSecretCommitment,
+    "Presentation holder secret commitment does not match the credential holder binding"
+  );
+}
+
+export pure circuit assertValidBlindedSecretHolderCredentialBinding(
+  binding: BlindedSecretHolderBinding
+): [] {
+  assert(
+    binding.requestChallengeResponse == noSecretHolderChallengeResponse(),
+    "Credential blinded holder binding must not embed a request challenge response"
+  );
+}
+
+export pure circuit assertValidBlindedSecretHolderPresentationBinding(
+  binding: BlindedSecretHolderBinding
+): [] {
+  assert(
+    binding.requestChallengeResponse != noSecretHolderChallengeResponse(),
+    "Presentation blinded holder binding must include a request challenge response"
+  );
+}
+
+export pure circuit assertMatchingBlindedSecretHolderBindings(
+  credentialBinding: BlindedSecretHolderBinding,
+  presentationBinding: BlindedSecretHolderBinding
+): [] {
+  assert(
+    credentialBinding.blindedHolderSecretCommitment
+      == presentationBinding.blindedHolderSecretCommitment,
+    "Presentation blinded holder commitment does not match the credential holder binding"
+  );
+  assert(
+    credentialBinding.issuerNonce == presentationBinding.issuerNonce,
+    "Presentation issuer nonce does not match the credential holder binding"
+  );
+}
+
+// =====================
+// Witness validation and recomputation helpers
+// =====================
+// NOTE: these helpers validate caller-supplied witness material passed as
+// ordinary parameters. They do not perform Compact `witness` reads themselves.
+export pure circuit assertSecretHolderBindingWitness(
+  binding: SecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  opening: Bytes<32>
+): [] {
+  assert(
+    secretHolderBindingCommitment(holderSecret, opening) == binding.holderSecretCommitment,
+    "Holder secret witness does not match the holder-binding commitment"
+  );
+  assert(
+    secretHolderBindingChallengeResponse(holderSecret, verifierChallengeHash)
+      == binding.requestChallengeResponse,
+    "Holder secret challenge response does not match the verifier challenge"
+  );
+}
+
+export pure circuit assertBlindedSecretHolderBindingWitness(
+  binding: BlindedSecretHolderBinding,
+  verifierChallengeHash: Bytes<32>,
+  holderSecret: Bytes<32>,
+  opening: Bytes<32>,
+  blindingFactor: Bytes<32>
+): [] {
+  const holderCommitment: Bytes<32> = secretHolderBindingCommitment(
+    holderSecret,
+    opening
+  );
+  assert(
+    blindedSecretHolderCommitment(
+      holderCommitment,
+      binding.issuerNonce,
+      blindingFactor
+    ) == binding.blindedHolderSecretCommitment,
+    "Blinded holder commitment does not match the hidden holder secret witness"
+  );
+  assert(
+    secretHolderBindingChallengeResponse(holderSecret, verifierChallengeHash)
+      == binding.requestChallengeResponse,
+    "Blinded holder challenge response does not match the verifier challenge"
+  );
+}

package/src/credentials/issue.compact

@@ -0,0 +1,91 @@
+// Generic issuance message choreography.
+// Owns offer/request/result envelope alignment only; issuer- and holder-side
+// claim semantics stay in the family layer.
+module Issue<TOfferBody, TRequestBody, TResultBody> {
+  export struct OfferMessage {
+    envelope: ProtocolMessageEnvelope,
+    schema: SchemaRef,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBindingProfile: HolderBindingProfile,
+    features: CredentialProtocolFeatures,
+    body: TOfferBody,
+  }
+
+  export struct RequestMessage {
+    envelope: ProtocolMessageEnvelope,
+    schema: SchemaRef,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBindingProfile: HolderBindingProfile,
+    body: TRequestBody,
+  }
+
+  export struct ResultMessage {
+    envelope: ProtocolMessageEnvelope,
+    schema: SchemaRef,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBindingProfile: HolderBindingProfile,
+    body: TResultBody,
+  }
+
+  export pure circuit assertValidOfferMessage(
+    offer: OfferMessage
+  ): [] {
+    assertValidProtocolMessageEnvelope(offer.envelope);
+    assert(offer.envelope.initialMessage, "Issuance offer must be the initial message");
+    assertValidVerificationMethodRef(offer.issuerVerificationMethodRef);
+  }
+
+  export pure circuit assertValidRequestMessage(
+    request: RequestMessage
+  ): [] {
+    assertValidProtocolMessageEnvelope(request.envelope);
+    assert(!request.envelope.initialMessage, "Issuance request must be a response message");
+    assertValidVerificationMethodRef(request.issuerVerificationMethodRef);
+  }
+
+  export pure circuit assertOfferRequestAlignment(
+    offer: OfferMessage,
+    request: RequestMessage
+  ): [] {
+    assertValidOfferMessage(offer);
+    assertValidRequestMessage(request);
+    assertProtocolResponseEnvelope(offer.envelope, request.envelope);
+    assertMatchingSchemaRefs(offer.schema, request.schema);
+    assert(
+      offer.issuerVerificationMethodRef.didContractAddress == request.issuerVerificationMethodRef.didContractAddress
+        && offer.issuerVerificationMethodRef.methodId == request.issuerVerificationMethodRef.methodId,
+      "Issuance request issuer verification method does not match the offer"
+    );
+    assert(
+      offer.holderBindingProfile == request.holderBindingProfile,
+      "Issuance request holder binding profile does not match the offer"
+    );
+  }
+
+  export pure circuit assertValidResultMessage(
+    result: ResultMessage
+  ): [] {
+    assertValidProtocolMessageEnvelope(result.envelope);
+    assert(!result.envelope.initialMessage, "Issuance result must be a response message");
+    assertValidVerificationMethodRef(result.issuerVerificationMethodRef);
+  }
+
+  export pure circuit assertRequestResultAlignment(
+    request: RequestMessage,
+    result: ResultMessage
+  ): [] {
+    assertValidRequestMessage(request);
+    assertValidResultMessage(result);
+    assertProtocolResponseEnvelope(request.envelope, result.envelope);
+    assertMatchingSchemaRefs(request.schema, result.schema);
+    assert(
+      request.issuerVerificationMethodRef.didContractAddress == result.issuerVerificationMethodRef.didContractAddress
+        && request.issuerVerificationMethodRef.methodId == result.issuerVerificationMethodRef.methodId,
+      "Issuance result issuer verification method does not match the request"
+    );
+    assert(
+      request.holderBindingProfile == result.holderBindingProfile,
+      "Issuance result holder binding profile does not match the request"
+    );
+  }
+}

package/src/credentials/present.compact

@@ -0,0 +1,84 @@
+// Generic presentation message choreography.
+// Owns request/submission/result envelope alignment; the family layer decides
+// what a verifier asked for and what a holder actually proved or disclosed.
+module Present<TRequestBody, TSubmissionBody, TResultBody> {
+  export struct RequestMessage {
+    envelope: ProtocolMessageEnvelope,
+    schema: SchemaRef,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBindingProfile: HolderBindingProfile,
+    features: CredentialProtocolFeatures,
+    verifierChallengeHash: Bytes<32>,
+    body: TRequestBody,
+  }
+
+  export struct SubmissionMessage {
+    envelope: ProtocolMessageEnvelope,
+    schema: SchemaRef,
+    issuerVerificationMethodRef: VerificationMethodRef,
+    holderBindingProfile: HolderBindingProfile,
+    challengeHash: Bytes<32>,
+    body: TSubmissionBody,
+  }
+
+  export struct ResultMessage {
+    envelope: ProtocolMessageEnvelope,
+    approved: Boolean,
+    body: TResultBody,
+  }
+
+  export pure circuit assertValidRequestMessage(
+    request: RequestMessage
+  ): [] {
+    assertValidProtocolMessageEnvelope(request.envelope);
+    assert(request.envelope.initialMessage, "Presentation request must be the initial message");
+    assertValidVerificationMethodRef(request.issuerVerificationMethodRef);
+  }
+
+  export pure circuit assertValidSubmissionMessage(
+    submission: SubmissionMessage
+  ): [] {
+    assertValidProtocolMessageEnvelope(submission.envelope);
+    assert(!submission.envelope.initialMessage, "Presentation submission must be a response message");
+    assertValidVerificationMethodRef(submission.issuerVerificationMethodRef);
+  }
+
+  export pure circuit assertRequestSubmissionAlignment(
+    request: RequestMessage,
+    submission: SubmissionMessage
+  ): [] {
+    assertValidRequestMessage(request);
+    assertValidSubmissionMessage(submission);
+    assertProtocolResponseEnvelope(request.envelope, submission.envelope);
+    assertMatchingSchemaRefs(request.schema, submission.schema);
+    assert(
+      request.issuerVerificationMethodRef.didContractAddress == submission.issuerVerificationMethodRef.didContractAddress
+        && request.issuerVerificationMethodRef.methodId == submission.issuerVerificationMethodRef.methodId,
+      "Presentation submission issuer verification method does not match the request"
+    );
+    assert(
+      request.holderBindingProfile == submission.holderBindingProfile,
+      "Presentation submission holder binding profile does not match the request"
+    );
+    assert(
+      request.verifierChallengeHash == submission.challengeHash,
+      "Presentation submission challenge does not match the request challenge"
+    );
+  }
+
+  export pure circuit assertValidResultMessage(
+    result: ResultMessage
+  ): [] {
+    assertValidProtocolMessageEnvelope(result.envelope);
+    assert(!result.envelope.initialMessage, "Presentation result must be a response message");
+  }
+
+  export pure circuit assertSubmissionResultAlignment(
+    submission: SubmissionMessage,
+    result: ResultMessage
+  ): [] {
+    assertValidSubmissionMessage(submission);
+    assertValidResultMessage(result);
+    assertProtocolResponseEnvelope(submission.envelope, result.envelope);
+  }
+}